1 /*
   2  * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 // no precompiled headers
  26 #include "classfile/classLoader.hpp"
  27 #include "classfile/systemDictionary.hpp"
  28 #include "classfile/vmSymbols.hpp"
  29 #include "code/icBuffer.hpp"
  30 #include "code/vtableStubs.hpp"
  31 #include "compiler/compileBroker.hpp"
  32 #include "interpreter/interpreter.hpp"
  33 #include "jvm_solaris.h"
  34 #include "memory/allocation.inline.hpp"
  35 #include "memory/filemap.hpp"
  36 #include "mutex_solaris.inline.hpp"
  37 #include "oops/oop.inline.hpp"
  38 #include "os_share_solaris.hpp"
  39 #include "prims/jniFastGetField.hpp"
  40 #include "prims/jvm.h"
  41 #include "prims/jvm_misc.hpp"
  42 #include "runtime/arguments.hpp"
  43 #include "runtime/extendedPC.hpp"
  44 #include "runtime/globals.hpp"
  45 #include "runtime/interfaceSupport.hpp"
  46 #include "runtime/java.hpp"
  47 #include "runtime/javaCalls.hpp"
  48 #include "runtime/mutexLocker.hpp"
  49 #include "runtime/objectMonitor.hpp"
  50 #include "runtime/osThread.hpp"
  51 #include "runtime/perfMemory.hpp"
  52 #include "runtime/sharedRuntime.hpp"
  53 #include "runtime/statSampler.hpp"
  54 #include "runtime/stubRoutines.hpp"
  55 #include "runtime/threadCritical.hpp"
  56 #include "runtime/timer.hpp"
  57 #include "services/attachListener.hpp"
  58 #include "services/runtimeService.hpp"
  59 #include "thread_solaris.inline.hpp"
  60 #include "utilities/decoder.hpp"
  61 #include "utilities/defaultStream.hpp"
  62 #include "utilities/events.hpp"
  63 #include "utilities/growableArray.hpp"
  64 #include "utilities/vmError.hpp"
  65 #ifdef TARGET_ARCH_x86
  66 # include "assembler_x86.inline.hpp"
  67 # include "nativeInst_x86.hpp"
  68 #endif
  69 #ifdef TARGET_ARCH_sparc
  70 # include "assembler_sparc.inline.hpp"
  71 # include "nativeInst_sparc.hpp"
  72 #endif
  73 #ifdef COMPILER1
  74 #include "c1/c1_Runtime1.hpp"
  75 #endif
  76 #ifdef COMPILER2
  77 #include "opto/runtime.hpp"
  78 #endif
  79 
  80 // put OS-includes here
  81 # include <dlfcn.h>
  82 # include <errno.h>
  83 # include <exception>
  84 # include <link.h>
  85 # include <poll.h>
  86 # include <pthread.h>
  87 # include <pwd.h>
  88 # include <schedctl.h>
  89 # include <setjmp.h>
  90 # include <signal.h>
  91 # include <stdio.h>
  92 # include <alloca.h>
  93 # include <sys/filio.h>
  94 # include <sys/ipc.h>
  95 # include <sys/lwp.h>
  96 # include <sys/machelf.h>     // for elf Sym structure used by dladdr1
  97 # include <sys/mman.h>
  98 # include <sys/processor.h>
  99 # include <sys/procset.h>
 100 # include <sys/pset.h>
 101 # include <sys/resource.h>
 102 # include <sys/shm.h>
 103 # include <sys/socket.h>
 104 # include <sys/stat.h>
 105 # include <sys/systeminfo.h>
 106 # include <sys/time.h>
 107 # include <sys/times.h>
 108 # include <sys/types.h>
 109 # include <sys/wait.h>
 110 # include <sys/utsname.h>
 111 # include <thread.h>
 112 # include <unistd.h>
 113 # include <sys/priocntl.h>
 114 # include <sys/rtpriocntl.h>
 115 # include <sys/tspriocntl.h>
 116 # include <sys/iapriocntl.h>
 117 # include <sys/loadavg.h>
 118 # include <string.h>
 119 # include <stdio.h>
 120 
 121 # define _STRUCTURED_PROC 1  //  this gets us the new structured proc interfaces of 5.6 & later
 122 # include <sys/procfs.h>     //  see comment in <sys/procfs.h>
 123 
 124 #define MAX_PATH (2 * K)
 125 
 126 // for timer info max values which include all bits
 127 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)
 128 
 129 #ifdef _GNU_SOURCE
 130 // See bug #6514594
 131 extern "C" int madvise(caddr_t, size_t, int);
 132 extern "C"  int memcntl(caddr_t addr, size_t len, int cmd, caddr_t  arg,
 133      int attr, int mask);
 134 #endif //_GNU_SOURCE
 135 
 136 /*
 137   MPSS Changes Start.
 138   The JVM binary needs to be built and run on pre-Solaris 9
 139   systems, but the constants needed by MPSS are only in Solaris 9
 140   header files.  They are textually replicated here to allow
 141   building on earlier systems.  Once building on Solaris 8 is
 142   no longer a requirement, these #defines can be replaced by ordinary
 143   system .h inclusion.
 144 
 145   In earlier versions of the  JDK and Solaris, we used ISM for large pages.
 146   But ISM requires shared memory to achieve this and thus has many caveats.
 147   MPSS is a fully transparent and is a cleaner way to get large pages.
 148   Although we still require keeping ISM for backward compatiblitiy as well as
 149   giving the opportunity to use large pages on older systems it is
 150   recommended that MPSS be used for Solaris 9 and above.
 151 
 152 */
 153 
 154 #ifndef MC_HAT_ADVISE
 155 
 156 struct memcntl_mha {
 157   uint_t          mha_cmd;        /* command(s) */
 158   uint_t          mha_flags;
 159   size_t          mha_pagesize;
 160 };
 161 #define MC_HAT_ADVISE   7       /* advise hat map size */
 162 #define MHA_MAPSIZE_VA  0x1     /* set preferred page size */
 163 #define MAP_ALIGN       0x200   /* addr specifies alignment */
 164 
 165 #endif
 166 // MPSS Changes End.
 167 
 168 
 169 // Here are some liblgrp types from sys/lgrp_user.h to be able to
 170 // compile on older systems without this header file.
 171 
 172 #ifndef MADV_ACCESS_LWP
 173 # define  MADV_ACCESS_LWP         7       /* next LWP to access heavily */
 174 #endif
 175 #ifndef MADV_ACCESS_MANY
 176 # define  MADV_ACCESS_MANY        8       /* many processes to access heavily */
 177 #endif
 178 
 179 #ifndef LGRP_RSRC_CPU
 180 # define LGRP_RSRC_CPU           0       /* CPU resources */
 181 #endif
 182 #ifndef LGRP_RSRC_MEM
 183 # define LGRP_RSRC_MEM           1       /* memory resources */
 184 #endif
 185 
 186 // Some more macros from sys/mman.h that are not present in Solaris 8.
 187 
 188 #ifndef MAX_MEMINFO_CNT
 189 /*
 190  * info_req request type definitions for meminfo
 191  * request types starting with MEMINFO_V are used for Virtual addresses
 192  * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical
 193  * addresses
 194  */
 195 # define MEMINFO_SHIFT           16
 196 # define MEMINFO_MASK            (0xFF << MEMINFO_SHIFT)
 197 # define MEMINFO_VPHYSICAL       (0x01 << MEMINFO_SHIFT) /* get physical addr */
 198 # define MEMINFO_VLGRP           (0x02 << MEMINFO_SHIFT) /* get lgroup */
 199 # define MEMINFO_VPAGESIZE       (0x03 << MEMINFO_SHIFT) /* size of phys page */
 200 # define MEMINFO_VREPLCNT        (0x04 << MEMINFO_SHIFT) /* no. of replica */
 201 # define MEMINFO_VREPL           (0x05 << MEMINFO_SHIFT) /* physical replica */
 202 # define MEMINFO_VREPL_LGRP      (0x06 << MEMINFO_SHIFT) /* lgrp of replica */
 203 # define MEMINFO_PLGRP           (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */
 204 
 205 /* maximum number of addresses meminfo() can process at a time */
 206 # define MAX_MEMINFO_CNT 256
 207 
 208 /* maximum number of request types */
 209 # define MAX_MEMINFO_REQ 31
 210 #endif
 211 
 212 // see thr_setprio(3T) for the basis of these numbers
 213 #define MinimumPriority 0
 214 #define NormalPriority  64
 215 #define MaximumPriority 127
 216 
 217 // Values for ThreadPriorityPolicy == 1
 218 int prio_policy1[MaxPriority+1] = { -99999, 0, 16, 32, 48, 64,
 219                                         80, 96, 112, 124, 127 };
 220 
 221 // System parameters used internally
 222 static clock_t clock_tics_per_sec = 100;
 223 
 224 // Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+)
 225 static bool enabled_extended_FILE_stdio = false;
 226 
 227 // For diagnostics to print a message once. see run_periodic_checks
 228 static bool check_addr0_done = false;
 229 static sigset_t check_signal_done;
 230 static bool check_signals = true;
 231 
 232 address os::Solaris::handler_start;  // start pc of thr_sighndlrinfo
 233 address os::Solaris::handler_end;    // end pc of thr_sighndlrinfo
 234 
 235 address os::Solaris::_main_stack_base = NULL;  // 4352906 workaround
 236 
 237 
 238 // "default" initializers for missing libc APIs
 239 extern "C" {
 240   static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
 241   static int lwp_mutex_destroy(mutex_t *mx)                 { return 0; }
 242 
 243   static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
 244   static int lwp_cond_destroy(cond_t *cv)                   { return 0; }
 245 }
 246 
 247 // "default" initializers for pthread-based synchronization
 248 extern "C" {
 249   static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }
 250   static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }
 251 }
 252 
 253 // Thread Local Storage
 254 // This is common to all Solaris platforms so it is defined here,
 255 // in this common file.
 256 // The declarations are in the os_cpu threadLS*.hpp files.
 257 //
 258 // Static member initialization for TLS
 259 Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};
 260 
 261 #ifndef PRODUCT
 262 #define _PCT(n,d)       ((100.0*(double)(n))/(double)(d))
 263 
 264 int ThreadLocalStorage::_tcacheHit = 0;
 265 int ThreadLocalStorage::_tcacheMiss = 0;
 266 
 267 void ThreadLocalStorage::print_statistics() {
 268   int total = _tcacheMiss+_tcacheHit;
 269   tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",
 270                 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));
 271 }
 272 #undef _PCT
 273 #endif // PRODUCT
 274 
 275 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,
 276                                                         int index) {
 277   Thread *thread = get_thread_slow();
 278   if (thread != NULL) {
 279     address sp = os::current_stack_pointer();
 280     guarantee(thread->_stack_base == NULL ||
 281               (sp <= thread->_stack_base &&
 282                  sp >= thread->_stack_base - thread->_stack_size) ||
 283                is_error_reported(),
 284               "sp must be inside of selected thread stack");
 285 
 286     thread->set_self_raw_id(raw_id);  // mark for quick retrieval
 287     _get_thread_cache[ index ] = thread;
 288   }
 289   return thread;
 290 }
 291 
 292 
 293 static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0};
 294 #define NO_CACHED_THREAD ((Thread*)all_zero)
 295 
 296 void ThreadLocalStorage::pd_set_thread(Thread* thread) {
 297 
 298   // Store the new value before updating the cache to prevent a race
 299   // between get_thread_via_cache_slowly() and this store operation.
 300   os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);
 301 
 302   // Update thread cache with new thread if setting on thread create,
 303   // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit.
 304   uintptr_t raw = pd_raw_thread_id();
 305   int ix = pd_cache_index(raw);
 306   _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread;
 307 }
 308 
 309 void ThreadLocalStorage::pd_init() {
 310   for (int i = 0; i < _pd_cache_size; i++) {
 311     _get_thread_cache[i] = NO_CACHED_THREAD;
 312   }
 313 }
 314 
 315 // Invalidate all the caches (happens to be the same as pd_init).
 316 void ThreadLocalStorage::pd_invalidate_all() { pd_init(); }
 317 
 318 #undef NO_CACHED_THREAD
 319 
 320 // END Thread Local Storage
 321 
 322 static inline size_t adjust_stack_size(address base, size_t size) {
 323   if ((ssize_t)size < 0) {
 324     // 4759953: Compensate for ridiculous stack size.
 325     size = max_intx;
 326   }
 327   if (size > (size_t)base) {
 328     // 4812466: Make sure size doesn't allow the stack to wrap the address space.
 329     size = (size_t)base;
 330   }
 331   return size;
 332 }
 333 
 334 static inline stack_t get_stack_info() {
 335   stack_t st;
 336   int retval = thr_stksegment(&st);
 337   st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);
 338   assert(retval == 0, "incorrect return value from thr_stksegment");
 339   assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
 340   assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
 341   return st;
 342 }
 343 
 344 address os::current_stack_base() {
 345   int r = thr_main() ;
 346   guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
 347   bool is_primordial_thread = r;
 348 
 349   // Workaround 4352906, avoid calls to thr_stksegment by
 350   // thr_main after the first one (it looks like we trash
 351   // some data, causing the value for ss_sp to be incorrect).
 352   if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) {
 353     stack_t st = get_stack_info();
 354     if (is_primordial_thread) {
 355       // cache initial value of stack base
 356       os::Solaris::_main_stack_base = (address)st.ss_sp;
 357     }
 358     return (address)st.ss_sp;
 359   } else {
 360     guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");
 361     return os::Solaris::_main_stack_base;
 362   }
 363 }
 364 
 365 size_t os::current_stack_size() {
 366   size_t size;
 367 
 368   int r = thr_main() ;
 369   guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
 370   if(!r) {
 371     size = get_stack_info().ss_size;
 372   } else {
 373     struct rlimit limits;
 374     getrlimit(RLIMIT_STACK, &limits);
 375     size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);
 376   }
 377   // base may not be page aligned
 378   address base = current_stack_base();
 379   address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());;
 380   return (size_t)(base - bottom);
 381 }
 382 
 383 struct tm* os::localtime_pd(const time_t* clock, struct tm*  res) {
 384   return localtime_r(clock, res);
 385 }
 386 
 387 // interruptible infrastructure
 388 
 389 // setup_interruptible saves the thread state before going into an
 390 // interruptible system call.
 391 // The saved state is used to restore the thread to
 392 // its former state whether or not an interrupt is received.
 393 // Used by classloader os::read
 394 // os::restartable_read calls skip this layer and stay in _thread_in_native
 395 
 396 void os::Solaris::setup_interruptible(JavaThread* thread) {
 397 
 398   JavaThreadState thread_state = thread->thread_state();
 399 
 400   assert(thread_state != _thread_blocked, "Coming from the wrong thread");
 401   assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible");
 402   OSThread* osthread = thread->osthread();
 403   osthread->set_saved_interrupt_thread_state(thread_state);
 404   thread->frame_anchor()->make_walkable(thread);
 405   ThreadStateTransition::transition(thread, thread_state, _thread_blocked);
 406 }
 407 
 408 // Version of setup_interruptible() for threads that are already in
 409 // _thread_blocked. Used by os_sleep().
 410 void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) {
 411   thread->frame_anchor()->make_walkable(thread);
 412 }
 413 
 414 JavaThread* os::Solaris::setup_interruptible() {
 415   JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();
 416   setup_interruptible(thread);
 417   return thread;
 418 }
 419 
 420 void os::Solaris::try_enable_extended_io() {
 421   typedef int (*enable_extended_FILE_stdio_t)(int, int);
 422 
 423   if (!UseExtendedFileIO) {
 424     return;
 425   }
 426 
 427   enable_extended_FILE_stdio_t enabler =
 428     (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,
 429                                          "enable_extended_FILE_stdio");
 430   if (enabler) {
 431     enabler(-1, -1);
 432   }
 433 }
 434 
 435 
 436 #ifdef ASSERT
 437 
 438 JavaThread* os::Solaris::setup_interruptible_native() {
 439   JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();
 440   JavaThreadState thread_state = thread->thread_state();
 441   assert(thread_state == _thread_in_native, "Assumed thread_in_native");
 442   return thread;
 443 }
 444 
 445 void os::Solaris::cleanup_interruptible_native(JavaThread* thread) {
 446   JavaThreadState thread_state = thread->thread_state();
 447   assert(thread_state == _thread_in_native, "Assumed thread_in_native");
 448 }
 449 #endif
 450 
 451 // cleanup_interruptible reverses the effects of setup_interruptible
 452 // setup_interruptible_already_blocked() does not need any cleanup.
 453 
 454 void os::Solaris::cleanup_interruptible(JavaThread* thread) {
 455   OSThread* osthread = thread->osthread();
 456 
 457   ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state());
 458 }
 459 
 460 // I/O interruption related counters called in _INTERRUPTIBLE
 461 
 462 void os::Solaris::bump_interrupted_before_count() {
 463   RuntimeService::record_interrupted_before_count();
 464 }
 465 
 466 void os::Solaris::bump_interrupted_during_count() {
 467   RuntimeService::record_interrupted_during_count();
 468 }
 469 
 470 static int _processors_online = 0;
 471 
 472          jint os::Solaris::_os_thread_limit = 0;
 473 volatile jint os::Solaris::_os_thread_count = 0;
 474 
 475 julong os::available_memory() {
 476   return Solaris::available_memory();
 477 }
 478 
 479 julong os::Solaris::available_memory() {
 480   return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();
 481 }
 482 
 483 julong os::Solaris::_physical_memory = 0;
 484 
 485 julong os::physical_memory() {
 486    return Solaris::physical_memory();
 487 }
 488 
 489 julong os::allocatable_physical_memory(julong size) {
 490 #ifdef _LP64
 491    return size;
 492 #else
 493    julong result = MIN2(size, (julong)3835*M);
 494    if (!is_allocatable(result)) {
 495      // Memory allocations will be aligned but the alignment
 496      // is not known at this point.  Alignments will
 497      // be at most to LargePageSizeInBytes.  Protect
 498      // allocations from alignments up to illegal
 499      // values. If at this point 2G is illegal.
 500      julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes;
 501      result =  MIN2(size, reasonable_size);
 502    }
 503    return result;
 504 #endif
 505 }
 506 
 507 static hrtime_t first_hrtime = 0;
 508 static const hrtime_t hrtime_hz = 1000*1000*1000;
 509 const int LOCK_BUSY = 1;
 510 const int LOCK_FREE = 0;
 511 const int LOCK_INVALID = -1;
 512 static volatile hrtime_t max_hrtime = 0;
 513 static volatile int max_hrtime_lock = LOCK_FREE;     // Update counter with LSB as lock-in-progress
 514 
 515 
 516 void os::Solaris::initialize_system_info() {
 517   set_processor_count(sysconf(_SC_NPROCESSORS_CONF));
 518   _processors_online = sysconf (_SC_NPROCESSORS_ONLN);
 519   _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);
 520 }
 521 
 522 int os::active_processor_count() {
 523   int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
 524   pid_t pid = getpid();
 525   psetid_t pset = PS_NONE;
 526   // Are we running in a processor set or is there any processor set around?
 527   if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {
 528     uint_t pset_cpus;
 529     // Query the number of cpus available to us.
 530     if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {
 531       assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");
 532       _processors_online = pset_cpus;
 533       return pset_cpus;
 534     }
 535   }
 536   // Otherwise return number of online cpus
 537   return online_cpus;
 538 }
 539 
 540 static bool find_processors_in_pset(psetid_t        pset,
 541                                     processorid_t** id_array,
 542                                     uint_t*         id_length) {
 543   bool result = false;
 544   // Find the number of processors in the processor set.
 545   if (pset_info(pset, NULL, id_length, NULL) == 0) {
 546     // Make up an array to hold their ids.
 547     *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
 548     // Fill in the array with their processor ids.
 549     if (pset_info(pset, NULL, id_length, *id_array) == 0) {
 550       result = true;
 551     }
 552   }
 553   return result;
 554 }
 555 
 556 // Callers of find_processors_online() must tolerate imprecise results --
 557 // the system configuration can change asynchronously because of DR
 558 // or explicit psradm operations.
 559 //
 560 // We also need to take care that the loop (below) terminates as the
 561 // number of processors online can change between the _SC_NPROCESSORS_ONLN
 562 // request and the loop that builds the list of processor ids.   Unfortunately
 563 // there's no reliable way to determine the maximum valid processor id,
 564 // so we use a manifest constant, MAX_PROCESSOR_ID, instead.  See p_online
 565 // man pages, which claim the processor id set is "sparse, but
 566 // not too sparse".  MAX_PROCESSOR_ID is used to ensure that we eventually
 567 // exit the loop.
 568 //
 569 // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's
 570 // not available on S8.0.
 571 
 572 static bool find_processors_online(processorid_t** id_array,
 573                                    uint*           id_length) {
 574   const processorid_t MAX_PROCESSOR_ID = 100000 ;
 575   // Find the number of processors online.
 576   *id_length = sysconf(_SC_NPROCESSORS_ONLN);
 577   // Make up an array to hold their ids.
 578   *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
 579   // Processors need not be numbered consecutively.
 580   long found = 0;
 581   processorid_t next = 0;
 582   while (found < *id_length && next < MAX_PROCESSOR_ID) {
 583     processor_info_t info;
 584     if (processor_info(next, &info) == 0) {
 585       // NB, PI_NOINTR processors are effectively online ...
 586       if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {
 587         (*id_array)[found] = next;
 588         found += 1;
 589       }
 590     }
 591     next += 1;
 592   }
 593   if (found < *id_length) {
 594       // The loop above didn't identify the expected number of processors.
 595       // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)
 596       // and re-running the loop, above, but there's no guarantee of progress
 597       // if the system configuration is in flux.  Instead, we just return what
 598       // we've got.  Note that in the worst case find_processors_online() could
 599       // return an empty set.  (As a fall-back in the case of the empty set we
 600       // could just return the ID of the current processor).
 601       *id_length = found ;
 602   }
 603 
 604   return true;
 605 }
 606 
 607 static bool assign_distribution(processorid_t* id_array,
 608                                 uint           id_length,
 609                                 uint*          distribution,
 610                                 uint           distribution_length) {
 611   // We assume we can assign processorid_t's to uint's.
 612   assert(sizeof(processorid_t) == sizeof(uint),
 613          "can't convert processorid_t to uint");
 614   // Quick check to see if we won't succeed.
 615   if (id_length < distribution_length) {
 616     return false;
 617   }
 618   // Assign processor ids to the distribution.
 619   // Try to shuffle processors to distribute work across boards,
 620   // assuming 4 processors per board.
 621   const uint processors_per_board = ProcessDistributionStride;
 622   // Find the maximum processor id.
 623   processorid_t max_id = 0;
 624   for (uint m = 0; m < id_length; m += 1) {
 625     max_id = MAX2(max_id, id_array[m]);
 626   }
 627   // The next id, to limit loops.
 628   const processorid_t limit_id = max_id + 1;
 629   // Make up markers for available processors.
 630   bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id);
 631   for (uint c = 0; c < limit_id; c += 1) {
 632     available_id[c] = false;
 633   }
 634   for (uint a = 0; a < id_length; a += 1) {
 635     available_id[id_array[a]] = true;
 636   }
 637   // Step by "boards", then by "slot", copying to "assigned".
 638   // NEEDS_CLEANUP: The assignment of processors should be stateful,
 639   //                remembering which processors have been assigned by
 640   //                previous calls, etc., so as to distribute several
 641   //                independent calls of this method.  What we'd like is
 642   //                It would be nice to have an API that let us ask
 643   //                how many processes are bound to a processor,
 644   //                but we don't have that, either.
 645   //                In the short term, "board" is static so that
 646   //                subsequent distributions don't all start at board 0.
 647   static uint board = 0;
 648   uint assigned = 0;
 649   // Until we've found enough processors ....
 650   while (assigned < distribution_length) {
 651     // ... find the next available processor in the board.
 652     for (uint slot = 0; slot < processors_per_board; slot += 1) {
 653       uint try_id = board * processors_per_board + slot;
 654       if ((try_id < limit_id) && (available_id[try_id] == true)) {
 655         distribution[assigned] = try_id;
 656         available_id[try_id] = false;
 657         assigned += 1;
 658         break;
 659       }
 660     }
 661     board += 1;
 662     if (board * processors_per_board + 0 >= limit_id) {
 663       board = 0;
 664     }
 665   }
 666   if (available_id != NULL) {
 667     FREE_C_HEAP_ARRAY(bool, available_id);
 668   }
 669   return true;
 670 }
 671 
 672 bool os::distribute_processes(uint length, uint* distribution) {
 673   bool result = false;
 674   // Find the processor id's of all the available CPUs.
 675   processorid_t* id_array  = NULL;
 676   uint           id_length = 0;
 677   // There are some races between querying information and using it,
 678   // since processor sets can change dynamically.
 679   psetid_t pset = PS_NONE;
 680   // Are we running in a processor set?
 681   if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {
 682     result = find_processors_in_pset(pset, &id_array, &id_length);
 683   } else {
 684     result = find_processors_online(&id_array, &id_length);
 685   }
 686   if (result == true) {
 687     if (id_length >= length) {
 688       result = assign_distribution(id_array, id_length, distribution, length);
 689     } else {
 690       result = false;
 691     }
 692   }
 693   if (id_array != NULL) {
 694     FREE_C_HEAP_ARRAY(processorid_t, id_array);
 695   }
 696   return result;
 697 }
 698 
 699 bool os::bind_to_processor(uint processor_id) {
 700   // We assume that a processorid_t can be stored in a uint.
 701   assert(sizeof(uint) == sizeof(processorid_t),
 702          "can't convert uint to processorid_t");
 703   int bind_result =
 704     processor_bind(P_LWPID,                       // bind LWP.
 705                    P_MYID,                        // bind current LWP.
 706                    (processorid_t) processor_id,  // id.
 707                    NULL);                         // don't return old binding.
 708   return (bind_result == 0);
 709 }
 710 
 711 bool os::getenv(const char* name, char* buffer, int len) {
 712   char* val = ::getenv( name );
 713   if ( val == NULL
 714   ||   strlen(val) + 1  >  len ) {
 715     if (len > 0)  buffer[0] = 0; // return a null string
 716     return false;
 717   }
 718   strcpy( buffer, val );
 719   return true;
 720 }
 721 
 722 
 723 // Return true if user is running as root.
 724 
 725 bool os::have_special_privileges() {
 726   static bool init = false;
 727   static bool privileges = false;
 728   if (!init) {
 729     privileges = (getuid() != geteuid()) || (getgid() != getegid());
 730     init = true;
 731   }
 732   return privileges;
 733 }
 734 
 735 
 736 void os::init_system_properties_values() {
 737   char arch[12];
 738   sysinfo(SI_ARCHITECTURE, arch, sizeof(arch));
 739 
 740   // The next steps are taken in the product version:
 741   //
 742   // Obtain the JAVA_HOME value from the location of libjvm[_g].so.
 743   // This library should be located at:
 744   // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so.
 745   //
 746   // If "/jre/lib/" appears at the right place in the path, then we
 747   // assume libjvm[_g].so is installed in a JDK and we use this path.
 748   //
 749   // Otherwise exit with message: "Could not create the Java virtual machine."
 750   //
 751   // The following extra steps are taken in the debugging version:
 752   //
 753   // If "/jre/lib/" does NOT appear at the right place in the path
 754   // instead of exit check for $JAVA_HOME environment variable.
 755   //
 756   // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,
 757   // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so
 758   // it looks like libjvm[_g].so is installed there
 759   // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so.
 760   //
 761   // Otherwise exit.
 762   //
 763   // Important note: if the location of libjvm.so changes this
 764   // code needs to be changed accordingly.
 765 
 766   // The next few definitions allow the code to be verbatim:
 767 #define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))
 768 #define free(p) FREE_C_HEAP_ARRAY(char, p)
 769 #define getenv(n) ::getenv(n)
 770 
 771 #define EXTENSIONS_DIR  "/lib/ext"
 772 #define ENDORSED_DIR    "/lib/endorsed"
 773 #define COMMON_DIR      "/usr/jdk/packages"
 774 
 775   {
 776     /* sysclasspath, java_home, dll_dir */
 777     {
 778         char *home_path;
 779         char *dll_path;
 780         char *pslash;
 781         char buf[MAXPATHLEN];
 782         os::jvm_path(buf, sizeof(buf));
 783 
 784         // Found the full path to libjvm.so.
 785         // Now cut the path to <java_home>/jre if we can.
 786         *(strrchr(buf, '/')) = '\0';  /* get rid of /libjvm.so */
 787         pslash = strrchr(buf, '/');
 788         if (pslash != NULL)
 789             *pslash = '\0';           /* get rid of /{client|server|hotspot} */
 790         dll_path = malloc(strlen(buf) + 1);
 791         if (dll_path == NULL)
 792             return;
 793         strcpy(dll_path, buf);
 794         Arguments::set_dll_dir(dll_path);
 795 
 796         if (pslash != NULL) {
 797             pslash = strrchr(buf, '/');
 798             if (pslash != NULL) {
 799                 *pslash = '\0';       /* get rid of /<arch> */
 800                 pslash = strrchr(buf, '/');
 801                 if (pslash != NULL)
 802                     *pslash = '\0';   /* get rid of /lib */
 803             }
 804         }
 805 
 806         home_path = malloc(strlen(buf) + 1);
 807         if (home_path == NULL)
 808             return;
 809         strcpy(home_path, buf);
 810         Arguments::set_java_home(home_path);
 811 
 812         if (!set_boot_path('/', ':'))
 813             return;
 814     }
 815 
 816     /*
 817      * Where to look for native libraries
 818      */
 819     {
 820       // Use dlinfo() to determine the correct java.library.path.
 821       //
 822       // If we're launched by the Java launcher, and the user
 823       // does not set java.library.path explicitly on the commandline,
 824       // the Java launcher sets LD_LIBRARY_PATH for us and unsets
 825       // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64.  In this case
 826       // dlinfo returns LD_LIBRARY_PATH + crle settings (including
 827       // /usr/lib), which is exactly what we want.
 828       //
 829       // If the user does set java.library.path, it completely
 830       // overwrites this setting, and always has.
 831       //
 832       // If we're not launched by the Java launcher, we may
 833       // get here with any/all of the LD_LIBRARY_PATH[_32|64]
 834       // settings.  Again, dlinfo does exactly what we want.
 835 
 836       Dl_serinfo     _info, *info = &_info;
 837       Dl_serpath     *path;
 838       char*          library_path;
 839       char           *common_path;
 840       int            i;
 841 
 842       // determine search path count and required buffer size
 843       if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {
 844         vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());
 845       }
 846 
 847       // allocate new buffer and initialize
 848       info = (Dl_serinfo*)malloc(_info.dls_size);
 849       if (info == NULL) {
 850         vm_exit_out_of_memory(_info.dls_size,
 851                               "init_system_properties_values info");
 852       }
 853       info->dls_size = _info.dls_size;
 854       info->dls_cnt = _info.dls_cnt;
 855 
 856       // obtain search path information
 857       if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {
 858         free(info);
 859         vm_exit_during_initialization("dlinfo SERINFO request", dlerror());
 860       }
 861 
 862       path = &info->dls_serpath[0];
 863 
 864       // Note: Due to a legacy implementation, most of the library path
 865       // is set in the launcher.  This was to accomodate linking restrictions
 866       // on legacy Solaris implementations (which are no longer supported).
 867       // Eventually, all the library path setting will be done here.
 868       //
 869       // However, to prevent the proliferation of improperly built native
 870       // libraries, the new path component /usr/jdk/packages is added here.
 871 
 872       // Determine the actual CPU architecture.
 873       char cpu_arch[12];
 874       sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
 875 #ifdef _LP64
 876       // If we are a 64-bit vm, perform the following translations:
 877       //   sparc   -> sparcv9
 878       //   i386    -> amd64
 879       if (strcmp(cpu_arch, "sparc") == 0)
 880         strcat(cpu_arch, "v9");
 881       else if (strcmp(cpu_arch, "i386") == 0)
 882         strcpy(cpu_arch, "amd64");
 883 #endif
 884 
 885       // Construct the invariant part of ld_library_path. Note that the
 886       // space for the colon and the trailing null are provided by the
 887       // nulls included by the sizeof operator.
 888       size_t bufsize = sizeof(COMMON_DIR) + sizeof("/lib/") + strlen(cpu_arch);
 889       common_path = malloc(bufsize);
 890       if (common_path == NULL) {
 891         free(info);
 892         vm_exit_out_of_memory(bufsize,
 893                               "init_system_properties_values common_path");
 894       }
 895       sprintf(common_path, COMMON_DIR "/lib/%s", cpu_arch);
 896 
 897       // struct size is more than sufficient for the path components obtained
 898       // through the dlinfo() call, so only add additional space for the path
 899       // components explicitly added here.
 900       bufsize = info->dls_size + strlen(common_path);
 901       library_path = malloc(bufsize);
 902       if (library_path == NULL) {
 903         free(info);
 904         free(common_path);
 905         vm_exit_out_of_memory(bufsize,
 906                               "init_system_properties_values library_path");
 907       }
 908       library_path[0] = '\0';
 909 
 910       // Construct the desired Java library path from the linker's library
 911       // search path.
 912       //
 913       // For compatibility, it is optimal that we insert the additional path
 914       // components specific to the Java VM after those components specified
 915       // in LD_LIBRARY_PATH (if any) but before those added by the ld.so
 916       // infrastructure.
 917       if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it
 918         strcpy(library_path, common_path);
 919       } else {
 920         int inserted = 0;
 921         for (i = 0; i < info->dls_cnt; i++, path++) {
 922           uint_t flags = path->dls_flags & LA_SER_MASK;
 923           if (((flags & LA_SER_LIBPATH) == 0) && !inserted) {
 924             strcat(library_path, common_path);
 925             strcat(library_path, os::path_separator());
 926             inserted = 1;
 927           }
 928           strcat(library_path, path->dls_name);
 929           strcat(library_path, os::path_separator());
 930         }
 931         // eliminate trailing path separator
 932         library_path[strlen(library_path)-1] = '\0';
 933       }
 934 
 935       // happens before argument parsing - can't use a trace flag
 936       // tty->print_raw("init_system_properties_values: native lib path: ");
 937       // tty->print_raw_cr(library_path);
 938 
 939       // callee copies into its own buffer
 940       Arguments::set_library_path(library_path);
 941 
 942       free(common_path);
 943       free(library_path);
 944       free(info);
 945     }
 946 
 947     /*
 948      * Extensions directories.
 949      *
 950      * Note that the space for the colon and the trailing null are provided
 951      * by the nulls included by the sizeof operator (so actually one byte more
 952      * than necessary is allocated).
 953      */
 954     {
 955         char *buf = (char *) malloc(strlen(Arguments::get_java_home()) +
 956             sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) +
 957             sizeof(EXTENSIONS_DIR));
 958         sprintf(buf, "%s" EXTENSIONS_DIR ":" COMMON_DIR EXTENSIONS_DIR,
 959             Arguments::get_java_home());
 960         Arguments::set_ext_dirs(buf);
 961     }
 962 
 963     /* Endorsed standards default directory. */
 964     {
 965         char * buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR));
 966         sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home());
 967         Arguments::set_endorsed_dirs(buf);
 968     }
 969   }
 970 
 971 #undef malloc
 972 #undef free
 973 #undef getenv
 974 #undef EXTENSIONS_DIR
 975 #undef ENDORSED_DIR
 976 #undef COMMON_DIR
 977 
 978 }
 979 
 980 void os::breakpoint() {
 981   BREAKPOINT;
 982 }
 983 
 984 bool os::obsolete_option(const JavaVMOption *option)
 985 {
 986   if (!strncmp(option->optionString, "-Xt", 3)) {
 987     return true;
 988   } else if (!strncmp(option->optionString, "-Xtm", 4)) {
 989     return true;
 990   } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) {
 991     return true;
 992   } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) {
 993     return true;
 994   }
 995   return false;
 996 }
 997 
 998 bool os::Solaris::valid_stack_address(Thread* thread, address sp) {
 999   address  stackStart  = (address)thread->stack_base();
1000   address  stackEnd    = (address)(stackStart - (address)thread->stack_size());
1001   if (sp < stackStart && sp >= stackEnd ) return true;
1002   return false;
1003 }
1004 
1005 extern "C" void breakpoint() {
1006   // use debugger to set breakpoint here
1007 }
1008 
1009 // Returns an estimate of the current stack pointer. Result must be guaranteed to
1010 // point into the calling threads stack, and be no lower than the current stack
1011 // pointer.
1012 address os::current_stack_pointer() {
1013   volatile int dummy;
1014   address sp = (address)&dummy + 8;     // %%%% need to confirm if this is right
1015   return sp;
1016 }
1017 
1018 static thread_t main_thread;
1019 
1020 // Thread start routine for all new Java threads
1021 extern "C" void* java_start(void* thread_addr) {
1022   // Try to randomize the cache line index of hot stack frames.
1023   // This helps when threads of the same stack traces evict each other's
1024   // cache lines. The threads can be either from the same JVM instance, or
1025   // from different JVM instances. The benefit is especially true for
1026   // processors with hyperthreading technology.
1027   static int counter = 0;
1028   int pid = os::current_process_id();
1029   alloca(((pid ^ counter++) & 7) * 128);
1030 
1031   int prio;
1032   Thread* thread = (Thread*)thread_addr;
1033   OSThread* osthr = thread->osthread();
1034 
1035   osthr->set_lwp_id( _lwp_self() );  // Store lwp in case we are bound
1036   thread->_schedctl = (void *) schedctl_init () ;
1037 
1038   if (UseNUMA) {
1039     int lgrp_id = os::numa_get_group_id();
1040     if (lgrp_id != -1) {
1041       thread->set_lgrp_id(lgrp_id);
1042     }
1043   }
1044 
1045   // If the creator called set priority before we started,
1046   // we need to call set priority now that we have an lwp.
1047   // Get the priority from libthread and set the priority
1048   // for the new Solaris lwp.
1049   if ( osthr->thread_id() != -1 ) {
1050     if ( UseThreadPriorities ) {
1051       thr_getprio(osthr->thread_id(), &prio);
1052       if (ThreadPriorityVerbose) {
1053         tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT ", setting priority: %d\n",
1054                       osthr->thread_id(), osthr->lwp_id(), prio );
1055       }
1056       os::set_native_priority(thread, prio);
1057     }
1058   } else if (ThreadPriorityVerbose) {
1059     warning("Can't set priority in _start routine, thread id hasn't been set\n");
1060   }
1061 
1062   assert(osthr->get_state() == RUNNABLE, "invalid os thread state");
1063 
1064   // initialize signal mask for this thread
1065   os::Solaris::hotspot_sigmask(thread);
1066 
1067   thread->run();
1068 
1069   // One less thread is executing
1070   // When the VMThread gets here, the main thread may have already exited
1071   // which frees the CodeHeap containing the Atomic::dec code
1072   if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {
1073     Atomic::dec(&os::Solaris::_os_thread_count);
1074   }
1075 
1076   if (UseDetachedThreads) {
1077     thr_exit(NULL);
1078     ShouldNotReachHere();
1079   }
1080   return NULL;
1081 }
1082 
1083 static OSThread* create_os_thread(Thread* thread, thread_t thread_id) {
1084   // Allocate the OSThread object
1085   OSThread* osthread = new OSThread(NULL, NULL);
1086   if (osthread == NULL) return NULL;
1087 
1088   // Store info on the Solaris thread into the OSThread
1089   osthread->set_thread_id(thread_id);
1090   osthread->set_lwp_id(_lwp_self());
1091   thread->_schedctl = (void *) schedctl_init () ;
1092 
1093   if (UseNUMA) {
1094     int lgrp_id = os::numa_get_group_id();
1095     if (lgrp_id != -1) {
1096       thread->set_lgrp_id(lgrp_id);
1097     }
1098   }
1099 
1100   if ( ThreadPriorityVerbose ) {
1101     tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n",
1102                   osthread->thread_id(), osthread->lwp_id() );
1103   }
1104 
1105   // Initial thread state is INITIALIZED, not SUSPENDED
1106   osthread->set_state(INITIALIZED);
1107 
1108   return osthread;
1109 }
1110 
1111 void os::Solaris::hotspot_sigmask(Thread* thread) {
1112 
1113   //Save caller's signal mask
1114   sigset_t sigmask;
1115   thr_sigsetmask(SIG_SETMASK, NULL, &sigmask);
1116   OSThread *osthread = thread->osthread();
1117   osthread->set_caller_sigmask(sigmask);
1118 
1119   thr_sigsetmask(SIG_UNBLOCK, os::Solaris::unblocked_signals(), NULL);
1120   if (!ReduceSignalUsage) {
1121     if (thread->is_VM_thread()) {
1122       // Only the VM thread handles BREAK_SIGNAL ...
1123       thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL);
1124     } else {
1125       // ... all other threads block BREAK_SIGNAL
1126       assert(!sigismember(vm_signals(), SIGINT), "SIGINT should not be blocked");
1127       thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL);
1128     }
1129   }
1130 }
1131 
1132 bool os::create_attached_thread(JavaThread* thread) {
1133 #ifdef ASSERT
1134   thread->verify_not_published();
1135 #endif
1136   OSThread* osthread = create_os_thread(thread, thr_self());
1137   if (osthread == NULL) {
1138      return false;
1139   }
1140 
1141   // Initial thread state is RUNNABLE
1142   osthread->set_state(RUNNABLE);
1143   thread->set_osthread(osthread);
1144 
1145   // initialize signal mask for this thread
1146   // and save the caller's signal mask
1147   os::Solaris::hotspot_sigmask(thread);
1148 
1149   return true;
1150 }
1151 
1152 bool os::create_main_thread(JavaThread* thread) {
1153 #ifdef ASSERT
1154   thread->verify_not_published();
1155 #endif
1156   if (_starting_thread == NULL) {
1157     _starting_thread = create_os_thread(thread, main_thread);
1158      if (_starting_thread == NULL) {
1159         return false;
1160      }
1161   }
1162 
1163   // The primodial thread is runnable from the start
1164   _starting_thread->set_state(RUNNABLE);
1165 
1166   thread->set_osthread(_starting_thread);
1167 
1168   // initialize signal mask for this thread
1169   // and save the caller's signal mask
1170   os::Solaris::hotspot_sigmask(thread);
1171 
1172   return true;
1173 }
1174 
1175 // _T2_libthread is true if we believe we are running with the newer
1176 // SunSoft lwp/libthread.so (2.8 patch, 2.9 default)
1177 bool os::Solaris::_T2_libthread = false;
1178 
1179 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
1180   // Allocate the OSThread object
1181   OSThread* osthread = new OSThread(NULL, NULL);
1182   if (osthread == NULL) {
1183     return false;
1184   }
1185 
1186   if ( ThreadPriorityVerbose ) {
1187     char *thrtyp;
1188     switch ( thr_type ) {
1189       case vm_thread:
1190         thrtyp = (char *)"vm";
1191         break;
1192       case cgc_thread:
1193         thrtyp = (char *)"cgc";
1194         break;
1195       case pgc_thread:
1196         thrtyp = (char *)"pgc";
1197         break;
1198       case java_thread:
1199         thrtyp = (char *)"java";
1200         break;
1201       case compiler_thread:
1202         thrtyp = (char *)"compiler";
1203         break;
1204       case watcher_thread:
1205         thrtyp = (char *)"watcher";
1206         break;
1207       default:
1208         thrtyp = (char *)"unknown";
1209         break;
1210     }
1211     tty->print_cr("In create_thread, creating a %s thread\n", thrtyp);
1212   }
1213 
1214   // Calculate stack size if it's not specified by caller.
1215   if (stack_size == 0) {
1216     // The default stack size 1M (2M for LP64).
1217     stack_size = (BytesPerWord >> 2) * K * K;
1218 
1219     switch (thr_type) {
1220     case os::java_thread:
1221       // Java threads use ThreadStackSize which default value can be changed with the flag -Xss
1222       if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create();
1223       break;
1224     case os::compiler_thread:
1225       if (CompilerThreadStackSize > 0) {
1226         stack_size = (size_t)(CompilerThreadStackSize * K);
1227         break;
1228       } // else fall through:
1229         // use VMThreadStackSize if CompilerThreadStackSize is not defined
1230     case os::vm_thread:
1231     case os::pgc_thread:
1232     case os::cgc_thread:
1233     case os::watcher_thread:
1234       if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
1235       break;
1236     }
1237   }
1238   stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed);
1239 
1240   // Initial state is ALLOCATED but not INITIALIZED
1241   osthread->set_state(ALLOCATED);
1242 
1243   if (os::Solaris::_os_thread_count > os::Solaris::_os_thread_limit) {
1244     // We got lots of threads. Check if we still have some address space left.
1245     // Need to be at least 5Mb of unreserved address space. We do check by
1246     // trying to reserve some.
1247     const size_t VirtualMemoryBangSize = 20*K*K;
1248     char* mem = os::reserve_memory(VirtualMemoryBangSize);
1249     if (mem == NULL) {
1250       delete osthread;
1251       return false;
1252     } else {
1253       // Release the memory again
1254       os::release_memory(mem, VirtualMemoryBangSize);
1255     }
1256   }
1257 
1258   // Setup osthread because the child thread may need it.
1259   thread->set_osthread(osthread);
1260 
1261   // Create the Solaris thread
1262   // explicit THR_BOUND for T2_libthread case in case
1263   // that assumption is not accurate, but our alternate signal stack
1264   // handling is based on it which must have bound threads
1265   thread_t tid = 0;
1266   long     flags = (UseDetachedThreads ? THR_DETACHED : 0) | THR_SUSPENDED
1267                    | ((UseBoundThreads || os::Solaris::T2_libthread() ||
1268                        (thr_type == vm_thread) ||
1269                        (thr_type == cgc_thread) ||
1270                        (thr_type == pgc_thread) ||
1271                        (thr_type == compiler_thread && BackgroundCompilation)) ?
1272                       THR_BOUND : 0);
1273   int      status;
1274 
1275   // 4376845 -- libthread/kernel don't provide enough LWPs to utilize all CPUs.
1276   //
1277   // On multiprocessors systems, libthread sometimes under-provisions our
1278   // process with LWPs.  On a 30-way systems, for instance, we could have
1279   // 50 user-level threads in ready state and only 2 or 3 LWPs assigned
1280   // to our process.  This can result in under utilization of PEs.
1281   // I suspect the problem is related to libthread's LWP
1282   // pool management and to the kernel's SIGBLOCKING "last LWP parked"
1283   // upcall policy.
1284   //
1285   // The following code is palliative -- it attempts to ensure that our
1286   // process has sufficient LWPs to take advantage of multiple PEs.
1287   // Proper long-term cures include using user-level threads bound to LWPs
1288   // (THR_BOUND) or using LWP-based synchronization.  Note that there is a
1289   // slight timing window with respect to sampling _os_thread_count, but
1290   // the race is benign.  Also, we should periodically recompute
1291   // _processors_online as the min of SC_NPROCESSORS_ONLN and the
1292   // the number of PEs in our partition.  You might be tempted to use
1293   // THR_NEW_LWP here, but I'd recommend against it as that could
1294   // result in undesirable growth of the libthread's LWP pool.
1295   // The fix below isn't sufficient; for instance, it doesn't take into count
1296   // LWPs parked on IO.  It does, however, help certain CPU-bound benchmarks.
1297   //
1298   // Some pathologies this scheme doesn't handle:
1299   // *  Threads can block, releasing the LWPs.  The LWPs can age out.
1300   //    When a large number of threads become ready again there aren't
1301   //    enough LWPs available to service them.  This can occur when the
1302   //    number of ready threads oscillates.
1303   // *  LWPs/Threads park on IO, thus taking the LWP out of circulation.
1304   //
1305   // Finally, we should call thr_setconcurrency() periodically to refresh
1306   // the LWP pool and thwart the LWP age-out mechanism.
1307   // The "+3" term provides a little slop -- we want to slightly overprovision.
1308 
1309   if (AdjustConcurrency && os::Solaris::_os_thread_count < (_processors_online+3)) {
1310     if (!(flags & THR_BOUND)) {
1311       thr_setconcurrency (os::Solaris::_os_thread_count);       // avoid starvation
1312     }
1313   }
1314   // Although this doesn't hurt, we should warn of undefined behavior
1315   // when using unbound T1 threads with schedctl().  This should never
1316   // happen, as the compiler and VM threads are always created bound
1317   DEBUG_ONLY(
1318       if ((VMThreadHintNoPreempt || CompilerThreadHintNoPreempt) &&
1319           (!os::Solaris::T2_libthread() && (!(flags & THR_BOUND))) &&
1320           ((thr_type == vm_thread) || (thr_type == cgc_thread) ||
1321            (thr_type == pgc_thread) || (thr_type == compiler_thread && BackgroundCompilation))) {
1322          warning("schedctl behavior undefined when Compiler/VM/GC Threads are Unbound");
1323       }
1324   );
1325 
1326 
1327   // Mark that we don't have an lwp or thread id yet.
1328   // In case we attempt to set the priority before the thread starts.
1329   osthread->set_lwp_id(-1);
1330   osthread->set_thread_id(-1);
1331 
1332   status = thr_create(NULL, stack_size, java_start, thread, flags, &tid);
1333   if (status != 0) {
1334     if (PrintMiscellaneous && (Verbose || WizardMode)) {
1335       perror("os::create_thread");
1336     }
1337     thread->set_osthread(NULL);
1338     // Need to clean up stuff we've allocated so far
1339     delete osthread;
1340     return false;
1341   }
1342 
1343   Atomic::inc(&os::Solaris::_os_thread_count);
1344 
1345   // Store info on the Solaris thread into the OSThread
1346   osthread->set_thread_id(tid);
1347 
1348   // Remember that we created this thread so we can set priority on it
1349   osthread->set_vm_created();
1350 
1351   // Set the default thread priority otherwise use NormalPriority
1352 
1353   if ( UseThreadPriorities ) {
1354      thr_setprio(tid, (DefaultThreadPriority == -1) ?
1355                         java_to_os_priority[NormPriority] :
1356                         DefaultThreadPriority);
1357   }
1358 
1359   // Initial thread state is INITIALIZED, not SUSPENDED
1360   osthread->set_state(INITIALIZED);
1361 
1362   // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
1363   return true;
1364 }
1365 
1366 /* defined for >= Solaris 10. This allows builds on earlier versions
1367  *  of Solaris to take advantage of the newly reserved Solaris JVM signals
1368  *  With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2
1369  *  and -XX:+UseAltSigs does nothing since these should have no conflict
1370  */
1371 #if !defined(SIGJVM1)
1372 #define SIGJVM1 39
1373 #define SIGJVM2 40
1374 #endif
1375 
1376 debug_only(static bool signal_sets_initialized = false);
1377 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
1378 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;
1379 int os::Solaris::_SIGasync = ASYNC_SIGNAL;
1380 
1381 bool os::Solaris::is_sig_ignored(int sig) {
1382       struct sigaction oact;
1383       sigaction(sig, (struct sigaction*)NULL, &oact);
1384       void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oact.sa_sigaction)
1385                                      : CAST_FROM_FN_PTR(void*,  oact.sa_handler);
1386       if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
1387            return true;
1388       else
1389            return false;
1390 }
1391 
1392 // Note: SIGRTMIN is a macro that calls sysconf() so it will
1393 // dynamically detect SIGRTMIN value for the system at runtime, not buildtime
1394 static bool isJVM1available() {
1395   return SIGJVM1 < SIGRTMIN;
1396 }
1397 
1398 void os::Solaris::signal_sets_init() {
1399   // Should also have an assertion stating we are still single-threaded.
1400   assert(!signal_sets_initialized, "Already initialized");
1401   // Fill in signals that are necessarily unblocked for all threads in
1402   // the VM. Currently, we unblock the following signals:
1403   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden
1404   //                         by -Xrs (=ReduceSignalUsage));
1405   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all
1406   // other threads. The "ReduceSignalUsage" boolean tells us not to alter
1407   // the dispositions or masks wrt these signals.
1408   // Programs embedding the VM that want to use the above signals for their
1409   // own purposes must, at this time, use the "-Xrs" option to prevent
1410   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.
1411   // (See bug 4345157, and other related bugs).
1412   // In reality, though, unblocking these signals is really a nop, since
1413   // these signals are not blocked by default.
1414   sigemptyset(&unblocked_sigs);
1415   sigemptyset(&allowdebug_blocked_sigs);
1416   sigaddset(&unblocked_sigs, SIGILL);
1417   sigaddset(&unblocked_sigs, SIGSEGV);
1418   sigaddset(&unblocked_sigs, SIGBUS);
1419   sigaddset(&unblocked_sigs, SIGFPE);
1420 
1421   if (isJVM1available) {
1422     os::Solaris::set_SIGinterrupt(SIGJVM1);
1423     os::Solaris::set_SIGasync(SIGJVM2);
1424   } else if (UseAltSigs) {
1425     os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL);
1426     os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL);
1427   } else {
1428     os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL);
1429     os::Solaris::set_SIGasync(ASYNC_SIGNAL);
1430   }
1431 
1432   sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt());
1433   sigaddset(&unblocked_sigs, os::Solaris::SIGasync());
1434 
1435   if (!ReduceSignalUsage) {
1436    if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
1437       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
1438       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
1439    }
1440    if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
1441       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
1442       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
1443    }
1444    if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
1445       sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
1446       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
1447    }
1448   }
1449   // Fill in signals that are blocked by all but the VM thread.
1450   sigemptyset(&vm_sigs);
1451   if (!ReduceSignalUsage)
1452     sigaddset(&vm_sigs, BREAK_SIGNAL);
1453   debug_only(signal_sets_initialized = true);
1454 
1455   // For diagnostics only used in run_periodic_checks
1456   sigemptyset(&check_signal_done);
1457 }
1458 
1459 // These are signals that are unblocked while a thread is running Java.
1460 // (For some reason, they get blocked by default.)
1461 sigset_t* os::Solaris::unblocked_signals() {
1462   assert(signal_sets_initialized, "Not initialized");
1463   return &unblocked_sigs;
1464 }
1465 
1466 // These are the signals that are blocked while a (non-VM) thread is
1467 // running Java. Only the VM thread handles these signals.
1468 sigset_t* os::Solaris::vm_signals() {
1469   assert(signal_sets_initialized, "Not initialized");
1470   return &vm_sigs;
1471 }
1472 
1473 // These are signals that are blocked during cond_wait to allow debugger in
1474 sigset_t* os::Solaris::allowdebug_blocked_signals() {
1475   assert(signal_sets_initialized, "Not initialized");
1476   return &allowdebug_blocked_sigs;
1477 }
1478 
1479 
1480 void _handle_uncaught_cxx_exception() {
1481   VMError err("An uncaught C++ exception");
1482   err.report_and_die();
1483 }
1484 
1485 
1486 // First crack at OS-specific initialization, from inside the new thread.
1487 void os::initialize_thread() {
1488   int r = thr_main() ;
1489   guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;
1490   if (r) {
1491     JavaThread* jt = (JavaThread *)Thread::current();
1492     assert(jt != NULL,"Sanity check");
1493     size_t stack_size;
1494     address base = jt->stack_base();
1495     if (Arguments::created_by_java_launcher()) {
1496       // Use 2MB to allow for Solaris 7 64 bit mode.
1497       stack_size = JavaThread::stack_size_at_create() == 0
1498         ? 2048*K : JavaThread::stack_size_at_create();
1499 
1500       // There are rare cases when we may have already used more than
1501       // the basic stack size allotment before this method is invoked.
1502       // Attempt to allow for a normally sized java_stack.
1503       size_t current_stack_offset = (size_t)(base - (address)&stack_size);
1504       stack_size += ReservedSpace::page_align_size_down(current_stack_offset);
1505     } else {
1506       // 6269555: If we were not created by a Java launcher, i.e. if we are
1507       // running embedded in a native application, treat the primordial thread
1508       // as much like a native attached thread as possible.  This means using
1509       // the current stack size from thr_stksegment(), unless it is too large
1510       // to reliably setup guard pages.  A reasonable max size is 8MB.
1511       size_t current_size = current_stack_size();
1512       // This should never happen, but just in case....
1513       if (current_size == 0) current_size = 2 * K * K;
1514       stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size;
1515     }
1516     address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());;
1517     stack_size = (size_t)(base - bottom);
1518 
1519     assert(stack_size > 0, "Stack size calculation problem");
1520 
1521     if (stack_size > jt->stack_size()) {
1522       NOT_PRODUCT(
1523         struct rlimit limits;
1524         getrlimit(RLIMIT_STACK, &limits);
1525         size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur);
1526         assert(size >= jt->stack_size(), "Stack size problem in main thread");
1527       )
1528       tty->print_cr(
1529         "Stack size of %d Kb exceeds current limit of %d Kb.\n"
1530         "(Stack sizes are rounded up to a multiple of the system page size.)\n"
1531         "See limit(1) to increase the stack size limit.",
1532         stack_size / K, jt->stack_size() / K);
1533       vm_exit(1);
1534     }
1535     assert(jt->stack_size() >= stack_size,
1536           "Attempt to map more stack than was allocated");
1537     jt->set_stack_size(stack_size);
1538   }
1539 
1540    // 5/22/01: Right now alternate signal stacks do not handle
1541    // throwing stack overflow exceptions, see bug 4463178
1542    // Until a fix is found for this, T2 will NOT imply alternate signal
1543    // stacks.
1544    // If using T2 libthread threads, install an alternate signal stack.
1545    // Because alternate stacks associate with LWPs on Solaris,
1546    // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads
1547    // we prefer to explicitly stack bang.
1548    // If not using T2 libthread, but using UseBoundThreads any threads
1549    // (primordial thread, jni_attachCurrentThread) we do not create,
1550    // probably are not bound, therefore they can not have an alternate
1551    // signal stack. Since our stack banging code is generated and
1552    // is shared across threads, all threads must be bound to allow
1553    // using alternate signal stacks.  The alternative is to interpose
1554    // on _lwp_create to associate an alt sig stack with each LWP,
1555    // and this could be a problem when the JVM is embedded.
1556    // We would prefer to use alternate signal stacks with T2
1557    // Since there is currently no accurate way to detect T2
1558    // we do not. Assuming T2 when running T1 causes sig 11s or assertions
1559    // on installing alternate signal stacks
1560 
1561 
1562    // 05/09/03: removed alternate signal stack support for Solaris
1563    // The alternate signal stack mechanism is no longer needed to
1564    // handle stack overflow. This is now handled by allocating
1565    // guard pages (red zone) and stackbanging.
1566    // Initially the alternate signal stack mechanism was removed because
1567    // it did not work with T1 llibthread. Alternate
1568    // signal stacks MUST have all threads bound to lwps. Applications
1569    // can create their own threads and attach them without their being
1570    // bound under T1. This is frequently the case for the primordial thread.
1571    // If we were ever to reenable this mechanism we would need to
1572    // use the dynamic check for T2 libthread.
1573 
1574   os::Solaris::init_thread_fpu_state();
1575   std::set_terminate(_handle_uncaught_cxx_exception);
1576 }
1577 
1578 
1579 
1580 // Free Solaris resources related to the OSThread
1581 void os::free_thread(OSThread* osthread) {
1582   assert(osthread != NULL, "os::free_thread but osthread not set");
1583 
1584 
1585   // We are told to free resources of the argument thread,
1586   // but we can only really operate on the current thread.
1587   // The main thread must take the VMThread down synchronously
1588   // before the main thread exits and frees up CodeHeap
1589   guarantee((Thread::current()->osthread() == osthread
1590      || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread");
1591   if (Thread::current()->osthread() == osthread) {
1592     // Restore caller's signal mask
1593     sigset_t sigmask = osthread->caller_sigmask();
1594     thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);
1595   }
1596   delete osthread;
1597 }
1598 
1599 void os::pd_start_thread(Thread* thread) {
1600   int status = thr_continue(thread->osthread()->thread_id());
1601   assert_status(status == 0, status, "thr_continue failed");
1602 }
1603 
1604 
1605 intx os::current_thread_id() {
1606   return (intx)thr_self();
1607 }
1608 
1609 static pid_t _initial_pid = 0;
1610 
1611 int os::current_process_id() {
1612   return (int)(_initial_pid ? _initial_pid : getpid());
1613 }
1614 
1615 int os::allocate_thread_local_storage() {
1616   // %%%       in Win32 this allocates a memory segment pointed to by a
1617   //           register.  Dan Stein can implement a similar feature in
1618   //           Solaris.  Alternatively, the VM can do the same thing
1619   //           explicitly: malloc some storage and keep the pointer in a
1620   //           register (which is part of the thread's context) (or keep it
1621   //           in TLS).
1622   // %%%       In current versions of Solaris, thr_self and TSD can
1623   //           be accessed via short sequences of displaced indirections.
1624   //           The value of thr_self is available as %g7(36).
1625   //           The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4),
1626   //           assuming that the current thread already has a value bound to k.
1627   //           It may be worth experimenting with such access patterns,
1628   //           and later having the parameters formally exported from a Solaris
1629   //           interface.  I think, however, that it will be faster to
1630   //           maintain the invariant that %g2 always contains the
1631   //           JavaThread in Java code, and have stubs simply
1632   //           treat %g2 as a caller-save register, preserving it in a %lN.
1633   thread_key_t tk;
1634   if (thr_keycreate( &tk, NULL ) )
1635     fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed "
1636                   "(%s)", strerror(errno)));
1637   return int(tk);
1638 }
1639 
1640 void os::free_thread_local_storage(int index) {
1641   // %%% don't think we need anything here
1642   // if ( pthread_key_delete((pthread_key_t) tk) )
1643   //   fatal("os::free_thread_local_storage: pthread_key_delete failed");
1644 }
1645 
1646 #define SMALLINT 32   // libthread allocate for tsd_common is a version specific
1647                       // small number - point is NO swap space available
1648 void os::thread_local_storage_at_put(int index, void* value) {
1649   // %%% this is used only in threadLocalStorage.cpp
1650   if (thr_setspecific((thread_key_t)index, value)) {
1651     if (errno == ENOMEM) {
1652        vm_exit_out_of_memory(SMALLINT, "thr_setspecific: out of swap space");
1653     } else {
1654       fatal(err_msg("os::thread_local_storage_at_put: thr_setspecific failed "
1655                     "(%s)", strerror(errno)));
1656     }
1657   } else {
1658       ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ;
1659   }
1660 }
1661 
1662 // This function could be called before TLS is initialized, for example, when
1663 // VM receives an async signal or when VM causes a fatal error during
1664 // initialization. Return NULL if thr_getspecific() fails.
1665 void* os::thread_local_storage_at(int index) {
1666   // %%% this is used only in threadLocalStorage.cpp
1667   void* r = NULL;
1668   return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r;
1669 }
1670 
1671 
1672 const int NANOSECS_PER_MILLISECS = 1000000;
1673 // gethrtime can move backwards if read from one cpu and then a different cpu
1674 // getTimeNanos is guaranteed to not move backward on Solaris
1675 // local spinloop created as faster for a CAS on an int than
1676 // a CAS on a 64bit jlong. Also Atomic::cmpxchg for jlong is not
1677 // supported on sparc v8 or pre supports_cx8 intel boxes.
1678 // oldgetTimeNanos for systems which do not support CAS on 64bit jlong
1679 // i.e. sparc v8 and pre supports_cx8 (i486) intel boxes
1680 inline hrtime_t oldgetTimeNanos() {
1681   int gotlock = LOCK_INVALID;
1682   hrtime_t newtime = gethrtime();
1683 
1684   for (;;) {
1685 // grab lock for max_hrtime
1686     int curlock = max_hrtime_lock;
1687     if (curlock & LOCK_BUSY)  continue;
1688     if (gotlock = Atomic::cmpxchg(LOCK_BUSY, &max_hrtime_lock, LOCK_FREE) != LOCK_FREE) continue;
1689     if (newtime > max_hrtime) {
1690       max_hrtime = newtime;
1691     } else {
1692       newtime = max_hrtime;
1693     }
1694     // release lock
1695     max_hrtime_lock = LOCK_FREE;
1696     return newtime;
1697   }
1698 }
1699 // gethrtime can move backwards if read from one cpu and then a different cpu
1700 // getTimeNanos is guaranteed to not move backward on Solaris
1701 inline hrtime_t getTimeNanos() {
1702   if (VM_Version::supports_cx8()) {
1703     const hrtime_t now = gethrtime();
1704     // Use atomic long load since 32-bit x86 uses 2 registers to keep long.
1705     const hrtime_t prev = Atomic::load((volatile jlong*)&max_hrtime);
1706     if (now <= prev)  return prev;   // same or retrograde time;
1707     const hrtime_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&max_hrtime, prev);
1708     assert(obsv >= prev, "invariant");   // Monotonicity
1709     // If the CAS succeeded then we're done and return "now".
1710     // If the CAS failed and the observed value "obs" is >= now then
1711     // we should return "obs".  If the CAS failed and now > obs > prv then
1712     // some other thread raced this thread and installed a new value, in which case
1713     // we could either (a) retry the entire operation, (b) retry trying to install now
1714     // or (c) just return obs.  We use (c).   No loop is required although in some cases
1715     // we might discard a higher "now" value in deference to a slightly lower but freshly
1716     // installed obs value.   That's entirely benign -- it admits no new orderings compared
1717     // to (a) or (b) -- and greatly reduces coherence traffic.
1718     // We might also condition (c) on the magnitude of the delta between obs and now.
1719     // Avoiding excessive CAS operations to hot RW locations is critical.
1720     // See http://blogs.sun.com/dave/entry/cas_and_cache_trivia_invalidate
1721     return (prev == obsv) ? now : obsv ;
1722   } else {
1723     return oldgetTimeNanos();
1724   }
1725 }
1726 
1727 // Time since start-up in seconds to a fine granularity.
1728 // Used by VMSelfDestructTimer and the MemProfiler.
1729 double os::elapsedTime() {
1730   return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz;
1731 }
1732 
1733 jlong os::elapsed_counter() {
1734   return (jlong)(getTimeNanos() - first_hrtime);
1735 }
1736 
1737 jlong os::elapsed_frequency() {
1738    return hrtime_hz;
1739 }
1740 
1741 // Return the real, user, and system times in seconds from an
1742 // arbitrary fixed point in the past.
1743 bool os::getTimesSecs(double* process_real_time,
1744                   double* process_user_time,
1745                   double* process_system_time) {
1746   struct tms ticks;
1747   clock_t real_ticks = times(&ticks);
1748 
1749   if (real_ticks == (clock_t) (-1)) {
1750     return false;
1751   } else {
1752     double ticks_per_second = (double) clock_tics_per_sec;
1753     *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;
1754     *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;
1755     // For consistency return the real time from getTimeNanos()
1756     // converted to seconds.
1757     *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS);
1758 
1759     return true;
1760   }
1761 }
1762 
1763 bool os::supports_vtime() { return true; }
1764 
1765 bool os::enable_vtime() {
1766   int fd = ::open("/proc/self/ctl", O_WRONLY);
1767   if (fd == -1)
1768     return false;
1769 
1770   long cmd[] = { PCSET, PR_MSACCT };
1771   int res = ::write(fd, cmd, sizeof(long) * 2);
1772   ::close(fd);
1773   if (res != sizeof(long) * 2)
1774     return false;
1775 
1776   return true;
1777 }
1778 
1779 bool os::vtime_enabled() {
1780   int fd = ::open("/proc/self/status", O_RDONLY);
1781   if (fd == -1)
1782     return false;
1783 
1784   pstatus_t status;
1785   int res = os::read(fd, (void*) &status, sizeof(pstatus_t));
1786   ::close(fd);
1787   if (res != sizeof(pstatus_t))
1788     return false;
1789 
1790   return status.pr_flags & PR_MSACCT;
1791 }
1792 
1793 double os::elapsedVTime() {
1794   return (double)gethrvtime() / (double)hrtime_hz;
1795 }
1796 
1797 // Used internally for comparisons only
1798 // getTimeMillis guaranteed to not move backwards on Solaris
1799 jlong getTimeMillis() {
1800   jlong nanotime = getTimeNanos();
1801   return (jlong)(nanotime / NANOSECS_PER_MILLISECS);
1802 }
1803 
1804 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis
1805 jlong os::javaTimeMillis() {
1806   timeval t;
1807   if (gettimeofday( &t, NULL) == -1)
1808     fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno)));
1809   return jlong(t.tv_sec) * 1000  +  jlong(t.tv_usec) / 1000;
1810 }
1811 
1812 jlong os::javaTimeNanos() {
1813   return (jlong)getTimeNanos();
1814 }
1815 
1816 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
1817   info_ptr->max_value = ALL_64_BITS;      // gethrtime() uses all 64 bits
1818   info_ptr->may_skip_backward = false;    // not subject to resetting or drifting
1819   info_ptr->may_skip_forward = false;     // not subject to resetting or drifting
1820   info_ptr->kind = JVMTI_TIMER_ELAPSED;   // elapsed not CPU time
1821 }
1822 
1823 char * os::local_time_string(char *buf, size_t buflen) {
1824   struct tm t;
1825   time_t long_time;
1826   time(&long_time);
1827   localtime_r(&long_time, &t);
1828   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",
1829                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
1830                t.tm_hour, t.tm_min, t.tm_sec);
1831   return buf;
1832 }
1833 
1834 // Note: os::shutdown() might be called very early during initialization, or
1835 // called from signal handler. Before adding something to os::shutdown(), make
1836 // sure it is async-safe and can handle partially initialized VM.
1837 void os::shutdown() {
1838 
1839   // allow PerfMemory to attempt cleanup of any persistent resources
1840   perfMemory_exit();
1841 
1842   // needs to remove object in file system
1843   AttachListener::abort();
1844 
1845   // flush buffered output, finish log files
1846   ostream_abort();
1847 
1848   // Check for abort hook
1849   abort_hook_t abort_hook = Arguments::abort_hook();
1850   if (abort_hook != NULL) {
1851     abort_hook();
1852   }
1853 }
1854 
1855 // Note: os::abort() might be called very early during initialization, or
1856 // called from signal handler. Before adding something to os::abort(), make
1857 // sure it is async-safe and can handle partially initialized VM.
1858 void os::abort(bool dump_core) {
1859   os::shutdown();
1860   if (dump_core) {
1861 #ifndef PRODUCT
1862     fdStream out(defaultStream::output_fd());
1863     out.print_raw("Current thread is ");
1864     char buf[16];
1865     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());
1866     out.print_raw_cr(buf);
1867     out.print_raw_cr("Dumping core ...");
1868 #endif
1869     ::abort(); // dump core (for debugging)
1870   }
1871 
1872   ::exit(1);
1873 }
1874 
1875 // Die immediately, no exit hook, no abort hook, no cleanup.
1876 void os::die() {
1877   _exit(-1);
1878 }
1879 
1880 // unused
1881 void os::set_error_file(const char *logfile) {}
1882 
1883 // DLL functions
1884 
1885 const char* os::dll_file_extension() { return ".so"; }
1886 
1887 // This must be hard coded because it's the system's temporary
1888 // directory not the java application's temp directory, ala java.io.tmpdir.
1889 const char* os::get_temp_directory() { return "/tmp"; }
1890 
1891 static bool file_exists(const char* filename) {
1892   struct stat statbuf;
1893   if (filename == NULL || strlen(filename) == 0) {
1894     return false;
1895   }
1896   return os::stat(filename, &statbuf) == 0;
1897 }
1898 
1899 void os::dll_build_name(char* buffer, size_t buflen,
1900                         const char* pname, const char* fname) {
1901   const size_t pnamelen = pname ? strlen(pname) : 0;
1902 
1903   // Quietly truncate on buffer overflow.  Should be an error.
1904   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {
1905     *buffer = '\0';
1906     return;
1907   }
1908 
1909   if (pnamelen == 0) {
1910     snprintf(buffer, buflen, "lib%s.so", fname);
1911   } else if (strchr(pname, *os::path_separator()) != NULL) {
1912     int n;
1913     char** pelements = split_path(pname, &n);
1914     for (int i = 0 ; i < n ; i++) {
1915       // really shouldn't be NULL but what the heck, check can't hurt
1916       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
1917         continue; // skip the empty path values
1918       }
1919       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);
1920       if (file_exists(buffer)) {
1921         break;
1922       }
1923     }
1924     // release the storage
1925     for (int i = 0 ; i < n ; i++) {
1926       if (pelements[i] != NULL) {
1927         FREE_C_HEAP_ARRAY(char, pelements[i]);
1928       }
1929     }
1930     if (pelements != NULL) {
1931       FREE_C_HEAP_ARRAY(char*, pelements);
1932     }
1933   } else {
1934     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
1935   }
1936 }
1937 
1938 const char* os::get_current_directory(char *buf, int buflen) {
1939   return getcwd(buf, buflen);
1940 }
1941 
1942 // check if addr is inside libjvm[_g].so
1943 bool os::address_is_in_vm(address addr) {
1944   static address libjvm_base_addr;
1945   Dl_info dlinfo;
1946 
1947   if (libjvm_base_addr == NULL) {
1948     dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo);
1949     libjvm_base_addr = (address)dlinfo.dli_fbase;
1950     assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");
1951   }
1952 
1953   if (dladdr((void *)addr, &dlinfo)) {
1954     if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;
1955   }
1956 
1957   return false;
1958 }
1959 
1960 typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int);
1961 static dladdr1_func_type dladdr1_func = NULL;
1962 
1963 bool os::dll_address_to_function_name(address addr, char *buf,
1964                                       int buflen, int * offset) {
1965   Dl_info dlinfo;
1966 
1967   // dladdr1_func was initialized in os::init()
1968   if (dladdr1_func){
1969       // yes, we have dladdr1
1970 
1971       // Support for dladdr1 is checked at runtime; it may be
1972       // available even if the vm is built on a machine that does
1973       // not have dladdr1 support.  Make sure there is a value for
1974       // RTLD_DL_SYMENT.
1975       #ifndef RTLD_DL_SYMENT
1976       #define RTLD_DL_SYMENT 1
1977       #endif
1978       Sym * info;
1979       if (dladdr1_func((void *)addr, &dlinfo, (void **)&info,
1980                        RTLD_DL_SYMENT)) {
1981         if ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr) {
1982           if (buf != NULL) {
1983             if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen))
1984               jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);
1985             }
1986             if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
1987             return true;
1988         }
1989       }
1990       if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) {
1991         if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
1992           dlinfo.dli_fname, buf, buflen, offset) == Decoder::no_error) {
1993           return true;
1994         }
1995       }
1996       if (buf != NULL) buf[0] = '\0';
1997       if (offset != NULL) *offset  = -1;
1998       return false;
1999   } else {
2000       // no, only dladdr is available
2001       if (dladdr((void *)addr, &dlinfo)) {
2002         if (buf != NULL) {
2003           if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen))
2004             jio_snprintf(buf, buflen, dlinfo.dli_sname);
2005         }
2006         if (offset != NULL) *offset = addr - (address)dlinfo.dli_saddr;
2007         return true;
2008       } else if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) {
2009         if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
2010           dlinfo.dli_fname, buf, buflen, offset) == Decoder::no_error) {
2011           return true;
2012         }
2013       }
2014       if (buf != NULL) buf[0] = '\0';
2015       if (offset != NULL) *offset  = -1;
2016       return false;
2017   }
2018 }
2019 
2020 bool os::dll_address_to_library_name(address addr, char* buf,
2021                                      int buflen, int* offset) {
2022   Dl_info dlinfo;
2023 
2024   if (dladdr((void*)addr, &dlinfo)){
2025      if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);
2026      if (offset) *offset = addr - (address)dlinfo.dli_fbase;
2027      return true;
2028   } else {
2029      if (buf) buf[0] = '\0';
2030      if (offset) *offset = -1;
2031      return false;
2032   }
2033 }
2034 
2035 // Prints the names and full paths of all opened dynamic libraries
2036 // for current process
2037 void os::print_dll_info(outputStream * st) {
2038     Dl_info dli;
2039     void *handle;
2040     Link_map *map;
2041     Link_map *p;
2042 
2043     st->print_cr("Dynamic libraries:"); st->flush();
2044 
2045     if (!dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli)) {
2046         st->print_cr("Error: Cannot print dynamic libraries.");
2047         return;
2048     }
2049     handle = dlopen(dli.dli_fname, RTLD_LAZY);
2050     if (handle == NULL) {
2051         st->print_cr("Error: Cannot print dynamic libraries.");
2052         return;
2053     }
2054     dlinfo(handle, RTLD_DI_LINKMAP, &map);
2055     if (map == NULL) {
2056         st->print_cr("Error: Cannot print dynamic libraries.");
2057         return;
2058     }
2059 
2060     while (map->l_prev != NULL)
2061         map = map->l_prev;
2062 
2063     while (map != NULL) {
2064         st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);
2065         map = map->l_next;
2066     }
2067 
2068     dlclose(handle);
2069 }
2070 
2071   // Loads .dll/.so and
2072   // in case of error it checks if .dll/.so was built for the
2073   // same architecture as Hotspot is running on
2074 
2075 void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
2076 {
2077   void * result= ::dlopen(filename, RTLD_LAZY);
2078   if (result != NULL) {
2079     // Successful loading
2080     return result;
2081   }
2082 
2083   Elf32_Ehdr elf_head;
2084 
2085   // Read system error message into ebuf
2086   // It may or may not be overwritten below
2087   ::strncpy(ebuf, ::dlerror(), ebuflen-1);
2088   ebuf[ebuflen-1]='\0';
2089   int diag_msg_max_length=ebuflen-strlen(ebuf);
2090   char* diag_msg_buf=ebuf+strlen(ebuf);
2091 
2092   if (diag_msg_max_length==0) {
2093     // No more space in ebuf for additional diagnostics message
2094     return NULL;
2095   }
2096 
2097 
2098   int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);
2099 
2100   if (file_descriptor < 0) {
2101     // Can't open library, report dlerror() message
2102     return NULL;
2103   }
2104 
2105   bool failed_to_read_elf_head=
2106     (sizeof(elf_head)!=
2107         (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;
2108 
2109   ::close(file_descriptor);
2110   if (failed_to_read_elf_head) {
2111     // file i/o error - report dlerror() msg
2112     return NULL;
2113   }
2114 
2115   typedef struct {
2116     Elf32_Half  code;         // Actual value as defined in elf.h
2117     Elf32_Half  compat_class; // Compatibility of archs at VM's sense
2118     char        elf_class;    // 32 or 64 bit
2119     char        endianess;    // MSB or LSB
2120     char*       name;         // String representation
2121   } arch_t;
2122 
2123   static const arch_t arch_array[]={
2124     {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
2125     {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
2126     {EM_IA_64,       EM_IA_64,   ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
2127     {EM_X86_64,      EM_X86_64,  ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},
2128     {EM_SPARC,       EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
2129     {EM_SPARC32PLUS, EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},
2130     {EM_SPARCV9,     EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
2131     {EM_PPC,         EM_PPC,     ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
2132     {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
2133     {EM_ARM,         EM_ARM,     ELFCLASS32, ELFDATA2LSB, (char*)"ARM 32"}
2134   };
2135 
2136   #if  (defined IA32)
2137     static  Elf32_Half running_arch_code=EM_386;
2138   #elif   (defined AMD64)
2139     static  Elf32_Half running_arch_code=EM_X86_64;
2140   #elif  (defined IA64)
2141     static  Elf32_Half running_arch_code=EM_IA_64;
2142   #elif  (defined __sparc) && (defined _LP64)
2143     static  Elf32_Half running_arch_code=EM_SPARCV9;
2144   #elif  (defined __sparc) && (!defined _LP64)
2145     static  Elf32_Half running_arch_code=EM_SPARC;
2146   #elif  (defined __powerpc64__)
2147     static  Elf32_Half running_arch_code=EM_PPC64;
2148   #elif  (defined __powerpc__)
2149     static  Elf32_Half running_arch_code=EM_PPC;
2150   #elif (defined ARM)
2151     static  Elf32_Half running_arch_code=EM_ARM;
2152   #else
2153     #error Method os::dll_load requires that one of following is defined:\
2154          IA32, AMD64, IA64, __sparc, __powerpc__, ARM, ARM
2155   #endif
2156 
2157   // Identify compatability class for VM's architecture and library's architecture
2158   // Obtain string descriptions for architectures
2159 
2160   arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
2161   int running_arch_index=-1;
2162 
2163   for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {
2164     if (running_arch_code == arch_array[i].code) {
2165       running_arch_index    = i;
2166     }
2167     if (lib_arch.code == arch_array[i].code) {
2168       lib_arch.compat_class = arch_array[i].compat_class;
2169       lib_arch.name         = arch_array[i].name;
2170     }
2171   }
2172 
2173   assert(running_arch_index != -1,
2174     "Didn't find running architecture code (running_arch_code) in arch_array");
2175   if (running_arch_index == -1) {
2176     // Even though running architecture detection failed
2177     // we may still continue with reporting dlerror() message
2178     return NULL;
2179   }
2180 
2181   if (lib_arch.endianess != arch_array[running_arch_index].endianess) {
2182     ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");
2183     return NULL;
2184   }
2185 
2186   if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {
2187     ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");
2188     return NULL;
2189   }
2190 
2191   if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
2192     if ( lib_arch.name!=NULL ) {
2193       ::snprintf(diag_msg_buf, diag_msg_max_length-1,
2194         " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
2195         lib_arch.name, arch_array[running_arch_index].name);
2196     } else {
2197       ::snprintf(diag_msg_buf, diag_msg_max_length-1,
2198       " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
2199         lib_arch.code,
2200         arch_array[running_arch_index].name);
2201     }
2202   }
2203 
2204   return NULL;
2205 }
2206 
2207 void* os::dll_lookup(void* handle, const char* name) {
2208   return dlsym(handle, name);
2209 }
2210 
2211 int os::stat(const char *path, struct stat *sbuf) {
2212   char pathbuf[MAX_PATH];
2213   if (strlen(path) > MAX_PATH - 1) {
2214     errno = ENAMETOOLONG;
2215     return -1;
2216   }
2217   os::native_path(strcpy(pathbuf, path));
2218   return ::stat(pathbuf, sbuf);
2219 }
2220 
2221 static bool _print_ascii_file(const char* filename, outputStream* st) {
2222   int fd = ::open(filename, O_RDONLY);
2223   if (fd == -1) {
2224      return false;
2225   }
2226 
2227   char buf[32];
2228   int bytes;
2229   while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) {
2230     st->print_raw(buf, bytes);
2231   }
2232 
2233   ::close(fd);
2234 
2235   return true;
2236 }
2237 
2238 void os::print_os_info(outputStream* st) {
2239   st->print("OS:");
2240 
2241   if (!_print_ascii_file("/etc/release", st)) {
2242     st->print("Solaris");
2243   }
2244   st->cr();
2245 
2246   // kernel
2247   st->print("uname:");
2248   struct utsname name;
2249   uname(&name);
2250   st->print(name.sysname); st->print(" ");
2251   st->print(name.release); st->print(" ");
2252   st->print(name.version); st->print(" ");
2253   st->print(name.machine);
2254 
2255   // libthread
2256   if (os::Solaris::T2_libthread()) st->print("  (T2 libthread)");
2257   else st->print("  (T1 libthread)");
2258   st->cr();
2259 
2260   // rlimit
2261   st->print("rlimit:");
2262   struct rlimit rlim;
2263 
2264   st->print(" STACK ");
2265   getrlimit(RLIMIT_STACK, &rlim);
2266   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2267   else st->print("%uk", rlim.rlim_cur >> 10);
2268 
2269   st->print(", CORE ");
2270   getrlimit(RLIMIT_CORE, &rlim);
2271   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2272   else st->print("%uk", rlim.rlim_cur >> 10);
2273 
2274   st->print(", NOFILE ");
2275   getrlimit(RLIMIT_NOFILE, &rlim);
2276   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2277   else st->print("%d", rlim.rlim_cur);
2278 
2279   st->print(", AS ");
2280   getrlimit(RLIMIT_AS, &rlim);
2281   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");
2282   else st->print("%uk", rlim.rlim_cur >> 10);
2283   st->cr();
2284 
2285   // load average
2286   st->print("load average:");
2287   double loadavg[3];
2288   os::loadavg(loadavg, 3);
2289   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);
2290   st->cr();
2291 }
2292 
2293 
2294 static bool check_addr0(outputStream* st) {
2295   jboolean status = false;
2296   int fd = ::open("/proc/self/map",O_RDONLY);
2297   if (fd >= 0) {
2298     prmap_t p;
2299     while(::read(fd, &p, sizeof(p)) > 0) {
2300       if (p.pr_vaddr == 0x0) {
2301         st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);
2302         st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);
2303         st->print("Access:");
2304         st->print("%s",(p.pr_mflags & MA_READ)  ? "r" : "-");
2305         st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-");
2306         st->print("%s",(p.pr_mflags & MA_EXEC)  ? "x" : "-");
2307         st->cr();
2308         status = true;
2309       }
2310       ::close(fd);
2311     }
2312   }
2313   return status;
2314 }
2315 
2316 void os::print_memory_info(outputStream* st) {
2317   st->print("Memory:");
2318   st->print(" %dk page", os::vm_page_size()>>10);
2319   st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10);
2320   st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10);
2321   st->cr();
2322   (void) check_addr0(st);
2323 }
2324 
2325 // Taken from /usr/include/sys/machsig.h  Supposed to be architecture specific
2326 // but they're the same for all the solaris architectures that we support.
2327 const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",
2328                           "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",
2329                           "ILL_COPROC", "ILL_BADSTK" };
2330 
2331 const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",
2332                           "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",
2333                           "FPE_FLTINV", "FPE_FLTSUB" };
2334 
2335 const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };
2336 
2337 const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };
2338 
2339 void os::print_siginfo(outputStream* st, void* siginfo) {
2340   st->print("siginfo:");
2341 
2342   const int buflen = 100;
2343   char buf[buflen];
2344   siginfo_t *si = (siginfo_t*)siginfo;
2345   st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
2346   char *err = strerror(si->si_errno);
2347   if (si->si_errno != 0 && err != NULL) {
2348     st->print("si_errno=%s", err);
2349   } else {
2350     st->print("si_errno=%d", si->si_errno);
2351   }
2352   const int c = si->si_code;
2353   assert(c > 0, "unexpected si_code");
2354   switch (si->si_signo) {
2355   case SIGILL:
2356     st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);
2357     st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2358     break;
2359   case SIGFPE:
2360     st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);
2361     st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2362     break;
2363   case SIGSEGV:
2364     st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);
2365     st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2366     break;
2367   case SIGBUS:
2368     st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);
2369     st->print(", si_addr=" PTR_FORMAT, si->si_addr);
2370     break;
2371   default:
2372     st->print(", si_code=%d", si->si_code);
2373     // no si_addr
2374   }
2375 
2376   if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
2377       UseSharedSpaces) {
2378     FileMapInfo* mapinfo = FileMapInfo::current_info();
2379     if (mapinfo->is_in_shared_space(si->si_addr)) {
2380       st->print("\n\nError accessing class data sharing archive."   \
2381                 " Mapped file inaccessible during execution, "      \
2382                 " possible disk/network problem.");
2383     }
2384   }
2385   st->cr();
2386 }
2387 
2388 // Moved from whole group, because we need them here for diagnostic
2389 // prints.
2390 #define OLDMAXSIGNUM 32
2391 static int Maxsignum = 0;
2392 static int *ourSigFlags = NULL;
2393 
2394 extern "C" void sigINTRHandler(int, siginfo_t*, void*);
2395 
2396 int os::Solaris::get_our_sigflags(int sig) {
2397   assert(ourSigFlags!=NULL, "signal data structure not initialized");
2398   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2399   return ourSigFlags[sig];
2400 }
2401 
2402 void os::Solaris::set_our_sigflags(int sig, int flags) {
2403   assert(ourSigFlags!=NULL, "signal data structure not initialized");
2404   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");
2405   ourSigFlags[sig] = flags;
2406 }
2407 
2408 
2409 static const char* get_signal_handler_name(address handler,
2410                                            char* buf, int buflen) {
2411   int offset;
2412   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);
2413   if (found) {
2414     // skip directory names
2415     const char *p1, *p2;
2416     p1 = buf;
2417     size_t len = strlen(os::file_separator());
2418     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;
2419     jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);
2420   } else {
2421     jio_snprintf(buf, buflen, PTR_FORMAT, handler);
2422   }
2423   return buf;
2424 }
2425 
2426 static void print_signal_handler(outputStream* st, int sig,
2427                                   char* buf, size_t buflen) {
2428   struct sigaction sa;
2429 
2430   sigaction(sig, NULL, &sa);
2431 
2432   st->print("%s: ", os::exception_name(sig, buf, buflen));
2433 
2434   address handler = (sa.sa_flags & SA_SIGINFO)
2435                   ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)
2436                   : CAST_FROM_FN_PTR(address, sa.sa_handler);
2437 
2438   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {
2439     st->print("SIG_DFL");
2440   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {
2441     st->print("SIG_IGN");
2442   } else {
2443     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
2444   }
2445 
2446   st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);
2447 
2448   address rh = VMError::get_resetted_sighandler(sig);
2449   // May be, handler was resetted by VMError?
2450   if(rh != NULL) {
2451     handler = rh;
2452     sa.sa_flags = VMError::get_resetted_sigflags(sig);
2453   }
2454 
2455   st->print(", sa_flags="   PTR32_FORMAT, sa.sa_flags);
2456 
2457   // Check: is it our handler?
2458   if(handler == CAST_FROM_FN_PTR(address, signalHandler) ||
2459      handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {
2460     // It is our signal handler
2461     // check for flags
2462     if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {
2463       st->print(
2464         ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
2465         os::Solaris::get_our_sigflags(sig));
2466     }
2467   }
2468   st->cr();
2469 }
2470 
2471 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {
2472   st->print_cr("Signal Handlers:");
2473   print_signal_handler(st, SIGSEGV, buf, buflen);
2474   print_signal_handler(st, SIGBUS , buf, buflen);
2475   print_signal_handler(st, SIGFPE , buf, buflen);
2476   print_signal_handler(st, SIGPIPE, buf, buflen);
2477   print_signal_handler(st, SIGXFSZ, buf, buflen);
2478   print_signal_handler(st, SIGILL , buf, buflen);
2479   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);
2480   print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);
2481   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
2482   print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);
2483   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
2484   print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);
2485   print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);
2486   print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);
2487 }
2488 
2489 static char saved_jvm_path[MAXPATHLEN] = { 0 };
2490 
2491 // Find the full path to the current module, libjvm.so or libjvm_g.so
2492 void os::jvm_path(char *buf, jint buflen) {
2493   // Error checking.
2494   if (buflen < MAXPATHLEN) {
2495     assert(false, "must use a large-enough buffer");
2496     buf[0] = '\0';
2497     return;
2498   }
2499   // Lazy resolve the path to current module.
2500   if (saved_jvm_path[0] != 0) {
2501     strcpy(buf, saved_jvm_path);
2502     return;
2503   }
2504 
2505   Dl_info dlinfo;
2506   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);
2507   assert(ret != 0, "cannot locate libjvm");
2508   realpath((char *)dlinfo.dli_fname, buf);
2509 
2510   if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) {
2511     // Support for the gamma launcher.  Typical value for buf is
2512     // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".  If "/jre/lib/" appears at
2513     // the right place in the string, then assume we are installed in a JDK and
2514     // we're done.  Otherwise, check for a JAVA_HOME environment variable and fix
2515     // up the path so it looks like libjvm.so is installed there (append a
2516     // fake suffix hotspot/libjvm.so).
2517     const char *p = buf + strlen(buf) - 1;
2518     for (int count = 0; p > buf && count < 5; ++count) {
2519       for (--p; p > buf && *p != '/'; --p)
2520         /* empty */ ;
2521     }
2522 
2523     if (strncmp(p, "/jre/lib/", 9) != 0) {
2524       // Look for JAVA_HOME in the environment.
2525       char* java_home_var = ::getenv("JAVA_HOME");
2526       if (java_home_var != NULL && java_home_var[0] != 0) {
2527         char cpu_arch[12];
2528         char* jrelib_p;
2529         int   len;
2530         sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));
2531 #ifdef _LP64
2532         // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.
2533         if (strcmp(cpu_arch, "sparc") == 0) {
2534           strcat(cpu_arch, "v9");
2535         } else if (strcmp(cpu_arch, "i386") == 0) {
2536           strcpy(cpu_arch, "amd64");
2537         }
2538 #endif
2539         // Check the current module name "libjvm.so" or "libjvm_g.so".
2540         p = strrchr(buf, '/');
2541         assert(strstr(p, "/libjvm") == p, "invalid library name");
2542         p = strstr(p, "_g") ? "_g" : "";
2543 
2544         realpath(java_home_var, buf);
2545         // determine if this is a legacy image or modules image
2546         // modules image doesn't have "jre" subdirectory
2547         len = strlen(buf);
2548         jrelib_p = buf + len;
2549         snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch);
2550         if (0 != access(buf, F_OK)) {
2551           snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch);
2552         }
2553 
2554         if (0 == access(buf, F_OK)) {
2555           // Use current module name "libjvm[_g].so" instead of
2556           // "libjvm"debug_only("_g")".so" since for fastdebug version
2557           // we should have "libjvm.so" but debug_only("_g") adds "_g"!
2558           len = strlen(buf);
2559           snprintf(buf + len, buflen-len, "/hotspot/libjvm%s.so", p);
2560         } else {
2561           // Go back to path of .so
2562           realpath((char *)dlinfo.dli_fname, buf);
2563         }
2564       }
2565     }
2566   }
2567 
2568   strcpy(saved_jvm_path, buf);
2569 }
2570 
2571 
2572 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {
2573   // no prefix required, not even "_"
2574 }
2575 
2576 
2577 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {
2578   // no suffix required
2579 }
2580 
2581 // This method is a copy of JDK's sysGetLastErrorString
2582 // from src/solaris/hpi/src/system_md.c
2583 
2584 size_t os::lasterror(char *buf, size_t len) {
2585 
2586   if (errno == 0)  return 0;
2587 
2588   const char *s = ::strerror(errno);
2589   size_t n = ::strlen(s);
2590   if (n >= len) {
2591     n = len - 1;
2592   }
2593   ::strncpy(buf, s, n);
2594   buf[n] = '\0';
2595   return n;
2596 }
2597 
2598 
2599 // sun.misc.Signal
2600 
2601 extern "C" {
2602   static void UserHandler(int sig, void *siginfo, void *context) {
2603     // Ctrl-C is pressed during error reporting, likely because the error
2604     // handler fails to abort. Let VM die immediately.
2605     if (sig == SIGINT && is_error_reported()) {
2606        os::die();
2607     }
2608 
2609     os::signal_notify(sig);
2610     // We do not need to reinstate the signal handler each time...
2611   }
2612 }
2613 
2614 void* os::user_handler() {
2615   return CAST_FROM_FN_PTR(void*, UserHandler);
2616 }
2617 
2618 extern "C" {
2619   typedef void (*sa_handler_t)(int);
2620   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);
2621 }
2622 
2623 void* os::signal(int signal_number, void* handler) {
2624   struct sigaction sigAct, oldSigAct;
2625   sigfillset(&(sigAct.sa_mask));
2626   sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;
2627   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
2628 
2629   if (sigaction(signal_number, &sigAct, &oldSigAct))
2630     // -1 means registration failed
2631     return (void *)-1;
2632 
2633   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
2634 }
2635 
2636 void os::signal_raise(int signal_number) {
2637   raise(signal_number);
2638 }
2639 
2640 /*
2641  * The following code is moved from os.cpp for making this
2642  * code platform specific, which it is by its very nature.
2643  */
2644 
2645 // a counter for each possible signal value
2646 static int Sigexit = 0;
2647 static int Maxlibjsigsigs;
2648 static jint *pending_signals = NULL;
2649 static int *preinstalled_sigs = NULL;
2650 static struct sigaction *chainedsigactions = NULL;
2651 static sema_t sig_sem;
2652 typedef int (*version_getting_t)();
2653 version_getting_t os::Solaris::get_libjsig_version = NULL;
2654 static int libjsigversion = NULL;
2655 
2656 int os::sigexitnum_pd() {
2657   assert(Sigexit > 0, "signal memory not yet initialized");
2658   return Sigexit;
2659 }
2660 
2661 void os::Solaris::init_signal_mem() {
2662   // Initialize signal structures
2663   Maxsignum = SIGRTMAX;
2664   Sigexit = Maxsignum+1;
2665   assert(Maxsignum >0, "Unable to obtain max signal number");
2666 
2667   Maxlibjsigsigs = Maxsignum;
2668 
2669   // pending_signals has one int per signal
2670   // The additional signal is for SIGEXIT - exit signal to signal_thread
2671   pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1));
2672   memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
2673 
2674   if (UseSignalChaining) {
2675      chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
2676        * (Maxsignum + 1));
2677      memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
2678      preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1));
2679      memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
2680   }
2681   ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ));
2682   memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
2683 }
2684 
2685 void os::signal_init_pd() {
2686   int ret;
2687 
2688   ret = ::sema_init(&sig_sem, 0, NULL, NULL);
2689   assert(ret == 0, "sema_init() failed");
2690 }
2691 
2692 void os::signal_notify(int signal_number) {
2693   int ret;
2694 
2695   Atomic::inc(&pending_signals[signal_number]);
2696   ret = ::sema_post(&sig_sem);
2697   assert(ret == 0, "sema_post() failed");
2698 }
2699 
2700 static int check_pending_signals(bool wait_for_signal) {
2701   int ret;
2702   while (true) {
2703     for (int i = 0; i < Sigexit + 1; i++) {
2704       jint n = pending_signals[i];
2705       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {
2706         return i;
2707       }
2708     }
2709     if (!wait_for_signal) {
2710       return -1;
2711     }
2712     JavaThread *thread = JavaThread::current();
2713     ThreadBlockInVM tbivm(thread);
2714 
2715     bool threadIsSuspended;
2716     do {
2717       thread->set_suspend_equivalent();
2718       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
2719       while((ret = ::sema_wait(&sig_sem)) == EINTR)
2720           ;
2721       assert(ret == 0, "sema_wait() failed");
2722 
2723       // were we externally suspended while we were waiting?
2724       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
2725       if (threadIsSuspended) {
2726         //
2727         // The semaphore has been incremented, but while we were waiting
2728         // another thread suspended us. We don't want to continue running
2729         // while suspended because that would surprise the thread that
2730         // suspended us.
2731         //
2732         ret = ::sema_post(&sig_sem);
2733         assert(ret == 0, "sema_post() failed");
2734 
2735         thread->java_suspend_self();
2736       }
2737     } while (threadIsSuspended);
2738   }
2739 }
2740 
2741 int os::signal_lookup() {
2742   return check_pending_signals(false);
2743 }
2744 
2745 int os::signal_wait() {
2746   return check_pending_signals(true);
2747 }
2748 
2749 ////////////////////////////////////////////////////////////////////////////////
2750 // Virtual Memory
2751 
2752 static int page_size = -1;
2753 
2754 // The mmap MAP_ALIGN flag is supported on Solaris 9 and later.  init_2() will
2755 // clear this var if support is not available.
2756 static bool has_map_align = true;
2757 
2758 int os::vm_page_size() {
2759   assert(page_size != -1, "must call os::init");
2760   return page_size;
2761 }
2762 
2763 // Solaris allocates memory by pages.
2764 int os::vm_allocation_granularity() {
2765   assert(page_size != -1, "must call os::init");
2766   return page_size;
2767 }
2768 
2769 bool os::commit_memory(char* addr, size_t bytes, bool exec) {
2770   int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
2771   size_t size = bytes;
2772   return
2773      NULL != Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
2774 }
2775 
2776 bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint,
2777                        bool exec) {
2778   if (commit_memory(addr, bytes, exec)) {
2779     if (UseMPSS && alignment_hint > (size_t)vm_page_size()) {
2780       // If the large page size has been set and the VM
2781       // is using large pages, use the large page size
2782       // if it is smaller than the alignment hint. This is
2783       // a case where the VM wants to use a larger alignment size
2784       // for its own reasons but still want to use large pages
2785       // (which is what matters to setting the mpss range.
2786       size_t page_size = 0;
2787       if (large_page_size() < alignment_hint) {
2788         assert(UseLargePages, "Expected to be here for large page use only");
2789         page_size = large_page_size();
2790       } else {
2791         // If the alignment hint is less than the large page
2792         // size, the VM wants a particular alignment (thus the hint)
2793         // for internal reasons.  Try to set the mpss range using
2794         // the alignment_hint.
2795         page_size = alignment_hint;
2796       }
2797       // Since this is a hint, ignore any failures.
2798       (void)Solaris::set_mpss_range(addr, bytes, page_size);
2799     }
2800     return true;
2801   }
2802   return false;
2803 }
2804 
2805 // Uncommit the pages in a specified region.
2806 void os::free_memory(char* addr, size_t bytes) {
2807   if (madvise(addr, bytes, MADV_FREE) < 0) {
2808     debug_only(warning("MADV_FREE failed."));
2809     return;
2810   }
2811 }
2812 
2813 bool os::create_stack_guard_pages(char* addr, size_t size) {
2814   return os::commit_memory(addr, size);
2815 }
2816 
2817 bool os::remove_stack_guard_pages(char* addr, size_t size) {
2818   return os::uncommit_memory(addr, size);
2819 }
2820 
2821 // Change the page size in a given range.
2822 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
2823   assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
2824   assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
2825   Solaris::set_mpss_range(addr, bytes, alignment_hint);
2826 }
2827 
2828 // Tell the OS to make the range local to the first-touching LWP
2829 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {
2830   assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2831   if (madvise(addr, bytes, MADV_ACCESS_LWP) < 0) {
2832     debug_only(warning("MADV_ACCESS_LWP failed."));
2833   }
2834 }
2835 
2836 // Tell the OS that this range would be accessed from different LWPs.
2837 void os::numa_make_global(char *addr, size_t bytes) {
2838   assert((intptr_t)addr % os::vm_page_size() == 0, "Address should be page-aligned.");
2839   if (madvise(addr, bytes, MADV_ACCESS_MANY) < 0) {
2840     debug_only(warning("MADV_ACCESS_MANY failed."));
2841   }
2842 }
2843 
2844 // Get the number of the locality groups.
2845 size_t os::numa_get_groups_num() {
2846   size_t n = Solaris::lgrp_nlgrps(Solaris::lgrp_cookie());
2847   return n != -1 ? n : 1;
2848 }
2849 
2850 // Get a list of leaf locality groups. A leaf lgroup is group that
2851 // doesn't have any children. Typical leaf group is a CPU or a CPU/memory
2852 // board. An LWP is assigned to one of these groups upon creation.
2853 size_t os::numa_get_leaf_groups(int *ids, size_t size) {
2854    if ((ids[0] = Solaris::lgrp_root(Solaris::lgrp_cookie())) == -1) {
2855      ids[0] = 0;
2856      return 1;
2857    }
2858    int result_size = 0, top = 1, bottom = 0, cur = 0;
2859    for (int k = 0; k < size; k++) {
2860      int r = Solaris::lgrp_children(Solaris::lgrp_cookie(), ids[cur],
2861                                     (Solaris::lgrp_id_t*)&ids[top], size - top);
2862      if (r == -1) {
2863        ids[0] = 0;
2864        return 1;
2865      }
2866      if (!r) {
2867        // That's a leaf node.
2868        assert (bottom <= cur, "Sanity check");
2869        // Check if the node has memory
2870        if (Solaris::lgrp_resources(Solaris::lgrp_cookie(), ids[cur],
2871                                    NULL, 0, LGRP_RSRC_MEM) > 0) {
2872          ids[bottom++] = ids[cur];
2873        }
2874      }
2875      top += r;
2876      cur++;
2877    }
2878    if (bottom == 0) {
2879      // Handle a situation, when the OS reports no memory available.
2880      // Assume UMA architecture.
2881      ids[0] = 0;
2882      return 1;
2883    }
2884    return bottom;
2885 }
2886 
2887 // Detect the topology change. Typically happens during CPU plugging-unplugging.
2888 bool os::numa_topology_changed() {
2889   int is_stale = Solaris::lgrp_cookie_stale(Solaris::lgrp_cookie());
2890   if (is_stale != -1 && is_stale) {
2891     Solaris::lgrp_fini(Solaris::lgrp_cookie());
2892     Solaris::lgrp_cookie_t c = Solaris::lgrp_init(Solaris::LGRP_VIEW_CALLER);
2893     assert(c != 0, "Failure to initialize LGRP API");
2894     Solaris::set_lgrp_cookie(c);
2895     return true;
2896   }
2897   return false;
2898 }
2899 
2900 // Get the group id of the current LWP.
2901 int os::numa_get_group_id() {
2902   int lgrp_id = Solaris::lgrp_home(P_LWPID, P_MYID);
2903   if (lgrp_id == -1) {
2904     return 0;
2905   }
2906   const int size = os::numa_get_groups_num();
2907   int *ids = (int*)alloca(size * sizeof(int));
2908 
2909   // Get the ids of all lgroups with memory; r is the count.
2910   int r = Solaris::lgrp_resources(Solaris::lgrp_cookie(), lgrp_id,
2911                                   (Solaris::lgrp_id_t*)ids, size, LGRP_RSRC_MEM);
2912   if (r <= 0) {
2913     return 0;
2914   }
2915   return ids[os::random() % r];
2916 }
2917 
2918 // Request information about the page.
2919 bool os::get_page_info(char *start, page_info* info) {
2920   const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2921   uint64_t addr = (uintptr_t)start;
2922   uint64_t outdata[2];
2923   uint_t validity = 0;
2924 
2925   if (os::Solaris::meminfo(&addr, 1, info_types, 2, outdata, &validity) < 0) {
2926     return false;
2927   }
2928 
2929   info->size = 0;
2930   info->lgrp_id = -1;
2931 
2932   if ((validity & 1) != 0) {
2933     if ((validity & 2) != 0) {
2934       info->lgrp_id = outdata[0];
2935     }
2936     if ((validity & 4) != 0) {
2937       info->size = outdata[1];
2938     }
2939     return true;
2940   }
2941   return false;
2942 }
2943 
2944 // Scan the pages from start to end until a page different than
2945 // the one described in the info parameter is encountered.
2946 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
2947   const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
2948   const size_t types = sizeof(info_types) / sizeof(info_types[0]);
2949   uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT];
2950   uint_t validity[MAX_MEMINFO_CNT];
2951 
2952   size_t page_size = MAX2((size_t)os::vm_page_size(), page_expected->size);
2953   uint64_t p = (uint64_t)start;
2954   while (p < (uint64_t)end) {
2955     addrs[0] = p;
2956     size_t addrs_count = 1;
2957     while (addrs_count < MAX_MEMINFO_CNT && addrs[addrs_count - 1] < (uint64_t)end) {
2958       addrs[addrs_count] = addrs[addrs_count - 1] + page_size;
2959       addrs_count++;
2960     }
2961 
2962     if (os::Solaris::meminfo(addrs, addrs_count, info_types, types, outdata, validity) < 0) {
2963       return NULL;
2964     }
2965 
2966     size_t i = 0;
2967     for (; i < addrs_count; i++) {
2968       if ((validity[i] & 1) != 0) {
2969         if ((validity[i] & 4) != 0) {
2970           if (outdata[types * i + 1] != page_expected->size) {
2971             break;
2972           }
2973         } else
2974           if (page_expected->size != 0) {
2975             break;
2976           }
2977 
2978         if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) {
2979           if (outdata[types * i] != page_expected->lgrp_id) {
2980             break;
2981           }
2982         }
2983       } else {
2984         return NULL;
2985       }
2986     }
2987 
2988     if (i != addrs_count) {
2989       if ((validity[i] & 2) != 0) {
2990         page_found->lgrp_id = outdata[types * i];
2991       } else {
2992         page_found->lgrp_id = -1;
2993       }
2994       if ((validity[i] & 4) != 0) {
2995         page_found->size = outdata[types * i + 1];
2996       } else {
2997         page_found->size = 0;
2998       }
2999       return (char*)addrs[i];
3000     }
3001 
3002     p = addrs[addrs_count - 1] + page_size;
3003   }
3004   return end;
3005 }
3006 
3007 bool os::uncommit_memory(char* addr, size_t bytes) {
3008   size_t size = bytes;
3009   // Map uncommitted pages PROT_NONE so we fail early if we touch an
3010   // uncommitted page. Otherwise, the read/write might succeed if we
3011   // have enough swap space to back the physical page.
3012   return
3013     NULL != Solaris::mmap_chunk(addr, size,
3014                                 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE,
3015                                 PROT_NONE);
3016 }
3017 
3018 char* os::Solaris::mmap_chunk(char *addr, size_t size, int flags, int prot) {
3019   char *b = (char *)mmap(addr, size, prot, flags, os::Solaris::_dev_zero_fd, 0);
3020 
3021   if (b == MAP_FAILED) {
3022     return NULL;
3023   }
3024   return b;
3025 }
3026 
3027 char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) {
3028   char* addr = requested_addr;
3029   int flags = MAP_PRIVATE | MAP_NORESERVE;
3030 
3031   assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap");
3032 
3033   if (fixed) {
3034     flags |= MAP_FIXED;
3035   } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) {
3036     flags |= MAP_ALIGN;
3037     addr = (char*) alignment_hint;
3038   }
3039 
3040   // Map uncommitted pages PROT_NONE so we fail early if we touch an
3041   // uncommitted page. Otherwise, the read/write might succeed if we
3042   // have enough swap space to back the physical page.
3043   return mmap_chunk(addr, bytes, flags, PROT_NONE);
3044 }
3045 
3046 char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
3047   char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL));
3048 
3049   guarantee(requested_addr == NULL || requested_addr == addr,
3050             "OS failed to return requested mmap address.");
3051   return addr;
3052 }
3053 
3054 // Reserve memory at an arbitrary address, only if that area is
3055 // available (and not reserved for something else).
3056 
3057 char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
3058   const int max_tries = 10;
3059   char* base[max_tries];
3060   size_t size[max_tries];
3061 
3062   // Solaris adds a gap between mmap'ed regions.  The size of the gap
3063   // is dependent on the requested size and the MMU.  Our initial gap
3064   // value here is just a guess and will be corrected later.
3065   bool had_top_overlap = false;
3066   bool have_adjusted_gap = false;
3067   size_t gap = 0x400000;
3068 
3069   // Assert only that the size is a multiple of the page size, since
3070   // that's all that mmap requires, and since that's all we really know
3071   // about at this low abstraction level.  If we need higher alignment,
3072   // we can either pass an alignment to this method or verify alignment
3073   // in one of the methods further up the call chain.  See bug 5044738.
3074   assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");
3075 
3076   // Since snv_84, Solaris attempts to honor the address hint - see 5003415.
3077   // Give it a try, if the kernel honors the hint we can return immediately.
3078   char* addr = Solaris::anon_mmap(requested_addr, bytes, 0, false);
3079   volatile int err = errno;
3080   if (addr == requested_addr) {
3081     return addr;
3082   } else if (addr != NULL) {
3083     unmap_memory(addr, bytes);
3084   }
3085 
3086   if (PrintMiscellaneous && Verbose) {
3087     char buf[256];
3088     buf[0] = '\0';
3089     if (addr == NULL) {
3090       jio_snprintf(buf, sizeof(buf), ": %s", strerror(err));
3091     }
3092     warning("attempt_reserve_memory_at: couldn't reserve " SIZE_FORMAT " bytes at "
3093             PTR_FORMAT ": reserve_memory_helper returned " PTR_FORMAT
3094             "%s", bytes, requested_addr, addr, buf);
3095   }
3096 
3097   // Address hint method didn't work.  Fall back to the old method.
3098   // In theory, once SNV becomes our oldest supported platform, this
3099   // code will no longer be needed.
3100   //
3101   // Repeatedly allocate blocks until the block is allocated at the
3102   // right spot. Give up after max_tries.
3103   int i;
3104   for (i = 0; i < max_tries; ++i) {
3105     base[i] = reserve_memory(bytes);
3106 
3107     if (base[i] != NULL) {
3108       // Is this the block we wanted?
3109       if (base[i] == requested_addr) {
3110         size[i] = bytes;
3111         break;
3112       }
3113 
3114       // check that the gap value is right
3115       if (had_top_overlap && !have_adjusted_gap) {
3116         size_t actual_gap = base[i-1] - base[i] - bytes;
3117         if (gap != actual_gap) {
3118           // adjust the gap value and retry the last 2 allocations
3119           assert(i > 0, "gap adjustment code problem");
3120           have_adjusted_gap = true;  // adjust the gap only once, just in case
3121           gap = actual_gap;
3122           if (PrintMiscellaneous && Verbose) {
3123             warning("attempt_reserve_memory_at: adjusted gap to 0x%lx", gap);
3124           }
3125           unmap_memory(base[i], bytes);
3126           unmap_memory(base[i-1], size[i-1]);
3127           i-=2;
3128           continue;
3129         }
3130       }
3131 
3132       // Does this overlap the block we wanted? Give back the overlapped
3133       // parts and try again.
3134       //
3135       // There is still a bug in this code: if top_overlap == bytes,
3136       // the overlap is offset from requested region by the value of gap.
3137       // In this case giving back the overlapped part will not work,
3138       // because we'll give back the entire block at base[i] and
3139       // therefore the subsequent allocation will not generate a new gap.
3140       // This could be fixed with a new algorithm that used larger
3141       // or variable size chunks to find the requested region -
3142       // but such a change would introduce additional complications.
3143       // It's rare enough that the planets align for this bug,
3144       // so we'll just wait for a fix for 6204603/5003415 which
3145       // will provide a mmap flag to allow us to avoid this business.
3146 
3147       size_t top_overlap = requested_addr + (bytes + gap) - base[i];
3148       if (top_overlap >= 0 && top_overlap < bytes) {
3149         had_top_overlap = true;
3150         unmap_memory(base[i], top_overlap);
3151         base[i] += top_overlap;
3152         size[i] = bytes - top_overlap;
3153       } else {
3154         size_t bottom_overlap = base[i] + bytes - requested_addr;
3155         if (bottom_overlap >= 0 && bottom_overlap < bytes) {
3156           if (PrintMiscellaneous && Verbose && bottom_overlap == 0) {
3157             warning("attempt_reserve_memory_at: possible alignment bug");
3158           }
3159           unmap_memory(requested_addr, bottom_overlap);
3160           size[i] = bytes - bottom_overlap;
3161         } else {
3162           size[i] = bytes;
3163         }
3164       }
3165     }
3166   }
3167 
3168   // Give back the unused reserved pieces.
3169 
3170   for (int j = 0; j < i; ++j) {
3171     if (base[j] != NULL) {
3172       unmap_memory(base[j], size[j]);
3173     }
3174   }
3175 
3176   return (i < max_tries) ? requested_addr : NULL;
3177 }
3178 
3179 bool os::release_memory(char* addr, size_t bytes) {
3180   size_t size = bytes;
3181   return munmap(addr, size) == 0;
3182 }
3183 
3184 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
3185   assert(addr == (char*)align_size_down((uintptr_t)addr, os::vm_page_size()),
3186          "addr must be page aligned");
3187   int retVal = mprotect(addr, bytes, prot);
3188   return retVal == 0;
3189 }
3190 
3191 // Protect memory (Used to pass readonly pages through
3192 // JNI GetArray<type>Elements with empty arrays.)
3193 // Also, used for serialization page and for compressed oops null pointer
3194 // checking.
3195 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,
3196                         bool is_committed) {
3197   unsigned int p = 0;
3198   switch (prot) {
3199   case MEM_PROT_NONE: p = PROT_NONE; break;
3200   case MEM_PROT_READ: p = PROT_READ; break;
3201   case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;
3202   case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;
3203   default:
3204     ShouldNotReachHere();
3205   }
3206   // is_committed is unused.
3207   return solaris_mprotect(addr, bytes, p);
3208 }
3209 
3210 // guard_memory and unguard_memory only happens within stack guard pages.
3211 // Since ISM pertains only to the heap, guard and unguard memory should not
3212 /// happen with an ISM region.
3213 bool os::guard_memory(char* addr, size_t bytes) {
3214   return solaris_mprotect(addr, bytes, PROT_NONE);
3215 }
3216 
3217 bool os::unguard_memory(char* addr, size_t bytes) {
3218   return solaris_mprotect(addr, bytes, PROT_READ|PROT_WRITE);
3219 }
3220 
3221 // Large page support
3222 
3223 // UseLargePages is the master flag to enable/disable large page memory.
3224 // UseMPSS and UseISM are supported for compatibility reasons. Their combined
3225 // effects can be described in the following table:
3226 //
3227 // UseLargePages UseMPSS UseISM
3228 //    false         *       *   => UseLargePages is the master switch, turning
3229 //                                 it off will turn off both UseMPSS and
3230 //                                 UseISM. VM will not use large page memory
3231 //                                 regardless the settings of UseMPSS/UseISM.
3232 //     true      false    false => Unless future Solaris provides other
3233 //                                 mechanism to use large page memory, this
3234 //                                 combination is equivalent to -UseLargePages,
3235 //                                 VM will not use large page memory
3236 //     true      true     false => JVM will use MPSS for large page memory.
3237 //                                 This is the default behavior.
3238 //     true      false    true  => JVM will use ISM for large page memory.
3239 //     true      true     true  => JVM will use ISM if it is available.
3240 //                                 Otherwise, JVM will fall back to MPSS.
3241 //                                 Becaues ISM is now available on all
3242 //                                 supported Solaris versions, this combination
3243 //                                 is equivalent to +UseISM -UseMPSS.
3244 
3245 typedef int (*getpagesizes_func_type) (size_t[], int);
3246 static size_t _large_page_size = 0;
3247 
3248 bool os::Solaris::ism_sanity_check(bool warn, size_t * page_size) {
3249   // x86 uses either 2M or 4M page, depending on whether PAE (Physical Address
3250   // Extensions) mode is enabled. AMD64/EM64T uses 2M page in 64bit mode. Sparc
3251   // can support multiple page sizes.
3252 
3253   // Don't bother to probe page size because getpagesizes() comes with MPSS.
3254   // ISM is only recommended on old Solaris where there is no MPSS support.
3255   // Simply choose a conservative value as default.
3256   *page_size = LargePageSizeInBytes ? LargePageSizeInBytes :
3257                SPARC_ONLY(4 * M) IA32_ONLY(4 * M) AMD64_ONLY(2 * M)
3258                ARM_ONLY(2 * M);
3259 
3260   // ISM is available on all supported Solaris versions
3261   return true;
3262 }
3263 
3264 // Insertion sort for small arrays (descending order).
3265 static void insertion_sort_descending(size_t* array, int len) {
3266   for (int i = 0; i < len; i++) {
3267     size_t val = array[i];
3268     for (size_t key = i; key > 0 && array[key - 1] < val; --key) {
3269       size_t tmp = array[key];
3270       array[key] = array[key - 1];
3271       array[key - 1] = tmp;
3272     }
3273   }
3274 }
3275 
3276 bool os::Solaris::mpss_sanity_check(bool warn, size_t * page_size) {
3277   getpagesizes_func_type getpagesizes_func =
3278     CAST_TO_FN_PTR(getpagesizes_func_type, dlsym(RTLD_DEFAULT, "getpagesizes"));
3279   if (getpagesizes_func == NULL) {
3280     if (warn) {
3281       warning("MPSS is not supported by the operating system.");
3282     }
3283     return false;
3284   }
3285 
3286   const unsigned int usable_count = VM_Version::page_size_count();
3287   if (usable_count == 1) {
3288     return false;
3289   }
3290 
3291   // Fill the array of page sizes.
3292   int n = getpagesizes_func(_page_sizes, page_sizes_max);
3293   assert(n > 0, "Solaris bug?");
3294   if (n == page_sizes_max) {
3295     // Add a sentinel value (necessary only if the array was completely filled
3296     // since it is static (zeroed at initialization)).
3297     _page_sizes[--n] = 0;
3298     DEBUG_ONLY(warning("increase the size of the os::_page_sizes array.");)
3299   }
3300   assert(_page_sizes[n] == 0, "missing sentinel");
3301 
3302   if (n == 1) return false;     // Only one page size available.
3303 
3304   // Skip sizes larger than 4M (or LargePageSizeInBytes if it was set) and
3305   // select up to usable_count elements.  First sort the array, find the first
3306   // acceptable value, then copy the usable sizes to the top of the array and
3307   // trim the rest.  Make sure to include the default page size :-).
3308   //
3309   // A better policy could get rid of the 4M limit by taking the sizes of the
3310   // important VM memory regions (java heap and possibly the code cache) into
3311   // account.
3312   insertion_sort_descending(_page_sizes, n);
3313   const size_t size_limit =
3314     FLAG_IS_DEFAULT(LargePageSizeInBytes) ? 4 * M : LargePageSizeInBytes;
3315   int beg;
3316   for (beg = 0; beg < n && _page_sizes[beg] > size_limit; ++beg) /* empty */ ;
3317   const int end = MIN2((int)usable_count, n) - 1;
3318   for (int cur = 0; cur < end; ++cur, ++beg) {
3319     _page_sizes[cur] = _page_sizes[beg];
3320   }
3321   _page_sizes[end] = vm_page_size();
3322   _page_sizes[end + 1] = 0;
3323 
3324   if (_page_sizes[end] > _page_sizes[end - 1]) {
3325     // Default page size is not the smallest; sort again.
3326     insertion_sort_descending(_page_sizes, end + 1);
3327   }
3328   *page_size = _page_sizes[0];
3329 
3330   return true;
3331 }
3332 
3333 bool os::large_page_init() {
3334   if (!UseLargePages) {
3335     UseISM = false;
3336     UseMPSS = false;
3337     return false;
3338   }
3339 
3340   // print a warning if any large page related flag is specified on command line
3341   bool warn_on_failure = !FLAG_IS_DEFAULT(UseLargePages)        ||
3342                          !FLAG_IS_DEFAULT(UseISM)               ||
3343                          !FLAG_IS_DEFAULT(UseMPSS)              ||
3344                          !FLAG_IS_DEFAULT(LargePageSizeInBytes);
3345   UseISM = UseISM &&
3346            Solaris::ism_sanity_check(warn_on_failure, &_large_page_size);
3347   if (UseISM) {
3348     // ISM disables MPSS to be compatible with old JDK behavior
3349     UseMPSS = false;
3350     _page_sizes[0] = _large_page_size;
3351     _page_sizes[1] = vm_page_size();
3352   }
3353 
3354   UseMPSS = UseMPSS &&
3355             Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size);
3356 
3357   UseLargePages = UseISM || UseMPSS;
3358   return UseLargePages;
3359 }
3360 
3361 bool os::Solaris::set_mpss_range(caddr_t start, size_t bytes, size_t align) {
3362   // Signal to OS that we want large pages for addresses
3363   // from addr, addr + bytes
3364   struct memcntl_mha mpss_struct;
3365   mpss_struct.mha_cmd = MHA_MAPSIZE_VA;
3366   mpss_struct.mha_pagesize = align;
3367   mpss_struct.mha_flags = 0;
3368   if (memcntl(start, bytes, MC_HAT_ADVISE,
3369               (caddr_t) &mpss_struct, 0, 0) < 0) {
3370     debug_only(warning("Attempt to use MPSS failed."));
3371     return false;
3372   }
3373   return true;
3374 }
3375 
3376 char* os::reserve_memory_special(size_t bytes, char* addr, bool exec) {
3377   // "exec" is passed in but not used.  Creating the shared image for
3378   // the code cache doesn't have an SHM_X executable permission to check.
3379   assert(UseLargePages && UseISM, "only for ISM large pages");
3380 
3381   size_t size = bytes;
3382   char* retAddr = NULL;
3383   int shmid;
3384   key_t ismKey;
3385 
3386   bool warn_on_failure = UseISM &&
3387                         (!FLAG_IS_DEFAULT(UseLargePages)         ||
3388                          !FLAG_IS_DEFAULT(UseISM)                ||
3389                          !FLAG_IS_DEFAULT(LargePageSizeInBytes)
3390                         );
3391   char msg[128];
3392 
3393   ismKey = IPC_PRIVATE;
3394 
3395   // Create a large shared memory region to attach to based on size.
3396   // Currently, size is the total size of the heap
3397   shmid = shmget(ismKey, size, SHM_R | SHM_W | IPC_CREAT);
3398   if (shmid == -1){
3399      if (warn_on_failure) {
3400        jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno);
3401        warning(msg);
3402      }
3403      return NULL;
3404   }
3405 
3406   // Attach to the region
3407   retAddr = (char *) shmat(shmid, 0, SHM_SHARE_MMU | SHM_R | SHM_W);
3408   int err = errno;
3409 
3410   // Remove shmid. If shmat() is successful, the actual shared memory segment
3411   // will be deleted when it's detached by shmdt() or when the process
3412   // terminates. If shmat() is not successful this will remove the shared
3413   // segment immediately.
3414   shmctl(shmid, IPC_RMID, NULL);
3415 
3416   if (retAddr == (char *) -1) {
3417     if (warn_on_failure) {
3418       jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
3419       warning(msg);
3420     }
3421     return NULL;
3422   }
3423 
3424   return retAddr;
3425 }
3426 
3427 bool os::release_memory_special(char* base, size_t bytes) {
3428   // detaching the SHM segment will also delete it, see reserve_memory_special()
3429   int rslt = shmdt(base);
3430   return rslt == 0;
3431 }
3432 
3433 size_t os::large_page_size() {
3434   return _large_page_size;
3435 }
3436 
3437 // MPSS allows application to commit large page memory on demand; with ISM
3438 // the entire memory region must be allocated as shared memory.
3439 bool os::can_commit_large_page_memory() {
3440   return UseISM ? false : true;
3441 }
3442 
3443 bool os::can_execute_large_page_memory() {
3444   return UseISM ? false : true;
3445 }
3446 
3447 static int os_sleep(jlong millis, bool interruptible) {
3448   const jlong limit = INT_MAX;
3449   jlong prevtime;
3450   int res;
3451 
3452   while (millis > limit) {
3453     if ((res = os_sleep(limit, interruptible)) != OS_OK)
3454       return res;
3455     millis -= limit;
3456   }
3457 
3458   // Restart interrupted polls with new parameters until the proper delay
3459   // has been completed.
3460 
3461   prevtime = getTimeMillis();
3462 
3463   while (millis > 0) {
3464     jlong newtime;
3465 
3466     if (!interruptible) {
3467       // Following assert fails for os::yield_all:
3468       // assert(!thread->is_Java_thread(), "must not be java thread");
3469       res = poll(NULL, 0, millis);
3470     } else {
3471       JavaThread *jt = JavaThread::current();
3472 
3473       INTERRUPTIBLE_NORESTART_VM_ALWAYS(poll(NULL, 0, millis), res, jt,
3474         os::Solaris::clear_interrupted);
3475     }
3476 
3477     // INTERRUPTIBLE_NORESTART_VM_ALWAYS returns res == OS_INTRPT for
3478     // thread.Interrupt.
3479 
3480     // See c/r 6751923. Poll can return 0 before time
3481     // has elapsed if time is set via clock_settime (as NTP does).
3482     // res == 0 if poll timed out (see man poll RETURN VALUES)
3483     // using the logic below checks that we really did
3484     // sleep at least "millis" if not we'll sleep again.
3485     if( ( res == 0 ) || ((res == OS_ERR) && (errno == EINTR))) {
3486       newtime = getTimeMillis();
3487       assert(newtime >= prevtime, "time moving backwards");
3488     /* Doing prevtime and newtime in microseconds doesn't help precision,
3489        and trying to round up to avoid lost milliseconds can result in a
3490        too-short delay. */
3491       millis -= newtime - prevtime;
3492       if(millis <= 0)
3493         return OS_OK;
3494       prevtime = newtime;
3495     } else
3496       return res;
3497   }
3498 
3499   return OS_OK;
3500 }
3501 
3502 // Read calls from inside the vm need to perform state transitions
3503 size_t os::read(int fd, void *buf, unsigned int nBytes) {
3504   INTERRUPTIBLE_RETURN_INT_VM(::read(fd, buf, nBytes), os::Solaris::clear_interrupted);
3505 }
3506 
3507 size_t os::restartable_read(int fd, void *buf, unsigned int nBytes) {
3508   INTERRUPTIBLE_RETURN_INT(::read(fd, buf, nBytes), os::Solaris::clear_interrupted);
3509 }
3510 
3511 int os::sleep(Thread* thread, jlong millis, bool interruptible) {
3512   assert(thread == Thread::current(),  "thread consistency check");
3513 
3514   // TODO-FIXME: this should be removed.
3515   // On Solaris machines (especially 2.5.1) we found that sometimes the VM gets into a live lock
3516   // situation with a JavaThread being starved out of a lwp. The kernel doesn't seem to generate
3517   // a SIGWAITING signal which would enable the threads library to create a new lwp for the starving
3518   // thread. We suspect that because the Watcher thread keeps waking up at periodic intervals the kernel
3519   // is fooled into believing that the system is making progress. In the code below we block the
3520   // the watcher thread while safepoint is in progress so that it would not appear as though the
3521   // system is making progress.
3522   if (!Solaris::T2_libthread() &&
3523       thread->is_Watcher_thread() && SafepointSynchronize::is_synchronizing() && !Arguments::has_profile()) {
3524     // We now try to acquire the threads lock. Since this lock is held by the VM thread during
3525     // the entire safepoint, the watcher thread will  line up here during the safepoint.
3526     Threads_lock->lock_without_safepoint_check();
3527     Threads_lock->unlock();
3528   }
3529 
3530   if (thread->is_Java_thread()) {
3531     // This is a JavaThread so we honor the _thread_blocked protocol
3532     // even for sleeps of 0 milliseconds. This was originally done
3533     // as a workaround for bug 4338139. However, now we also do it
3534     // to honor the suspend-equivalent protocol.
3535 
3536     JavaThread *jt = (JavaThread *) thread;
3537     ThreadBlockInVM tbivm(jt);
3538 
3539     jt->set_suspend_equivalent();
3540     // cleared by handle_special_suspend_equivalent_condition() or
3541     // java_suspend_self() via check_and_wait_while_suspended()
3542 
3543     int ret_code;
3544     if (millis <= 0) {
3545       thr_yield();
3546       ret_code = 0;
3547     } else {
3548       // The original sleep() implementation did not create an
3549       // OSThreadWaitState helper for sleeps of 0 milliseconds.
3550       // I'm preserving that decision for now.
3551       OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
3552 
3553       ret_code = os_sleep(millis, interruptible);
3554     }
3555 
3556     // were we externally suspended while we were waiting?
3557     jt->check_and_wait_while_suspended();
3558 
3559     return ret_code;
3560   }
3561 
3562   // non-JavaThread from this point on:
3563 
3564   if (millis <= 0) {
3565     thr_yield();
3566     return 0;
3567   }
3568 
3569   OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
3570 
3571   return os_sleep(millis, interruptible);
3572 }
3573 
3574 int os::naked_sleep() {
3575   // %% make the sleep time an integer flag. for now use 1 millisec.
3576   return os_sleep(1, false);
3577 }
3578 
3579 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
3580 void os::infinite_sleep() {
3581   while (true) {    // sleep forever ...
3582     ::sleep(100);   // ... 100 seconds at a time
3583   }
3584 }
3585 
3586 // Used to convert frequent JVM_Yield() to nops
3587 bool os::dont_yield() {
3588   if (DontYieldALot) {
3589     static hrtime_t last_time = 0;
3590     hrtime_t diff = getTimeNanos() - last_time;
3591 
3592     if (diff < DontYieldALotInterval * 1000000)
3593       return true;
3594 
3595     last_time += diff;
3596 
3597     return false;
3598   }
3599   else {
3600     return false;
3601   }
3602 }
3603 
3604 // Caveat: Solaris os::yield() causes a thread-state transition whereas
3605 // the linux and win32 implementations do not.  This should be checked.
3606 
3607 void os::yield() {
3608   // Yields to all threads with same or greater priority
3609   os::sleep(Thread::current(), 0, false);
3610 }
3611 
3612 // Note that yield semantics are defined by the scheduling class to which
3613 // the thread currently belongs.  Typically, yield will _not yield to
3614 // other equal or higher priority threads that reside on the dispatch queues
3615 // of other CPUs.
3616 
3617 os::YieldResult os::NakedYield() { thr_yield(); return os::YIELD_UNKNOWN; }
3618 
3619 
3620 // On Solaris we found that yield_all doesn't always yield to all other threads.
3621 // There have been cases where there is a thread ready to execute but it doesn't
3622 // get an lwp as the VM thread continues to spin with sleeps of 1 millisecond.
3623 // The 1 millisecond wait doesn't seem long enough for the kernel to issue a
3624 // SIGWAITING signal which will cause a new lwp to be created. So we count the
3625 // number of times yield_all is called in the one loop and increase the sleep
3626 // time after 8 attempts. If this fails too we increase the concurrency level
3627 // so that the starving thread would get an lwp
3628 
3629 void os::yield_all(int attempts) {
3630   // Yields to all threads, including threads with lower priorities
3631   if (attempts == 0) {
3632     os::sleep(Thread::current(), 1, false);
3633   } else {
3634     int iterations = attempts % 30;
3635     if (iterations == 0 && !os::Solaris::T2_libthread()) {
3636       // thr_setconcurrency and _getconcurrency make sense only under T1.
3637       int noofLWPS = thr_getconcurrency();
3638       if (noofLWPS < (Threads::number_of_threads() + 2)) {
3639         thr_setconcurrency(thr_getconcurrency() + 1);
3640       }
3641     } else if (iterations < 25) {
3642       os::sleep(Thread::current(), 1, false);
3643     } else {
3644       os::sleep(Thread::current(), 10, false);
3645     }
3646   }
3647 }
3648 
3649 // Called from the tight loops to possibly influence time-sharing heuristics
3650 void os::loop_breaker(int attempts) {
3651   os::yield_all(attempts);
3652 }
3653 
3654 
3655 // Interface for setting lwp priorities.  If we are using T2 libthread,
3656 // which forces the use of BoundThreads or we manually set UseBoundThreads,
3657 // all of our threads will be assigned to real lwp's.  Using the thr_setprio
3658 // function is meaningless in this mode so we must adjust the real lwp's priority
3659 // The routines below implement the getting and setting of lwp priorities.
3660 //
3661 // Note: There are three priority scales used on Solaris.  Java priotities
3662 //       which range from 1 to 10, libthread "thr_setprio" scale which range
3663 //       from 0 to 127, and the current scheduling class of the process we
3664 //       are running in.  This is typically from -60 to +60.
3665 //       The setting of the lwp priorities in done after a call to thr_setprio
3666 //       so Java priorities are mapped to libthread priorities and we map from
3667 //       the latter to lwp priorities.  We don't keep priorities stored in
3668 //       Java priorities since some of our worker threads want to set priorities
3669 //       higher than all Java threads.
3670 //
3671 // For related information:
3672 // (1)  man -s 2 priocntl
3673 // (2)  man -s 4 priocntl
3674 // (3)  man dispadmin
3675 // =    librt.so
3676 // =    libthread/common/rtsched.c - thrp_setlwpprio().
3677 // =    ps -cL <pid> ... to validate priority.
3678 // =    sched_get_priority_min and _max
3679 //              pthread_create
3680 //              sched_setparam
3681 //              pthread_setschedparam
3682 //
3683 // Assumptions:
3684 // +    We assume that all threads in the process belong to the same
3685 //              scheduling class.   IE. an homogenous process.
3686 // +    Must be root or in IA group to change change "interactive" attribute.
3687 //              Priocntl() will fail silently.  The only indication of failure is when
3688 //              we read-back the value and notice that it hasn't changed.
3689 // +    Interactive threads enter the runq at the head, non-interactive at the tail.
3690 // +    For RT, change timeslice as well.  Invariant:
3691 //              constant "priority integral"
3692 //              Konst == TimeSlice * (60-Priority)
3693 //              Given a priority, compute appropriate timeslice.
3694 // +    Higher numerical values have higher priority.
3695 
3696 // sched class attributes
3697 typedef struct {
3698         int   schedPolicy;              // classID
3699         int   maxPrio;
3700         int   minPrio;
3701 } SchedInfo;
3702 
3703 
3704 static SchedInfo tsLimits, iaLimits, rtLimits;
3705 
3706 #ifdef ASSERT
3707 static int  ReadBackValidate = 1;
3708 #endif
3709 static int  myClass     = 0;
3710 static int  myMin       = 0;
3711 static int  myMax       = 0;
3712 static int  myCur       = 0;
3713 static bool priocntl_enable = false;
3714 
3715 
3716 // Call the version of priocntl suitable for all supported versions
3717 // of Solaris. We need to call through this wrapper so that we can
3718 // build on Solaris 9 and run on Solaris 8, 9 and 10.
3719 //
3720 // This code should be removed if we ever stop supporting Solaris 8
3721 // and earlier releases.
3722 
3723 static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg);
3724 typedef long (*priocntl_type)(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg);
3725 static priocntl_type priocntl_ptr = priocntl_stub;
3726 
3727 // Stub to set the value of the real pointer, and then call the real
3728 // function.
3729 
3730 static long priocntl_stub(int pcver, idtype_t idtype, id_t id, int cmd, caddr_t arg) {
3731   // Try Solaris 8- name only.
3732   priocntl_type tmp = (priocntl_type)dlsym(RTLD_DEFAULT, "__priocntl");
3733   guarantee(tmp != NULL, "priocntl function not found.");
3734   priocntl_ptr = tmp;
3735   return (*priocntl_ptr)(PC_VERSION, idtype, id, cmd, arg);
3736 }
3737 
3738 
3739 // lwp_priocntl_init
3740 //
3741 // Try to determine the priority scale for our process.
3742 //
3743 // Return errno or 0 if OK.
3744 //
3745 static
3746 int     lwp_priocntl_init ()
3747 {
3748   int rslt;
3749   pcinfo_t ClassInfo;
3750   pcparms_t ParmInfo;
3751   int i;
3752 
3753   if (!UseThreadPriorities) return 0;
3754 
3755   // We are using Bound threads, we need to determine our priority ranges
3756   if (os::Solaris::T2_libthread() || UseBoundThreads) {
3757     // If ThreadPriorityPolicy is 1, switch tables
3758     if (ThreadPriorityPolicy == 1) {
3759       for (i = 0 ; i < MaxPriority+1; i++)
3760         os::java_to_os_priority[i] = prio_policy1[i];
3761     }
3762   }
3763   // Not using Bound Threads, set to ThreadPolicy 1
3764   else {
3765     for ( i = 0 ; i < MaxPriority+1; i++ ) {
3766       os::java_to_os_priority[i] = prio_policy1[i];
3767     }
3768     return 0;
3769   }
3770 
3771 
3772   // Get IDs for a set of well-known scheduling classes.
3773   // TODO-FIXME: GETCLINFO returns the current # of classes in the
3774   // the system.  We should have a loop that iterates over the
3775   // classID values, which are known to be "small" integers.
3776 
3777   strcpy(ClassInfo.pc_clname, "TS");
3778   ClassInfo.pc_cid = -1;
3779   rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3780   if (rslt < 0) return errno;
3781   assert(ClassInfo.pc_cid != -1, "cid for TS class is -1");
3782   tsLimits.schedPolicy = ClassInfo.pc_cid;
3783   tsLimits.maxPrio = ((tsinfo_t*)ClassInfo.pc_clinfo)->ts_maxupri;
3784   tsLimits.minPrio = -tsLimits.maxPrio;
3785 
3786   strcpy(ClassInfo.pc_clname, "IA");
3787   ClassInfo.pc_cid = -1;
3788   rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3789   if (rslt < 0) return errno;
3790   assert(ClassInfo.pc_cid != -1, "cid for IA class is -1");
3791   iaLimits.schedPolicy = ClassInfo.pc_cid;
3792   iaLimits.maxPrio = ((iainfo_t*)ClassInfo.pc_clinfo)->ia_maxupri;
3793   iaLimits.minPrio = -iaLimits.maxPrio;
3794 
3795   strcpy(ClassInfo.pc_clname, "RT");
3796   ClassInfo.pc_cid = -1;
3797   rslt = (*priocntl_ptr)(PC_VERSION, P_ALL, 0, PC_GETCID, (caddr_t)&ClassInfo);
3798   if (rslt < 0) return errno;
3799   assert(ClassInfo.pc_cid != -1, "cid for RT class is -1");
3800   rtLimits.schedPolicy = ClassInfo.pc_cid;
3801   rtLimits.maxPrio = ((rtinfo_t*)ClassInfo.pc_clinfo)->rt_maxpri;
3802   rtLimits.minPrio = 0;
3803 
3804 
3805   // Query our "current" scheduling class.
3806   // This will normally be IA,TS or, rarely, RT.
3807   memset (&ParmInfo, 0, sizeof(ParmInfo));
3808   ParmInfo.pc_cid = PC_CLNULL;
3809   rslt = (*priocntl_ptr) (PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo );
3810   if ( rslt < 0 ) return errno;
3811   myClass = ParmInfo.pc_cid;
3812 
3813   // We now know our scheduling classId, get specific information
3814   // the class.
3815   ClassInfo.pc_cid = myClass;
3816   ClassInfo.pc_clname[0] = 0;
3817   rslt = (*priocntl_ptr) (PC_VERSION, (idtype)0, 0, PC_GETCLINFO, (caddr_t)&ClassInfo );
3818   if ( rslt < 0 ) return errno;
3819 
3820   if (ThreadPriorityVerbose)
3821     tty->print_cr ("lwp_priocntl_init: Class=%d(%s)...", myClass, ClassInfo.pc_clname);
3822 
3823   memset(&ParmInfo, 0, sizeof(pcparms_t));
3824   ParmInfo.pc_cid = PC_CLNULL;
3825   rslt = (*priocntl_ptr)(PC_VERSION, P_PID, P_MYID, PC_GETPARMS, (caddr_t)&ParmInfo);
3826   if (rslt < 0) return errno;
3827 
3828   if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3829     myMin = rtLimits.minPrio;
3830     myMax = rtLimits.maxPrio;
3831   } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3832     iaparms_t *iaInfo  = (iaparms_t*)ParmInfo.pc_clparms;
3833     myMin = iaLimits.minPrio;
3834     myMax = iaLimits.maxPrio;
3835     myMax = MIN2(myMax, (int)iaInfo->ia_uprilim);       // clamp - restrict
3836   } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3837     tsparms_t *tsInfo  = (tsparms_t*)ParmInfo.pc_clparms;
3838     myMin = tsLimits.minPrio;
3839     myMax = tsLimits.maxPrio;
3840     myMax = MIN2(myMax, (int)tsInfo->ts_uprilim);       // clamp - restrict
3841   } else {
3842     // No clue - punt
3843     if (ThreadPriorityVerbose)
3844       tty->print_cr ("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname);
3845     return EINVAL;      // no clue, punt
3846   }
3847 
3848   if (ThreadPriorityVerbose)
3849         tty->print_cr ("Thread priority Range: [%d..%d]\n", myMin, myMax);
3850 
3851   priocntl_enable = true;  // Enable changing priorities
3852   return 0;
3853 }
3854 
3855 #define IAPRI(x)        ((iaparms_t *)((x).pc_clparms))
3856 #define RTPRI(x)        ((rtparms_t *)((x).pc_clparms))
3857 #define TSPRI(x)        ((tsparms_t *)((x).pc_clparms))
3858 
3859 
3860 // scale_to_lwp_priority
3861 //
3862 // Convert from the libthread "thr_setprio" scale to our current
3863 // lwp scheduling class scale.
3864 //
3865 static
3866 int     scale_to_lwp_priority (int rMin, int rMax, int x)
3867 {
3868   int v;
3869 
3870   if (x == 127) return rMax;            // avoid round-down
3871     v = (((x*(rMax-rMin)))/128)+rMin;
3872   return v;
3873 }
3874 
3875 
3876 // set_lwp_priority
3877 //
3878 // Set the priority of the lwp.  This call should only be made
3879 // when using bound threads (T2 threads are bound by default).
3880 //
3881 int     set_lwp_priority (int ThreadID, int lwpid, int newPrio )
3882 {
3883   int rslt;
3884   int Actual, Expected, prv;
3885   pcparms_t ParmInfo;                   // for GET-SET
3886 #ifdef ASSERT
3887   pcparms_t ReadBack;                   // for readback
3888 #endif
3889 
3890   // Set priority via PC_GETPARMS, update, PC_SETPARMS
3891   // Query current values.
3892   // TODO: accelerate this by eliminating the PC_GETPARMS call.
3893   // Cache "pcparms_t" in global ParmCache.
3894   // TODO: elide set-to-same-value
3895 
3896   // If something went wrong on init, don't change priorities.
3897   if ( !priocntl_enable ) {
3898     if (ThreadPriorityVerbose)
3899       tty->print_cr("Trying to set priority but init failed, ignoring");
3900     return EINVAL;
3901   }
3902 
3903 
3904   // If lwp hasn't started yet, just return
3905   // the _start routine will call us again.
3906   if ( lwpid <= 0 ) {
3907     if (ThreadPriorityVerbose) {
3908       tty->print_cr ("deferring the set_lwp_priority of thread " INTPTR_FORMAT " to %d, lwpid not set",
3909                      ThreadID, newPrio);
3910     }
3911     return 0;
3912   }
3913 
3914   if (ThreadPriorityVerbose) {
3915     tty->print_cr ("set_lwp_priority(" INTPTR_FORMAT "@" INTPTR_FORMAT " %d) ",
3916                    ThreadID, lwpid, newPrio);
3917   }
3918 
3919   memset(&ParmInfo, 0, sizeof(pcparms_t));
3920   ParmInfo.pc_cid = PC_CLNULL;
3921   rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ParmInfo);
3922   if (rslt < 0) return errno;
3923 
3924   if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3925     rtparms_t *rtInfo  = (rtparms_t*)ParmInfo.pc_clparms;
3926     rtInfo->rt_pri     = scale_to_lwp_priority (rtLimits.minPrio, rtLimits.maxPrio, newPrio);
3927     rtInfo->rt_tqsecs  = RT_NOCHANGE;
3928     rtInfo->rt_tqnsecs = RT_NOCHANGE;
3929     if (ThreadPriorityVerbose) {
3930       tty->print_cr("RT: %d->%d\n", newPrio, rtInfo->rt_pri);
3931     }
3932   } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3933     iaparms_t *iaInfo  = (iaparms_t*)ParmInfo.pc_clparms;
3934     int maxClamped     = MIN2(iaLimits.maxPrio, (int)iaInfo->ia_uprilim);
3935     iaInfo->ia_upri    = scale_to_lwp_priority(iaLimits.minPrio, maxClamped, newPrio);
3936     iaInfo->ia_uprilim = IA_NOCHANGE;
3937     iaInfo->ia_mode    = IA_NOCHANGE;
3938     if (ThreadPriorityVerbose) {
3939       tty->print_cr ("IA: [%d...%d] %d->%d\n",
3940                iaLimits.minPrio, maxClamped, newPrio, iaInfo->ia_upri);
3941     }
3942   } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3943     tsparms_t *tsInfo  = (tsparms_t*)ParmInfo.pc_clparms;
3944     int maxClamped     = MIN2(tsLimits.maxPrio, (int)tsInfo->ts_uprilim);
3945     prv                = tsInfo->ts_upri;
3946     tsInfo->ts_upri    = scale_to_lwp_priority(tsLimits.minPrio, maxClamped, newPrio);
3947     tsInfo->ts_uprilim = IA_NOCHANGE;
3948     if (ThreadPriorityVerbose) {
3949       tty->print_cr ("TS: %d [%d...%d] %d->%d\n",
3950                prv, tsLimits.minPrio, maxClamped, newPrio, tsInfo->ts_upri);
3951     }
3952     if (prv == tsInfo->ts_upri) return 0;
3953   } else {
3954     if ( ThreadPriorityVerbose ) {
3955       tty->print_cr ("Unknown scheduling class\n");
3956     }
3957       return EINVAL;    // no clue, punt
3958   }
3959 
3960   rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_SETPARMS, (caddr_t)&ParmInfo);
3961   if (ThreadPriorityVerbose && rslt) {
3962     tty->print_cr ("PC_SETPARMS ->%d %d\n", rslt, errno);
3963   }
3964   if (rslt < 0) return errno;
3965 
3966 #ifdef ASSERT
3967   // Sanity check: read back what we just attempted to set.
3968   // In theory it could have changed in the interim ...
3969   //
3970   // The priocntl system call is tricky.
3971   // Sometimes it'll validate the priority value argument and
3972   // return EINVAL if unhappy.  At other times it fails silently.
3973   // Readbacks are prudent.
3974 
3975   if (!ReadBackValidate) return 0;
3976 
3977   memset(&ReadBack, 0, sizeof(pcparms_t));
3978   ReadBack.pc_cid = PC_CLNULL;
3979   rslt = (*priocntl_ptr)(PC_VERSION, P_LWPID, lwpid, PC_GETPARMS, (caddr_t)&ReadBack);
3980   assert(rslt >= 0, "priocntl failed");
3981   Actual = Expected = 0xBAD;
3982   assert(ParmInfo.pc_cid == ReadBack.pc_cid, "cid's don't match");
3983   if (ParmInfo.pc_cid == rtLimits.schedPolicy) {
3984     Actual   = RTPRI(ReadBack)->rt_pri;
3985     Expected = RTPRI(ParmInfo)->rt_pri;
3986   } else if (ParmInfo.pc_cid == iaLimits.schedPolicy) {
3987     Actual   = IAPRI(ReadBack)->ia_upri;
3988     Expected = IAPRI(ParmInfo)->ia_upri;
3989   } else if (ParmInfo.pc_cid == tsLimits.schedPolicy) {
3990     Actual   = TSPRI(ReadBack)->ts_upri;
3991     Expected = TSPRI(ParmInfo)->ts_upri;
3992   } else {
3993     if ( ThreadPriorityVerbose ) {
3994       tty->print_cr("set_lwp_priority: unexpected class in readback: %d\n", ParmInfo.pc_cid);
3995     }
3996   }
3997 
3998   if (Actual != Expected) {
3999     if ( ThreadPriorityVerbose ) {
4000       tty->print_cr ("set_lwp_priority(%d %d) Class=%d: actual=%d vs expected=%d\n",
4001              lwpid, newPrio, ReadBack.pc_cid, Actual, Expected);
4002     }
4003   }
4004 #endif
4005 
4006   return 0;
4007 }
4008 
4009 
4010 
4011 // Solaris only gives access to 128 real priorities at a time,
4012 // so we expand Java's ten to fill this range.  This would be better
4013 // if we dynamically adjusted relative priorities.
4014 //
4015 // The ThreadPriorityPolicy option allows us to select 2 different
4016 // priority scales.
4017 //
4018 // ThreadPriorityPolicy=0
4019 // Since the Solaris' default priority is MaximumPriority, we do not
4020 // set a priority lower than Max unless a priority lower than
4021 // NormPriority is requested.
4022 //
4023 // ThreadPriorityPolicy=1
4024 // This mode causes the priority table to get filled with
4025 // linear values.  NormPriority get's mapped to 50% of the
4026 // Maximum priority an so on.  This will cause VM threads
4027 // to get unfair treatment against other Solaris processes
4028 // which do not explicitly alter their thread priorities.
4029 //
4030 
4031 
4032 int os::java_to_os_priority[MaxPriority + 1] = {
4033   -99999,         // 0 Entry should never be used
4034 
4035   0,              // 1 MinPriority
4036   32,             // 2
4037   64,             // 3
4038 
4039   96,             // 4
4040   127,            // 5 NormPriority
4041   127,            // 6
4042 
4043   127,            // 7
4044   127,            // 8
4045   127,            // 9 NearMaxPriority
4046 
4047   127             // 10 MaxPriority
4048 };
4049 
4050 
4051 OSReturn os::set_native_priority(Thread* thread, int newpri) {
4052   assert(newpri >= MinimumPriority && newpri <= MaximumPriority, "bad priority mapping");
4053   if ( !UseThreadPriorities ) return OS_OK;
4054   int status = thr_setprio(thread->osthread()->thread_id(), newpri);
4055   if ( os::Solaris::T2_libthread() || (UseBoundThreads && thread->osthread()->is_vm_created()) )
4056     status |= (set_lwp_priority (thread->osthread()->thread_id(),
4057                     thread->osthread()->lwp_id(), newpri ));
4058   return (status == 0) ? OS_OK : OS_ERR;
4059 }
4060 
4061 
4062 OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
4063   int p;
4064   if ( !UseThreadPriorities ) {
4065     *priority_ptr = NormalPriority;
4066     return OS_OK;
4067   }
4068   int status = thr_getprio(thread->osthread()->thread_id(), &p);
4069   if (status != 0) {
4070     return OS_ERR;
4071   }
4072   *priority_ptr = p;
4073   return OS_OK;
4074 }
4075 
4076 
4077 // Hint to the underlying OS that a task switch would not be good.
4078 // Void return because it's a hint and can fail.
4079 void os::hint_no_preempt() {
4080   schedctl_start(schedctl_init());
4081 }
4082 
4083 void os::interrupt(Thread* thread) {
4084   assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer");
4085 
4086   OSThread* osthread = thread->osthread();
4087 
4088   int isInterrupted = osthread->interrupted();
4089   if (!isInterrupted) {
4090       osthread->set_interrupted(true);
4091       OrderAccess::fence();
4092       // os::sleep() is implemented with either poll (NULL,0,timeout) or
4093       // by parking on _SleepEvent.  If the former, thr_kill will unwedge
4094       // the sleeper by SIGINTR, otherwise the unpark() will wake the sleeper.
4095       ParkEvent * const slp = thread->_SleepEvent ;
4096       if (slp != NULL) slp->unpark() ;
4097   }
4098 
4099   // For JSR166:  unpark after setting status but before thr_kill -dl
4100   if (thread->is_Java_thread()) {
4101     ((JavaThread*)thread)->parker()->unpark();
4102   }
4103 
4104   // Handle interruptible wait() ...
4105   ParkEvent * const ev = thread->_ParkEvent ;
4106   if (ev != NULL) ev->unpark() ;
4107 
4108   // When events are used everywhere for os::sleep, then this thr_kill
4109   // will only be needed if UseVMInterruptibleIO is true.
4110 
4111   if (!isInterrupted) {
4112     int status = thr_kill(osthread->thread_id(), os::Solaris::SIGinterrupt());
4113     assert_status(status == 0, status, "thr_kill");
4114 
4115     // Bump thread interruption counter
4116     RuntimeService::record_thread_interrupt_signaled_count();
4117   }
4118 }
4119 
4120 
4121 bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
4122   assert(Thread::current() == thread || Threads_lock->owned_by_self(), "possibility of dangling Thread pointer");
4123 
4124   OSThread* osthread = thread->osthread();
4125 
4126   bool res = osthread->interrupted();
4127 
4128   // NOTE that since there is no "lock" around these two operations,
4129   // there is the possibility that the interrupted flag will be
4130   // "false" but that the interrupt event will be set. This is
4131   // intentional. The effect of this is that Object.wait() will appear
4132   // to have a spurious wakeup, which is not harmful, and the
4133   // possibility is so rare that it is not worth the added complexity
4134   // to add yet another lock. It has also been recommended not to put
4135   // the interrupted flag into the os::Solaris::Event structure,
4136   // because it hides the issue.
4137   if (res && clear_interrupted) {
4138     osthread->set_interrupted(false);
4139   }
4140   return res;
4141 }
4142 
4143 
4144 void os::print_statistics() {
4145 }
4146 
4147 int os::message_box(const char* title, const char* message) {
4148   int i;
4149   fdStream err(defaultStream::error_fd());
4150   for (i = 0; i < 78; i++) err.print_raw("=");
4151   err.cr();
4152   err.print_raw_cr(title);
4153   for (i = 0; i < 78; i++) err.print_raw("-");
4154   err.cr();
4155   err.print_raw_cr(message);
4156   for (i = 0; i < 78; i++) err.print_raw("=");
4157   err.cr();
4158 
4159   char buf[16];
4160   // Prevent process from exiting upon "read error" without consuming all CPU
4161   while (::read(0, buf, sizeof(buf)) <= 0) { ::sleep(100); }
4162 
4163   return buf[0] == 'y' || buf[0] == 'Y';
4164 }
4165 
4166 // A lightweight implementation that does not suspend the target thread and
4167 // thus returns only a hint. Used for profiling only!
4168 ExtendedPC os::get_thread_pc(Thread* thread) {
4169   // Make sure that it is called by the watcher and the Threads lock is owned.
4170   assert(Thread::current()->is_Watcher_thread(), "Must be watcher and own Threads_lock");
4171   // For now, is only used to profile the VM Thread
4172   assert(thread->is_VM_thread(), "Can only be called for VMThread");
4173   ExtendedPC epc;
4174 
4175   GetThreadPC_Callback  cb(ProfileVM_lock);
4176   OSThread *osthread = thread->osthread();
4177   const int time_to_wait = 400; // 400ms wait for initial response
4178   int status = cb.interrupt(thread, time_to_wait);
4179 
4180   if (cb.is_done() ) {
4181     epc = cb.addr();
4182   } else {
4183     DEBUG_ONLY(tty->print_cr("Failed to get pc for thread: %d got %d status",
4184                               osthread->thread_id(), status););
4185     // epc is already NULL
4186   }
4187   return epc;
4188 }
4189 
4190 
4191 // This does not do anything on Solaris. This is basically a hook for being
4192 // able to use structured exception handling (thread-local exception filters) on, e.g., Win32.
4193 void os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread) {
4194   f(value, method, args, thread);
4195 }
4196 
4197 // This routine may be used by user applications as a "hook" to catch signals.
4198 // The user-defined signal handler must pass unrecognized signals to this
4199 // routine, and if it returns true (non-zero), then the signal handler must
4200 // return immediately.  If the flag "abort_if_unrecognized" is true, then this
4201 // routine will never retun false (zero), but instead will execute a VM panic
4202 // routine kill the process.
4203 //
4204 // If this routine returns false, it is OK to call it again.  This allows
4205 // the user-defined signal handler to perform checks either before or after
4206 // the VM performs its own checks.  Naturally, the user code would be making
4207 // a serious error if it tried to handle an exception (such as a null check
4208 // or breakpoint) that the VM was generating for its own correct operation.
4209 //
4210 // This routine may recognize any of the following kinds of signals:
4211 // SIGBUS, SIGSEGV, SIGILL, SIGFPE, BREAK_SIGNAL, SIGPIPE, SIGXFSZ,
4212 // os::Solaris::SIGasync
4213 // It should be consulted by handlers for any of those signals.
4214 // It explicitly does not recognize os::Solaris::SIGinterrupt
4215 //
4216 // The caller of this routine must pass in the three arguments supplied
4217 // to the function referred to in the "sa_sigaction" (not the "sa_handler")
4218 // field of the structure passed to sigaction().  This routine assumes that
4219 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
4220 //
4221 // Note that the VM will print warnings if it detects conflicting signal
4222 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
4223 //
4224 extern "C" int JVM_handle_solaris_signal(int signo, siginfo_t* siginfo, void* ucontext, int abort_if_unrecognized);
4225 
4226 
4227 void signalHandler(int sig, siginfo_t* info, void* ucVoid) {
4228   JVM_handle_solaris_signal(sig, info, ucVoid, true);
4229 }
4230 
4231 /* Do not delete - if guarantee is ever removed,  a signal handler (even empty)
4232    is needed to provoke threads blocked on IO to return an EINTR
4233    Note: this explicitly does NOT call JVM_handle_solaris_signal and
4234    does NOT participate in signal chaining due to requirement for
4235    NOT setting SA_RESTART to make EINTR work. */
4236 extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) {
4237    if (UseSignalChaining) {
4238       struct sigaction *actp = os::Solaris::get_chained_signal_action(sig);
4239       if (actp && actp->sa_handler) {
4240         vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs");
4241       }
4242    }
4243 }
4244 
4245 // This boolean allows users to forward their own non-matching signals
4246 // to JVM_handle_solaris_signal, harmlessly.
4247 bool os::Solaris::signal_handlers_are_installed = false;
4248 
4249 // For signal-chaining
4250 bool os::Solaris::libjsig_is_loaded = false;
4251 typedef struct sigaction *(*get_signal_t)(int);
4252 get_signal_t os::Solaris::get_signal_action = NULL;
4253 
4254 struct sigaction* os::Solaris::get_chained_signal_action(int sig) {
4255   struct sigaction *actp = NULL;
4256 
4257   if ((libjsig_is_loaded)  && (sig <= Maxlibjsigsigs)) {
4258     // Retrieve the old signal handler from libjsig
4259     actp = (*get_signal_action)(sig);
4260   }
4261   if (actp == NULL) {
4262     // Retrieve the preinstalled signal handler from jvm
4263     actp = get_preinstalled_handler(sig);
4264   }
4265 
4266   return actp;
4267 }
4268 
4269 static bool call_chained_handler(struct sigaction *actp, int sig,
4270                                  siginfo_t *siginfo, void *context) {
4271   // Call the old signal handler
4272   if (actp->sa_handler == SIG_DFL) {
4273     // It's more reasonable to let jvm treat it as an unexpected exception
4274     // instead of taking the default action.
4275     return false;
4276   } else if (actp->sa_handler != SIG_IGN) {
4277     if ((actp->sa_flags & SA_NODEFER) == 0) {
4278       // automaticlly block the signal
4279       sigaddset(&(actp->sa_mask), sig);
4280     }
4281 
4282     sa_handler_t hand;
4283     sa_sigaction_t sa;
4284     bool siginfo_flag_set = (actp->sa_flags & SA_SIGINFO) != 0;
4285     // retrieve the chained handler
4286     if (siginfo_flag_set) {
4287       sa = actp->sa_sigaction;
4288     } else {
4289       hand = actp->sa_handler;
4290     }
4291 
4292     if ((actp->sa_flags & SA_RESETHAND) != 0) {
4293       actp->sa_handler = SIG_DFL;
4294     }
4295 
4296     // try to honor the signal mask
4297     sigset_t oset;
4298     thr_sigsetmask(SIG_SETMASK, &(actp->sa_mask), &oset);
4299 
4300     // call into the chained handler
4301     if (siginfo_flag_set) {
4302       (*sa)(sig, siginfo, context);
4303     } else {
4304       (*hand)(sig);
4305     }
4306 
4307     // restore the signal mask
4308     thr_sigsetmask(SIG_SETMASK, &oset, 0);
4309   }
4310   // Tell jvm's signal handler the signal is taken care of.
4311   return true;
4312 }
4313 
4314 bool os::Solaris::chained_handler(int sig, siginfo_t* siginfo, void* context) {
4315   bool chained = false;
4316   // signal-chaining
4317   if (UseSignalChaining) {
4318     struct sigaction *actp = get_chained_signal_action(sig);
4319     if (actp != NULL) {
4320       chained = call_chained_handler(actp, sig, siginfo, context);
4321     }
4322   }
4323   return chained;
4324 }
4325 
4326 struct sigaction* os::Solaris::get_preinstalled_handler(int sig) {
4327   assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized");
4328   if (preinstalled_sigs[sig] != 0) {
4329     return &chainedsigactions[sig];
4330   }
4331   return NULL;
4332 }
4333 
4334 void os::Solaris::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
4335 
4336   assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range");
4337   assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized");
4338   chainedsigactions[sig] = oldAct;
4339   preinstalled_sigs[sig] = 1;
4340 }
4341 
4342 void os::Solaris::set_signal_handler(int sig, bool set_installed, bool oktochain) {
4343   // Check for overwrite.
4344   struct sigaction oldAct;
4345   sigaction(sig, (struct sigaction*)NULL, &oldAct);
4346   void* oldhand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oldAct.sa_sigaction)
4347                                       : CAST_FROM_FN_PTR(void*,  oldAct.sa_handler);
4348   if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
4349       oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
4350       oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) {
4351     if (AllowUserSignalHandlers || !set_installed) {
4352       // Do not overwrite; user takes responsibility to forward to us.
4353       return;
4354     } else if (UseSignalChaining) {
4355       if (oktochain) {
4356         // save the old handler in jvm
4357         save_preinstalled_handler(sig, oldAct);
4358       } else {
4359         vm_exit_during_initialization("Signal chaining not allowed for VM interrupt signal, try -XX:+UseAltSigs.");
4360       }
4361       // libjsig also interposes the sigaction() call below and saves the
4362       // old sigaction on it own.
4363     } else {
4364       fatal(err_msg("Encountered unexpected pre-existing sigaction handler "
4365                     "%#lx for signal %d.", (long)oldhand, sig));
4366     }
4367   }
4368 
4369   struct sigaction sigAct;
4370   sigfillset(&(sigAct.sa_mask));
4371   sigAct.sa_handler = SIG_DFL;
4372 
4373   sigAct.sa_sigaction = signalHandler;
4374   // Handle SIGSEGV on alternate signal stack if
4375   // not using stack banging
4376   if (!UseStackBanging && sig == SIGSEGV) {
4377     sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
4378   // Interruptible i/o requires SA_RESTART cleared so EINTR
4379   // is returned instead of restarting system calls
4380   } else if (sig == os::Solaris::SIGinterrupt()) {
4381     sigemptyset(&sigAct.sa_mask);
4382     sigAct.sa_handler = NULL;
4383     sigAct.sa_flags = SA_SIGINFO;
4384     sigAct.sa_sigaction = sigINTRHandler;
4385   } else {
4386     sigAct.sa_flags = SA_SIGINFO | SA_RESTART;
4387   }
4388   os::Solaris::set_our_sigflags(sig, sigAct.sa_flags);
4389 
4390   sigaction(sig, &sigAct, &oldAct);
4391 
4392   void* oldhand2 = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*, oldAct.sa_sigaction)
4393                                        : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
4394   assert(oldhand2 == oldhand, "no concurrent signal handler installation");
4395 }
4396 
4397 
4398 #define DO_SIGNAL_CHECK(sig) \
4399   if (!sigismember(&check_signal_done, sig)) \
4400     os::Solaris::check_signal_handler(sig)
4401 
4402 // This method is a periodic task to check for misbehaving JNI applications
4403 // under CheckJNI, we can add any periodic checks here
4404 
4405 void os::run_periodic_checks() {
4406   // A big source of grief is hijacking virt. addr 0x0 on Solaris,
4407   // thereby preventing a NULL checks.
4408   if(!check_addr0_done) check_addr0_done = check_addr0(tty);
4409 
4410   if (check_signals == false) return;
4411 
4412   // SEGV and BUS if overridden could potentially prevent
4413   // generation of hs*.log in the event of a crash, debugging
4414   // such a case can be very challenging, so we absolutely
4415   // check for the following for a good measure:
4416   DO_SIGNAL_CHECK(SIGSEGV);
4417   DO_SIGNAL_CHECK(SIGILL);
4418   DO_SIGNAL_CHECK(SIGFPE);
4419   DO_SIGNAL_CHECK(SIGBUS);
4420   DO_SIGNAL_CHECK(SIGPIPE);
4421   DO_SIGNAL_CHECK(SIGXFSZ);
4422 
4423   // ReduceSignalUsage allows the user to override these handlers
4424   // see comments at the very top and jvm_solaris.h
4425   if (!ReduceSignalUsage) {
4426     DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
4427     DO_SIGNAL_CHECK(SHUTDOWN2_SIGNAL);
4428     DO_SIGNAL_CHECK(SHUTDOWN3_SIGNAL);
4429     DO_SIGNAL_CHECK(BREAK_SIGNAL);
4430   }
4431 
4432   // See comments above for using JVM1/JVM2 and UseAltSigs
4433   DO_SIGNAL_CHECK(os::Solaris::SIGinterrupt());
4434   DO_SIGNAL_CHECK(os::Solaris::SIGasync());
4435 
4436 }
4437 
4438 typedef int (*os_sigaction_t)(int, const struct sigaction *, struct sigaction *);
4439 
4440 static os_sigaction_t os_sigaction = NULL;
4441 
4442 void os::Solaris::check_signal_handler(int sig) {
4443   char buf[O_BUFLEN];
4444   address jvmHandler = NULL;
4445 
4446   struct sigaction act;
4447   if (os_sigaction == NULL) {
4448     // only trust the default sigaction, in case it has been interposed
4449     os_sigaction = (os_sigaction_t)dlsym(RTLD_DEFAULT, "sigaction");
4450     if (os_sigaction == NULL) return;
4451   }
4452 
4453   os_sigaction(sig, (struct sigaction*)NULL, &act);
4454 
4455   address thisHandler = (act.sa_flags & SA_SIGINFO)
4456     ? CAST_FROM_FN_PTR(address, act.sa_sigaction)
4457     : CAST_FROM_FN_PTR(address, act.sa_handler) ;
4458 
4459 
4460   switch(sig) {
4461     case SIGSEGV:
4462     case SIGBUS:
4463     case SIGFPE:
4464     case SIGPIPE:
4465     case SIGXFSZ:
4466     case SIGILL:
4467       jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4468       break;
4469 
4470     case SHUTDOWN1_SIGNAL:
4471     case SHUTDOWN2_SIGNAL:
4472     case SHUTDOWN3_SIGNAL:
4473     case BREAK_SIGNAL:
4474       jvmHandler = (address)user_handler();
4475       break;
4476 
4477     default:
4478       int intrsig = os::Solaris::SIGinterrupt();
4479       int asynsig = os::Solaris::SIGasync();
4480 
4481       if (sig == intrsig) {
4482         jvmHandler = CAST_FROM_FN_PTR(address, sigINTRHandler);
4483       } else if (sig == asynsig) {
4484         jvmHandler = CAST_FROM_FN_PTR(address, signalHandler);
4485       } else {
4486         return;
4487       }
4488       break;
4489   }
4490 
4491 
4492   if (thisHandler != jvmHandler) {
4493     tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
4494     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
4495     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
4496     // No need to check this sig any longer
4497     sigaddset(&check_signal_done, sig);
4498   } else if(os::Solaris::get_our_sigflags(sig) != 0 && act.sa_flags != os::Solaris::get_our_sigflags(sig)) {
4499     tty->print("Warning: %s handler flags ", exception_name(sig, buf, O_BUFLEN));
4500     tty->print("expected:" PTR32_FORMAT, os::Solaris::get_our_sigflags(sig));
4501     tty->print_cr("  found:" PTR32_FORMAT, act.sa_flags);
4502     // No need to check this sig any longer
4503     sigaddset(&check_signal_done, sig);
4504   }
4505 
4506   // Print all the signal handler state
4507   if (sigismember(&check_signal_done, sig)) {
4508     print_signal_handlers(tty, buf, O_BUFLEN);
4509   }
4510 
4511 }
4512 
4513 void os::Solaris::install_signal_handlers() {
4514   bool libjsigdone = false;
4515   signal_handlers_are_installed = true;
4516 
4517   // signal-chaining
4518   typedef void (*signal_setting_t)();
4519   signal_setting_t begin_signal_setting = NULL;
4520   signal_setting_t end_signal_setting = NULL;
4521   begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4522                                         dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
4523   if (begin_signal_setting != NULL) {
4524     end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
4525                                         dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
4526     get_signal_action = CAST_TO_FN_PTR(get_signal_t,
4527                                        dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
4528     get_libjsig_version = CAST_TO_FN_PTR(version_getting_t,
4529                                          dlsym(RTLD_DEFAULT, "JVM_get_libjsig_version"));
4530     libjsig_is_loaded = true;
4531     if (os::Solaris::get_libjsig_version != NULL) {
4532       libjsigversion =  (*os::Solaris::get_libjsig_version)();
4533     }
4534     assert(UseSignalChaining, "should enable signal-chaining");
4535   }
4536   if (libjsig_is_loaded) {
4537     // Tell libjsig jvm is setting signal handlers
4538     (*begin_signal_setting)();
4539   }
4540 
4541   set_signal_handler(SIGSEGV, true, true);
4542   set_signal_handler(SIGPIPE, true, true);
4543   set_signal_handler(SIGXFSZ, true, true);
4544   set_signal_handler(SIGBUS, true, true);
4545   set_signal_handler(SIGILL, true, true);
4546   set_signal_handler(SIGFPE, true, true);
4547 
4548 
4549   if (os::Solaris::SIGinterrupt() > OLDMAXSIGNUM || os::Solaris::SIGasync() > OLDMAXSIGNUM) {
4550 
4551     // Pre-1.4.1 Libjsig limited to signal chaining signals <= 32 so
4552     // can not register overridable signals which might be > 32
4553     if (libjsig_is_loaded && libjsigversion <= JSIG_VERSION_1_4_1) {
4554     // Tell libjsig jvm has finished setting signal handlers
4555       (*end_signal_setting)();
4556       libjsigdone = true;
4557     }
4558   }
4559 
4560   // Never ok to chain our SIGinterrupt
4561   set_signal_handler(os::Solaris::SIGinterrupt(), true, false);
4562   set_signal_handler(os::Solaris::SIGasync(), true, true);
4563 
4564   if (libjsig_is_loaded && !libjsigdone) {
4565     // Tell libjsig jvm finishes setting signal handlers
4566     (*end_signal_setting)();
4567   }
4568 
4569   // We don't activate signal checker if libjsig is in place, we trust ourselves
4570   // and if UserSignalHandler is installed all bets are off
4571   if (CheckJNICalls) {
4572     if (libjsig_is_loaded) {
4573       tty->print_cr("Info: libjsig is activated, all active signal checking is disabled");
4574       check_signals = false;
4575     }
4576     if (AllowUserSignalHandlers) {
4577       tty->print_cr("Info: AllowUserSignalHandlers is activated, all active signal checking is disabled");
4578       check_signals = false;
4579     }
4580   }
4581 }
4582 
4583 
4584 void report_error(const char* file_name, int line_no, const char* title, const char* format, ...);
4585 
4586 const char * signames[] = {
4587   "SIG0",
4588   "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP",
4589   "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS",
4590   "SIGSEGV", "SIGSYS", "SIGPIPE", "SIGALRM", "SIGTERM",
4591   "SIGUSR1", "SIGUSR2", "SIGCLD", "SIGPWR", "SIGWINCH",
4592   "SIGURG", "SIGPOLL", "SIGSTOP", "SIGTSTP", "SIGCONT",
4593   "SIGTTIN", "SIGTTOU", "SIGVTALRM", "SIGPROF", "SIGXCPU",
4594   "SIGXFSZ", "SIGWAITING", "SIGLWP", "SIGFREEZE", "SIGTHAW",
4595   "SIGCANCEL", "SIGLOST"
4596 };
4597 
4598 const char* os::exception_name(int exception_code, char* buf, size_t size) {
4599   if (0 < exception_code && exception_code <= SIGRTMAX) {
4600     // signal
4601     if (exception_code < sizeof(signames)/sizeof(const char*)) {
4602        jio_snprintf(buf, size, "%s", signames[exception_code]);
4603     } else {
4604        jio_snprintf(buf, size, "SIG%d", exception_code);
4605     }
4606     return buf;
4607   } else {
4608     return NULL;
4609   }
4610 }
4611 
4612 // (Static) wrappers for the new libthread API
4613 int_fnP_thread_t_iP_uP_stack_tP_gregset_t os::Solaris::_thr_getstate;
4614 int_fnP_thread_t_i_gregset_t os::Solaris::_thr_setstate;
4615 int_fnP_thread_t_i os::Solaris::_thr_setmutator;
4616 int_fnP_thread_t os::Solaris::_thr_suspend_mutator;
4617 int_fnP_thread_t os::Solaris::_thr_continue_mutator;
4618 
4619 // (Static) wrapper for getisax(2) call.
4620 os::Solaris::getisax_func_t os::Solaris::_getisax = 0;
4621 
4622 // (Static) wrappers for the liblgrp API
4623 os::Solaris::lgrp_home_func_t os::Solaris::_lgrp_home;
4624 os::Solaris::lgrp_init_func_t os::Solaris::_lgrp_init;
4625 os::Solaris::lgrp_fini_func_t os::Solaris::_lgrp_fini;
4626 os::Solaris::lgrp_root_func_t os::Solaris::_lgrp_root;
4627 os::Solaris::lgrp_children_func_t os::Solaris::_lgrp_children;
4628 os::Solaris::lgrp_resources_func_t os::Solaris::_lgrp_resources;
4629 os::Solaris::lgrp_nlgrps_func_t os::Solaris::_lgrp_nlgrps;
4630 os::Solaris::lgrp_cookie_stale_func_t os::Solaris::_lgrp_cookie_stale;
4631 os::Solaris::lgrp_cookie_t os::Solaris::_lgrp_cookie = 0;
4632 
4633 // (Static) wrapper for meminfo() call.
4634 os::Solaris::meminfo_func_t os::Solaris::_meminfo = 0;
4635 
4636 static address resolve_symbol_lazy(const char* name) {
4637   address addr = (address) dlsym(RTLD_DEFAULT, name);
4638   if(addr == NULL) {
4639     // RTLD_DEFAULT was not defined on some early versions of 2.5.1
4640     addr = (address) dlsym(RTLD_NEXT, name);
4641   }
4642   return addr;
4643 }
4644 
4645 static address resolve_symbol(const char* name) {
4646   address addr = resolve_symbol_lazy(name);
4647   if(addr == NULL) {
4648     fatal(dlerror());
4649   }
4650   return addr;
4651 }
4652 
4653 
4654 
4655 // isT2_libthread()
4656 //
4657 // Routine to determine if we are currently using the new T2 libthread.
4658 //
4659 // We determine if we are using T2 by reading /proc/self/lstatus and
4660 // looking for a thread with the ASLWP bit set.  If we find this status
4661 // bit set, we must assume that we are NOT using T2.  The T2 team
4662 // has approved this algorithm.
4663 //
4664 // We need to determine if we are running with the new T2 libthread
4665 // since setting native thread priorities is handled differently
4666 // when using this library.  All threads created using T2 are bound
4667 // threads. Calling thr_setprio is meaningless in this case.
4668 //
4669 bool isT2_libthread() {
4670   static prheader_t * lwpArray = NULL;
4671   static int lwpSize = 0;
4672   static int lwpFile = -1;
4673   lwpstatus_t * that;
4674   char lwpName [128];
4675   bool isT2 = false;
4676 
4677 #define ADR(x)  ((uintptr_t)(x))
4678 #define LWPINDEX(ary,ix)   ((lwpstatus_t *)(((ary)->pr_entsize * (ix)) + (ADR((ary) + 1))))
4679 
4680   lwpFile = ::open("/proc/self/lstatus", O_RDONLY, 0);
4681   if (lwpFile < 0) {
4682       if (ThreadPriorityVerbose) warning ("Couldn't open /proc/self/lstatus\n");
4683       return false;
4684   }
4685   lwpSize = 16*1024;
4686   for (;;) {
4687     ::lseek64 (lwpFile, 0, SEEK_SET);
4688     lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize);
4689     if (::read(lwpFile, lwpArray, lwpSize) < 0) {
4690       if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n");
4691       break;
4692     }
4693     if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) {
4694        // We got a good snapshot - now iterate over the list.
4695       int aslwpcount = 0;
4696       for (int i = 0; i < lwpArray->pr_nent; i++ ) {
4697         that = LWPINDEX(lwpArray,i);
4698         if (that->pr_flags & PR_ASLWP) {
4699           aslwpcount++;
4700         }
4701       }
4702       if (aslwpcount == 0) isT2 = true;
4703       break;
4704     }
4705     lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize;
4706     FREE_C_HEAP_ARRAY(char, lwpArray);  // retry.
4707   }
4708 
4709   FREE_C_HEAP_ARRAY(char, lwpArray);
4710   ::close (lwpFile);
4711   if (ThreadPriorityVerbose) {
4712     if (isT2) tty->print_cr("We are running with a T2 libthread\n");
4713     else tty->print_cr("We are not running with a T2 libthread\n");
4714   }
4715   return isT2;
4716 }
4717 
4718 
4719 void os::Solaris::libthread_init() {
4720   address func = (address)dlsym(RTLD_DEFAULT, "_thr_suspend_allmutators");
4721 
4722   // Determine if we are running with the new T2 libthread
4723   os::Solaris::set_T2_libthread(isT2_libthread());
4724 
4725   lwp_priocntl_init();
4726 
4727   // RTLD_DEFAULT was not defined on some early versions of 5.5.1
4728   if(func == NULL) {
4729     func = (address) dlsym(RTLD_NEXT, "_thr_suspend_allmutators");
4730     // Guarantee that this VM is running on an new enough OS (5.6 or
4731     // later) that it will have a new enough libthread.so.
4732     guarantee(func != NULL, "libthread.so is too old.");
4733   }
4734 
4735   // Initialize the new libthread getstate API wrappers
4736   func = resolve_symbol("thr_getstate");
4737   os::Solaris::set_thr_getstate(CAST_TO_FN_PTR(int_fnP_thread_t_iP_uP_stack_tP_gregset_t, func));
4738 
4739   func = resolve_symbol("thr_setstate");
4740   os::Solaris::set_thr_setstate(CAST_TO_FN_PTR(int_fnP_thread_t_i_gregset_t, func));
4741 
4742   func = resolve_symbol("thr_setmutator");
4743   os::Solaris::set_thr_setmutator(CAST_TO_FN_PTR(int_fnP_thread_t_i, func));
4744 
4745   func = resolve_symbol("thr_suspend_mutator");
4746   os::Solaris::set_thr_suspend_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func));
4747 
4748   func = resolve_symbol("thr_continue_mutator");
4749   os::Solaris::set_thr_continue_mutator(CAST_TO_FN_PTR(int_fnP_thread_t, func));
4750 
4751   int size;
4752   void (*handler_info_func)(address *, int *);
4753   handler_info_func = CAST_TO_FN_PTR(void (*)(address *, int *), resolve_symbol("thr_sighndlrinfo"));
4754   handler_info_func(&handler_start, &size);
4755   handler_end = handler_start + size;
4756 }
4757 
4758 
4759 int_fnP_mutex_tP os::Solaris::_mutex_lock;
4760 int_fnP_mutex_tP os::Solaris::_mutex_trylock;
4761 int_fnP_mutex_tP os::Solaris::_mutex_unlock;
4762 int_fnP_mutex_tP_i_vP os::Solaris::_mutex_init;
4763 int_fnP_mutex_tP os::Solaris::_mutex_destroy;
4764 int os::Solaris::_mutex_scope = USYNC_THREAD;
4765 
4766 int_fnP_cond_tP_mutex_tP_timestruc_tP os::Solaris::_cond_timedwait;
4767 int_fnP_cond_tP_mutex_tP os::Solaris::_cond_wait;
4768 int_fnP_cond_tP os::Solaris::_cond_signal;
4769 int_fnP_cond_tP os::Solaris::_cond_broadcast;
4770 int_fnP_cond_tP_i_vP os::Solaris::_cond_init;
4771 int_fnP_cond_tP os::Solaris::_cond_destroy;
4772 int os::Solaris::_cond_scope = USYNC_THREAD;
4773 
4774 void os::Solaris::synchronization_init() {
4775   if(UseLWPSynchronization) {
4776     os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_lock")));
4777     os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_trylock")));
4778     os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("_lwp_mutex_unlock")));
4779     os::Solaris::set_mutex_init(lwp_mutex_init);
4780     os::Solaris::set_mutex_destroy(lwp_mutex_destroy);
4781     os::Solaris::set_mutex_scope(USYNC_THREAD);
4782 
4783     os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("_lwp_cond_timedwait")));
4784     os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("_lwp_cond_wait")));
4785     os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal")));
4786     os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast")));
4787     os::Solaris::set_cond_init(lwp_cond_init);
4788     os::Solaris::set_cond_destroy(lwp_cond_destroy);
4789     os::Solaris::set_cond_scope(USYNC_THREAD);
4790   }
4791   else {
4792     os::Solaris::set_mutex_scope(USYNC_THREAD);
4793     os::Solaris::set_cond_scope(USYNC_THREAD);
4794 
4795     if(UsePthreads) {
4796       os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock")));
4797       os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_trylock")));
4798       os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_unlock")));
4799       os::Solaris::set_mutex_init(pthread_mutex_default_init);
4800       os::Solaris::set_mutex_destroy(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_destroy")));
4801 
4802       os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("pthread_cond_timedwait")));
4803       os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait")));
4804       os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal")));
4805       os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast")));
4806       os::Solaris::set_cond_init(pthread_cond_default_init);
4807       os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy")));
4808     }
4809     else {
4810       os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock")));
4811       os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock")));
4812       os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock")));
4813       os::Solaris::set_mutex_init(::mutex_init);
4814       os::Solaris::set_mutex_destroy(::mutex_destroy);
4815 
4816       os::Solaris::set_cond_timedwait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP_timestruc_tP, resolve_symbol("cond_timedwait")));
4817       os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("cond_wait")));
4818       os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_signal")));
4819       os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("cond_broadcast")));
4820       os::Solaris::set_cond_init(::cond_init);
4821       os::Solaris::set_cond_destroy(::cond_destroy);
4822     }
4823   }
4824 }
4825 
4826 bool os::Solaris::liblgrp_init() {
4827   void *handle = dlopen("liblgrp.so.1", RTLD_LAZY);
4828   if (handle != NULL) {
4829     os::Solaris::set_lgrp_home(CAST_TO_FN_PTR(lgrp_home_func_t, dlsym(handle, "lgrp_home")));
4830     os::Solaris::set_lgrp_init(CAST_TO_FN_PTR(lgrp_init_func_t, dlsym(handle, "lgrp_init")));
4831     os::Solaris::set_lgrp_fini(CAST_TO_FN_PTR(lgrp_fini_func_t, dlsym(handle, "lgrp_fini")));
4832     os::Solaris::set_lgrp_root(CAST_TO_FN_PTR(lgrp_root_func_t, dlsym(handle, "lgrp_root")));
4833     os::Solaris::set_lgrp_children(CAST_TO_FN_PTR(lgrp_children_func_t, dlsym(handle, "lgrp_children")));
4834     os::Solaris::set_lgrp_resources(CAST_TO_FN_PTR(lgrp_resources_func_t, dlsym(handle, "lgrp_resources")));
4835     os::Solaris::set_lgrp_nlgrps(CAST_TO_FN_PTR(lgrp_nlgrps_func_t, dlsym(handle, "lgrp_nlgrps")));
4836     os::Solaris::set_lgrp_cookie_stale(CAST_TO_FN_PTR(lgrp_cookie_stale_func_t,
4837                                        dlsym(handle, "lgrp_cookie_stale")));
4838 
4839     lgrp_cookie_t c = lgrp_init(LGRP_VIEW_CALLER);
4840     set_lgrp_cookie(c);
4841     return true;
4842   }
4843   return false;
4844 }
4845 
4846 void os::Solaris::misc_sym_init() {
4847   address func;
4848 
4849   // getisax
4850   func = resolve_symbol_lazy("getisax");
4851   if (func != NULL) {
4852     os::Solaris::_getisax = CAST_TO_FN_PTR(getisax_func_t, func);
4853   }
4854 
4855   // meminfo
4856   func = resolve_symbol_lazy("meminfo");
4857   if (func != NULL) {
4858     os::Solaris::set_meminfo(CAST_TO_FN_PTR(meminfo_func_t, func));
4859   }
4860 }
4861 
4862 uint_t os::Solaris::getisax(uint32_t* array, uint_t n) {
4863   assert(_getisax != NULL, "_getisax not set");
4864   return _getisax(array, n);
4865 }
4866 
4867 // Symbol doesn't exist in Solaris 8 pset.h
4868 #ifndef PS_MYID
4869 #define PS_MYID -3
4870 #endif
4871 
4872 // int pset_getloadavg(psetid_t pset, double loadavg[], int nelem);
4873 typedef long (*pset_getloadavg_type)(psetid_t pset, double loadavg[], int nelem);
4874 static pset_getloadavg_type pset_getloadavg_ptr = NULL;
4875 
4876 void init_pset_getloadavg_ptr(void) {
4877   pset_getloadavg_ptr =
4878     (pset_getloadavg_type)dlsym(RTLD_DEFAULT, "pset_getloadavg");
4879   if (PrintMiscellaneous && Verbose && pset_getloadavg_ptr == NULL) {
4880     warning("pset_getloadavg function not found");
4881   }
4882 }
4883 
4884 int os::Solaris::_dev_zero_fd = -1;
4885 
4886 // this is called _before_ the global arguments have been parsed
4887 void os::init(void) {
4888   _initial_pid = getpid();
4889 
4890   max_hrtime = first_hrtime = gethrtime();
4891 
4892   init_random(1234567);
4893 
4894   page_size = sysconf(_SC_PAGESIZE);
4895   if (page_size == -1)
4896     fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)",
4897                   strerror(errno)));
4898   init_page_sizes((size_t) page_size);
4899 
4900   Solaris::initialize_system_info();
4901 
4902   // Initialize misc. symbols as soon as possible, so we can use them
4903   // if we need them.
4904   Solaris::misc_sym_init();
4905 
4906   int fd = ::open("/dev/zero", O_RDWR);
4907   if (fd < 0) {
4908     fatal(err_msg("os::init: cannot open /dev/zero (%s)", strerror(errno)));
4909   } else {
4910     Solaris::set_dev_zero_fd(fd);
4911 
4912     // Close on exec, child won't inherit.
4913     fcntl(fd, F_SETFD, FD_CLOEXEC);
4914   }
4915 
4916   clock_tics_per_sec = CLK_TCK;
4917 
4918   // check if dladdr1() exists; dladdr1 can provide more information than
4919   // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9
4920   // and is available on linker patches for 5.7 and 5.8.
4921   // libdl.so must have been loaded, this call is just an entry lookup
4922   void * hdl = dlopen("libdl.so", RTLD_NOW);
4923   if (hdl)
4924     dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1"));
4925 
4926   // (Solaris only) this switches to calls that actually do locking.
4927   ThreadCritical::initialize();
4928 
4929   main_thread = thr_self();
4930 
4931   // Constant minimum stack size allowed. It must be at least
4932   // the minimum of what the OS supports (thr_min_stack()), and
4933   // enough to allow the thread to get to user bytecode execution.
4934   Solaris::min_stack_allowed = MAX2(thr_min_stack(), Solaris::min_stack_allowed);
4935   // If the pagesize of the VM is greater than 8K determine the appropriate
4936   // number of initial guard pages.  The user can change this with the
4937   // command line arguments, if needed.
4938   if (vm_page_size() > 8*K) {
4939     StackYellowPages = 1;
4940     StackRedPages = 1;
4941     StackShadowPages = round_to((StackShadowPages*8*K), vm_page_size()) / vm_page_size();
4942   }
4943 }
4944 
4945 // To install functions for atexit system call
4946 extern "C" {
4947   static void perfMemory_exit_helper() {
4948     perfMemory_exit();
4949   }
4950 }
4951 
4952 // this is called _after_ the global arguments have been parsed
4953 jint os::init_2(void) {
4954   // try to enable extended file IO ASAP, see 6431278
4955   os::Solaris::try_enable_extended_io();
4956 
4957   // Allocate a single page and mark it as readable for safepoint polling.  Also
4958   // use this first mmap call to check support for MAP_ALIGN.
4959   address polling_page = (address)Solaris::mmap_chunk((char*)page_size,
4960                                                       page_size,
4961                                                       MAP_PRIVATE | MAP_ALIGN,
4962                                                       PROT_READ);
4963   if (polling_page == NULL) {
4964     has_map_align = false;
4965     polling_page = (address)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE,
4966                                                 PROT_READ);
4967   }
4968 
4969   os::set_polling_page(polling_page);
4970 
4971 #ifndef PRODUCT
4972   if( Verbose && PrintMiscellaneous )
4973     tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
4974 #endif
4975 
4976   if (!UseMembar) {
4977     address mem_serialize_page = (address)Solaris::mmap_chunk( NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE );
4978     guarantee( mem_serialize_page != NULL, "mmap Failed for memory serialize page");
4979     os::set_memory_serialize_page( mem_serialize_page );
4980 
4981 #ifndef PRODUCT
4982     if(Verbose && PrintMiscellaneous)
4983       tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
4984 #endif
4985 }
4986 
4987   FLAG_SET_DEFAULT(UseLargePages, os::large_page_init());
4988 
4989   // Check minimum allowable stack size for thread creation and to initialize
4990   // the java system classes, including StackOverflowError - depends on page
4991   // size.  Add a page for compiler2 recursion in main thread.
4992   // Add in 2*BytesPerWord times page size to account for VM stack during
4993   // class initialization depending on 32 or 64 bit VM.
4994   os::Solaris::min_stack_allowed = MAX2(os::Solaris::min_stack_allowed,
4995             (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
4996                     2*BytesPerWord COMPILER2_PRESENT(+1)) * page_size);
4997 
4998   size_t threadStackSizeInBytes = ThreadStackSize * K;
4999   if (threadStackSizeInBytes != 0 &&
5000     threadStackSizeInBytes < os::Solaris::min_stack_allowed) {
5001     tty->print_cr("\nThe stack size specified is too small, Specify at least %dk",
5002                   os::Solaris::min_stack_allowed/K);
5003     return JNI_ERR;
5004   }
5005 
5006   // For 64kbps there will be a 64kb page size, which makes
5007   // the usable default stack size quite a bit less.  Increase the
5008   // stack for 64kb (or any > than 8kb) pages, this increases
5009   // virtual memory fragmentation (since we're not creating the
5010   // stack on a power of 2 boundary.  The real fix for this
5011   // should be to fix the guard page mechanism.
5012 
5013   if (vm_page_size() > 8*K) {
5014       threadStackSizeInBytes = (threadStackSizeInBytes != 0)
5015          ? threadStackSizeInBytes +
5016            ((StackYellowPages + StackRedPages) * vm_page_size())
5017          : 0;
5018       ThreadStackSize = threadStackSizeInBytes/K;
5019   }
5020 
5021   // Make the stack size a multiple of the page size so that
5022   // the yellow/red zones can be guarded.
5023   JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
5024         vm_page_size()));
5025 
5026   Solaris::libthread_init();
5027 
5028   if (UseNUMA) {
5029     if (!Solaris::liblgrp_init()) {
5030       UseNUMA = false;
5031     } else {
5032       size_t lgrp_limit = os::numa_get_groups_num();
5033       int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit);
5034       size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit);
5035       FREE_C_HEAP_ARRAY(int, lgrp_ids);
5036       if (lgrp_num < 2) {
5037         // There's only one locality group, disable NUMA.
5038         UseNUMA = false;
5039       }
5040     }
5041     if (!UseNUMA && ForceNUMA) {
5042       UseNUMA = true;
5043     }
5044   }
5045 
5046   Solaris::signal_sets_init();
5047   Solaris::init_signal_mem();
5048   Solaris::install_signal_handlers();
5049 
5050   if (libjsigversion < JSIG_VERSION_1_4_1) {
5051     Maxlibjsigsigs = OLDMAXSIGNUM;
5052   }
5053 
5054   // initialize synchronization primitives to use either thread or
5055   // lwp synchronization (controlled by UseLWPSynchronization)
5056   Solaris::synchronization_init();
5057 
5058   if (MaxFDLimit) {
5059     // set the number of file descriptors to max. print out error
5060     // if getrlimit/setrlimit fails but continue regardless.
5061     struct rlimit nbr_files;
5062     int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
5063     if (status != 0) {
5064       if (PrintMiscellaneous && (Verbose || WizardMode))
5065         perror("os::init_2 getrlimit failed");
5066     } else {
5067       nbr_files.rlim_cur = nbr_files.rlim_max;
5068       status = setrlimit(RLIMIT_NOFILE, &nbr_files);
5069       if (status != 0) {
5070         if (PrintMiscellaneous && (Verbose || WizardMode))
5071           perror("os::init_2 setrlimit failed");
5072       }
5073     }
5074   }
5075 
5076   // Calculate theoretical max. size of Threads to guard gainst
5077   // artifical out-of-memory situations, where all available address-
5078   // space has been reserved by thread stacks. Default stack size is 1Mb.
5079   size_t pre_thread_stack_size = (JavaThread::stack_size_at_create()) ?
5080     JavaThread::stack_size_at_create() : (1*K*K);
5081   assert(pre_thread_stack_size != 0, "Must have a stack");
5082   // Solaris has a maximum of 4Gb of user programs. Calculate the thread limit when
5083   // we should start doing Virtual Memory banging. Currently when the threads will
5084   // have used all but 200Mb of space.
5085   size_t max_address_space = ((unsigned int)4 * K * K * K) - (200 * K * K);
5086   Solaris::_os_thread_limit = max_address_space / pre_thread_stack_size;
5087 
5088   // at-exit methods are called in the reverse order of their registration.
5089   // In Solaris 7 and earlier, atexit functions are called on return from
5090   // main or as a result of a call to exit(3C). There can be only 32 of
5091   // these functions registered and atexit() does not set errno. In Solaris
5092   // 8 and later, there is no limit to the number of functions registered
5093   // and atexit() sets errno. In addition, in Solaris 8 and later, atexit
5094   // functions are called upon dlclose(3DL) in addition to return from main
5095   // and exit(3C).
5096 
5097   if (PerfAllowAtExitRegistration) {
5098     // only register atexit functions if PerfAllowAtExitRegistration is set.
5099     // atexit functions can be delayed until process exit time, which
5100     // can be problematic for embedded VM situations. Embedded VMs should
5101     // call DestroyJavaVM() to assure that VM resources are released.
5102 
5103     // note: perfMemory_exit_helper atexit function may be removed in
5104     // the future if the appropriate cleanup code can be added to the
5105     // VM_Exit VMOperation's doit method.
5106     if (atexit(perfMemory_exit_helper) != 0) {
5107       warning("os::init2 atexit(perfMemory_exit_helper) failed");
5108     }
5109   }
5110 
5111   // Init pset_loadavg function pointer
5112   init_pset_getloadavg_ptr();
5113 
5114   return JNI_OK;
5115 }
5116 
5117 void os::init_3(void) {
5118   return;
5119 }
5120 
5121 // Mark the polling page as unreadable
5122 void os::make_polling_page_unreadable(void) {
5123   if( mprotect((char *)_polling_page, page_size, PROT_NONE) != 0 )
5124     fatal("Could not disable polling page");
5125 };
5126 
5127 // Mark the polling page as readable
5128 void os::make_polling_page_readable(void) {
5129   if( mprotect((char *)_polling_page, page_size, PROT_READ) != 0 )
5130     fatal("Could not enable polling page");
5131 };
5132 
5133 // OS interface.
5134 
5135 bool os::check_heap(bool force) { return true; }
5136 
5137 typedef int (*vsnprintf_t)(char* buf, size_t count, const char* fmt, va_list argptr);
5138 static vsnprintf_t sol_vsnprintf = NULL;
5139 
5140 int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr) {
5141   if (!sol_vsnprintf) {
5142     //search  for the named symbol in the objects that were loaded after libjvm
5143     void* where = RTLD_NEXT;
5144     if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL)
5145         sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf"));
5146     if (!sol_vsnprintf){
5147       //search  for the named symbol in the objects that were loaded before libjvm
5148       where = RTLD_DEFAULT;
5149       if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL)
5150         sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf"));
5151       assert(sol_vsnprintf != NULL, "vsnprintf not found");
5152     }
5153   }
5154   return (*sol_vsnprintf)(buf, count, fmt, argptr);
5155 }
5156 
5157 
5158 // Is a (classpath) directory empty?
5159 bool os::dir_is_empty(const char* path) {
5160   DIR *dir = NULL;
5161   struct dirent *ptr;
5162 
5163   dir = opendir(path);
5164   if (dir == NULL) return true;
5165 
5166   /* Scan the directory */
5167   bool result = true;
5168   char buf[sizeof(struct dirent) + MAX_PATH];
5169   struct dirent *dbuf = (struct dirent *) buf;
5170   while (result && (ptr = readdir(dir, dbuf)) != NULL) {
5171     if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
5172       result = false;
5173     }
5174   }
5175   closedir(dir);
5176   return result;
5177 }
5178 
5179 // This code originates from JDK's sysOpen and open64_w
5180 // from src/solaris/hpi/src/system_md.c
5181 
5182 #ifndef O_DELETE
5183 #define O_DELETE 0x10000
5184 #endif
5185 
5186 // Open a file. Unlink the file immediately after open returns
5187 // if the specified oflag has the O_DELETE flag set.
5188 // O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
5189 
5190 int os::open(const char *path, int oflag, int mode) {
5191   if (strlen(path) > MAX_PATH - 1) {
5192     errno = ENAMETOOLONG;
5193     return -1;
5194   }
5195   int fd;
5196   int o_delete = (oflag & O_DELETE);
5197   oflag = oflag & ~O_DELETE;
5198 
5199   fd = ::open64(path, oflag, mode);
5200   if (fd == -1) return -1;
5201 
5202   //If the open succeeded, the file might still be a directory
5203   {
5204     struct stat64 buf64;
5205     int ret = ::fstat64(fd, &buf64);
5206     int st_mode = buf64.st_mode;
5207 
5208     if (ret != -1) {
5209       if ((st_mode & S_IFMT) == S_IFDIR) {
5210         errno = EISDIR;
5211         ::close(fd);
5212         return -1;
5213       }
5214     } else {
5215       ::close(fd);
5216       return -1;
5217     }
5218   }
5219     /*
5220      * 32-bit Solaris systems suffer from:
5221      *
5222      * - an historical default soft limit of 256 per-process file
5223      *   descriptors that is too low for many Java programs.
5224      *
5225      * - a design flaw where file descriptors created using stdio
5226      *   fopen must be less than 256, _even_ when the first limit above
5227      *   has been raised.  This can cause calls to fopen (but not calls to
5228      *   open, for example) to fail mysteriously, perhaps in 3rd party
5229      *   native code (although the JDK itself uses fopen).  One can hardly
5230      *   criticize them for using this most standard of all functions.
5231      *
5232      * We attempt to make everything work anyways by:
5233      *
5234      * - raising the soft limit on per-process file descriptors beyond
5235      *   256
5236      *
5237      * - As of Solaris 10u4, we can request that Solaris raise the 256
5238      *   stdio fopen limit by calling function enable_extended_FILE_stdio.
5239      *   This is done in init_2 and recorded in enabled_extended_FILE_stdio
5240      *
5241      * - If we are stuck on an old (pre 10u4) Solaris system, we can
5242      *   workaround the bug by remapping non-stdio file descriptors below
5243      *   256 to ones beyond 256, which is done below.
5244      *
5245      * See:
5246      * 1085341: 32-bit stdio routines should support file descriptors >255
5247      * 6533291: Work around 32-bit Solaris stdio limit of 256 open files
5248      * 6431278: Netbeans crash on 32 bit Solaris: need to call
5249      *          enable_extended_FILE_stdio() in VM initialisation
5250      * Giri Mandalika's blog
5251      * http://technopark02.blogspot.com/2005_05_01_archive.html
5252      */
5253 #ifndef  _LP64
5254      if ((!enabled_extended_FILE_stdio) && fd < 256) {
5255          int newfd = ::fcntl(fd, F_DUPFD, 256);
5256          if (newfd != -1) {
5257              ::close(fd);
5258              fd = newfd;
5259          }
5260      }
5261 #endif // 32-bit Solaris
5262     /*
5263      * All file descriptors that are opened in the JVM and not
5264      * specifically destined for a subprocess should have the
5265      * close-on-exec flag set.  If we don't set it, then careless 3rd
5266      * party native code might fork and exec without closing all
5267      * appropriate file descriptors (e.g. as we do in closeDescriptors in
5268      * UNIXProcess.c), and this in turn might:
5269      *
5270      * - cause end-of-file to fail to be detected on some file
5271      *   descriptors, resulting in mysterious hangs, or
5272      *
5273      * - might cause an fopen in the subprocess to fail on a system
5274      *   suffering from bug 1085341.
5275      *
5276      * (Yes, the default setting of the close-on-exec flag is a Unix
5277      * design flaw)
5278      *
5279      * See:
5280      * 1085341: 32-bit stdio routines should support file descriptors >255
5281      * 4843136: (process) pipe file descriptor from Runtime.exec not being closed
5282      * 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
5283      */
5284 #ifdef FD_CLOEXEC
5285     {
5286         int flags = ::fcntl(fd, F_GETFD);
5287         if (flags != -1)
5288             ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
5289     }
5290 #endif
5291 
5292   if (o_delete != 0) {
5293     ::unlink(path);
5294   }
5295   return fd;
5296 }
5297 
5298 // create binary file, rewriting existing file if required
5299 int os::create_binary_file(const char* path, bool rewrite_existing) {
5300   int oflags = O_WRONLY | O_CREAT;
5301   if (!rewrite_existing) {
5302     oflags |= O_EXCL;
5303   }
5304   return ::open64(path, oflags, S_IREAD | S_IWRITE);
5305 }
5306 
5307 // return current position of file pointer
5308 jlong os::current_file_offset(int fd) {
5309   return (jlong)::lseek64(fd, (off64_t)0, SEEK_CUR);
5310 }
5311 
5312 // move file pointer to the specified offset
5313 jlong os::seek_to_file_offset(int fd, jlong offset) {
5314   return (jlong)::lseek64(fd, (off64_t)offset, SEEK_SET);
5315 }
5316 
5317 jlong os::lseek(int fd, jlong offset, int whence) {
5318   return (jlong) ::lseek64(fd, offset, whence);
5319 }
5320 
5321 char * os::native_path(char *path) {
5322   return path;
5323 }
5324 
5325 int os::ftruncate(int fd, jlong length) {
5326   return ::ftruncate64(fd, length);
5327 }
5328 
5329 int os::fsync(int fd)  {
5330   RESTARTABLE_RETURN_INT(::fsync(fd));
5331 }
5332 
5333 int os::available(int fd, jlong *bytes) {
5334   jlong cur, end;
5335   int mode;
5336   struct stat64 buf64;
5337 
5338   if (::fstat64(fd, &buf64) >= 0) {
5339     mode = buf64.st_mode;
5340     if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
5341       /*
5342       * XXX: is the following call interruptible? If so, this might
5343       * need to go through the INTERRUPT_IO() wrapper as for other
5344       * blocking, interruptible calls in this file.
5345       */
5346       int n,ioctl_return;
5347 
5348       INTERRUPTIBLE(::ioctl(fd, FIONREAD, &n),ioctl_return,os::Solaris::clear_interrupted);
5349       if (ioctl_return>= 0) {
5350           *bytes = n;
5351         return 1;
5352       }
5353     }
5354   }
5355   if ((cur = ::lseek64(fd, 0L, SEEK_CUR)) == -1) {
5356     return 0;
5357   } else if ((end = ::lseek64(fd, 0L, SEEK_END)) == -1) {
5358     return 0;
5359   } else if (::lseek64(fd, cur, SEEK_SET) == -1) {
5360     return 0;
5361   }
5362   *bytes = end - cur;
5363   return 1;
5364 }
5365 
5366 // Map a block of memory.
5367 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
5368                      char *addr, size_t bytes, bool read_only,
5369                      bool allow_exec) {
5370   int prot;
5371   int flags;
5372 
5373   if (read_only) {
5374     prot = PROT_READ;
5375     flags = MAP_SHARED;
5376   } else {
5377     prot = PROT_READ | PROT_WRITE;
5378     flags = MAP_PRIVATE;
5379   }
5380 
5381   if (allow_exec) {
5382     prot |= PROT_EXEC;
5383   }
5384 
5385   if (addr != NULL) {
5386     flags |= MAP_FIXED;
5387   }
5388 
5389   char* mapped_address = (char*)mmap(addr, (size_t)bytes, prot, flags,
5390                                      fd, file_offset);
5391   if (mapped_address == MAP_FAILED) {
5392     return NULL;
5393   }
5394   return mapped_address;
5395 }
5396 
5397 
5398 // Remap a block of memory.
5399 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
5400                        char *addr, size_t bytes, bool read_only,
5401                        bool allow_exec) {
5402   // same as map_memory() on this OS
5403   return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
5404                         allow_exec);
5405 }
5406 
5407 
5408 // Unmap a block of memory.
5409 bool os::unmap_memory(char* addr, size_t bytes) {
5410   return munmap(addr, bytes) == 0;
5411 }
5412 
5413 void os::pause() {
5414   char filename[MAX_PATH];
5415   if (PauseAtStartupFile && PauseAtStartupFile[0]) {
5416     jio_snprintf(filename, MAX_PATH, PauseAtStartupFile);
5417   } else {
5418     jio_snprintf(filename, MAX_PATH, "./vm.paused.%d", current_process_id());
5419   }
5420 
5421   int fd = ::open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
5422   if (fd != -1) {
5423     struct stat buf;
5424     ::close(fd);
5425     while (::stat(filename, &buf) == 0) {
5426       (void)::poll(NULL, 0, 100);
5427     }
5428   } else {
5429     jio_fprintf(stderr,
5430       "Could not open pause file '%s', continuing immediately.\n", filename);
5431   }
5432 }
5433 
5434 #ifndef PRODUCT
5435 #ifdef INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5436 // Turn this on if you need to trace synch operations.
5437 // Set RECORD_SYNCH_LIMIT to a large-enough value,
5438 // and call record_synch_enable and record_synch_disable
5439 // around the computation of interest.
5440 
5441 void record_synch(char* name, bool returning);  // defined below
5442 
5443 class RecordSynch {
5444   char* _name;
5445  public:
5446   RecordSynch(char* name) :_name(name)
5447                  { record_synch(_name, false); }
5448   ~RecordSynch() { record_synch(_name,   true);  }
5449 };
5450 
5451 #define CHECK_SYNCH_OP(ret, name, params, args, inner)          \
5452 extern "C" ret name params {                                    \
5453   typedef ret name##_t params;                                  \
5454   static name##_t* implem = NULL;                               \
5455   static int callcount = 0;                                     \
5456   if (implem == NULL) {                                         \
5457     implem = (name##_t*) dlsym(RTLD_NEXT, #name);               \
5458     if (implem == NULL)  fatal(dlerror());                      \
5459   }                                                             \
5460   ++callcount;                                                  \
5461   RecordSynch _rs(#name);                                       \
5462   inner;                                                        \
5463   return implem args;                                           \
5464 }
5465 // in dbx, examine callcounts this way:
5466 // for n in $(eval whereis callcount | awk '{print $2}'); do print $n; done
5467 
5468 #define CHECK_POINTER_OK(p) \
5469   (Universe::perm_gen() == NULL || !Universe::is_reserved_heap((oop)(p)))
5470 #define CHECK_MU \
5471   if (!CHECK_POINTER_OK(mu)) fatal("Mutex must be in C heap only.");
5472 #define CHECK_CV \
5473   if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only.");
5474 #define CHECK_P(p) \
5475   if (!CHECK_POINTER_OK(p))  fatal(false,  "Pointer must be in C heap only.");
5476 
5477 #define CHECK_MUTEX(mutex_op) \
5478 CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU);
5479 
5480 CHECK_MUTEX(   mutex_lock)
5481 CHECK_MUTEX(  _mutex_lock)
5482 CHECK_MUTEX( mutex_unlock)
5483 CHECK_MUTEX(_mutex_unlock)
5484 CHECK_MUTEX( mutex_trylock)
5485 CHECK_MUTEX(_mutex_trylock)
5486 
5487 #define CHECK_COND(cond_op) \
5488 CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU;CHECK_CV);
5489 
5490 CHECK_COND( cond_wait);
5491 CHECK_COND(_cond_wait);
5492 CHECK_COND(_cond_wait_cancel);
5493 
5494 #define CHECK_COND2(cond_op) \
5495 CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU;CHECK_CV);
5496 
5497 CHECK_COND2( cond_timedwait);
5498 CHECK_COND2(_cond_timedwait);
5499 CHECK_COND2(_cond_timedwait_cancel);
5500 
5501 // do the _lwp_* versions too
5502 #define mutex_t lwp_mutex_t
5503 #define cond_t  lwp_cond_t
5504 CHECK_MUTEX(  _lwp_mutex_lock)
5505 CHECK_MUTEX(  _lwp_mutex_unlock)
5506 CHECK_MUTEX(  _lwp_mutex_trylock)
5507 CHECK_MUTEX( __lwp_mutex_lock)
5508 CHECK_MUTEX( __lwp_mutex_unlock)
5509 CHECK_MUTEX( __lwp_mutex_trylock)
5510 CHECK_MUTEX(___lwp_mutex_lock)
5511 CHECK_MUTEX(___lwp_mutex_unlock)
5512 
5513 CHECK_COND(  _lwp_cond_wait);
5514 CHECK_COND( __lwp_cond_wait);
5515 CHECK_COND(___lwp_cond_wait);
5516 
5517 CHECK_COND2(  _lwp_cond_timedwait);
5518 CHECK_COND2( __lwp_cond_timedwait);
5519 #undef mutex_t
5520 #undef cond_t
5521 
5522 CHECK_SYNCH_OP(int, _lwp_suspend2,       (int lwp, int *n), (lwp, n), 0);
5523 CHECK_SYNCH_OP(int,__lwp_suspend2,       (int lwp, int *n), (lwp, n), 0);
5524 CHECK_SYNCH_OP(int, _lwp_kill,           (int lwp, int n),  (lwp, n), 0);
5525 CHECK_SYNCH_OP(int,__lwp_kill,           (int lwp, int n),  (lwp, n), 0);
5526 CHECK_SYNCH_OP(int, _lwp_sema_wait,      (lwp_sema_t* p),   (p),  CHECK_P(p));
5527 CHECK_SYNCH_OP(int,__lwp_sema_wait,      (lwp_sema_t* p),   (p),  CHECK_P(p));
5528 CHECK_SYNCH_OP(int, _lwp_cond_broadcast, (lwp_cond_t* cv),  (cv), CHECK_CV);
5529 CHECK_SYNCH_OP(int,__lwp_cond_broadcast, (lwp_cond_t* cv),  (cv), CHECK_CV);
5530 
5531 
5532 // recording machinery:
5533 
5534 enum { RECORD_SYNCH_LIMIT = 200 };
5535 char* record_synch_name[RECORD_SYNCH_LIMIT];
5536 void* record_synch_arg0ptr[RECORD_SYNCH_LIMIT];
5537 bool record_synch_returning[RECORD_SYNCH_LIMIT];
5538 thread_t record_synch_thread[RECORD_SYNCH_LIMIT];
5539 int record_synch_count = 0;
5540 bool record_synch_enabled = false;
5541 
5542 // in dbx, examine recorded data this way:
5543 // for n in name arg0ptr returning thread; do print record_synch_$n[0..record_synch_count-1]; done
5544 
5545 void record_synch(char* name, bool returning) {
5546   if (record_synch_enabled) {
5547     if (record_synch_count < RECORD_SYNCH_LIMIT) {
5548       record_synch_name[record_synch_count] = name;
5549       record_synch_returning[record_synch_count] = returning;
5550       record_synch_thread[record_synch_count] = thr_self();
5551       record_synch_arg0ptr[record_synch_count] = &name;
5552       record_synch_count++;
5553     }
5554     // put more checking code here:
5555     // ...
5556   }
5557 }
5558 
5559 void record_synch_enable() {
5560   // start collecting trace data, if not already doing so
5561   if (!record_synch_enabled)  record_synch_count = 0;
5562   record_synch_enabled = true;
5563 }
5564 
5565 void record_synch_disable() {
5566   // stop collecting trace data
5567   record_synch_enabled = false;
5568 }
5569 
5570 #endif // INTERPOSE_ON_SYSTEM_SYNCH_FUNCTIONS
5571 #endif // PRODUCT
5572 
5573 const intptr_t thr_time_off  = (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5574 const intptr_t thr_time_size = (intptr_t)(&((prusage_t *)(NULL))->pr_ttime) -
5575                                (intptr_t)(&((prusage_t *)(NULL))->pr_utime);
5576 
5577 
5578 // JVMTI & JVM monitoring and management support
5579 // The thread_cpu_time() and current_thread_cpu_time() are only
5580 // supported if is_thread_cpu_time_supported() returns true.
5581 // They are not supported on Solaris T1.
5582 
5583 // current_thread_cpu_time(bool) and thread_cpu_time(Thread*, bool)
5584 // are used by JVM M&M and JVMTI to get user+sys or user CPU time
5585 // of a thread.
5586 //
5587 // current_thread_cpu_time() and thread_cpu_time(Thread *)
5588 // returns the fast estimate available on the platform.
5589 
5590 // hrtime_t gethrvtime() return value includes
5591 // user time but does not include system time
5592 jlong os::current_thread_cpu_time() {
5593   return (jlong) gethrvtime();
5594 }
5595 
5596 jlong os::thread_cpu_time(Thread *thread) {
5597   // return user level CPU time only to be consistent with
5598   // what current_thread_cpu_time returns.
5599   // thread_cpu_time_info() must be changed if this changes
5600   return os::thread_cpu_time(thread, false /* user time only */);
5601 }
5602 
5603 jlong os::current_thread_cpu_time(bool user_sys_cpu_time) {
5604   if (user_sys_cpu_time) {
5605     return os::thread_cpu_time(Thread::current(), user_sys_cpu_time);
5606   } else {
5607     return os::current_thread_cpu_time();
5608   }
5609 }
5610 
5611 jlong os::thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
5612   char proc_name[64];
5613   int count;
5614   prusage_t prusage;
5615   jlong lwp_time;
5616   int fd;
5617 
5618   sprintf(proc_name, "/proc/%d/lwp/%d/lwpusage",
5619                      getpid(),
5620                      thread->osthread()->lwp_id());
5621   fd = ::open(proc_name, O_RDONLY);
5622   if ( fd == -1 ) return -1;
5623 
5624   do {
5625     count = ::pread(fd,
5626                   (void *)&prusage.pr_utime,
5627                   thr_time_size,
5628                   thr_time_off);
5629   } while (count < 0 && errno == EINTR);
5630   ::close(fd);
5631   if ( count < 0 ) return -1;
5632 
5633   if (user_sys_cpu_time) {
5634     // user + system CPU time
5635     lwp_time = (((jlong)prusage.pr_stime.tv_sec +
5636                  (jlong)prusage.pr_utime.tv_sec) * (jlong)1000000000) +
5637                  (jlong)prusage.pr_stime.tv_nsec +
5638                  (jlong)prusage.pr_utime.tv_nsec;
5639   } else {
5640     // user level CPU time only
5641     lwp_time = ((jlong)prusage.pr_utime.tv_sec * (jlong)1000000000) +
5642                 (jlong)prusage.pr_utime.tv_nsec;
5643   }
5644 
5645   return(lwp_time);
5646 }
5647 
5648 void os::current_thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5649   info_ptr->max_value = ALL_64_BITS;      // will not wrap in less than 64 bits
5650   info_ptr->may_skip_backward = false;    // elapsed time not wall time
5651   info_ptr->may_skip_forward = false;     // elapsed time not wall time
5652   info_ptr->kind = JVMTI_TIMER_USER_CPU;  // only user time is returned
5653 }
5654 
5655 void os::thread_cpu_time_info(jvmtiTimerInfo *info_ptr) {
5656   info_ptr->max_value = ALL_64_BITS;      // will not wrap in less than 64 bits
5657   info_ptr->may_skip_backward = false;    // elapsed time not wall time
5658   info_ptr->may_skip_forward = false;     // elapsed time not wall time
5659   info_ptr->kind = JVMTI_TIMER_USER_CPU;  // only user time is returned
5660 }
5661 
5662 bool os::is_thread_cpu_time_supported() {
5663   if ( os::Solaris::T2_libthread() || UseBoundThreads ) {
5664     return true;
5665   } else {
5666     return false;
5667   }
5668 }
5669 
5670 // System loadavg support.  Returns -1 if load average cannot be obtained.
5671 // Return the load average for our processor set if the primitive exists
5672 // (Solaris 9 and later).  Otherwise just return system wide loadavg.
5673 int os::loadavg(double loadavg[], int nelem) {
5674   if (pset_getloadavg_ptr != NULL) {
5675     return (*pset_getloadavg_ptr)(PS_MYID, loadavg, nelem);
5676   } else {
5677     return ::getloadavg(loadavg, nelem);
5678   }
5679 }
5680 
5681 //---------------------------------------------------------------------------------
5682 
5683 static address same_page(address x, address y) {
5684   intptr_t page_bits = -os::vm_page_size();
5685   if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
5686     return x;
5687   else if (x > y)
5688     return (address)(intptr_t(y) | ~page_bits) + 1;
5689   else
5690     return (address)(intptr_t(y) & page_bits);
5691 }
5692 
5693 bool os::find(address addr, outputStream* st) {
5694   Dl_info dlinfo;
5695   memset(&dlinfo, 0, sizeof(dlinfo));
5696   if (dladdr(addr, &dlinfo)) {
5697 #ifdef _LP64
5698     st->print("0x%016lx: ", addr);
5699 #else
5700     st->print("0x%08x: ", addr);
5701 #endif
5702     if (dlinfo.dli_sname != NULL)
5703       st->print("%s+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr);
5704     else if (dlinfo.dli_fname)
5705       st->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase);
5706     else
5707       st->print("<absolute address>");
5708     if (dlinfo.dli_fname)  st->print(" in %s", dlinfo.dli_fname);
5709 #ifdef _LP64
5710     if (dlinfo.dli_fbase)  st->print(" at 0x%016lx", dlinfo.dli_fbase);
5711 #else
5712     if (dlinfo.dli_fbase)  st->print(" at 0x%08x", dlinfo.dli_fbase);
5713 #endif
5714     st->cr();
5715 
5716     if (Verbose) {
5717       // decode some bytes around the PC
5718       address begin = same_page(addr-40, addr);
5719       address end   = same_page(addr+40, addr);
5720       address       lowest = (address) dlinfo.dli_sname;
5721       if (!lowest)  lowest = (address) dlinfo.dli_fbase;
5722       if (begin < lowest)  begin = lowest;
5723       Dl_info dlinfo2;
5724       if (dladdr(end, &dlinfo2) && dlinfo2.dli_saddr != dlinfo.dli_saddr
5725           && end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin)
5726         end = (address) dlinfo2.dli_saddr;
5727       Disassembler::decode(begin, end, st);
5728     }
5729     return true;
5730   }
5731   return false;
5732 }
5733 
5734 // Following function has been added to support HotSparc's libjvm.so running
5735 // under Solaris production JDK 1.2.2 / 1.3.0.  These came from
5736 // src/solaris/hpi/native_threads in the EVM codebase.
5737 //
5738 // NOTE: This is no longer needed in the 1.3.1 and 1.4 production release
5739 // libraries and should thus be removed. We will leave it behind for a while
5740 // until we no longer want to able to run on top of 1.3.0 Solaris production
5741 // JDK. See 4341971.
5742 
5743 #define STACK_SLACK 0x800
5744 
5745 extern "C" {
5746   intptr_t sysThreadAvailableStackWithSlack() {
5747     stack_t st;
5748     intptr_t retval, stack_top;
5749     retval = thr_stksegment(&st);
5750     assert(retval == 0, "incorrect return value from thr_stksegment");
5751     assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");
5752     assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");
5753     stack_top=(intptr_t)st.ss_sp-st.ss_size;
5754     return ((intptr_t)&stack_top - stack_top - STACK_SLACK);
5755   }
5756 }
5757 
5758 // Just to get the Kernel build to link on solaris for testing.
5759 
5760 extern "C" {
5761 class ASGCT_CallTrace;
5762 void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext)
5763   KERNEL_RETURN;
5764 }
5765 
5766 
5767 // ObjectMonitor park-unpark infrastructure ...
5768 //
5769 // We implement Solaris and Linux PlatformEvents with the
5770 // obvious condvar-mutex-flag triple.
5771 // Another alternative that works quite well is pipes:
5772 // Each PlatformEvent consists of a pipe-pair.
5773 // The thread associated with the PlatformEvent
5774 // calls park(), which reads from the input end of the pipe.
5775 // Unpark() writes into the other end of the pipe.
5776 // The write-side of the pipe must be set NDELAY.
5777 // Unfortunately pipes consume a large # of handles.
5778 // Native solaris lwp_park() and lwp_unpark() work nicely, too.
5779 // Using pipes for the 1st few threads might be workable, however.
5780 //
5781 // park() is permitted to return spuriously.
5782 // Callers of park() should wrap the call to park() in
5783 // an appropriate loop.  A litmus test for the correct
5784 // usage of park is the following: if park() were modified
5785 // to immediately return 0 your code should still work,
5786 // albeit degenerating to a spin loop.
5787 //
5788 // An interesting optimization for park() is to use a trylock()
5789 // to attempt to acquire the mutex.  If the trylock() fails
5790 // then we know that a concurrent unpark() operation is in-progress.
5791 // in that case the park() code could simply set _count to 0
5792 // and return immediately.  The subsequent park() operation *might*
5793 // return immediately.  That's harmless as the caller of park() is
5794 // expected to loop.  By using trylock() we will have avoided a
5795 // avoided a context switch caused by contention on the per-thread mutex.
5796 //
5797 // TODO-FIXME:
5798 // 1.  Reconcile Doug's JSR166 j.u.c park-unpark with the
5799 //     objectmonitor implementation.
5800 // 2.  Collapse the JSR166 parker event, and the
5801 //     objectmonitor ParkEvent into a single "Event" construct.
5802 // 3.  In park() and unpark() add:
5803 //     assert (Thread::current() == AssociatedWith).
5804 // 4.  add spurious wakeup injection on a -XX:EarlyParkReturn=N switch.
5805 //     1-out-of-N park() operations will return immediately.
5806 //
5807 // _Event transitions in park()
5808 //   -1 => -1 : illegal
5809 //    1 =>  0 : pass - return immediately
5810 //    0 => -1 : block
5811 //
5812 // _Event serves as a restricted-range semaphore.
5813 //
5814 // Another possible encoding of _Event would be with
5815 // explicit "PARKED" == 01b and "SIGNALED" == 10b bits.
5816 //
5817 // TODO-FIXME: add DTRACE probes for:
5818 // 1.   Tx parks
5819 // 2.   Ty unparks Tx
5820 // 3.   Tx resumes from park
5821 
5822 
5823 // value determined through experimentation
5824 #define ROUNDINGFIX 11
5825 
5826 // utility to compute the abstime argument to timedwait.
5827 // TODO-FIXME: switch from compute_abstime() to unpackTime().
5828 
5829 static timestruc_t* compute_abstime(timestruc_t* abstime, jlong millis) {
5830   // millis is the relative timeout time
5831   // abstime will be the absolute timeout time
5832   if (millis < 0)  millis = 0;
5833   struct timeval now;
5834   int status = gettimeofday(&now, NULL);
5835   assert(status == 0, "gettimeofday");
5836   jlong seconds = millis / 1000;
5837   jlong max_wait_period;
5838 
5839   if (UseLWPSynchronization) {
5840     // forward port of fix for 4275818 (not sleeping long enough)
5841     // There was a bug in Solaris 6, 7 and pre-patch 5 of 8 where
5842     // _lwp_cond_timedwait() used a round_down algorithm rather
5843     // than a round_up. For millis less than our roundfactor
5844     // it rounded down to 0 which doesn't meet the spec.
5845     // For millis > roundfactor we may return a bit sooner, but
5846     // since we can not accurately identify the patch level and
5847     // this has already been fixed in Solaris 9 and 8 we will
5848     // leave it alone rather than always rounding down.
5849 
5850     if (millis > 0 && millis < ROUNDINGFIX) millis = ROUNDINGFIX;
5851        // It appears that when we go directly through Solaris _lwp_cond_timedwait()
5852            // the acceptable max time threshold is smaller than for libthread on 2.5.1 and 2.6
5853            max_wait_period = 21000000;
5854   } else {
5855     max_wait_period = 50000000;
5856   }
5857   millis %= 1000;
5858   if (seconds > max_wait_period) {      // see man cond_timedwait(3T)
5859      seconds = max_wait_period;
5860   }
5861   abstime->tv_sec = now.tv_sec  + seconds;
5862   long       usec = now.tv_usec + millis * 1000;
5863   if (usec >= 1000000) {
5864     abstime->tv_sec += 1;
5865     usec -= 1000000;
5866   }
5867   abstime->tv_nsec = usec * 1000;
5868   return abstime;
5869 }
5870 
5871 // Test-and-clear _Event, always leaves _Event set to 0, returns immediately.
5872 // Conceptually TryPark() should be equivalent to park(0).
5873 
5874 int os::PlatformEvent::TryPark() {
5875   for (;;) {
5876     const int v = _Event ;
5877     guarantee ((v == 0) || (v == 1), "invariant") ;
5878     if (Atomic::cmpxchg (0, &_Event, v) == v) return v  ;
5879   }
5880 }
5881 
5882 void os::PlatformEvent::park() {           // AKA: down()
5883   // Invariant: Only the thread associated with the Event/PlatformEvent
5884   // may call park().
5885   int v ;
5886   for (;;) {
5887       v = _Event ;
5888       if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
5889   }
5890   guarantee (v >= 0, "invariant") ;
5891   if (v == 0) {
5892      // Do this the hard way by blocking ...
5893      // See http://monaco.sfbay/detail.jsf?cr=5094058.
5894      // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
5895      // Only for SPARC >= V8PlusA
5896 #if defined(__sparc) && defined(COMPILER2)
5897      if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
5898 #endif
5899      int status = os::Solaris::mutex_lock(_mutex);
5900      assert_status(status == 0, status,  "mutex_lock");
5901      guarantee (_nParked == 0, "invariant") ;
5902      ++ _nParked ;
5903      while (_Event < 0) {
5904         // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
5905         // Treat this the same as if the wait was interrupted
5906         // With usr/lib/lwp going to kernel, always handle ETIME
5907         status = os::Solaris::cond_wait(_cond, _mutex);
5908         if (status == ETIME) status = EINTR ;
5909         assert_status(status == 0 || status == EINTR, status, "cond_wait");
5910      }
5911      -- _nParked ;
5912      _Event = 0 ;
5913      status = os::Solaris::mutex_unlock(_mutex);
5914      assert_status(status == 0, status, "mutex_unlock");
5915   }
5916 }
5917 
5918 int os::PlatformEvent::park(jlong millis) {
5919   guarantee (_nParked == 0, "invariant") ;
5920   int v ;
5921   for (;;) {
5922       v = _Event ;
5923       if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ;
5924   }
5925   guarantee (v >= 0, "invariant") ;
5926   if (v != 0) return OS_OK ;
5927 
5928   int ret = OS_TIMEOUT;
5929   timestruc_t abst;
5930   compute_abstime (&abst, millis);
5931 
5932   // See http://monaco.sfbay/detail.jsf?cr=5094058.
5933   // For Solaris SPARC set fprs.FEF=0 prior to parking.
5934   // Only for SPARC >= V8PlusA
5935 #if defined(__sparc) && defined(COMPILER2)
5936  if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
5937 #endif
5938   int status = os::Solaris::mutex_lock(_mutex);
5939   assert_status(status == 0, status, "mutex_lock");
5940   guarantee (_nParked == 0, "invariant") ;
5941   ++ _nParked ;
5942   while (_Event < 0) {
5943      int status = os::Solaris::cond_timedwait(_cond, _mutex, &abst);
5944      assert_status(status == 0 || status == EINTR ||
5945                    status == ETIME || status == ETIMEDOUT,
5946                    status, "cond_timedwait");
5947      if (!FilterSpuriousWakeups) break ;                // previous semantics
5948      if (status == ETIME || status == ETIMEDOUT) break ;
5949      // We consume and ignore EINTR and spurious wakeups.
5950   }
5951   -- _nParked ;
5952   if (_Event >= 0) ret = OS_OK ;
5953   _Event = 0 ;
5954   status = os::Solaris::mutex_unlock(_mutex);
5955   assert_status(status == 0, status, "mutex_unlock");
5956   return ret;
5957 }
5958 
5959 void os::PlatformEvent::unpark() {
5960   int v, AnyWaiters;
5961 
5962   // Increment _Event.
5963   // Another acceptable implementation would be to simply swap 1
5964   // into _Event:
5965   //   if (Swap (&_Event, 1) < 0) {
5966   //      mutex_lock (_mutex) ; AnyWaiters = nParked; mutex_unlock (_mutex) ;
5967   //      if (AnyWaiters) cond_signal (_cond) ;
5968   //   }
5969 
5970   for (;;) {
5971     v = _Event ;
5972     if (v > 0) {
5973        // The LD of _Event could have reordered or be satisfied
5974        // by a read-aside from this processor's write buffer.
5975        // To avoid problems execute a barrier and then
5976        // ratify the value.  A degenerate CAS() would also work.
5977        // Viz., CAS (v+0, &_Event, v) == v).
5978        OrderAccess::fence() ;
5979        if (_Event == v) return ;
5980        continue ;
5981     }
5982     if (Atomic::cmpxchg (v+1, &_Event, v) == v) break ;
5983   }
5984 
5985   // If the thread associated with the event was parked, wake it.
5986   if (v < 0) {
5987      int status ;
5988      // Wait for the thread assoc with the PlatformEvent to vacate.
5989      status = os::Solaris::mutex_lock(_mutex);
5990      assert_status(status == 0, status, "mutex_lock");
5991      AnyWaiters = _nParked ;
5992      status = os::Solaris::mutex_unlock(_mutex);
5993      assert_status(status == 0, status, "mutex_unlock");
5994      guarantee (AnyWaiters == 0 || AnyWaiters == 1, "invariant") ;
5995      if (AnyWaiters != 0) {
5996        // We intentional signal *after* dropping the lock
5997        // to avoid a common class of futile wakeups.
5998        status = os::Solaris::cond_signal(_cond);
5999        assert_status(status == 0, status, "cond_signal");
6000      }
6001   }
6002 }
6003 
6004 // JSR166
6005 // -------------------------------------------------------
6006 
6007 /*
6008  * The solaris and linux implementations of park/unpark are fairly
6009  * conservative for now, but can be improved. They currently use a
6010  * mutex/condvar pair, plus _counter.
6011  * Park decrements _counter if > 0, else does a condvar wait.  Unpark
6012  * sets count to 1 and signals condvar.  Only one thread ever waits
6013  * on the condvar. Contention seen when trying to park implies that someone
6014  * is unparking you, so don't wait. And spurious returns are fine, so there
6015  * is no need to track notifications.
6016  */
6017 
6018 #define NANOSECS_PER_SEC 1000000000
6019 #define NANOSECS_PER_MILLISEC 1000000
6020 #define MAX_SECS 100000000
6021 
6022 /*
6023  * This code is common to linux and solaris and will be moved to a
6024  * common place in dolphin.
6025  *
6026  * The passed in time value is either a relative time in nanoseconds
6027  * or an absolute time in milliseconds. Either way it has to be unpacked
6028  * into suitable seconds and nanoseconds components and stored in the
6029  * given timespec structure.
6030  * Given time is a 64-bit value and the time_t used in the timespec is only
6031  * a signed-32-bit value (except on 64-bit Linux) we have to watch for
6032  * overflow if times way in the future are given. Further on Solaris versions
6033  * prior to 10 there is a restriction (see cond_timedwait) that the specified
6034  * number of seconds, in abstime, is less than current_time  + 100,000,000.
6035  * As it will be 28 years before "now + 100000000" will overflow we can
6036  * ignore overflow and just impose a hard-limit on seconds using the value
6037  * of "now + 100,000,000". This places a limit on the timeout of about 3.17
6038  * years from "now".
6039  */
6040 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
6041   assert (time > 0, "convertTime");
6042 
6043   struct timeval now;
6044   int status = gettimeofday(&now, NULL);
6045   assert(status == 0, "gettimeofday");
6046 
6047   time_t max_secs = now.tv_sec + MAX_SECS;
6048 
6049   if (isAbsolute) {
6050     jlong secs = time / 1000;
6051     if (secs > max_secs) {
6052       absTime->tv_sec = max_secs;
6053     }
6054     else {
6055       absTime->tv_sec = secs;
6056     }
6057     absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
6058   }
6059   else {
6060     jlong secs = time / NANOSECS_PER_SEC;
6061     if (secs >= MAX_SECS) {
6062       absTime->tv_sec = max_secs;
6063       absTime->tv_nsec = 0;
6064     }
6065     else {
6066       absTime->tv_sec = now.tv_sec + secs;
6067       absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
6068       if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
6069         absTime->tv_nsec -= NANOSECS_PER_SEC;
6070         ++absTime->tv_sec; // note: this must be <= max_secs
6071       }
6072     }
6073   }
6074   assert(absTime->tv_sec >= 0, "tv_sec < 0");
6075   assert(absTime->tv_sec <= max_secs, "tv_sec > max_secs");
6076   assert(absTime->tv_nsec >= 0, "tv_nsec < 0");
6077   assert(absTime->tv_nsec < NANOSECS_PER_SEC, "tv_nsec >= nanos_per_sec");
6078 }
6079 
6080 void Parker::park(bool isAbsolute, jlong time) {
6081 
6082   // Optional fast-path check:
6083   // Return immediately if a permit is available.
6084   if (_counter > 0) {
6085       _counter = 0 ;
6086       OrderAccess::fence();
6087       return ;
6088   }
6089 
6090   // Optional fast-exit: Check interrupt before trying to wait
6091   Thread* thread = Thread::current();
6092   assert(thread->is_Java_thread(), "Must be JavaThread");
6093   JavaThread *jt = (JavaThread *)thread;
6094   if (Thread::is_interrupted(thread, false)) {
6095     return;
6096   }
6097 
6098   // First, demultiplex/decode time arguments
6099   timespec absTime;
6100   if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all
6101     return;
6102   }
6103   if (time > 0) {
6104     // Warning: this code might be exposed to the old Solaris time
6105     // round-down bugs.  Grep "roundingFix" for details.
6106     unpackTime(&absTime, isAbsolute, time);
6107   }
6108 
6109   // Enter safepoint region
6110   // Beware of deadlocks such as 6317397.
6111   // The per-thread Parker:: _mutex is a classic leaf-lock.
6112   // In particular a thread must never block on the Threads_lock while
6113   // holding the Parker:: mutex.  If safepoints are pending both the
6114   // the ThreadBlockInVM() CTOR and DTOR may grab Threads_lock.
6115   ThreadBlockInVM tbivm(jt);
6116 
6117   // Don't wait if cannot get lock since interference arises from
6118   // unblocking.  Also. check interrupt before trying wait
6119   if (Thread::is_interrupted(thread, false) ||
6120       os::Solaris::mutex_trylock(_mutex) != 0) {
6121     return;
6122   }
6123 
6124   int status ;
6125 
6126   if (_counter > 0)  { // no wait needed
6127     _counter = 0;
6128     status = os::Solaris::mutex_unlock(_mutex);
6129     assert (status == 0, "invariant") ;
6130     OrderAccess::fence();
6131     return;
6132   }
6133 
6134 #ifdef ASSERT
6135   // Don't catch signals while blocked; let the running threads have the signals.
6136   // (This allows a debugger to break into the running thread.)
6137   sigset_t oldsigs;
6138   sigset_t* allowdebug_blocked = os::Solaris::allowdebug_blocked_signals();
6139   thr_sigsetmask(SIG_BLOCK, allowdebug_blocked, &oldsigs);
6140 #endif
6141 
6142   OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
6143   jt->set_suspend_equivalent();
6144   // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()
6145 
6146   // Do this the hard way by blocking ...
6147   // See http://monaco.sfbay/detail.jsf?cr=5094058.
6148   // TODO-FIXME: for Solaris SPARC set fprs.FEF=0 prior to parking.
6149   // Only for SPARC >= V8PlusA
6150 #if defined(__sparc) && defined(COMPILER2)
6151   if (ClearFPUAtPark) { _mark_fpu_nosave() ; }
6152 #endif
6153 
6154   if (time == 0) {
6155     status = os::Solaris::cond_wait (_cond, _mutex) ;
6156   } else {
6157     status = os::Solaris::cond_timedwait (_cond, _mutex, &absTime);
6158   }
6159   // Note that an untimed cond_wait() can sometimes return ETIME on older
6160   // versions of the Solaris.
6161   assert_status(status == 0 || status == EINTR ||
6162                 status == ETIME || status == ETIMEDOUT,
6163                 status, "cond_timedwait");
6164 
6165 #ifdef ASSERT
6166   thr_sigsetmask(SIG_SETMASK, &oldsigs, NULL);
6167 #endif
6168   _counter = 0 ;
6169   status = os::Solaris::mutex_unlock(_mutex);
6170   assert_status(status == 0, status, "mutex_unlock") ;
6171 
6172   // If externally suspended while waiting, re-suspend
6173   if (jt->handle_special_suspend_equivalent_condition()) {
6174     jt->java_suspend_self();
6175   }
6176   OrderAccess::fence();
6177 }
6178 
6179 void Parker::unpark() {
6180   int s, status ;
6181   status = os::Solaris::mutex_lock (_mutex) ;
6182   assert (status == 0, "invariant") ;
6183   s = _counter;
6184   _counter = 1;
6185   status = os::Solaris::mutex_unlock (_mutex) ;
6186   assert (status == 0, "invariant") ;
6187 
6188   if (s < 1) {
6189     status = os::Solaris::cond_signal (_cond) ;
6190     assert (status == 0, "invariant") ;
6191   }
6192 }
6193 
6194 extern char** environ;
6195 
6196 // Run the specified command in a separate process. Return its exit value,
6197 // or -1 on failure (e.g. can't fork a new process).
6198 // Unlike system(), this function can be called from signal handler. It
6199 // doesn't block SIGINT et al.
6200 int os::fork_and_exec(char* cmd) {
6201   char * argv[4];
6202   argv[0] = (char *)"sh";
6203   argv[1] = (char *)"-c";
6204   argv[2] = cmd;
6205   argv[3] = NULL;
6206 
6207   // fork is async-safe, fork1 is not so can't use in signal handler
6208   pid_t pid;
6209   Thread* t = ThreadLocalStorage::get_thread_slow();
6210   if (t != NULL && t->is_inside_signal_handler()) {
6211     pid = fork();
6212   } else {
6213     pid = fork1();
6214   }
6215 
6216   if (pid < 0) {
6217     // fork failed
6218     warning("fork failed: %s", strerror(errno));
6219     return -1;
6220 
6221   } else if (pid == 0) {
6222     // child process
6223 
6224     // try to be consistent with system(), which uses "/usr/bin/sh" on Solaris
6225     execve("/usr/bin/sh", argv, environ);
6226 
6227     // execve failed
6228     _exit(-1);
6229 
6230   } else  {
6231     // copied from J2SE ..._waitForProcessExit() in UNIXProcess_md.c; we don't
6232     // care about the actual exit code, for now.
6233 
6234     int status;
6235 
6236     // Wait for the child process to exit.  This returns immediately if
6237     // the child has already exited. */
6238     while (waitpid(pid, &status, 0) < 0) {
6239         switch (errno) {
6240         case ECHILD: return 0;
6241         case EINTR: break;
6242         default: return -1;
6243         }
6244     }
6245 
6246     if (WIFEXITED(status)) {
6247        // The child exited normally; get its exit code.
6248        return WEXITSTATUS(status);
6249     } else if (WIFSIGNALED(status)) {
6250        // The child exited because of a signal
6251        // The best value to return is 0x80 + signal number,
6252        // because that is what all Unix shells do, and because
6253        // it allows callers to distinguish between process exit and
6254        // process death by signal.
6255        return 0x80 + WTERMSIG(status);
6256     } else {
6257        // Unknown exit code; pass it through
6258        return status;
6259     }
6260   }
6261 }
6262 
6263 // is_headless_jre()
6264 //
6265 // Test for the existence of libmawt in motif21 or xawt directories
6266 // in order to report if we are running in a headless jre
6267 //
6268 bool os::is_headless_jre() {
6269     struct stat statbuf;
6270     char buf[MAXPATHLEN];
6271     char libmawtpath[MAXPATHLEN];
6272     const char *xawtstr  = "/xawt/libmawt.so";
6273     const char *motifstr = "/motif21/libmawt.so";
6274     char *p;
6275 
6276     // Get path to libjvm.so
6277     os::jvm_path(buf, sizeof(buf));
6278 
6279     // Get rid of libjvm.so
6280     p = strrchr(buf, '/');
6281     if (p == NULL) return false;
6282     else *p = '\0';
6283 
6284     // Get rid of client or server
6285     p = strrchr(buf, '/');
6286     if (p == NULL) return false;
6287     else *p = '\0';
6288 
6289     // check xawt/libmawt.so
6290     strcpy(libmawtpath, buf);
6291     strcat(libmawtpath, xawtstr);
6292     if (::stat(libmawtpath, &statbuf) == 0) return false;
6293 
6294     // check motif21/libmawt.so
6295     strcpy(libmawtpath, buf);
6296     strcat(libmawtpath, motifstr);
6297     if (::stat(libmawtpath, &statbuf) == 0) return false;
6298 
6299     return true;
6300 }
6301 
6302 size_t os::write(int fd, const void *buf, unsigned int nBytes) {
6303   INTERRUPTIBLE_RETURN_INT(::write(fd, buf, nBytes), os::Solaris::clear_interrupted);
6304 }
6305 
6306 int os::close(int fd) {
6307   RESTARTABLE_RETURN_INT(::close(fd));
6308 }
6309 
6310 int os::socket_close(int fd) {
6311   RESTARTABLE_RETURN_INT(::close(fd));
6312 }
6313 
6314 int os::recv(int fd, char *buf, int nBytes, int flags) {
6315   INTERRUPTIBLE_RETURN_INT(::recv(fd, buf, nBytes, flags), os::Solaris::clear_interrupted);
6316 }
6317 
6318 
6319 int os::send(int fd, char *buf, int nBytes, int flags) {
6320   INTERRUPTIBLE_RETURN_INT(::send(fd, buf, nBytes, flags), os::Solaris::clear_interrupted);
6321 }
6322 
6323 int os::raw_send(int fd, char *buf, int nBytes, int flags) {
6324   RESTARTABLE_RETURN_INT(::send(fd, buf, nBytes, flags));
6325 }
6326 
6327 // As both poll and select can be interrupted by signals, we have to be
6328 // prepared to restart the system call after updating the timeout, unless
6329 // a poll() is done with timeout == -1, in which case we repeat with this
6330 // "wait forever" value.
6331 
6332 int os::timeout(int fd, long timeout) {
6333   int res;
6334   struct timeval t;
6335   julong prevtime, newtime;
6336   static const char* aNull = 0;
6337   struct pollfd pfd;
6338   pfd.fd = fd;
6339   pfd.events = POLLIN;
6340 
6341   gettimeofday(&t, &aNull);
6342   prevtime = ((julong)t.tv_sec * 1000)  +  t.tv_usec / 1000;
6343 
6344   for(;;) {
6345     INTERRUPTIBLE_NORESTART(::poll(&pfd, 1, timeout), res, os::Solaris::clear_interrupted);
6346     if(res == OS_ERR && errno == EINTR) {
6347         if(timeout != -1) {
6348           gettimeofday(&t, &aNull);
6349           newtime = ((julong)t.tv_sec * 1000)  +  t.tv_usec /1000;
6350           timeout -= newtime - prevtime;
6351           if(timeout <= 0)
6352             return OS_OK;
6353           prevtime = newtime;
6354         }
6355     } else return res;
6356   }
6357 }
6358 
6359 int os::connect(int fd, struct sockaddr *him, int len) {
6360   int _result;
6361   INTERRUPTIBLE_NORESTART(::connect(fd, him, len), _result,
6362                           os::Solaris::clear_interrupted);
6363 
6364   // Depending on when thread interruption is reset, _result could be
6365   // one of two values when errno == EINTR
6366 
6367   if (((_result == OS_INTRPT) || (_result == OS_ERR))
6368                                         && (errno == EINTR)) {
6369      /* restarting a connect() changes its errno semantics */
6370      INTERRUPTIBLE(::connect(fd, him, len), _result,
6371                      os::Solaris::clear_interrupted);
6372      /* undo these changes */
6373      if (_result == OS_ERR) {
6374        if (errno == EALREADY) {
6375          errno = EINPROGRESS; /* fall through */
6376        } else if (errno == EISCONN) {
6377          errno = 0;
6378          return OS_OK;
6379        }
6380      }
6381    }
6382    return _result;
6383  }
6384 
6385 int os::accept(int fd, struct sockaddr *him, int *len) {
6386   if (fd < 0)
6387    return OS_ERR;
6388   INTERRUPTIBLE_RETURN_INT((int)::accept(fd, him,\
6389     (socklen_t*) len), os::Solaris::clear_interrupted);
6390  }
6391 
6392 int os::recvfrom(int fd, char *buf, int nBytes, int flags,
6393                              sockaddr *from, int *fromlen) {
6394    //%%note jvm_r11
6395   INTERRUPTIBLE_RETURN_INT((int)::recvfrom(fd, buf, nBytes,\
6396     flags, from, fromlen), os::Solaris::clear_interrupted);
6397 }
6398 
6399 int os::sendto(int fd, char *buf, int len, int flags,
6400                            struct sockaddr *to, int tolen) {
6401   //%%note jvm_r11
6402   INTERRUPTIBLE_RETURN_INT((int)::sendto(fd, buf, len, flags,\
6403     to, tolen), os::Solaris::clear_interrupted);
6404 }
6405 
6406 int os::socket_available(int fd, jint *pbytes) {
6407    if (fd < 0)
6408      return OS_OK;
6409 
6410    int ret;
6411 
6412    RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret);
6413 
6414    //%% note ioctl can return 0 when successful, JVM_SocketAvailable
6415    // is expected to return 0 on failure and 1 on success to the jdk.
6416 
6417    return (ret == OS_ERR) ? 0 : 1;
6418 }
6419 
6420 
6421 int os::bind(int fd, struct sockaddr *him, int len) {
6422    INTERRUPTIBLE_RETURN_INT_NORESTART(::bind(fd, him, len),\
6423      os::Solaris::clear_interrupted);
6424 }
6425