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