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