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