1 /*

        2  * Copyright (c) 1997, 2009, 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 // do not include  precompiled  header file

       26 # include "incls/_os_solaris.cpp.incl"

       27 

       28 // put OS-includes here

       29 # include <dlfcn.h>

       30 # include <errno.h>

       31 # include <link.h>

       32 # include <poll.h>

       33 # include <pthread.h>

       34 # include <pwd.h>

       35 # include <schedctl.h>

       36 # include <setjmp.h>

       37 # include <signal.h>

       38 # include <stdio.h>

       39 # include <alloca.h>

       40 # include <sys/filio.h>

       41 # include <sys/ipc.h>

       42 # include <sys/lwp.h>

       43 # include <sys/machelf.h>     // for elf Sym structure used by dladdr1

       44 # include <sys/mman.h>

       45 # include <sys/processor.h>

       46 # include <sys/procset.h>

       47 # include <sys/pset.h>

       48 # include <sys/resource.h>

       49 # include <sys/shm.h>

       50 # include <sys/socket.h>

       51 # include <sys/stat.h>

       52 # include <sys/systeminfo.h>

       53 # include <sys/time.h>

       54 # include <sys/times.h>

       55 # include <sys/types.h>

       56 # include <sys/wait.h>

       57 # include <sys/utsname.h>

       58 # include <thread.h>

       59 # include <unistd.h>

       60 # include <sys/priocntl.h>

       61 # include <sys/rtpriocntl.h>

       62 # include <sys/tspriocntl.h>

       63 # include <sys/iapriocntl.h>

       64 # include <sys/loadavg.h>

       65 # include <string.h>

       66 

       67 # define _STRUCTURED_PROC 1  //  this gets us the new structured proc interfaces of 5.6 & later

       68 # include <sys/procfs.h>     //  see comment in <sys/procfs.h>

       69 

       70 #define MAX_PATH (2 * K)

       71 

       72 // for timer info max values which include all bits

       73 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

       74 

       75 #ifdef _GNU_SOURCE

       76 // See bug #6514594

       77 extern "C" int madvise(caddr_t, size_t, int);

       78 extern "C"  int memcntl(caddr_t addr, size_t len, int cmd, caddr_t  arg,

       79      int attr, int mask);

       80 #endif //_GNU_SOURCE

       81 

       82 /*

       83   MPSS Changes Start.

       84   The JVM binary needs to be built and run on pre-Solaris 9

       85   systems, but the constants needed by MPSS are only in Solaris 9

       86   header files.  They are textually replicated here to allow

       87   building on earlier systems.  Once building on Solaris 8 is

       88   no longer a requirement, these #defines can be replaced by ordinary

       89   system .h inclusion.

       90 

       91   In earlier versions of the  JDK and Solaris, we used ISM for large pages.

       92   But ISM requires shared memory to achieve this and thus has many caveats.

       93   MPSS is a fully transparent and is a cleaner way to get large pages.

       94   Although we still require keeping ISM for backward compatiblitiy as well as

       95   giving the opportunity to use large pages on older systems it is

       96   recommended that MPSS be used for Solaris 9 and above.

       97 

       98 */

       99 

      100 #ifndef MC_HAT_ADVISE

      101 

      102 struct memcntl_mha {

      103   uint_t          mha_cmd;        /* command(s) */

      104   uint_t          mha_flags;

      105   size_t          mha_pagesize;

      106 };

      107 #define MC_HAT_ADVISE   7       /* advise hat map size */

      108 #define MHA_MAPSIZE_VA  0x1     /* set preferred page size */

      109 #define MAP_ALIGN       0x200   /* addr specifies alignment */

      110 

      111 #endif

      112 // MPSS Changes End.

      113 

      114 

      115 // Here are some liblgrp types from sys/lgrp_user.h to be able to

      116 // compile on older systems without this header file.

      117 

      118 #ifndef MADV_ACCESS_LWP

      119 # define  MADV_ACCESS_LWP         7       /* next LWP to access heavily */

      120 #endif

      121 #ifndef MADV_ACCESS_MANY

      122 # define  MADV_ACCESS_MANY        8       /* many processes to access heavily */

      123 #endif

      124 

      125 #ifndef LGRP_RSRC_CPU

      126 # define LGRP_RSRC_CPU           0       /* CPU resources */

      127 #endif

      128 #ifndef LGRP_RSRC_MEM

      129 # define LGRP_RSRC_MEM           1       /* memory resources */

      130 #endif

      131 

      132 // Some more macros from sys/mman.h that are not present in Solaris 8.

      133 

      134 #ifndef MAX_MEMINFO_CNT

      135 /*

      136  * info_req request type definitions for meminfo

      137  * request types starting with MEMINFO_V are used for Virtual addresses

      138  * and should not be mixed with MEMINFO_PLGRP which is targeted for Physical

      139  * addresses

      140  */

      141 # define MEMINFO_SHIFT           16

      142 # define MEMINFO_MASK            (0xFF << MEMINFO_SHIFT)

      143 # define MEMINFO_VPHYSICAL       (0x01 << MEMINFO_SHIFT) /* get physical addr */

      144 # define MEMINFO_VLGRP           (0x02 << MEMINFO_SHIFT) /* get lgroup */

      145 # define MEMINFO_VPAGESIZE       (0x03 << MEMINFO_SHIFT) /* size of phys page */

      146 # define MEMINFO_VREPLCNT        (0x04 << MEMINFO_SHIFT) /* no. of replica */

      147 # define MEMINFO_VREPL           (0x05 << MEMINFO_SHIFT) /* physical replica */

      148 # define MEMINFO_VREPL_LGRP      (0x06 << MEMINFO_SHIFT) /* lgrp of replica */

      149 # define MEMINFO_PLGRP           (0x07 << MEMINFO_SHIFT) /* lgroup for paddr */

      150 

      151 /* maximum number of addresses meminfo() can process at a time */

      152 # define MAX_MEMINFO_CNT 256

      153 

      154 /* maximum number of request types */

      155 # define MAX_MEMINFO_REQ 31

      156 #endif

      157 

      158 // see thr_setprio(3T) for the basis of these numbers

      159 #define MinimumPriority 0

      160 #define NormalPriority  64

      161 #define MaximumPriority 127

      162 

      163 // Values for ThreadPriorityPolicy == 1

      164 int prio_policy1[MaxPriority+1] = { -99999, 0, 16, 32, 48, 64,

      165                                         80, 96, 112, 124, 127 };

      166 

      167 // System parameters used internally

      168 static clock_t clock_tics_per_sec = 100;

      169 

      170 // For diagnostics to print a message once. see run_periodic_checks

      171 static bool check_addr0_done = false;

      172 static sigset_t check_signal_done;

      173 static bool check_signals = true;

      174 

      175 address os::Solaris::handler_start;  // start pc of thr_sighndlrinfo

      176 address os::Solaris::handler_end;    // end pc of thr_sighndlrinfo

      177 

      178 address os::Solaris::_main_stack_base = NULL;  // 4352906 workaround

      179 

      180 

      181 // "default" initializers for missing libc APIs

      182 extern "C" {

      183   static int lwp_mutex_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }

      184   static int lwp_mutex_destroy(mutex_t *mx)                 { return 0; }

      185 

      186   static int lwp_cond_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }

      187   static int lwp_cond_destroy(cond_t *cv)                   { return 0; }

      188 }

      189 

      190 // "default" initializers for pthread-based synchronization

      191 extern "C" {

      192   static int pthread_mutex_default_init(mutex_t *mx, int scope, void *arg) { memset(mx, 0, sizeof(mutex_t)); return 0; }

      193   static int pthread_cond_default_init(cond_t *cv, int scope, void *arg){ memset(cv, 0, sizeof(cond_t)); return 0; }

      194 }

      195 

      196 // Thread Local Storage

      197 // This is common to all Solaris platforms so it is defined here,

      198 // in this common file.

      199 // The declarations are in the os_cpu threadLS*.hpp files.

      200 //

      201 // Static member initialization for TLS

      202 Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};

      203 

      204 #ifndef PRODUCT

      205 #define _PCT(n,d)       ((100.0*(double)(n))/(double)(d))

      206 

      207 int ThreadLocalStorage::_tcacheHit = 0;

      208 int ThreadLocalStorage::_tcacheMiss = 0;

      209 

      210 void ThreadLocalStorage::print_statistics() {

      211   int total = _tcacheMiss+_tcacheHit;

      212   tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",

      213                 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));

      214 }

      215 #undef _PCT

      216 #endif // PRODUCT

      217 

      218 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,

      219                                                         int index) {

      220   Thread *thread = get_thread_slow();

      221   if (thread != NULL) {

      222     address sp = os::current_stack_pointer();

      223     guarantee(thread->_stack_base == NULL ||

      224               (sp <= thread->_stack_base &&

      225                  sp >= thread->_stack_base - thread->_stack_size) ||

      226                is_error_reported(),

      227               "sp must be inside of selected thread stack");

      228 

      229     thread->_self_raw_id = raw_id;  // mark for quick retrieval

      230     _get_thread_cache[ index ] = thread;

      231   }

      232   return thread;

      233 }

      234 

      235 

      236 static const double all_zero[ sizeof(Thread) / sizeof(double) + 1 ] = {0};

      237 #define NO_CACHED_THREAD ((Thread*)all_zero)

      238 

      239 void ThreadLocalStorage::pd_set_thread(Thread* thread) {

      240 

      241   // Store the new value before updating the cache to prevent a race

      242   // between get_thread_via_cache_slowly() and this store operation.

      243   os::thread_local_storage_at_put(ThreadLocalStorage::thread_index(), thread);

      244 

      245   // Update thread cache with new thread if setting on thread create,

      246   // or NO_CACHED_THREAD (zeroed) thread if resetting thread on exit.

      247   uintptr_t raw = pd_raw_thread_id();

      248   int ix = pd_cache_index(raw);

      249   _get_thread_cache[ix] = thread == NULL ? NO_CACHED_THREAD : thread;

      250 }

      251 

      252 void ThreadLocalStorage::pd_init() {

      253   for (int i = 0; i < _pd_cache_size; i++) {

      254     _get_thread_cache[i] = NO_CACHED_THREAD;

      255   }

      256 }

      257 

      258 // Invalidate all the caches (happens to be the same as pd_init).

      259 void ThreadLocalStorage::pd_invalidate_all() { pd_init(); }

      260 

      261 #undef NO_CACHED_THREAD

      262 

      263 // END Thread Local Storage

      264 

      265 static inline size_t adjust_stack_size(address base, size_t size) {

      266   if ((ssize_t)size < 0) {

      267     // 4759953: Compensate for ridiculous stack size.

      268     size = max_intx;

      269   }

      270   if (size > (size_t)base) {

      271     // 4812466: Make sure size doesn't allow the stack to wrap the address space.

      272     size = (size_t)base;

      273   }

      274   return size;

      275 }

      276 

      277 static inline stack_t get_stack_info() {

      278   stack_t st;

      279   int retval = thr_stksegment(&st);

      280   st.ss_size = adjust_stack_size((address)st.ss_sp, st.ss_size);

      281   assert(retval == 0, "incorrect return value from thr_stksegment");

      282   assert((address)&st < (address)st.ss_sp, "Invalid stack base returned");

      283   assert((address)&st > (address)st.ss_sp-st.ss_size, "Invalid stack size returned");

      284   return st;

      285 }

      286 

      287 address os::current_stack_base() {

      288   int r = thr_main() ;

      289   guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;

      290   bool is_primordial_thread = r;

      291 

      292   // Workaround 4352906, avoid calls to thr_stksegment by

      293   // thr_main after the first one (it looks like we trash

      294   // some data, causing the value for ss_sp to be incorrect).

      295   if (!is_primordial_thread || os::Solaris::_main_stack_base == NULL) {

      296     stack_t st = get_stack_info();

      297     if (is_primordial_thread) {

      298       // cache initial value of stack base

      299       os::Solaris::_main_stack_base = (address)st.ss_sp;

      300     }

      301     return (address)st.ss_sp;

      302   } else {

      303     guarantee(os::Solaris::_main_stack_base != NULL, "Attempt to use null cached stack base");

      304     return os::Solaris::_main_stack_base;

      305   }

      306 }

      307 

      308 size_t os::current_stack_size() {

      309   size_t size;

      310 

      311   int r = thr_main() ;

      312   guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;

      313   if(!r) {

      314     size = get_stack_info().ss_size;

      315   } else {

      316     struct rlimit limits;

      317     getrlimit(RLIMIT_STACK, &limits);

      318     size = adjust_stack_size(os::Solaris::_main_stack_base, (size_t)limits.rlim_cur);

      319   }

      320   // base may not be page aligned

      321   address base = current_stack_base();

      322   address bottom = (address)align_size_up((intptr_t)(base - size), os::vm_page_size());;

      323   return (size_t)(base - bottom);

      324 }

      325 

      326 struct tm* os::localtime_pd(const time_t* clock, struct tm*  res) {

      327   return localtime_r(clock, res);

      328 }

      329 

      330 // interruptible infrastructure

      331 

      332 // setup_interruptible saves the thread state before going into an

      333 // interruptible system call.

      334 // The saved state is used to restore the thread to

      335 // its former state whether or not an interrupt is received.

      336 // Used by classloader os::read

      337 // hpi calls skip this layer and stay in _thread_in_native

      338 

      339 void os::Solaris::setup_interruptible(JavaThread* thread) {

      340 

      341   JavaThreadState thread_state = thread->thread_state();

      342 

      343   assert(thread_state != _thread_blocked, "Coming from the wrong thread");

      344   assert(thread_state != _thread_in_native, "Native threads skip setup_interruptible");

      345   OSThread* osthread = thread->osthread();

      346   osthread->set_saved_interrupt_thread_state(thread_state);

      347   thread->frame_anchor()->make_walkable(thread);

      348   ThreadStateTransition::transition(thread, thread_state, _thread_blocked);

      349 }

      350 

      351 // Version of setup_interruptible() for threads that are already in

      352 // _thread_blocked. Used by os_sleep().

      353 void os::Solaris::setup_interruptible_already_blocked(JavaThread* thread) {

      354   thread->frame_anchor()->make_walkable(thread);

      355 }

      356 

      357 JavaThread* os::Solaris::setup_interruptible() {

      358   JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();

      359   setup_interruptible(thread);

      360   return thread;

      361 }

      362 

      363 void os::Solaris::try_enable_extended_io() {

      364   typedef int (*enable_extended_FILE_stdio_t)(int, int);

      365 

      366   if (!UseExtendedFileIO) {

      367     return;

      368   }

      369 

      370   enable_extended_FILE_stdio_t enabler =

      371     (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,

      372                                          "enable_extended_FILE_stdio");

      373   if (enabler) {

      374     enabler(-1, -1);

      375   }

      376 }

      377 

      378 

      379 #ifdef ASSERT

      380 

      381 JavaThread* os::Solaris::setup_interruptible_native() {

      382   JavaThread* thread = (JavaThread*)ThreadLocalStorage::thread();

      383   JavaThreadState thread_state = thread->thread_state();

      384   assert(thread_state == _thread_in_native, "Assumed thread_in_native");

      385   return thread;

      386 }

      387 

      388 void os::Solaris::cleanup_interruptible_native(JavaThread* thread) {

      389   JavaThreadState thread_state = thread->thread_state();

      390   assert(thread_state == _thread_in_native, "Assumed thread_in_native");

      391 }

      392 #endif

      393 

      394 // cleanup_interruptible reverses the effects of setup_interruptible

      395 // setup_interruptible_already_blocked() does not need any cleanup.

      396 

      397 void os::Solaris::cleanup_interruptible(JavaThread* thread) {

      398   OSThread* osthread = thread->osthread();

      399 

      400   ThreadStateTransition::transition(thread, _thread_blocked, osthread->saved_interrupt_thread_state());

      401 }

      402 

      403 // I/O interruption related counters called in _INTERRUPTIBLE

      404 

      405 void os::Solaris::bump_interrupted_before_count() {

      406   RuntimeService::record_interrupted_before_count();

      407 }

      408 

      409 void os::Solaris::bump_interrupted_during_count() {

      410   RuntimeService::record_interrupted_during_count();

      411 }

      412 

      413 static int _processors_online = 0;

      414 

      415          jint os::Solaris::_os_thread_limit = 0;

      416 volatile jint os::Solaris::_os_thread_count = 0;

      417 

      418 julong os::available_memory() {

      419   return Solaris::available_memory();

      420 }

      421 

      422 julong os::Solaris::available_memory() {

      423   return (julong)sysconf(_SC_AVPHYS_PAGES) * os::vm_page_size();

      424 }

      425 

      426 julong os::Solaris::_physical_memory = 0;

      427 

      428 julong os::physical_memory() {

      429    return Solaris::physical_memory();

      430 }

      431 

      432 julong os::allocatable_physical_memory(julong size) {

      433 #ifdef _LP64

      434    return size;

      435 #else

      436    julong result = MIN2(size, (julong)3835*M);

      437    if (!is_allocatable(result)) {

      438      // Memory allocations will be aligned but the alignment

      439      // is not known at this point.  Alignments will

      440      // be at most to LargePageSizeInBytes.  Protect

      441      // allocations from alignments up to illegal

      442      // values. If at this point 2G is illegal.

      443      julong reasonable_size = (julong)2*G - 2 * LargePageSizeInBytes;

      444      result =  MIN2(size, reasonable_size);

      445    }

      446    return result;

      447 #endif

      448 }

      449 

      450 static hrtime_t first_hrtime = 0;

      451 static const hrtime_t hrtime_hz = 1000*1000*1000;

      452 const int LOCK_BUSY = 1;

      453 const int LOCK_FREE = 0;

      454 const int LOCK_INVALID = -1;

      455 static volatile hrtime_t max_hrtime = 0;

      456 static volatile int max_hrtime_lock = LOCK_FREE;     // Update counter with LSB as lock-in-progress

      457 

      458 

      459 void os::Solaris::initialize_system_info() {

      460   set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

      461   _processors_online = sysconf (_SC_NPROCESSORS_ONLN);

      462   _physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);

      463 }

      464 

      465 int os::active_processor_count() {

      466   int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);

      467   pid_t pid = getpid();

      468   psetid_t pset = PS_NONE;

      469   // Are we running in a processor set or is there any processor set around?

      470   if (pset_bind(PS_QUERY, P_PID, pid, &pset) == 0) {

      471     uint_t pset_cpus;

      472     // Query the number of cpus available to us.

      473     if (pset_info(pset, NULL, &pset_cpus, NULL) == 0) {

      474       assert(pset_cpus > 0 && pset_cpus <= online_cpus, "sanity check");

      475       _processors_online = pset_cpus;

      476       return pset_cpus;

      477     }

      478   }

      479   // Otherwise return number of online cpus

      480   return online_cpus;

      481 }

      482 

      483 static bool find_processors_in_pset(psetid_t        pset,

      484                                     processorid_t** id_array,

      485                                     uint_t*         id_length) {

      486   bool result = false;

      487   // Find the number of processors in the processor set.

      488   if (pset_info(pset, NULL, id_length, NULL) == 0) {

      489     // Make up an array to hold their ids.

      490     *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);

      491     // Fill in the array with their processor ids.

      492     if (pset_info(pset, NULL, id_length, *id_array) == 0) {

      493       result = true;

      494     }

      495   }

      496   return result;

      497 }

      498 

      499 // Callers of find_processors_online() must tolerate imprecise results --

      500 // the system configuration can change asynchronously because of DR

      501 // or explicit psradm operations.

      502 //

      503 // We also need to take care that the loop (below) terminates as the

      504 // number of processors online can change between the _SC_NPROCESSORS_ONLN

      505 // request and the loop that builds the list of processor ids.   Unfortunately

      506 // there's no reliable way to determine the maximum valid processor id,

      507 // so we use a manifest constant, MAX_PROCESSOR_ID, instead.  See p_online

      508 // man pages, which claim the processor id set is "sparse, but

      509 // not too sparse".  MAX_PROCESSOR_ID is used to ensure that we eventually

      510 // exit the loop.

      511 //

      512 // In the future we'll be able to use sysconf(_SC_CPUID_MAX), but that's

      513 // not available on S8.0.

      514 

      515 static bool find_processors_online(processorid_t** id_array,

      516                                    uint*           id_length) {

      517   const processorid_t MAX_PROCESSOR_ID = 100000 ;

      518   // Find the number of processors online.

      519   *id_length = sysconf(_SC_NPROCESSORS_ONLN);

      520   // Make up an array to hold their ids.

      521   *id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);

      522   // Processors need not be numbered consecutively.

      523   long found = 0;

      524   processorid_t next = 0;

      525   while (found < *id_length && next < MAX_PROCESSOR_ID) {

      526     processor_info_t info;

      527     if (processor_info(next, &info) == 0) {

      528       // NB, PI_NOINTR processors are effectively online ...

      529       if (info.pi_state == P_ONLINE || info.pi_state == P_NOINTR) {

      530         (*id_array)[found] = next;

      531         found += 1;

      532       }

      533     }

      534     next += 1;

      535   }

      536   if (found < *id_length) {

      537       // The loop above didn't identify the expected number of processors.

      538       // We could always retry the operation, calling sysconf(_SC_NPROCESSORS_ONLN)

      539       // and re-running the loop, above, but there's no guarantee of progress

      540       // if the system configuration is in flux.  Instead, we just return what

      541       // we've got.  Note that in the worst case find_processors_online() could

      542       // return an empty set.  (As a fall-back in the case of the empty set we

      543       // could just return the ID of the current processor).

      544       *id_length = found ;

      545   }

      546 

      547   return true;

      548 }

      549 

      550 static bool assign_distribution(processorid_t* id_array,

      551                                 uint           id_length,

      552                                 uint*          distribution,

      553                                 uint           distribution_length) {

      554   // We assume we can assign processorid_t's to uint's.

      555   assert(sizeof(processorid_t) == sizeof(uint),

      556          "can't convert processorid_t to uint");

      557   // Quick check to see if we won't succeed.

      558   if (id_length < distribution_length) {

      559     return false;

      560   }

      561   // Assign processor ids to the distribution.

      562   // Try to shuffle processors to distribute work across boards,

      563   // assuming 4 processors per board.

      564   const uint processors_per_board = ProcessDistributionStride;

      565   // Find the maximum processor id.

      566   processorid_t max_id = 0;

      567   for (uint m = 0; m < id_length; m += 1) {

      568     max_id = MAX2(max_id, id_array[m]);

      569   }

      570   // The next id, to limit loops.

      571   const processorid_t limit_id = max_id + 1;

      572   // Make up markers for available processors.

      573   bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id);

      574   for (uint c = 0; c < limit_id; c += 1) {

      575     available_id[c] = false;

      576   }

      577   for (uint a = 0; a < id_length; a += 1) {

      578     available_id[id_array[a]] = true;

      579   }

      580   // Step by "boards", then by "slot", copying to "assigned".

      581   // NEEDS_CLEANUP: The assignment of processors should be stateful,

      582   //                remembering which processors have been assigned by

      583   //                previous calls, etc., so as to distribute several

      584   //                independent calls of this method.  What we'd like is

      585   //                It would be nice to have an API that let us ask

      586   //                how many processes are bound to a processor,

      587   //                but we don't have that, either.

      588   //                In the short term, "board" is static so that

      589   //                subsequent distributions don't all start at board 0.

      590   static uint board = 0;

      591   uint assigned = 0;

      592   // Until we've found enough processors ....

      593   while (assigned < distribution_length) {

      594     // ... find the next available processor in the board.

      595     for (uint slot = 0; slot < processors_per_board; slot += 1) {

      596       uint try_id = board * processors_per_board + slot;

      597       if ((try_id < limit_id) && (available_id[try_id] == true)) {

      598         distribution[assigned] = try_id;

      599         available_id[try_id] = false;

      600         assigned += 1;

      601         break;

      602       }

      603     }

      604     board += 1;

      605     if (board * processors_per_board + 0 >= limit_id) {

      606       board = 0;

      607     }

      608   }

      609   if (available_id != NULL) {

      610     FREE_C_HEAP_ARRAY(bool, available_id);

      611   }

      612   return true;

      613 }

      614 

      615 bool os::distribute_processes(uint length, uint* distribution) {

      616   bool result = false;

      617   // Find the processor id's of all the available CPUs.

      618   processorid_t* id_array  = NULL;

      619   uint           id_length = 0;

      620   // There are some races between querying information and using it,

      621   // since processor sets can change dynamically.

      622   psetid_t pset = PS_NONE;

      623   // Are we running in a processor set?

      624   if ((pset_bind(PS_QUERY, P_PID, P_MYID, &pset) == 0) && pset != PS_NONE) {

      625     result = find_processors_in_pset(pset, &id_array, &id_length);

      626   } else {

      627     result = find_processors_online(&id_array, &id_length);

      628   }

      629   if (result == true) {

      630     if (id_length >= length) {

      631       result = assign_distribution(id_array, id_length, distribution, length);

      632     } else {

      633       result = false;

      634     }

      635   }

      636   if (id_array != NULL) {

      637     FREE_C_HEAP_ARRAY(processorid_t, id_array);

      638   }

      639   return result;

      640 }

      641 

      642 bool os::bind_to_processor(uint processor_id) {

      643   // We assume that a processorid_t can be stored in a uint.

      644   assert(sizeof(uint) == sizeof(processorid_t),

      645          "can't convert uint to processorid_t");

      646   int bind_result =

      647     processor_bind(P_LWPID,                       // bind LWP.

      648                    P_MYID,                        // bind current LWP.

      649                    (processorid_t) processor_id,  // id.

      650                    NULL);                         // don't return old binding.

      651   return (bind_result == 0);

      652 }

      653 

      654 bool os::getenv(const char* name, char* buffer, int len) {

      655   char* val = ::getenv( name );

      656   if ( val == NULL

      657   ||   strlen(val) + 1  >  len ) {

      658     if (len > 0)  buffer[0] = 0; // return a null string

      659     return false;

      660   }

      661   strcpy( buffer, val );

      662   return true;

      663 }

      664 

      665 

      666 // Return true if user is running as root.

      667 

      668 bool os::have_special_privileges() {

      669   static bool init = false;

      670   static bool privileges = false;

      671   if (!init) {

      672     privileges = (getuid() != geteuid()) || (getgid() != getegid());

      673     init = true;

      674   }

      675   return privileges;

      676 }

      677 

      678 

      679 void os::init_system_properties_values() {

      680   char arch[12];

      681   sysinfo(SI_ARCHITECTURE, arch, sizeof(arch));

      682 

      683   // The next steps are taken in the product version:

      684   //

      685   // Obtain the JAVA_HOME value from the location of libjvm[_g].so.

      686   // This library should be located at:

      687   // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm[_g].so.

      688   //

      689   // If "/jre/lib/" appears at the right place in the path, then we

      690   // assume libjvm[_g].so is installed in a JDK and we use this path.

      691   //

      692   // Otherwise exit with message: "Could not create the Java virtual machine."

      693   //

      694   // The following extra steps are taken in the debugging version:

      695   //

      696   // If "/jre/lib/" does NOT appear at the right place in the path

      697   // instead of exit check for $JAVA_HOME environment variable.

      698   //

      699   // If it is defined and we are able to locate $JAVA_HOME/jre/lib/<arch>,

      700   // then we append a fake suffix "hotspot/libjvm[_g].so" to this path so

      701   // it looks like libjvm[_g].so is installed there

      702   // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm[_g].so.

      703   //

      704   // Otherwise exit.

      705   //

      706   // Important note: if the location of libjvm.so changes this

      707   // code needs to be changed accordingly.

      708 

      709   // The next few definitions allow the code to be verbatim:

      710 #define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))

      711 #define free(p) FREE_C_HEAP_ARRAY(char, p)

      712 #define getenv(n) ::getenv(n)

      713 

      714 #define EXTENSIONS_DIR  "/lib/ext"

      715 #define ENDORSED_DIR    "/lib/endorsed"

      716 #define COMMON_DIR      "/usr/jdk/packages"

      717 

      718   {

      719     /* sysclasspath, java_home, dll_dir */

      720     {

      721         char *home_path;

      722         char *dll_path;

      723         char *pslash;

      724         char buf[MAXPATHLEN];

      725         os::jvm_path(buf, sizeof(buf));

      726 

      727         // Found the full path to libjvm.so.

      728         // Now cut the path to <java_home>/jre if we can.

      729         *(strrchr(buf, '/')) = '\0';  /* get rid of /libjvm.so */

      730         pslash = strrchr(buf, '/');

      731         if (pslash != NULL)

      732             *pslash = '\0';           /* get rid of /{client|server|hotspot} */

      733         dll_path = malloc(strlen(buf) + 1);

      734         if (dll_path == NULL)

      735             return;

      736         strcpy(dll_path, buf);

      737         Arguments::set_dll_dir(dll_path);

      738 

      739         if (pslash != NULL) {

      740             pslash = strrchr(buf, '/');

      741             if (pslash != NULL) {

      742                 *pslash = '\0';       /* get rid of /<arch> */

      743                 pslash = strrchr(buf, '/');

      744                 if (pslash != NULL)

      745                     *pslash = '\0';   /* get rid of /lib */

      746             }

      747         }

      748 

      749         home_path = malloc(strlen(buf) + 1);

      750         if (home_path == NULL)

      751             return;

      752         strcpy(home_path, buf);

      753         Arguments::set_java_home(home_path);

      754 

      755         if (!set_boot_path('/', ':'))

      756             return;

      757     }

      758 

      759     /*

      760      * Where to look for native libraries

      761      */

      762     {

      763       // Use dlinfo() to determine the correct java.library.path.

      764       //

      765       // If we're launched by the Java launcher, and the user

      766       // does not set java.library.path explicitly on the commandline,

      767       // the Java launcher sets LD_LIBRARY_PATH for us and unsets

      768       // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64.  In this case

      769       // dlinfo returns LD_LIBRARY_PATH + crle settings (including

      770       // /usr/lib), which is exactly what we want.

      771       //

      772       // If the user does set java.library.path, it completely

      773       // overwrites this setting, and always has.

      774       //

      775       // If we're not launched by the Java launcher, we may

      776       // get here with any/all of the LD_LIBRARY_PATH[_32|64]

      777       // settings.  Again, dlinfo does exactly what we want.

      778 

      779       Dl_serinfo     _info, *info = &_info;

      780       Dl_serpath     *path;

      781       char*          library_path;

      782       char           *common_path;

      783       int            i;

      784 

      785       // determine search path count and required buffer size

      786       if (dlinfo(RTLD_SELF, RTLD_DI_SERINFOSIZE, (void *)info) == -1) {

      787         vm_exit_during_initialization("dlinfo SERINFOSIZE request", dlerror());

      788       }

      789 

      790       // allocate new buffer and initialize

      791       info = (Dl_serinfo*)malloc(_info.dls_size);

      792       if (info == NULL) {

      793         vm_exit_out_of_memory(_info.dls_size,

      794                               "init_system_properties_values info");

      795       }

      796       info->dls_size = _info.dls_size;

      797       info->dls_cnt = _info.dls_cnt;

      798 

      799       // obtain search path information

      800       if (dlinfo(RTLD_SELF, RTLD_DI_SERINFO, (void *)info) == -1) {

      801         free(info);

      802         vm_exit_during_initialization("dlinfo SERINFO request", dlerror());

      803       }

      804 

      805       path = &info->dls_serpath[0];

      806 

      807       // Note: Due to a legacy implementation, most of the library path

      808       // is set in the launcher.  This was to accomodate linking restrictions

      809       // on legacy Solaris implementations (which are no longer supported).

      810       // Eventually, all the library path setting will be done here.

      811       //

      812       // However, to prevent the proliferation of improperly built native

      813       // libraries, the new path component /usr/jdk/packages is added here.

      814 

      815       // Determine the actual CPU architecture.

      816       char cpu_arch[12];

      817       sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));

      818 #ifdef _LP64

      819       // If we are a 64-bit vm, perform the following translations:

      820       //   sparc   -> sparcv9

      821       //   i386    -> amd64

      822       if (strcmp(cpu_arch, "sparc") == 0)

      823         strcat(cpu_arch, "v9");

      824       else if (strcmp(cpu_arch, "i386") == 0)

      825         strcpy(cpu_arch, "amd64");

      826 #endif

      827 

      828       // Construct the invariant part of ld_library_path. Note that the

      829       // space for the colon and the trailing null are provided by the

      830       // nulls included by the sizeof operator.

      831       size_t bufsize = sizeof(COMMON_DIR) + sizeof("/lib/") + strlen(cpu_arch);

      832       common_path = malloc(bufsize);

      833       if (common_path == NULL) {

      834         free(info);

      835         vm_exit_out_of_memory(bufsize,

      836                               "init_system_properties_values common_path");

      837       }

      838       sprintf(common_path, COMMON_DIR "/lib/%s", cpu_arch);

      839 

      840       // struct size is more than sufficient for the path components obtained

      841       // through the dlinfo() call, so only add additional space for the path

      842       // components explicitly added here.

      843       bufsize = info->dls_size + strlen(common_path);

      844       library_path = malloc(bufsize);

      845       if (library_path == NULL) {

      846         free(info);

      847         free(common_path);

      848         vm_exit_out_of_memory(bufsize,

      849                               "init_system_properties_values library_path");

      850       }

      851       library_path[0] = '\0';

      852 

      853       // Construct the desired Java library path from the linker's library

      854       // search path.

      855       //

      856       // For compatibility, it is optimal that we insert the additional path

      857       // components specific to the Java VM after those components specified

      858       // in LD_LIBRARY_PATH (if any) but before those added by the ld.so

      859       // infrastructure.

      860       if (info->dls_cnt == 0) { // Not sure this can happen, but allow for it

      861         strcpy(library_path, common_path);

      862       } else {

      863         int inserted = 0;

      864         for (i = 0; i < info->dls_cnt; i++, path++) {

      865           uint_t flags = path->dls_flags & LA_SER_MASK;

      866           if (((flags & LA_SER_LIBPATH) == 0) && !inserted) {

      867             strcat(library_path, common_path);

      868             strcat(library_path, os::path_separator());

      869             inserted = 1;

      870           }

      871           strcat(library_path, path->dls_name);

      872           strcat(library_path, os::path_separator());

      873         }

      874         // eliminate trailing path separator

      875         library_path[strlen(library_path)-1] = '\0';

      876       }

      877 

      878       // happens before argument parsing - can't use a trace flag

      879       // tty->print_raw("init_system_properties_values: native lib path: ");

      880       // tty->print_raw_cr(library_path);

      881 

      882       // callee copies into its own buffer

      883       Arguments::set_library_path(library_path);

      884 

      885       free(common_path);

      886       free(library_path);

      887       free(info);

      888     }

      889 

      890     /*

      891      * Extensions directories.

      892      *

      893      * Note that the space for the colon and the trailing null are provided

      894      * by the nulls included by the sizeof operator (so actually one byte more

      895      * than necessary is allocated).

      896      */

      897     {

      898         char *buf = (char *) malloc(strlen(Arguments::get_java_home()) +

      899             sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) +

      900             sizeof(EXTENSIONS_DIR));

      901         sprintf(buf, "%s" EXTENSIONS_DIR ":" COMMON_DIR EXTENSIONS_DIR,

      902             Arguments::get_java_home());

      903         Arguments::set_ext_dirs(buf);

      904     }

      905 

      906     /* Endorsed standards default directory. */

      907     {

      908         char * buf = malloc(strlen(Arguments::get_java_home()) + sizeof(ENDORSED_DIR));

      909         sprintf(buf, "%s" ENDORSED_DIR, Arguments::get_java_home());

      910         Arguments::set_endorsed_dirs(buf);

      911     }

      912   }

      913 

      914 #undef malloc

      915 #undef free

      916 #undef getenv

      917 #undef EXTENSIONS_DIR

      918 #undef ENDORSED_DIR

      919 #undef COMMON_DIR

      920 

      921 }

      922 

      923 void os::breakpoint() {

      924   BREAKPOINT;

      925 }

      926 

      927 bool os::obsolete_option(const JavaVMOption *option)

      928 {

      929   if (!strncmp(option->optionString, "-Xt", 3)) {

      930     return true;

      931   } else if (!strncmp(option->optionString, "-Xtm", 4)) {

      932     return true;

      933   } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) {

      934     return true;

      935   } else if (!strncmp(option->optionString, "-Xmaxjitcodesize", 16)) {

      936     return true;

      937   }

      938   return false;

      939 }

      940 

      941 bool os::Solaris::valid_stack_address(Thread* thread, address sp) {

      942   address  stackStart  = (address)thread->stack_base();

      943   address  stackEnd    = (address)(stackStart - (address)thread->stack_size());

      944   if (sp < stackStart && sp >= stackEnd ) return true;

      945   return false;

      946 }

      947 

      948 extern "C" void breakpoint() {

      949   // use debugger to set breakpoint here

      950 }

      951 

      952 // Returns an estimate of the current stack pointer. Result must be guaranteed to

      953 // point into the calling threads stack, and be no lower than the current stack

      954 // pointer.

      955 address os::current_stack_pointer() {

      956   volatile int dummy;

      957   address sp = (address)&dummy + 8;     // %%%% need to confirm if this is right

      958   return sp;

      959 }

      960 

      961 static thread_t main_thread;

      962 

      963 // Thread start routine for all new Java threads

      964 extern "C" void* java_start(void* thread_addr) {

      965   // Try to randomize the cache line index of hot stack frames.

      966   // This helps when threads of the same stack traces evict each other's

      967   // cache lines. The threads can be either from the same JVM instance, or

      968   // from different JVM instances. The benefit is especially true for

      969   // processors with hyperthreading technology.

      970   static int counter = 0;

      971   int pid = os::current_process_id();

      972   alloca(((pid ^ counter++) & 7) * 128);

      973 

      974   int prio;

      975   Thread* thread = (Thread*)thread_addr;

      976   OSThread* osthr = thread->osthread();

      977 

      978   osthr->set_lwp_id( _lwp_self() );  // Store lwp in case we are bound

      979   thread->_schedctl = (void *) schedctl_init () ;

      980 

      981   if (UseNUMA) {

      982     int lgrp_id = os::numa_get_group_id();

      983     if (lgrp_id != -1) {

      984       thread->set_lgrp_id(lgrp_id);

      985     }

      986   }

      987 

      988   // If the creator called set priority before we started,

      989   // we need to call set priority now that we have an lwp.

      990   // Get the priority from libthread and set the priority

      991   // for the new Solaris lwp.

      992   if ( osthr->thread_id() != -1 ) {

      993     if ( UseThreadPriorities ) {

      994       thr_getprio(osthr->thread_id(), &prio);

      995       if (ThreadPriorityVerbose) {

      996         tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT ", setting priority: %d\n",

      997                       osthr->thread_id(), osthr->lwp_id(), prio );

      998       }

      999       os::set_native_priority(thread, prio);

     1000     }

     1001   } else if (ThreadPriorityVerbose) {

     1002     warning("Can't set priority in _start routine, thread id hasn't been set\n");

     1003   }

     1004 

     1005   assert(osthr->get_state() == RUNNABLE, "invalid os thread state");

     1006 

     1007   // initialize signal mask for this thread

     1008   os::Solaris::hotspot_sigmask(thread);

     1009 

     1010   thread->run();

     1011 

     1012   // One less thread is executing

     1013   // When the VMThread gets here, the main thread may have already exited

     1014   // which frees the CodeHeap containing the Atomic::dec code

     1015   if (thread != VMThread::vm_thread() && VMThread::vm_thread() != NULL) {

     1016     Atomic::dec(&os::Solaris::_os_thread_count);

     1017   }

     1018 

     1019   if (UseDetachedThreads) {

     1020     thr_exit(NULL);

     1021     ShouldNotReachHere();

     1022   }

     1023   return NULL;

     1024 }

     1025 

     1026 static OSThread* create_os_thread(Thread* thread, thread_t thread_id) {

     1027   // Allocate the OSThread object

     1028   OSThread* osthread = new OSThread(NULL, NULL);

     1029   if (osthread == NULL) return NULL;

     1030 

     1031   // Store info on the Solaris thread into the OSThread

     1032   osthread->set_thread_id(thread_id);

     1033   osthread->set_lwp_id(_lwp_self());

     1034   thread->_schedctl = (void *) schedctl_init () ;

     1035 

     1036   if (UseNUMA) {

     1037     int lgrp_id = os::numa_get_group_id();

     1038     if (lgrp_id != -1) {

     1039       thread->set_lgrp_id(lgrp_id);

     1040     }

     1041   }

     1042 

     1043   if ( ThreadPriorityVerbose ) {

     1044     tty->print_cr("In create_os_thread, Thread " INTPTR_FORMAT ", LWP is " INTPTR_FORMAT "\n",

     1045                   osthread->thread_id(), osthread->lwp_id() );

     1046   }

     1047 

     1048   // Initial thread state is INITIALIZED, not SUSPENDED

     1049   osthread->set_state(INITIALIZED);

     1050 

     1051   return osthread;

     1052 }

     1053 

     1054 void os::Solaris::hotspot_sigmask(Thread* thread) {

     1055 

     1056   //Save caller's signal mask

     1057   sigset_t sigmask;

     1058   thr_sigsetmask(SIG_SETMASK, NULL, &sigmask);

     1059   OSThread *osthread = thread->osthread();

     1060   osthread->set_caller_sigmask(sigmask);

     1061 

     1062   thr_sigsetmask(SIG_UNBLOCK, os::Solaris::unblocked_signals(), NULL);

     1063   if (!ReduceSignalUsage) {

     1064     if (thread->is_VM_thread()) {

     1065       // Only the VM thread handles BREAK_SIGNAL ...

     1066       thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL);

     1067     } else {

     1068       // ... all other threads block BREAK_SIGNAL

     1069       assert(!sigismember(vm_signals(), SIGINT), "SIGINT should not be blocked");

     1070       thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL);

     1071     }

     1072   }

     1073 }

     1074 

     1075 bool os::create_attached_thread(JavaThread* thread) {

     1076 #ifdef ASSERT

     1077   thread->verify_not_published();

     1078 #endif

     1079   OSThread* osthread = create_os_thread(thread, thr_self());

     1080   if (osthread == NULL) {

     1081      return false;

     1082   }

     1083 

     1084   // Initial thread state is RUNNABLE

     1085   osthread->set_state(RUNNABLE);

     1086   thread->set_osthread(osthread);

     1087 

     1088   // initialize signal mask for this thread

     1089   // and save the caller's signal mask

     1090   os::Solaris::hotspot_sigmask(thread);

     1091 

     1092   return true;

     1093 }

     1094 

     1095 bool os::create_main_thread(JavaThread* thread) {

     1096 #ifdef ASSERT

     1097   thread->verify_not_published();

     1098 #endif

     1099   if (_starting_thread == NULL) {

     1100     _starting_thread = create_os_thread(thread, main_thread);

     1101      if (_starting_thread == NULL) {

     1102         return false;

     1103      }

     1104   }

     1105 

     1106   // The primodial thread is runnable from the start

     1107   _starting_thread->set_state(RUNNABLE);

     1108 

     1109   thread->set_osthread(_starting_thread);

     1110 

     1111   // initialize signal mask for this thread

     1112   // and save the caller's signal mask

     1113   os::Solaris::hotspot_sigmask(thread);

     1114 

     1115   return true;

     1116 }

     1117 

     1118 // _T2_libthread is true if we believe we are running with the newer

     1119 // SunSoft lwp/libthread.so (2.8 patch, 2.9 default)

     1120 bool os::Solaris::_T2_libthread = false;

     1121 

     1122 bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {

     1123   // Allocate the OSThread object

     1124   OSThread* osthread = new OSThread(NULL, NULL);

     1125   if (osthread == NULL) {

     1126     return false;

     1127   }

     1128 

     1129   if ( ThreadPriorityVerbose ) {

     1130     char *thrtyp;

     1131     switch ( thr_type ) {

     1132       case vm_thread:

     1133         thrtyp = (char *)"vm";

     1134         break;

     1135       case cgc_thread:

     1136         thrtyp = (char *)"cgc";

     1137         break;

     1138       case pgc_thread:

     1139         thrtyp = (char *)"pgc";

     1140         break;

     1141       case java_thread:

     1142         thrtyp = (char *)"java";

     1143         break;

     1144       case compiler_thread:

     1145         thrtyp = (char *)"compiler";

     1146         break;

     1147       case watcher_thread:

     1148         thrtyp = (char *)"watcher";

     1149         break;

     1150       default:

     1151         thrtyp = (char *)"unknown";

     1152         break;

     1153     }

     1154     tty->print_cr("In create_thread, creating a %s thread\n", thrtyp);

     1155   }

     1156 

     1157   // Calculate stack size if it's not specified by caller.

     1158   if (stack_size == 0) {

     1159     // The default stack size 1M (2M for LP64).

     1160     stack_size = (BytesPerWord >> 2) * K * K;

     1161 

     1162     switch (thr_type) {

     1163     case os::java_thread:

     1164       // Java threads use ThreadStackSize which default value can be changed with the flag -Xss

     1165       if (JavaThread::stack_size_at_create() > 0) stack_size = JavaThread::stack_size_at_create();

     1166       break;

     1167     case os::compiler_thread:

     1168       if (CompilerThreadStackSize > 0) {

     1169         stack_size = (size_t)(CompilerThreadStackSize * K);

     1170         break;

     1171       } // else fall through:

     1172         // use VMThreadStackSize if CompilerThreadStackSize is not defined

     1173     case os::vm_thread:

     1174     case os::pgc_thread:

     1175     case os::cgc_thread:

     1176     case os::watcher_thread:

     1177       if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);

     1178       break;

     1179     }

     1180   }

     1181   stack_size = MAX2(stack_size, os::Solaris::min_stack_allowed);

     1182 

     1183   // Initial state is ALLOCATED but not INITIALIZED

     1184   osthread->set_state(ALLOCATED);

     1185 

     1186   if (os::Solaris::_os_thread_count > os::Solaris::_os_thread_limit) {

     1187     // We got lots of threads. Check if we still have some address space left.

     1188     // Need to be at least 5Mb of unreserved address space. We do check by

     1189     // trying to reserve some.

     1190     const size_t VirtualMemoryBangSize = 20*K*K;

     1191     char* mem = os::reserve_memory(VirtualMemoryBangSize);

     1192     if (mem == NULL) {

     1193       delete osthread;

     1194       return false;

     1195     } else {

     1196       // Release the memory again

     1197       os::release_memory(mem, VirtualMemoryBangSize);

     1198     }

     1199   }

     1200 

     1201   // Setup osthread because the child thread may need it.

     1202   thread->set_osthread(osthread);

     1203 

     1204   // Create the Solaris thread

     1205   // explicit THR_BOUND for T2_libthread case in case

     1206   // that assumption is not accurate, but our alternate signal stack

     1207   // handling is based on it which must have bound threads

     1208   thread_t tid = 0;

     1209   long     flags = (UseDetachedThreads ? THR_DETACHED : 0) | THR_SUSPENDED

     1210                    | ((UseBoundThreads || os::Solaris::T2_libthread() ||

     1211                        (thr_type == vm_thread) ||

     1212                        (thr_type == cgc_thread) ||

     1213                        (thr_type == pgc_thread) ||

     1214                        (thr_type == compiler_thread && BackgroundCompilation)) ?

     1215                       THR_BOUND : 0);

     1216   int      status;

     1217 

     1218   // 4376845 -- libthread/kernel don't provide enough LWPs to utilize all CPUs.

     1219   //

     1220   // On multiprocessors systems, libthread sometimes under-provisions our

     1221   // process with LWPs.  On a 30-way systems, for instance, we could have

     1222   // 50 user-level threads in ready state and only 2 or 3 LWPs assigned

     1223   // to our process.  This can result in under utilization of PEs.

     1224   // I suspect the problem is related to libthread's LWP

     1225   // pool management and to the kernel's SIGBLOCKING "last LWP parked"

     1226   // upcall policy.

     1227   //

     1228   // The following code is palliative -- it attempts to ensure that our

     1229   // process has sufficient LWPs to take advantage of multiple PEs.

     1230   // Proper long-term cures include using user-level threads bound to LWPs

     1231   // (THR_BOUND) or using LWP-based synchronization.  Note that there is a

     1232   // slight timing window with respect to sampling _os_thread_count, but

     1233   // the race is benign.  Also, we should periodically recompute

     1234   // _processors_online as the min of SC_NPROCESSORS_ONLN and the

     1235   // the number of PEs in our partition.  You might be tempted to use

     1236   // THR_NEW_LWP here, but I'd recommend against it as that could

     1237   // result in undesirable growth of the libthread's LWP pool.

     1238   // The fix below isn't sufficient; for instance, it doesn't take into count

     1239   // LWPs parked on IO.  It does, however, help certain CPU-bound benchmarks.

     1240   //

     1241   // Some pathologies this scheme doesn't handle:

     1242   // *  Threads can block, releasing the LWPs.  The LWPs can age out.

     1243   //    When a large number of threads become ready again there aren't

     1244   //    enough LWPs available to service them.  This can occur when the

     1245   //    number of ready threads oscillates.

     1246   // *  LWPs/Threads park on IO, thus taking the LWP out of circulation.

     1247   //

     1248   // Finally, we should call thr_setconcurrency() periodically to refresh

     1249   // the LWP pool and thwart the LWP age-out mechanism.

     1250   // The "+3" term provides a little slop -- we want to slightly overprovision.

     1251 

     1252   if (AdjustConcurrency && os::Solaris::_os_thread_count < (_processors_online+3)) {

     1253     if (!(flags & THR_BOUND)) {

     1254       thr_setconcurrency (os::Solaris::_os_thread_count);       // avoid starvation

     1255     }

     1256   }

     1257   // Although this doesn't hurt, we should warn of undefined behavior

     1258   // when using unbound T1 threads with schedctl().  This should never

     1259   // happen, as the compiler and VM threads are always created bound

     1260   DEBUG_ONLY(

     1261       if ((VMThreadHintNoPreempt || CompilerThreadHintNoPreempt) &&

     1262           (!os::Solaris::T2_libthread() && (!(flags & THR_BOUND))) &&

     1263           ((thr_type == vm_thread) || (thr_type == cgc_thread) ||

     1264            (thr_type == pgc_thread) || (thr_type == compiler_thread && BackgroundCompilation))) {

     1265          warning("schedctl behavior undefined when Compiler/VM/GC Threads are Unbound");

     1266       }

     1267   );

     1268 

     1269 

     1270   // Mark that we don't have an lwp or thread id yet.

     1271   // In case we attempt to set the priority before the thread starts.

     1272   osthread->set_lwp_id(-1);

     1273   osthread->set_thread_id(-1);

     1274 

     1275   status = thr_create(NULL, stack_size, java_start, thread, flags, &tid);

     1276   if (status != 0) {

     1277     if (PrintMiscellaneous && (Verbose || WizardMode)) {

     1278       perror("os::create_thread");

     1279     }

     1280     thread->set_osthread(NULL);

     1281     // Need to clean up stuff we've allocated so far

     1282     delete osthread;

     1283     return false;

     1284   }

     1285 

     1286   Atomic::inc(&os::Solaris::_os_thread_count);

     1287 

     1288   // Store info on the Solaris thread into the OSThread

     1289   osthread->set_thread_id(tid);

     1290 

     1291   // Remember that we created this thread so we can set priority on it

     1292   osthread->set_vm_created();

     1293 

     1294   // Set the default thread priority otherwise use NormalPriority

     1295 

     1296   if ( UseThreadPriorities ) {

     1297      thr_setprio(tid, (DefaultThreadPriority == -1) ?

     1298                         java_to_os_priority[NormPriority] :

     1299                         DefaultThreadPriority);

     1300   }

     1301 

     1302   // Initial thread state is INITIALIZED, not SUSPENDED

     1303   osthread->set_state(INITIALIZED);

     1304 

     1305   // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain

     1306   return true;

     1307 }

     1308 

     1309 /* defined for >= Solaris 10. This allows builds on earlier versions

     1310  *  of Solaris to take advantage of the newly reserved Solaris JVM signals

     1311  *  With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2

     1312  *  and -XX:+UseAltSigs does nothing since these should have no conflict

     1313  */

     1314 #if !defined(SIGJVM1)

     1315 #define SIGJVM1 39

     1316 #define SIGJVM2 40

     1317 #endif

     1318 

     1319 debug_only(static bool signal_sets_initialized = false);

     1320 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;

     1321 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;

     1322 int os::Solaris::_SIGasync = ASYNC_SIGNAL;

     1323 

     1324 bool os::Solaris::is_sig_ignored(int sig) {

     1325       struct sigaction oact;

     1326       sigaction(sig, (struct sigaction*)NULL, &oact);

     1327       void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oact.sa_sigaction)

     1328                                      : CAST_FROM_FN_PTR(void*,  oact.sa_handler);

     1329       if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))

     1330            return true;

     1331       else

     1332            return false;

     1333 }

     1334 

     1335 // Note: SIGRTMIN is a macro that calls sysconf() so it will

     1336 // dynamically detect SIGRTMIN value for the system at runtime, not buildtime

     1337 static bool isJVM1available() {

     1338   return SIGJVM1 < SIGRTMIN;

     1339 }

     1340 

     1341 void os::Solaris::signal_sets_init() {

     1342   // Should also have an assertion stating we are still single-threaded.

     1343   assert(!signal_sets_initialized, "Already initialized");

     1344   // Fill in signals that are necessarily unblocked for all threads in

     1345   // the VM. Currently, we unblock the following signals:

     1346   // SHUTDOWN{1,2,3}_SIGNAL: for shutdown hooks support (unless over-ridden

     1347   //                         by -Xrs (=ReduceSignalUsage));

     1348   // BREAK_SIGNAL which is unblocked only by the VM thread and blocked by all

     1349   // other threads. The "ReduceSignalUsage" boolean tells us not to alter

     1350   // the dispositions or masks wrt these signals.

     1351   // Programs embedding the VM that want to use the above signals for their

     1352   // own purposes must, at this time, use the "-Xrs" option to prevent

     1353   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.

     1354   // (See bug 4345157, and other related bugs).

     1355   // In reality, though, unblocking these signals is really a nop, since

     1356   // these signals are not blocked by default.

     1357   sigemptyset(&unblocked_sigs);

     1358   sigemptyset(&allowdebug_blocked_sigs);

     1359   sigaddset(&unblocked_sigs, SIGILL);

     1360   sigaddset(&unblocked_sigs, SIGSEGV);

     1361   sigaddset(&unblocked_sigs, SIGBUS);

     1362   sigaddset(&unblocked_sigs, SIGFPE);

     1363 

     1364   if (isJVM1available) {

     1365     os::Solaris::set_SIGinterrupt(SIGJVM1);

     1366     os::Solaris::set_SIGasync(SIGJVM2);

     1367   } else if (UseAltSigs) {

     1368     os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL);

     1369     os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL);

     1370   } else {

     1371     os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL);

     1372     os::Solaris::set_SIGasync(ASYNC_SIGNAL);

     1373   }

     1374 

     1375   sigaddset(&unblocked_sigs, os::Solaris::SIGinterrupt());

     1376   sigaddset(&unblocked_sigs, os::Solaris::SIGasync());

     1377 

     1378   if (!ReduceSignalUsage) {

     1379    if (!os::Solaris::is_sig_ignored(SHUTDOWN1_SIGNAL)) {

     1380       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);

     1381       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);

     1382    }

     1383    if (!os::Solaris::is_sig_ignored(SHUTDOWN2_SIGNAL)) {

     1384       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);

     1385       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);

     1386    }

     1387    if (!os::Solaris::is_sig_ignored(SHUTDOWN3_SIGNAL)) {

     1388       sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);

     1389       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);

     1390    }

     1391   }

     1392   // Fill in signals that are blocked by all but the VM thread.

     1393   sigemptyset(&vm_sigs);

     1394   if (!ReduceSignalUsage)

     1395     sigaddset(&vm_sigs, BREAK_SIGNAL);

     1396   debug_only(signal_sets_initialized = true);

     1397 

     1398   // For diagnostics only used in run_periodic_checks

     1399   sigemptyset(&check_signal_done);

     1400 }

     1401 

     1402 // These are signals that are unblocked while a thread is running Java.

     1403 // (For some reason, they get blocked by default.)

     1404 sigset_t* os::Solaris::unblocked_signals() {

     1405   assert(signal_sets_initialized, "Not initialized");

     1406   return &unblocked_sigs;

     1407 }

     1408 

     1409 // These are the signals that are blocked while a (non-VM) thread is

     1410 // running Java. Only the VM thread handles these signals.

     1411 sigset_t* os::Solaris::vm_signals() {

     1412   assert(signal_sets_initialized, "Not initialized");

     1413   return &vm_sigs;

     1414 }

     1415 

     1416 // These are signals that are blocked during cond_wait to allow debugger in

     1417 sigset_t* os::Solaris::allowdebug_blocked_signals() {

     1418   assert(signal_sets_initialized, "Not initialized");

     1419   return &allowdebug_blocked_sigs;

     1420 }

     1421 

     1422 // First crack at OS-specific initialization, from inside the new thread.

     1423 void os::initialize_thread() {

     1424   int r = thr_main() ;

     1425   guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ;

     1426   if (r) {

     1427     JavaThread* jt = (JavaThread *)Thread::current();

     1428     assert(jt != NULL,"Sanity check");

     1429     size_t stack_size;

     1430     address base = jt->stack_base();

     1431     if (Arguments::created_by_java_launcher()) {

     1432       // Use 2MB to allow for Solaris 7 64 bit mode.

     1433       stack_size = JavaThread::stack_size_at_create() == 0

     1434         ? 2048*K : JavaThread::stack_size_at_create();

     1435 

     1436       // There are rare cases when we may have already used more than

     1437       // the basic stack size allotment before this method is invoked.

     1438       // Attempt to allow for a normally sized java_stack.

     1439       size_t current_stack_offset = (size_t)(base - (address)&stack_size);

     1440       stack_size += ReservedSpace::page_align_size_down(current_stack_offset);

     1441     } else {

     1442       // 6269555: If we were not created by a Java launcher, i.e. if we are

     1443       // running embedded in a native application, treat the primordial thread

     1444       // as much like a native attached thread as possible.  This means using

     1445       // the current stack size from thr_stksegment(), unless it is too large

     1446       // to reliably setup guard pages.  A reasonable max size is 8MB.

     1447       size_t current_size = current_stack_size();

     1448       // This should never happen, but just in case....

     1449       if (current_size == 0) current_size = 2 * K * K;

     1450       stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size;

     1451     }

     1452     address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());;

     1453     stack_size = (size_t)(base - bottom);

     1454 

     1455     assert(stack_size > 0, "Stack size calculation problem");

     1456 

     1457     if (stack_size > jt->stack_size()) {

     1458       NOT_PRODUCT(

     1459         struct rlimit limits;

     1460         getrlimit(RLIMIT_STACK, &limits);

     1461         size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur);

     1462         assert(size >= jt->stack_size(), "Stack size problem in main thread");

     1463       )

     1464       tty->print_cr(

     1465         "Stack size of %d Kb exceeds current limit of %d Kb.\n"

     1466         "(Stack sizes are rounded up to a multiple of the system page size.)\n"

     1467         "See limit(1) to increase the stack size limit.",

     1468         stack_size / K, jt->stack_size() / K);

     1469       vm_exit(1);

     1470     }

     1471     assert(jt->stack_size() >= stack_size,

     1472           "Attempt to map more stack than was allocated");

     1473     jt->set_stack_size(stack_size);

     1474   }

     1475 

     1476    // 5/22/01: Right now alternate signal stacks do not handle

     1477    // throwing stack overflow exceptions, see bug 4463178

     1478    // Until a fix is found for this, T2 will NOT imply alternate signal

     1479    // stacks.

     1480    // If using T2 libthread threads, install an alternate signal stack.

     1481    // Because alternate stacks associate with LWPs on Solaris,

     1482    // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads

     1483    // we prefer to explicitly stack bang.

     1484    // If not using T2 libthread, but using UseBoundThreads any threads

     1485    // (primordial thread, jni_attachCurrentThread) we do not create,

     1486    // probably are not bound, therefore they can not have an alternate

     1487    // signal stack. Since our stack banging code is generated and

     1488    // is shared across threads, all threads must be bound to allow

     1489    // using alternate signal stacks.  The alternative is to interpose

     1490    // on _lwp_create to associate an alt sig stack with each LWP,

     1491    // and this could be a problem when the JVM is embedded.

     1492    // We would prefer to use alternate signal stacks with T2

     1493    // Since there is currently no accurate way to detect T2

     1494    // we do not. Assuming T2 when running T1 causes sig 11s or assertions

     1495    // on installing alternate signal stacks

     1496 

     1497 

     1498    // 05/09/03: removed alternate signal stack support for Solaris

     1499    // The alternate signal stack mechanism is no longer needed to

     1500    // handle stack overflow. This is now handled by allocating

     1501    // guard pages (red zone) and stackbanging.

     1502    // Initially the alternate signal stack mechanism was removed because

     1503    // it did not work with T1 llibthread. Alternate

     1504    // signal stacks MUST have all threads bound to lwps. Applications

     1505    // can create their own threads and attach them without their being

     1506    // bound under T1. This is frequently the case for the primordial thread.

     1507    // If we were ever to reenable this mechanism we would need to

     1508    // use the dynamic check for T2 libthread.

     1509 

     1510   os::Solaris::init_thread_fpu_state();

     1511 }

     1512 

     1513 

     1514 

     1515 // Free Solaris resources related to the OSThread

     1516 void os::free_thread(OSThread* osthread) {

     1517   assert(osthread != NULL, "os::free_thread but osthread not set");

     1518 

     1519 

     1520   // We are told to free resources of the argument thread,

     1521   // but we can only really operate on the current thread.

     1522   // The main thread must take the VMThread down synchronously

     1523   // before the main thread exits and frees up CodeHeap

     1524   guarantee((Thread::current()->osthread() == osthread

     1525      || (osthread == VMThread::vm_thread()->osthread())), "os::free_thread but not current thread");

     1526   if (Thread::current()->osthread() == osthread) {

     1527     // Restore caller's signal mask

     1528     sigset_t sigmask = osthread->caller_sigmask();

     1529     thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);

     1530   }

     1531   delete osthread;

     1532 }

     1533 

     1534 void os::pd_start_thread(Thread* thread) {

     1535   int status = thr_continue(thread->osthread()->thread_id());

     1536   assert_status(status == 0, status, "thr_continue failed");

     1537 }

     1538 

     1539 

     1540 intx os::current_thread_id() {

     1541   return (intx)thr_self();

     1542 }

     1543 

     1544 static pid_t _initial_pid = 0;

     1545 

     1546 int os::current_process_id() {

     1547   return (int)(_initial_pid ? _initial_pid : getpid());

     1548 }

     1549 

     1550 int os::allocate_thread_local_storage() {

     1551   // %%%       in Win32 this allocates a memory segment pointed to by a

     1552   //           register.  Dan Stein can implement a similar feature in

     1553   //           Solaris.  Alternatively, the VM can do the same thing

     1554   //           explicitly: malloc some storage and keep the pointer in a

     1555   //           register (which is part of the thread's context) (or keep it

     1556   //           in TLS).

     1557   // %%%       In current versions of Solaris, thr_self and TSD can

     1558   //           be accessed via short sequences of displaced indirections.

     1559   //           The value of thr_self is available as %g7(36).

     1560   //           The value of thr_getspecific(k) is stored in %g7(12)(4)(k*4-4),

     1561   //           assuming that the current thread already has a value bound to k.

     1562   //           It may be worth experimenting with such access patterns,

     1563   //           and later having the parameters formally exported from a Solaris

     1564   //           interface.  I think, however, that it will be faster to

     1565   //           maintain the invariant that %g2 always contains the

     1566   //           JavaThread in Java code, and have stubs simply

     1567   //           treat %g2 as a caller-save register, preserving it in a %lN.

     1568   thread_key_t tk;

     1569   if (thr_keycreate( &tk, NULL ) )

     1570     fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed "

     1571                   "(%s)", strerror(errno)));

     1572   return int(tk);

     1573 }

     1574 

     1575 void os::free_thread_local_storage(int index) {

     1576   // %%% don't think we need anything here

     1577   // if ( pthread_key_delete((pthread_key_t) tk) )

     1578   //   fatal("os::free_thread_local_storage: pthread_key_delete failed");

     1579 }

     1580 

     1581 #define SMALLINT 32   // libthread allocate for tsd_common is a version specific

     1582                       // small number - point is NO swap space available

     1583 void os::thread_local_storage_at_put(int index, void* value) {

     1584   // %%% this is used only in threadLocalStorage.cpp

     1585   if (thr_setspecific((thread_key_t)index, value)) {

     1586     if (errno == ENOMEM) {

     1587        vm_exit_out_of_memory(SMALLINT, "thr_setspecific: out of swap space");

     1588     } else {

     1589       fatal(err_msg("os::thread_local_storage_at_put: thr_setspecific failed "

     1590                     "(%s)", strerror(errno)));

     1591     }

     1592   } else {

     1593       ThreadLocalStorage::set_thread_in_slot ((Thread *) value) ;

     1594   }

     1595 }

     1596 

     1597 // This function could be called before TLS is initialized, for example, when

     1598 // VM receives an async signal or when VM causes a fatal error during

     1599 // initialization. Return NULL if thr_getspecific() fails.

     1600 void* os::thread_local_storage_at(int index) {

     1601   // %%% this is used only in threadLocalStorage.cpp

     1602   void* r = NULL;

     1603   return thr_getspecific((thread_key_t)index, &r) != 0 ? NULL : r;

     1604 }

     1605 

     1606 

     1607 const int NANOSECS_PER_MILLISECS = 1000000;

     1608 // gethrtime can move backwards if read from one cpu and then a different cpu

     1609 // getTimeNanos is guaranteed to not move backward on Solaris

     1610 // local spinloop created as faster for a CAS on an int than

     1611 // a CAS on a 64bit jlong. Also Atomic::cmpxchg for jlong is not

     1612 // supported on sparc v8 or pre supports_cx8 intel boxes.

     1613 // oldgetTimeNanos for systems which do not support CAS on 64bit jlong

     1614 // i.e. sparc v8 and pre supports_cx8 (i486) intel boxes

     1615 inline hrtime_t oldgetTimeNanos() {

     1616   int gotlock = LOCK_INVALID;

     1617   hrtime_t newtime = gethrtime();

     1618 

     1619   for (;;) {

     1620 // grab lock for max_hrtime

     1621     int curlock = max_hrtime_lock;

     1622     if (curlock & LOCK_BUSY)  continue;

     1623     if (gotlock = Atomic::cmpxchg(LOCK_BUSY, &max_hrtime_lock, LOCK_FREE) != LOCK_FREE) continue;

     1624     if (newtime > max_hrtime) {

     1625       max_hrtime = newtime;

     1626     } else {

     1627       newtime = max_hrtime;

     1628     }

     1629     // release lock

     1630     max_hrtime_lock = LOCK_FREE;

     1631     return newtime;

     1632   }

     1633 }

     1634 // gethrtime can move backwards if read from one cpu and then a different cpu

     1635 // getTimeNanos is guaranteed to not move backward on Solaris

     1636 inline hrtime_t getTimeNanos() {

     1637   if (VM_Version::supports_cx8()) {

     1638     const hrtime_t now = gethrtime();

     1639     // Use atomic long load since 32-bit x86 uses 2 registers to keep long.

     1640     const hrtime_t prev = Atomic::load((volatile jlong*)&max_hrtime);

     1641     if (now <= prev)  return prev;   // same or retrograde time;

     1642     const hrtime_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&max_hrtime, prev);

     1643     assert(obsv >= prev, "invariant");   // Monotonicity

     1644     // If the CAS succeeded then we're done and return "now".

     1645     // If the CAS failed and the observed value "obs" is >= now then

     1646     // we should return "obs".  If the CAS failed and now > obs > prv then

     1647     // some other thread raced this thread and installed a new value, in which case

     1648     // we could either (a) retry the entire operation, (b) retry trying to install now

     1649     // or (c) just return obs.  We use (c).   No loop is required although in some cases

     1650     // we might discard a higher "now" value in deference to a slightly lower but freshly

     1651     // installed obs value.   That's entirely benign -- it admits no new orderings compared

     1652     // to (a) or (b) -- and greatly reduces coherence traffic.

     1653     // We might also condition (c) on the magnitude of the delta between obs and now.

     1654     // Avoiding excessive CAS operations to hot RW locations is critical.

     1655     // See http://blogs.sun.com/dave/entry/cas_and_cache_trivia_invalidate

     1656     return (prev == obsv) ? now : obsv ;

     1657   } else {

     1658     return oldgetTimeNanos();

     1659   }

     1660 }

     1661 

     1662 // Time since start-up in seconds to a fine granularity.

     1663 // Used by VMSelfDestructTimer and the MemProfiler.

     1664 double os::elapsedTime() {

     1665   return (double)(getTimeNanos() - first_hrtime) / (double)hrtime_hz;

     1666 }

     1667 

     1668 jlong os::elapsed_counter() {

     1669   return (jlong)(getTimeNanos() - first_hrtime);

     1670 }

     1671 

     1672 jlong os::elapsed_frequency() {

     1673    return hrtime_hz;

     1674 }

     1675 

     1676 // Return the real, user, and system times in seconds from an

     1677 // arbitrary fixed point in the past.

     1678 bool os::getTimesSecs(double* process_real_time,

     1679                   double* process_user_time,

     1680                   double* process_system_time) {

     1681   struct tms ticks;

     1682   clock_t real_ticks = times(&ticks);

     1683 

     1684   if (real_ticks == (clock_t) (-1)) {

     1685     return false;

     1686   } else {

     1687     double ticks_per_second = (double) clock_tics_per_sec;

     1688     *process_user_time = ((double) ticks.tms_utime) / ticks_per_second;

     1689     *process_system_time = ((double) ticks.tms_stime) / ticks_per_second;

     1690     // For consistency return the real time from getTimeNanos()

     1691     // converted to seconds.

     1692     *process_real_time = ((double) getTimeNanos()) / ((double) NANOUNITS);

     1693 

     1694     return true;

     1695   }

     1696 }

     1697 

     1698 bool os::supports_vtime() { return true; }

     1699 

     1700 bool os::enable_vtime() {

     1701   int fd = open("/proc/self/ctl", O_WRONLY);

     1702   if (fd == -1)

     1703     return false;

     1704 

     1705   long cmd[] = { PCSET, PR_MSACCT };

     1706   int res = write(fd, cmd, sizeof(long) * 2);

     1707   close(fd);

     1708   if (res != sizeof(long) * 2)

     1709     return false;

     1710 

     1711   return true;

     1712 }

     1713 

     1714 bool os::vtime_enabled() {

     1715   int fd = open("/proc/self/status", O_RDONLY);

     1716   if (fd == -1)

     1717     return false;

     1718 

     1719   pstatus_t status;

     1720   int res = read(fd, (void*) &status, sizeof(pstatus_t));

     1721   close(fd);

     1722   if (res != sizeof(pstatus_t))

     1723     return false;

     1724 

     1725   return status.pr_flags & PR_MSACCT;

     1726 }

     1727 

     1728 double os::elapsedVTime() {

     1729   return (double)gethrvtime() / (double)hrtime_hz;

     1730 }

     1731 

     1732 // Used internally for comparisons only

     1733 // getTimeMillis guaranteed to not move backwards on Solaris

     1734 jlong getTimeMillis() {

     1735   jlong nanotime = getTimeNanos();

     1736   return (jlong)(nanotime / NANOSECS_PER_MILLISECS);

     1737 }

     1738 

     1739 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis

     1740 jlong os::javaTimeMillis() {

     1741   timeval t;

     1742   if (gettimeofday( &t, NULL) == -1)

     1743     fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno)));

     1744   return jlong(t.tv_sec) * 1000  +  jlong(t.tv_usec) / 1000;

     1745 }

     1746 

     1747 jlong os::javaTimeNanos() {

     1748   return (jlong)getTimeNanos();

     1749 }

     1750 

     1751 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {

     1752   info_ptr->max_value = ALL_64_BITS;      // gethrtime() uses all 64 bits

     1753   info_ptr->may_skip_backward = false;    // not subject to resetting or drifting

     1754   info_ptr->may_skip_forward = false;     // not subject to resetting or drifting

     1755   info_ptr->kind = JVMTI_TIMER_ELAPSED;   // elapsed not CPU time

     1756 }

     1757 

     1758 char * os::local_time_string(char *buf, size_t buflen) {

     1759   struct tm t;

     1760   time_t long_time;

     1761   time(&long_time);

     1762   localtime_r(&long_time, &t);

     1763   jio_snprintf(buf, buflen, "%d-%02d-%02d %02d:%02d:%02d",

     1764                t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,

     1765                t.tm_hour, t.tm_min, t.tm_sec);

     1766   return buf;

     1767 }

     1768 

     1769 // Note: os::shutdown() might be called very early during initialization, or

     1770 // called from signal handler. Before adding something to os::shutdown(), make

     1771 // sure it is async-safe and can handle partially initialized VM.

     1772 void os::shutdown() {

     1773 

     1774   // allow PerfMemory to attempt cleanup of any persistent resources

     1775   perfMemory_exit();

     1776 

     1777   // needs to remove object in file system

     1778   AttachListener::abort();

     1779 

     1780   // flush buffered output, finish log files

     1781   ostream_abort();

     1782 

     1783   // Check for abort hook

     1784   abort_hook_t abort_hook = Arguments::abort_hook();

     1785   if (abort_hook != NULL) {

     1786     abort_hook();

     1787   }

     1788 }

     1789 

     1790 // Note: os::abort() might be called very early during initialization, or

     1791 // called from signal handler. Before adding something to os::abort(), make

     1792 // sure it is async-safe and can handle partially initialized VM.

     1793 void os::abort(bool dump_core) {

     1794   os::shutdown();

     1795   if (dump_core) {

     1796 #ifndef PRODUCT

     1797     fdStream out(defaultStream::output_fd());

     1798     out.print_raw("Current thread is ");

     1799     char buf[16];

     1800     jio_snprintf(buf, sizeof(buf), UINTX_FORMAT, os::current_thread_id());

     1801     out.print_raw_cr(buf);

     1802     out.print_raw_cr("Dumping core ...");

     1803 #endif

     1804     ::abort(); // dump core (for debugging)

     1805   }

     1806 

     1807   ::exit(1);

     1808 }

     1809 

     1810 // Die immediately, no exit hook, no abort hook, no cleanup.

     1811 void os::die() {

     1812   _exit(-1);

     1813 }

     1814 

     1815 // unused

     1816 void os::set_error_file(const char *logfile) {}

     1817 

     1818 // DLL functions

     1819 

     1820 const char* os::dll_file_extension() { return ".so"; }

     1821 

     1822 // This must be hard coded because it's the system's temporary

     1823 // directory not the java application's temp directory, ala java.io.tmpdir.

     1824 const char* os::get_temp_directory() { return "/tmp"; }

     1825 

     1826 static bool file_exists(const char* filename) {

     1827   struct stat statbuf;

     1828   if (filename == NULL || strlen(filename) == 0) {

     1829     return false;

     1830   }

     1831   return os::stat(filename, &statbuf) == 0;

     1832 }

     1833 

     1834 void os::dll_build_name(char* buffer, size_t buflen,

     1835                         const char* pname, const char* fname) {

     1836   // Copied from libhpi

     1837   const size_t pnamelen = pname ? strlen(pname) : 0;

     1838 

     1839   // Quietly truncate on buffer overflow.  Should be an error.

     1840   if (pnamelen + strlen(fname) + 10 > (size_t) buflen) {

     1841     *buffer = '\0';

     1842     return;

     1843   }

     1844 

     1845   if (pnamelen == 0) {

     1846     snprintf(buffer, buflen, "lib%s.so", fname);

     1847   } else if (strchr(pname, *os::path_separator()) != NULL) {

     1848     int n;

     1849     char** pelements = split_path(pname, &n);

     1850     for (int i = 0 ; i < n ; i++) {

     1851       // really shouldn't be NULL but what the heck, check can't hurt

     1852       if (pelements[i] == NULL || strlen(pelements[i]) == 0) {

     1853         continue; // skip the empty path values

     1854       }

     1855       snprintf(buffer, buflen, "%s/lib%s.so", pelements[i], fname);

     1856       if (file_exists(buffer)) {

     1857         break;

     1858       }

     1859     }

     1860     // release the storage

     1861     for (int i = 0 ; i < n ; i++) {

     1862       if (pelements[i] != NULL) {

     1863         FREE_C_HEAP_ARRAY(char, pelements[i]);

     1864       }

     1865     }

     1866     if (pelements != NULL) {

     1867       FREE_C_HEAP_ARRAY(char*, pelements);

     1868     }

     1869   } else {

     1870     snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);

     1871   }

     1872 }

     1873 

     1874 const char* os::get_current_directory(char *buf, int buflen) {

     1875   return getcwd(buf, buflen);

     1876 }

     1877 

     1878 // check if addr is inside libjvm[_g].so

     1879 bool os::address_is_in_vm(address addr) {

     1880   static address libjvm_base_addr;

     1881   Dl_info dlinfo;

     1882 

     1883   if (libjvm_base_addr == NULL) {

     1884     dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo);

     1885     libjvm_base_addr = (address)dlinfo.dli_fbase;

     1886     assert(libjvm_base_addr !=NULL, "Cannot obtain base address for libjvm");

     1887   }

     1888 

     1889   if (dladdr((void *)addr, &dlinfo)) {

     1890     if (libjvm_base_addr == (address)dlinfo.dli_fbase) return true;

     1891   }

     1892 

     1893   return false;

     1894 }

     1895 

     1896 typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int);

     1897 static dladdr1_func_type dladdr1_func = NULL;

     1898 

     1899 bool os::dll_address_to_function_name(address addr, char *buf,

     1900                                       int buflen, int * offset) {

     1901   Dl_info dlinfo;

     1902 

     1903   // dladdr1_func was initialized in os::init()

     1904   if (dladdr1_func){

     1905       // yes, we have dladdr1

     1906 

     1907       // Support for dladdr1 is checked at runtime; it may be

     1908       // available even if the vm is built on a machine that does

     1909       // not have dladdr1 support.  Make sure there is a value for

     1910       // RTLD_DL_SYMENT.

     1911       #ifndef RTLD_DL_SYMENT

     1912       #define RTLD_DL_SYMENT 1

     1913       #endif

     1914       Sym * info;

     1915       if (dladdr1_func((void *)addr, &dlinfo, (void **)&info,

     1916                        RTLD_DL_SYMENT)) {

     1917           if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_sname);

     1918           if (offset) *offset = addr - (address)dlinfo.dli_saddr;

     1919 

     1920           // check if the returned symbol really covers addr

     1921           return ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr);

     1922       } else {

     1923           if (buf) buf[0] = '\0';

     1924           if (offset) *offset  = -1;

     1925           return false;

     1926       }

     1927   } else {

     1928       // no, only dladdr is available

     1929       if(dladdr((void *)addr, &dlinfo)) {

     1930           if (buf) jio_snprintf(buf, buflen, dlinfo.dli_sname);

     1931           if (offset) *offset = addr - (address)dlinfo.dli_saddr;

     1932           return true;

     1933       } else {

     1934           if (buf) buf[0] = '\0';

     1935           if (offset) *offset  = -1;

     1936           return false;

     1937       }

     1938   }

     1939 }

     1940 

     1941 bool os::dll_address_to_library_name(address addr, char* buf,

     1942                                      int buflen, int* offset) {

     1943   Dl_info dlinfo;

     1944 

     1945   if (dladdr((void*)addr, &dlinfo)){

     1946      if (buf) jio_snprintf(buf, buflen, "%s", dlinfo.dli_fname);

     1947      if (offset) *offset = addr - (address)dlinfo.dli_fbase;

     1948      return true;

     1949   } else {

     1950      if (buf) buf[0] = '\0';

     1951      if (offset) *offset = -1;

     1952      return false;

     1953   }

     1954 }

     1955 

     1956 // Prints the names and full paths of all opened dynamic libraries

     1957 // for current process

     1958 void os::print_dll_info(outputStream * st) {

     1959     Dl_info dli;

     1960     void *handle;

     1961     Link_map *map;

     1962     Link_map *p;

     1963 

     1964     st->print_cr("Dynamic libraries:"); st->flush();

     1965 

     1966     if (!dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli)) {

     1967         st->print_cr("Error: Cannot print dynamic libraries.");

     1968         return;

     1969     }

     1970     handle = dlopen(dli.dli_fname, RTLD_LAZY);

     1971     if (handle == NULL) {

     1972         st->print_cr("Error: Cannot print dynamic libraries.");

     1973         return;

     1974     }

     1975     dlinfo(handle, RTLD_DI_LINKMAP, &map);

     1976     if (map == NULL) {

     1977         st->print_cr("Error: Cannot print dynamic libraries.");

     1978         return;

     1979     }

     1980 

     1981     while (map->l_prev != NULL)

     1982         map = map->l_prev;

     1983 

     1984     while (map != NULL) {

     1985         st->print_cr(PTR_FORMAT " \t%s", map->l_addr, map->l_name);

     1986         map = map->l_next;

     1987     }

     1988 

     1989     dlclose(handle);

     1990 }

     1991 

     1992   // Loads .dll/.so and

     1993   // in case of error it checks if .dll/.so was built for the

     1994   // same architecture as Hotspot is running on

     1995 

     1996 void * os::dll_load(const char *filename, char *ebuf, int ebuflen)

     1997 {

     1998   void * result= ::dlopen(filename, RTLD_LAZY);

     1999   if (result != NULL) {

     2000     // Successful loading

     2001     return result;

     2002   }

     2003 

     2004   Elf32_Ehdr elf_head;

     2005 

     2006   // Read system error message into ebuf

     2007   // It may or may not be overwritten below

     2008   ::strncpy(ebuf, ::dlerror(), ebuflen-1);

     2009   ebuf[ebuflen-1]='\0';

     2010   int diag_msg_max_length=ebuflen-strlen(ebuf);

     2011   char* diag_msg_buf=ebuf+strlen(ebuf);

     2012 

     2013   if (diag_msg_max_length==0) {

     2014     // No more space in ebuf for additional diagnostics message

     2015     return NULL;

     2016   }

     2017 

     2018 

     2019   int file_descriptor= ::open(filename, O_RDONLY | O_NONBLOCK);

     2020 

     2021   if (file_descriptor < 0) {

     2022     // Can't open library, report dlerror() message

     2023     return NULL;

     2024   }

     2025 

     2026   bool failed_to_read_elf_head=

     2027     (sizeof(elf_head)!=

     2028         (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ;

     2029 

     2030   ::close(file_descriptor);

     2031   if (failed_to_read_elf_head) {

     2032     // file i/o error - report dlerror() msg

     2033     return NULL;

     2034   }

     2035 

     2036   typedef struct {

     2037     Elf32_Half  code;         // Actual value as defined in elf.h

     2038     Elf32_Half  compat_class; // Compatibility of archs at VM's sense

     2039     char        elf_class;    // 32 or 64 bit

     2040     char        endianess;    // MSB or LSB

     2041     char*       name;         // String representation

     2042   } arch_t;

     2043 

     2044   static const arch_t arch_array[]={

     2045     {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},

     2046     {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},

     2047     {EM_IA_64,       EM_IA_64,   ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},

     2048     {EM_X86_64,      EM_X86_64,  ELFCLASS64, ELFDATA2LSB, (char*)"AMD 64"},

     2049     {EM_SPARC,       EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},

     2050     {EM_SPARC32PLUS, EM_SPARC,   ELFCLASS32, ELFDATA2MSB, (char*)"Sparc 32"},

     2051     {EM_SPARCV9,     EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},

     2052     {EM_PPC,         EM_PPC,     ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},

     2053     {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},

     2054     {EM_ARM,         EM_ARM,     ELFCLASS32, ELFDATA2LSB, (char*)"ARM 32"}

     2055   };

     2056 

     2057   #if  (defined IA32)

     2058     static  Elf32_Half running_arch_code=EM_386;

     2059   #elif   (defined AMD64)

     2060     static  Elf32_Half running_arch_code=EM_X86_64;

     2061   #elif  (defined IA64)

     2062     static  Elf32_Half running_arch_code=EM_IA_64;

     2063   #elif  (defined __sparc) && (defined _LP64)

     2064     static  Elf32_Half running_arch_code=EM_SPARCV9;

     2065   #elif  (defined __sparc) && (!defined _LP64)

     2066     static  Elf32_Half running_arch_code=EM_SPARC;

     2067   #elif  (defined __powerpc64__)

     2068     static  Elf32_Half running_arch_code=EM_PPC64;

     2069   #elif  (defined __powerpc__)

     2070     static  Elf32_Half running_arch_code=EM_PPC;

     2071   #elif (defined ARM)

     2072     static  Elf32_Half running_arch_code=EM_ARM;

     2073   #else

     2074     #error Method os::dll_load requires that one of following is defined:\

     2075          IA32, AMD64, IA64, __sparc, __powerpc__, ARM, ARM

     2076   #endif

     2077 

     2078   // Identify compatability class for VM's architecture and library's architecture

     2079   // Obtain string descriptions for architectures

     2080 

     2081   arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};

     2082   int running_arch_index=-1;

     2083 

     2084   for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) {

     2085     if (running_arch_code == arch_array[i].code) {

     2086       running_arch_index    = i;

     2087     }

     2088     if (lib_arch.code == arch_array[i].code) {

     2089       lib_arch.compat_class = arch_array[i].compat_class;

     2090       lib_arch.name         = arch_array[i].name;

     2091     }

     2092   }

     2093 

     2094   assert(running_arch_index != -1,

     2095     "Didn't find running architecture code (running_arch_code) in arch_array");

     2096   if (running_arch_index == -1) {

     2097     // Even though running architecture detection failed

     2098     // we may still continue with reporting dlerror() message

     2099     return NULL;

     2100   }

     2101 

     2102   if (lib_arch.endianess != arch_array[running_arch_index].endianess) {

     2103     ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: endianness mismatch)");

     2104     return NULL;

     2105   }

     2106 

     2107   if (lib_arch.elf_class != arch_array[running_arch_index].elf_class) {

     2108     ::snprintf(diag_msg_buf, diag_msg_max_length-1," (Possible cause: architecture word width mismatch)");

     2109     return NULL;

     2110   }

     2111 

     2112   if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {

     2113     if ( lib_arch.name!=NULL ) {

     2114       ::snprintf(diag_msg_buf, diag_msg_max_length-1,

     2115         " (Possible cause: can't load %s-bit .so on a %s-bit platform)",

     2116         lib_arch.name, arch_array[running_arch_index].name);

     2117     } else {

     2118       ::snprintf(diag_msg_buf, diag_msg_max_length-1,

     2119       " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",

     2120         lib_arch.code,

     2121         arch_array[running_arch_index].name);

     2122     }

     2123   }

     2124 

     2125   return NULL;

     2126 }

     2127 

     2128 void* os::dll_lookup(void* handle, const char* name) {

     2129   return dlsym(handle, name);

     2130 }

     2131 

     2132 

     2133 bool _print_ascii_file(const char* filename, outputStream* st) {

     2134   int fd = open(filename, O_RDONLY);

     2135   if (fd == -1) {

     2136      return false;

     2137   }

     2138 

     2139   char buf[32];

     2140   int bytes;

     2141   while ((bytes = read(fd, buf, sizeof(buf))) > 0) {

     2142     st->print_raw(buf, bytes);

     2143   }

     2144 

     2145   close(fd);

     2146 

     2147   return true;

     2148 }

     2149 

     2150 void os::print_os_info(outputStream* st) {

     2151   st->print("OS:");

     2152 

     2153   if (!_print_ascii_file("/etc/release", st)) {

     2154     st->print("Solaris");

     2155   }

     2156   st->cr();

     2157 

     2158   // kernel

     2159   st->print("uname:");

     2160   struct utsname name;

     2161   uname(&name);

     2162   st->print(name.sysname); st->print(" ");

     2163   st->print(name.release); st->print(" ");

     2164   st->print(name.version); st->print(" ");

     2165   st->print(name.machine);

     2166 

     2167   // libthread

     2168   if (os::Solaris::T2_libthread()) st->print("  (T2 libthread)");

     2169   else st->print("  (T1 libthread)");

     2170   st->cr();

     2171 

     2172   // rlimit

     2173   st->print("rlimit:");

     2174   struct rlimit rlim;

     2175 

     2176   st->print(" STACK ");

     2177   getrlimit(RLIMIT_STACK, &rlim);

     2178   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

     2179   else st->print("%uk", rlim.rlim_cur >> 10);

     2180 

     2181   st->print(", CORE ");

     2182   getrlimit(RLIMIT_CORE, &rlim);

     2183   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

     2184   else st->print("%uk", rlim.rlim_cur >> 10);

     2185 

     2186   st->print(", NOFILE ");

     2187   getrlimit(RLIMIT_NOFILE, &rlim);

     2188   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

     2189   else st->print("%d", rlim.rlim_cur);

     2190 

     2191   st->print(", AS ");

     2192   getrlimit(RLIMIT_AS, &rlim);

     2193   if (rlim.rlim_cur == RLIM_INFINITY) st->print("infinity");

     2194   else st->print("%uk", rlim.rlim_cur >> 10);

     2195   st->cr();

     2196 

     2197   // load average

     2198   st->print("load average:");

     2199   double loadavg[3];

     2200   os::loadavg(loadavg, 3);

     2201   st->print("%0.02f %0.02f %0.02f", loadavg[0], loadavg[1], loadavg[2]);

     2202   st->cr();

     2203 }

     2204 

     2205 

     2206 static bool check_addr0(outputStream* st) {

     2207   jboolean status = false;

     2208   int fd = open("/proc/self/map",O_RDONLY);

     2209   if (fd >= 0) {

     2210     prmap_t p;

     2211     while(read(fd, &p, sizeof(p)) > 0) {

     2212       if (p.pr_vaddr == 0x0) {

     2213         st->print("Warning: Address: 0x%x, Size: %dK, ",p.pr_vaddr, p.pr_size/1024, p.pr_mapname);

     2214         st->print("Mapped file: %s, ", p.pr_mapname[0] == '\0' ? "None" : p.pr_mapname);

     2215         st->print("Access:");

     2216         st->print("%s",(p.pr_mflags & MA_READ)  ? "r" : "-");

     2217         st->print("%s",(p.pr_mflags & MA_WRITE) ? "w" : "-");

     2218         st->print("%s",(p.pr_mflags & MA_EXEC)  ? "x" : "-");

     2219         st->cr();

     2220         status = true;

     2221       }

     2222       close(fd);

     2223     }

     2224   }

     2225   return status;

     2226 }

     2227 

     2228 void os::print_memory_info(outputStream* st) {

     2229   st->print("Memory:");

     2230   st->print(" %dk page", os::vm_page_size()>>10);

     2231   st->print(", physical " UINT64_FORMAT "k", os::physical_memory()>>10);

     2232   st->print("(" UINT64_FORMAT "k free)", os::available_memory() >> 10);

     2233   st->cr();

     2234   (void) check_addr0(st);

     2235 }

     2236 

     2237 // Taken from /usr/include/sys/machsig.h  Supposed to be architecture specific

     2238 // but they're the same for all the solaris architectures that we support.

     2239 const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",

     2240                           "ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",

     2241                           "ILL_COPROC", "ILL_BADSTK" };

     2242 

     2243 const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",

     2244                           "FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",

     2245                           "FPE_FLTINV", "FPE_FLTSUB" };

     2246 

     2247 const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };

     2248 

     2249 const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };

     2250 

     2251 void os::print_siginfo(outputStream* st, void* siginfo) {

     2252   st->print("siginfo:");

     2253 

     2254   const int buflen = 100;

     2255   char buf[buflen];

     2256   siginfo_t *si = (siginfo_t*)siginfo;

     2257   st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));

     2258   char *err = strerror(si->si_errno);

     2259   if (si->si_errno != 0 && err != NULL) {

     2260     st->print("si_errno=%s", err);

     2261   } else {

     2262     st->print("si_errno=%d", si->si_errno);

     2263   }

     2264   const int c = si->si_code;

     2265   assert(c > 0, "unexpected si_code");

     2266   switch (si->si_signo) {

     2267   case SIGILL:

     2268     st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);

     2269     st->print(", si_addr=" PTR_FORMAT, si->si_addr);

     2270     break;

     2271   case SIGFPE:

     2272     st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);

     2273     st->print(", si_addr=" PTR_FORMAT, si->si_addr);

     2274     break;

     2275   case SIGSEGV:

     2276     st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);

     2277     st->print(", si_addr=" PTR_FORMAT, si->si_addr);

     2278     break;

     2279   case SIGBUS:

     2280     st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);

     2281     st->print(", si_addr=" PTR_FORMAT, si->si_addr);

     2282     break;

     2283   default:

     2284     st->print(", si_code=%d", si->si_code);

     2285     // no si_addr

     2286   }

     2287 

     2288   if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&

     2289       UseSharedSpaces) {

     2290     FileMapInfo* mapinfo = FileMapInfo::current_info();

     2291     if (mapinfo->is_in_shared_space(si->si_addr)) {

     2292       st->print("\n\nError accessing class data sharing archive."   \

     2293                 " Mapped file inaccessible during execution, "      \

     2294                 " possible disk/network problem.");

     2295     }

     2296   }

     2297   st->cr();

     2298 }

     2299 

     2300 // Moved from whole group, because we need them here for diagnostic

     2301 // prints.

     2302 #define OLDMAXSIGNUM 32

     2303 static int Maxsignum = 0;

     2304 static int *ourSigFlags = NULL;

     2305 

     2306 extern "C" void sigINTRHandler(int, siginfo_t*, void*);

     2307 

     2308 int os::Solaris::get_our_sigflags(int sig) {

     2309   assert(ourSigFlags!=NULL, "signal data structure not initialized");

     2310   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");

     2311   return ourSigFlags[sig];

     2312 }

     2313 

     2314 void os::Solaris::set_our_sigflags(int sig, int flags) {

     2315   assert(ourSigFlags!=NULL, "signal data structure not initialized");

     2316   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");

     2317   ourSigFlags[sig] = flags;

     2318 }

     2319 

     2320 

     2321 static const char* get_signal_handler_name(address handler,

     2322                                            char* buf, int buflen) {

     2323   int offset;

     2324   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);

     2325   if (found) {

     2326     // skip directory names

     2327     const char *p1, *p2;

     2328     p1 = buf;

     2329     size_t len = strlen(os::file_separator());

     2330     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;

     2331     jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);

     2332   } else {

     2333     jio_snprintf(buf, buflen, PTR_FORMAT, handler);

     2334   }

     2335   return buf;

     2336 }

     2337 

     2338 static void print_signal_handler(outputStream* st, int sig,

     2339                                   char* buf, size_t buflen) {

     2340   struct sigaction sa;

     2341 

     2342   sigaction(sig, NULL, &sa);

     2343 

     2344   st->print("%s: ", os::exception_name(sig, buf, buflen));

     2345 

     2346   address handler = (sa.sa_flags & SA_SIGINFO)

     2347                   ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)

     2348                   : CAST_FROM_FN_PTR(address, sa.sa_handler);

     2349 

     2350   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {

     2351     st->print("SIG_DFL");

     2352   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {

     2353     st->print("SIG_IGN");

     2354   } else {

     2355     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));

     2356   }

     2357 

     2358   st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);

     2359 

     2360   address rh = VMError::get_resetted_sighandler(sig);

     2361   // May be, handler was resetted by VMError?

     2362   if(rh != NULL) {

     2363     handler = rh;

     2364     sa.sa_flags = VMError::get_resetted_sigflags(sig);

     2365   }

     2366 

     2367   st->print(", sa_flags="   PTR32_FORMAT, sa.sa_flags);

     2368 

     2369   // Check: is it our handler?

     2370   if(handler == CAST_FROM_FN_PTR(address, signalHandler) ||

     2371      handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {

     2372     // It is our signal handler

     2373     // check for flags

     2374     if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {

     2375       st->print(

     2376         ", flags was changed from " PTR32_FORMAT ", consider using jsig library",

     2377         os::Solaris::get_our_sigflags(sig));

     2378     }

     2379   }

     2380   st->cr();

     2381 }

     2382 

     2383 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {

     2384   st->print_cr("Signal Handlers:");

     2385   print_signal_handler(st, SIGSEGV, buf, buflen);

     2386   print_signal_handler(st, SIGBUS , buf, buflen);

     2387   print_signal_handler(st, SIGFPE , buf, buflen);

     2388   print_signal_handler(st, SIGPIPE, buf, buflen);

     2389   print_signal_handler(st, SIGXFSZ, buf, buflen);

     2390   print_signal_handler(st, SIGILL , buf, buflen);

     2391   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);

     2392   print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);

     2393   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);

     2394   print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);

     2395   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);

     2396   print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);

     2397   print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);

     2398   print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);

     2399 }

     2400 

     2401 static char saved_jvm_path[MAXPATHLEN] = { 0 };

     2402 

     2403 // Find the full path to the current module, libjvm.so or libjvm_g.so

     2404 void os::jvm_path(char *buf, jint buflen) {

     2405   // Error checking.

     2406   if (buflen < MAXPATHLEN) {

     2407     assert(false, "must use a large-enough buffer");

     2408     buf[0] = '\0';

     2409     return;

     2410   }

     2411   // Lazy resolve the path to current module.

     2412   if (saved_jvm_path[0] != 0) {

     2413     strcpy(buf, saved_jvm_path);

     2414     return;

     2415   }

     2416 

     2417   Dl_info dlinfo;

     2418   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);

     2419   assert(ret != 0, "cannot locate libjvm");

     2420   realpath((char *)dlinfo.dli_fname, buf);

     2421 

     2422   if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) {

     2423     // Support for the gamma launcher.  Typical value for buf is

     2424     // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".  If "/jre/lib/" appears at

     2425     // the right place in the string, then assume we are installed in a JDK and

     2426     // we're done.  Otherwise, check for a JAVA_HOME environment variable and fix

     2427     // up the path so it looks like libjvm.so is installed there (append a

     2428     // fake suffix hotspot/libjvm.so).

     2429     const char *p = buf + strlen(buf) - 1;

     2430     for (int count = 0; p > buf && count < 5; ++count) {

     2431       for (--p; p > buf && *p != '/'; --p)

     2432         /* empty */ ;

     2433     }

     2434 

     2435     if (strncmp(p, "/jre/lib/", 9) != 0) {

     2436       // Look for JAVA_HOME in the environment.

     2437       char* java_home_var = ::getenv("JAVA_HOME");

     2438       if (java_home_var != NULL && java_home_var[0] != 0) {

     2439         char cpu_arch[12];

     2440         char* jrelib_p;

     2441         int   len;

     2442         sysinfo(SI_ARCHITECTURE, cpu_arch, sizeof(cpu_arch));

     2443 #ifdef _LP64

     2444         // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.

     2445         if (strcmp(cpu_arch, "sparc") == 0) {

     2446           strcat(cpu_arch, "v9");

     2447         } else if (strcmp(cpu_arch, "i386") == 0) {

     2448           strcpy(cpu_arch, "amd64");

     2449         }

     2450 #endif

     2451         // Check the current module name "libjvm.so" or "libjvm_g.so".

     2452         p = strrchr(buf, '/');

     2453         assert(strstr(p, "/libjvm") == p, "invalid library name");

     2454         p = strstr(p, "_g") ? "_g" : "";

     2455 

     2456         realpath(java_home_var, buf);

     2457         // determine if this is a legacy image or modules image

     2458         // modules image doesn't have "jre" subdirectory

     2459         len = strlen(buf);

     2460         jrelib_p = buf + len;

     2461         snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch);

     2462         if (0 != access(buf, F_OK)) {

     2463           snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch);

     2464         }

     2465 

     2466         if (0 == access(buf, F_OK)) {

     2467           // Use current module name "libjvm[_g].so" instead of

     2468           // "libjvm"debug_only("_g")".so" since for fastdebug version

     2469           // we should have "libjvm.so" but debug_only("_g") adds "_g"!

     2470           // It is used when we are choosing the HPI library's name

     2471           // "libhpi[_g].so" in hpi::initialize_get_interface().

     2472           len = strlen(buf);

     2473           snprintf(buf + len, buflen-len, "/hotspot/libjvm%s.so", p);

     2474         } else {

     2475           // Go back to path of .so

     2476           realpath((char *)dlinfo.dli_fname, buf);

     2477         }

     2478       }

     2479     }

     2480   }

     2481 

     2482   strcpy(saved_jvm_path, buf);

     2483 }

     2484 

     2485 

     2486 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {

     2487   // no prefix required, not even "_"

     2488 }

     2489 

     2490 

     2491 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {

     2492   // no suffix required

     2493 }

     2494 

     2495 

     2496 // sun.misc.Signal

     2497 

     2498 extern "C" {

     2499   static void UserHandler(int sig, void *siginfo, void *context) {

     2500     // Ctrl-C is pressed during error reporting, likely because the error

     2501     // handler fails to abort. Let VM die immediately.

     2502     if (sig == SIGINT && is_error_reported()) {

     2503        os::die();

     2504     }

     2505 

     2506     os::signal_notify(sig);

     2507     // We do not need to reinstate the signal handler each time...

     2508   }

     2509 }

     2510 

     2511 void* os::user_handler() {

     2512   return CAST_FROM_FN_PTR(void*, UserHandler);

     2513 }

     2514 

     2515 extern "C" {

     2516   typedef void (*sa_handler_t)(int);

     2517   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);

     2518 }

     2519 

     2520 void* os::signal(int signal_number, void* handler) {

     2521   struct sigaction sigAct, oldSigAct;

     2522   sigfillset(&(sigAct.sa_mask));

     2523   sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;

     2524   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);

     2525 

     2526   if (sigaction(signal_number, &sigAct, &oldSigAct))

     2527     // -1 means registration failed

     2528     return (void *)-1;

     2529 

     2530   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);

     2531 }

     2532 

     2533 void os::signal_raise(int signal_number) {

     2534   raise(signal_number);

     2535 }

     2536 

     2537 /*

     2538  * The following code is moved from os.cpp for making this

     2539  * code platform specific, which it is by its very nature.

     2540  */

     2541 

     2542 // a counter for each possible signal value

     2543 static int Sigexit = 0;

     2544 static int Maxlibjsigsigs;

     2545 static jint *pending_signals = NULL;

     2546 static int *preinstalled_sigs = NULL;

     2547 static struct sigaction *chainedsigactions = NULL;

     2548 static sema_t sig_sem;

     2549 typedef int (*version_getting_t)();

     2550 version_getting_t os::Solaris::get_libjsig_version = NULL;

     2551 static int libjsigversion = NULL;

     2552 

     2553 int os::sigexitnum_pd() {

     2554   assert(Sigexit > 0, "signal memory not yet initialized");

     2555   return Sigexit;

     2556 }

     2557 

     2558 void os::Solaris::init_signal_mem() {

     2559   // Initialize signal structures

     2560   Maxsignum = SIGRTMAX;

     2561   Sigexit = Maxsignum+1;

     2562   assert(Maxsignum >0, "Unable to obtain max signal number");

     2563 

     2564   Maxlibjsigsigs = Maxsignum;

     2565 

     2566   // pending_signals has one int per signal

     2567   // The additional signal is for SIGEXIT - exit signal to signal_thread

     2568   pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1));

     2569   memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));

     2570 

     2571   if (UseSignalChaining) {

     2572      chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)

     2573        * (Maxsignum + 1));

     2574      memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));

     2575      preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1));

     2576      memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));

     2577   }

     2578   ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ));

     2579   memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));

     2580 }

     2581 

     2582 void os::signal_init_pd() {

     2583   int ret;

     2584 

     2585   ret = ::sema_init(&sig_sem, 0, NULL, NULL);

     2586   assert(ret == 0, "sema_init() failed");

     2587 }

     2588 

     2589 void os::signal_notify(int signal_number) {

     2590   int ret;

     2591 

     2592   Atomic::inc(&pending_signals[signal_number]);

     2593   ret = ::sema_post(&sig_sem);

     2594   assert(ret == 0, "sema_post() failed");

     2595 }

     2596 

     2597 static int check_pending_signals(bool wait_for_signal) {

     2598   int ret;

     2599   while (true) {

     2600     for (int i = 0; i < Sigexit + 1; i++) {

     2601       jint n = pending_signals[i];

     2602       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {

     2603         return i;

     2604       }

     2605     }

     2606     if (!wait_for_signal) {

     2607       return -1;

     2608     }

     2609     JavaThread *thread = JavaThread::current();

     2610     ThreadBlockInVM tbivm(thread);

     2611 

     2612     bool threadIsSuspended;

     2613     do {

     2614       thread->set_suspend_equivalent();

     2615       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

     2616       while((ret = ::sema_wait(&sig_sem)) == EINTR)

     2617           ;

     2618       assert(ret == 0, "sema_wait() failed");

     2619 

     2620       // were we externally suspended while we were waiting?

     2621       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();

     2622       if (threadIsSuspended) {

     2623         //

     2624         // The semaphore has been incremented, but while we were waiting

     2625         // another thread suspended us. We don't want to continue running

     2626         // while suspended because that would surprise the thread that

     2627         // suspended us.

     2628         //

     2629         ret = ::sema_post(&sig_sem);

     2630         assert(ret == 0, "sema_post() failed");

     2631 

     2632         thread->java_suspend_self();

     2633       }

     2634     } while (threadIsSuspended);

     2635   }

     2636 }

     2637 

     2638 int os::signal_lookup() {

     2639   return check_pending_signals(false);

     2640 }

     2641 

     2642 int os::signal_wait() {

     2643   return check_pending_signals(true);

     2644 }

     2645 

     2646 ////////////////////////////////////////////////////////////////////////////////

     2647 // Virtual Memory

     2648 

     2649 static int page_size = -1;

     2650 

     2651 // The mmap MAP_ALIGN flag is supported on Solaris 9 and later.  init_2() will