1 /*

        2  * Copyright (c) 1999, 2009, Oracle and/or its affiliates. All rights reserved.

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

        4  *

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

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

        7  * published by the Free Software Foundation.

        8  *

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

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

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

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

       13  * accompanied this code).

       14  *

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

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

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

       18  *

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

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

       21  * questions.

       22  *

       23  */

       24 

       25 # define __STDC_FORMAT_MACROS

       26 

       27 // do not include  precompiled  header file

       28 # include "incls/_os_linux.cpp.incl"

       29 

       30 // put OS-includes here

       31 # include <sys/types.h>

       32 # include <sys/mman.h>

       33 # include <sys/stat.h>

       34 # include <sys/select.h>

       35 # include <pthread.h>

       36 # include <signal.h>

       37 # include <errno.h>

       38 # include <dlfcn.h>

       39 # include <stdio.h>

       40 # include <unistd.h>

       41 # include <sys/resource.h>

       42 # include <pthread.h>

       43 # include <sys/stat.h>

       44 # include <sys/time.h>

       45 # include <sys/times.h>

       46 # include <sys/utsname.h>

       47 # include <sys/socket.h>

       48 # include <sys/wait.h>

       49 # include <pwd.h>

       50 # include <poll.h>

       51 # include <semaphore.h>

       52 # include <fcntl.h>

       53 # include <string.h>

       54 # include <syscall.h>

       55 # include <sys/sysinfo.h>

       56 # include <gnu/libc-version.h>

       57 # include <sys/ipc.h>

       58 # include <sys/shm.h>

       59 # include <link.h>

       60 # include <stdint.h>

       61 # include <inttypes.h>

       62 

       63 #define MAX_PATH    (2 * K)

       64 

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

       66 #define ALL_64_BITS CONST64(0xFFFFFFFFFFFFFFFF)

       67 #define SEC_IN_NANOSECS  1000000000LL

       68 

       69 ////////////////////////////////////////////////////////////////////////////////

       70 // global variables

       71 julong os::Linux::_physical_memory = 0;

       72 

       73 address   os::Linux::_initial_thread_stack_bottom = NULL;

       74 uintptr_t os::Linux::_initial_thread_stack_size   = 0;

       75 

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

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

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

       79 pthread_t os::Linux::_main_thread;

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

       81 bool os::Linux::_is_floating_stack = false;

       82 bool os::Linux::_is_NPTL = false;

       83 bool os::Linux::_supports_fast_thread_cpu_time = false;

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

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

       86 

       87 static jlong initial_time_count=0;

       88 

       89 static int clock_tics_per_sec = 100;

       90 

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

       92 static sigset_t check_signal_done;

       93 static bool check_signals = true;;

       94 

       95 static pid_t _initial_pid = 0;

       96 

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

       98 

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

      100 static int SR_signum = SIGUSR2;

      101 sigset_t SR_sigset;

      102 

      103 /* Used to protect dlsym() calls */

      104 static pthread_mutex_t dl_mutex;

      105 

      106 ////////////////////////////////////////////////////////////////////////////////

      107 // utility functions

      108 

      109 static int SR_initialize();

      110 static int SR_finalize();

      111 

      112 julong os::available_memory() {

      113   return Linux::available_memory();

      114 }

      115 

      116 julong os::Linux::available_memory() {

      117   // values in struct sysinfo are "unsigned long"

      118   struct sysinfo si;

      119   sysinfo(&si);

      120 

      121   return (julong)si.freeram * si.mem_unit;

      122 }

      123 

      124 julong os::physical_memory() {

      125   return Linux::physical_memory();

      126 }

      127 

      128 julong os::allocatable_physical_memory(julong size) {

      129 #ifdef _LP64

      130   return size;

      131 #else

      132   julong result = MIN2(size, (julong)3800*M);

      133    if (!is_allocatable(result)) {

      134      // See comments under solaris for alignment considerations

      135      julong reasonable_size = (julong)2*G - 2 * os::vm_page_size();

      136      result =  MIN2(size, reasonable_size);

      137    }

      138    return result;

      139 #endif // _LP64

      140 }

      141 

      142 ////////////////////////////////////////////////////////////////////////////////

      143 // environment support

      144 

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

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

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

      148     strcpy(buf, val);

      149     return true;

      150   }

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

      152   return false;

      153 }

      154 

      155 

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

      157 

      158 bool os::have_special_privileges() {

      159   static bool init = false;

      160   static bool privileges = false;

      161   if (!init) {

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

      163     init = true;

      164   }

      165   return privileges;

      166 }

      167 

      168 

      169 #ifndef SYS_gettid

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

      171 #ifdef __ia64__

      172 #define SYS_gettid 1105

      173 #elif __i386__

      174 #define SYS_gettid 224

      175 #elif __amd64__

      176 #define SYS_gettid 186

      177 #elif __sparc__

      178 #define SYS_gettid 143

      179 #else

      180 #error define gettid for the arch

      181 #endif

      182 #endif

      183 

      184 // Cpu architecture string

      185 #if   defined(ZERO)

      186 static char cpu_arch[] = ZERO_LIBARCH;

      187 #elif defined(IA64)

      188 static char cpu_arch[] = "ia64";

      189 #elif defined(IA32)

      190 static char cpu_arch[] = "i386";

      191 #elif defined(AMD64)

      192 static char cpu_arch[] = "amd64";

      193 #elif defined(ARM)

      194 static char cpu_arch[] = "arm";

      195 #elif defined(PPC)

      196 static char cpu_arch[] = "ppc";

      197 #elif defined(SPARC)

      198 #  ifdef _LP64

      199 static char cpu_arch[] = "sparcv9";

      200 #  else

      201 static char cpu_arch[] = "sparc";

      202 #  endif

      203 #else

      204 #error Add appropriate cpu_arch setting

      205 #endif

      206 

      207 

      208 // pid_t gettid()

      209 //

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

      211 // thread id is used to access /proc.

      212 //

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

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

      215 //

      216 pid_t os::Linux::gettid() {

      217   int rslt = syscall(SYS_gettid);

      218   if (rslt == -1) {

      219      // old kernel, no NPTL support

      220      return getpid();

      221   } else {

      222      return (pid_t)rslt;

      223   }

      224 }

      225 

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

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

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

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

      230 static bool unsafe_chroot_detected = false;

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

      232                      "Java may be unstable running multithreaded in a chroot "

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

      234 

      235 void os::Linux::initialize_system_info() {

      236   set_processor_count(sysconf(_SC_NPROCESSORS_CONF));

      237   if (processor_count() == 1) {

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

      239     char fname[32];

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

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

      242     if (fp == NULL) {

      243       unsafe_chroot_detected = true;

      244     } else {

      245       fclose(fp);

      246     }

      247   }

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

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

      250 }

      251 

      252 void os::init_system_properties_values() {

      253 //  char arch[12];

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

      255 

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

      257   //

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

      259   // This library should be located at:

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

      261   //

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

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

      264   //

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

      266   //

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

      268   //

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

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

      271   //

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

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

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

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

      276   //

      277   // Otherwise exit.

      278   //

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

      280   // code needs to be changed accordingly.

      281 

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

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

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

      285 

      286 /*

      287  * See ld(1):

      288  *      The linker uses the following search paths to locate required

      289  *      shared libraries:

      290  *        1: ...

      291  *        ...

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

      293  */

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

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

      296 #else

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

      298 #endif

      299 

      300 #define EXTENSIONS_DIR  "/lib/ext"

      301 #define ENDORSED_DIR    "/lib/endorsed"

      302 #define REG_DIR         "/usr/java/packages"

      303 

      304   {

      305     /* sysclasspath, java_home, dll_dir */

      306     {

      307         char *home_path;

      308         char *dll_path;

      309         char *pslash;

      310         char buf[MAXPATHLEN];

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

      312 

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

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

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

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

      317         if (pslash != NULL)

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

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

      320         if (dll_path == NULL)

      321             return;

      322         strcpy(dll_path, buf);

      323         Arguments::set_dll_dir(dll_path);

      324 

      325         if (pslash != NULL) {

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

      327             if (pslash != NULL) {

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

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

      330                 if (pslash != NULL)

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

      332             }

      333         }

      334 

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

      336         if (home_path == NULL)

      337             return;

      338         strcpy(home_path, buf);

      339         Arguments::set_java_home(home_path);

      340 

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

      342             return;

      343     }

      344 

      345     /*

      346      * Where to look for native libraries

      347      *

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

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

      350      * on legacy Linux implementations (which are no longer supported).

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

      352      *

      353      * However, to prevent the proliferation of improperly built native

      354      * libraries, the new path component /usr/java/packages is added here.

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

      356      */

      357     {

      358         char *ld_library_path;

      359 

      360         /*

      361          * Construct the invariant part of ld_library_path. Note that the

      362          * space for the colon and the trailing null are provided by the

      363          * nulls included by the sizeof operator (so actually we allocate

      364          * a byte more than necessary).

      365          */

      366         ld_library_path = (char *) malloc(sizeof(REG_DIR) + sizeof("/lib/") +

      367             strlen(cpu_arch) + sizeof(DEFAULT_LIBPATH));

      368         sprintf(ld_library_path, REG_DIR "/lib/%s:" DEFAULT_LIBPATH, cpu_arch);

      369 

      370         /*

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

      372          * should always exist (until the legacy problem cited above is

      373          * addressed).

      374          */

      375         char *v = getenv("LD_LIBRARY_PATH");

      376         if (v != NULL) {

      377             char *t = ld_library_path;

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

      379             ld_library_path = (char *) malloc(strlen(v) + 1 + strlen(t) + 1);

      380             sprintf(ld_library_path, "%s:%s", v, t);

      381         }

      382         Arguments::set_library_path(ld_library_path);

      383     }

      384 

      385     /*

      386      * Extensions directories.

      387      *

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

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

      390      * than necessary is allocated).

      391      */

      392     {

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

      394             sizeof(EXTENSIONS_DIR) + sizeof(REG_DIR) + sizeof(EXTENSIONS_DIR));

      395         sprintf(buf, "%s" EXTENSIONS_DIR ":" REG_DIR EXTENSIONS_DIR,

      396             Arguments::get_java_home());

      397         Arguments::set_ext_dirs(buf);

      398     }

      399 

      400     /* Endorsed standards default directory. */

      401     {

      402         char * buf;

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

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

      405         Arguments::set_endorsed_dirs(buf);

      406     }

      407   }

      408 

      409 #undef malloc

      410 #undef getenv

      411 #undef EXTENSIONS_DIR

      412 #undef ENDORSED_DIR

      413 

      414   // Done

      415   return;

      416 }

      417 

      418 ////////////////////////////////////////////////////////////////////////////////

      419 // breakpoint support

      420 

      421 void os::breakpoint() {

      422   BREAKPOINT;

      423 }

      424 

      425 extern "C" void breakpoint() {

      426   // use debugger to set breakpoint here

      427 }

      428 

      429 ////////////////////////////////////////////////////////////////////////////////

      430 // signal support

      431 

      432 debug_only(static bool signal_sets_initialized = false);

      433 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;

      434 

      435 bool os::Linux::is_sig_ignored(int sig) {

      436       struct sigaction oact;

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

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

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

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

      441            return true;

      442       else

      443            return false;

      444 }

      445 

      446 void os::Linux::signal_sets_init() {

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

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

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

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

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

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

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

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

      455   // the dispositions or masks wrt these signals.

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

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

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

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

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

      461   // these signals are not blocked by default.

      462   sigemptyset(&unblocked_sigs);

      463   sigemptyset(&allowdebug_blocked_sigs);

      464   sigaddset(&unblocked_sigs, SIGILL);

      465   sigaddset(&unblocked_sigs, SIGSEGV);

      466   sigaddset(&unblocked_sigs, SIGBUS);

      467   sigaddset(&unblocked_sigs, SIGFPE);

      468   sigaddset(&unblocked_sigs, SR_signum);

      469 

      470   if (!ReduceSignalUsage) {

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

      472       sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);

      473       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);

      474    }

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

      476       sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);

      477       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);

      478    }

      479    if (!os::Linux::is_sig_ignored(SHUTDOWN3_SIGNAL)) {

      480       sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);

      481       sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);

      482    }

      483   }

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

      485   sigemptyset(&vm_sigs);

      486   if (!ReduceSignalUsage)

      487     sigaddset(&vm_sigs, BREAK_SIGNAL);

      488   debug_only(signal_sets_initialized = true);

      489 

      490 }

      491 

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

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

      494 sigset_t* os::Linux::unblocked_signals() {

      495   assert(signal_sets_initialized, "Not initialized");

      496   return &unblocked_sigs;

      497 }

      498 

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

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

      501 sigset_t* os::Linux::vm_signals() {

      502   assert(signal_sets_initialized, "Not initialized");

      503   return &vm_sigs;

      504 }

      505 

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

      507 sigset_t* os::Linux::allowdebug_blocked_signals() {

      508   assert(signal_sets_initialized, "Not initialized");

      509   return &allowdebug_blocked_sigs;

      510 }

      511 

      512 void os::Linux::hotspot_sigmask(Thread* thread) {

      513 

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

      515   sigset_t caller_sigmask;

      516   pthread_sigmask(SIG_BLOCK, NULL, &caller_sigmask);

      517 

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

      519   osthread->set_caller_sigmask(caller_sigmask);

      520 

      521   pthread_sigmask(SIG_UNBLOCK, os::Linux::unblocked_signals(), NULL);

      522 

      523   if (!ReduceSignalUsage) {

      524     if (thread->is_VM_thread()) {

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

      526       pthread_sigmask(SIG_UNBLOCK, vm_signals(), NULL);

      527     } else {

      528       // ... all other threads block BREAK_SIGNAL

      529       pthread_sigmask(SIG_BLOCK, vm_signals(), NULL);

      530     }

      531   }

      532 }

      533 

      534 //////////////////////////////////////////////////////////////////////////////

      535 // detecting pthread library

      536 

      537 void os::Linux::libpthread_init() {

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

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

      540   // generic name for earlier versions.

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

      542 # ifndef _CS_GNU_LIBC_VERSION

      543 # define _CS_GNU_LIBC_VERSION 2

      544 # endif

      545 # ifndef _CS_GNU_LIBPTHREAD_VERSION

      546 # define _CS_GNU_LIBPTHREAD_VERSION 3

      547 # endif

      548 

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

      550   if (n > 0) {

      551      char *str = (char *)malloc(n);

      552      confstr(_CS_GNU_LIBC_VERSION, str, n);

      553      os::Linux::set_glibc_version(str);

      554   } else {

      555      // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()

      556      static char _gnu_libc_version[32];

      557      jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),

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

      559      os::Linux::set_glibc_version(_gnu_libc_version);

      560   }

      561 

      562   n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);

      563   if (n > 0) {

      564      char *str = (char *)malloc(n);

      565      confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);

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

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

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

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

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

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

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

      573          strstr(str, "NPTL") &&

      574          sysconf(_SC_THREAD_THREADS_MAX) > 0) {

      575        free(str);

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

      577      } else {

      578        os::Linux::set_libpthread_version(str);

      579      }

      580   } else {

      581     // glibc before 2.3.2 only has LinuxThreads.

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

      583   }

      584 

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

      586     os::Linux::set_is_NPTL();

      587   } else {

      588     os::Linux::set_is_LinuxThreads();

      589   }

      590 

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

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

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

      594     os::Linux::set_is_floating_stack();

      595   }

      596 }

      597 

      598 /////////////////////////////////////////////////////////////////////////////

      599 // thread stack

      600 

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

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

      603 //

      604 // MAP_GROWSDOWN:

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

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

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

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

      609 //   stack as needed (on page faults).

      610 //

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

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

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

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

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

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

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

      618 //

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

      620 //   stack overflow detection.

      621 //

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

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

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

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

      626 //   and then attach the thread to JVM.

      627 //

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

      629 // manually expand thread stack after receiving the SIGSEGV.

      630 //

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

      632 // both of them in JVM before 1.5:

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

      634 //      touch "bottom"

      635 //   2. mmap() the page in question

      636 //

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

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

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

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

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

      642 //

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

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

      645 // stack mapping.

      646 //

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

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

      649 

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

      651 #define NOINLINE

      652 #else

      653 #define NOINLINE __attribute__ ((noinline))

      654 #endif

      655 

      656 static void _expand_stack_to(address bottom) NOINLINE;

      657 

      658 static void _expand_stack_to(address bottom) {

      659   address sp;

      660   size_t size;

      661   volatile char *p;

      662 

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

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

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

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

      667 

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

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

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

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

      672   sp = (address)&sp;

      673 

      674   if (sp > bottom) {

      675     size = sp - bottom;

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

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

      678     p[0] = '\0';

      679   }

      680 }

      681 

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

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

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

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

      686 

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

      688     sigset_t mask_all, old_sigset;

      689     sigfillset(&mask_all);

      690     pthread_sigmask(SIG_SETMASK, &mask_all, &old_sigset);

      691     _expand_stack_to(addr);

      692     pthread_sigmask(SIG_SETMASK, &old_sigset, NULL);

      693     return true;

      694   }

      695   return false;

      696 }

      697 

      698 //////////////////////////////////////////////////////////////////////////////

      699 // create new thread

      700 

      701 static address highest_vm_reserved_address();

      702 

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

      704 static bool _thread_safety_check(Thread* thread) {

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

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

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

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

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

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

      711     //

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

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

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

      715     // collide with heap.

      716     //

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

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

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

      720     //

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

      722     //

      723     if (ThreadSafetyMargin > 0) {

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

      725 

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

      727       return stack_bottom - ThreadSafetyMargin >= highest_vm_reserved_address();

      728     } else {

      729       return true;

      730     }

      731   } else {

      732     // Floating stack LinuxThreads or NPTL:

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

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

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

      736     return true;

      737   }

      738 }

      739 

      740 // Thread start routine for all newly created threads

      741 static void *java_start(Thread *thread) {

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

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

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

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

      746   // processors with hyperthreading technology.

      747   static int counter = 0;

      748   int pid = os::current_process_id();

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

      750 

      751   ThreadLocalStorage::set_thread(thread);

      752 

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

      754   Monitor* sync = osthread->startThread_lock();

      755 

      756   // non floating stack LinuxThreads needs extra check, see above

      757   if (!_thread_safety_check(thread)) {

      758     // notify parent thread

      759     MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);

      760     osthread->set_state(ZOMBIE);

      761     sync->notify_all();

      762     return NULL;

      763   }

      764 

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

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

      767 

      768   if (UseNUMA) {

      769     int lgrp_id = os::numa_get_group_id();

      770     if (lgrp_id != -1) {

      771       thread->set_lgrp_id(lgrp_id);

      772     }

      773   }

      774   // initialize signal mask for this thread

      775   os::Linux::hotspot_sigmask(thread);

      776 

      777   // initialize floating point control register

      778   os::Linux::init_thread_fpu_state();

      779 

      780   // handshaking with parent thread

      781   {

      782     MutexLockerEx ml(sync, Mutex::_no_safepoint_check_flag);

      783 

      784     // notify parent thread

      785     osthread->set_state(INITIALIZED);

      786     sync->notify_all();

      787 

      788     // wait until os::start_thread()

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

      790       sync->wait(Mutex::_no_safepoint_check_flag);

      791     }

      792   }

      793 

      794   // call one more level start routine

      795   thread->run();

      796 

      797   return 0;

      798 }

      799 

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

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

      802 

      803   // Allocate the OSThread object

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

      805   if (osthread == NULL) {

      806     return false;

      807   }

      808 

      809   // set the correct thread state

      810   osthread->set_thread_type(thr_type);

      811 

      812   // Initial state is ALLOCATED but not INITIALIZED

      813   osthread->set_state(ALLOCATED);

      814 

      815   thread->set_osthread(osthread);

      816 

      817   // init thread attributes

      818   pthread_attr_t attr;

      819   pthread_attr_init(&attr);

      820   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);

      821 

      822   // stack size

      823   if (os::Linux::supports_variable_stack_size()) {

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

      825     if (stack_size == 0) {

      826       stack_size = os::Linux::default_stack_size(thr_type);

      827 

      828       switch (thr_type) {

      829       case os::java_thread:

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

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

      832         break;

      833       case os::compiler_thread:

      834         if (CompilerThreadStackSize > 0) {

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

      836           break;

      837         } // else fall through:

      838           // use VMThreadStackSize if CompilerThreadStackSize is not defined

      839       case os::vm_thread:

      840       case os::pgc_thread:

      841       case os::cgc_thread:

      842       case os::watcher_thread:

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

      844         break;

      845       }

      846     }

      847 

      848     stack_size = MAX2(stack_size, os::Linux::min_stack_allowed);

      849     pthread_attr_setstacksize(&attr, stack_size);

      850   } else {

      851     // let pthread_create() pick the default value.

      852   }

      853 

      854   // glibc guard page

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

      856 

      857   ThreadState state;

      858 

      859   {

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

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

      862     if (lock) {

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

      864     }

      865 

      866     pthread_t tid;

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

      868 

      869     pthread_attr_destroy(&attr);

      870 

      871     if (ret != 0) {

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

      873         perror("pthread_create()");

      874       }

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

      876       thread->set_osthread(NULL);

      877       delete osthread;

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

      879       return false;

      880     }

      881 

      882     // Store pthread info into the OSThread

      883     osthread->set_pthread_id(tid);

      884 

      885     // Wait until child thread is either initialized or aborted

      886     {

      887       Monitor* sync_with_child = osthread->startThread_lock();

      888       MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);

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

      890         sync_with_child->wait(Mutex::_no_safepoint_check_flag);

      891       }

      892     }

      893 

      894     if (lock) {

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

      896     }

      897   }

      898 

      899   // Aborted due to thread limit being reached

      900   if (state == ZOMBIE) {

      901       thread->set_osthread(NULL);

      902       delete osthread;

      903       return false;

      904   }

      905 

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

      907   // and is started higher up in the call chain

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

      909   return true;

      910 }

      911 

      912 /////////////////////////////////////////////////////////////////////////////

      913 // attach existing thread

      914 

      915 // bootstrap the main thread

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

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

      918   return create_attached_thread(thread);

      919 }

      920 

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

      922 #ifdef ASSERT

      923     thread->verify_not_published();

      924 #endif

      925 

      926   // Allocate the OSThread object

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

      928 

      929   if (osthread == NULL) {

      930     return false;

      931   }

      932 

      933   // Store pthread info into the OSThread

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

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

      936 

      937   // initialize floating point control register

      938   os::Linux::init_thread_fpu_state();

      939 

      940   // Initial thread state is RUNNABLE

      941   osthread->set_state(RUNNABLE);

      942 

      943   thread->set_osthread(osthread);

      944 

      945   if (UseNUMA) {

      946     int lgrp_id = os::numa_get_group_id();

      947     if (lgrp_id != -1) {

      948       thread->set_lgrp_id(lgrp_id);

      949     }

      950   }

      951 

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

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

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

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

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

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

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

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

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

      961 

      962     JavaThread *jt = (JavaThread *)thread;

      963     address addr = jt->stack_yellow_zone_base();

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

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

      966 

      967     osthread->set_expanding_stack();

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

      969     osthread->clear_expanding_stack();

      970   }

      971 

      972   // initialize signal mask for this thread

      973   // and save the caller's signal mask

      974   os::Linux::hotspot_sigmask(thread);

      975 

      976   return true;

      977 }

      978 

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

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

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

      982   Monitor* sync_with_child = osthread->startThread_lock();

      983   MutexLockerEx ml(sync_with_child, Mutex::_no_safepoint_check_flag);

      984   sync_with_child->notify();

      985 }

      986 

      987 // Free Linux resources related to the OSThread

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

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

      990 

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

      992     // Restore caller's signal mask

      993     sigset_t sigmask = osthread->caller_sigmask();

      994     pthread_sigmask(SIG_SETMASK, &sigmask, NULL);

      995    }

      996 

      997   delete osthread;

      998 }

      999 

     1000 //////////////////////////////////////////////////////////////////////////////

     1001 // thread local storage

     1002 

     1003 int os::allocate_thread_local_storage() {

     1004   pthread_key_t key;

     1005   int rslt = pthread_key_create(&key, NULL);

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

     1007   return (int)key;

     1008 }

     1009 

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

     1011 // on VM exit.

     1012 void os::free_thread_local_storage(int index) {

     1013   int rslt = pthread_key_delete((pthread_key_t)index);

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

     1015 }

     1016 

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

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

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

     1020 }

     1021 

     1022 extern "C" Thread* get_thread() {

     1023   return ThreadLocalStorage::thread();

     1024 }

     1025 

     1026 //////////////////////////////////////////////////////////////////////////////

     1027 // initial thread

     1028 

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

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

     1031   char dummy;

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

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

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

     1035   assert(initial_thread_stack_bottom() != NULL &&

     1036          initial_thread_stack_size()   != 0,

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

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

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

     1040        return true;

     1041   else return false;

     1042 }

     1043 

     1044 // Find the virtual memory area that contains addr

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

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

     1047   if (fp) {

     1048     address low, high;

     1049     while (!feof(fp)) {

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

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

     1052            if (vma_low)  *vma_low  = low;

     1053            if (vma_high) *vma_high = high;

     1054            fclose (fp);

     1055            return true;

     1056         }

     1057       }

     1058       for (;;) {

     1059         int ch = fgetc(fp);

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

     1061       }

     1062     }

     1063     fclose(fp);

     1064   }

     1065   return false;

     1066 }

     1067 

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

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

     1070 // bogus value for initial thread.

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

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

     1073   size_t stack_size;

     1074   struct rlimit rlim;

     1075   getrlimit(RLIMIT_STACK, &rlim);

     1076   stack_size = rlim.rlim_cur;

     1077 

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

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

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

     1081   stack_size -= 2 * page_size();

     1082 

     1083   // 4441425: avoid crash with "unlimited" stack size on SuSE 7.1 or Redhat

     1084   //   7.1, in both cases we will get 2G in return value.

     1085   // 4466587: glibc 2.2.x compiled w/o "--enable-kernel=2.4.0" (RH 7.0,

     1086   //   SuSE 7.2, Debian) can not handle alternate signal stack correctly

     1087   //   for initial thread if its stack size exceeds 6M. Cap it at 2M,

     1088   //   in case other parts in glibc still assumes 2M max stack size.

     1089   // FIXME: alt signal stack is gone, maybe we can relax this constraint?

     1090 #ifndef IA64

     1091   if (stack_size > 2 * K * K) stack_size = 2 * K * K;

     1092 #else

     1093   // Problem still exists RH7.2 (IA64 anyway) but 2MB is a little small

     1094   if (stack_size > 4 * K * K) stack_size = 4 * K * K;

     1095 #endif

     1096 

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

     1098   //

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

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

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

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

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

     1104   //

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

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

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

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

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

     1110   //

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

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

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

     1114 

     1115   uintptr_t stack_start;

     1116 

     1117   // try __libc_stack_end first

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

     1119   if (p && *p) {

     1120     stack_start = *p;

     1121   } else {

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

     1123     FILE *fp;

     1124     int pid;

     1125     char state;

     1126     int ppid;

     1127     int pgrp;

     1128     int session;

     1129     int nr;

     1130     int tpgrp;

     1131     unsigned long flags;

     1132     unsigned long minflt;

     1133     unsigned long cminflt;

     1134     unsigned long majflt;

     1135     unsigned long cmajflt;

     1136     unsigned long utime;

     1137     unsigned long stime;

     1138     long cutime;

     1139     long cstime;

     1140     long prio;

     1141     long nice;

     1142     long junk;

     1143     long it_real;

     1144     uintptr_t start;

     1145     uintptr_t vsize;

     1146     intptr_t rss;

     1147     uintptr_t rsslim;

     1148     uintptr_t scodes;

     1149     uintptr_t ecode;

     1150     int i;

     1151 

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

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

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

     1155     char stat[2048];

     1156     int statlen;

     1157 

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

     1159     if (fp) {

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

     1161       stat[statlen] = '\0';

     1162       fclose(fp);

     1163 

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

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

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

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

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

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

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

     1171 

     1172       i = 0;

     1173       if (s) {

     1174         // Skip blank chars

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

     1176 

     1177 #define _UFM UINTX_FORMAT

     1178 #define _DFM INTX_FORMAT

     1179 

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

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

     1182         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,

     1183              &state,          /* 3  %c  */

     1184              &ppid,           /* 4  %d  */

     1185              &pgrp,           /* 5  %d  */

     1186              &session,        /* 6  %d  */

     1187              &nr,             /* 7  %d  */

     1188              &tpgrp,          /* 8  %d  */

     1189              &flags,          /* 9  %lu  */

     1190              &minflt,         /* 10 %lu  */

     1191              &cminflt,        /* 11 %lu  */

     1192              &majflt,         /* 12 %lu  */

     1193              &cmajflt,        /* 13 %lu  */

     1194              &utime,          /* 14 %lu  */

     1195              &stime,          /* 15 %lu  */

     1196              &cutime,         /* 16 %ld  */

     1197              &cstime,         /* 17 %ld  */

     1198              &prio,           /* 18 %ld  */

     1199              &nice,           /* 19 %ld  */

     1200              &junk,           /* 20 %ld  */

     1201              &it_real,        /* 21 %ld  */

     1202              &start,          /* 22 UINTX_FORMAT */

     1203              &vsize,          /* 23 UINTX_FORMAT */

     1204              &rss,            /* 24 INTX_FORMAT  */

     1205              &rsslim,         /* 25 UINTX_FORMAT */

     1206              &scodes,         /* 26 UINTX_FORMAT */

     1207              &ecode,          /* 27 UINTX_FORMAT */

     1208              &stack_start);   /* 28 UINTX_FORMAT */

     1209       }

     1210 

     1211 #undef _UFM

     1212 #undef _DFM

     1213 

     1214       if (i != 28 - 2) {

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

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

     1217          // embedded case.

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

     1219          stack_start = (uintptr_t) &rlim;

     1220       }

     1221     } else {

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

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

     1224       // most cases, so don't abort:

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

     1226       stack_start = (uintptr_t) &rlim;

     1227     }

     1228   }

     1229 

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

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

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

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

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

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

     1236 

     1237   uintptr_t stack_top;

     1238   address low, high;

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

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

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

     1242     stack_top = (uintptr_t)high;

     1243   } else {

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

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

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

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

     1248     // guard page outside stack.

     1249     stack_top = stack_start;

     1250     stack_size -= 16 * page_size();

     1251   }

     1252 

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

     1254   stack_top = align_size_up(stack_top, page_size());

     1255 

     1256   if (max_size && stack_size > max_size) {

     1257      _initial_thread_stack_size = max_size;

     1258   } else {

     1259      _initial_thread_stack_size = stack_size;

     1260   }

     1261 

     1262   _initial_thread_stack_size = align_size_down(_initial_thread_stack_size, page_size());

     1263   _initial_thread_stack_bottom = (address)stack_top - _initial_thread_stack_size;

     1264 }

     1265 

     1266 ////////////////////////////////////////////////////////////////////////////////

     1267 // time support

     1268 

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

     1270 // Used by VMSelfDestructTimer and the MemProfiler.

     1271 double os::elapsedTime() {

     1272 

     1273   return (double)(os::elapsed_counter()) * 0.000001;

     1274 }

     1275 

     1276 jlong os::elapsed_counter() {

     1277   timeval time;

     1278   int status = gettimeofday(&time, NULL);

     1279   return jlong(time.tv_sec) * 1000 * 1000 + jlong(time.tv_usec) - initial_time_count;

     1280 }

     1281 

     1282 jlong os::elapsed_frequency() {

     1283   return (1000 * 1000);

     1284 }

     1285 

     1286 // For now, we say that linux does not support vtime.  I have no idea

     1287 // whether it can actually be made to (DLD, 9/13/05).

     1288 

     1289 bool os::supports_vtime() { return false; }

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

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

     1292 double os::elapsedVTime() {

     1293   // better than nothing, but not much

     1294   return elapsedTime();

     1295 }

     1296 

     1297 jlong os::javaTimeMillis() {

     1298   timeval time;

     1299   int status = gettimeofday(&time, NULL);

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

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

     1302 }

     1303 

     1304 #ifndef CLOCK_MONOTONIC

     1305 #define CLOCK_MONOTONIC (1)

     1306 #endif

     1307 

     1308 void os::Linux::clock_init() {

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

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

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

     1312   if (handle == NULL) {

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

     1314   }

     1315 

     1316   if (handle) {

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

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

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

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

     1321     if (clock_getres_func && clock_gettime_func) {

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

     1323       // early implementations simply return kernel jiffies (updated every

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

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

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

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

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

     1329       // won't be a problem.

     1330       struct timespec res;

     1331       struct timespec tp;

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

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

     1334         // yes, monotonic clock is supported

     1335         _clock_gettime = clock_gettime_func;

     1336       } else {

     1337         // close librt if there is no monotonic clock

     1338         dlclose(handle);

     1339       }

     1340     }

     1341   }

     1342 }

     1343 

     1344 #ifndef SYS_clock_getres

     1345 

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

     1347 #define SYS_clock_getres IA32_ONLY(266)  AMD64_ONLY(229)

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

     1349 #else

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

     1351 #define sys_clock_getres(x,y)  -1

     1352 #endif

     1353 

     1354 #else

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

     1356 #endif

     1357 

     1358 void os::Linux::fast_thread_clock_init() {

     1359   if (!UseLinuxPosixThreadCPUClocks) {

     1360     return;

     1361   }

     1362   clockid_t clockid;

     1363   struct timespec tp;

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

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

     1366 

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

     1368   // the sys_clock_getres() returns 0 error code.

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

     1370   // clock (CLOCK_THREAD_CPUTIME_ID) but not the clocks

     1371   // returned by the pthread_getcpuclockid().

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

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

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

     1375 

     1376   if(pthread_getcpuclockid_func &&

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

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

     1379 

     1380     _supports_fast_thread_cpu_time = true;

     1381     _pthread_getcpuclockid = pthread_getcpuclockid_func;

     1382   }

     1383 }

     1384 

     1385 jlong os::javaTimeNanos() {

     1386   if (Linux::supports_monotonic_clock()) {

     1387     struct timespec tp;

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

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

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

     1391     return result;

     1392   } else {

     1393     timeval time;

     1394     int status = gettimeofday(&time, NULL);

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

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

     1397     return 1000 * usecs;

     1398   }

     1399 }

     1400 

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

     1402   if (Linux::supports_monotonic_clock()) {

     1403     info_ptr->max_value = ALL_64_BITS;

     1404 

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

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

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

     1408   } else {

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

     1410     info_ptr->max_value = ALL_64_BITS;

     1411 

     1412     // gettimeofday is a real time clock so it skips

     1413     info_ptr->may_skip_backward = true;

     1414     info_ptr->may_skip_forward = true;

     1415   }

     1416 

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

     1418 }

     1419 

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

     1421 // arbitrary fixed point in the past.

     1422 bool os::getTimesSecs(double* process_real_time,

     1423                       double* process_user_time,

     1424                       double* process_system_time) {

     1425   struct tms ticks;

     1426   clock_t real_ticks = times(&ticks);

     1427 

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

     1429     return false;

     1430   } else {

     1431     double ticks_per_second = (double) clock_tics_per_sec;

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

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

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

     1435 

     1436     return true;

     1437   }

     1438 }

     1439 

     1440 

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

     1442   struct tm t;

     1443   time_t long_time;

     1444   time(&long_time);

     1445   localtime_r(&long_time, &t);

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

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

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

     1449   return buf;

     1450 }

     1451 

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

     1453   return localtime_r(clock, res);

     1454 }

     1455 

     1456 ////////////////////////////////////////////////////////////////////////////////

     1457 // runtime exit support

     1458 

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

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

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

     1462 void os::shutdown() {

     1463 

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

     1465   perfMemory_exit();

     1466 

     1467   // needs to remove object in file system

     1468   AttachListener::abort();

     1469 

     1470   // flush buffered output, finish log files

     1471   ostream_abort();

     1472 

     1473   // Check for abort hook

     1474   abort_hook_t abort_hook = Arguments::abort_hook();

     1475   if (abort_hook != NULL) {

     1476     abort_hook();

     1477   }

     1478 

     1479 }

     1480 

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

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

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

     1484 void os::abort(bool dump_core) {

     1485   os::shutdown();

     1486   if (dump_core) {

     1487 #ifndef PRODUCT

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

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

     1490     char buf[16];

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

     1492     out.print_raw_cr(buf);

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

     1494 #endif

     1495     ::abort(); // dump core

     1496   }

     1497 

     1498   ::exit(1);

     1499 }

     1500 

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

     1502 void os::die() {

     1503   // _exit() on LinuxThreads only kills current thread

     1504   ::abort();

     1505 }

     1506 

     1507 // unused on linux for now.

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

     1509 

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

     1511 int os::current_process_id() {

     1512 

     1513   // Under the old linux thread library, linux gives each thread

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

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

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

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

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

     1519   // that starts the vm 'process'.

     1520 

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

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

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

     1524 

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

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

     1527   // OSThread::thread_id() method in osThread_linux.hpp file

     1528 

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

     1530 }

     1531 

     1532 // DLL functions

     1533 

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

     1535 

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

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

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

     1539 

     1540 static bool file_exists(const char* filename) {

     1541   struct stat statbuf;

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

     1543     return false;

     1544   }

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

     1546 }

     1547 

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

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

     1550   // Copied from libhpi

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

     1552 

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

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

     1555     *buffer = '\0';

     1556     return;

     1557   }

     1558 

     1559   if (pnamelen == 0) {

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

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

     1562     int n;

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

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

     1565       // Really shouldn't be NULL, but check can't hurt

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

     1567         continue; // skip the empty path values

     1568       }

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

     1570       if (file_exists(buffer)) {

     1571         break;

     1572       }

     1573     }

     1574     // release the storage

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

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

     1577         FREE_C_HEAP_ARRAY(char, pelements[i]);

     1578       }

     1579     }

     1580     if (pelements != NULL) {

     1581       FREE_C_HEAP_ARRAY(char*, pelements);

     1582     }

     1583   } else {

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

     1585   }

     1586 }

     1587 

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

     1589   return getcwd(buf, buflen);

     1590 }

     1591 

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

     1593 bool os::address_is_in_vm(address addr) {

     1594   static address libjvm_base_addr;

     1595   Dl_info dlinfo;

     1596 

     1597   if (libjvm_base_addr == NULL) {

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

     1599     libjvm_base_addr = (address)dlinfo.dli_fbase;

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

     1601   }

     1602 

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

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

     1605   }

     1606 

     1607   return false;

     1608 }

     1609 

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

     1611                                       int buflen, int *offset) {

     1612   Dl_info dlinfo;

     1613 

     1614   if (dladdr((void*)addr, &dlinfo) && dlinfo.dli_sname != NULL) {

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

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

     1617     return true;

     1618   } else {

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

     1620     if (offset) *offset = -1;

     1621     return false;

     1622   }

     1623 }

     1624 

     1625 struct _address_to_library_name {

     1626   address addr;          // input : memory address

     1627   size_t  buflen;        //         size of fname

     1628   char*   fname;         // output: library name

     1629   address base;          //         library base addr

     1630 };

     1631 

     1632 static int address_to_library_name_callback(struct dl_phdr_info *info,

     1633                                             size_t size, void *data) {

     1634   int i;

     1635   bool found = false;

     1636   address libbase = NULL;

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

     1638 

     1639   // iterate through all loadable segments

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

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

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

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

     1644       // segments.

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

     1646         libbase = segbase;

     1647       }

     1648       // see if 'addr' is within current segment

     1649       if (segbase <= d->addr &&

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

     1651         found = true;

     1652       }

     1653     }

     1654   }

     1655 

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

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

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

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

     1660     d->base = libbase;

     1661     if (d->fname) {

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

     1663     }

     1664     return 1;

     1665   }

     1666   return 0;

     1667 }

     1668 

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

     1670                                      int buflen, int* offset) {

     1671   Dl_info dlinfo;

     1672   struct _address_to_library_name data;

     1673 

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

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

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

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

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

     1679   data.addr = addr;

     1680   data.fname = buf;

     1681   data.buflen = buflen;

     1682   data.base = NULL;

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

     1684 

     1685   if (rslt) {

     1686      // buf already contains library name

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

     1688      return true;

     1689   } else if (dladdr((void*)addr, &dlinfo)){

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

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

     1692      return true;

     1693   } else {

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

     1695      if (offset) *offset = -1;

     1696      return false;

     1697   }

     1698 }

     1699 

     1700   // Loads .dll/.so and

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

     1702   // same architecture as Hotspot is running on

     1703 

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

     1705 {

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

     1707   if (result != NULL) {

     1708     // Successful loading

     1709     return result;

     1710   }

     1711 

     1712   Elf32_Ehdr elf_head;

     1713 

     1714   // Read system error message into ebuf

     1715   // It may or may not be overwritten below

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

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

     1718   int diag_msg_max_length=ebuflen-strlen(ebuf);

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

     1720 

     1721   if (diag_msg_max_length==0) {

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

     1723     return NULL;

     1724   }

     1725 

     1726 

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

     1728 

     1729   if (file_descriptor < 0) {

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

     1731     return NULL;

     1732   }

     1733 

     1734   bool failed_to_read_elf_head=

     1735     (sizeof(elf_head)!=

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

     1737 

     1738   ::close(file_descriptor);

     1739   if (failed_to_read_elf_head) {

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

     1741     return NULL;

     1742   }

     1743 

     1744   typedef struct {

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

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

     1747     char        elf_class;    // 32 or 64 bit

     1748     char        endianess;    // MSB or LSB

     1749     char*       name;         // String representation

     1750   } arch_t;

     1751 

     1752   #ifndef EM_486

     1753   #define EM_486          6               /* Intel 80486 */

     1754   #endif

     1755 

     1756   static const arch_t arch_array[]={

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

     1773   };

     1774 

     1775   #if  (defined IA32)

     1776     static  Elf32_Half running_arch_code=EM_386;

     1777   #elif   (defined AMD64)

     1778     static  Elf32_Half running_arch_code=EM_X86_64;

     1779   #elif  (defined IA64)

     1780     static  Elf32_Half running_arch_code=EM_IA_64;

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

     1782     static  Elf32_Half running_arch_code=EM_SPARCV9;

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

     1784     static  Elf32_Half running_arch_code=EM_SPARC;

     1785   #elif  (defined __powerpc64__)

     1786     static  Elf32_Half running_arch_code=EM_PPC64;

     1787   #elif  (defined __powerpc__)

     1788     static  Elf32_Half running_arch_code=EM_PPC;

     1789   #elif  (defined ARM)

     1790     static  Elf32_Half running_arch_code=EM_ARM;

     1791   #elif  (defined S390)

     1792     static  Elf32_Half running_arch_code=EM_S390;

     1793   #elif  (defined ALPHA)

     1794     static  Elf32_Half running_arch_code=EM_ALPHA;

     1795   #elif  (defined MIPSEL)

     1796     static  Elf32_Half running_arch_code=EM_MIPS_RS3_LE;

     1797   #elif  (defined PARISC)

     1798     static  Elf32_Half running_arch_code=EM_PARISC;

     1799   #elif  (defined MIPS)

     1800     static  Elf32_Half running_arch_code=EM_MIPS;

     1801   #elif  (defined M68K)

     1802     static  Elf32_Half running_arch_code=EM_68K;

     1803   #else

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

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

     1806   #endif

     1807 

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

     1809   // Obtain string descriptions for architectures

     1810 

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

     1812   int running_arch_index=-1;

     1813 

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

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

     1816       running_arch_index    = i;

     1817     }

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

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

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

     1821     }

     1822   }

     1823 

     1824   assert(running_arch_index != -1,

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

     1826   if (running_arch_index == -1) {

     1827     // Even though running architecture detection failed

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

     1829     return NULL;

     1830   }

     1831 

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

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

     1834     return NULL;

     1835   }

     1836 

     1837 #ifndef S390

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

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

     1840     return NULL;

     1841   }

     1842 #endif // !S390

     1843 

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

     1845     if ( lib_arch.name!=NULL ) {

     1846       ::snprintf(diag_msg_buf, diag_msg_max_length-1,

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

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

     1849     } else {

     1850       ::snprintf(diag_msg_buf, diag_msg_max_length-1,

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

     1852         lib_arch.code,

     1853         arch_array[running_arch_index].name);

     1854     }

     1855   }

     1856 

     1857   return NULL;

     1858 }

     1859 

     1860 /*

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

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

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

     1864  */

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

     1866   pthread_mutex_lock(&dl_mutex);

     1867   void* res = dlsym(handle, name);

     1868   pthread_mutex_unlock(&dl_mutex);

     1869   return res;

     1870 }

     1871 

     1872 

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

     1874   int fd = open(filename, O_RDONLY);

     1875   if (fd == -1) {

     1876      return false;

     1877   }

     1878 

     1879   char buf[32];

     1880   int bytes;

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

     1882     st->print_raw(buf, bytes);

     1883   }

     1884 

     1885   close(fd);

     1886 

     1887   return true;

     1888 }

     1889 

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

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

     1892 

     1893    char fname[32];

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

     1895 

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

     1897 

     1898    if (!_print_ascii_file(fname, st)) {

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

     1900    }

     1901 }

     1902 

     1903 

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

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

     1906 

     1907   // Try to identify popular distros.

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

     1909   // the OS version string. Some have more than one /etc/XXX-release file

     1910   // (e.g. Mandrake has both /etc/mandrake-release and /etc/redhat-release.),

     1911   // so the order is important.

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

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

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

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

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

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

     1918       !_print_ascii_file("/etc/debian_version", st) &&

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

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

     1921       st->print("Linux");

     1922   }

     1923   st->cr();

     1924 

     1925   // kernel

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

     1927   struct utsname name;

     1928   uname(&name);

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

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

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

     1932   st->print(name.machine);

     1933   st->cr();

     1934 

     1935   // Print warning if unsafe chroot environment detected

     1936   if (unsafe_chroot_detected) {

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

     1938     st->print_cr(unstable_chroot_error);

     1939   }

     1940 

     1941   // libc, pthread

     1942   st->print("libc:");

     1943   st->print(os::Linux::glibc_version()); st->print(" ");

     1944   st->print(os::Linux::libpthread_version()); st->print(" ");

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

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

     1947   }

     1948   st->cr();

     1949 

     1950   // rlimit

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

     1952   struct rlimit rlim;

     1953 

     1954   st->print(" STACK ");

     1955   getrlimit(RLIMIT_STACK, &rlim);

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

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

     1958 

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

     1960   getrlimit(RLIMIT_CORE, &rlim);

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

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

     1963 

     1964   st->print(", NPROC ");

     1965   getrlimit(RLIMIT_NPROC, &rlim);

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

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

     1968 

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

     1970   getrlimit(RLIMIT_NOFILE, &rlim);

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

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

     1973 

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

     1975   getrlimit(RLIMIT_AS, &rlim);

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

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

     1978   st->cr();

     1979 

     1980   // load average

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

     1982   double loadavg[3];

     1983   os::loadavg(loadavg, 3);

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

     1985   st->cr();

     1986 

     1987   // meminfo

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

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

     1990   st->cr();

     1991 }

     1992 

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

     1994 

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

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

     1997 

     1998   // values in struct sysinfo are "unsigned long"

     1999   struct sysinfo si;

     2000   sysinfo(&si);

     2001 

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

     2003             os::physical_memory() >> 10);

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

     2005             os::available_memory() >> 10);

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

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

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

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

     2010   st->cr();

     2011 }

     2012 

     2013 // Taken from /usr/include/bits/siginfo.h  Supposed to be architecture specific

     2014 // but they're the same for all the linux arch that we support

     2015 // and they're the same for solaris but there's no common place to put this.

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

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

     2018                           "ILL_COPROC", "ILL_BADSTK" };

     2019 

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

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

     2022                           "FPE_FLTINV", "FPE_FLTSUB", "FPE_FLTDEN" };

     2023 

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

     2025 

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

     2027 

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

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

     2030 

     2031   const int buflen = 100;

     2032   char buf[buflen];

     2033   siginfo_t *si = (siginfo_t*)siginfo;

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

     2035   if (si->si_errno != 0 && strerror_r(si->si_errno, buf, buflen) == 0) {

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

     2037   } else {

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

     2039   }

     2040   const int c = si->si_code;

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

     2042   switch (si->si_signo) {

     2043   case SIGILL:

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

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

     2046     break;

     2047   case SIGFPE:

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

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

     2050     break;

     2051   case SIGSEGV:

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

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

     2054     break;

     2055   case SIGBUS:

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

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

     2058     break;

     2059   default:

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

     2061     // no si_addr

     2062   }

     2063 

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

     2065       UseSharedSpaces) {

     2066     FileMapInfo* mapinfo = FileMapInfo::current_info();

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

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

     2069                 " Mapped file inaccessible during execution, "      \

     2070                 " possible disk/network problem.");

     2071     }

     2072   }

     2073   st->cr();

     2074 }

     2075 

     2076 

     2077 static void print_signal_handler(outputStream* st, int sig,

     2078                                  char* buf, size_t buflen);

     2079 

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

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

     2082   print_signal_handler(st, SIGSEGV, buf, buflen);

     2083   print_signal_handler(st, SIGBUS , buf, buflen);

     2084   print_signal_handler(st, SIGFPE , buf, buflen);

     2085   print_signal_handler(st, SIGPIPE, buf, buflen);

     2086   print_signal_handler(st, SIGXFSZ, buf, buflen);

     2087   print_signal_handler(st, SIGILL , buf, buflen);

     2088   print_signal_handler(st, INTERRUPT_SIGNAL, buf, buflen);

     2089   print_signal_handler(st, SR_signum, buf, buflen);

     2090   print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);

     2091   print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);

     2092   print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);

     2093   print_signal_handler(st, BREAK_SIGNAL, buf, buflen);

     2094 }

     2095 

     2096 static char saved_jvm_path[MAXPATHLEN] = {0};

     2097 

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

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

     2100   // Error checking.

     2101   if (buflen < MAXPATHLEN) {

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

     2103     buf[0] = '\0';

     2104     return;

     2105   }

     2106   // Lazy resolve the path to current module.

     2107   if (saved_jvm_path[0] != 0) {

     2108     strcpy(buf, saved_jvm_path);

     2109     return;

     2110   }

     2111 

     2112   char dli_fname[MAXPATHLEN];

     2113   bool ret = dll_address_to_library_name(

     2114                 CAST_FROM_FN_PTR(address, os::jvm_path),

     2115                 dli_fname, sizeof(dli_fname), NULL);

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

     2117   char *rp = realpath(dli_fname, buf);

     2118   if (rp == NULL)

     2119     return;

     2120 

     2121   if (strcmp(Arguments::sun_java_launcher(), "gamma") == 0) {

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

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

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

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

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

     2127     // fake suffix hotspot/libjvm.so).

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

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

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

     2131         /* empty */ ;

     2132     }

     2133 

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

     2135       // Look for JAVA_HOME in the environment.

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

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

     2138         char* jrelib_p;

     2139         int len;

     2140 

     2141         // Check the current module name "libjvm.so" or "libjvm_g.so".

     2142         p = strrchr(buf, '/');

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

     2144         p = strstr(p, "_g") ? "_g" : "";

     2145 

     2146         rp = realpath(java_home_var, buf);

     2147         if (rp == NULL)

     2148           return;

     2149 

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

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

     2152         len = strlen(buf);

     2153         jrelib_p = buf + len;

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

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

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

     2157         }

     2158 

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

     2160           // Use current module name "libjvm[_g].so" instead of

     2161           // "libjvm"debug_only("_g")".so" since for fastdebug version

     2162           // we should have "libjvm.so" but debug_only("_g") adds "_g"!

     2163           // It is used when we are choosing the HPI library's name

     2164           // "libhpi[_g].so" in hpi::initialize_get_interface().

     2165           len = strlen(buf);

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

     2167         } else {

     2168           // Go back to path of .so

     2169           rp = realpath(dli_fname, buf);

     2170           if (rp == NULL)

     2171             return;

     2172         }

     2173       }

     2174     }

     2175   }

     2176 

     2177   strcpy(saved_jvm_path, buf);

     2178 }

     2179 

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

     2181   // no prefix required, not even "_"

     2182 }

     2183 

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

     2185   // no suffix required

     2186 }

     2187 

     2188 ////////////////////////////////////////////////////////////////////////////////

     2189 // sun.misc.Signal support

     2190 

     2191 static volatile jint sigint_count = 0;

     2192 

     2193 static void

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

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

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

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

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

     2199       return;

     2200 

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

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

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

     2204      os::die();

     2205   }

     2206 

     2207   os::signal_notify(sig);

     2208 }

     2209 

     2210 void* os::user_handler() {

     2211   return CAST_FROM_FN_PTR(void*, UserHandler);

     2212 }

     2213 

     2214 extern "C" {

     2215   typedef void (*sa_handler_t)(int);

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

     2217 }

     2218 

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

     2220   struct sigaction sigAct, oldSigAct;

     2221 

     2222   sigfillset(&(sigAct.sa_mask));

     2223   sigAct.sa_flags   = SA_RESTART|SA_SIGINFO;

     2224   sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);

     2225 

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

     2227     // -1 means registration failed

     2228     return (void *)-1;

     2229   }

     2230 

     2231   return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);

     2232 }

     2233 

     2234 void os::signal_raise(int signal_number) {

     2235   ::raise(signal_number);

     2236 }

     2237 

     2238 /*

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

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

     2241  */

     2242 

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

     2244 int os::sigexitnum_pd() {

     2245   return NSIG;

     2246 }

     2247 

     2248 // a counter for each possible signal value

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

     2250 

     2251 // Linux(POSIX) specific hand shaking semaphore.

     2252 static sem_t sig_sem;

     2253 

     2254 void os::signal_init_pd() {

     2255   // Initialize signal structures

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

     2257 

     2258   // Initialize signal semaphore

     2259   ::sem_init(&sig_sem, 0, 0);

     2260 }

     2261 

     2262 void os::signal_notify(int sig) {

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

     2264   ::sem_post(&sig_sem);

     2265 }

     2266 

     2267 static int check_pending_signals(bool wait) {

     2268   Atomic::store(0, &sigint_count);

     2269   for (;;) {

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

     2271       jint n = pending_signals[i];

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

     2273         return i;

     2274       }

     2275     }

     2276     if (!wait) {

     2277       return -1;

     2278     }

     2279     JavaThread *thread = JavaThread::current();

     2280     ThreadBlockInVM tbivm(thread);

     2281 

     2282     bool threadIsSuspended;

     2283     do {

     2284       thread->set_suspend_equivalent();

     2285       // cleared by handle_special_suspend_equivalent_condition() or java_suspend_self()

     2286       ::sem_wait(&sig_sem);

     2287 

     2288       // were we externally suspended while we were waiting?

     2289       threadIsSuspended = thread->handle_special_suspend_equivalent_condition();

     2290       if (threadIsSuspended) {

     2291         //

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

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

     2294         // while suspended because that would surprise the thread that

     2295         // suspended us.

     2296         //

     2297         ::sem_post(&sig_sem);

     2298 

     2299         thread->java_suspend_self();

     2300       }

     2301     } while (threadIsSuspended);

     2302   }

     2303 }

     2304 

     2305 int os::signal_lookup() {

     2306   return check_pending_signals(false);

     2307 }

     2308 

     2309 int os::signal_wait() {

     2310   return check_pending_signals(true);

     2311 }

     2312 

     2313 ////////////////////////////////////////////////////////////////////////////////

     2314 // Virtual Memory

     2315 

     2316 int os::vm_page_size() {

     2317   // Seems redundant as all get out

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

     2319   return os::Linux::page_size();

     2320 }

     2321 

     2322 // Solaris allocates memory by pages.

     2323 int os::vm_allocation_granularity() {

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

     2325   return os::Linux::page_size();

     2326 }

     2327 

     2328 // Rationale behind this function:

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

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

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

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

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

     2334 void linux_wrap_code(char* base, size_t size) {

     2335   static volatile jint cnt = 0;

     2336 

     2337   if (!UseOprofile) {

     2338     return;

     2339   }

     2340 

     2341   char buf[PATH_MAX+1];

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

     2343 

     2344   snprintf(buf, sizeof(buf), "%s/hs-vm-%d-%d",

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

     2346   unlink(buf);

     2347 

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

     2349 

     2350   if (fd != -1) {

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

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

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

     2354         mmap(base, size,

     2355              PROT_READ|PROT_WRITE|PROT_EXEC,

     2356              MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE, fd, 0);

     2357       }

     2358     }

     2359     close(fd);

     2360     unlink(buf);

     2361   }

     2362 }

     2363 

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

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

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

     2367 //       problem.

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

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

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

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

     2372   return res != (uintptr_t) MAP_FAILED;

     2373 }

     2374 

     2375 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,

     2376                        bool exec) {

     2377   return commit_memory(addr, size, exec);

     2378 }

     2379 

     2380 void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) { }

     2381 

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

     2383   ::mmap(addr, bytes, PROT_READ | PROT_WRITE,

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

     2385 }

     2386 

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

     2388   Linux::numa_interleave_memory(addr, bytes);

     2389 }

     2390 

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

     2392   Linux::numa_tonode_memory(addr, bytes, lgrp_hint);

     2393 }

     2394 

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

     2396 

     2397 size_t os::numa_get_groups_num() {

     2398   int max_node = Linux::numa_max_node();

     2399   return max_node > 0 ? max_node + 1 : 1;

     2400 }

     2401 

     2402 int os::numa_get_group_id() {

     2403   int cpu_id = Linux::sched_getcpu();

     2404   if (cpu_id != -1) {

     2405     int lgrp_id = Linux::get_node_by_cpu(cpu_id);

     2406     if (lgrp_id != -1) {

     2407       return lgrp_id;

     2408     }

     2409   }

     2410   return 0;

     2411 }

     2412 

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

     2414   for (size_t i = 0; i < size; i++) {

     2415     ids[i] = i;

     2416   }

     2417   return size;

     2418 }

     2419 

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

     2421   return false;

     2422 }

     2423 

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

     2425   return end;

     2426 }

     2427 

     2428 extern "C" void numa_warn(int number, char *where, ...) { }

     2429 extern "C" void numa_error(char *where) { }

     2430 

     2431 

     2432 // If we are running with libnuma version > 2, then we should

     2433 // be trying to use symbols with versions 1.1

     2434 // If we are running with earlier version, which did not have symbol versions,

     2435 // we should use the base version.

     2436 void* os::Linux::libnuma_dlsym(void* handle, const char *name) {

     2437   void *f = dlvsym(handle, name, "libnuma_1.1");

     2438   if (f == NULL) {

     2439     f = dlsym(handle, name);

     2440   }

     2441   return f;

     2442 }

     2443 

     2444 bool os::Linux::libnuma_init() {

     2445   // sched_getcpu() should be in libc.

     2446   set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t,

     2447                                   dlsym(RTLD_DEFAULT, "sched_getcpu")));

     2448 

     2449   if (sched_getcpu() != -1) { // Does it work?

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

     2451     if (handle != NULL) {

     2452       set_numa_node_to_cpus(CAST_TO_FN_PTR(numa_node_to_cpus_func_t,

     2453                                            libnuma_dlsym(handle, "numa_node_to_cpus")));

     2454       set_numa_max_node(CAST_TO_FN_PTR(numa_max_node_func_t,

     2455                                        libnuma_dlsym(handle, "numa_max_node")));

     2456       set_numa_available(CAST_TO_FN_PTR(numa_available_func_t,

     2457                                         libnuma_dlsym(handle, "numa_available")));

     2458       set_numa_tonode_memory(CAST_TO_FN_PTR(numa_tonode_memory_func_t,

     2459                                             libnuma_dlsym(handle, "numa_tonode_memory")));

     2460       set_numa_interleave_memory(CAST_TO_FN_PTR(numa_interleave_memory_func_t,

     2461                                             libnuma_dlsym(handle, "numa_interleave_memory")));

     2462 

     2463 

     2464       if (numa_available() != -1) {

     2465         set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes"));

     2466         // Create a cpu -> node mapping

     2467         _cpu_to_node = new (ResourceObj::C_HEAP) GrowableArray<int>(0, true);

     2468         rebuild_cpu_to_node_map();

     2469         return true;

     2470       }

     2471     }

     2472   }

     2473   return false;

     2474 }

     2475 

     2476 // rebuild_cpu_to_node_map() constructs a table mapping cpud id to node id.

     2477 // The table is later used in get_node_by_cpu().

     2478 void os::Linux::rebuild_cpu_to_node_map() {

     2479   const size_t NCPUS = 32768; // Since the buffer size computation is very obscure

     2480                               // in libnuma (possible values are starting from 16,

     2481                               // and continuing up with every other power of 2, but less

     2482                               // than the maximum number of CPUs supported by kernel), and

     2483                               // is a subject to change (in libnuma version 2 the requirements

     2484                               // are more reasonable) we'll just hardcode the number they use

     2485                               // in the library.

     2486   const size_t BitsPerCLong = sizeof(long) * CHAR_BIT;

     2487 

     2488   size_t cpu_num = os::active_processor_count();

     2489   size_t cpu_map_size = NCPUS / BitsPerCLong;

     2490   size_t cpu_map_valid_size =

     2491     MIN2((cpu_num + BitsPerCLong - 1) / BitsPerCLong, cpu_map_size);

     2492 

     2493   cpu_to_node()->clear();

     2494   cpu_to_node()->at_grow(cpu_num - 1);

     2495   size_t node_num = numa_get_groups_num();

     2496 

     2497   unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size);

     2498   for (size_t i = 0; i < node_num; i++) {

     2499     if (numa_node_to_cpus(i, cpu_map, cpu_map_size * sizeof(unsigned long)) != -1) {

     2500       for (size_t j = 0; j < cpu_map_valid_size; j++) {

     2501         if (cpu_map[j] != 0) {

     2502           for (size_t k = 0; k < BitsPerCLong; k++) {

     2503             if (cpu_map[j] & (1UL << k)) {

     2504               cpu_to_node()->at_put(j * BitsPerCLong + k, i);

     2505             }

     2506           }

     2507         }

     2508       }

     2509     }

     2510   }

     2511   FREE_C_HEAP_ARRAY(unsigned long, cpu_map);

     2512 }

     2513 

     2514 int os::Linux::get_node_by_cpu(int cpu_id) {

     2515   if (cpu_to_node() != NULL && cpu_id >= 0 && cpu_id < cpu_to_node()->length()) {

     2516     return cpu_to_node()->at(cpu_id);

     2517   }

     2518   return -1;

     2519 }

     2520 

     2521 GrowableArray<int>* os::Linux::_cpu_to_node;

     2522 os::Linux::sched_getcpu_func_t os::Linux::_sched_getcpu;

     2523 os::Linux::numa_node_to_cpus_func_t os::Linux::_numa_node_to_cpus;

     2524 os::Linux::numa_max_node_func_t os::Linux::_numa_max_node;

     2525 os::Linux::numa_available_func_t os::Linux::_numa_available;

     2526 os::Linux::numa_tonode_memory_func_t os::Linux::_numa_tonode_memory;

     2527 os::Linux::numa_interleave_memory_func_t os::Linux::_numa_interleave_memory;

     2528 unsigned long* os::Linux::_numa_all_nodes;

     2529 

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

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

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

     2533   return res  != (uintptr_t) MAP_FAILED;

     2534 }

     2535 

     2536 // Linux uses a growable mapping for the stack, and if the mapping for

     2537 // the stack guard pages is not removed when we detach a thread the

     2538 // stack cannot grow beyond the pages where the stack guard was

     2539 // mapped.  If at some point later in the process the stack expands to

     2540 // that point, the Linux kernel cannot expand the stack any further

     2541 // because the guard pages are in the way, and a segfault occurs.

     2542 //

     2543 // However, it's essential not to split the stack region by unmapping

     2544 // a region (leaving a hole) that's already part of the stack mapping,

     2545 // so if the stack mapping has already grown beyond the guard pages at

     2546 // the time we create them, we have to truncate the stack mapping.

     2547 // So, we need to know the extent of the stack mapping when

     2548 // create_stack_guard_pages() is called.

     2549 

     2550 // Find the bounds of the stack mapping.  Return true for success.

     2551 //

     2552 // We only need this for stacks that are growable: at the time of

     2553 // writing thread stacks don't use growable mappings (i.e. those

     2554 // creeated with MAP_GROWSDOWN), and aren't marked "[stack]", so this

     2555 // only applies to the main thread.

     2556 static bool

     2557 get_stack_bounds(uintptr_t *bottom, uintptr_t *top)

     2558 {

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

     2560   if (f == NULL)

     2561     return false;

     2562 

     2563   while (!feof(f)) {

     2564     size_t dummy;

     2565     char *str = NULL;

     2566     ssize_t len = getline(&str, &dummy, f);

     2567     if (len == -1) {

     2568       fclose(f);

     2569       return false;

     2570     }

     2571 

     2572     if (len > 0 && str[len-1] == '\n') {

     2573       str[len-1] = 0;

     2574       len--;

     2575     }

     2576 

     2577     static const char *stack_str = "[stack]";

     2578     if (len > (ssize_t)strlen(stack_str)

     2579        && (strcmp(str + len - strlen(stack_str), stack_str) == 0)) {

     2580       if (sscanf(str, "%" SCNxPTR "-%" SCNxPTR, bottom, top) == 2) {

     2581         uintptr_t sp = (uintptr_t)__builtin_frame_address(0);

     2582         if (sp >= *bottom && sp <= *top) {

     2583           free(str);

     2584           fclose(f);

     2585           return true;

     2586         }

     2587       }

     2588     }

     2589     free(str);

     2590   }

     2591   fclose(f);

     2592   return false;

     2593 }

     2594 

     2595 // If the (growable) stack mapping already extends beyond the point

     2596 // where we're going to put our guard pages, truncate the mapping at

     2597 // that point by munmap()ping it.  This ensures that when we later

     2598 // munmap() the guard pages we don't leave a hole in the stack

     2599 // mapping. This only affects the main/initial thread, but guard

     2600 // against future OS changes

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

     2602   uintptr_t stack_extent, stack_base;

     2603   bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);

     2604   if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {

     2605       assert(os::Linux::is_initial_thread(),

     2606            "growable stack in non-initial thread");

     2607     if (stack_extent < (uintptr_t)addr)

     2608       ::munmap((void*)stack_extent, (uintptr_t)addr - stack_extent);

     2609   }

     2610 

     2611   return os::commit_memory(addr, size);

     2612 }

     2613 

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

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

     2616 // affects the main/initial thread, but guard against future OS changes

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

     2618   uintptr_t stack_extent, stack_base;

     2619   bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);

     2620   if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {

     2621       assert(os::Linux::is_initial_thread(),

     2622            "growable stack in non-initial thread");

     2623 

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

     2625   }

     2626 

     2627   return os::uncommit_memory(addr, size);

     2628 }

     2629 

     2630 static address _highest_vm_reserved_address = NULL;

     2631 

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

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

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

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

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

     2637 // function returns NULL to indicate failure.

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

     2639   char * addr;

     2640   int flags;

     2641 

     2642   flags = MAP_PRIVATE | MAP_NORESERVE | MAP_ANONYMOUS;

     2643   if (fixed) {

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

     2645     flags |= MAP_FIXED;

     2646   }

     2647 

     2648   // Map uncommitted pages PROT_READ and PROT_WRITE, change access

     2649   // to PROT_EXEC if executable when we commit the page.

     2650   addr = (char*)::mmap(requested_addr, bytes, PROT_READ|PROT_WRITE,

     2651                        flags, -1, 0);