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

 /*

  * Copyright (c) 1999, 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_bsd.h"

 #include "memory/allocation.inline.hpp"

 #include "memory/filemap.hpp"

 #include "mutex_bsd.inline.hpp"

 #include "oops/oop.inline.hpp"

 #include "os_share_bsd.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 <sys/types.h>

 # include <sys/mman.h>

 # include <sys/stat.h>

 # include <sys/select.h>

 # include <pthread.h>

 # include <signal.h>

 # include <errno.h>

 # include <dlfcn.h>

 # include <stdio.h>

 # include <unistd.h>

 # include <sys/resource.h>

 # include <pthread.h>

 # include <sys/stat.h>

 # include <sys/time.h>

 # include <sys/times.h>

 # include <sys/utsname.h>

 # include <sys/socket.h>

 # include <sys/wait.h>

 # include <time.h>

 # include <pwd.h>

 # include <poll.h>

 # include <semaphore.h>

 # include <fcntl.h>

 # include <string.h>

 # include <sys/param.h>

 # include <sys/sysctl.h>

 # include <sys/ipc.h>

 # include <sys/shm.h>

 #ifndef __APPLE__

 # include <link.h>

 #endif

 # include <stdint.h>

 # include <inttypes.h>

 # include <sys/ioctl.h>

 # include <sys/syscall.h>

 #if defined(__FreeBSD__) || defined(__NetBSD__)

 # include <elf.h>

 #endif

 #ifdef __APPLE__

 # include <mach/mach.h> // semaphore_* API

 # include <mach-o/dyld.h>

 # include <sys/proc_info.h>

 # include <objc/objc-auto.h>

 #endif

 #ifndef MAP_ANONYMOUS

 #define MAP_ANONYMOUS MAP_ANON

 #endif

 #define MAX_PATH    (2 * K)

 // for timer info max values which include all bits

 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

 #define LARGEPAGES_BIT (1 << 6)

 ////////////////////////////////////////////////////////////////////////////////

 // global variables

 julong os::Bsd::_physical_memory = 0;

 int (*os::Bsd::_clock_gettime)(clockid_t, struct timespec *) = NULL;

 pthread_t os::Bsd::_main_thread;

 int os::Bsd::_page_size = -1;

 static jlong initial_time_count=0;

 static int clock_tics_per_sec = 100;

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

 static sigset_t check_signal_done;

 static bool check_signals = true;

 static pid_t _initial_pid = 0;

 /* Signal number used to suspend/resume a thread */

 /* do not use any signal number less than SIGSEGV, see 4355769 */

 static int SR_signum = SIGUSR2;

 sigset_t SR_sigset;

 ////////////////////////////////////////////////////////////////////////////////

 // utility functions

 static int SR_initialize();

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

 julong os::available_memory() {

   return Bsd::available_memory();

 }

 // available here means free

 julong os::Bsd::available_memory() {

   uint64_t available = physical_memory() >> 2;

 #ifdef __APPLE__

   mach_msg_type_number_t count = HOST_VM_INFO64_COUNT;

   vm_statistics64_data_t vmstat;

   kern_return_t kerr = host_statistics64(mach_host_self(), HOST_VM_INFO64,

                                          (host_info64_t)&vmstat, &count);

   assert(kerr == KERN_SUCCESS,

          "host_statistics64 failed - check mach_host_self() and count");

   if (kerr == KERN_SUCCESS) {

     available = vmstat.free_count * os::vm_page_size();

   }

 #endif

   return available;

 }

 julong os::physical_memory() {

   return Bsd::physical_memory();

 }

 ////////////////////////////////////////////////////////////////////////////////

 // environment support

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

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

   if (val != NULL && strlen(val) < (size_t)len) {

     strcpy(buf, val);

     return true;

   }

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

   return false;

 }

 // 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;

 }

 // Cpu architecture string

 #if   defined(ZERO)

 static char cpu_arch[] = ZERO_LIBARCH;

 #elif defined(IA64)

 static char cpu_arch[] = "ia64";

 #elif defined(IA32)

 static char cpu_arch[] = "i386";

 #elif defined(AMD64)

 static char cpu_arch[] = "amd64";

 #elif defined(ARM)

 static char cpu_arch[] = "arm";

 #elif defined(PPC32)

 static char cpu_arch[] = "ppc";

 #elif defined(SPARC)

 #  ifdef _LP64

 static char cpu_arch[] = "sparcv9";

 #  else

 static char cpu_arch[] = "sparc";

 #  endif

 #else

 #error Add appropriate cpu_arch setting

 #endif

 // Compiler variant

 #ifdef COMPILER2

 #define COMPILER_VARIANT "server"

 #else

 #define COMPILER_VARIANT "client"

 #endif

 void os::Bsd::initialize_system_info() {

   int mib[2];

   size_t len;

   int cpu_val;

   julong mem_val;

   /* get processors count via hw.ncpus sysctl */

   mib[0] = CTL_HW;

   mib[1] = HW_NCPU;

   len = sizeof(cpu_val);

   if (sysctl(mib, 2, &cpu_val, &len, NULL, 0) != -1 && cpu_val >= 1) {

        assert(len == sizeof(cpu_val), "unexpected data size");

        set_processor_count(cpu_val);

   }

   else {

        set_processor_count(1);   // fallback

   }

   /* get physical memory via hw.memsize sysctl (hw.memsize is used

    * since it returns a 64 bit value)

    */

   mib[0] = CTL_HW;

 #if defined (HW_MEMSIZE) // Apple

   mib[1] = HW_MEMSIZE;

 #elif defined(HW_PHYSMEM) // Most of BSD

   mib[1] = HW_PHYSMEM;

 #elif defined(HW_REALMEM) // Old FreeBSD

   mib[1] = HW_REALMEM;

 #else

   #error No ways to get physmem

 #endif

   len = sizeof(mem_val);

   if (sysctl(mib, 2, &mem_val, &len, NULL, 0) != -1) {

        assert(len == sizeof(mem_val), "unexpected data size");

        _physical_memory = mem_val;

   } else {

        _physical_memory = 256*1024*1024;       // fallback (XXXBSD?)

   }

 #ifdef __OpenBSD__

   {

        // limit _physical_memory memory view on OpenBSD since

        // datasize rlimit restricts us anyway.

        struct rlimit limits;

        getrlimit(RLIMIT_DATA, &limits);

        _physical_memory = MIN2(_physical_memory, (julong)limits.rlim_cur);

   }

 #endif

 }

 #ifdef __APPLE__

 static const char *get_home() {

   const char *home_dir = ::getenv("HOME");

   if ((home_dir == NULL) || (*home_dir == '\0')) {

     struct passwd *passwd_info = getpwuid(geteuid());

     if (passwd_info != NULL) {

       home_dir = passwd_info->pw_dir;

     }

   }

   return home_dir;

 }

 #endif

 void os::init_system_properties_values() {

   // 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.

 // See ld(1):

 //      The linker uses the following search paths to locate required

 //      shared libraries:

 //        1: ...

 //        ...

 //        7: The default directories, normally /lib and /usr/lib.

 #ifndef DEFAULT_LIBPATH

 #define DEFAULT_LIBPATH "/lib:/usr/lib"

 #endif

 // Base path of extensions installed on the system.

 #define SYS_EXT_DIR     "/usr/java/packages"

 #define EXTENSIONS_DIR  "/lib/ext"

 #define ENDORSED_DIR    "/lib/endorsed"

 #ifndef __APPLE__

   // Buffer that fits several sprintfs.

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

   // by the nulls included by the sizeof operator.

   const size_t bufsize =

     MAX3((size_t)MAXPATHLEN,  // For dll_dir & friends.

          (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR) + sizeof(SYS_EXT_DIR) + sizeof(EXTENSIONS_DIR), // extensions dir

          (size_t)MAXPATHLEN + sizeof(ENDORSED_DIR)); // endorsed dir

   char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);

   // sysclasspath, java_home, dll_dir

   {

     char *pslash;

     os::jvm_path(buf, bufsize);

     // 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}.

     }

     Arguments::set_dll_dir(buf);

     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.

         }

       }

     }

     Arguments::set_java_home(buf);

     set_boot_path('/', ':');

   }

   // Where to look for native libraries.

   //

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

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

   // on legacy Bsd 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/java/packages is added here.

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

   {

     // Get the user setting of LD_LIBRARY_PATH, and prepended it. It

     // should always exist (until the legacy problem cited above is

     // addressed).

     const char *v = ::getenv("LD_LIBRARY_PATH");

     const char *v_colon = ":";

     if (v == NULL) { v = ""; v_colon = ""; }

     // That's +1 for the colon and +1 for the trailing '\0'.

     char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char,

                                                      strlen(v) + 1 +

                                                      sizeof(SYS_EXT_DIR) + sizeof("/lib/") + strlen(cpu_arch) + sizeof(DEFAULT_LIBPATH) + 1,

                                                      mtInternal);

     sprintf(ld_library_path, "%s%s" SYS_EXT_DIR "/lib/%s:" DEFAULT_LIBPATH, v, v_colon, cpu_arch);

     Arguments::set_library_path(ld_library_path);

     FREE_C_HEAP_ARRAY(char, ld_library_path, mtInternal);

   }

   // Extensions directories.

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

   Arguments::set_ext_dirs(buf);

   // Endorsed standards default directory.

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

   Arguments::set_endorsed_dirs(buf);

   FREE_C_HEAP_ARRAY(char, buf, mtInternal);

 #else // __APPLE__

 #define SYS_EXTENSIONS_DIR   "/Library/Java/Extensions"

 #define SYS_EXTENSIONS_DIRS  SYS_EXTENSIONS_DIR ":/Network" SYS_EXTENSIONS_DIR ":/System" SYS_EXTENSIONS_DIR ":/usr/lib/java"

   const char *user_home_dir = get_home();

   // The null in SYS_EXTENSIONS_DIRS counts for the size of the colon after user_home_dir.

   size_t system_ext_size = strlen(user_home_dir) + sizeof(SYS_EXTENSIONS_DIR) +

     sizeof(SYS_EXTENSIONS_DIRS);

   // Buffer that fits several sprintfs.

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

   // by the nulls included by the sizeof operator.

   const size_t bufsize =

     MAX3((size_t)MAXPATHLEN,  // for dll_dir & friends.

          (size_t)MAXPATHLEN + sizeof(EXTENSIONS_DIR) + system_ext_size, // extensions dir

          (size_t)MAXPATHLEN + sizeof(ENDORSED_DIR)); // endorsed dir

   char *buf = (char *)NEW_C_HEAP_ARRAY(char, bufsize, mtInternal);

   // sysclasspath, java_home, dll_dir

   {

     char *pslash;

     os::jvm_path(buf, bufsize);

     // 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}.

     }

     Arguments::set_dll_dir(buf);

     if (pslash != NULL) {

       pslash = strrchr(buf, '/');

       if (pslash != NULL) {

         *pslash = '\0';          // Get rid of /lib.

       }

     }

     Arguments::set_java_home(buf);

     set_boot_path('/', ':');

   }

   // Where to look for native libraries.

   //

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

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

   // on legacy Bsd 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/java/packages is added here.

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

   {

     // Get the user setting of LD_LIBRARY_PATH, and prepended it. It

     // should always exist (until the legacy problem cited above is

     // addressed).

     // Prepend the default path with the JAVA_LIBRARY_PATH so that the app launcher code

     // can specify a directory inside an app wrapper

     const char *l = ::getenv("JAVA_LIBRARY_PATH");

     const char *l_colon = ":";

     if (l == NULL) { l = ""; l_colon = ""; }

     const char *v = ::getenv("DYLD_LIBRARY_PATH");

     const char *v_colon = ":";

     if (v == NULL) { v = ""; v_colon = ""; }

     // Apple's Java6 has "." at the beginning of java.library.path.

     // OpenJDK on Windows has "." at the end of java.library.path.

     // OpenJDK on Linux and Solaris don't have "." in java.library.path

     // at all. To ease the transition from Apple's Java6 to OpenJDK7,

     // "." is appended to the end of java.library.path. Yes, this

     // could cause a change in behavior, but Apple's Java6 behavior

     // can be achieved by putting "." at the beginning of the

     // JAVA_LIBRARY_PATH environment variable.

     char *ld_library_path = (char *)NEW_C_HEAP_ARRAY(char,

                                                      strlen(v) + 1 + strlen(l) + 1 +

                                                      system_ext_size + 3,

                                                      mtInternal);

     sprintf(ld_library_path, "%s%s%s%s%s" SYS_EXTENSIONS_DIR ":" SYS_EXTENSIONS_DIRS ":.",

             v, v_colon, l, l_colon, user_home_dir);

     Arguments::set_library_path(ld_library_path);

     FREE_C_HEAP_ARRAY(char, ld_library_path, mtInternal);

   }

   // 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).

   sprintf(buf, "%s" SYS_EXTENSIONS_DIR ":%s" EXTENSIONS_DIR ":" SYS_EXTENSIONS_DIRS,

           user_home_dir, Arguments::get_java_home());

   Arguments::set_ext_dirs(buf);

   // Endorsed standards default directory.

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

   Arguments::set_endorsed_dirs(buf);

   FREE_C_HEAP_ARRAY(char, buf, mtInternal);

 #undef SYS_EXTENSIONS_DIR

 #undef SYS_EXTENSIONS_DIRS

 #endif // __APPLE__

 #undef SYS_EXT_DIR

 #undef EXTENSIONS_DIR

 #undef ENDORSED_DIR

 }

 ////////////////////////////////////////////////////////////////////////////////

 // breakpoint support

 void os::breakpoint() {

   BREAKPOINT;

 }

 extern "C" void breakpoint() {

   // use debugger to set breakpoint here

 }

 ////////////////////////////////////////////////////////////////////////////////

 // signal support

 debug_only(static bool signal_sets_initialized = false);

 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;

 bool os::Bsd::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;

 }

 void os::Bsd::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);

   sigaddset(&unblocked_sigs, SR_signum);

   if (!ReduceSignalUsage) {

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

       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);

    }

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

       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);

    }

    if (!os::Bsd::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);

 }

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

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

 sigset_t* os::Bsd::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::Bsd::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::Bsd::allowdebug_blocked_signals() {

   assert(signal_sets_initialized, "Not initialized");

   return &allowdebug_blocked_sigs;

 }

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

   //Save caller's signal mask before setting VM signal mask

   sigset_t caller_sigmask;

   pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);

   OSThread* osthread = thread->osthread();

   osthread->set_caller_sigmask(caller_sigmask);

   pthread_sigmask(SIG_UNBLOCK, os::Bsd::unblocked_signals(), NULL);

   if (!ReduceSignalUsage) {

     if (thread->is_VM_thread()) {

       // Only the VM thread handles BREAK_SIGNAL ...

       pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);

     } else {

       // ... all other threads block BREAK_SIGNAL

       pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);

     }

   }

 }

 //////////////////////////////////////////////////////////////////////////////

 // create new thread

 // check if it's safe to start a new thread

 static bool _thread_safety_check(Thread* thread) {

   return true;

 }

 #ifdef __APPLE__

 // library handle for calling objc_registerThreadWithCollector()

 // without static linking to the libobjc library

 #define OBJC_LIB "/usr/lib/libobjc.dylib"

 #define OBJC_GCREGISTER "objc_registerThreadWithCollector"

 typedef void (*objc_registerThreadWithCollector_t)();

 extern "C" objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction;

 objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction = NULL;

 #endif

 #ifdef __APPLE__

 static uint64_t locate_unique_thread_id(mach_port_t mach_thread_port) {

   // Additional thread_id used to correlate threads in SA

   thread_identifier_info_data_t     m_ident_info;

   mach_msg_type_number_t            count = THREAD_IDENTIFIER_INFO_COUNT;

   thread_info(mach_thread_port, THREAD_IDENTIFIER_INFO,

               (thread_info_t) &m_ident_info, &count);

   return m_ident_info.thread_id;

 }

 #endif

 // Thread start routine for all newly created threads

 static void *java_start(Thread *thread) {

   // 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);

   ThreadLocalStorage::set_thread(thread);

   OSThread* osthread = thread->osthread();

   Monitor* sync = osthread->startThread_lock();

   // non floating stack BsdThreads needs extra check, see above

   if (!_thread_safety_check(thread)) {

     // notify parent thread

     MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);

     osthread->set_state(ZOMBIE);

     sync->notify_all();

     return NULL;

   }

   osthread->set_thread_id(os::Bsd::gettid());

 #ifdef __APPLE__

   uint64_t unique_thread_id = locate_unique_thread_id(osthread->thread_id());

   guarantee(unique_thread_id != 0, "unique thread id was not found");

   osthread->set_unique_thread_id(unique_thread_id);

 #endif

   // initialize signal mask for this thread

   os::Bsd::hotspot_sigmask(thread);

   // initialize floating point control register

   os::Bsd::init_thread_fpu_state();

 #ifdef __APPLE__

   // register thread with objc gc

   if (objc_registerThreadWithCollectorFunction != NULL) {

     objc_registerThreadWithCollectorFunction();

   }

 #endif

   // handshaking with parent thread

   {

     MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);

     // notify parent thread

     osthread->set_state(INITIALIZED);

     sync->notify_all();

     // wait until os::start_thread()

     while (osthread->get_state() == INITIALIZED) {

       sync->wait(Mutex::_no_safepoint_check_flag);

     }

   }

   // call one more level start routine

   thread->run();

   return 0;

 }

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

   assert(thread->osthread() == NULL, "caller responsible");

   // Allocate the OSThread object

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

   if (osthread == NULL) {

     return false;

   }

   // set the correct thread state

   osthread->set_thread_type(thr_type);

   // Initial state is ALLOCATED but not INITIALIZED

   osthread->set_state(ALLOCATED);

   thread->set_osthread(osthread);

   // init thread attributes

   pthread_attr_t attr;

   pthread_attr_init(&attr);

   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

   // stack size

   if (os::Bsd::supports_variable_stack_size()) {

     // calculate stack size if it's not specified by caller

     if (stack_size == 0) {

       stack_size = os::Bsd::default_stack_size(thr_type);

       switch (thr_type) {

       case os::java_thread:

         // Java threads use ThreadStackSize which default value can be

         // changed with the flag -Xss

         assert (JavaThread::stack_size_at_create() > 0, "this should be set");

         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::Bsd::min_stack_allowed);

     pthread_attr_setstacksize(&attr, stack_size);

   } else {

     // let pthread_create() pick the default value.

   }

   ThreadState state;

   {

     pthread_t tid;

     int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

     pthread_attr_destroy(&attr);

     if (ret != 0) {

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

         perror("pthread_create()");

       }

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

       thread->set_osthread(NULL);

       delete osthread;

       return false;

     }

     // Store pthread info into the OSThread

     osthread->set_pthread_id(tid);

     // Wait until child thread is either initialized or aborted

     {

       Monitor* sync_with_child = osthread->startThread_lock();

       MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);

       while ((state = osthread->get_state()) == ALLOCATED) {

         sync_with_child->wait(Mutex::_no_safepoint_check_flag);

       }

     }

   }

   // Aborted due to thread limit being reached

   if (state == ZOMBIE) {

       thread->set_osthread(NULL);

       delete osthread;

       return false;

   }

   // The thread is returned suspended (in state INITIALIZED),

   // and is started higher up in the call chain

   assert(state == INITIALIZED, "race condition");

   return true;

 }

 /////////////////////////////////////////////////////////////////////////////

 // attach existing thread

 // bootstrap the main thread

 bool os::create_main_thread(JavaThread* thread) {

   assert(os::Bsd::_main_thread == pthread_self(), "should be called inside main thread");

   return create_attached_thread(thread);

 }

 bool os::create_attached_thread(JavaThread* thread) {

 #ifdef ASSERT

     thread->verify_not_published();

 #endif

   // Allocate the OSThread object

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

   if (osthread == NULL) {

     return false;

   }

   osthread->set_thread_id(os::Bsd::gettid());

   // Store pthread info into the OSThread

 #ifdef __APPLE__

   uint64_t unique_thread_id = locate_unique_thread_id(osthread->thread_id());

   guarantee(unique_thread_id != 0, "just checking");

   osthread->set_unique_thread_id(unique_thread_id);

 #endif

   osthread->set_pthread_id(::pthread_self());

   // initialize floating point control register

   os::Bsd::init_thread_fpu_state();

   // 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::Bsd::hotspot_sigmask(thread);

   return true;

 }

 void os::pd_start_thread(Thread* thread) {

   OSThread * osthread = thread->osthread();

   assert(osthread->get_state() != INITIALIZED, "just checking");

   Monitor* sync_with_child = osthread->startThread_lock();

   MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);

   sync_with_child->notify();

 }

 // Free Bsd resources related to the OSThread

 void os::free_thread(OSThread* osthread) {

   assert(osthread != NULL, "osthread not set");

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

     // Restore caller's signal mask

     sigset_t sigmask = osthread->caller_sigmask();

     pthread_sigmask(SIG_SETMASK, &sigmask, NULL);

    }

   delete osthread;

 }

 //////////////////////////////////////////////////////////////////////////////

 // thread local storage

 // Restore the thread pointer if the destructor is called. This is in case

 // someone from JNI code sets up a destructor with pthread_key_create to run

 // detachCurrentThread on thread death. Unless we restore the thread pointer we

 // will hang or crash. When detachCurrentThread is called the key will be set

 // to null and we will not be called again. If detachCurrentThread is never

 // called we could loop forever depending on the pthread implementation.

 static void restore_thread_pointer(void* p) {

   Thread* thread = (Thread*) p;

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

 }

 int os::allocate_thread_local_storage() {

   pthread_key_t key;

   int rslt = pthread_key_create(&key, restore_thread_pointer);

   assert(rslt == 0, "cannot allocate thread local storage");

   return (int)key;

 }

 // Note: This is currently not used by VM, as we don't destroy TLS key

 // on VM exit.

 void os::free_thread_local_storage(int index) {

   int rslt = pthread_key_delete((pthread_key_t)index);

   assert(rslt == 0, "invalid index");

 }

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

   int rslt = pthread_setspecific((pthread_key_t)index, value);

   assert(rslt == 0, "pthread_setspecific failed");

 }

 extern "C" Thread* get_thread() {

   return ThreadLocalStorage::thread();

 }

 ////////////////////////////////////////////////////////////////////////////////

 // time support

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

 // Used by VMSelfDestructTimer and the MemProfiler.

 double os::elapsedTime() {

   return ((double)os::elapsed_counter()) / os::elapsed_frequency();

 }

 jlong os::elapsed_counter() {

   return javaTimeNanos() - initial_time_count;

 }

 jlong os::elapsed_frequency() {

   return NANOSECS_PER_SEC; // nanosecond resolution

 }

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

 bool os::enable_vtime()   { return false; }

 bool os::vtime_enabled()  { return false; }

 double os::elapsedVTime() {

   // better than nothing, but not much

   return elapsedTime();

 }

 jlong os::javaTimeMillis() {

   timeval time;

   int status = gettimeofday(&time, NULL);

   assert(status != -1, "bsd error");

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

 }

 #ifndef CLOCK_MONOTONIC

 #define CLOCK_MONOTONIC (1)

 #endif

 #ifdef __APPLE__

 void os::Bsd::clock_init() {

         // XXXDARWIN: Investigate replacement monotonic clock

 }

 #else

 void os::Bsd::clock_init() {

   struct timespec res;

   struct timespec tp;

   if (::clock_getres(CLOCK_MONOTONIC, &res) == 0 &&

       ::clock_gettime(CLOCK_MONOTONIC, &tp)  == 0) {

     // yes, monotonic clock is supported

     _clock_gettime = ::clock_gettime;

   }

 }

 #endif

 jlong os::javaTimeNanos() {

   if (Bsd::supports_monotonic_clock()) {

     struct timespec tp;

     int status = Bsd::clock_gettime(CLOCK_MONOTONIC, &tp);

     assert(status == 0, "gettime error");

     jlong result = jlong(tp.tv_sec) * (1000 * 1000 * 1000) + jlong(tp.tv_nsec);

     return result;

   } else {

     timeval time;

     int status = gettimeofday(&time, NULL);

     assert(status != -1, "bsd error");

     jlong usecs = jlong(time.tv_sec) * (1000 * 1000) + jlong(time.tv_usec);

     return 1000 * usecs;

   }

 }

 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {

   if (Bsd::supports_monotonic_clock()) {

     info_ptr->max_value = ALL_64_BITS;

     // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past

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

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

   } else {

     // gettimeofday - based on time in seconds since the Epoch thus does not wrap

     info_ptr->max_value = ALL_64_BITS;

     // gettimeofday is a real time clock so it skips

     info_ptr->may_skip_backward = true;

     info_ptr->may_skip_forward = true;

   }

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

 }

 // 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;

     *process_real_time = ((double) real_ticks) / ticks_per_second;

     return true;

   }

 }

 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;

 }

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

   return localtime_r(clock, res);

 }

 ////////////////////////////////////////////////////////////////////////////////

 // runtime exit support

 // 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

   }

   ::exit(1);

 }

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

 void os::die() {

   // _exit() on BsdThreads only kills current thread

   ::abort();

 }

 // unused on bsd for now.

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

 // 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;

 }

 // Information of current thread in variety of formats

 pid_t os::Bsd::gettid() {

   int retval = -1;

 #ifdef __APPLE__ //XNU kernel

   // despite the fact mach port is actually not a thread id use it

   // instead of syscall(SYS_thread_selfid) as it certainly fits to u4

   retval = ::pthread_mach_thread_np(::pthread_self());

   guarantee(retval != 0, "just checking");

   return retval;

 #elif __FreeBSD__

   retval = syscall(SYS_thr_self);

 #elif __OpenBSD__

   retval = syscall(SYS_getthrid);

 #elif __NetBSD__

   retval = (pid_t) syscall(SYS__lwp_self);

 #endif

   if (retval == -1) {

     return getpid();

   }

 }

 intx os::current_thread_id() {

 #ifdef __APPLE__

   return (intx)::pthread_mach_thread_np(::pthread_self());

 #else

   return (intx)::pthread_self();

 #endif

 }

 int os::current_process_id() {

   // Under the old bsd thread library, bsd gives each thread

   // its own process id. Because of this each thread will return

   // a different pid if this method were to return the result

   // of getpid(2). Bsd provides no api that returns the pid

   // of the launcher thread for the vm. This implementation

   // returns a unique pid, the pid of the launcher thread

   // that starts the vm 'process'.

   // Under the NPTL, getpid() returns the same pid as the

   // launcher thread rather than a unique pid per thread.

   // Use gettid() if you want the old pre NPTL behaviour.

   // if you are looking for the result of a call to getpid() that

   // returns a unique pid for the calling thread, then look at the

   // OSThread::thread_id() method in osThread_bsd.hpp file

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

 }

 // DLL functions

 #define JNI_LIB_PREFIX "lib"

 #ifdef __APPLE__

 #define JNI_LIB_SUFFIX ".dylib"

 #else

 #define JNI_LIB_SUFFIX ".so"

 #endif

 const char* os::dll_file_extension() { return JNI_LIB_SUFFIX; }

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

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

 #ifdef __APPLE__

 // macosx has a secure per-user temporary directory

 char temp_path_storage[PATH_MAX];

 const char* os::get_temp_directory() {

   static char *temp_path = NULL;

   if (temp_path == NULL) {

     int pathSize = confstr(_CS_DARWIN_USER_TEMP_DIR, temp_path_storage, PATH_MAX);

     if (pathSize == 0 || pathSize > PATH_MAX) {

       strlcpy(temp_path_storage, "/tmp/", sizeof(temp_path_storage));

     }

     temp_path = temp_path_storage;

   }

   return temp_path;

 }

 #else /* __APPLE__ */

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

 #endif /* __APPLE__ */

 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;

   // Copied from libhpi

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

   // Return error on buffer overflow.

   if (pnamelen + strlen(fname) + strlen(JNI_LIB_PREFIX) + strlen(JNI_LIB_SUFFIX) + 2 > buflen) {

     return retval;

   }

   if (pnamelen == 0) {

     snprintf(buffer, buflen, JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX, 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 check can't hurt

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

         continue; // skip the empty path values

       }

       snprintf(buffer, buflen, "%s/" JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX,

           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/" JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX, 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) {

     if (dladdr(CAST_FROM_FN_PTR(void *, os::address_is_in_vm), &dlinfo) != 0) {

       libjvm_base_addr = (address)dlinfo.dli_fbase;

     }

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

   }

   if (dladdr((void *)addr, &dlinfo) != 0) {

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

   }

   return false;

 }

 #define MACH_MAXSYMLEN 256

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

                                       int buflen, int *offset) {

   // buf is not optional, but offset is optional

   assert(buf != NULL, "sanity check");

   Dl_info dlinfo;

   char localbuf[MACH_MAXSYMLEN];

   if (dladdr((void*)addr, &dlinfo) != 0) {

     // see if we have a matching symbol

     if (dlinfo.dli_saddr != NULL && dlinfo.dli_sname != 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;

     }

     // no matching symbol so try for just file info

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

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

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

          return true;

       }

     }

     // Handle non-dynamic manually:

     if (dlinfo.dli_fbase != NULL &&

         Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset,

                         dlinfo.dli_fbase)) {

       if (!Decoder::demangle(localbuf, buf, buflen)) {

         jio_snprintf(buf, buflen, "%s", localbuf);

       }

       return true;

     }

   }

   buf[0] = '\0';

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

   return false;

 }

 // ported from solaris version

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

                                      int buflen, int* offset) {

   // buf is not optional, but offset is optional

   assert(buf != NULL, "sanity check");

   Dl_info dlinfo;

   if (dladdr((void*)addr, &dlinfo) != 0) {

     if (dlinfo.dli_fname != NULL) {

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

     }

     if (dlinfo.dli_fbase != NULL && offset != NULL) {

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

     }

     return true;

   }

   buf[0] = '\0';

   if (offset) *offset = -1;

   return false;

 }

 // Loads .dll/.so and

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

 // same architecture as Hotspot is running on

 #ifdef __APPLE__

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

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

   if (result != NULL) {

     // Successful loading

     return result;

   }

   // Read system error message into ebuf

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

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

   return NULL;

 }

 #else

 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;

   #ifndef EM_486

   #define EM_486          6               /* Intel 80486 */

   #endif

   #ifndef EM_MIPS_RS3_LE

   #define EM_MIPS_RS3_LE  10              /* MIPS */

   #endif

   #ifndef EM_PPC64

   #define EM_PPC64        21              /* PowerPC64 */

   #endif

   #ifndef EM_S390

   #define EM_S390         22              /* IBM System/390 */

   #endif

   #ifndef EM_IA_64

   #define EM_IA_64        50              /* HP/Intel IA-64 */

   #endif

   #ifndef EM_X86_64

   #define EM_X86_64       62              /* AMD x86-64 */

   #endif

   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"},

     {EM_S390,        EM_S390,    ELFCLASSNONE, ELFDATA2MSB, (char*)"IBM System/390"},

     {EM_ALPHA,       EM_ALPHA,   ELFCLASS64, ELFDATA2LSB, (char*)"Alpha"},

     {EM_MIPS_RS3_LE, EM_MIPS_RS3_LE, ELFCLASS32, ELFDATA2LSB, (char*)"MIPSel"},

     {EM_MIPS,        EM_MIPS,    ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"},

     {EM_PARISC,      EM_PARISC,  ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"},

     {EM_68K,         EM_68K,     ELFCLASS32, ELFDATA2MSB, (char*)"M68k"}

   };

   #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;

   #elif  (defined S390)

     static  Elf32_Half running_arch_code=EM_S390;

   #elif  (defined ALPHA)

     static  Elf32_Half running_arch_code=EM_ALPHA;

   #elif  (defined MIPSEL)

     static  Elf32_Half running_arch_code=EM_MIPS_RS3_LE;

   #elif  (defined PARISC)

     static  Elf32_Half running_arch_code=EM_PARISC;

   #elif  (defined MIPS)

     static  Elf32_Half running_arch_code=EM_MIPS;

   #elif  (defined M68K)

     static  Elf32_Half running_arch_code=EM_68K;

   #else

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

          IA32, AMD64, IA64, __sparc, __powerpc__, ARM, S390, ALPHA, MIPS, MIPSEL, PARISC, M68K

   #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;

   }

 #ifndef S390

   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;

   }

 #endif // !S390

   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;

 }

 #endif /* !__APPLE__ */

 void* os::get_default_process_handle() {

 #ifdef __APPLE__

   // MacOS X needs to use RTLD_FIRST instead of RTLD_LAZY

   // to avoid finding unexpected symbols on second (or later)

   // loads of a library.

   return (void*)::dlopen(NULL, RTLD_FIRST);

 #else

   return (void*)::dlopen(NULL, RTLD_LAZY);

 #endif

 }

 // XXX: Do we need a lock around this as per Linux?

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

   return dlsym(handle, name);

 }

 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_dll_info(outputStream *st) {

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

 #ifdef RTLD_DI_LINKMAP

   Dl_info dli;

   void *handle;

   Link_map *map;

   Link_map *p;

   if (dladdr(CAST_FROM_FN_PTR(void *, os::print_dll_info), &dli) == 0 ||

       dli.dli_fname == NULL) {

     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);

 #elif defined(__APPLE__)

   uint32_t count;

   uint32_t i;

   count = _dyld_image_count();

   for (i = 1; i < count; i++) {

     const char *name = _dyld_get_image_name(i);

     intptr_t slide = _dyld_get_image_vmaddr_slide(i);

     st->print_cr(PTR_FORMAT " \t%s", slide, name);

   }

 #else

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

 #endif

 }

 void os::print_os_info_brief(outputStream* st) {

   st->print("Bsd");

   os::Posix::print_uname_info(st);

 }

 void os::print_os_info(outputStream* st) {

   st->print("OS:");

   st->print("Bsd");

   os::Posix::print_uname_info(st);

   os::Posix::print_rlimit_info(st);

   os::Posix::print_load_average(st);

 }

 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();

   // meminfo

   st->print("\n/proc/meminfo:\n");

   _print_ascii_file("/proc/meminfo", st);

   st->cr();

 }

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

   const siginfo_t* si = (const siginfo_t*)siginfo;

   os::Posix::print_siginfo_brief(st, si);

   if (si && (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();

 }

 static void print_signal_handler(outputStream* st, int sig,

                                  char* buf, size_t buflen);

 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, SR_signum, 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, BREAK_SIGNAL, buf, buflen);

 }

 static char saved_jvm_path[MAXPATHLEN] = {0};

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

 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;

   }

   char dli_fname[MAXPATHLEN];

   bool ret = dll_address_to_library_name(

                 CAST_FROM_FN_PTR(address, os::jvm_path),

                 dli_fname, sizeof(dli_fname), NULL);

   assert(ret, "cannot locate libjvm");

   char *rp = NULL;

   if (ret && dli_fname[0] != '\0') {

     rp = realpath(dli_fname, buf);

   }

   if (rp == NULL)

     return;

   if (Arguments::created_by_gamma_launcher()) {

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

     // "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm".  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

     // construct a path to the JVM being overridden.

     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* jrelib_p;

         int len;

         // Check the current module name "libjvm"

         p = strrchr(buf, '/');

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

         rp = realpath(java_home_var, buf);

         if (rp == NULL)

           return;

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

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

         len = strlen(buf);

         jrelib_p = buf + len;

         // Add the appropriate library subdir

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

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

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

         }

         // Add the appropriate client or server subdir

         len = strlen(buf);

         jrelib_p = buf + len;

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

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

           snprintf(jrelib_p, buflen-len, "");

         }

         // If the path exists within JAVA_HOME, add the JVM library name

         // to complete the path to JVM being overridden.  Otherwise fallback

         // to the path to the current library.

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

           // Use current module name "libjvm"

           len = strlen(buf);

           snprintf(buf + len, buflen-len, "/libjvm%s", JNI_LIB_SUFFIX);

         } else {

           // Fall back to path of current library

           rp = realpath(dli_fname, buf);

           if (rp == NULL)

             return;

         }

       }

     }

   }

   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

 }

 ////////////////////////////////////////////////////////////////////////////////

 // sun.misc.Signal support

 static volatile jint sigint_count = 0;

 static void

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

   // 4511530 - sem_post is serialized and handled by the manager thread. When

   // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We

   // don't want to flood the manager thread with sem_post requests.

   if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)

       return;

   // 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);

 }

 void* os::user_handler() {

   return CAST_FROM_FN_PTR(void*, UserHandler);

 }

 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_SIGINFO;

   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.

  */

 // Will be modified when max signal is changed to be dynamic

 int os::sigexitnum_pd() {

   return NSIG;

 }

 // a counter for each possible signal value

 static volatile jint pending_signals[NSIG+1] = { 0 };

 // Bsd(POSIX) specific hand shaking semaphore.

 #ifdef __APPLE__

 typedef semaphore_t os_semaphore_t;

 #define SEM_INIT(sem, value)    semaphore_create(mach_task_self(), &sem, SYNC_POLICY_FIFO, value)

 #define SEM_WAIT(sem)           semaphore_wait(sem)

 #define SEM_POST(sem)           semaphore_signal(sem)

 #define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)

 #else

 typedef sem_t os_semaphore_t;

 #define SEM_INIT(sem, value)    sem_init(&sem, 0, value)

 #define SEM_WAIT(sem)           sem_wait(&sem)

 #define SEM_POST(sem)           sem_post(&sem)

 #define SEM_DESTROY(sem)        sem_destroy(&sem)

 #endif

 class Semaphore : public StackObj {

   public:

     Semaphore();

     ~Semaphore();

     void signal();

     void wait();

     bool trywait();

     bool timedwait(unsigned int sec, int nsec);

   private:

     jlong currenttime() const;

     os_semaphore_t _semaphore;

 };

 Semaphore::Semaphore() : _semaphore(0) {

   SEM_INIT(_semaphore, 0);

 }

 Semaphore::~Semaphore() {

   SEM_DESTROY(_semaphore);

 }

 void Semaphore::signal() {

   SEM_POST(_semaphore);

 }

 void Semaphore::wait() {

   SEM_WAIT(_semaphore);

 }

 jlong Semaphore::currenttime() const {

     struct timeval tv;

     gettimeofday(&tv, NULL);

     return (tv.tv_sec * NANOSECS_PER_SEC) + (tv.tv_usec * 1000);

 }

 #ifdef __APPLE__

 bool Semaphore::trywait() {

   return timedwait(0, 0);

 }

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

   kern_return_t kr = KERN_ABORTED;

   mach_timespec_t waitspec;

   waitspec.tv_sec = sec;

   waitspec.tv_nsec = nsec;

   jlong starttime = currenttime();

   kr = semaphore_timedwait(_semaphore, waitspec);

   while (kr == KERN_ABORTED) {

     jlong totalwait = (sec * NANOSECS_PER_SEC) + nsec;

     jlong current = currenttime();

     jlong passedtime = current - starttime;

     if (passedtime >= totalwait) {

       waitspec.tv_sec = 0;

       waitspec.tv_nsec = 0;

     } else {

       jlong waittime = totalwait - (current - starttime);

       waitspec.tv_sec = waittime / NANOSECS_PER_SEC;

       waitspec.tv_nsec = waittime % NANOSECS_PER_SEC;

     }

     kr = semaphore_timedwait(_semaphore, waitspec);

   }

   return kr == KERN_SUCCESS;

 }

 #else

 bool Semaphore::trywait() {

   return sem_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 = sem_timedwait(&_semaphore, &ts);

     if (result == 0) {

       return true;

     } else if (errno == EINTR) {

       continue;

     } else if (errno == ETIMEDOUT) {

       return false;

     } else {

       return false;

     }

   }

 }

 #endif // __APPLE__

 static os_semaphore_t sig_sem;

 static Semaphore sr_semaphore;

 void os::signal_init_pd() {

   // Initialize signal structures

   ::memset((void*)pending_signals, 0, sizeof(pending_signals));

   // Initialize signal semaphore

   ::SEM_INIT(sig_sem, 0);

 }

 void os::signal_notify(int sig) {

   Atomic::inc(&pending_signals[sig]);

   ::SEM_POST(sig_sem);

 }

 static int check_pending_signals(bool wait) {

   Atomic::store(0, &sigint_count);

   for (;;) {

     for (int i = 0; i < NSIG + 1; i++) {

       jint n = pending_signals[i];

       if (n > 0 && n == Atomic::cmpxchg(n - 1, &pending_signals[i], n)) {

         return i;

       }

     }

     if (!wait) {

       return -1;

     }

     JavaThread *thread = JavaThread::current();

     ThreadBlockInVM tbivm(thread);

     bool threadIsSuspended;

     do {

       thread->set_suspend_equivalent();

       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

       ::SEM_WAIT(sig_sem);

       // were we externally suspended while we were waiting?

       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();

       if (threadIsSuspended) {

         //

         // The semaphore has been incremented, but while we were waiting

         // another thread suspended us. We don't want to continue running

         // while suspended because that would surprise the thread that

         // suspended us.

         //

         ::SEM_POST(sig_sem);

         thread->java_suspend_self();

       }

     } while (threadIsSuspended);

   }

 }

 int os::signal_lookup() {

   return check_pending_signals(false);

 }

 int os::signal_wait() {

   return check_pending_signals(true);

 }

 ////////////////////////////////////////////////////////////////////////////////

 // Virtual Memory

 int os::vm_page_size() {

   // Seems redundant as all get out

   assert(os::Bsd::page_size() != -1, "must call os::init");

   return os::Bsd::page_size();

 }

 // Solaris allocates memory by pages.

 int os::vm_allocation_granularity() {

   assert(os::Bsd::page_size() != -1, "must call os::init");

   return os::Bsd::page_size();

 }

 // Rationale behind this function:

 //  current (Mon Apr 25 20:12:18 MSD 2005) oprofile drops samples without executable

 //  mapping for address (see lookup_dcookie() in the kernel module), thus we cannot get

 //  samples for JITted code. Here we create private executable mapping over the code cache

 //  and then we can use standard (well, almost, as mapping can change) way to provide

 //  info for the reporting script by storing timestamp and location of symbol

 void bsd_wrap_code(char* base, size_t size) {

   static volatile jint cnt = 0;

   if (!UseOprofile) {

     return;

   }

   char buf[PATH_MAX + 1];

   int num = Atomic::add(1, &cnt);

   snprintf(buf, PATH_MAX + 1, "%s/hs-vm-%d-%d",

            os::get_temp_directory(), os::current_process_id(), num);

   unlink(buf);

   int fd = ::open(buf, O_CREAT | O_RDWR, S_IRWXU);

   if (fd != -1) {

     off_t rv = ::lseek(fd, size-2, SEEK_SET);

     if (rv != (off_t)-1) {

       if (::write(fd, "", 1) == 1) {

         mmap(base, size,

              PROT_READ|PROT_WRITE|PROT_EXEC,

              MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, fd, 0);

       }

     }

     ::close(fd);

     unlink(buf);

   }

 }

 static void warn_fail_commit_memory(char* addr, size_t size, bool exec,

                                     int err) {

   warning("INFO: os::commit_memory(" PTR_FORMAT ", " SIZE_FORMAT

           ", %d) failed; error='%s' (errno=%d)", addr, size, exec,

           strerror(err), err);

 }

 // NOTE: Bsd kernel does not really reserve the pages for us.

 //       All it does is to check if there are enough free pages

 //       left at the time of mmap(). This could be a potential

 //       problem.

 bool os::pd_commit_memory(char* addr, size_t size, bool exec) {

   int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;

 #ifdef __OpenBSD__

   // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD

   if (::mprotect(addr, size, prot) == 0) {

     return true;

   }

 #else

   uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,

                                    MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);

   if (res != (uintptr_t) MAP_FAILED) {

     return true;

   }

 #endif

   // Warn about any commit errors we see in non-product builds just

   // in case mmap() doesn't work as described on the man page.

   NOT_PRODUCT(warn_fail_commit_memory(addr, size, exec, errno);)

   return false;

 }

 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,

                        bool exec) {

   // alignment_hint is ignored on this OS

   return pd_commit_memory(addr, size, exec);

 }

 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,

                                   const char* mesg) {

   assert(mesg != NULL, "mesg must be specified");

   if (!pd_commit_memory(addr, size, exec)) {

     // add extra info in product mode for vm_exit_out_of_memory():

     PRODUCT_ONLY(warn_fail_commit_memory(addr, size, exec, errno);)

     vm_exit_out_of_memory(size, OOM_MMAP_ERROR, mesg);

   }

 }

 void os::pd_commit_memory_or_exit(char* addr, size_t size,

                                   size_t alignment_hint, bool exec,

                                   const char* mesg) {

   // alignment_hint is ignored on this OS

   pd_commit_memory_or_exit(addr, size, exec, mesg);

 }

 void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {

 }

 void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {

   ::madvise(addr, bytes, MADV_DONTNEED);

 }

 void os::numa_make_global(char *addr, size_t bytes) {

 }

 void os::numa_make_local(char *addr, size_t bytes, int lgrp_hint) {

 }

 bool os::numa_topology_changed()   { return false; }

 size_t os::numa_get_groups_num() {

   return 1;

 }

 int os::numa_get_group_id() {

   return 0;

 }

 size_t os::numa_get_leaf_groups(int *ids, size_t size) {

   if (size > 0) {

     ids[0] = 0;

     return 1;

   }

   return 0;

 }

 bool os::get_page_info(char *start, page_info* info) {

   return false;

 }

 char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {

   return end;

 }

 bool os::pd_uncommit_memory(char* addr, size_t size) {

 #ifdef __OpenBSD__

   // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD

   return ::mprotect(addr, size, PROT_NONE) == 0;

 #else

   uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE,

                 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0);

   return res  != (uintptr_t) MAP_FAILED;

 #endif

 }

 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {

   return os::commit_memory(addr, size, !ExecMem);

 }

 // If this is a growable mapping, remove the guard pages entirely by

 // munmap()ping them.  If not, just call uncommit_memory().

 bool os::remove_stack_guard_pages(char* addr, size_t size) {

   return os::uncommit_memory(addr, size);

 }

 static address _highest_vm_reserved_address = NULL;

 // If 'fixed' is true, anon_mmap() will attempt to reserve anonymous memory

 // at 'requested_addr'. If there are existing memory mappings at the same

 // location, however, they will be overwritten. If 'fixed' is false,

 // 'requested_addr' is only treated as a hint, the return value may or

 // may not start from the requested address. Unlike Bsd mmap(), this

 // function returns NULL to indicate failure.

 static char* anon_mmap(char* requested_addr, size_t bytes, bool fixed) {

   char * addr;

   int flags;

   flags = MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS;

   if (fixed) {

     assert((uintptr_t)requested_addr % os::Bsd::page_size() == 0, "unaligned address");

     flags |= MAP_FIXED;

   }

   // Map reserved/uncommitted pages PROT_NONE so we fail early if we

   // touch an uncommitted page. Otherwise, the read/write might

   // succeed if we have enough swap space to back the physical page.

   addr = (char*)::mmap(requested_addr, bytes, PROT_NONE,

                        flags, -1, 0);

   if (addr != MAP_FAILED) {

     // anon_mmap() should only get called during VM initialization,

     // don't need lock (actually we can skip locking even it can be called

     // from multiple threads, because _highest_vm_reserved_address is just a

     // hint about the upper limit of non-stack memory regions.)

     if ((address)addr + bytes > _highest_vm_reserved_address) {

       _highest_vm_reserved_address = (address)addr + bytes;

     }

   }

   return addr == MAP_FAILED ? NULL : addr;

 }

 // Don't update _highest_vm_reserved_address, because there might be memory

 // regions above addr + size. If so, releasing a memory region only creates

 // a hole in the address space, it doesn't help prevent heap-stack collision.

 //

 static int anon_munmap(char * addr, size_t size) {

   return ::munmap(addr, size) == 0;

 }

 char* os::pd_reserve_memory(size_t bytes, char* requested_addr,

                          size_t alignment_hint) {

   return anon_mmap(requested_addr, bytes, (requested_addr != NULL));

 }

 bool os::pd_release_memory(char* addr, size_t size) {

   return anon_munmap(addr, size);

 }

 static bool bsd_mprotect(char* addr, size_t size, int prot) {

   // Bsd wants the mprotect address argument to be page aligned.

   char* bottom = (char*)align_size_down((intptr_t)addr, os::Bsd::page_size());

   // According to SUSv3, mprotect() should only be used with mappings

   // established by mmap(), and mmap() always maps whole pages. Unaligned

   // 'addr' likely indicates problem in the VM (e.g. trying to change

   // protection of malloc'ed or statically allocated memory). Check the

   // caller if you hit this assert.

   assert(addr == bottom, "sanity check");

   size = align_size_up(pointer_delta(addr, bottom, 1) + size, os::Bsd::page_size());

   return ::mprotect(bottom, size, prot) == 0;

 }

 // Set protections specified

 bool os::protect_memory(char* addr, size_t bytes, ProtType prot,

                         bool is_committed) {

   unsigned int p = 0;

   switch (prot) {

   case MEM_PROT_NONE: p = PROT_NONE; break;

   case MEM_PROT_READ: p = PROT_READ; break;

   case MEM_PROT_RW:   p = PROT_READ|PROT_WRITE; break;

   case MEM_PROT_RWX:  p = PROT_READ|PROT_WRITE|PROT_EXEC; break;

   default:

     ShouldNotReachHere();

   }

   // is_committed is unused.

   return bsd_mprotect(addr, bytes, p);

 }

 bool os::guard_memory(char* addr, size_t size) {

   return bsd_mprotect(addr, size, PROT_NONE);

 }

 bool os::unguard_memory(char* addr, size_t size) {

   return bsd_mprotect(addr, size, PROT_READ|PROT_WRITE);

 }

 bool os::Bsd::hugetlbfs_sanity_check(bool warn, size_t page_size) {

   return false;

 }

 // Large page support

 static size_t _large_page_size = 0;

 void os::large_page_init() {

 }

 char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {

   fatal("This code is not used or maintained.");

   // "exec" is passed in but not used.  Creating the shared image for

   // the code cache doesn't have an SHM_X executable permission to check.

   assert(UseLargePages && UseSHM, "only for SHM large pages");

   key_t key = IPC_PRIVATE;

   char *addr;

   bool warn_on_failure = UseLargePages &&

                         (!FLAG_IS_DEFAULT(UseLargePages) ||

                          !FLAG_IS_DEFAULT(LargePageSizeInBytes)

                         );

   char msg[128];

   // Create a large shared memory region to attach to based on size.

   // Currently, size is the total size of the heap

   int shmid = shmget(key, bytes, IPC_CREAT|SHM_R|SHM_W);

   if (shmid == -1) {

      // Possible reasons for shmget failure:

      // 1. shmmax is too small for Java heap.

      //    > check shmmax value: cat /proc/sys/kernel/shmmax

      //    > increase shmmax value: echo "0xffffffff" > /proc/sys/kernel/shmmax

      // 2. not enough large page memory.

      //    > check available large pages: cat /proc/meminfo

      //    > increase amount of large pages:

      //          echo new_value > /proc/sys/vm/nr_hugepages

      //      Note 1: different Bsd may use different name for this property,

      //            e.g. on Redhat AS-3 it is "hugetlb_pool".

      //      Note 2: it's possible there's enough physical memory available but

      //            they are so fragmented after a long run that they can't

      //            coalesce into large pages. Try to reserve large pages when

      //            the system is still "fresh".

      if (warn_on_failure) {

        jio_snprintf(msg, sizeof(msg), "Failed to reserve shared memory (errno = %d).", errno);

        warning(msg);

      }

      return NULL;

   }

   // attach to the region

   addr = (char*)shmat(shmid, req_addr, 0);

   int err = errno;

   // Remove shmid. If shmat() is successful, the actual shared memory segment

   // will be deleted when it's detached by shmdt() or when the process

   // terminates. If shmat() is not successful this will remove the shared

   // segment immediately.

   shmctl(shmid, IPC_RMID, NULL);

   if ((intptr_t)addr == -1) {

      if (warn_on_failure) {

        jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);

        warning(msg);

      }

      return NULL;

   }

   // The memory is committed

   MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, mtNone, CALLER_PC);

   return addr;

 }

 bool os::release_memory_special(char* base, size_t bytes) {

   MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();

   // detaching the SHM segment will also delete it, see reserve_memory_special()

   int rslt = shmdt(base);

   if (rslt == 0) {

     tkr.record((address)base, bytes);

     return true;

   } else {

     tkr.discard();

     return false;

   }

 }

 size_t os::large_page_size() {

   return _large_page_size;

 }

 // HugeTLBFS allows application to commit large page memory on demand;

 // with SysV SHM the entire memory region must be allocated as shared

 // memory.

 bool os::can_commit_large_page_memory() {

   return UseHugeTLBFS;

 }

 bool os::can_execute_large_page_memory() {

   return UseHugeTLBFS;

 }

 // Reserve memory at an arbitrary address, only if that area is

 // available (and not reserved for something else).

 char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {

   const int max_tries = 10;

   char* base[max_tries];

   size_t size[max_tries];

   const size_t gap = 0x000000;

   // Assert only that the size is a multiple of the page size, since

   // that's all that mmap requires, and since that's all we really know

   // about at this low abstraction level.  If we need higher alignment,

   // we can either pass an alignment to this method or verify alignment

   // in one of the methods further up the call chain.  See bug 5044738.

   assert(bytes % os::vm_page_size() == 0, "reserving unexpected size block");

   // Repeatedly allocate blocks until the block is allocated at the

   // right spot. Give up after max_tries. Note that reserve_memory() will

   // automatically update _highest_vm_reserved_address if the call is

   // successful. The variable tracks the highest memory address every reserved

   // by JVM. It is used to detect heap-stack collision if running with

   // fixed-stack BsdThreads. Because here we may attempt to reserve more

   // space than needed, it could confuse the collision detecting code. To

   // solve the problem, save current _highest_vm_reserved_address and

   // calculate the correct value before return.

   address old_highest = _highest_vm_reserved_address;

   // Bsd mmap allows caller to pass an address as hint; give it a try first,

   // if kernel honors the hint then we can return immediately.

   char * addr = anon_mmap(requested_addr, bytes, false);

   if (addr == requested_addr) {

      return requested_addr;

   }

   if (addr != NULL) {

      // mmap() is successful but it fails to reserve at the requested address

      anon_munmap(addr, bytes);

   }

   int i;

   for (i = 0; i < max_tries; ++i) {

     base[i] = reserve_memory(bytes);

     if (base[i] != NULL) {

       // Is this the block we wanted?

       if (base[i] == requested_addr) {

         size[i] = bytes;

         break;

       }

       // Does this overlap the block we wanted? Give back the overlapped

       // parts and try again.

       size_t top_overlap = requested_addr + (bytes + gap) - base[i];

       if (top_overlap >= 0 && top_overlap < bytes) {

         unmap_memory(base[i], top_overlap);

         base[i] += top_overlap;

         size[i] = bytes - top_overlap;

       } else {

         size_t bottom_overlap = base[i] + bytes - requested_addr;

         if (bottom_overlap >= 0 && bottom_overlap < bytes) {

           unmap_memory(requested_addr, bottom_overlap);

           size[i] = bytes - bottom_overlap;

         } else {

           size[i] = bytes;

         }

       }

     }

   }

   // Give back the unused reserved pieces.

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

     if (base[j] != NULL) {

       unmap_memory(base[j], size[j]);

     }

   }

   if (i < max_tries) {

     _highest_vm_reserved_address = MAX2(old_highest, (address)requested_addr + bytes);

     return requested_addr;

   } else {

     _highest_vm_reserved_address = old_highest;

     return NULL;

   }

 }

 size_t os::read(int fd, void *buf, unsigned int nBytes) {

   RESTARTABLE_RETURN_INT(::read(fd, buf, nBytes));

 }

 // TODO-FIXME: reconcile Solaris' os::sleep with the bsd variation.

 // Solaris uses poll(), bsd uses park().

 // Poll() is likely a better choice, assuming that Thread.interrupt()

 // generates a SIGUSRx signal. Note that SIGUSR1 can interfere with

 // SIGSEGV, see 4355769.

 int os::sleep(Thread* thread, jlong millis, bool interruptible) {

   assert(thread == Thread::current(),  "thread consistency check");

   ParkEvent * const slp = thread->_SleepEvent ;

   slp->reset() ;

   OrderAccess::fence() ;

   if (interruptible) {

     jlong prevtime = javaTimeNanos();

     for (;;) {

       if (os::is_interrupted(thread, true)) {

         return OS_INTRPT;

       }

       jlong newtime = javaTimeNanos();

       if (newtime - prevtime < 0) {

         // time moving backwards, should only happen if no monotonic clock

         // not a guarantee() because JVM should not abort on kernel/glibc bugs

         assert(!Bsd::supports_monotonic_clock(), "time moving backwards");

       } else {

         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;

       }

       if(millis <= 0) {

         return OS_OK;

       }

       prevtime = newtime;

       {

         assert(thread->is_Java_thread(), "sanity check");

         JavaThread *jt = (JavaThread *) thread;

         ThreadBlockInVM tbivm(jt);

         OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);

         jt->set_suspend_equivalent();

         // cleared by handle_special_suspend_equivalent_condition() or

         // java_suspend_self() via check_and_wait_while_suspended()

         slp->park(millis);

         // were we externally suspended while we were waiting?

         jt->check_and_wait_while_suspended();

       }

     }

   } else {

     OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);

     jlong prevtime = javaTimeNanos();

     for (;;) {

       // It'd be nice to avoid the back-to-back javaTimeNanos() calls on

       // the 1st iteration ...

       jlong newtime = javaTimeNanos();

       if (newtime - prevtime < 0) {

         // time moving backwards, should only happen if no monotonic clock

         // not a guarantee() because JVM should not abort on kernel/glibc bugs

         assert(!Bsd::supports_monotonic_clock(), "time moving backwards");

       } else {

         millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;

       }

       if(millis <= 0) break ;

       prevtime = newtime;

       slp->park(millis);

     }

     return OS_OK ;

   }

 }

 void os::naked_short_sleep(jlong ms) {

   struct timespec req;

   assert(ms < 1000, "Un-interruptable sleep, short time use only");

   req.tv_sec = 0;

   if (ms > 0) {

     req.tv_nsec = (ms % 1000) * 1000000;

   }

   else {

     req.tv_nsec = 1;

   }

   nanosleep(&req, NULL);

   return;

 }

 // Sleep forever; naked call to OS-specific sleep; use with CAUTION

 void os::infinite_sleep() {

   while (true) {    // sleep forever ...

     ::sleep(100);   // ... 100 seconds at a time

   }

 }

 // Used to convert frequent JVM_Yield() to nops

 bool os::dont_yield() {

   return DontYieldALot;

 }

 void os::yield() {

   sched_yield();

 }

 os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;}

 void os::yield_all(int attempts) {

   // Yields to all threads, including threads with lower priorities