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