jdk-sandbox: comparison hotspot/src/os/bsd/vm/os

equal deleted inserted replaced

-:a5739f4f8eca
+:36bff23b2c2e
 # include <inttypes.h>
 # include <sys/ioctl.h>
 # include <sys/syscall.h>
 #if defined(__FreeBSD__) || defined(__NetBSD__)
-# include <elf.h>
+#include <elf.h>
 #endif
 #ifdef __APPLE__
-# include <mach/mach.h> // semaphore_* API
+#include <mach/mach.h> // semaphore_* API
-# include <mach-o/dyld.h>
+#include <mach-o/dyld.h>
-# include <sys/proc_info.h>
+#include <sys/proc_info.h>
-# include <objc/objc-auto.h>
+#include <objc/objc-auto.h>
 #endif
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 #define MAX_PATH    (2 * K)
 // for timer info max values which include all bits
 static sigset_t check_signal_done;
 static bool check_signals = true;
 static pid_t _initial_pid = 0;
-/* Signal number used to suspend/resume a thread */
+// Signal number used to suspend/resume a thread
-/* do not use any signal number less than SIGSEGV, see 4355769 */
+// do not use any signal number less than SIGSEGV, see 4355769
 static int SR_signum = SIGUSR2;
 sigset_t SR_sigset;
 ////////////////////////////////////////////////////////////////////////////////
 #elif defined(ARM)
 static char cpu_arch[] = "arm";
 #elif defined(PPC32)
 static char cpu_arch[] = "ppc";
 #elif defined(SPARC)
-#  ifdef _LP64
+#ifdef _LP64
 static char cpu_arch[] = "sparcv9";
-#  else
+#else
 static char cpu_arch[] = "sparc";
-#  endif
+#endif
 #else
 #error Add appropriate cpu_arch setting
 #endif
 // Compiler variant
 #ifdef COMPILER2
 #define COMPILER_VARIANT "server"
 #else
 #define COMPILER_VARIANT "client"
 #endif
 void os::Bsd::initialize_system_info() {
 int mib[2];
 size_t len;
 int cpu_val;
 julong mem_val;
-/* get processors count via hw.ncpus sysctl */
+// get processors count via hw.ncpus sysctl
 mib[0] = CTL_HW;
 mib[1] = HW_NCPU;
 len = sizeof(cpu_val);
 if (sysctl(mib, 2, &cpu_val, &len, NULL, 0) != -1 && cpu_val >= 1) {
 assert(len == sizeof(cpu_val), "unexpected data size");
 set_processor_count(cpu_val);
-}
+} else {
-else {
+set_processor_count(1);   // fallback
-set_processor_count(1);   // fallback
+}
-}
+// get physical memory via hw.memsize sysctl (hw.memsize is used
-/* get physical memory via hw.memsize sysctl (hw.memsize is used
+// since it returns a 64 bit value)
-* since it returns a 64 bit value)
-*/
 mib[0] = CTL_HW;
 #if defined (HW_MEMSIZE) // Apple
 mib[1] = HW_MEMSIZE;
 #elif defined(HW_PHYSMEM) // Most of BSD
 #error No ways to get physmem
 #endif
 len = sizeof(mem_val);
 if (sysctl(mib, 2, &mem_val, &len, NULL, 0) != -1) {
 assert(len == sizeof(mem_val), "unexpected data size");
 _physical_memory = mem_val;
 } else {
-_physical_memory = 256*1024*1024;       // fallback (XXXBSD?)
+_physical_memory = 256 * 1024 * 1024;       // fallback (XXXBSD?)
 }
 #ifdef __OpenBSD__
 {
 // limit _physical_memory memory view on OpenBSD since
 // datasize rlimit restricts us anyway.
 struct rlimit limits;
 getrlimit(RLIMIT_DATA, &limits);
 _physical_memory = MIN2(_physical_memory, (julong)limits.rlim_cur);
 }
 #endif
 }
 #ifdef __APPLE__
 // Otherwise exit.
 //
 // Important note: if the location of libjvm.so changes this
 // code needs to be changed accordingly.
 // See ld(1):
 //      The linker uses the following search paths to locate required
 //      shared libraries:
 //        1: ...
 //        ...
 //        7: The default directories, normally /lib and /usr/lib.
 #ifndef DEFAULT_LIBPATH
 #define DEFAULT_LIBPATH "/lib:/usr/lib"
 #endif
 // Base path of extensions installed on the system.
 #define SYS_EXT_DIR     "/usr/java/packages"
 #define EXTENSIONS_DIR  "/lib/ext"
 FREE_C_HEAP_ARRAY(char, buf, mtInternal);
 #else // __APPLE__
 #define SYS_EXTENSIONS_DIR   "/Library/Java/Extensions"
 #define SYS_EXTENSIONS_DIRS  SYS_EXTENSIONS_DIR ":/Network" SYS_EXTENSIONS_DIR ":/System" SYS_EXTENSIONS_DIR ":/usr/lib/java"
 const char *user_home_dir = get_home();
 // The null in SYS_EXTENSIONS_DIRS counts for the size of the colon after user_home_dir.
 size_t system_ext_size = strlen(user_home_dir) + sizeof(SYS_EXTENSIONS_DIR) +
 sizeof(SYS_EXTENSIONS_DIRS);
 debug_only(static bool signal_sets_initialized = false);
 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
 bool os::Bsd::is_sig_ignored(int sig) {
 struct sigaction oact;
 sigaction(sig, (struct sigaction*)NULL, &oact);
 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oact.sa_sigaction)
 : CAST_FROM_FN_PTR(void*,  oact.sa_handler);
-if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
+if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
 return true;
-else
+} else {
 return false;
+}
 }
 void os::Bsd::signal_sets_init() {
 // Should also have an assertion stating we are still single-threaded.
 assert(!signal_sets_initialized, "Already initialized");
 sigaddset(&unblocked_sigs, SIGBUS);
 sigaddset(&unblocked_sigs, SIGFPE);
 sigaddset(&unblocked_sigs, SR_signum);
 if (!ReduceSignalUsage) {
 if (!os::Bsd::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN1_SIGNAL);
 }
 if (!os::Bsd::is_sig_ignored(SHUTDOWN2_SIGNAL)) {
 sigaddset(&unblocked_sigs, SHUTDOWN2_SIGNAL);
 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN2_SIGNAL);
 }
 if (!os::Bsd::is_sig_ignored(SHUTDOWN3_SIGNAL)) {
 sigaddset(&unblocked_sigs, SHUTDOWN3_SIGNAL);
 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
 }
 }
 // Fill in signals that are blocked by all but the VM thread.
 sigemptyset(&vm_sigs);
-if (!ReduceSignalUsage)
+if (!ReduceSignalUsage) {
 sigaddset(&vm_sigs, BREAK_SIGNAL);
+}
 debug_only(signal_sets_initialized = true);
 }
 // These are signals that are unblocked while a thread is running Java.
 }
 #ifdef __APPLE__
 // library handle for calling objc_registerThreadWithCollector()
 // without static linking to the libobjc library
 #define OBJC_LIB "/usr/lib/libobjc.dylib"
 #define OBJC_GCREGISTER "objc_registerThreadWithCollector"
 typedef void (*objc_registerThreadWithCollector_t)();
 extern "C" objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction;
 objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction = NULL;
 #endif
 }
 // Aborted due to thread limit being reached
 if (state == ZOMBIE) {
 thread->set_osthread(NULL);
 delete osthread;
 return false;
 }
 // The thread is returned suspended (in state INITIALIZED),
 // and is started higher up in the call chain
 assert(state == INITIALIZED, "race condition");
 return create_attached_thread(thread);
 }
 bool os::create_attached_thread(JavaThread* thread) {
 #ifdef ASSERT
 thread->verify_not_published();
 #endif
 // Allocate the OSThread object
 OSThread* osthread = new OSThread(NULL, NULL);
 if (Thread::current()->osthread() == osthread) {
 // Restore caller's signal mask
 sigset_t sigmask = osthread->caller_sigmask();
 pthread_sigmask(SIG_SETMASK, &sigmask, NULL);
 }
 delete osthread;
 }
 //////////////////////////////////////////////////////////////////////////////
 assert(status != -1, "bsd error");
 return jlong(time.tv_sec) * 1000  +  jlong(time.tv_usec / 1000);
 }
 #ifndef __APPLE__
 #ifndef CLOCK_MONOTONIC
 #define CLOCK_MONOTONIC (1)
 #endif
 #endif
 #ifdef __APPLE__
 void os::Bsd::clock_init() {
 mach_timebase_info(&_timebase_info);
 #ifdef __APPLE__
 jlong os::javaTimeNanos() {
 const uint64_t tm = mach_absolute_time();
 const uint64_t now = (tm * Bsd::_timebase_info.numer) / Bsd::_timebase_info.denom;
 const uint64_t prev = Bsd::_max_abstime;
 if (now <= prev) {
 return prev;   // same or retrograde time;
 }
 const uint64_t obsv = Atomic::cmpxchg(now, (volatile jlong*)&Bsd::_max_abstime, prev);
 assert(obsv >= prev, "invariant");   // Monotonicity
 // If the CAS succeeded then we're done and return "now".
 // If the CAS failed and the observed value "obsv" is >= now then
 // we should return "obsv".  If the CAS failed and now > obsv > prv then
 // some other thread raced this thread and installed a new value, in which case
 // we could either (a) retry the entire operation, (b) retry trying to install now
 // or (c) just return obsv.  We use (c).   No loop is required although in some cases
 // we might discard a higher "now" value in deference to a slightly lower but freshly
 // installed obsv value.   That's entirely benign -- it admits no new orderings compared
 // to (a) or (b) -- and greatly reduces coherence traffic.
 // We might also condition (c) on the magnitude of the delta between obsv and now.
 // Avoiding excessive CAS operations to hot RW locations is critical.
 // See https://blogs.oracle.com/dave/entry/cas_and_cache_trivia_invalidate
 return (prev == obsv) ? now : obsv;
 }
 #else // __APPLE__
 jlong os::javaTimeNanos() {
 // This method is a copy of JDK's sysGetLastErrorString
 // from src/solaris/hpi/src/system_md.c
 size_t os::lasterror(char *buf, size_t len) {
 if (errno == 0)  return 0;
 const char *s = ::strerror(errno);
 size_t n = ::strlen(s);
 if (n >= len) {
 // DLL functions
 #define JNI_LIB_PREFIX "lib"
 #ifdef __APPLE__
 #define JNI_LIB_SUFFIX ".dylib"
 #else
 #define JNI_LIB_SUFFIX ".so"
 #endif
 const char* os::dll_file_extension() { return JNI_LIB_SUFFIX; }
 // This must be hard coded because it's the system's temporary
 }
 temp_path = temp_path_storage;
 }
 return temp_path;
 }
-#else /* __APPLE__ */
+#else // __APPLE__
 const char* os::get_temp_directory() { return "/tmp"; }
-#endif /* __APPLE__ */
+#endif // __APPLE__
 static bool file_exists(const char* filename) {
 struct stat statbuf;
 if (filename == NULL || strlen(filename) == 0) {
 return false;
 // Really shouldn't be NULL, but check can't hurt
 if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
 continue; // skip the empty path values
 }
 snprintf(buffer, buflen, "%s/" JNI_LIB_PREFIX "%s" JNI_LIB_SUFFIX,
 pelements[i], fname);
 if (file_exists(buffer)) {
 retval = true;
 break;
 }
 }
 }
 // no matching symbol so try for just file info
 if (dlinfo.dli_fname != NULL && dlinfo.dli_fbase != NULL) {
 if (Decoder::decode((address)(addr - (address)dlinfo.dli_fbase),
 buf, buflen, offset, dlinfo.dli_fname)) {
 return true;
 }
 }
 // Handle non-dynamic manually:
 if (dlinfo.dli_fbase != NULL &&
-Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset,
+Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset, dlinfo.dli_fbase)) {
-dlinfo.dli_fbase)) {
 if (!Decoder::demangle(localbuf, buf, buflen)) {
 jio_snprintf(buf, buflen, "%s", localbuf);
 }
 return true;
 }
 ebuf[ebuflen-1]='\0';
 return NULL;
 }
 #else
-void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
+void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
-{
 void * result= ::dlopen(filename, RTLD_LAZY);
 if (result != NULL) {
 // Successful loading
 return result;
 }
 return NULL;
 }
 bool failed_to_read_elf_head=
 (sizeof(elf_head)!=
 (::read(file_descriptor, &elf_head,sizeof(elf_head))));
 ::close(file_descriptor);
 if (failed_to_read_elf_head) {
 // file i/o error - report dlerror() msg
 return NULL;
 char        endianess;    // MSB or LSB
 char*       name;         // String representation
 } arch_t;
 #ifndef EM_486
 #define EM_486          6               /* Intel 80486 */
 #endif
 #ifndef EM_MIPS_RS3_LE
 #define EM_MIPS_RS3_LE  10              /* MIPS */
 #endif
 #ifndef EM_PPC64
 #define EM_PPC64        21              /* PowerPC64 */
 #endif
 #ifndef EM_S390
 #define EM_S390         22              /* IBM System/390 */
 #endif
 #ifndef EM_IA_64
 #define EM_IA_64        50              /* HP/Intel IA-64 */
 #endif
 #ifndef EM_X86_64
 #define EM_X86_64       62              /* AMD x86-64 */
 #endif
 static const arch_t arch_array[]={
 {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
 {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
 {EM_PARISC,      EM_PARISC,  ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"},
 {EM_68K,         EM_68K,     ELFCLASS32, ELFDATA2MSB, (char*)"M68k"}
 };
 #if  (defined IA32)
 static  Elf32_Half running_arch_code=EM_386;
 #elif   (defined AMD64)
 static  Elf32_Half running_arch_code=EM_X86_64;
 #elif  (defined IA64)
 static  Elf32_Half running_arch_code=EM_IA_64;
 #elif  (defined __sparc) && (defined _LP64)
 static  Elf32_Half running_arch_code=EM_SPARCV9;
 #elif  (defined __sparc) && (!defined _LP64)
 static  Elf32_Half running_arch_code=EM_SPARC;
 #elif  (defined __powerpc64__)
 static  Elf32_Half running_arch_code=EM_PPC64;
 #elif  (defined __powerpc__)
 static  Elf32_Half running_arch_code=EM_PPC;
 #elif  (defined ARM)
 static  Elf32_Half running_arch_code=EM_ARM;
 #elif  (defined S390)
 static  Elf32_Half running_arch_code=EM_S390;
 #elif  (defined ALPHA)
 static  Elf32_Half running_arch_code=EM_ALPHA;
 #elif  (defined MIPSEL)
 static  Elf32_Half running_arch_code=EM_MIPS_RS3_LE;
 #elif  (defined PARISC)
 static  Elf32_Half running_arch_code=EM_PARISC;
 #elif  (defined MIPS)
 static  Elf32_Half running_arch_code=EM_MIPS;
 #elif  (defined M68K)
 static  Elf32_Half running_arch_code=EM_68K;
 #else
 #error Method os::dll_load requires that one of following is defined:\
 IA32, AMD64, IA64, __sparc, __powerpc__, ARM, S390, ALPHA, MIPS, MIPSEL, PARISC, M68K
 #endif
 lib_arch.name         = arch_array[i].name;
 }
 }
 assert(running_arch_index != -1,
 "Didn't find running architecture code (running_arch_code) in arch_array");
 if (running_arch_index == -1) {
 // Even though running architecture detection failed
 // we may still continue with reporting dlerror() message
 return NULL;
 }
 #endif // !S390
 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) {
 if (lib_arch.name!=NULL) {
 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
 " (Possible cause: can't load %s-bit .so on a %s-bit platform)",
 lib_arch.name, arch_array[running_arch_index].name);
 } else {
 ::snprintf(diag_msg_buf, diag_msg_max_length-1,
 " (Possible cause: can't load this .so (machine code=0x%x) on a %s-bit platform)",
 lib_arch.code,
 arch_array[running_arch_index].name);
 }
 }
 return NULL;
 }
-#endif /* !__APPLE__ */
+#endif // !__APPLE__
 void* os::get_default_process_handle() {
 #ifdef __APPLE__
 // MacOS X needs to use RTLD_FIRST instead of RTLD_LAZY
 // to avoid finding unexpected symbols on second (or later)
 static bool _print_ascii_file(const char* filename, outputStream* st) {
 int fd = ::open(filename, O_RDONLY);
 if (fd == -1) {
 return false;
 }
 char buf[32];
 int bytes;
 while ((bytes = ::read(fd, buf, sizeof(buf))) > 0) {
 return;
 }
 char dli_fname[MAXPATHLEN];
 bool ret = dll_address_to_library_name(
 CAST_FROM_FN_PTR(address, os::jvm_path),
 dli_fname, sizeof(dli_fname), NULL);
 assert(ret, "cannot locate libjvm");
 char *rp = NULL;
 if (ret && dli_fname[0] != '\0') {
 rp = realpath(dli_fname, buf);
 }
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 if (Arguments::sun_java_launcher_is_altjvm()) {
 // Support for the java launcher's '-XXaltjvm=<path>' option. Typical
 // value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so"
 // or "<JAVA_HOME>/jre/lib/<vmtype>/libjvm.dylib". If "/jre/lib/"
 // Check the current module name "libjvm"
 p = strrchr(buf, '/');
 assert(strstr(p, "/libjvm") == p, "invalid library name");
 rp = realpath(java_home_var, buf);
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 // determine if this is a legacy image or modules image
 // modules image doesn't have "jre" subdirectory
 len = strlen(buf);
 assert(len < buflen, "Ran out of buffer space");
 len = strlen(buf);
 snprintf(buf + len, buflen-len, "/libjvm%s", JNI_LIB_SUFFIX);
 } else {
 // Fall back to path of current library
 rp = realpath(dli_fname, buf);
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 }
 }
 }
 }
 ////////////////////////////////////////////////////////////////////////////////
 // sun.misc.Signal support
 static volatile jint sigint_count = 0;
-static void
+static void UserHandler(int sig, void *siginfo, void *context) {
-UserHandler(int sig, void *siginfo, void *context) {
 // 4511530 - sem_post is serialized and handled by the manager thread. When
 // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
 // don't want to flood the manager thread with sem_post requests.
-if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
+if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1) {
 return;
+}
 // Ctrl-C is pressed during error reporting, likely because the error
 // handler fails to abort. Let VM die immediately.
 if (sig == SIGINT && is_error_reported()) {
 os::die();
 }
 os::signal_notify(sig);
 }
 void os::signal_raise(int signal_number) {
 ::raise(signal_number);
 }
-/*
+// The following code is moved from os.cpp for making this
-* The following code is moved from os.cpp for making this
+// code platform specific, which it is by its very nature.
-* code platform specific, which it is by its very nature.
-*/
 // Will be modified when max signal is changed to be dynamic
 int os::sigexitnum_pd() {
 return NSIG;
 }
 static volatile jint pending_signals[NSIG+1] = { 0 };
 // Bsd(POSIX) specific hand shaking semaphore.
 #ifdef __APPLE__
 typedef semaphore_t os_semaphore_t;
-#define SEM_INIT(sem, value)    semaphore_create(mach_task_self(), &sem, SYNC_POLICY_FIFO, value)
-#define SEM_WAIT(sem)           semaphore_wait(sem)
+#define SEM_INIT(sem, value)    semaphore_create(mach_task_self(), &sem, SYNC_POLICY_FIFO, value)
-#define SEM_POST(sem)           semaphore_signal(sem)
+#define SEM_WAIT(sem)           semaphore_wait(sem)
-#define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)
+#define SEM_POST(sem)           semaphore_signal(sem)
+#define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)
 #else
 typedef sem_t os_semaphore_t;
-#define SEM_INIT(sem, value)    sem_init(&sem, 0, value)
-#define SEM_WAIT(sem)           sem_wait(&sem)
+#define SEM_INIT(sem, value)    sem_init(&sem, 0, value)
-#define SEM_POST(sem)           sem_post(&sem)
+#define SEM_WAIT(sem)           sem_wait(&sem)
-#define SEM_DESTROY(sem)        sem_destroy(&sem)
+#define SEM_POST(sem)           sem_post(&sem)
+#define SEM_DESTROY(sem)        sem_destroy(&sem)
 #endif
 class Semaphore : public StackObj {
 public:
 Semaphore();
 ~Semaphore();
 void signal();
 void wait();
 bool trywait();
 bool timedwait(unsigned int sec, int nsec);
 private:
 jlong currenttime() const;
 os_semaphore_t _semaphore;
 };
 Semaphore::Semaphore() : _semaphore(0) {
 SEM_INIT(_semaphore, 0);
 }
 void Semaphore::wait() {
 SEM_WAIT(_semaphore);
 }
 jlong Semaphore::currenttime() const {
 struct timeval tv;
 gettimeofday(&tv, NULL);
 return (tv.tv_sec * NANOSECS_PER_SEC) + (tv.tv_usec * 1000);
 }
 #ifdef __APPLE__
 bool Semaphore::trywait() {
 return timedwait(0, 0);
 ::SEM_WAIT(sig_sem);
 // were we externally suspended while we were waiting?
 threadIsSuspended = thread->handle_special_suspend_equivalent_condition();
 if (threadIsSuspended) {
-//
 // The semaphore has been incremented, but while we were waiting
 // another thread suspended us. We don't want to continue running
 // while suspended because that would surprise the thread that
 // suspended us.
-//
 ::SEM_POST(sig_sem);
 thread->java_suspend_self();
 }
 } while (threadIsSuspended);
 if (::mprotect(addr, size, prot) == 0) {
 return true;
 }
 #else
 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
 if (res != (uintptr_t) MAP_FAILED) {
 return true;
 }
 #endif
 return false;
 }
 bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
 bool exec) {
 // alignment_hint is ignored on this OS
 return pd_commit_memory(addr, size, exec);
 }
 void os::pd_commit_memory_or_exit(char* addr, size_t size, bool exec,
 #ifdef __OpenBSD__
 // XXX: Work-around mmap/MAP_FIXED bug temporarily on OpenBSD
 return ::mprotect(addr, size, PROT_NONE) == 0;
 #else
 uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE,
 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0);
 return res  != (uintptr_t) MAP_FAILED;
 #endif
 }
 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
 static int anon_munmap(char * addr, size_t size) {
 return ::munmap(addr, size) == 0;
 }
 char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
 size_t alignment_hint) {
 return anon_mmap(requested_addr, bytes, (requested_addr != NULL));
 }
 bool os::pd_release_memory(char* addr, size_t size) {
 return anon_munmap(addr, size);
 key_t key = IPC_PRIVATE;
 char *addr;
 bool warn_on_failure = UseLargePages &&
 (!FLAG_IS_DEFAULT(UseLargePages) ||
-!FLAG_IS_DEFAULT(LargePageSizeInBytes)
+!FLAG_IS_DEFAULT(LargePageSizeInBytes));
-);
 // Create a large shared memory region to attach to based on size.
 // Currently, size is the total size of the heap
 int shmid = shmget(key, bytes, IPC_CREAT|SHM_R|SHM_W);
 if (shmid == -1) {
 // Possible reasons for shmget failure:
 // 1. shmmax is too small for Java heap.
 //    > check shmmax value: cat /proc/sys/kernel/shmmax
 //    > increase shmmax value: echo "0xffffffff" > /proc/sys/kernel/shmmax
 // 2. not enough large page memory.
 //    > check available large pages: cat /proc/meminfo
 //    > increase amount of large pages:
 //          echo new_value > /proc/sys/vm/nr_hugepages
 //      Note 1: different Bsd may use different name for this property,
 //            e.g. on Redhat AS-3 it is "hugetlb_pool".
 //      Note 2: it's possible there's enough physical memory available but
 //            they are so fragmented after a long run that they can't
 //            coalesce into large pages. Try to reserve large pages when
 //            the system is still "fresh".
 if (warn_on_failure) {
 warning("Failed to reserve shared memory (errno = %d).", errno);
 }
 return NULL;
 }
 // attach to the region
 addr = (char*)shmat(shmid, req_addr, 0);
 int err = errno;
 // terminates. If shmat() is not successful this will remove the shared
 // segment immediately.
 shmctl(shmid, IPC_RMID, NULL);
 if ((intptr_t)addr == -1) {
 if (warn_on_failure) {
 warning("Failed to attach shared memory (errno = %d).", err);
 }
 return NULL;
 }
 // The memory is committed
 MemTracker::record_virtual_memory_reserve_and_commit((address)addr, bytes, CALLER_PC);
 // Bsd mmap allows caller to pass an address as hint; give it a try first,
 // if kernel honors the hint then we can return immediately.
 char * addr = anon_mmap(requested_addr, bytes, false);
 if (addr == requested_addr) {
 return requested_addr;
 }
 if (addr != NULL) {
 // mmap() is successful but it fails to reserve at the requested address
 anon_munmap(addr, bytes);
 }
 int i;
 for (i = 0; i < max_tries; ++i) {
 base[i] = reserve_memory(bytes);
 assert(ms < 1000, "Un-interruptable sleep, short time use only");
 req.tv_sec = 0;
 if (ms > 0) {
 req.tv_nsec = (ms % 1000) * 1000000;
-}
+} else {
-else {
 req.tv_nsec = 1;
 }
 nanosleep(&req, NULL);
 31,              // 10 MaxPriority
 31               // 11 CriticalPriority
 };
 #else
-/* Using Mach high-level priority assignments */
+// Using Mach high-level priority assignments
 int os::java_to_os_priority[CriticalPriority + 1] = {
 0,              // 0 Entry should never be used (MINPRI_USER)
 27,              // 1 MinPriority
 28,              // 2
 #elif defined(__APPLE__) || defined(__NetBSD__)
 struct sched_param sp;
 int policy;
 pthread_t self = pthread_self();
-if (pthread_getschedparam(self, &policy, &sp) != 0)
+if (pthread_getschedparam(self, &policy, &sp) != 0) {
 return OS_ERR;
+}
 sp.sched_priority = newpri;
-if (pthread_setschedparam(self, policy, &sp) != 0)
+if (pthread_setschedparam(self, policy, &sp) != 0) {
 return OS_ERR;
+}
 return OS_OK;
 #else
 int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri);
 return (ret == 0) ? OS_OK : OS_ERR;
 //  - resume:
 //      - sets target osthread state to continue
 //      - sends signal to end the sigsuspend loop in the SR_handler
 //
 //  Note that the SR_lock plays no role in this suspend/resume protocol.
-//
 static void resume_clear_context(OSThread *osthread) {
 osthread->set_ucontext(NULL);
 osthread->set_siginfo(NULL);
 }
 static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
 osthread->set_ucontext(context);
 osthread->set_siginfo(siginfo);
 }
-//
 // Handler function invoked when a thread's execution is suspended or
 // resumed. We have to be careful that only async-safe functions are
 // called here (Note: most pthread functions are not async safe and
 // should be avoided.)
 //
 static int SR_initialize() {
 struct sigaction act;
 char *s;
-/* Get signal number to use for suspend/resume */
+// Get signal number to use for suspend/resume
 if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
 int sig = ::strtol(s, 0, 10);
 if (sig > 0 || sig < NSIG) {
 SR_signum = sig;
 }
 }
 assert(SR_signum > SIGSEGV && SR_signum > SIGBUS,
 "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
 sigemptyset(&SR_sigset);
 sigaddset(&SR_sigset, SR_signum);
-/* Set up signal handler for suspend/resume */
+// Set up signal handler for suspend/resume
 act.sa_flags = SA_RESTART|SA_SIGINFO;
 act.sa_handler = (void (*)(int)) SR_handler;
 // SR_signum is blocked by default.
 // 4528190 - We also need to block pthread restart signal (32 on all
 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
 //
 // Note that the VM will print warnings if it detects conflicting signal
 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
 //
-extern "C" JNIEXPORT int
+extern "C" JNIEXPORT int JVM_handle_bsd_signal(int signo, siginfo_t* siginfo,
-JVM_handle_bsd_signal(int signo, siginfo_t* siginfo,
+void* ucontext,
-void* ucontext, int abort_if_unrecognized);
+int abort_if_unrecognized);
 void signalHandler(int sig, siginfo_t* info, void* uc) {
 assert(info != NULL && uc != NULL, "it must be old kernel");
 int orig_errno = errno;  // Preserve errno value over signal handler.
 JVM_handle_bsd_signal(sig, info, uc, true);
 // signal-chaining
 typedef void (*signal_setting_t)();
 signal_setting_t begin_signal_setting = NULL;
 signal_setting_t end_signal_setting = NULL;
 begin_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
 dlsym(RTLD_DEFAULT, "JVM_begin_signal_setting"));
 if (begin_signal_setting != NULL) {
 end_signal_setting = CAST_TO_FN_PTR(signal_setting_t,
 dlsym(RTLD_DEFAULT, "JVM_end_signal_setting"));
 get_signal_action = CAST_TO_FN_PTR(get_signal_t,
 dlsym(RTLD_DEFAULT, "JVM_get_signal_action"));
 libjsig_is_loaded = true;
 assert(UseSignalChaining, "should enable signal-chaining");
 }
 if (libjsig_is_loaded) {
 // Tell libjsig jvm is setting signal handlers
 // Additionally, gdb installs both standard BSD signal handlers, and mach exception
 // handlers. By replacing the existing task exception handler, we disable gdb's mach
 // exception handling, while leaving the standard BSD signal handlers functional.
 kern_return_t kr;
 kr = task_set_exception_ports(mach_task_self(),
 EXC_MASK_BAD_ACCESS | EXC_MASK_ARITHMETIC,
 MACH_PORT_NULL,
 EXCEPTION_STATE_IDENTITY,
 MACHINE_THREAD_STATE);
 assert(kr == KERN_SUCCESS, "could not set mach task signal handler");
 #endif
 if (libjsig_is_loaded) {
 // to indicate, that some special sort of signal
 // trampoline is used.
 // We will never set this flag, and we should
 // ignore this flag in our diagnostic
 #ifdef SIGNIFICANT_SIGNAL_MASK
 #undef SIGNIFICANT_SIGNAL_MASK
 #endif
 #define SIGNIFICANT_SIGNAL_MASK (~0x04000000)
 static const char* get_signal_handler_name(address handler,
 char* buf, int buflen) {
 st->print(", sa_flags=");
 os::Posix::print_sa_flags(st, sa.sa_flags);
 // Check: is it our handler?
 if (handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
 handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
 // It is our signal handler
 // check for flags, reset system-used one!
 if ((int)sa.sa_flags != os::Bsd::get_our_sigflags(sig)) {
 st->print(
 ", flags was changed from " PTR32_FORMAT ", consider using jsig library",
 }
 st->cr();
 }
-#define DO_SIGNAL_CHECK(sig) \
+#define DO_SIGNAL_CHECK(sig)                      \
-if (!sigismember(&check_signal_done, sig)) \
+do {                                            \
-os::Bsd::check_signal_handler(sig)
+if (!sigismember(&check_signal_done, sig)) {  \
+os::Bsd::check_signal_handler(sig);         \
+}                                             \
+} while (0)
 // This method is a periodic task to check for misbehaving JNI applications
 // under CheckJNI, we can add any periodic checks here
 void os::run_periodic_checks() {
 if (sigismember(&check_signal_done, sig)) {
 print_signal_handlers(tty, buf, O_BUFLEN);
 }
 }
-extern void report_error(char* file_name, int line_no, char* title, char* format, ...);
+extern void report_error(char* file_name, int line_no, char* title,
+char* format, ...);
 extern bool signal_name(int signo, char* buf, size_t len);
 const char* os::exception_name(int exception_code, char* buf, size_t size) {
 if (0 < exception_code && exception_code <= SIGRTMAX) {
 }
 }
 // this is called _before_ the most of global arguments have been parsed
 void os::init(void) {
-char dummy;   /* used to get a guess on initial stack address */
+char dummy;   // used to get a guess on initial stack address
 //  first_hrtime = gethrtime();
 // With BsdThreads the JavaMain thread pid (primordial thread)
 // is different than the pid of the java launcher thread.
 // So, on Bsd, the launcher thread pid is passed to the VM
 perfMemory_exit();
 }
 }
 // this is called _after_ the global arguments have been parsed
-jint os::init_2(void)
+jint os::init_2(void) {
-{
 // Allocate a single page and mark it as readable for safepoint polling
 address polling_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 guarantee(polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page");
 os::set_polling_page(polling_page);
 #ifndef PRODUCT
-if (Verbose && PrintMiscellaneous)
+if (Verbose && PrintMiscellaneous) {
-tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
+tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n",
+(intptr_t)polling_page);
+}
 #endif
 if (!UseMembar) {
 address mem_serialize_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 guarantee(mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
 os::set_memory_serialize_page(mem_serialize_page);
 #ifndef PRODUCT
-if (Verbose && PrintMiscellaneous)
+if (Verbose && PrintMiscellaneous) {
-tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
+tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n",
+(intptr_t)mem_serialize_page);
+}
 #endif
 }
 // initialize suspend/resume support - must do this before signal_sets_init()
 if (SR_initialize() != 0) {
 // the java system classes, including StackOverflowError - depends on page
 // size.  Add a page for compiler2 recursion in main thread.
 // Add in 2*BytesPerWord times page size to account for VM stack during
 // class initialization depending on 32 or 64 bit VM.
 os::Bsd::min_stack_allowed = MAX2(os::Bsd::min_stack_allowed,
 (size_t)(StackYellowPages+StackRedPages+StackShadowPages+
 2*BytesPerWord COMPILER2_PRESENT(+1)) * Bsd::page_size());
 size_t threadStackSizeInBytes = ThreadStackSize * K;
 if (threadStackSizeInBytes != 0 &&
 threadStackSizeInBytes < os::Bsd::min_stack_allowed) {
 tty->print_cr("\nThe stack size specified is too small, "
 "Specify at least %dk",
 os::Bsd::min_stack_allowed/ K);
 return JNI_ERR;
 }
 // Make the stack size a multiple of the page size so that
 // the yellow/red zones can be guarded.
 JavaThread::set_stack_size_at_create(round_to(threadStackSizeInBytes,
 vm_page_size()));
 if (MaxFDLimit) {
 // set the number of file descriptors to max. print out error
 // if getrlimit/setrlimit fails but continue regardless.
 struct rlimit nbr_files;
 int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
 if (status != 0) {
-if (PrintMiscellaneous && (Verbose || WizardMode))
+if (PrintMiscellaneous && (Verbose || WizardMode)) {
 perror("os::init_2 getrlimit failed");
+}
 } else {
 nbr_files.rlim_cur = nbr_files.rlim_max;
 #ifdef __APPLE__
 // Darwin returns RLIM_INFINITY for rlim_max, but fails with EINVAL if
 nbr_files.rlim_cur = MIN(OPEN_MAX, nbr_files.rlim_cur);
 #endif
 status = setrlimit(RLIMIT_NOFILE, &nbr_files);
 if (status != 0) {
-if (PrintMiscellaneous && (Verbose || WizardMode))
+if (PrintMiscellaneous && (Verbose || WizardMode)) {
 perror("os::init_2 setrlimit failed");
+}
 }
 }
 }
 // at-exit methods are called in the reverse order of their registration.
 // this is called at the end of vm_initialization
 void os::init_3(void) { }
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
-if (!guard_memory((char*)_polling_page, Bsd::page_size()))
+if (!guard_memory((char*)_polling_page, Bsd::page_size())) {
 fatal("Could not disable polling page");
-};
+}
+}
 // Mark the polling page as readable
 void os::make_polling_page_readable(void) {
 if (!bsd_mprotect((char *)_polling_page, Bsd::page_size(), PROT_READ)) {
 fatal("Could not enable polling page");
 }
-};
+}
 int os::active_processor_count() {
 return _processor_count;
 }
 }
 }
 ///
 class PcFetcher : public os::SuspendedThreadTask {
 public:
 PcFetcher(Thread* thread) : os::SuspendedThreadTask(thread) {}
 ExtendedPC result();
 protected:
 void do_task(const os::SuspendedThreadTaskContext& context);
 private:
 ExtendedPC _epc;
 };
 ExtendedPC PcFetcher::result() {
 guarantee(is_done(), "task is not done yet.");
 PcFetcher fetcher(thread);
 fetcher.run();
 return fetcher.result();
 }
-int os::Bsd::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime)
+int os::Bsd::safe_cond_timedwait(pthread_cond_t *_cond,
-{
+pthread_mutex_t *_mutex,
+const struct timespec *_abstime) {
 return pthread_cond_timedwait(_cond, _mutex, _abstime);
 }
 ////////////////////////////////////////////////////////////////////////////////
 // debug support
 memset(&dlinfo, 0, sizeof(dlinfo));
 if (dladdr(addr, &dlinfo) != 0) {
 st->print(PTR_FORMAT ": ", addr);
 if (dlinfo.dli_sname != NULL && dlinfo.dli_saddr != NULL) {
 st->print("%s+%#x", dlinfo.dli_sname,
 addr - (intptr_t)dlinfo.dli_saddr);
 } else if (dlinfo.dli_fbase != NULL) {
 st->print("<offset %#x>", addr - (intptr_t)dlinfo.dli_fbase);
 } else {
 st->print("<absolute address>");
 }
 address       lowest = (address) dlinfo.dli_sname;
 if (!lowest)  lowest = (address) dlinfo.dli_fbase;
 if (begin < lowest)  begin = lowest;
 Dl_info dlinfo2;
 if (dladdr(end, &dlinfo2) != 0 && dlinfo2.dli_saddr != dlinfo.dli_saddr
-&& end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin)
+&& end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) {
 end = (address) dlinfo2.dli_saddr;
+}
 Disassembler::decode(begin, end, st);
 }
 return true;
 }
 return false;
 // misc
 // This does not do anything on Bsd. This is basically a hook for being
 // able to use structured exception handling (thread-local exception filters)
 // on, e.g., Win32.
-void
+void os::os_exception_wrapper(java_call_t f, JavaValue* value,
-os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method,
+methodHandle* method, JavaCallArguments* args,
-JavaCallArguments* args, Thread* thread) {
+Thread* thread) {
 f(value, method, args, thread);
 }
 void os::print_statistics() {
 }
 struct dirent *ptr;
 dir = opendir(path);
 if (dir == NULL) return true;
-/* Scan the directory */
+// Scan the directory
 bool result = true;
 char buf[sizeof(struct dirent) + MAX_PATH];
 while (result && (ptr = ::readdir(dir)) != NULL) {
 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
 result = false;
 // This code originates from JDK's sysOpen and open64_w
 // from src/solaris/hpi/src/system_md.c
 #ifndef O_DELETE
 #define O_DELETE 0x10000
 #endif
 // Open a file. Unlink the file immediately after open returns
 // if the specified oflag has the O_DELETE flag set.
 // O_DELETE is used only in j2se/src/share/native/java/util/zip/ZipFile.c
 int os::open(const char *path, int oflag, int mode) {
 if (strlen(path) > MAX_PATH - 1) {
 errno = ENAMETOOLONG;
 return -1;
 }
 int fd;
 oflag = oflag & ~O_DELETE;
 fd = ::open(path, oflag, mode);
 if (fd == -1) return -1;
-//If the open succeeded, the file might still be a directory
+// If the open succeeded, the file might still be a directory
 {
 struct stat buf;
 int ret = ::fstat(fd, &buf);
 int st_mode = buf.st_mode;
 ::close(fd);
 return -1;
 }
 }
-/*
+// All file descriptors that are opened in the JVM and not
-* All file descriptors that are opened in the JVM and not
+// specifically destined for a subprocess should have the
-* specifically destined for a subprocess should have the
+// close-on-exec flag set.  If we don't set it, then careless 3rd
-* close-on-exec flag set.  If we don't set it, then careless 3rd
+// party native code might fork and exec without closing all
-* party native code might fork and exec without closing all
+// appropriate file descriptors (e.g. as we do in closeDescriptors in
-* appropriate file descriptors (e.g. as we do in closeDescriptors in
+// UNIXProcess.c), and this in turn might:
-* UNIXProcess.c), and this in turn might:
+//
-*
+// - cause end-of-file to fail to be detected on some file
-* - cause end-of-file to fail to be detected on some file
+//   descriptors, resulting in mysterious hangs, or
-*   descriptors, resulting in mysterious hangs, or
+//
-*
+// - might cause an fopen in the subprocess to fail on a system
-* - might cause an fopen in the subprocess to fail on a system
+//   suffering from bug 1085341.
-*   suffering from bug 1085341.
+//
-*
+// (Yes, the default setting of the close-on-exec flag is a Unix
-* (Yes, the default setting of the close-on-exec flag is a Unix
+// design flaw)
-* design flaw)
+//
-*
+// See:
-* See:
+// 1085341: 32-bit stdio routines should support file descriptors >255
-* 1085341: 32-bit stdio routines should support file descriptors >255
+// 4843136: (process) pipe file descriptor from Runtime.exec not being closed
-* 4843136: (process) pipe file descriptor from Runtime.exec not being closed
+// 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
-* 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
+//
-*/
 #ifdef FD_CLOEXEC
 {
 int flags = ::fcntl(fd, F_GETFD);
-if (flags != -1)
+if (flags != -1) {
 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
 }
+}
 #endif
 if (o_delete != 0) {
 ::unlink(path);
 }
 struct stat buf;
 if (::fstat(fd, &buf) >= 0) {
 mode = buf.st_mode;
 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
-/*
+// XXX: is the following call interruptible? If so, this might
-* XXX: is the following call interruptible? If so, this might
+// need to go through the INTERRUPT_IO() wrapper as for other
-* need to go through the INTERRUPT_IO() wrapper as for other
+// blocking, interruptible calls in this file.
-* blocking, interruptible calls in this file.
-*/
 int n;
 if (::ioctl(fd, FIONREAD, &n) >= 0) {
 *bytes = n;
 return 1;
 }
 *bytes = end - cur;
 return 1;
 }
 int os::socket_available(int fd, jint *pbytes) {
-if (fd < 0)
+if (fd < 0) {
 return OS_OK;
+}
-int ret;
+int ret;
-RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret);
+RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret);
-//%% note ioctl can return 0 when successful, JVM_SocketAvailable
-// is expected to return 0 on failure and 1 on success to the jdk.
+//%% note ioctl can return 0 when successful, JVM_SocketAvailable
+// is expected to return 0 on failure and 1 on success to the jdk.
-return (ret == OS_ERR) ? 0 : 1;
+return (ret == OS_ERR) ? 0 : 1;
 }
 // Map a block of memory.
 char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 int prot;
 int flags;
 if (read_only) {
 prot = PROT_READ;
 }
 // Remap a block of memory.
 char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 // same as map_memory() on this OS
 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
 allow_exec);
 }
 kern_return_t kr;
 thread_t mach_thread;
 mach_thread = thread->osthread()->thread_id();
 kr = thread_info(mach_thread, THREAD_BASIC_INFO, (thread_info_t)&tinfo, &tcount);
-if (kr != KERN_SUCCESS)
+if (kr != KERN_SUCCESS) {
 return -1;
+}
 if (user_sys_cpu_time) {
 jlong nanos;
 nanos = ((jlong) tinfo.system_time.seconds + tinfo.user_time.seconds) * (jlong)1000000000;
 nanos += ((jlong) tinfo.system_time.microseconds + (jlong) tinfo.user_time.microseconds) * (jlong)1000;
 while (::stat(filename, &buf) == 0) {
 (void)::poll(NULL, 0, 100);
 }
 } else {
 jio_fprintf(stderr,
 "Could not open pause file '%s', continuing immediately.\n", filename);
 }
 }
 // Refer to the comments in os_solaris.cpp park-unpark.
 // utility to compute the abstime argument to timedwait:
 // millis is the relative timeout time
 // abstime will be the absolute timeout time
 // TODO: replace compute_abstime() with unpackTime()
-static struct timespec* compute_abstime(struct timespec* abstime, jlong millis) {
+static struct timespec* compute_abstime(struct timespec* abstime,
+jlong millis) {
 if (millis < 0)  millis = 0;
 struct timeval now;
 int status = gettimeofday(&now, NULL);
 assert(status == 0, "gettimeofday");
 jlong seconds = millis / 1000;
 // TODO: assert that _Assoc != NULL or _Assoc == Self
 assert(_nParked == 0, "invariant");
 int v;
 for (;;) {
 v = _Event;
 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
 }
 guarantee(v >= 0, "invariant");
 if (v == 0) {
 // Do this the hard way by blocking ...
 int status = pthread_mutex_lock(_mutex);
 assert_status(status == 0, status, "mutex_lock");
 guarantee(_nParked == 0, "invariant");
 ++_nParked;
 while (_Event < 0) {
 status = pthread_cond_wait(_cond, _mutex);
 // for some reason, under 2.7 lwp_cond_wait() may return ETIME ...
 // Treat this the same as if the wait was interrupted
 if (status == ETIMEDOUT) { status = EINTR; }
 assert_status(status == 0 || status == EINTR, status, "cond_wait");
 }
 --_nParked;
 _Event = 0;
 status = pthread_mutex_unlock(_mutex);
 assert_status(status == 0, status, "mutex_unlock");
 // Paranoia to ensure our locked and lock-free paths interact
 // correctly with each other.
 OrderAccess::fence();
 }
 guarantee(_Event >= 0, "invariant");
 int os::PlatformEvent::park(jlong millis) {
 guarantee(_nParked == 0, "invariant");
 int v;
 for (;;) {
 v = _Event;
 if (Atomic::cmpxchg(v-1, &_Event, v) == v) break;
 }
 guarantee(v >= 0, "invariant");
 if (v != 0) return OS_OK;
 // We do this the hard way, by blocking the thread.
 if (status == ETIMEDOUT) break;
 // We consume and ignore EINTR and spurious wakeups.
 }
 --_nParked;
 if (_Event >= 0) {
 ret = OS_OK;
 }
 _Event = 0;
 status = pthread_mutex_unlock(_mutex);
 assert_status(status == 0, status, "mutex_unlock");
 assert(_nParked == 0, "invariant");
 // JSR166
 // -------------------------------------------------------
-/*
+// The solaris and bsd implementations of park/unpark are fairly
-* The solaris and bsd implementations of park/unpark are fairly
+// conservative for now, but can be improved. They currently use a
-* conservative for now, but can be improved. They currently use a
+// mutex/condvar pair, plus a a count.
-* mutex/condvar pair, plus a a count.
+// Park decrements count if > 0, else does a condvar wait.  Unpark
-* Park decrements count if > 0, else does a condvar wait.  Unpark
+// sets count to 1 and signals condvar.  Only one thread ever waits
-* sets count to 1 and signals condvar.  Only one thread ever waits
+// on the condvar. Contention seen when trying to park implies that someone
-* on the condvar. Contention seen when trying to park implies that someone
+// is unparking you, so don't wait. And spurious returns are fine, so there
-* is unparking you, so don't wait. And spurious returns are fine, so there
+// is no need to track notifications.
-* is no need to track notifications.
-*/
 #define MAX_SECS 100000000
-/*
-* This code is common to bsd and solaris and will be moved to a
+// This code is common to bsd and solaris and will be moved to a
-* common place in dolphin.
+// common place in dolphin.
-*
+//
-* The passed in time value is either a relative time in nanoseconds
+// The passed in time value is either a relative time in nanoseconds
-* or an absolute time in milliseconds. Either way it has to be unpacked
+// or an absolute time in milliseconds. Either way it has to be unpacked
-* into suitable seconds and nanoseconds components and stored in the
+// into suitable seconds and nanoseconds components and stored in the
-* given timespec structure.
+// given timespec structure.
-* Given time is a 64-bit value and the time_t used in the timespec is only
+// Given time is a 64-bit value and the time_t used in the timespec is only
-* a signed-32-bit value (except on 64-bit Bsd) we have to watch for
+// a signed-32-bit value (except on 64-bit Bsd) we have to watch for
-* overflow if times way in the future are given. Further on Solaris versions
+// overflow if times way in the future are given. Further on Solaris versions
-* prior to 10 there is a restriction (see cond_timedwait) that the specified
+// prior to 10 there is a restriction (see cond_timedwait) that the specified
-* number of seconds, in abstime, is less than current_time  + 100,000,000.
+// number of seconds, in abstime, is less than current_time  + 100,000,000.
-* As it will be 28 years before "now + 100000000" will overflow we can
+// As it will be 28 years before "now + 100000000" will overflow we can
-* ignore overflow and just impose a hard-limit on seconds using the value
+// ignore overflow and just impose a hard-limit on seconds using the value
-* of "now + 100,000,000". This places a limit on the timeout of about 3.17
+// of "now + 100,000,000". This places a limit on the timeout of about 3.17
-* years from "now".
+// years from "now".
-*/
 static void unpackTime(struct timespec* absTime, bool isAbsolute, jlong time) {
 assert(time > 0, "convertTime");
 struct timeval now;
 if (isAbsolute) {
 jlong secs = time / 1000;
 if (secs > max_secs) {
 absTime->tv_sec = max_secs;
-}
+} else {
-else {
 absTime->tv_sec = secs;
 }
 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
-}
+} else {
-else {
 jlong secs = time / NANOSECS_PER_SEC;
 if (secs >= MAX_SECS) {
 absTime->tv_sec = max_secs;
 absTime->tv_nsec = 0;
-}
+} else {
-else {
 absTime->tv_sec = now.tv_sec + secs;
 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
 if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
 absTime->tv_nsec -= NANOSECS_PER_SEC;
 ++absTime->tv_sec; // note: this must be <= max_secs
 int status = pthread_mutex_lock(_mutex);
 assert(status == 0, "invariant");
 const int s = _counter;
 _counter = 1;
 if (s < 1) {
 if (WorkAroundNPTLTimedWaitHang) {
 status = pthread_cond_signal(_cond);
 assert(status == 0, "invariant");
 status = pthread_mutex_unlock(_mutex);
 assert(status == 0, "invariant");
 } else {
 status = pthread_mutex_unlock(_mutex);
 assert(status == 0, "invariant");
 status = pthread_cond_signal(_cond);
 assert(status == 0, "invariant");
 }
 } else {
 pthread_mutex_unlock(_mutex);
 assert(status == 0, "invariant");
 }
 }
-/* Darwin has no "environ" in a dynamic library. */
+// Darwin has no "environ" in a dynamic library.
 #ifdef __APPLE__
 #include <crt_externs.h>
 #define environ (*_NSGetEnviron())
 #else
 extern char** environ;
 #endif
 // Run the specified command in a separate process. Return its exit value,
 int status;
 // Wait for the child process to exit.  This returns immediately if
 // the child has already exited. */
 while (waitpid(pid, &status, 0) < 0) {
 switch (errno) {
 case ECHILD: return 0;
 case EINTR: break;
 default: return -1;
 }
 }
 if (WIFEXITED(status)) {
 // The child exited normally; get its exit code.
 return WEXITSTATUS(status);
 } else if (WIFSIGNALED(status)) {
 // The child exited because of a signal
 // The best value to return is 0x80 + signal number,
 // because that is what all Unix shells do, and because
 // it allows callers to distinguish between process exit and
 // process death by signal.
 return 0x80 + WTERMSIG(status);
 } else {
 // Unknown exit code; pass it through
 return status;
 }
 }
 }
 // is_headless_jre()
 // Since JDK8 xawt/libmawt.so was moved into the same directory
 // as libawt.so, and renamed libawt_xawt.so
 //
 bool os::is_headless_jre() {
 #ifdef __APPLE__
 // We no longer build headless-only on Mac OS X
+return false;
+#else
+struct stat statbuf;
+char buf[MAXPATHLEN];
+char libmawtpath[MAXPATHLEN];
+const char *xawtstr  = "/xawt/libmawt" JNI_LIB_SUFFIX;
+const char *new_xawtstr = "/libawt_xawt" JNI_LIB_SUFFIX;
+char *p;
+// Get path to libjvm.so
+os::jvm_path(buf, sizeof(buf));
+// Get rid of libjvm.so
+p = strrchr(buf, '/');
+if (p == NULL) {
 return false;
-#else
+} else {
-struct stat statbuf;
+*p = '\0';
-char buf[MAXPATHLEN];
+}
-char libmawtpath[MAXPATHLEN];
-const char *xawtstr  = "/xawt/libmawt" JNI_LIB_SUFFIX;
+// Get rid of client or server
-const char *new_xawtstr = "/libawt_xawt" JNI_LIB_SUFFIX;
+p = strrchr(buf, '/');
-char *p;
+if (p == NULL) {
+return false;
-// Get path to libjvm.so
+} else {
-os::jvm_path(buf, sizeof(buf));
+*p = '\0';
+}
-// Get rid of libjvm.so
-p = strrchr(buf, '/');
+// check xawt/libmawt.so
-if (p == NULL) return false;
+strcpy(libmawtpath, buf);
-else *p = '\0';
+strcat(libmawtpath, xawtstr);
+if (::stat(libmawtpath, &statbuf) == 0) return false;
-// Get rid of client or server
-p = strrchr(buf, '/');
+// check libawt_xawt.so
-if (p == NULL) return false;
+strcpy(libmawtpath, buf);
-else *p = '\0';
+strcat(libmawtpath, new_xawtstr);
+if (::stat(libmawtpath, &statbuf) == 0) return false;
-// check xawt/libmawt.so
-strcpy(libmawtpath, buf);
+return true;
-strcat(libmawtpath, xawtstr);
-if (::stat(libmawtpath, &statbuf) == 0) return false;
-// check libawt_xawt.so
-strcpy(libmawtpath, buf);
-strcat(libmawtpath, new_xawtstr);
-if (::stat(libmawtpath, &statbuf) == 0) return false;
-return true;
 #endif
 }
 // Get the default path to the core file
 // Returns the length of the string

changeset 26704	36bff23b2c2e
parent 26698	2a7f85720535
parent 26685	aa239a0dfbea
child 27157	364276bc8d8b