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