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