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

 /*

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

 #include "memory/allocation.inline.hpp"

 #include "memory/filemap.hpp"

 #include "mutex_linux.inline.hpp"

 #include "oops/oop.inline.hpp"

 #include "os_share_linux.hpp"

 #include "osContainer_linux.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/init.hpp"

 #include "runtime/java.hpp"

 #include "runtime/javaCalls.hpp"

 #include "runtime/mutexLocker.hpp"

 #include "runtime/objectMonitor.hpp"

 #include "runtime/orderAccess.inline.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/elfFile.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 <pwd.h>

 # include <poll.h>

 # include <semaphore.h>

 # include <fcntl.h>

 # include <string.h>

 # include <syscall.h>

 # include <sys/sysinfo.h>

 # include <gnu/libc-version.h>

 # include <sys/ipc.h>

 # include <sys/shm.h>

 # include <link.h>

 # include <stdint.h>

 # include <inttypes.h>

 # include <sys/ioctl.h>

 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC

 #ifndef _GNU_SOURCE

   #define _GNU_SOURCE

   #include <sched.h>

   #undef _GNU_SOURCE

 #else

   #include <sched.h>

 #endif

 // if RUSAGE_THREAD for getrusage() has not been defined, do it here. The code calling

 // getrusage() is prepared to handle the associated failure.

 #ifndef RUSAGE_THREAD

 #define RUSAGE_THREAD   (1)               /* only the calling thread */

 #endif

 #define MAX_PATH    (2 * K)

 #define MAX_SECS 100000000

 // for timer info max values which include all bits

 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

 #define LARGEPAGES_BIT (1 << 6)

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

 // global variables

 julong os::Linux::_physical_memory = 0;

 address   os::Linux::_initial_thread_stack_bottom = NULL;

 uintptr_t os::Linux::_initial_thread_stack_size   = 0;

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

 int (*os::Linux::_pthread_getcpuclockid)(pthread_t, clockid_t *) = NULL;

 Mutex* os::Linux::_createThread_lock = NULL;

 pthread_t os::Linux::_main_thread;

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

 const int os::Linux::_vm_default_page_size = (8 * K);

 bool os::Linux::_is_floating_stack = false;

 bool os::Linux::_is_NPTL = false;

 bool os::Linux::_supports_fast_thread_cpu_time = false;

 const char * os::Linux::_glibc_version = NULL;

 const char * os::Linux::_libpthread_version = NULL;

 pthread_condattr_t os::Linux::_condattr[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;

 /* Used to protect dlsym() calls */

 static pthread_mutex_t dl_mutex;

 // Declarations

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

 // utility functions

 static int SR_initialize();

 julong os::available_memory() {

   return Linux::available_memory();

 }

 julong os::Linux::available_memory() {

   // values in struct sysinfo are "unsigned long"

   struct sysinfo si;

   julong avail_mem;

   if (OSContainer::is_containerized()) {

     jlong mem_limit, mem_usage;

     if ((mem_limit = OSContainer::memory_limit_in_bytes()) < 1) {

       if (PrintContainerInfo) {

         tty->print_cr("container memory limit %s: " JLONG_FORMAT ", using host value",

                        mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit);

       }

     }

     if (mem_limit > 0 && (mem_usage = OSContainer::memory_usage_in_bytes()) < 1) {

       if (PrintContainerInfo) {

         tty->print_cr("container memory usage failed: " JLONG_FORMAT ", using host value", mem_usage);

       }

     }

     if (mem_limit > 0 && mem_usage > 0 ) {

       avail_mem = mem_limit > mem_usage ? (julong)mem_limit - (julong)mem_usage : 0;

       if (PrintContainerInfo) {

         tty->print_cr("available container memory: " JULONG_FORMAT, avail_mem);

       }

       return avail_mem;

     }

   }

   sysinfo(&si);

   avail_mem = (julong)si.freeram * si.mem_unit;

   if (Verbose) {

     tty->print_cr("available memory: " JULONG_FORMAT, avail_mem);

   }

   return avail_mem;

 }

 julong os::physical_memory() {

   jlong phys_mem = 0;

   if (OSContainer::is_containerized()) {

     jlong mem_limit;

     if ((mem_limit = OSContainer::memory_limit_in_bytes()) > 0) {

       if (PrintContainerInfo) {

         tty->print_cr("total container memory: " JLONG_FORMAT, mem_limit);

       }

       return mem_limit;

     }

     if (PrintContainerInfo) {

       tty->print_cr("container memory limit %s: " JLONG_FORMAT ", using host value",

                      mem_limit == OSCONTAINER_ERROR ? "failed" : "unlimited", mem_limit);

     }

   }

   phys_mem = Linux::physical_memory();

   if (Verbose) {

     tty->print_cr("total system memory: " JLONG_FORMAT, phys_mem);

   }

   return phys_mem;

 }

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

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

 }

 #ifndef SYS_gettid

 // i386: 224, ia64: 1105, amd64: 186, sparc 143

   #ifdef __ia64__

     #define SYS_gettid 1105

   #else

     #ifdef __i386__

       #define SYS_gettid 224

     #else

       #ifdef __amd64__

         #define SYS_gettid 186

       #else

         #ifdef __sparc__

           #define SYS_gettid 143

         #else

           #error define gettid for the arch

         #endif

       #endif

     #endif

   #endif

 #endif

 // Cpu architecture string

 static char cpu_arch[] = HOTSPOT_LIB_ARCH;

 // pid_t gettid()

 //

 // Returns the kernel thread id of the currently running thread. Kernel

 // thread id is used to access /proc.

 //

 // (Note that getpid() on LinuxThreads returns kernel thread id too; but

 // on NPTL, it returns the same pid for all threads, as required by POSIX.)

 //

 pid_t os::Linux::gettid() {

   int rslt = syscall(SYS_gettid);

   if (rslt == -1) {

      // old kernel, no NPTL support

      return getpid();

   } else {

      return (pid_t)rslt;

   }

 }

 // Most versions of linux have a bug where the number of processors are

 // determined by looking at the /proc file system.  In a chroot environment,

 // the system call returns 1.  This causes the VM to act as if it is

 // a single processor and elide locking (see is_MP() call).

 static bool unsafe_chroot_detected = false;

 static const char *unstable_chroot_error = "/proc file system not found.\n"

                      "Java may be unstable running multithreaded in a chroot "

                      "environment on Linux when /proc filesystem is not mounted.";

 void os::Linux::initialize_system_info() {

   set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

   if (processor_count() == 1) {

     pid_t pid = os::Linux::gettid();

     char fname[32];

     jio_snprintf(fname, sizeof(fname), "/proc/%d", pid);

     FILE *fp = fopen(fname, "r");

     if (fp == NULL) {

       unsafe_chroot_detected = true;

     } else {

       fclose(fp);

     }

   }

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

   assert(processor_count() > 0, "linux error");

 }

 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.

 #if defined(AMD64) || defined(_LP64) && (defined(SPARC) || defined(PPC) || defined(S390))

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

 #else

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

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

 #undef DEFAULT_LIBPATH

 #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::Linux::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::Linux::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 defined(PPC64)

   sigaddset(&unblocked_sigs, SIGTRAP);

 #endif

   sigaddset(&unblocked_sigs, SR_signum);

   if (!ReduceSignalUsage) {

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

       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);

    }

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

       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);

       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);

    }

    if (!os::Linux::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::Linux::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::Linux::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::Linux::allowdebug_blocked_signals() {

   assert(signal_sets_initialized, "Not initialized");

   return &allowdebug_blocked_sigs;

 }

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

     }

   }

 }

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

 // detecting pthread library

 void os::Linux::libpthread_init() {

   // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION

   // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a

   // generic name for earlier versions.

   // Define macros here so we can build HotSpot on old systems.

 # ifndef _CS_GNU_LIBC_VERSION

 # define _CS_GNU_LIBC_VERSION 2

 # endif

 # ifndef _CS_GNU_LIBPTHREAD_VERSION

 # define _CS_GNU_LIBPTHREAD_VERSION 3

 # endif

   size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);

   if (n > 0) {

      char *str = (char *)malloc(n, mtInternal);

      confstr(_CS_GNU_LIBC_VERSION, str, n);

      os::Linux::set_glibc_version(str);

   } else {

      // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()

      static char _gnu_libc_version[32];

      jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),

               "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release());

      os::Linux::set_glibc_version(_gnu_libc_version);

   }

   n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);

   if (n > 0) {

      char *str = (char *)malloc(n, mtInternal);

      confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);

      // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells

      // us "NPTL-0.29" even we are running with LinuxThreads. Check if this

      // is the case. LinuxThreads has a hard limit on max number of threads.

      // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.

      // On the other hand, NPTL does not have such a limit, sysconf()

      // will return -1 and errno is not changed. Check if it is really NPTL.

      if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 &&

          strstr(str, "NPTL") &&

          sysconf(_SC_THREAD_THREADS_MAX) > 0) {

        free(str);

        os::Linux::set_libpthread_version("linuxthreads");

      } else {

        os::Linux::set_libpthread_version(str);

      }

   } else {

     // glibc before 2.3.2 only has LinuxThreads.

     os::Linux::set_libpthread_version("linuxthreads");

   }

   if (strstr(libpthread_version(), "NPTL")) {

      os::Linux::set_is_NPTL();

   } else {

      os::Linux::set_is_LinuxThreads();

   }

   // LinuxThreads have two flavors: floating-stack mode, which allows variable

   // stack size; and fixed-stack mode. NPTL is always floating-stack.

   if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) {

      os::Linux::set_is_floating_stack();

   }

 }

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

 // thread stack

 // Force Linux kernel to expand current thread stack. If "bottom" is close

 // to the stack guard, caller should block all signals.

 //

 // MAP_GROWSDOWN:

 //   A special mmap() flag that is used to implement thread stacks. It tells

 //   kernel that the memory region should extend downwards when needed. This

 //   allows early versions of LinuxThreads to only mmap the first few pages

 //   when creating a new thread. Linux kernel will automatically expand thread

 //   stack as needed (on page faults).

 //

 //   However, because the memory region of a MAP_GROWSDOWN stack can grow on

 //   demand, if a page fault happens outside an already mapped MAP_GROWSDOWN

 //   region, it's hard to tell if the fault is due to a legitimate stack

 //   access or because of reading/writing non-exist memory (e.g. buffer

 //   overrun). As a rule, if the fault happens below current stack pointer,

 //   Linux kernel does not expand stack, instead a SIGSEGV is sent to the

 //   application (see Linux kernel fault.c).

 //

 //   This Linux feature can cause SIGSEGV when VM bangs thread stack for

 //   stack overflow detection.

 //

 //   Newer version of LinuxThreads (since glibc-2.2, or, RH-7.x) and NPTL do

 //   not use this flag. However, the stack of initial thread is not created

 //   by pthread, it is still MAP_GROWSDOWN. Also it's possible (though

 //   unlikely) that user code can create a thread with MAP_GROWSDOWN stack

 //   and then attach the thread to JVM.

 //

 // To get around the problem and allow stack banging on Linux, we need to

 // manually expand thread stack after receiving the SIGSEGV.

 //

 // There are two ways to expand thread stack to address "bottom", we used

 // both of them in JVM before 1.5:

 //   1. adjust stack pointer first so that it is below "bottom", and then

 //      touch "bottom"

 //   2. mmap() the page in question

 //

 // Now alternate signal stack is gone, it's harder to use 2. For instance,

 // if current sp is already near the lower end of page 101, and we need to

 // call mmap() to map page 100, it is possible that part of the mmap() frame

 // will be placed in page 100. When page 100 is mapped, it is zero-filled.

 // That will destroy the mmap() frame and cause VM to crash.

 //

 // The following code works by adjusting sp first, then accessing the "bottom"

 // page to force a page fault. Linux kernel will then automatically expand the

 // stack mapping.

 //

 // _expand_stack_to() assumes its frame size is less than page size, which

 // should always be true if the function is not inlined.

 #if __GNUC__ < 3    // gcc 2.x does not support noinline attribute

 #define NOINLINE

 #else

 #define NOINLINE __attribute__ ((noinline))

 #endif

 static void _expand_stack_to(address bottom) NOINLINE;

 static void _expand_stack_to(address bottom) {

   address sp;

   size_t size;

   volatile char *p;

   // Adjust bottom to point to the largest address within the same page, it

   // gives us a one-page buffer if alloca() allocates slightly more memory.

   bottom = (address)align_size_down((uintptr_t)bottom, os::Linux::page_size());

   bottom += os::Linux::page_size() - 1;

   // sp might be slightly above current stack pointer; if that's the case, we

   // will alloca() a little more space than necessary, which is OK. Don't use

   // os::current_stack_pointer(), as its result can be slightly below current

   // stack pointer, causing us to not alloca enough to reach "bottom".

   sp = (address)&sp;

   if (sp > bottom) {

     size = sp - bottom;

     p = (volatile char *)alloca(size);

     assert(p != NULL && p <= (volatile char *)bottom, "alloca problem?");

     p[0] = '\0';

   }

 }

 bool os::Linux::manually_expand_stack(JavaThread * t, address addr) {

   assert(t!=NULL, "just checking");

   assert(t->osthread()->expanding_stack(), "expand should be set");

   assert(t->stack_base() != NULL, "stack_base was not initialized");

   if (addr <  t->stack_base() && addr >= t->stack_yellow_zone_base()) {

     sigset_t mask_all, old_sigset;

     sigfillset(&mask_all);

     pthread_sigmask(SIG_SETMASK, &mask_all, &old_sigset);

     _expand_stack_to(addr);

     pthread_sigmask(SIG_SETMASK, &old_sigset, NULL);

     return true;

   }

   return false;

 }

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

 // create new thread

 static address highest_vm_reserved_address();

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

 static bool _thread_safety_check(Thread* thread) {

   if (os::Linux::is_LinuxThreads() && !os::Linux::is_floating_stack()) {

     // Fixed stack LinuxThreads (SuSE Linux/x86, and some versions of Redhat)

     //   Heap is mmap'ed at lower end of memory space. Thread stacks are

     //   allocated (MAP_FIXED) from high address space. Every thread stack

     //   occupies a fixed size slot (usually 2Mbytes, but user can change

     //   it to other values if they rebuild LinuxThreads).

     //

     // Problem with MAP_FIXED is that mmap() can still succeed even part of

     // the memory region has already been mmap'ed. That means if we have too

     // many threads and/or very large heap, eventually thread stack will

     // collide with heap.

     //

     // Here we try to prevent heap/stack collision by comparing current

     // stack bottom with the highest address that has been mmap'ed by JVM

     // plus a safety margin for memory maps created by native code.

     //

     // This feature can be disabled by setting ThreadSafetyMargin to 0

     //

     if (ThreadSafetyMargin > 0) {

       address stack_bottom = os::current_stack_base() - os::current_stack_size();

       // not safe if our stack extends below the safety margin

       return stack_bottom - ThreadSafetyMargin >= highest_vm_reserved_address();

     } else {

       return true;

     }

   } else {

     // Floating stack LinuxThreads or NPTL:

     //   Unlike fixed stack LinuxThreads, thread stacks are not MAP_FIXED. When

     //   there's not enough space left, pthread_create() will fail. If we come

     //   here, that means enough space has been reserved for stack.

     return true;

   }

 }

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

   }

   // thread_id is kernel thread id (similar to Solaris LWP id)

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

   if (UseNUMA) {

     int lgrp_id = os::numa_get_group_id();

     if (lgrp_id != -1) {

       thread->set_lgrp_id(lgrp_id);

     }

   }

   // initialize signal mask for this thread

   os::Linux::hotspot_sigmask(thread);

   // initialize floating point control register

   os::Linux::init_thread_fpu_state();

   // 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::Linux::supports_variable_stack_size()) {

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

     if (stack_size == 0) {

       stack_size = os::Linux::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::Linux::min_stack_allowed);

     pthread_attr_setstacksize(&attr, stack_size);

   } else {

     // let pthread_create() pick the default value.

   }

   // glibc guard page

   pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));

   ThreadState state;

   {

     // Serialize thread creation if we are running with fixed stack LinuxThreads

     bool lock = os::Linux::is_LinuxThreads() && !os::Linux::is_floating_stack();

     if (lock) {

       os::Linux::createThread_lock()->lock_without_safepoint_check();

     }

     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;

       if (lock) os::Linux::createThread_lock()->unlock();

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

       }

     }

     if (lock) {

       os::Linux::createThread_lock()->unlock();

     }

   }

   // 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::Linux::_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;

   }

   // Store pthread info into the OSThread

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

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

   // initialize floating point control register

   os::Linux::init_thread_fpu_state();

   // Initial thread state is RUNNABLE

   osthread->set_state(RUNNABLE);

   thread->set_osthread(osthread);

   if (UseNUMA) {

     int lgrp_id = os::numa_get_group_id();

     if (lgrp_id != -1) {

       thread->set_lgrp_id(lgrp_id);

     }

   }

   if (os::Linux::is_initial_thread()) {

     // If current thread is initial thread, its stack is mapped on demand,

     // see notes about MAP_GROWSDOWN. Here we try to force kernel to map

     // the entire stack region to avoid SEGV in stack banging.

     // It is also useful to get around the heap-stack-gap problem on SuSE

     // kernel (see 4821821 for details). We first expand stack to the top

     // of yellow zone, then enable stack yellow zone (order is significant,

     // enabling yellow zone first will crash JVM on SuSE Linux), so there

     // is no gap between the last two virtual memory regions.

     JavaThread *jt = (JavaThread *)thread;

     address addr = jt->stack_yellow_zone_base();

     assert(addr != NULL, "initialization problem?");

     assert(jt->stack_available(addr) > 0, "stack guard should not be enabled");

     osthread->set_expanding_stack();

     os::Linux::manually_expand_stack(jt, addr);

     osthread->clear_expanding_stack();

   }

   // initialize signal mask for this thread

   // and save the caller's signal mask

   os::Linux::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 Linux 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();

 }

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

 // initial thread

 // Check if current thread is the initial thread, similar to Solaris thr_main.

 bool os::Linux::is_initial_thread(void) {

   char dummy;

   // If called before init complete, thread stack bottom will be null.

   // Can be called if fatal error occurs before initialization.

   if (initial_thread_stack_bottom() == NULL) return false;

   assert(initial_thread_stack_bottom() != NULL &&

          initial_thread_stack_size()   != 0,

          "os::init did not locate initial thread's stack region");

   if ((address)&dummy >= initial_thread_stack_bottom() &&

       (address)&dummy < initial_thread_stack_bottom() + initial_thread_stack_size())

        return true;

   else return false;

 }

 // Find the virtual memory area that contains addr

 static bool find_vma(address addr, address* vma_low, address* vma_high) {

   FILE *fp = fopen("/proc/self/maps", "r");

   if (fp) {

     address low, high;

     while (!feof(fp)) {

       if (fscanf(fp, "%p-%p", &low, &high) == 2) {

         if (low <= addr && addr < high) {

            if (vma_low)  *vma_low  = low;

            if (vma_high) *vma_high = high;

            fclose (fp);

            return true;

         }

       }

       for (;;) {

         int ch = fgetc(fp);

         if (ch == EOF || ch == (int)'\n') break;

       }

     }

     fclose(fp);

   }

   return false;

 }

 // Locate initial thread stack. This special handling of initial thread stack

 // is needed because pthread_getattr_np() on most (all?) Linux distros returns

 // bogus value for the primordial process thread. While the launcher has created

 // the VM in a new thread since JDK 6, we still have to allow for the use of the

 // JNI invocation API from a primordial thread.

 void os::Linux::capture_initial_stack(size_t max_size) {

   // max_size is either 0 (which means accept OS default for thread stacks) or

   // a user-specified value known to be at least the minimum needed. If we

   // are actually on the primordial thread we can make it appear that we have a

   // smaller max_size stack by inserting the guard pages at that location. But we

   // cannot do anything to emulate a larger stack than what has been provided by

   // the OS or threading library. In fact if we try to use a stack greater than

   // what is set by rlimit then we will crash the hosting process.

   // Maximum stack size is the easy part, get it from RLIMIT_STACK.

   // If this is "unlimited" then it will be a huge value.

   struct rlimit rlim;

   getrlimit(RLIMIT_STACK, &rlim);

   size_t stack_size = rlim.rlim_cur;

   // 6308388: a bug in ld.so will relocate its own .data section to the

   //   lower end of primordial stack; reduce ulimit -s value a little bit

   //   so we won't install guard page on ld.so's data section.

   stack_size -= 2 * page_size();

   // Try to figure out where the stack base (top) is. This is harder.

   //

   // When an application is started, glibc saves the initial stack pointer in

   // a global variable "__libc_stack_end", which is then used by system

   // libraries. __libc_stack_end should be pretty close to stack top. The

   // variable is available since the very early days. However, because it is

   // a private interface, it could disappear in the future.

   //

   // Linux kernel saves start_stack information in /proc/<pid>/stat. Similar

   // to __libc_stack_end, it is very close to stack top, but isn't the real

   // stack top. Note that /proc may not exist if VM is running as a chroot

   // program, so reading /proc/<pid>/stat could fail. Also the contents of

   // /proc/<pid>/stat could change in the future (though unlikely).

   //

   // We try __libc_stack_end first. If that doesn't work, look for

   // /proc/<pid>/stat. If neither of them works, we use current stack pointer

   // as a hint, which should work well in most cases.

   uintptr_t stack_start;

   // try __libc_stack_end first

   uintptr_t *p = (uintptr_t *)dlsym(RTLD_DEFAULT, "__libc_stack_end");

   if (p && *p) {

     stack_start = *p;

   } else {

     // see if we can get the start_stack field from /proc/self/stat

     FILE *fp;

     int pid;

     char state;

     int ppid;

     int pgrp;

     int session;

     int nr;

     int tpgrp;

     unsigned long flags;

     unsigned long minflt;

     unsigned long cminflt;

     unsigned long majflt;

     unsigned long cmajflt;

     unsigned long utime;

     unsigned long stime;

     long cutime;

     long cstime;

     long prio;

     long nice;

     long junk;

     long it_real;

     uintptr_t start;

     uintptr_t vsize;

     intptr_t rss;

     uintptr_t rsslim;

     uintptr_t scodes;

     uintptr_t ecode;

     int i;

     // Figure what the primordial thread stack base is. Code is inspired

     // by email from Hans Boehm. /proc/self/stat begins with current pid,

     // followed by command name surrounded by parentheses, state, etc.

     char stat[2048];

     int statlen;

     fp = fopen("/proc/self/stat", "r");

     if (fp) {

       statlen = fread(stat, 1, 2047, fp);

       stat[statlen] = '\0';

       fclose(fp);

       // Skip pid and the command string. Note that we could be dealing with

       // weird command names, e.g. user could decide to rename java launcher

       // to "java 1.4.2 :)", then the stat file would look like

       //                1234 (java 1.4.2 :)) R ... ...

       // We don't really need to know the command string, just find the last

       // occurrence of ")" and then start parsing from there. See bug 4726580.

       char * s = strrchr(stat, ')');

       i = 0;

       if (s) {

         // Skip blank chars

         do s++; while (isspace(*s));

 #define _UFM UINTX_FORMAT

 #define _DFM INTX_FORMAT

         /*                                     1   1   1   1   1   1   1   1   1   1   2   2    2    2    2    2    2    2    2 */

         /*              3  4  5  6  7  8   9   0   1   2   3   4   5   6   7   8   9   0   1    2    3    4    5    6    7    8 */

         i = sscanf(s, "%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld " _UFM _UFM _DFM _UFM _UFM _UFM _UFM,

              &state,          /* 3  %c  */

              &ppid,           /* 4  %d  */

              &pgrp,           /* 5  %d  */

              &session,        /* 6  %d  */

              &nr,             /* 7  %d  */

              &tpgrp,          /* 8  %d  */

              &flags,          /* 9  %lu  */

              &minflt,         /* 10 %lu  */

              &cminflt,        /* 11 %lu  */

              &majflt,         /* 12 %lu  */

              &cmajflt,        /* 13 %lu  */

              &utime,          /* 14 %lu  */

              &stime,          /* 15 %lu  */

              &cutime,         /* 16 %ld  */

              &cstime,         /* 17 %ld  */

              &prio,           /* 18 %ld  */

              &nice,           /* 19 %ld  */

              &junk,           /* 20 %ld  */

              &it_real,        /* 21 %ld  */

              &start,          /* 22 UINTX_FORMAT */

              &vsize,          /* 23 UINTX_FORMAT */

              &rss,            /* 24 INTX_FORMAT  */

              &rsslim,         /* 25 UINTX_FORMAT */

              &scodes,         /* 26 UINTX_FORMAT */

              &ecode,          /* 27 UINTX_FORMAT */

              &stack_start);   /* 28 UINTX_FORMAT */

       }

 #undef _UFM

 #undef _DFM

       if (i != 28 - 2) {

          assert(false, "Bad conversion from /proc/self/stat");

          // product mode - assume we are the initial thread, good luck in the

          // embedded case.

          warning("Can't detect initial thread stack location - bad conversion");

          stack_start = (uintptr_t) &rlim;

       }

     } else {

       // For some reason we can't open /proc/self/stat (for example, running on

       // FreeBSD with a Linux emulator, or inside chroot), this should work for

       // most cases, so don't abort:

       warning("Can't detect initial thread stack location - no /proc/self/stat");

       stack_start = (uintptr_t) &rlim;

     }

   }

   // Now we have a pointer (stack_start) very close to the stack top, the

   // next thing to do is to figure out the exact location of stack top. We

   // can find out the virtual memory area that contains stack_start by

   // reading /proc/self/maps, it should be the last vma in /proc/self/maps,

   // and its upper limit is the real stack top. (again, this would fail if

   // running inside chroot, because /proc may not exist.)

   uintptr_t stack_top;

   address low, high;

   if (find_vma((address)stack_start, &low, &high)) {

     // success, "high" is the true stack top. (ignore "low", because initial

     // thread stack grows on demand, its real bottom is high - RLIMIT_STACK.)

     stack_top = (uintptr_t)high;

   } else {

     // failed, likely because /proc/self/maps does not exist

     warning("Can't detect initial thread stack location - find_vma failed");

     // best effort: stack_start is normally within a few pages below the real

     // stack top, use it as stack top, and reduce stack size so we won't put

     // guard page outside stack.

     stack_top = stack_start;

     stack_size -= 16 * page_size();

   }

   // stack_top could be partially down the page so align it

   stack_top = align_size_up(stack_top, page_size());

   // Allowed stack value is minimum of max_size and what we derived from rlimit

   if (max_size > 0) {

     _initial_thread_stack_size = MIN2(max_size, stack_size);

   } else {

     // Accept the rlimit max, but if stack is unlimited then it will be huge, so

     // clamp it at 8MB as we do on Solaris

     _initial_thread_stack_size = MIN2(stack_size, 8*M);

   }

   _initial_thread_stack_size = align_size_down(_initial_thread_stack_size, page_size());

   _initial_thread_stack_bottom = (address)stack_top - _initial_thread_stack_size;

   assert(_initial_thread_stack_bottom < (address)stack_top, "overflow!");

 }

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

 // 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(); // nanosecond resolution

 }

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

   struct rusage usage;

   int retval = getrusage(RUSAGE_THREAD, &usage);

   if (retval == 0) {

     return (double) (usage.ru_utime.tv_sec + usage.ru_stime.tv_sec) + (double) (usage.ru_utime.tv_usec + usage.ru_stime.tv_usec) / (1000 * 1000);

   } else {

     // better than nothing, but not much

     return elapsedTime();

   }

 }

 jlong os::javaTimeMillis() {

   timeval time;

   int status = gettimeofday(&time, NULL);

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

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

 }

 #ifndef CLOCK_MONOTONIC

 #define CLOCK_MONOTONIC (1)

 #endif

 void os::Linux::clock_init() {

   // we do dlopen's in this particular order due to bug in linux

   // dynamical loader (see 6348968) leading to crash on exit

   void* handle = dlopen("librt.so.1", RTLD_LAZY);

   if (handle == NULL) {

     handle = dlopen("librt.so", RTLD_LAZY);

   }

   if (handle) {

     int (*clock_getres_func)(clockid_t, struct timespec*) =

            (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_getres");

     int (*clock_gettime_func)(clockid_t, struct timespec*) =

            (int(*)(clockid_t, struct timespec*))dlsym(handle, "clock_gettime");

     if (clock_getres_func && clock_gettime_func) {

       // See if monotonic clock is supported by the kernel. Note that some

       // early implementations simply return kernel jiffies (updated every

       // 1/100 or 1/1000 second). It would be bad to use such a low res clock

       // for nano time (though the monotonic property is still nice to have).

       // It's fixed in newer kernels, however clock_getres() still returns

       // 1/HZ. We check if clock_getres() works, but will ignore its reported

       // resolution for now. Hopefully as people move to new kernels, this

       // won't be a problem.

       struct timespec res;

       struct timespec tp;

       if (clock_getres_func (CLOCK_MONOTONIC, &res) == 0 &&

           clock_gettime_func(CLOCK_MONOTONIC, &tp)  == 0) {

         // yes, monotonic clock is supported

         _clock_gettime = clock_gettime_func;

         return;

       } else {

         // close librt if there is no monotonic clock

         dlclose(handle);

       }

     }

   }

   warning("No monotonic clock was available - timed services may " \

           "be adversely affected if the time-of-day clock changes");

 }

 #ifndef SYS_clock_getres

 #if defined(IA32) || defined(AMD64)

 #define SYS_clock_getres IA32_ONLY(266)  AMD64_ONLY(229)

 #define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)

 #else

 #warning "SYS_clock_getres not defined for this platform, disabling fast_thread_cpu_time"

 #define sys_clock_getres(x,y)  -1

 #endif

 #else

 #define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)

 #endif

 void os::Linux::fast_thread_clock_init() {

   if (!UseLinuxPosixThreadCPUClocks) {

     return;

   }

   clockid_t clockid;

   struct timespec tp;

   int (*pthread_getcpuclockid_func)(pthread_t, clockid_t *) =

       (int(*)(pthread_t, clockid_t *)) dlsym(RTLD_DEFAULT, "pthread_getcpuclockid");

   // Switch to using fast clocks for thread cpu time if

   // the sys_clock_getres() returns 0 error code.

   // Note, that some kernels may support the current thread

   // clock (CLOCK_THREAD_CPUTIME_ID) but not the clocks

   // returned by the pthread_getcpuclockid().

   // If the fast Posix clocks are supported then the sys_clock_getres()

   // must return at least tp.tv_sec == 0 which means a resolution

   // better than 1 sec. This is extra check for reliability.

   if(pthread_getcpuclockid_func &&

      pthread_getcpuclockid_func(_main_thread, &clockid) == 0 &&

      sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) {

     _supports_fast_thread_cpu_time = true;

     _pthread_getcpuclockid = pthread_getcpuclockid_func;

   }

 }

 jlong os::javaTimeNanos() {

   if (Linux::supports_monotonic_clock()) {

     struct timespec tp;

     int status = Linux::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, "linux error");

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

     return 1000 * usecs;

   }

 }

 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {

   if (Linux::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 LinuxThreads only kills current thread

   ::abort();

 }

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

 }

 intx os::current_thread_id() { return (intx)pthread_self(); }

 int os::current_process_id() {

   // Under the old linux thread library, linux 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). Linux 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_linux.hpp file

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

 }

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

   // Copied from libhpi

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

     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;

 }

 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;

   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;

       }

     }

   }

   buf[0] = '\0';

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

   return false;

 }

 struct _address_to_library_name {

   address addr;          // input : memory address

   size_t  buflen;        //         size of fname

   char*   fname;         // output: library name

   address base;          //         library base addr

 };

 static int address_to_library_name_callback(struct dl_phdr_info *info,

                                             size_t size, void *data) {

   int i;

   bool found = false;

   address libbase = NULL;

   struct _address_to_library_name * d = (struct _address_to_library_name *)data;

   // iterate through all loadable segments

   for (i = 0; i < info->dlpi_phnum; i++) {

     address segbase = (address)(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr);

     if (info->dlpi_phdr[i].p_type == PT_LOAD) {

       // base address of a library is the lowest address of its loaded

       // segments.

       if (libbase == NULL || libbase > segbase) {

         libbase = segbase;

       }

       // see if 'addr' is within current segment

       if (segbase <= d->addr &&

           d->addr < segbase + info->dlpi_phdr[i].p_memsz) {

         found = true;

       }

     }

   }

   // dlpi_name is NULL or empty if the ELF file is executable, return 0

   // so dll_address_to_library_name() can fall through to use dladdr() which

   // can figure out executable name from argv[0].

   if (found && info->dlpi_name && info->dlpi_name[0]) {

     d->base = libbase;

     if (d->fname) {

       jio_snprintf(d->fname, d->buflen, "%s", info->dlpi_name);

     }

     return 1;

   }

   return 0;

 }

 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;

   struct _address_to_library_name data;

   // There is a bug in old glibc dladdr() implementation that it could resolve

   // to wrong library name if the .so file has a base address != NULL. Here

   // we iterate through the program headers of all loaded libraries to find

   // out which library 'addr' really belongs to. This workaround can be

   // removed once the minimum requirement for glibc is moved to 2.3.x.

   data.addr = addr;

   data.fname = buf;

   data.buflen = buflen;

   data.base = NULL;

   int rslt = dl_iterate_phdr(address_to_library_name_callback, (void *)&data);

   if (rslt) {

      // buf already contains library name

      if (offset) *offset = addr - data.base;

      return true;

   }

   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

 // Remember the stack's state. The Linux dynamic linker will change

 // the stack to 'executable' at most once, so we must safepoint only once.

 bool os::Linux::_stack_is_executable = false;

 // VM operation that loads a library.  This is necessary if stack protection

 // of the Java stacks can be lost during loading the library.  If we

 // do not stop the Java threads, they can stack overflow before the stacks

 // are protected again.

 class VM_LinuxDllLoad: public VM_Operation {

  private:

   const char *_filename;

   char *_ebuf;

   int _ebuflen;

   void *_lib;

  public:

   VM_LinuxDllLoad(const char *fn, char *ebuf, int ebuflen) :

     _filename(fn), _ebuf(ebuf), _ebuflen(ebuflen), _lib(NULL) {}

   VMOp_Type type() const { return VMOp_LinuxDllLoad; }

   void doit() {

     _lib = os::Linux::dll_load_in_vmthread(_filename, _ebuf, _ebuflen);

     os::Linux::_stack_is_executable = true;

   }

   void* loaded_library() { return _lib; }

 };

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

 {

   void * result = NULL;

   bool load_attempted = false;

   // Check whether the library to load might change execution rights

   // of the stack. If they are changed, the protection of the stack

   // guard pages will be lost. We need a safepoint to fix this.

   //

   // See Linux man page execstack(8) for more info.

   if (os::uses_stack_guard_pages() && !os::Linux::_stack_is_executable) {

     ElfFile ef(filename);

     if (!ef.specifies_noexecstack()) {

       if (!is_init_completed()) {

         os::Linux::_stack_is_executable = true;

         // This is OK - No Java threads have been created yet, and hence no

         // stack guard pages to fix.

         //

         // This should happen only when you are building JDK7 using a very

         // old version of JDK6 (e.g., with JPRT) and running test_gamma.

         //

         // Dynamic loader will make all stacks executable after

         // this function returns, and will not do that again.

         assert(Threads::first() == NULL, "no Java threads should exist yet.");

       } else {

         warning("You have loaded library %s which might have disabled stack guard. "

                 "The VM will try to fix the stack guard now.\n"

                 "It's highly recommended that you fix the library with "

                 "'execstack -c <libfile>', or link it with '-z noexecstack'.",

                 filename);

         assert(Thread::current()->is_Java_thread(), "must be Java thread");

         JavaThread *jt = JavaThread::current();

         if (jt->thread_state() != _thread_in_native) {

           // This happens when a compiler thread tries to load a hsdis-<arch>.so file

           // that requires ExecStack. Cannot enter safe point. Let's give up.

           warning("Unable to fix stack guard. Giving up.");

         } else {

           if (!LoadExecStackDllInVMThread) {

             // This is for the case where the DLL has an static

             // constructor function that executes JNI code. We cannot

             // load such DLLs in the VMThread.

             result = os::Linux::dlopen_helper(filename, ebuf, ebuflen);

           }

           ThreadInVMfromNative tiv(jt);

           debug_only(VMNativeEntryWrapper vew;)

           VM_LinuxDllLoad op(filename, ebuf, ebuflen);

           VMThread::execute(&op);

           if (LoadExecStackDllInVMThread) {

             result = op.loaded_library();

           }

           load_attempted = true;

         }

       }

     }

   }

   if (!load_attempted) {

     result = os::Linux::dlopen_helper(filename, ebuf, ebuflen);

   }

   if (result != NULL) {

     // Successful loading

     return result;

   }

   Elf32_Ehdr elf_head;

   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

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

 #if defined(VM_LITTLE_ENDIAN)

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

 #else

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

 #endif

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

 }

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

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

   if (result == NULL) {

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

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

   }

   return result;

 }

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

   void * result = NULL;

   if (LoadExecStackDllInVMThread) {

     result = dlopen_helper(filename, ebuf, ebuflen);

   }

   // Since 7019808, libjvm.so is linked with -noexecstack. If the VM loads a

   // library that requires an executable stack, or which does not have this

   // stack attribute set, dlopen changes the stack attribute to executable. The

   // read protection of the guard pages gets lost.

   //

   // Need to check _stack_is_executable again as multiple VM_LinuxDllLoad

   // may have been queued at the same time.

   if (!_stack_is_executable) {

     JavaThread *jt = Threads::first();

     while (jt) {

       if (!jt->stack_guard_zone_unused() &&        // Stack not yet fully initialized

           jt->stack_yellow_zone_enabled()) {       // No pending stack overflow exceptions

         if (!os::guard_memory((char *) jt->stack_red_zone_base() - jt->stack_red_zone_size(),

                               jt->stack_yellow_zone_size() + jt->stack_red_zone_size())) {

           warning("Attempt to reguard stack yellow zone failed.");

         }

       }

       jt = jt->next();

     }

   }

   return result;

 }

 /*

  * glibc-2.0 libdl is not MT safe.  If you are building with any glibc,

  * chances are you might want to run the generated bits against glibc-2.0

  * libdl.so, so always use locking for any version of glibc.

  */

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

   pthread_mutex_lock(&dl_mutex);

   void* res = dlsym(handle, name);

   pthread_mutex_unlock(&dl_mutex);

   return res;

 }

 void* os::get_default_process_handle() {

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

 }

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

    char fname[32];

    pid_t pid = os::Linux::gettid();

    jio_snprintf(fname, sizeof(fname), "/proc/%d/maps", pid);

    if (!_print_ascii_file(fname, st)) {

      st->print("Can not get library information for pid = %d\n", pid);

    }

 }

 void os::print_os_info_brief(outputStream* st) {

   os::Linux::print_distro_info(st);

   os::Posix::print_uname_info(st);

   os::Linux::print_libversion_info(st);

 }

 void os::print_os_info(outputStream* st) {

   st->print("OS:");

   os::Linux::print_distro_info(st);

   os::Posix::print_uname_info(st);

   // Print warning if unsafe chroot environment detected

   if (unsafe_chroot_detected) {

     st->print("WARNING!! ");

     st->print_cr("%s", unstable_chroot_error);

   }

   os::Linux::print_libversion_info(st);

   os::Posix::print_rlimit_info(st);

   os::Posix::print_load_average(st);

   os::Linux::print_full_memory_info(st);

   os::Linux::print_container_info(st);

 }

 // Try to identify popular distros.

 // Most Linux distributions have a /etc/XXX-release file, which contains

 // the OS version string. Newer Linux distributions have a /etc/lsb-release

 // file that also contains the OS version string. Some have more than one

 // /etc/XXX-release file (e.g. Mandrake has both /etc/mandrake-release and

 // /etc/redhat-release.), so the order is important.

 // Any Linux that is based on Redhat (i.e. Oracle, Mandrake, Sun JDS...) have

 // their own specific XXX-release file as well as a redhat-release file.

 // Because of this the XXX-release file needs to be searched for before the

 // redhat-release file.

 // Since Red Hat has a lsb-release file that is not very descriptive the

 // search for redhat-release needs to be before lsb-release.

 // Since the lsb-release file is the new standard it needs to be searched

 // before the older style release files.

 // Searching system-release (Red Hat) and os-release (other Linuxes) are a

 // next to last resort.  The os-release file is a new standard that contains

 // distribution information and the system-release file seems to be an old

 // standard that has been replaced by the lsb-release and os-release files.

 // Searching for the debian_version file is the last resort.  It contains

 // an informative string like "6.0.6" or "wheezy/sid". Because of this

 // "Debian " is printed before the contents of the debian_version file.

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

    if (!_print_ascii_file("/etc/oracle-release", st) &&

        !_print_ascii_file("/etc/mandriva-release", st) &&

        !_print_ascii_file("/etc/mandrake-release", st) &&

        !_print_ascii_file("/etc/sun-release", st) &&

        !_print_ascii_file("/etc/redhat-release", st) &&

        !_print_ascii_file("/etc/lsb-release", st) &&

        !_print_ascii_file("/etc/SuSE-release", st) &&

        !_print_ascii_file("/etc/turbolinux-release", st) &&

        !_print_ascii_file("/etc/gentoo-release", st) &&

        !_print_ascii_file("/etc/ltib-release", st) &&

        !_print_ascii_file("/etc/angstrom-version", st) &&

        !_print_ascii_file("/etc/system-release", st) &&

        !_print_ascii_file("/etc/os-release", st)) {

        if (file_exists("/etc/debian_version")) {

          st->print("Debian ");

          _print_ascii_file("/etc/debian_version", st);

        } else {

          st->print("Linux");

        }

    }

    st->cr();

 }

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

   // libc, pthread

   st->print("libc:");

   st->print("%s ", os::Linux::glibc_version());

   st->print("%s ", os::Linux::libpthread_version());

   if (os::Linux::is_LinuxThreads()) {

      st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");

   }

   st->cr();

 }

 void os::Linux::print_full_memory_info(outputStream* st) {

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

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

    st->cr();

 }

 void os::Linux::print_container_info(outputStream* st) {

 if (!OSContainer::is_containerized()) {

     return;

   }

   st->print("container (cgroup) information:\n");

   const char *p_ct = OSContainer::container_type();

   st->print("container_type: %s\n", p_ct != NULL ? p_ct : "failed");

   char *p = OSContainer::cpu_cpuset_cpus();

   st->print("cpu_cpuset_cpus: %s\n", p != NULL ? p : "failed");

   free(p);

   p = OSContainer::cpu_cpuset_memory_nodes();

   st->print("cpu_memory_nodes: %s\n", p != NULL ? p : "failed");

   free(p);

   int i = OSContainer::active_processor_count();

   if (i > 0) {

     st->print("active_processor_count: %d\n", i);

   } else {

     st->print("active_processor_count: failed\n");

   }

   i = OSContainer::cpu_quota();

   st->print("cpu_quota: %d\n", i);

   i = OSContainer::cpu_period();

   st->print("cpu_period: %d\n", i);

   i = OSContainer::cpu_shares();

   st->print("cpu_shares: %d\n", i);

   jlong j = OSContainer::memory_limit_in_bytes();

   st->print("memory_limit_in_bytes: " JLONG_FORMAT "\n", j);

   j = OSContainer::memory_and_swap_limit_in_bytes();

   st->print("memory_and_swap_limit_in_bytes: " JLONG_FORMAT "\n", j);

   j = OSContainer::memory_soft_limit_in_bytes();

   st->print("memory_soft_limit_in_bytes: " JLONG_FORMAT "\n", j);

   j = OSContainer::OSContainer::memory_usage_in_bytes();

   st->print("memory_usage_in_bytes: " JLONG_FORMAT "\n", j);

   j = OSContainer::OSContainer::memory_max_usage_in_bytes();

   st->print("memory_max_usage_in_bytes: " JLONG_FORMAT "\n", j);

   st->cr();

 }

 void os::print_memory_info(outputStream* st) {

   st->print("Memory:");

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

   // values in struct sysinfo are "unsigned long"

   struct sysinfo si;

   sysinfo(&si);

   st->print(", physical " UINT64_FORMAT "k",

             os::physical_memory() >> 10);

   st->print("(" UINT64_FORMAT "k free)",

             os::available_memory() >> 10);

   st->print(", swap " UINT64_FORMAT "k",

             ((jlong)si.totalswap * si.mem_unit) >> 10);

   st->print("(" UINT64_FORMAT "k free)",

             ((jlong)si.freeswap * si.mem_unit) >> 10);

   st->cr();

 }

 void os::pd_print_cpu_info(outputStream* st) {

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

   if (!_print_ascii_file("/proc/cpuinfo", st)) {

     st->print("  <Not Available>");

   }

   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 INCLUDE_CDS

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

     }

   }

 #endif

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

 #if defined(PPC64)

   print_signal_handler(st, SIGTRAP, buf, buflen);

 #endif

 }

 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;

   }

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

         int len;

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

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

         assert(len < buflen, "Ran out of buffer room");

         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

           rp = realpath(dli_fname, buf);

           if (rp == NULL)

             return;

         }

       }

     }

   }

   strncpy(saved_jvm_path, buf, MAXPATHLEN);

 }

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

 }

 class Semaphore : public StackObj {

   public:

     Semaphore();

     ~Semaphore();

     void signal();

     void wait();

     bool trywait();

     bool timedwait(unsigned int sec, int nsec);

   private:

     sem_t _semaphore;

 };

 Semaphore::Semaphore() {

   sem_init(&_semaphore, 0, 0);

 }

 Semaphore::~Semaphore() {

   sem_destroy(&_semaphore);

 }

 void Semaphore::signal() {

   sem_post(&_semaphore);

 }

 void Semaphore::wait() {

   sem_wait(&_semaphore);

 }

 bool Semaphore::trywait() {

   return sem_trywait(&_semaphore) == 0;

 }

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

   struct timespec ts;

   // Semaphore's are always associated with CLOCK_REALTIME

   os::Linux::clock_gettime(CLOCK_REALTIME, &ts);

   // see unpackTime for discussion on overflow checking

   if (sec >= MAX_SECS) {

     ts.tv_sec += MAX_SECS;

     ts.tv_nsec = 0;

   } else {

     ts.tv_sec += sec;

     ts.tv_nsec += nsec;

     if (ts.tv_nsec >= NANOSECS_PER_SEC) {

       ts.tv_nsec -= NANOSECS_PER_SEC;

       ++ts.tv_sec; // note: this must be <= max_secs

     }

   }

   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;

     }

   }

 }

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

 // Linux(POSIX) specific hand shaking semaphore.

 static sem_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, 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::Linux::page_size() != -1, "must call os::init");

   return os::Linux::page_size();

 }

 // Solaris allocates memory by pages.

 int os::vm_allocation_granularity() {