Mercurial > jdk8-mips64-public > hotspot / file revision

 /*

  * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.

  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

  *

  * This code is free software; you can redistribute it and/or modify it

  * under the terms of the GNU General Public License version 2 only, as

  * published by the Free Software Foundation.

  *

  * This code is distributed in the hope that it will be useful, but WITHOUT

  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

  * version 2 for more details (a copy is included in the LICENSE file that

  * accompanied this code).

  *

  * You should have received a copy of the GNU General Public License version

  * 2 along with this work; if not, write to the Free Software Foundation,

  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

  *

  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

  * or visit www.oracle.com if you need additional information or have any

  * questions.

  *

  */

 // no precompiled headers

 #include "classfile/classLoader.hpp"

 #include "classfile/systemDictionary.hpp"

 #include "classfile/vmSymbols.hpp"

 #include "code/icBuffer.hpp"

 #include "code/vtableStubs.hpp"

 #include "compiler/compileBroker.hpp"

 #include "compiler/disassembler.hpp"

 #include "interpreter/interpreter.hpp"

 #include "jvm_solaris.h"

 #include "memory/allocation.inline.hpp"

 #include "memory/filemap.hpp"

 #include "mutex_solaris.inline.hpp"

 #include "oops/oop.inline.hpp"

 #include "os_share_solaris.hpp"

 #include "prims/jniFastGetField.hpp"

 #include "prims/jvm.h"

 #include "prims/jvm_misc.hpp"

 #include "runtime/arguments.hpp"

 #include "runtime/extendedPC.hpp"

 #include "runtime/globals.hpp"

 #include "runtime/interfaceSupport.hpp"

 #include "runtime/java.hpp"

 #include "runtime/javaCalls.hpp"

 #include "runtime/mutexLocker.hpp"

 #include "runtime/objectMonitor.hpp"

 #include "runtime/osThread.hpp"

 #include "runtime/perfMemory.hpp"

 #include "runtime/sharedRuntime.hpp"

 #include "runtime/statSampler.hpp"

 #include "runtime/stubRoutines.hpp"

 #include "runtime/thread.inline.hpp"

 #include "runtime/threadCritical.hpp"

 #include "runtime/timer.hpp"

 #include "services/attachListener.hpp"

 #include "services/memTracker.hpp"

 #include "services/runtimeService.hpp"

 #include "utilities/decoder.hpp"

 #include "utilities/defaultStream.hpp"

 #include "utilities/events.hpp"

 #include "utilities/growableArray.hpp"

 #include "utilities/vmError.hpp"

 // put OS-includes here

 # include <dlfcn.h>

 # include <errno.h>

 # include <exception>

 # include <link.h>

 # include <poll.h>

 # include <pthread.h>

 # include <pwd.h>

 # include <schedctl.h>

 # include <setjmp.h>

 # include <signal.h>

 # include <stdio.h>

 # include <alloca.h>

 # include <sys/filio.h>

 # include <sys/ipc.h>

 # include <sys/lwp.h>

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

 # include <sys/mman.h>

 # include <sys/processor.h>

 # include <sys/procset.h>

 # include <sys/pset.h>

 # include <sys/resource.h>

 # include <sys/shm.h>

 # include <sys/socket.h>

 # include <sys/stat.h>

 # include <sys/systeminfo.h>

 # include <sys/time.h>

 # include <sys/times.h>

 # include <sys/types.h>

 # include <sys/wait.h>

 # include <sys/utsname.h>

 # include <thread.h>

 # include <unistd.h>

 # include <sys/priocntl.h>

 # include <sys/rtpriocntl.h>

 # include <sys/tspriocntl.h>

 # include <sys/iapriocntl.h>

 # include <sys/fxpriocntl.h>

 # include <sys/loadavg.h>

 # include <string.h>

 # include <stdio.h>

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

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

 #define MAX_PATH (2 * K)

 // for timer info max values which include all bits

 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

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

 // compile on older systems without this header file.

 #ifndef MADV_ACCESS_LWP

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

 #endif

 #ifndef MADV_ACCESS_MANY

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

 #endif

 #ifndef LGRP_RSRC_CPU

 # define LGRP_RSRC_CPU           0       /* CPU resources */

 #endif

 #ifndef LGRP_RSRC_MEM

 # define LGRP_RSRC_MEM           1       /* memory resources */

 #endif

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

 #define MinimumPriority 0

 #define NormalPriority  64

 #define MaximumPriority 127

 // Values for ThreadPriorityPolicy == 1

 int prio_policy1[CriticalPriority+1] = {

   -99999,  0, 16,  32,  48,  64,

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

 // System parameters used internally

 static clock_t clock_tics_per_sec = 100;

 // Track if we have called enable_extended_FILE_stdio (on Solaris 10u4+)

 static bool enabled_extended_FILE_stdio = false;

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

 static bool check_addr0_done = false;

 static sigset_t check_signal_done;

 static bool check_signals = true;

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

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

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

 // "default" initializers for missing libc APIs

 extern "C" {

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

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

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

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

 }

 // "default" initializers for pthread-based synchronization

 extern "C" {

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

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

 }

 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time);

 // Thread Local Storage

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

 // in this common file.

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

 //

 // Static member initialization for TLS

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

 #ifndef PRODUCT

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

 int ThreadLocalStorage::_tcacheHit = 0;

 int ThreadLocalStorage::_tcacheMiss = 0;

 void ThreadLocalStorage::print_statistics() {

   int total = _tcacheMiss+_tcacheHit;

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

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

 }

 #undef _PCT

 #endif // PRODUCT

 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,

                                                         int index) {

   Thread *thread = get_thread_slow();

   if (thread != NULL) {

     address sp = os::current_stack_pointer();

     guarantee(thread->_stack_base == NULL ||

               (sp <= thread->_stack_base &&

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

                is_error_reported(),

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

     thread->set_self_raw_id(raw_id);  // mark for quick retrieval

     _get_thread_cache[ index ] = thread;

   }

   return thread;

 }

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

 #define NO_CACHED_THREAD ((Thread*)all_zero)

 void ThreadLocalStorage::pd_set_thread(Thread* thread) {

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

   // between get_thread_via_cache_slowly() and this store operation.

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

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

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

   uintptr_t raw = pd_raw_thread_id();

   int ix = pd_cache_index(raw);

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

 }

 void ThreadLocalStorage::pd_init() {

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

     _get_thread_cache[i] = NO_CACHED_THREAD;

   }

 }

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

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

 #undef NO_CACHED_THREAD

 // END Thread Local Storage

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

   if ((ssize_t)size < 0) {

     // 4759953: Compensate for ridiculous stack size.

     size = max_intx;

   }

   if (size > (size_t)base) {

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

     size = (size_t)base;

   }

   return size;

 }

 static inline stack_t get_stack_info() {

   stack_t st;

   int retval = thr_stksegment(&st);

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

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

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

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

   return st;

 }

 address os::current_stack_base() {

   int r = thr_main() ;

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

   bool is_primordial_thread = r;

   // Workaround 4352906, avoid calls to thr_stksegment by

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

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

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

     stack_t st = get_stack_info();

     if (is_primordial_thread) {

       // cache initial value of stack base

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

     }

     return (address)st.ss_sp;

   } else {

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

     return os::Solaris::_main_stack_base;

   }

 }

 size_t os::current_stack_size() {

   size_t size;

   int r = thr_main() ;

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

   if(!r) {

     size = get_stack_info().ss_size;

   } else {

     struct rlimit limits;

     getrlimit(RLIMIT_STACK, &limits);

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

   }

   // base may not be page aligned

   address base = current_stack_base();

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

   return (size_t)(base - bottom);

 }

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

   return localtime_r(clock, res);

 }

 // interruptible infrastructure

 // setup_interruptible saves the thread state before going into an

 // interruptible system call.

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

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

 // Used by classloader os::read

 // os::restartable_read calls skip this layer and stay in _thread_in_native

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

   JavaThreadState thread_state = thread->thread_state();

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

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

   OSThread* osthread = thread->osthread();

   osthread->set_saved_interrupt_thread_state(thread_state);

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

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

 }

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

 // _thread_blocked. Used by os_sleep().

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

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

 }

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

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

   setup_interruptible(thread);

   return thread;

 }

 void os::Solaris::try_enable_extended_io() {

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

   if (!UseExtendedFileIO) {

     return;

   }

   enable_extended_FILE_stdio_t enabler =

     (enable_extended_FILE_stdio_t) dlsym(RTLD_DEFAULT,

                                          "enable_extended_FILE_stdio");

   if (enabler) {

     enabler(-1, -1);

   }

 }

 #ifdef ASSERT

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

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

   JavaThreadState thread_state = thread->thread_state();

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

   return thread;

 }

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

   JavaThreadState thread_state = thread->thread_state();

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

 }

 #endif

 // cleanup_interruptible reverses the effects of setup_interruptible

 // setup_interruptible_already_blocked() does not need any cleanup.

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

   OSThread* osthread = thread->osthread();

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

 }

 // I/O interruption related counters called in _INTERRUPTIBLE

 void os::Solaris::bump_interrupted_before_count() {

   RuntimeService::record_interrupted_before_count();

 }

 void os::Solaris::bump_interrupted_during_count() {

   RuntimeService::record_interrupted_during_count();

 }

 static int _processors_online = 0;

          jint os::Solaris::_os_thread_limit = 0;

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

 julong os::available_memory() {

   return Solaris::available_memory();

 }

 julong os::Solaris::available_memory() {

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

 }

 julong os::Solaris::_physical_memory = 0;

 julong os::physical_memory() {

    return Solaris::physical_memory();

 }

 static hrtime_t first_hrtime = 0;

 static const hrtime_t hrtime_hz = 1000*1000*1000;

 const int LOCK_BUSY = 1;

 const int LOCK_FREE = 0;

 const int LOCK_INVALID = -1;

 static volatile hrtime_t max_hrtime = 0;

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

 void os::Solaris::initialize_system_info() {

   set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

   _processors_online = sysconf (_SC_NPROCESSORS_ONLN);

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

 }

 int os::active_processor_count() {

   int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);

   pid_t pid = getpid();

   psetid_t pset = PS_NONE;

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

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

     uint_t pset_cpus;

     // Query the number of cpus available to us.

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

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

       _processors_online = pset_cpus;

       return pset_cpus;

     }

   }

   // Otherwise return number of online cpus

   return online_cpus;

 }

 static bool find_processors_in_pset(psetid_t        pset,

                                     processorid_t** id_array,

                                     uint_t*         id_length) {

   bool result = false;

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

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

     // Make up an array to hold their ids.

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

     // Fill in the array with their processor ids.

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

       result = true;

     }

   }

   return result;

 }

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

 // the system configuration can change asynchronously because of DR

 // or explicit psradm operations.

 //

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

 // number of processors online can change between the _SC_NPROCESSORS_ONLN

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

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

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

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

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

 // exit the loop.

 //

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

 // not available on S8.0.

 static bool find_processors_online(processorid_t** id_array,

                                    uint*           id_length) {

   const processorid_t MAX_PROCESSOR_ID = 100000 ;

   // Find the number of processors online.

   *id_length = sysconf(_SC_NPROCESSORS_ONLN);

   // Make up an array to hold their ids.

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

   // Processors need not be numbered consecutively.

   long found = 0;

   processorid_t next = 0;

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

     processor_info_t info;

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

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

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

         (*id_array)[found] = next;

         found += 1;

       }

     }

     next += 1;

   }

   if (found < *id_length) {

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

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

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

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

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

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

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

       *id_length = found ;

   }

   return true;

 }

 static bool assign_distribution(processorid_t* id_array,

                                 uint           id_length,

                                 uint*          distribution,

                                 uint           distribution_length) {

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

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

          "can't convert processorid_t to uint");

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

   if (id_length < distribution_length) {

     return false;

   }

   // Assign processor ids to the distribution.

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

   // assuming 4 processors per board.

   const uint processors_per_board = ProcessDistributionStride;

   // Find the maximum processor id.

   processorid_t max_id = 0;

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

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

   }

   // The next id, to limit loops.

   const processorid_t limit_id = max_id + 1;

   // Make up markers for available processors.

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

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

     available_id[c] = false;

   }

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

     available_id[id_array[a]] = true;

   }

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

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

   //                remembering which processors have been assigned by

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

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

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

   //                how many processes are bound to a processor,

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

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

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

   static uint board = 0;

   uint assigned = 0;

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

   while (assigned < distribution_length) {

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

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

       uint try_id = board * processors_per_board + slot;

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

         distribution[assigned] = try_id;

         available_id[try_id] = false;

         assigned += 1;

         break;

       }

     }

     board += 1;

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

       board = 0;

     }

   }

   if (available_id != NULL) {

     FREE_C_HEAP_ARRAY(bool, available_id, mtInternal);

   }

   return true;

 }

 void os::set_native_thread_name(const char *name) {

   // Not yet implemented.

   return;

 }

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

   bool result = false;

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

   processorid_t* id_array  = NULL;

   uint           id_length = 0;

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

   // since processor sets can change dynamically.

   psetid_t pset = PS_NONE;

   // Are we running in a processor set?

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

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

   } else {

     result = find_processors_online(&id_array, &id_length);

   }

   if (result == true) {

     if (id_length >= length) {

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

     } else {

       result = false;

     }

   }

   if (id_array != NULL) {

     FREE_C_HEAP_ARRAY(processorid_t, id_array, mtInternal);

   }

   return result;

 }

 bool os::bind_to_processor(uint processor_id) {

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

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

          "can't convert uint to processorid_t");

   int bind_result =

     processor_bind(P_LWPID,                       // bind LWP.

                    P_MYID,                        // bind current LWP.

                    (processorid_t) processor_id,  // id.

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

   return (bind_result == 0);

 }

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

   char* val = ::getenv( name );

   if ( val == NULL

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

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

     return false;

   }

   strcpy( buffer, val );

   return true;

 }

 // Return true if user is running as root.

 bool os::have_special_privileges() {

   static bool init = false;

   static bool privileges = false;

   if (!init) {

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

     init = true;

   }

   return privileges;

 }

 void os::init_system_properties_values() {

   char arch[12];

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

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

   //

   // Obtain the JAVA_HOME value from the location of libjvm.so.

   // This library should be located at:

   // <JAVA_HOME>/jre/lib/<arch>/{client|server}/libjvm.so.

   //

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

   // assume libjvm.so is installed in a JDK and we use this path.

   //

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

   //

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

   //

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

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

   //

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

   // then we append a fake suffix "hotspot/libjvm.so" to this path so

   // it looks like libjvm.so is installed there

   // <JAVA_HOME>/jre/lib/<arch>/hotspot/libjvm.so.

   //

   // Otherwise exit.

   //

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

   // code needs to be changed accordingly.

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

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

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

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

 #define EXTENSIONS_DIR  "/lib/ext"

 #define ENDORSED_DIR    "/lib/endorsed"

 #define COMMON_DIR      "/usr/jdk/packages"

   {

     /* sysclasspath, java_home, dll_dir */

     {

         char *home_path;

         char *dll_path;

         char *pslash;

         char buf[MAXPATHLEN];

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

         // Found the full path to libjvm.so.

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

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

         pslash = strrchr(buf, '/');

         if (pslash != NULL)

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

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

         if (dll_path == NULL)

             return;

         strcpy(dll_path, buf);

         Arguments::set_dll_dir(dll_path);

         if (pslash != NULL) {

             pslash = strrchr(buf, '/');

             if (pslash != NULL) {

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

                 pslash = strrchr(buf, '/');

                 if (pslash != NULL)

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

             }

         }

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

         if (home_path == NULL)

             return;

         strcpy(home_path, buf);

         Arguments::set_java_home(home_path);

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

             return;

     }

     /*

      * Where to look for native libraries

      */

     {

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

       //

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

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

       // the Java launcher sets LD_LIBRARY_PATH for us and unsets

       // LD_LIBRARY_PATH_32 and LD_LIBRARY_PATH_64.  In this case

       // dlinfo returns LD_LIBRARY_PATH + crle settings (including

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

       //

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

       // overwrites this setting, and always has.

       //

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

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

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

       Dl_serinfo     _info, *info = &_info;

       Dl_serpath     *path;

       char*          library_path;

       char           *common_path;

       int            i;

       // determine search path count and required buffer size

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

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

       }

       // allocate new buffer and initialize

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

       if (info == NULL) {

         vm_exit_out_of_memory(_info.dls_size, OOM_MALLOC_ERROR,

                               "init_system_properties_values info");

       }

       info->dls_size = _info.dls_size;

       info->dls_cnt = _info.dls_cnt;

       // obtain search path information

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

         free(info);

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

       }

       path = &info->dls_serpath[0];

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

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

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

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

       //

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

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

       // Determine the actual CPU architecture.

       char cpu_arch[12];

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

 #ifdef _LP64

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

       //   sparc   -> sparcv9

       //   i386    -> amd64

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

         strcat(cpu_arch, "v9");

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

         strcpy(cpu_arch, "amd64");

 #endif

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

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

       // nulls included by the sizeof operator.

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

       common_path = malloc(bufsize);

       if (common_path == NULL) {

         free(info);

         vm_exit_out_of_memory(bufsize, OOM_MALLOC_ERROR,

                               "init_system_properties_values common_path");

       }

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

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

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

       // components explicitly added here.

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

       library_path = malloc(bufsize);

       if (library_path == NULL) {

         free(info);

         free(common_path);

         vm_exit_out_of_memory(bufsize, OOM_MALLOC_ERROR,

                               "init_system_properties_values library_path");

       }

       library_path[0] = '\0';

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

       // search path.

       //

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

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

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

       // infrastructure.

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

         strcpy(library_path, common_path);

       } else {

         int inserted = 0;

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

           uint_t flags = path->dls_flags & LA_SER_MASK;

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

             strcat(library_path, common_path);

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

             inserted = 1;

           }

           strcat(library_path, path->dls_name);

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

         }

         // eliminate trailing path separator

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

       }

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

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

       // tty->print_raw_cr(library_path);

       // callee copies into its own buffer

       Arguments::set_library_path(library_path);

       free(common_path);

       free(library_path);

       free(info);

     }

     /*

      * Extensions directories.

      *

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

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

      * than necessary is allocated).

      */

     {

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

             sizeof(EXTENSIONS_DIR) + sizeof(COMMON_DIR) +

             sizeof(EXTENSIONS_DIR));

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

             Arguments::get_java_home());

         Arguments::set_ext_dirs(buf);

     }

     /* Endorsed standards default directory. */

     {

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

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

         Arguments::set_endorsed_dirs(buf);

     }

   }

 #undef malloc

 #undef free

 #undef getenv

 #undef EXTENSIONS_DIR

 #undef ENDORSED_DIR

 #undef COMMON_DIR

 }

 void os::breakpoint() {

   BREAKPOINT;

 }

 bool os::obsolete_option(const JavaVMOption *option)

 {

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

     return true;

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

     return true;

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

     return true;

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

     return true;

   }

   return false;

 }

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

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

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

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

   return false;

 }

 extern "C" void breakpoint() {

   // use debugger to set breakpoint here

 }

 static thread_t main_thread;

 // Thread start routine for all new Java threads

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

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

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

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

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

   // processors with hyperthreading technology.

   static int counter = 0;

   int pid = os::current_process_id();

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

   int prio;

   Thread* thread = (Thread*)thread_addr;

   OSThread* osthr = thread->osthread();

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

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

   if (UseNUMA) {

     int lgrp_id = os::numa_get_group_id();

     if (lgrp_id != -1) {

       thread->set_lgrp_id(lgrp_id);

     }

   }

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

   // we need to call set_native_priority now that we have an lwp.

   // We used to get the priority from thr_getprio (we called

   // thr_setprio way back in create_thread) and pass it to

   // set_native_priority, but Solaris scales the priority

   // in java_to_os_priority, so when we read it back here,

   // we pass trash to set_native_priority instead of what's

   // in java_to_os_priority. So we save the native priority

   // in the osThread and recall it here.

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

     if ( UseThreadPriorities ) {

       int prio = osthr->native_priority();

       if (ThreadPriorityVerbose) {

         tty->print_cr("Starting Thread " INTPTR_FORMAT ", LWP is "

                       INTPTR_FORMAT ", setting priority: %d\n",

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

       }

       os::set_native_priority(thread, prio);

     }

   } else if (ThreadPriorityVerbose) {

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

   }

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

   // initialize signal mask for this thread

   os::Solaris::hotspot_sigmask(thread);

   thread->run();

   // One less thread is executing

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

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

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

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

   }

   if (UseDetachedThreads) {

     thr_exit(NULL);

     ShouldNotReachHere();

   }

   return NULL;

 }

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

   // Allocate the OSThread object

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

   if (osthread == NULL) return NULL;

   // Store info on the Solaris thread into the OSThread

   osthread->set_thread_id(thread_id);

   osthread->set_lwp_id(_lwp_self());

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

   if (UseNUMA) {

     int lgrp_id = os::numa_get_group_id();

     if (lgrp_id != -1) {

       thread->set_lgrp_id(lgrp_id);

     }

   }

   if ( ThreadPriorityVerbose ) {

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

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

   }

   // Initial thread state is INITIALIZED, not SUSPENDED

   osthread->set_state(INITIALIZED);

   return osthread;

 }

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

   //Save caller's signal mask

   sigset_t sigmask;

   thr_sigsetmask(SIG_SETMASK, NULL, &sigmask);

   OSThread *osthread = thread->osthread();

   osthread->set_caller_sigmask(sigmask);

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

   if (!ReduceSignalUsage) {

     if (thread->is_VM_thread()) {

       // Only the VM thread handles BREAK_SIGNAL ...

       thr_sigsetmask(SIG_UNBLOCK, vm_signals(), NULL);

     } else {

       // ... all other threads block BREAK_SIGNAL

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

       thr_sigsetmask(SIG_BLOCK, vm_signals(), NULL);

     }

   }

 }

 bool os::create_attached_thread(JavaThread* thread) {

 #ifdef ASSERT

   thread->verify_not_published();

 #endif

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

   if (osthread == NULL) {

      return false;

   }

   // Initial thread state is RUNNABLE

   osthread->set_state(RUNNABLE);

   thread->set_osthread(osthread);

   // initialize signal mask for this thread

   // and save the caller's signal mask

   os::Solaris::hotspot_sigmask(thread);

   return true;

 }

 bool os::create_main_thread(JavaThread* thread) {

 #ifdef ASSERT

   thread->verify_not_published();

 #endif

   if (_starting_thread == NULL) {

     _starting_thread = create_os_thread(thread, main_thread);

      if (_starting_thread == NULL) {

         return false;

      }

   }

   // The primodial thread is runnable from the start

   _starting_thread->set_state(RUNNABLE);

   thread->set_osthread(_starting_thread);

   // initialize signal mask for this thread

   // and save the caller's signal mask

   os::Solaris::hotspot_sigmask(thread);

   return true;

 }

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

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

 bool os::Solaris::_T2_libthread = false;

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

   // Allocate the OSThread object

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

   if (osthread == NULL) {

     return false;

   }

   if ( ThreadPriorityVerbose ) {

     char *thrtyp;

     switch ( thr_type ) {

       case vm_thread:

         thrtyp = (char *)"vm";

         break;

       case cgc_thread:

         thrtyp = (char *)"cgc";

         break;

       case pgc_thread:

         thrtyp = (char *)"pgc";

         break;

       case java_thread:

         thrtyp = (char *)"java";

         break;

       case compiler_thread:

         thrtyp = (char *)"compiler";

         break;

       case watcher_thread:

         thrtyp = (char *)"watcher";

         break;

       default:

         thrtyp = (char *)"unknown";

         break;

     }

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

   }

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

   if (stack_size == 0) {

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

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

     switch (thr_type) {

     case os::java_thread:

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

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

       break;

     case os::compiler_thread:

       if (CompilerThreadStackSize > 0) {

         stack_size = (size_t)(CompilerThreadStackSize * K);

         break;

       } // else fall through:

         // use VMThreadStackSize if CompilerThreadStackSize is not defined

     case os::vm_thread:

     case os::pgc_thread:

     case os::cgc_thread:

     case os::watcher_thread:

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

       break;

     }

   }

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

   // Initial state is ALLOCATED but not INITIALIZED

   osthread->set_state(ALLOCATED);

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

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

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

     // trying to reserve some.

     const size_t VirtualMemoryBangSize = 20*K*K;

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

     if (mem == NULL) {

       delete osthread;

       return false;

     } else {

       // Release the memory again

       os::release_memory(mem, VirtualMemoryBangSize);

     }

   }

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

   thread->set_osthread(osthread);

   // Create the Solaris thread

   // explicit THR_BOUND for T2_libthread case in case

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

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

   thread_t tid = 0;

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

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

                        (thr_type == vm_thread) ||

                        (thr_type == cgc_thread) ||

                        (thr_type == pgc_thread) ||

                        (thr_type == compiler_thread && BackgroundCompilation)) ?

                       THR_BOUND : 0);

   int      status;

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

   //

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

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

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

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

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

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

   // upcall policy.

   //

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

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

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

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

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

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

   // _processors_online as the min of SC_NPROCESSORS_ONLN and the

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

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

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

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

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

   //

   // Some pathologies this scheme doesn't handle:

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

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

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

   //    number of ready threads oscillates.

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

   //

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

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

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

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

     if (!(flags & THR_BOUND)) {

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

     }

   }

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

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

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

   DEBUG_ONLY(

       if ((VMThreadHintNoPreempt || CompilerThreadHintNoPreempt) &&

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

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

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

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

       }

   );

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

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

   osthread->set_lwp_id(-1);

   osthread->set_thread_id(-1);

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

   if (status != 0) {

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

       perror("os::create_thread");

     }

     thread->set_osthread(NULL);

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

     delete osthread;

     return false;

   }

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

   // Store info on the Solaris thread into the OSThread

   osthread->set_thread_id(tid);

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

   osthread->set_vm_created();

   // Set the default thread priority.  If using bound threads, setting

   // lwp priority will be delayed until thread start.

   set_native_priority(thread,

                       DefaultThreadPriority == -1 ?

                         java_to_os_priority[NormPriority] :

                         DefaultThreadPriority);

   // Initial thread state is INITIALIZED, not SUSPENDED

   osthread->set_state(INITIALIZED);

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

   return true;

 }

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

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

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

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

  */

 #if !defined(SIGJVM1)

 #define SIGJVM1 39

 #define SIGJVM2 40

 #endif

 debug_only(static bool signal_sets_initialized = false);

 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;

 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;

 int os::Solaris::_SIGasync = ASYNC_SIGNAL;

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

       struct sigaction oact;

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

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

                                      : CAST_FROM_FN_PTR(void*,  oact.sa_handler);

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

            return true;

       else

            return false;

 }

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

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

 static bool isJVM1available() {

   return SIGJVM1 < SIGRTMIN;

 }

 void os::Solaris::signal_sets_init() {

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

   assert(!signal_sets_initialized, "Already initialized");

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

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

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

   //                         by -Xrs (=ReduceSignalUsage));

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

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

   // the dispositions or masks wrt these signals.

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

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

   // interference with shutdown hooks and BREAK_SIGNAL thread dumping.

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

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

   // these signals are not blocked by default.

   sigemptyset(&unblocked_sigs);

   sigemptyset(&allowdebug_blocked_sigs);

   sigaddset(&unblocked_sigs, SIGILL);

   sigaddset(&unblocked_sigs, SIGSEGV);

   sigaddset(&unblocked_sigs, SIGBUS);

   sigaddset(&unblocked_sigs, SIGFPE);

   if (isJVM1available) {

     os::Solaris::set_SIGinterrupt(SIGJVM1);

     os::Solaris::set_SIGasync(SIGJVM2);

   } else if (UseAltSigs) {

     os::Solaris::set_SIGinterrupt(ALT_INTERRUPT_SIGNAL);

     os::Solaris::set_SIGasync(ALT_ASYNC_SIGNAL);

   } else {

     os::Solaris::set_SIGinterrupt(INTERRUPT_SIGNAL);

     os::Solaris::set_SIGasync(ASYNC_SIGNAL);

   }

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

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

   if (!ReduceSignalUsage) {

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

       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);

    }

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

       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);

    }

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

       sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);

    }

   }

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

   sigemptyset(&vm_sigs);

   if (!ReduceSignalUsage)

     sigaddset(&vm_sigs, BREAK_SIGNAL);

   debug_only(signal_sets_initialized = true);

   // For diagnostics only used in run_periodic_checks

   sigemptyset(&check_signal_done);

 }

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

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

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

   assert(signal_sets_initialized, "Not initialized");

   return &unblocked_sigs;

 }

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

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

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

   assert(signal_sets_initialized, "Not initialized");

   return &vm_sigs;

 }

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

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

   assert(signal_sets_initialized, "Not initialized");

   return &allowdebug_blocked_sigs;

 }

 void _handle_uncaught_cxx_exception() {

   VMError err("An uncaught C++ exception");

   err.report_and_die();

 }

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

 void os::initialize_thread(Thread* thr) {

   int r = thr_main() ;

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

   if (r) {

     JavaThread* jt = (JavaThread *)thr;

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

     size_t stack_size;

     address base = jt->stack_base();

     if (Arguments::created_by_java_launcher()) {

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

       stack_size = JavaThread::stack_size_at_create() == 0

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

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

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

       // Attempt to allow for a normally sized java_stack.

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

       stack_size += ReservedSpace::page_align_size_down(current_stack_offset);

     } else {

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

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

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

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

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

       size_t current_size = current_stack_size();

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

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

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

     }

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

     stack_size = (size_t)(base - bottom);

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

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

       NOT_PRODUCT(

         struct rlimit limits;

         getrlimit(RLIMIT_STACK, &limits);

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

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

       )

       tty->print_cr(

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

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

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

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

       vm_exit(1);

     }

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

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

     jt->set_stack_size(stack_size);

   }

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

    // throwing stack overflow exceptions, see bug 4463178

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

    // stacks.

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

    // Because alternate stacks associate with LWPs on Solaris,

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

    // we prefer to explicitly stack bang.

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

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

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

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

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

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

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

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

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

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

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

    // on installing alternate signal stacks

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

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

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

    // guard pages (red zone) and stackbanging.

    // Initially the alternate signal stack mechanism was removed because

    // it did not work with T1 llibthread. Alternate

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

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

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

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

    // use the dynamic check for T2 libthread.

   os::Solaris::init_thread_fpu_state();

   std::set_terminate(_handle_uncaught_cxx_exception);

 }

 // Free Solaris resources related to the OSThread

 void os::free_thread(OSThread* osthread) {

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

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

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

   // The main thread must take the VMThread down synchronously

   // before the main thread exits and frees up CodeHeap

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

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

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

     // Restore caller's signal mask

     sigset_t sigmask = osthread->caller_sigmask();

     thr_sigsetmask(SIG_SETMASK, &sigmask, NULL);

   }

   delete osthread;

 }

 void os::pd_start_thread(Thread* thread) {

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

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

 }

 intx os::current_thread_id() {

   return (intx)thr_self();

 }

 static pid_t _initial_pid = 0;

 int os::current_process_id() {

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

 }

 int os::allocate_thread_local_storage() {

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

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

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

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

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

   //           in TLS).

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

   //           be accessed via short sequences of displaced indirections.

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

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

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

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

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

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

   //           maintain the invariant that %g2 always contains the

   //           JavaThread in Java code, and have stubs simply

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

   thread_key_t tk;

   if (thr_keycreate( &tk, NULL ) )

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

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

   return int(tk);

 }

 void os::free_thread_local_storage(int index) {

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

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

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

 }

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

                       // small number - point is NO swap space available

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

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

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

     if (errno == ENOMEM) {

        vm_exit_out_of_memory(SMALLINT, OOM_MALLOC_ERROR,

                              "thr_setspecific: out of swap space");

     } else {

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

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

     }

   } else {

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

   }

 }

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

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

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

 void* os::thread_local_storage_at(int index) {

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

   void* r = NULL;

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

 }

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

 // getTimeNanos is guaranteed to not move backward on Solaris

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

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

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

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

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

 inline hrtime_t oldgetTimeNanos() {

   int gotlock = LOCK_INVALID;

   hrtime_t newtime = gethrtime();

   for (;;) {

 // grab lock for max_hrtime

     int curlock = max_hrtime_lock;

     if (curlock & LOCK_BUSY)  continue;

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

     if (newtime > max_hrtime) {

       max_hrtime = newtime;

     } else {

       newtime = max_hrtime;

     }

     // release lock

     max_hrtime_lock = LOCK_FREE;

     return newtime;

   }

 }

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

 // getTimeNanos is guaranteed to not move backward on Solaris

 inline hrtime_t getTimeNanos() {

   if (VM_Version::supports_cx8()) {

     const hrtime_t now = gethrtime();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   } else {

     return oldgetTimeNanos();

   }

 }

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

 // Used by VMSelfDestructTimer and the MemProfiler.

 double os::elapsedTime() {

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

 }

 jlong os::elapsed_counter() {

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

 }

 jlong os::elapsed_frequency() {

    return hrtime_hz;

 }

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

 // arbitrary fixed point in the past.

 bool os::getTimesSecs(double* process_real_time,

                   double* process_user_time,

                   double* process_system_time) {

   struct tms ticks;

   clock_t real_ticks = times(&ticks);

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

     return false;

   } else {

     double ticks_per_second = (double) clock_tics_per_sec;

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

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

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

     // converted to seconds.

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

     return true;

   }

 }

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

 bool os::enable_vtime() {

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

   if (fd == -1)

     return false;

   long cmd[] = { PCSET, PR_MSACCT };

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

   ::close(fd);

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

     return false;

   return true;

 }

 bool os::vtime_enabled() {

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

   if (fd == -1)

     return false;

   pstatus_t status;

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

   ::close(fd);

   if (res != sizeof(pstatus_t))

     return false;

   return status.pr_flags & PR_MSACCT;

 }

 double os::elapsedVTime() {

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

 }

 // Used internally for comparisons only

 // getTimeMillis guaranteed to not move backwards on Solaris

 jlong getTimeMillis() {

   jlong nanotime = getTimeNanos();

   return (jlong)(nanotime / NANOSECS_PER_MILLISEC);

 }

 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis

 jlong os::javaTimeMillis() {

   timeval t;

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

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

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

 }

 jlong os::javaTimeNanos() {

   return (jlong)getTimeNanos();

 }

 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {

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

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

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

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

 }

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

   struct tm t;

   time_t long_time;

   time(&long_time);

   localtime_r(&long_time, &t);

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

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

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

   return buf;

 }

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

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

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

 void os::shutdown() {

   // allow PerfMemory to attempt cleanup of any persistent resources

   perfMemory_exit();

   // needs to remove object in file system

   AttachListener::abort();

   // flush buffered output, finish log files

   ostream_abort();

   // Check for abort hook

   abort_hook_t abort_hook = Arguments::abort_hook();

   if (abort_hook != NULL) {

     abort_hook();

   }

 }

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

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

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

 void os::abort(bool dump_core) {

   os::shutdown();

   if (dump_core) {

 #ifndef PRODUCT

     fdStream out(defaultStream::output_fd());

     out.print_raw("Current thread is ");

     char buf[16];

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

     out.print_raw_cr(buf);

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

 #endif

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

   }

   ::exit(1);

 }

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

 void os::die() {

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

 }

 // unused

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

 // DLL functions

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

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

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

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

 static bool file_exists(const char* filename) {

   struct stat statbuf;

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

     return false;

   }

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

 }

 bool os::dll_build_name(char* buffer, size_t buflen,

                         const char* pname, const char* fname) {

   bool retval = false;

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

   // Return error on buffer overflow.

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

     return retval;

   }

   if (pnamelen == 0) {

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

     retval = true;

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

     int n;

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

     if (pelements == NULL) {

       return false;

     }

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

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

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

         continue; // skip the empty path values

       }

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

       if (file_exists(buffer)) {

         retval = true;

         break;

       }

     }

     // release the storage

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

       if (pelements[i] != NULL) {

         FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);

       }

     }

     if (pelements != NULL) {

       FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);

     }

   } else {

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

     retval = true;

   }

   return retval;

 }

 // check if addr is inside libjvm.so

 bool os::address_is_in_vm(address addr) {

   static address libjvm_base_addr;

   Dl_info dlinfo;

   if (libjvm_base_addr == NULL) {

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

     libjvm_base_addr = (address)dlinfo.dli_fbase;

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

   }

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

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

   }

   return false;

 }

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

 static dladdr1_func_type dladdr1_func = NULL;

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

                                       int buflen, int * offset) {

   Dl_info dlinfo;

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

   if (dladdr1_func){

       // yes, we have dladdr1

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

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

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

       // RTLD_DL_SYMENT.

       #ifndef RTLD_DL_SYMENT

       #define RTLD_DL_SYMENT 1

       #endif

 #ifdef _LP64

       Elf64_Sym * info;

 #else

       Elf32_Sym * info;

 #endif

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

                        RTLD_DL_SYMENT)) {

         if ((char *)dlinfo.dli_saddr + info->st_size > (char *)addr) {

           if (buf != NULL) {

             if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen))

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

             }

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

             return true;

         }

       }

       if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) {

         if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),

            buf, buflen, offset, dlinfo.dli_fname)) {

           return true;

         }

       }

       if (buf != NULL) buf[0] = '\0';

       if (offset != NULL) *offset  = -1;

       return false;

   } else {

       // no, only dladdr is available

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

         if (buf != NULL) {

           if (!Decoder::demangle(dlinfo.dli_sname, buf, buflen))

             jio_snprintf(buf, buflen, dlinfo.dli_sname);

         }

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

         return true;

       } else if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != 0) {

         if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),

           buf, buflen, offset, dlinfo.dli_fname)) {

           return true;

         }

       }

       if (buf != NULL) buf[0] = '\0';

       if (offset != NULL) *offset  = -1;

       return false;

   }

 }

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

                                      int buflen, int* offset) {

   Dl_info dlinfo;

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

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

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

      return true;

   } else {

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

      if (offset) *offset = -1;

      return false;

   }

 }

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

 // for current process

 void os::print_dll_info(outputStream * st) {

     Dl_info dli;

     void *handle;

     Link_map *map;

     Link_map *p;

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

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

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

         return;

     }

     handle = dlopen(dli.dli_fname, RTLD_LAZY);

     if (handle == NULL) {

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

         return;

     }

     dlinfo(handle, RTLD_DI_LINKMAP, &map);

     if (map == NULL) {

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

         return;

     }

     while (map->l_prev != NULL)

         map = map->l_prev;

     while (map != NULL) {

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

         map = map->l_next;

     }

     dlclose(handle);

 }

   // Loads .dll/.so and

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

   // same architecture as Hotspot is running on

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

 {

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

   if (result != NULL) {

     // Successful loading

     return result;

   }

   Elf32_Ehdr elf_head;

   // Read system error message into ebuf

   // It may or may not be overwritten below

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

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

   int diag_msg_max_length=ebuflen-strlen(ebuf);

   char* diag_msg_buf=ebuf+strlen(ebuf);

   if (diag_msg_max_length==0) {

     // No more space in ebuf for additional diagnostics message

     return NULL;

   }

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

   if (file_descriptor < 0) {

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

     return NULL;

   }

   bool failed_to_read_elf_head=

     (sizeof(elf_head)!=

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

   ::close(file_descriptor);

   if (failed_to_read_elf_head) {

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

     return NULL;

   }

   typedef struct {

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

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

     char        elf_class;    // 32 or 64 bit

     char        endianess;    // MSB or LSB

     char*       name;         // String representation

   } arch_t;

   static const arch_t arch_array[]={

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

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

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

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

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

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

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

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

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

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

   };

   #if  (defined IA32)

     static  Elf32_Half running_arch_code=EM_386;

   #elif   (defined AMD64)

     static  Elf32_Half running_arch_code=EM_X86_64;

   #elif  (defined IA64)

     static  Elf32_Half running_arch_code=EM_IA_64;

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

     static  Elf32_Half running_arch_code=EM_SPARCV9;

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

     static  Elf32_Half running_arch_code=EM_SPARC;

   #elif  (defined __powerpc64__)

     static  Elf32_Half running_arch_code=EM_PPC64;

   #elif  (defined __powerpc__)

     static  Elf32_Half running_arch_code=EM_PPC;

   #elif (defined ARM)

     static  Elf32_Half running_arch_code=EM_ARM;

   #else

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

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

   #endif

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

   // Obtain string descriptions for architectures

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

   int running_arch_index=-1;

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

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

       running_arch_index    = i;

     }

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

       lib_arch.compat_class = arch_array[i].compat_class;

       lib_arch.name         = arch_array[i].name;

     }

   }

   assert(running_arch_index != -1,

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

   if (running_arch_index == -1) {

     // Even though running architecture detection failed

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

     return NULL;

   }

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

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

     return NULL;

   }

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

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

     return NULL;

   }

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

     if ( lib_arch.name!=NULL ) {

       ::snprintf(diag_msg_buf, diag_msg_max_length-1,

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

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

     } else {

       ::snprintf(diag_msg_buf, diag_msg_max_length-1,

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

         lib_arch.code,

         arch_array[running_arch_index].name);

     }

   }

   return NULL;

 }

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

   return dlsym(handle, name);

 }

 int os::stat(const char *path, struct stat *sbuf) {

   char pathbuf[MAX_PATH];

   if (strlen(path) > MAX_PATH - 1) {

     errno = ENAMETOOLONG;

     return -1;

   }

   os::native_path(strcpy(pathbuf, path));

   return ::stat(pathbuf, sbuf);

 }

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

   int fd = ::open(filename, O_RDONLY);

   if (fd == -1) {

      return false;

   }

   char buf[32];

   int bytes;

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

     st->print_raw(buf, bytes);

   }

   ::close(fd);

   return true;

 }

 void os::print_os_info_brief(outputStream* st) {

   os::Solaris::print_distro_info(st);

   os::Posix::print_uname_info(st);

   os::Solaris::print_libversion_info(st);

 }

 void os::print_os_info(outputStream* st) {

   st->print("OS:");

   os::Solaris::print_distro_info(st);

   os::Posix::print_uname_info(st);

   os::Solaris::print_libversion_info(st);

   os::Posix::print_rlimit_info(st);

   os::Posix::print_load_average(st);

 }

 void os::Solaris::print_distro_info(outputStream* st) {

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

       st->print("Solaris");

     }

     st->cr();

 }

 void os::Solaris::print_libversion_info(outputStream* st) {

   if (os::Solaris::T2_libthread()) {

     st->print("  (T2 libthread)");

   }

   else {

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

   }

   st->cr();

 }

 static bool check_addr0(outputStream* st) {

   jboolean status = false;

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

   if (fd >= 0) {

     prmap_t p;

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

       if (p.pr_vaddr == 0x0) {

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

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

         st->print("Access:");

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

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

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

         st->cr();

         status = true;

       }

       ::close(fd);

     }

   }

   return status;

 }

 void os::pd_print_cpu_info(outputStream* st) {

   // Nothing to do for now.

 }

 void os::print_memory_info(outputStream* st) {

   st->print("Memory:");

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

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

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

   st->cr();

   (void) check_addr0(st);

 }

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

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

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

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

                           "ILL_COPROC", "ILL_BADSTK" };

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

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

                           "FPE_FLTINV", "FPE_FLTSUB" };

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

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

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

   st->print("siginfo:");

   const int buflen = 100;

   char buf[buflen];

   siginfo_t *si = (siginfo_t*)siginfo;

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

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

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

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

   } else {

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

   }

   const int c = si->si_code;

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

   switch (si->si_signo) {

   case SIGILL:

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

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

     break;

   case SIGFPE:

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

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

     break;

   case SIGSEGV:

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

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

     break;

   case SIGBUS:

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

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

     break;

   default:

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

     // no si_addr

   }

   if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&

       UseSharedSpaces) {

     FileMapInfo* mapinfo = FileMapInfo::current_info();

     if (mapinfo->is_in_shared_space(si->si_addr)) {

       st->print("\n\nError accessing class data sharing archive."   \

                 " Mapped file inaccessible during execution, "      \

                 " possible disk/network problem.");

     }

   }

   st->cr();

 }

 // Moved from whole group, because we need them here for diagnostic

 // prints.

 #define OLDMAXSIGNUM 32

 static int Maxsignum = 0;

 static int *ourSigFlags = NULL;

 extern "C" void sigINTRHandler(int, siginfo_t*, void*);

 int os::Solaris::get_our_sigflags(int sig) {

   assert(ourSigFlags!=NULL, "signal data structure not initialized");

   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");

   return ourSigFlags[sig];

 }

 void os::Solaris::set_our_sigflags(int sig, int flags) {

   assert(ourSigFlags!=NULL, "signal data structure not initialized");

   assert(sig > 0 && sig < Maxsignum, "vm signal out of expected range");

   ourSigFlags[sig] = flags;

 }

 static const char* get_signal_handler_name(address handler,

                                            char* buf, int buflen) {

   int offset;

   bool found = os::dll_address_to_library_name(handler, buf, buflen, &offset);

   if (found) {

     // skip directory names

     const char *p1, *p2;

     p1 = buf;

     size_t len = strlen(os::file_separator());

     while ((p2 = strstr(p1, os::file_separator())) != NULL) p1 = p2 + len;

     jio_snprintf(buf, buflen, "%s+0x%x", p1, offset);

   } else {

     jio_snprintf(buf, buflen, PTR_FORMAT, handler);

   }

   return buf;

 }

 static void print_signal_handler(outputStream* st, int sig,

                                   char* buf, size_t buflen) {

   struct sigaction sa;

   sigaction(sig, NULL, &sa);

   st->print("%s: ", os::exception_name(sig, buf, buflen));

   address handler = (sa.sa_flags & SA_SIGINFO)

                   ? CAST_FROM_FN_PTR(address, sa.sa_sigaction)

                   : CAST_FROM_FN_PTR(address, sa.sa_handler);

   if (handler == CAST_FROM_FN_PTR(address, SIG_DFL)) {

     st->print("SIG_DFL");

   } else if (handler == CAST_FROM_FN_PTR(address, SIG_IGN)) {

     st->print("SIG_IGN");

   } else {

     st->print("[%s]", get_signal_handler_name(handler, buf, buflen));

   }

   st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);

   address rh = VMError::get_resetted_sighandler(sig);

   // May be, handler was resetted by VMError?

   if(rh != NULL) {

     handler = rh;

     sa.sa_flags = VMError::get_resetted_sigflags(sig);

   }

   st->print(", sa_flags="   PTR32_FORMAT, sa.sa_flags);

   // Check: is it our handler?

   if(handler == CAST_FROM_FN_PTR(address, signalHandler) ||

      handler == CAST_FROM_FN_PTR(address, sigINTRHandler)) {

     // It is our signal handler

     // check for flags

     if(sa.sa_flags != os::Solaris::get_our_sigflags(sig)) {

       st->print(

         ", flags was changed from " PTR32_FORMAT ", consider using jsig library",

         os::Solaris::get_our_sigflags(sig));

     }

   }

   st->cr();

 }

 void os::print_signal_handlers(outputStream* st, char* buf, size_t buflen) {

   st->print_cr("Signal Handlers:");

   print_signal_handler(st, SIGSEGV, buf, buflen);

   print_signal_handler(st, SIGBUS , buf, buflen);

   print_signal_handler(st, SIGFPE , buf, buflen);

   print_signal_handler(st, SIGPIPE, buf, buflen);

   print_signal_handler(st, SIGXFSZ, buf, buflen);

   print_signal_handler(st, SIGILL , buf, buflen);

   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);

   print_signal_handler(st, ASYNC_SIGNAL, buf, buflen);

   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);

   print_signal_handler(st, SHUTDOWN1_SIGNAL , buf, buflen);

   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);

   print_signal_handler(st, SHUTDOWN3_SIGNAL, buf, buflen);

   print_signal_handler(st, os::Solaris::SIGinterrupt(), buf, buflen);

   print_signal_handler(st, os::Solaris::SIGasync(), buf, buflen);

 }

 static char saved_jvm_path[MAXPATHLEN] = { 0 };

 // Find the full path to the current module, libjvm.so

 void os::jvm_path(char *buf, jint buflen) {

   // Error checking.

   if (buflen < MAXPATHLEN) {

     assert(false, "must use a large-enough buffer");

     buf[0] = '\0';

     return;

   }

   // Lazy resolve the path to current module.

   if (saved_jvm_path[0] != 0) {

     strcpy(buf, saved_jvm_path);

     return;

   }

   Dl_info dlinfo;

   int ret = dladdr(CAST_FROM_FN_PTR(void *, os::jvm_path), &dlinfo);

   assert(ret != 0, "cannot locate libjvm");

   realpath((char *)dlinfo.dli_fname, buf);

   if (Arguments::created_by_gamma_launcher()) {

     // Support for the gamma launcher.  Typical value for buf is

     // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".  If "/jre/lib/" appears at

     // the right place in the string, then assume we are installed in a JDK and

     // we're done.  Otherwise, check for a JAVA_HOME environment variable and fix

     // up the path so it looks like libjvm.so is installed there (append a

     // fake suffix hotspot/libjvm.so).

     const char *p = buf + strlen(buf) - 1;

     for (int count = 0; p > buf && count < 5; ++count) {

       for (--p; p > buf && *p != '/'; --p)

         /* empty */ ;

     }

     if (strncmp(p, "/jre/lib/", 9) != 0) {

       // Look for JAVA_HOME in the environment.

       char* java_home_var = ::getenv("JAVA_HOME");

       if (java_home_var != NULL && java_home_var[0] != 0) {

         char cpu_arch[12];

         char* jrelib_p;

         int   len;

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

 #ifdef _LP64

         // If we are on sparc running a 64-bit vm, look in jre/lib/sparcv9.

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

           strcat(cpu_arch, "v9");

         } else if (strcmp(cpu_arch, "i386") == 0) {

           strcpy(cpu_arch, "amd64");

         }

 #endif

         // Check the current module name "libjvm.so".

         p = strrchr(buf, '/');

         assert(strstr(p, "/libjvm") == p, "invalid library name");

         realpath(java_home_var, buf);

         // determine if this is a legacy image or modules image

         // modules image doesn't have "jre" subdirectory

         len = strlen(buf);

         jrelib_p = buf + len;

         snprintf(jrelib_p, buflen-len, "/jre/lib/%s", cpu_arch);

         if (0 != access(buf, F_OK)) {

           snprintf(jrelib_p, buflen-len, "/lib/%s", cpu_arch);

         }

         if (0 == access(buf, F_OK)) {

           // Use current module name "libjvm.so"

           len = strlen(buf);

           snprintf(buf + len, buflen-len, "/hotspot/libjvm.so");

         } else {

           // Go back to path of .so

           realpath((char *)dlinfo.dli_fname, buf);

         }

       }

     }

   }

   strcpy(saved_jvm_path, buf);

 }

 void os::print_jni_name_prefix_on(outputStream* st, int args_size) {

   // no prefix required, not even "_"

 }

 void os::print_jni_name_suffix_on(outputStream* st, int args_size) {

   // no suffix required

 }

 // This method is a copy of JDK's sysGetLastErrorString

 // from src/solaris/hpi/src/system_md.c

 size_t os::lasterror(char *buf, size_t len) {

   if (errno == 0)  return 0;

   const char *s = ::strerror(errno);

   size_t n = ::strlen(s);

   if (n >= len) {

     n = len - 1;

   }

   ::strncpy(buf, s, n);

   buf[n] = '\0';

   return n;

 }

 // sun.misc.Signal

 extern "C" {

   static void UserHandler(int sig, void *siginfo, void *context) {

     // Ctrl-C is pressed during error reporting, likely because the error

     // handler fails to abort. Let VM die immediately.

     if (sig == SIGINT && is_error_reported()) {

        os::die();

     }

     os::signal_notify(sig);

     // We do not need to reinstate the signal handler each time...

   }

 }

 void* os::user_handler() {

   return CAST_FROM_FN_PTR(void*, UserHandler);

 }

 class Semaphore : public StackObj {

   public:

     Semaphore();

     ~Semaphore();

     void signal();

     void wait();

     bool trywait();

     bool timedwait(unsigned int sec, int nsec);

   private:

     sema_t _semaphore;

 };

 Semaphore::Semaphore() {

   sema_init(&_semaphore, 0, NULL, NULL);

 }

 Semaphore::~Semaphore() {

   sema_destroy(&_semaphore);

 }

 void Semaphore::signal() {

   sema_post(&_semaphore);

 }

 void Semaphore::wait() {

   sema_wait(&_semaphore);

 }

 bool Semaphore::trywait() {

   return sema_trywait(&_semaphore) == 0;

 }

 bool Semaphore::timedwait(unsigned int sec, int nsec) {

   struct timespec ts;

   unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);

   while (1) {

     int result = sema_timedwait(&_semaphore, &ts);

     if (result == 0) {

       return true;

     } else if (errno == EINTR) {

       continue;

     } else if (errno == ETIME) {

       return false;

     } else {

       return false;

     }

   }

 }

 extern "C" {

   typedef void (*sa_handler_t)(int);

   typedef void (*sa_sigaction_t)(int, siginfo_t *, void *);

 }

 void* os::signal(int signal_number, void* handler) {

   struct sigaction sigAct, oldSigAct;

   sigfillset(&(sigAct.sa_mask));

   sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;

   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);

   if (sigaction(signal_number, &sigAct, &oldSigAct))

     // -1 means registration failed

     return (void *)-1;

   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);

 }

 void os::signal_raise(int signal_number) {

   raise(signal_number);

 }

 /*

  * The following code is moved from os.cpp for making this

  * code platform specific, which it is by its very nature.

  */

 // a counter for each possible signal value

 static int Sigexit = 0;

 static int Maxlibjsigsigs;

 static jint *pending_signals = NULL;

 static int *preinstalled_sigs = NULL;

 static struct sigaction *chainedsigactions = NULL;

 static sema_t sig_sem;

 typedef int (*version_getting_t)();

 version_getting_t os::Solaris::get_libjsig_version = NULL;

 static int libjsigversion = NULL;

 int os::sigexitnum_pd() {

   assert(Sigexit > 0, "signal memory not yet initialized");

   return Sigexit;

 }

 void os::Solaris::init_signal_mem() {

   // Initialize signal structures

   Maxsignum = SIGRTMAX;

   Sigexit = Maxsignum+1;

   assert(Maxsignum >0, "Unable to obtain max signal number");

   Maxlibjsigsigs = Maxsignum;

   // pending_signals has one int per signal

   // The additional signal is for SIGEXIT - exit signal to signal_thread

   pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal);

   memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));

   if (UseSignalChaining) {

      chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)

        * (Maxsignum + 1), mtInternal);

      memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));

      preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal);

      memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));

   }

   ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ), mtInternal);

   memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));

 }

 void os::signal_init_pd() {

   int ret;

   ret = ::sema_init(&sig_sem, 0, NULL, NULL);

   assert(ret == 0, "sema_init() failed");

 }