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

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
 // if RUSAGE_THREAD for getrusage() has not been defined, do it here. The code calling
 // getrusage() is prepared to handle the associated failure.
 #ifndef RUSAGE_THREAD
 #define RUSAGE_THREAD   (1)               /* only the calling thread */
 #endif
 #define MAX_PATH    (2 * K)
 #define MAX_SECS 100000000
 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;
-/* Used to protect dlsym() calls */
+// Used to protect dlsym() calls
 static pthread_mutex_t dl_mutex;
 // Declarations
 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time);
 }
 #ifndef SYS_gettid
 // i386: 224, ia64: 1105, amd64: 186, sparc 143
 #ifdef __ia64__
 #define SYS_gettid 1105
 #elif __i386__
 #define SYS_gettid 224
 #elif __amd64__
 #define SYS_gettid 186
 #elif __sparc__
 #define SYS_gettid 143
 #else
 #error define gettid for the arch
 #endif
 #endif
 // Cpu architecture string
 #if   defined(ZERO)
 static char cpu_arch[] = ZERO_LIBARCH;
 #elif defined(PPC32)
 static char cpu_arch[] = "ppc";
 #elif defined(PPC64)
 static char cpu_arch[] = "ppc64";
 #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
 // pid_t gettid()
 //
 // Otherwise exit.
 //
 // Important note: if the location of libjvm.so changes this
 // code needs to be changed accordingly.
 // See ld(1):
 //      The linker uses the following search paths to locate required
 //      shared libraries:
 //        1: ...
 //        ...
 //        7: The default directories, normally /lib and /usr/lib.
 #if defined(AMD64) || defined(_LP64) && (defined(SPARC) || defined(PPC) || defined(S390))
 #define DEFAULT_LIBPATH "/usr/lib64:/lib64:/lib:/usr/lib"
 #else
 #define DEFAULT_LIBPATH "/lib:/usr/lib"
 #endif
 // Base path of extensions installed on the system.
 #define SYS_EXT_DIR     "/usr/java/packages"
 #define EXTENSIONS_DIR  "/lib/ext"
 bool os::Linux::is_sig_ignored(int sig) {
 struct sigaction oact;
 sigaction(sig, (struct sigaction*)NULL, &oact);
 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oact.sa_sigaction)
 : CAST_FROM_FN_PTR(void*,  oact.sa_handler);
-if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
+if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
 return true;
-else
+} else {
 return false;
+}
 }
 void os::Linux::signal_sets_init() {
 // Should also have an assertion stating we are still single-threaded.
 assert(!signal_sets_initialized, "Already initialized");
 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.
 void os::Linux::libpthread_init() {
 // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION
 // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a
 // generic name for earlier versions.
 // Define macros here so we can build HotSpot on old systems.
-# ifndef _CS_GNU_LIBC_VERSION
+#ifndef _CS_GNU_LIBC_VERSION
-# define _CS_GNU_LIBC_VERSION 2
+#define _CS_GNU_LIBC_VERSION 2
-# endif
+#endif
-# ifndef _CS_GNU_LIBPTHREAD_VERSION
+#ifndef _CS_GNU_LIBPTHREAD_VERSION
-# define _CS_GNU_LIBPTHREAD_VERSION 3
+#define _CS_GNU_LIBPTHREAD_VERSION 3
-# endif
+#endif
 size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);
 if (n > 0) {
 char *str = (char *)malloc(n, mtInternal);
 confstr(_CS_GNU_LIBC_VERSION, str, n);
 //
 // _expand_stack_to() assumes its frame size is less than page size, which
 // should always be true if the function is not inlined.
 #if __GNUC__ < 3    // gcc 2.x does not support noinline attribute
 #define NOINLINE
 #else
 #define NOINLINE __attribute__ ((noinline))
 #endif
 static void _expand_stack_to(address bottom) NOINLINE;
 static void _expand_stack_to(address bottom) {
 thread->run();
 return 0;
 }
-bool os::create_thread(Thread* thread, ThreadType thr_type, size_t stack_size) {
+bool os::create_thread(Thread* thread, ThreadType thr_type,
+size_t stack_size) {
 assert(thread->osthread() == NULL, "caller responsible");
 // Allocate the OSThread object
 OSThread* osthread = new OSThread(NULL, NULL);
 if (osthread == NULL) {
 if (initial_thread_stack_bottom() == NULL) return false;
 assert(initial_thread_stack_bottom() != NULL &&
 initial_thread_stack_size()   != 0,
 "os::init did not locate initial thread's stack region");
 if ((address)&dummy >= initial_thread_stack_bottom() &&
-(address)&dummy < initial_thread_stack_bottom() + initial_thread_stack_size())
+(address)&dummy < initial_thread_stack_bottom() + initial_thread_stack_size()) {
 return true;
-else return false;
+} else {
+return false;
+}
 }
 // Find the virtual memory area that contains addr
 static bool find_vma(address addr, address* vma_low, address* vma_high) {
 FILE *fp = fopen("/proc/self/maps", "r");
 //   SuSE 7.2, Debian) can not handle alternate signal stack correctly
 //   for initial thread if its stack size exceeds 6M. Cap it at 2M,
 //   in case other parts in glibc still assumes 2M max stack size.
 // FIXME: alt signal stack is gone, maybe we can relax this constraint?
 // Problem still exists RH7.2 (IA64 anyway) but 2MB is a little small
-if (stack_size > 2 * K * K IA64_ONLY(*2))
+if (stack_size > 2 * K * K IA64_ONLY(*2)) {
 stack_size = 2 * K * K IA64_ONLY(*2);
+}
 // Try to figure out where the stack base (top) is. This is harder.
 //
 // When an application is started, glibc saves the initial stack pointer in
 // a global variable "__libc_stack_end", which is then used by system
 // libraries. __libc_stack_end should be pretty close to stack top. The
 do s++; while (isspace(*s));
 #define _UFM UINTX_FORMAT
 #define _DFM INTX_FORMAT
-/*                                     1   1   1   1   1   1   1   1   1   1   2   2    2    2    2    2    2    2    2 */
+//                                     1   1   1   1   1   1   1   1   1   1   2   2    2    2    2    2    2    2    2
-/*              3  4  5  6  7  8   9   0   1   2   3   4   5   6   7   8   9   0   1    2    3    4    5    6    7    8 */
+//              3  4  5  6  7  8   9   0   1   2   3   4   5   6   7   8   9   0   1    2    3    4    5    6    7    8
 i = sscanf(s, "%c %d %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %ld %ld %ld %ld %ld %ld " _UFM _UFM _DFM _UFM _UFM _UFM _UFM,
-&state,          /* 3  %c  */
+&state,          // 3  %c
-&ppid,           /* 4  %d  */
+&ppid,           // 4  %d
-&pgrp,           /* 5  %d  */
+&pgrp,           // 5  %d
-&session,        /* 6  %d  */
+&session,        // 6  %d
-&nr,             /* 7  %d  */
+&nr,             // 7  %d
-&tpgrp,          /* 8  %d  */
+&tpgrp,          // 8  %d
-&flags,          /* 9  %lu  */
+&flags,          // 9  %lu
-&minflt,         /* 10 %lu  */
+&minflt,         // 10 %lu
-&cminflt,        /* 11 %lu  */
+&cminflt,        // 11 %lu
-&majflt,         /* 12 %lu  */
+&majflt,         // 12 %lu
-&cmajflt,        /* 13 %lu  */
+&cmajflt,        // 13 %lu
-&utime,          /* 14 %lu  */
+&utime,          // 14 %lu
-&stime,          /* 15 %lu  */
+&stime,          // 15 %lu
-&cutime,         /* 16 %ld  */
+&cutime,         // 16 %ld
-&cstime,         /* 17 %ld  */
+&cstime,         // 17 %ld
-&prio,           /* 18 %ld  */
+&prio,           // 18 %ld
-&nice,           /* 19 %ld  */
+&nice,           // 19 %ld
-&junk,           /* 20 %ld  */
+&junk,           // 20 %ld
-&it_real,        /* 21 %ld  */
+&it_real,        // 21 %ld
-&start,          /* 22 UINTX_FORMAT */
+&start,          // 22 UINTX_FORMAT
-&vsize,          /* 23 UINTX_FORMAT */
+&vsize,          // 23 UINTX_FORMAT
-&rss,            /* 24 INTX_FORMAT  */
+&rss,            // 24 INTX_FORMAT
-&rsslim,         /* 25 UINTX_FORMAT */
+&rsslim,         // 25 UINTX_FORMAT
-&scodes,         /* 26 UINTX_FORMAT */
+&scodes,         // 26 UINTX_FORMAT
-&ecode,          /* 27 UINTX_FORMAT */
+&ecode,          // 27 UINTX_FORMAT
-&stack_start);   /* 28 UINTX_FORMAT */
+&stack_start);   // 28 UINTX_FORMAT
 }
 #undef _UFM
 #undef _DFM
 assert(status != -1, "linux error");
 return jlong(time.tv_sec) * 1000  +  jlong(time.tv_usec / 1000);
 }
 #ifndef CLOCK_MONOTONIC
 #define CLOCK_MONOTONIC (1)
 #endif
 void os::Linux::clock_init() {
 // we do dlopen's in this particular order due to bug in linux
 // dynamical loader (see 6348968) leading to crash on exit
 warning("No monotonic clock was available - timed services may " \
 "be adversely affected if the time-of-day clock changes");
 }
 #ifndef SYS_clock_getres
+#if defined(IA32) || defined(AMD64)
-#if defined(IA32) || defined(AMD64)
+#define SYS_clock_getres IA32_ONLY(266)  AMD64_ONLY(229)
-#define SYS_clock_getres IA32_ONLY(266)  AMD64_ONLY(229)
+#define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)
-#define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)
+#else
+#warning "SYS_clock_getres not defined for this platform, disabling fast_thread_cpu_time"
+#define sys_clock_getres(x,y)  -1
+#endif
 #else
-#warning "SYS_clock_getres not defined for this platform, disabling fast_thread_cpu_time"
+#define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)
-#define sys_clock_getres(x,y)  -1
-#endif
-#else
-#define sys_clock_getres(x,y)  ::syscall(SYS_clock_getres, x, y)
 #endif
 void os::Linux::fast_thread_clock_init() {
 if (!UseLinuxPosixThreadCPUClocks) {
 return;
 // better than 1 sec. This is extra check for reliability.
 if (pthread_getcpuclockid_func &&
 pthread_getcpuclockid_func(_main_thread, &clockid) == 0 &&
 sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) {
 _supports_fast_thread_cpu_time = true;
 _pthread_getcpuclockid = pthread_getcpuclockid_func;
 }
 }
 // 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) {
 os::Linux::_stack_is_executable = true;
 }
 void* loaded_library() { return _lib; }
 };
-void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
+void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
-{
 void * result = NULL;
 bool load_attempted = false;
 // Check whether the library to load might change execution rights
 // of the stack. If they are changed, the protection of the stack
 char        elf_class;    // 32 or 64 bit
 char        endianess;    // MSB or LSB
 char*       name;         // String representation
 } arch_t;
 #ifndef EM_486
 #define EM_486          6               /* Intel 80486 */
 #endif
 static const arch_t arch_array[]={
 {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
 {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
 {EM_IA_64,       EM_IA_64,   ELFCLASS64, ELFDATA2LSB, (char*)"IA 64"},
 {EM_MIPS,        EM_MIPS,    ELFCLASS32, ELFDATA2MSB, (char*)"MIPS"},
 {EM_PARISC,      EM_PARISC,  ELFCLASS32, ELFDATA2MSB, (char*)"PARISC"},
 {EM_68K,         EM_68K,     ELFCLASS32, ELFDATA2MSB, (char*)"M68k"}
 };
 #if  (defined IA32)
 static  Elf32_Half running_arch_code=EM_386;
 #elif   (defined AMD64)
 static  Elf32_Half running_arch_code=EM_X86_64;
 #elif  (defined IA64)
 static  Elf32_Half running_arch_code=EM_IA_64;
 #elif  (defined __sparc) && (defined _LP64)
 static  Elf32_Half running_arch_code=EM_SPARCV9;
 #elif  (defined __sparc) && (!defined _LP64)
 static  Elf32_Half running_arch_code=EM_SPARC;
 #elif  (defined __powerpc64__)
 static  Elf32_Half running_arch_code=EM_PPC64;
 #elif  (defined __powerpc__)
 static  Elf32_Half running_arch_code=EM_PPC;
 #elif  (defined ARM)
 static  Elf32_Half running_arch_code=EM_ARM;
 #elif  (defined S390)
 static  Elf32_Half running_arch_code=EM_S390;
 #elif  (defined ALPHA)
 static  Elf32_Half running_arch_code=EM_ALPHA;
 #elif  (defined MIPSEL)
 static  Elf32_Half running_arch_code=EM_MIPS_RS3_LE;
 #elif  (defined PARISC)
 static  Elf32_Half running_arch_code=EM_PARISC;
 #elif  (defined MIPS)
 static  Elf32_Half running_arch_code=EM_MIPS;
 #elif  (defined M68K)
 static  Elf32_Half running_arch_code=EM_68K;
 #else
 #error Method os::dll_load requires that one of following is defined:\
 IA32, AMD64, IA64, __sparc, __powerpc__, ARM, S390, ALPHA, MIPS, MIPSEL, PARISC, M68K
 #endif
 // Identify compatability class for VM's architecture and library's architecture
 // Obtain string descriptions for architectures
 arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL};
 }
 return NULL;
 }
-void * os::Linux::dlopen_helper(const char *filename, char *ebuf, int ebuflen) {
+void * os::Linux::dlopen_helper(const char *filename, char *ebuf,
+int ebuflen) {
 void * result = ::dlopen(filename, RTLD_LAZY);
 if (result == NULL) {
 ::strncpy(ebuf, ::dlerror(), ebuflen - 1);
 ebuf[ebuflen-1] = '\0';
 }
 return result;
 }
-void * os::Linux::dll_load_in_vmthread(const char *filename, char *ebuf, int ebuflen) {
+void * os::Linux::dll_load_in_vmthread(const char *filename, char *ebuf,
+int ebuflen) {
 void * result = NULL;
 if (LoadExecStackDllInVMThread) {
 result = dlopen_helper(filename, ebuf, ebuflen);
 }
 }
 return result;
 }
-/*
+// glibc-2.0 libdl is not MT safe.  If you are building with any glibc,
-* glibc-2.0 libdl is not MT safe.  If you are building with any glibc,
+// chances are you might want to run the generated bits against glibc-2.0
-* chances are you might want to run the generated bits against glibc-2.0
+// libdl.so, so always use locking for any version of glibc.
-* libdl.so, so always use locking for any version of glibc.
+//
-*/
 void* os::dll_lookup(void* handle, const char* name) {
 pthread_mutex_lock(&dl_mutex);
 void* res = dlsym(handle, name);
 pthread_mutex_unlock(&dl_mutex);
 return res;
 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".
 // If "/jre/lib/" appears at the right place in the string, then
 // Check the current module name "libjvm.so".
 p = strrchr(buf, '/');
 assert(strstr(p, "/libjvm") == p, "invalid library name");
 rp = realpath(java_home_var, buf);
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 // determine if this is a legacy image or modules image
 // modules image doesn't have "jre" subdirectory
 len = strlen(buf);
 assert(len < buflen, "Ran out of buffer room");
 len = strlen(buf);
 snprintf(buf + len, buflen-len, "/hotspot/libjvm.so");
 } else {
 // Go back to path of .so
 rp = realpath(dli_fname, buf);
-if (rp == NULL)
+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();
 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;
 }
 ::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);
 }
 }
 // Define MAP_HUGETLB here so we can build HotSpot on old systems.
 #ifndef MAP_HUGETLB
 #define MAP_HUGETLB 0x40000
 #endif
 // Define MADV_HUGEPAGE here so we can build HotSpot on old systems.
 #ifndef MADV_HUGEPAGE
 #define MADV_HUGEPAGE 14
 #endif
 int os::Linux::commit_memory_impl(char* addr, size_t size,
 size_t alignment_hint, bool exec) {
 int err = os::Linux::commit_memory_impl(addr, size, exec);
 // free large pages.
 Linux::numa_set_bind_policy(USE_MPOL_PREFERRED);
 Linux::numa_tonode_memory(addr, bytes, lgrp_hint);
 }
-bool os::numa_topology_changed()   { return false; }
+bool os::numa_topology_changed() { return false; }
 size_t os::numa_get_groups_num() {
 int max_node = Linux::numa_max_node();
 return max_node > 0 ? max_node + 1 : 1;
 }
 bool os::get_page_info(char *start, page_info* info) {
 return false;
 }
-char *os::scan_pages(char *start, char* end, page_info* page_expected, page_info* page_found) {
+char *os::scan_pages(char *start, char* end, page_info* page_expected,
+page_info* page_found) {
 return end;
 }
 int os::Linux::sched_getcpu_syscall(void) {
 unsigned int cpu;
 int retval = -1;
 #if defined(IA32)
-# ifndef SYS_getcpu
+#ifndef SYS_getcpu
-# define SYS_getcpu 318
+#define SYS_getcpu 318
-# endif
+#endif
 retval = syscall(SYS_getcpu, &cpu, NULL, NULL);
 #elif defined(AMD64)
 // Unfortunately we have to bring all these macros here from vsyscall.h
 // to be able to compile on old linuxes.
-# define __NR_vgetcpu 2
+#define __NR_vgetcpu 2
-# define VSYSCALL_START (-10UL << 20)
+#define VSYSCALL_START (-10UL << 20)
-# define VSYSCALL_SIZE 1024
+#define VSYSCALL_SIZE 1024
-# define VSYSCALL_ADDR(vsyscall_nr) (VSYSCALL_START+VSYSCALL_SIZE*(vsyscall_nr))
+#define VSYSCALL_ADDR(vsyscall_nr) (VSYSCALL_START+VSYSCALL_SIZE*(vsyscall_nr))
 typedef long (*vgetcpu_t)(unsigned int *cpu, unsigned int *node, unsigned long *tcache);
 vgetcpu_t vgetcpu = (vgetcpu_t)VSYSCALL_ADDR(__NR_vgetcpu);
 retval = vgetcpu(&cpu, NULL, NULL);
 #endif
 // sched_getcpu() should be in libc.
 set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t,
 dlsym(RTLD_DEFAULT, "sched_getcpu")));
 // If it's not, try a direct syscall.
-if (sched_getcpu() == -1)
+if (sched_getcpu() == -1) {
-set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t, (void*)&sched_getcpu_syscall));
+set_sched_getcpu(CAST_TO_FN_PTR(sched_getcpu_func_t,
+(void*)&sched_getcpu_syscall));
+}
 if (sched_getcpu() != -1) { // Does it work?
 void *handle = dlopen("libnuma.so.1", RTLD_LAZY);
 if (handle != NULL) {
 set_numa_node_to_cpus(CAST_TO_FN_PTR(numa_node_to_cpus_func_t,
 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;
 }
-static
+static address get_stack_commited_bottom(address bottom, size_t size) {
-address get_stack_commited_bottom(address bottom, size_t size) {
 address nbot = bottom;
 address ntop = bottom + size;
 size_t page_sz = os::vm_page_size();
 unsigned pages = size / page_sz;
 // that point by munmap()ping it.  This ensures that when we later
 // munmap() the guard pages we don't leave a hole in the stack
 // mapping. This only affects the main/initial thread
 bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
 if (os::Linux::is_initial_thread()) {
 // As we manually grow stack up to bottom inside create_attached_thread(),
 // it's likely that os::Linux::initial_thread_stack_bottom is mapped and
 // we don't need to do anything special.
 // Check it first, before calling heavy function.
 bool os::unguard_memory(char* addr, size_t size) {
 return linux_mprotect(addr, size, PROT_READ|PROT_WRITE);
 }
-bool os::Linux::transparent_huge_pages_sanity_check(bool warn, size_t page_size) {
+bool os::Linux::transparent_huge_pages_sanity_check(bool warn,
+size_t page_size) {
 bool result = false;
 void *p = mmap(NULL, page_size * 2, PROT_READ|PROT_WRITE,
 MAP_ANONYMOUS|MAP_PRIVATE,
 -1, 0);
 if (p != MAP_FAILED) {
 }
 return result;
 }
-/*
+// Set the coredump_filter bits to include largepages in core dump (bit 6)
-* Set the coredump_filter bits to include largepages in core dump (bit 6)
+//
-*
+// From the coredump_filter documentation:
-* From the coredump_filter documentation:
+//
-*
+// - (bit 0) anonymous private memory
-* - (bit 0) anonymous private memory
+// - (bit 1) anonymous shared memory
-* - (bit 1) anonymous shared memory
+// - (bit 2) file-backed private memory
-* - (bit 2) file-backed private memory
+// - (bit 3) file-backed shared memory
-* - (bit 3) file-backed shared memory
+// - (bit 4) ELF header pages in file-backed private memory areas (it is
-* - (bit 4) ELF header pages in file-backed private memory areas (it is
+//           effective only if the bit 2 is cleared)
-*           effective only if the bit 2 is cleared)
+// - (bit 5) hugetlb private memory
-* - (bit 5) hugetlb private memory
+// - (bit 6) hugetlb shared memory
-* - (bit 6) hugetlb shared memory
+//
-*/
 static void set_coredump_filter(void) {
 FILE *f;
 long cdm;
 if ((f = fopen("/proc/self/coredump_filter", "r+")) == NULL) {
 set_coredump_filter();
 }
 #ifndef SHM_HUGETLB
 #define SHM_HUGETLB 04000
 #endif
-char* os::Linux::reserve_memory_special_shm(size_t bytes, size_t alignment, char* req_addr, bool exec) {
+char* os::Linux::reserve_memory_special_shm(size_t bytes, size_t alignment,
+char* req_addr, bool exec) {
 // "exec" is passed in but not used.  Creating the shared image for
 // the code cache doesn't have an SHM_X executable permission to check.
 assert(UseLargePages && UseSHM, "only for SHM large pages");
 assert(is_ptr_aligned(req_addr, os::large_page_size()), "Unaligned address");
 char *addr;
 bool warn_on_failure = UseLargePages &&
 (!FLAG_IS_DEFAULT(UseLargePages) ||
 !FLAG_IS_DEFAULT(UseSHM) ||
-!FLAG_IS_DEFAULT(LargePageSizeInBytes)
+!FLAG_IS_DEFAULT(LargePageSizeInBytes));
-);
 char msg[128];
 // Create a large shared memory region to attach to based on size.
 // Currently, size is the total size of the heap
 int shmid = shmget(key, bytes, SHM_HUGETLB|IPC_CREAT|SHM_R|SHM_W);
 }
 return addr;
 }
-static void warn_on_large_pages_failure(char* req_addr, size_t bytes, int error) {
+static void warn_on_large_pages_failure(char* req_addr, size_t bytes,
+int error) {
 assert(error == ENOMEM, "Only expect to fail if no memory is available");
 bool warn_on_failure = UseLargePages &&
 (!FLAG_IS_DEFAULT(UseLargePages) ||
 !FLAG_IS_DEFAULT(UseHugeTLBFS) ||
 PTR_FORMAT " bytes: " SIZE_FORMAT " (errno = %d).", req_addr, bytes, error);
 warning("%s", msg);
 }
 }
-char* os::Linux::reserve_memory_special_huge_tlbfs_only(size_t bytes, char* req_addr, bool exec) {
+char* os::Linux::reserve_memory_special_huge_tlbfs_only(size_t bytes,
+char* req_addr,
+bool exec) {
 assert(UseLargePages && UseHugeTLBFS, "only for Huge TLBFS large pages");
 assert(is_size_aligned(bytes, os::large_page_size()), "Unaligned size");
 assert(is_ptr_aligned(req_addr, os::large_page_size()), "Unaligned address");
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 assert(is_ptr_aligned(addr, os::large_page_size()), "Must be");
 return addr;
 }
-char* os::Linux::reserve_memory_special_huge_tlbfs_mixed(size_t bytes, size_t alignment, char* req_addr, bool exec) {
+char* os::Linux::reserve_memory_special_huge_tlbfs_mixed(size_t bytes,
+size_t alignment,
+char* req_addr,
+bool exec) {
 size_t large_page_size = os::large_page_size();
 assert(bytes >= large_page_size, "Shouldn't allocate large pages for small sizes");
 // Allocate small pages.
 }
 return start;
 }
-char* os::Linux::reserve_memory_special_huge_tlbfs(size_t bytes, size_t alignment, char* req_addr, bool exec) {
+char* os::Linux::reserve_memory_special_huge_tlbfs(size_t bytes,
+size_t alignment,
+char* req_addr,
+bool exec) {
 assert(UseLargePages && UseHugeTLBFS, "only for Huge TLBFS large pages");
 assert(is_ptr_aligned(req_addr, alignment), "Must be");
 assert(is_power_of_2(alignment), "Must be");
 assert(is_power_of_2(os::large_page_size()), "Must be");
 assert(bytes >= os::large_page_size(), "Shouldn't allocate large pages for small sizes");
 } else {
 return reserve_memory_special_huge_tlbfs_mixed(bytes, alignment, req_addr, exec);
 }
 }
-char* os::reserve_memory_special(size_t bytes, size_t alignment, char* req_addr, bool exec) {
+char* os::reserve_memory_special(size_t bytes, size_t alignment,
+char* req_addr, bool exec) {
 assert(UseLargePages, "only for large pages");
 char* addr;
 if (UseSHM) {
 addr = os::Linux::reserve_memory_special_shm(bytes, alignment, req_addr, exec);
 size_t os::read(int fd, void *buf, unsigned int nBytes) {
 return ::read(fd, buf, nBytes);
 }
-//
 // Short sleep, direct OS call.
 //
 // Note: certain versions of Linux CFS scheduler (since 2.6.23) do not guarantee
 // sched_yield(2) will actually give up the CPU:
 //
 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);
 int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri);
 return (ret == 0) ? OS_OK : OS_ERR;
 }
-OSReturn os::get_native_priority(const Thread* const thread, int *priority_ptr) {
+OSReturn os::get_native_priority(const Thread* const thread,
+int *priority_ptr) {
 if (!UseThreadPriorities || ThreadPriorityPolicy == 0) {
 *priority_ptr = java_to_os_priority[NormPriority];
 return OS_OK;
 }
 //  - 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) {
+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;
 }
 "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_linux_signal(int signo,
-JVM_handle_linux_signal(int signo, siginfo_t* siginfo,
+siginfo_t* siginfo,
-void* ucontext, int abort_if_unrecognized);
+void* ucontext,
+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_linux_signal(sig, info, uc, true);
 // 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->cr();
 }
-#define DO_SIGNAL_CHECK(sig) \
+#define DO_SIGNAL_CHECK(sig)                      \
-if (!sigismember(&check_signal_done, sig)) \
+do {                                            \
-os::Linux::check_signal_handler(sig)
+if (!sigismember(&check_signal_done, sig)) {  \
+os::Linux::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 (check_signals == false) return;
 // SEGV and BUS if overridden could potentially prevent
 // generation of hs*.log in the event of a crash, debugging
 // such a case can be very challenging, so we absolutely
 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 LinuxThreads the JavaMain thread pid (primordial thread)
 // is different than the pid of the java launcher thread.
 // So, on Linux, 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) {
-{
 Linux::fast_thread_clock_init();
 // Allocate a single page and mark it as readable for safepoint polling
 address polling_page = (address) ::mmap(NULL, Linux::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, Linux::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) {
 // 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;
 status = setrlimit(RLIMIT_NOFILE, &nbr_files);
 if (status != 0) {
-if (PrintMiscellaneous && (Verbose || WizardMode))
+if (PrintMiscellaneous && (Verbose || WizardMode)) {
 perror("os::init_2 setrlimit failed");
+}
 }
 }
 }
 // Initialize lock used to serialize thread creation (see os::create_thread)
 #endif
 }
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
-if (!guard_memory((char*)_polling_page, Linux::page_size()))
+if (!guard_memory((char*)_polling_page, Linux::page_size())) {
 fatal("Could not disable polling page");
-};
+}
+}
 // Mark the polling page as readable
 void os::make_polling_page_readable(void) {
 if (!linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) {
 fatal("Could not enable polling page");
 }
-};
+}
 int os::active_processor_count() {
 // Linux doesn't yet have a (official) notion of processor sets,
 // so just return the number of online processors.
 int online_cpus = ::sysconf(_SC_NPROCESSORS_ONLN);
 PcFetcher fetcher(thread);
 fetcher.run();
 return fetcher.result();
 }
-int os::Linux::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime)
+int os::Linux::safe_cond_timedwait(pthread_cond_t *_cond,
-{
+pthread_mutex_t *_mutex,
+const struct timespec *_abstime) {
 if (is_NPTL()) {
 return pthread_cond_timedwait(_cond, _mutex, _abstime);
 } else {
 // 6292965: LinuxThreads pthread_cond_timedwait() resets FPU control
 // word back to default 64bit precision if condvar is signaled. Java
 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;
 bool os::check_heap(bool force) {
 return true;
 }
-int local_vsnprintf(char* buf, size_t count, const char* format, va_list args) {
+int local_vsnprintf(char* buf, size_t count, const char* format,
+va_list args) {
 return ::vsnprintf(buf, count, format, args);
 }
 // Is a (classpath) directory empty?
 bool os::dir_is_empty(const char* path) {
 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;
 ::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 stat64 buf64;
 if (::fstat64(fd, &buf64) >= 0) {
 mode = buf64.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;
 }
 } else {
 return slow_thread_cpu_time(thread, user_sys_cpu_time);
 }
 }
-//
 //  -1 on error.
-//
 static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time) {
 pid_t  tid = thread->osthread()->thread_id();
 char *s;
 char stat[2048];
 int statlen;
 // JSR166
 // -------------------------------------------------------
-/*
+// The solaris and linux implementations of park/unpark are fairly
-* The solaris and linux 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.
-*/
+// This code is common to linux and solaris and will be moved to a
+// common place in dolphin.
-/*
+//
-* This code is common to linux and solaris and will be moved to a
+// The passed in time value is either a relative time in nanoseconds
-* common place in dolphin.
+// or an absolute time in milliseconds. Either way it has to be unpacked
-*
+// into suitable seconds and nanoseconds components and stored in the
-* The passed in time value is either a relative time in nanoseconds
+// given timespec structure.
-* or an absolute time in milliseconds. Either way it has to be unpacked
+// Given time is a 64-bit value and the time_t used in the timespec is only
-* into suitable seconds and nanoseconds components and stored in the
+// a signed-32-bit value (except on 64-bit Linux) we have to watch for
-* given timespec structure.
+// overflow if times way in the future are given. Further on Solaris versions
-* Given time is a 64-bit value and the time_t used in the timespec is only
+// prior to 10 there is a restriction (see cond_timedwait) that the specified
-* a signed-32-bit value (except on 64-bit Linux) we have to watch for
+// number of seconds, in abstime, is less than current_time  + 100,000,000.
-* overflow if times way in the future are given. Further on Solaris versions
+// As it will be 28 years before "now + 100000000" will overflow we can
-* prior to 10 there is a restriction (see cond_timedwait) that the specified
+// ignore overflow and just impose a hard-limit on seconds using the value
-* number of seconds, in abstime, is less than current_time  + 100,000,000.
+// of "now + 100,000,000". This places a limit on the timeout of about 3.17
-* As it will be 28 years before "now + 100000000" will overflow we can
+// years from "now".
-* 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
-* years from "now".
-*/
 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
 assert(time > 0, "convertTime");
 time_t max_secs = 0;
 if (s < 1) {
 // thread might be parked
 if (_cur_index != -1) {
 // thread is definitely parked
 if (WorkAroundNPTLTimedWaitHang) {
-status = pthread_cond_signal (&_cond[_cur_index]);
+status = pthread_cond_signal(&_cond[_cur_index]);
 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[_cur_index]);
+status = pthread_cond_signal(&_cond[_cur_index]);
 assert(status == 0, "invariant");
 }
 } else {
 pthread_mutex_unlock(_mutex);
 assert(status == 0, "invariant");
 extern char** environ;
 #ifndef __NR_fork
 #define __NR_fork IA32_ONLY(2) IA64_ONLY(not defined) AMD64_ONLY(57)
 #endif
 #ifndef __NR_execve
 #define __NR_execve IA32_ONLY(11) IA64_ONLY(1033) AMD64_ONLY(59)
 #endif
 // Run the specified command in a separate process. Return its exit value,
 // or -1 on failure (e.g. can't fork a new process).
 // Unlike system(), this function can be called from signal handler. It
 // Get path to libjvm.so
 os::jvm_path(buf, sizeof(buf));
 // Get rid of libjvm.so
 p = strrchr(buf, '/');
-if (p == NULL) return false;
+if (p == NULL) {
-else *p = '\0';
+return false;
+} else {
+*p = '\0';
+}
 // Get rid of client or server
 p = strrchr(buf, '/');
-if (p == NULL) return false;
+if (p == NULL) {
-else *p = '\0';
+return false;
+} else {
+*p = '\0';
+}
 // check xawt/libmawt.so
 strcpy(libmawtpath, buf);
 strcat(libmawtpath, xawtstr);
 if (::stat(libmawtpath, &statbuf) == 0) return false;
 // Universe::heap()->size_policy()->set_gc_time_limit_exceeded(true);
 }
 }
 }
-//
 // See if the /dev/mem_notify device exists, and if so, start a thread to monitor it.
 //
 void MemNotifyThread::start() {
-int    fd;
+int fd;
-fd = open ("/dev/mem_notify", O_RDONLY, 0);
+fd = open("/dev/mem_notify", O_RDONLY, 0);
 if (fd < 0) {
 return;
 }
 if (memnotify_thread() == NULL) {
 /////////////// Unit tests ///////////////
 #ifndef PRODUCT
-#define test_log(...) \
+#define test_log(...)              \
-do {\
+do {                             \
-if (VerboseInternalVMTests) { \
+if (VerboseInternalVMTests) {  \
-tty->print_cr(__VA_ARGS__); \
+tty->print_cr(__VA_ARGS__);  \
-tty->flush(); \
+tty->flush();                \
-}\
+}                              \
 } while (false)
 class TestReserveMemorySpecial : AllStatic {
 public:
 static void small_page_write(void* addr, size_t size) {

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 26685	aa239a0dfbea