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

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 // Here are some liblgrp types from sys/lgrp_user.h to be able to
 // compile on older systems without this header file.
 #ifndef MADV_ACCESS_LWP
-# define  MADV_ACCESS_LWP         7       /* next LWP to access heavily */
+#define  MADV_ACCESS_LWP   7       /* next LWP to access heavily */
 #endif
 #ifndef MADV_ACCESS_MANY
-# define  MADV_ACCESS_MANY        8       /* many processes to access heavily */
+#define  MADV_ACCESS_MANY  8       /* many processes to access heavily */
 #endif
 #ifndef LGRP_RSRC_CPU
-# define LGRP_RSRC_CPU           0       /* CPU resources */
+#define LGRP_RSRC_CPU      0       /* CPU resources */
 #endif
 #ifndef LGRP_RSRC_MEM
-# define LGRP_RSRC_MEM           1       /* memory resources */
+#define LGRP_RSRC_MEM      1       /* memory resources */
 #endif
 // see thr_setprio(3T) for the basis of these numbers
 #define MinimumPriority 0
 #define NormalPriority  64
 //
 // Static member initialization for TLS
 Thread* ThreadLocalStorage::_get_thread_cache[ThreadLocalStorage::_pd_cache_size] = {NULL};
 #ifndef PRODUCT
 #define _PCT(n,d)       ((100.0*(double)(n))/(double)(d))
 int ThreadLocalStorage::_tcacheHit = 0;
 int ThreadLocalStorage::_tcacheMiss = 0;
 void ThreadLocalStorage::print_statistics() {
 int total = _tcacheMiss+_tcacheHit;
 tty->print_cr("Thread cache hits %d misses %d total %d percent %f\n",
 _tcacheHit, _tcacheMiss, total, _PCT(_tcacheHit, total));
 }
 #undef _PCT
 #endif // PRODUCT
 Thread* ThreadLocalStorage::get_thread_via_cache_slowly(uintptr_t raw_id,
 int index) {
 Thread *thread = get_thread_slow();
 static volatile hrtime_t max_hrtime = 0;
 void os::Solaris::initialize_system_info() {
 set_processor_count(sysconf(_SC_NPROCESSORS_CONF));
-_processors_online = sysconf (_SC_NPROCESSORS_ONLN);
+_processors_online = sysconf(_SC_NPROCESSORS_ONLN);
-_physical_memory = (julong)sysconf(_SC_PHYS_PAGES) * (julong)sysconf(_SC_PAGESIZE);
+_physical_memory = (julong)sysconf(_SC_PHYS_PAGES) *
+(julong)sysconf(_SC_PAGESIZE);
 }
 int os::active_processor_count() {
 int online_cpus = sysconf(_SC_NPROCESSORS_ONLN);
 pid_t pid = getpid();
 return (bind_result == 0);
 }
 bool os::getenv(const char* name, char* buffer, int len) {
 char* val = ::getenv(name);
-if (val == NULL
+if (val == NULL || strlen(val) + 1 > len) {
-||   strlen(val) + 1  >  len ) {
+if (len > 0) buffer[0] = 0; // return a null string
-if (len > 0)  buffer[0] = 0; // return a null string
 return false;
 }
 strcpy(buffer, val);
 return true;
 }
 void os::breakpoint() {
 BREAKPOINT;
 }
-bool os::obsolete_option(const JavaVMOption *option)
+bool os::obsolete_option(const JavaVMOption *option) {
-{
 if (!strncmp(option->optionString, "-Xt", 3)) {
 return true;
 } else if (!strncmp(option->optionString, "-Xtm", 4)) {
 return true;
 } else if (!strncmp(option->optionString, "-Xverifyheap", 12)) {
 return osthread;
 }
 void os::Solaris::hotspot_sigmask(Thread* thread) {
 //Save caller's signal mask
 sigset_t sigmask;
 thr_sigsetmask(SIG_SETMASK, NULL, &sigmask);
 OSThread *osthread = thread->osthread();
 osthread->set_caller_sigmask(sigmask);
 return true;
 }
-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) {
 // Allocate the OSThread object
 OSThread* osthread = new OSThread(NULL, NULL);
 if (osthread == NULL) {
 return false;
 }
 // The thread is returned suspended (in state INITIALIZED), and is started higher up in the call chain
 return true;
 }
-/* defined for >= Solaris 10. This allows builds on earlier versions
+// defined for >= Solaris 10. This allows builds on earlier versions
-*  of Solaris to take advantage of the newly reserved Solaris JVM signals
+// of Solaris to take advantage of the newly reserved Solaris JVM signals
-*  With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2
+// With SIGJVM1, SIGJVM2, INTERRUPT_SIGNAL is SIGJVM1, ASYNC_SIGNAL is SIGJVM2
-*  and -XX:+UseAltSigs does nothing since these should have no conflict
+// and -XX:+UseAltSigs does nothing since these should have no conflict
-*/
+//
 #if !defined(SIGJVM1)
 #define SIGJVM1 39
 #define SIGJVM2 40
 #endif
 debug_only(static bool signal_sets_initialized = false);
 static sigset_t unblocked_sigs, vm_sigs, allowdebug_blocked_sigs;
 int os::Solaris::_SIGinterrupt = INTERRUPT_SIGNAL;
 bool os::Solaris::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;
+}
 }
 // Note: SIGRTMIN is a macro that calls sysconf() so it will
 // dynamically detect SIGRTMIN value for the system at runtime, not buildtime
 static bool isJVM1available() {
 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);
 // For diagnostics only used in run_periodic_checks
 sigemptyset(&check_signal_done);
 }
 stack_size = (size_t)(base - bottom);
 assert(stack_size > 0, "Stack size calculation problem");
 if (stack_size > jt->stack_size()) {
-NOT_PRODUCT(
+#ifndef PRODUCT
 struct rlimit limits;
 getrlimit(RLIMIT_STACK, &limits);
 size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur);
 assert(size >= jt->stack_size(), "Stack size problem in main thread");
-)
+#endif
-tty->print_cr(
+tty->print_cr("Stack size of %d Kb exceeds current limit of %d Kb.\n"
-"Stack size of %d Kb exceeds current limit of %d Kb.\n"
 "(Stack sizes are rounded up to a multiple of the system page size.)\n"
 "See limit(1) to increase the stack size limit.",
 stack_size / K, jt->stack_size() / K);
 vm_exit(1);
 }
 //           interface.  I think, however, that it will be faster to
 //           maintain the invariant that %g2 always contains the
 //           JavaThread in Java code, and have stubs simply
 //           treat %g2 as a caller-save register, preserving it in a %lN.
 thread_key_t tk;
-if (thr_keycreate( &tk, NULL))
+if (thr_keycreate(&tk, NULL)) {
 fatal(err_msg("os::allocate_thread_local_storage: thr_keycreate failed "
 "(%s)", strerror(errno)));
+}
 return int(tk);
 }
 void os::free_thread_local_storage(int index) {
 // %%% don't think we need anything here
-// if ( pthread_key_delete((pthread_key_t) tk) )
+// if (pthread_key_delete((pthread_key_t) tk)) {
 //   fatal("os::free_thread_local_storage: pthread_key_delete failed");
-}
+// }
+}
-#define SMALLINT 32   // libthread allocate for tsd_common is a version specific
+// libthread allocate for tsd_common is a version specific
 // small number - point is NO swap space available
+#define SMALLINT 32
 void os::thread_local_storage_at_put(int index, void* value) {
 // %%% this is used only in threadLocalStorage.cpp
 if (thr_setspecific((thread_key_t)index, value)) {
 if (errno == ENOMEM) {
 vm_exit_out_of_memory(SMALLINT, OOM_MALLOC_ERROR,
 bool os::supports_vtime() { return true; }
 bool os::enable_vtime() {
 int fd = ::open("/proc/self/ctl", O_WRONLY);
-if (fd == -1)
+if (fd == -1) {
 return false;
+}
 long cmd[] = { PCSET, PR_MSACCT };
 int res = ::write(fd, cmd, sizeof(long) * 2);
 ::close(fd);
-if (res != sizeof(long) * 2)
+if (res != sizeof(long) * 2) {
 return false;
+}
 return true;
 }
 bool os::vtime_enabled() {
 int fd = ::open("/proc/self/status", O_RDONLY);
-if (fd == -1)
+if (fd == -1) {
 return false;
+}
 pstatus_t status;
 int res = os::read(fd, (void*) &status, sizeof(pstatus_t));
 ::close(fd);
-if (res != sizeof(pstatus_t))
+if (res != sizeof(pstatus_t)) {
 return false;
+}
 return status.pr_flags & PR_MSACCT;
 }
 double os::elapsedVTime() {
 return (double)gethrvtime() / (double)hrtime_hz;
 }
 // Must return millis since Jan 1 1970 for JVM_CurrentTimeMillis
 jlong os::javaTimeMillis() {
 timeval t;
-if (gettimeofday( &t, NULL) == -1)
+if (gettimeofday(&t, NULL) == -1) {
 fatal(err_msg("os::javaTimeMillis: gettimeofday (%s)", strerror(errno)));
+}
 return jlong(t.tv_sec) * 1000  +  jlong(t.tv_usec) / 1000;
 }
 jlong os::javaTimeNanos() {
 return (jlong)getTimeNanos();
 }
 return false;
 }
-typedef int (*dladdr1_func_type) (void *, Dl_info *, void **, int);
+typedef int (*dladdr1_func_type)(void *, Dl_info *, void **, int);
 static dladdr1_func_type dladdr1_func = NULL;
 bool os::dll_address_to_function_name(address addr, char *buf,
 int buflen, int * offset) {
 // buf is not optional, but offset is optional
 // Support for dladdr1 is checked at runtime; it may be
 // available even if the vm is built on a machine that does
 // not have dladdr1 support.  Make sure there is a value for
 // RTLD_DL_SYMENT.
 #ifndef RTLD_DL_SYMENT
 #define RTLD_DL_SYMENT 1
 #endif
 #ifdef _LP64
 Elf64_Sym * info;
 #else
 Elf32_Sym * info;
 #endif
 // Loads .dll/.so and
 // in case of error it checks if .dll/.so was built for the
 // same architecture as Hotspot is running on
-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;
 }
 {EM_PPC,         EM_PPC,     ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
 {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
 {EM_ARM,         EM_ARM,     ELFCLASS32, ELFDATA2LSB, (char*)"ARM 32"}
 };
 #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;
 #else
 #error Method os::dll_load requires that one of following is defined:\
 IA32, AMD64, IA64, __sparc, __powerpc__, ARM, ARM
 #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};
 // 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) {
 struct sigaction sigAct, oldSigAct;
 sigfillset(&(sigAct.sa_mask));
 sigAct.sa_flags = SA_RESTART & ~SA_RESETHAND;
 sigAct.sa_handler = CAST_TO_FN_PTR(sa_handler_t, handler);
-if (sigaction(signal_number, &sigAct, &oldSigAct))
+if (sigaction(signal_number, &sigAct, &oldSigAct)) {
 // -1 means registration failed
 return (void *)-1;
+}
 return CAST_FROM_FN_PTR(void*, oldSigAct.sa_handler);
 }
 void os::signal_raise(int signal_number) {
 raise(signal_number);
 }
-/*
+// The following code is moved from os.cpp for making this
-* 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.
-*/
 // a counter for each possible signal value
 static int Sigexit = 0;
 static int Maxlibjsigsigs;
 static jint *pending_signals = NULL;
 * (Maxsignum + 1), mtInternal);
 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
 preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
 }
-ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ), mtInternal);
+ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
 }
 void os::signal_init_pd() {
 int ret;
 assert(ret == 0, "sema_wait() failed");
 // 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.
-//
 ret = ::sema_post(&sig_sem);
 assert(ret == 0, "sema_post() failed");
 thread->java_suspend_self();
 }
 return false;
 }
 // Scan the pages from start to end until a page different than
 // the one described in the info parameter is encountered.
-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) {
 const uint_t info_types[] = { MEMINFO_VLGRP, MEMINFO_VPAGESIZE };
 const size_t types = sizeof(info_types) / sizeof(info_types[0]);
 uint64_t addrs[MAX_MEMINFO_CNT], outdata[types * MAX_MEMINFO_CNT + 1];
 uint_t validity[MAX_MEMINFO_CNT];
 if ((validity[i] & 1) != 0) {
 if ((validity[i] & 4) != 0) {
 if (outdata[types * i + 1] != page_expected->size) {
 break;
 }
-} else
+} else if (page_expected->size != 0) {
-if (page_expected->size != 0) {
 break;
 }
 if ((validity[i] & 2) != 0 && page_expected->lgrp_id > 0) {
 if (outdata[types * i] != page_expected->lgrp_id) {
 return NULL;
 }
 return b;
 }
-char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes, size_t alignment_hint, bool fixed) {
+char* os::Solaris::anon_mmap(char* requested_addr, size_t bytes,
+size_t alignment_hint, bool fixed) {
 char* addr = requested_addr;
 int flags = MAP_PRIVATE | MAP_NORESERVE;
-assert(!(fixed && (alignment_hint > 0)), "alignment hint meaningless with fixed mmap");
+assert(!(fixed && (alignment_hint > 0)),
+"alignment hint meaningless with fixed mmap");
 if (fixed) {
 flags |= MAP_FIXED;
 } else if (has_map_align && (alignment_hint > (size_t) vm_page_size())) {
 flags |= MAP_ALIGN;
 // uncommitted page. Otherwise, the read/write might succeed if we
 // have enough swap space to back the physical page.
 return mmap_chunk(addr, bytes, flags, PROT_NONE);
 }
-char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
+char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
-char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL));
+size_t alignment_hint) {
+char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint,
+(requested_addr != NULL));
 guarantee(requested_addr == NULL || requested_addr == addr,
 "OS failed to return requested mmap address.");
 return addr;
 }
 UseLargePages = Solaris::mpss_sanity_check(warn_on_failure, &_large_page_size);
 }
 }
-bool os::Solaris::setup_large_pages(caddr_t start, size_t bytes, size_t align) {
+bool os::Solaris::setup_large_pages(caddr_t start, size_t bytes,
+size_t align) {
 // Signal to OS that we want large pages for addresses
 // from addr, addr + bytes
 struct memcntl_mha mpss_struct;
 mpss_struct.mha_cmd = MHA_MAPSIZE_VA;
 mpss_struct.mha_pagesize = align;
 return false;
 }
 return true;
 }
-char* os::reserve_memory_special(size_t size, size_t alignment, char* addr, bool exec) {
+char* os::reserve_memory_special(size_t size, size_t alignment, char* addr,
+bool exec) {
 fatal("os::reserve_memory_special should not be called on Solaris.");
 return NULL;
 }
 bool os::release_memory_special(char* base, size_t bytes) {
 bool os::dont_yield() {
 if (DontYieldALot) {
 static hrtime_t last_time = 0;
 hrtime_t diff = getTimeNanos() - last_time;
-if (diff < DontYieldALotInterval * 1000000)
+if (diff < DontYieldALotInterval * 1000000) {
 return true;
+}
 last_time += diff;
 return false;
-}
+} else {
-else {
 return false;
 }
 }
 // Note that yield semantics are defined by the scheduling class to which
 myMin = fxLimits.minPrio;
 myMax = fxLimits.maxPrio;
 myMax = MIN2(myMax, (int)fxInfo->fx_uprilim);       // clamp - restrict
 } else {
 // No clue - punt
-if (ThreadPriorityVerbose)
+if (ThreadPriorityVerbose) {
-tty->print_cr("Unknown scheduling class: %s ... \n", ClassInfo.pc_clname);
+tty->print_cr("Unknown scheduling class: %s ... \n",
+ClassInfo.pc_clname);
+}
 return EINVAL;      // no clue, punt
 }
 if (ThreadPriorityVerbose) {
 tty->print_cr("Thread priority Range: [%d..%d]\n", myMin, myMax);
 // scale_to_lwp_priority
 //
 // Convert from the libthread "thr_setprio" scale to our current
 // lwp scheduling class scale.
 //
-static
+static int scale_to_lwp_priority(int rMin, int rMax, int x) {
-int     scale_to_lwp_priority (int rMin, int rMax, int x)
-{
 int v;
 if (x == 127) return rMax;            // avoid round-down
 v = (((x*(rMax-rMin)))/128)+rMin;
 return v;
 // Cache "pcparms_t" in global ParmCache.
 // TODO: elide set-to-same-value
 // If something went wrong on init, don't change priorities.
 if (!priocntl_enable) {
-if (ThreadPriorityVerbose)
+if (ThreadPriorityVerbose) {
 tty->print_cr("Trying to set priority but init failed, ignoring");
+}
 return EINVAL;
 }
 // If lwp hasn't started yet, just return
 // the _start routine will call us again.
 // This mode causes the priority table to get filled with
 // linear values.  NormPriority get's mapped to 50% of the
 // Maximum priority an so on.  This will cause VM threads
 // to get unfair treatment against other Solaris processes
 // which do not explicitly alter their thread priorities.
-//
 int os::java_to_os_priority[CriticalPriority + 1] = {
 -99999,         // 0 Entry should never be used
 0,              // 1 MinPriority
 status |= lwp_status;
 return (status == 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) {
 int p;
 if (!UseThreadPriorities) {
 *priority_ptr = NormalPriority;
 return OS_OK;
 }
 }
 // This does not do anything on Solaris. This is basically a hook for being
 // able to use structured exception handling (thread-local exception filters) on, e.g., Win32.
-void os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method, JavaCallArguments* args, Thread* thread) {
+void os::os_exception_wrapper(java_call_t f, JavaValue* value,
+methodHandle* method, JavaCallArguments* args,
+Thread* thread) {
 f(value, method, args, thread);
 }
 // This routine may be used by user applications as a "hook" to catch signals.
 // The user-defined signal handler must pass unrecognized signals to this
 // 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_solaris_signal(int signo,
-JVM_handle_solaris_signal(int signo, siginfo_t* siginfo, void* ucontext,
+siginfo_t* siginfo,
-int abort_if_unrecognized);
+void* ucontext,
+int abort_if_unrecognized);
 void signalHandler(int sig, siginfo_t* info, void* ucVoid) {
 int orig_errno = errno;  // Preserve errno value over signal handler.
 JVM_handle_solaris_signal(sig, info, ucVoid, true);
 errno = orig_errno;
 }
-/* Do not delete - if guarantee is ever removed,  a signal handler (even empty)
+// Do not delete - if guarantee is ever removed,  a signal handler (even empty)
-is needed to provoke threads blocked on IO to return an EINTR
+// is needed to provoke threads blocked on IO to return an EINTR
-Note: this explicitly does NOT call JVM_handle_solaris_signal and
+// Note: this explicitly does NOT call JVM_handle_solaris_signal and
-does NOT participate in signal chaining due to requirement for
+// does NOT participate in signal chaining due to requirement for
-NOT setting SA_RESTART to make EINTR work. */
+// NOT setting SA_RESTART to make EINTR work.
 extern "C" void sigINTRHandler(int sig, siginfo_t* info, void* ucVoid) {
 if (UseSignalChaining) {
 struct sigaction *actp = os::Solaris::get_chained_signal_action(sig);
 if (actp && actp->sa_handler) {
 vm_exit_during_initialization("Signal chaining detected for VM interrupt signal, try -XX:+UseAltSigs");
 }
 return chained;
 }
 struct sigaction* os::Solaris::get_preinstalled_handler(int sig) {
-assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized");
+assert((chainedsigactions != (struct sigaction *)NULL) &&
+(preinstalled_sigs != (int *)NULL), "signals not yet initialized");
 if (preinstalled_sigs[sig] != 0) {
 return &chainedsigactions[sig];
 }
 return NULL;
 }
-void os::Solaris::save_preinstalled_handler(int sig, struct sigaction& oldAct) {
+void os::Solaris::save_preinstalled_handler(int sig,
+struct sigaction& oldAct) {
 assert(sig > 0 && sig <= Maxsignum, "vm signal out of expected range");
-assert((chainedsigactions != (struct sigaction *)NULL) && (preinstalled_sigs != (int *)NULL) , "signals not yet initialized");
+assert((chainedsigactions != (struct sigaction *)NULL) &&
+(preinstalled_sigs != (int *)NULL), "signals not yet initialized");
 chainedsigactions[sig] = oldAct;
 preinstalled_sigs[sig] = 1;
 }
-void os::Solaris::set_signal_handler(int sig, bool set_installed, bool oktochain) {
+void os::Solaris::set_signal_handler(int sig, bool set_installed,
+bool oktochain) {
 // Check for overwrite.
 struct sigaction oldAct;
 sigaction(sig, (struct sigaction*)NULL, &oldAct);
-void* oldhand = oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oldAct.sa_sigaction)
+void* oldhand =
-: CAST_FROM_FN_PTR(void*,  oldAct.sa_handler);
+oldAct.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oldAct.sa_sigaction)
+: CAST_FROM_FN_PTR(void*,  oldAct.sa_handler);
 if (oldhand != CAST_FROM_FN_PTR(void*, SIG_DFL) &&
 oldhand != CAST_FROM_FN_PTR(void*, SIG_IGN) &&
 oldhand != CAST_FROM_FN_PTR(void*, signalHandler)) {
 if (AllowUserSignalHandlers || !set_installed) {
 // Do not overwrite; user takes responsibility to forward to us.
 sigAct.sa_sigaction = signalHandler;
 // Handle SIGSEGV on alternate signal stack if
 // not using stack banging
 if (!UseStackBanging && sig == SIGSEGV) {
 sigAct.sa_flags = SA_SIGINFO | SA_RESTART | SA_ONSTACK;
+} else if (sig == os::Solaris::SIGinterrupt()) {
 // Interruptible i/o requires SA_RESTART cleared so EINTR
 // is returned instead of restarting system calls
-} else if (sig == os::Solaris::SIGinterrupt()) {
 sigemptyset(&sigAct.sa_mask);
 sigAct.sa_handler = NULL;
 sigAct.sa_flags = SA_SIGINFO;
 sigAct.sa_sigaction = sigINTRHandler;
 } else {
 : CAST_FROM_FN_PTR(void*, oldAct.sa_handler);
 assert(oldhand2 == oldhand, "no concurrent signal handler installation");
 }
-#define DO_SIGNAL_CHECK(sig) \
+#define DO_SIGNAL_CHECK(sig)                      \
-if (!sigismember(&check_signal_done, sig)) \
+do {                                            \
-os::Solaris::check_signal_handler(sig)
+if (!sigismember(&check_signal_done, sig)) {  \
+os::Solaris::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() {
 }
 }
 }
-void report_error(const char* file_name, int line_no, const char* title, const char* format, ...);
+void report_error(const char* file_name, int line_no, const char* title,
+const char* format, ...);
 const char * signames[] = {
 "SIG0",
 "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGTRAP",
 "SIGABRT", "SIGEMT", "SIGFPE", "SIGKILL", "SIGBUS",
 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_signal")));
 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("_lwp_cond_broadcast")));
 os::Solaris::set_cond_init(lwp_cond_init);
 os::Solaris::set_cond_destroy(lwp_cond_destroy);
 os::Solaris::set_cond_scope(USYNC_THREAD);
-}
+} else {
-else {
 os::Solaris::set_mutex_scope(USYNC_THREAD);
 os::Solaris::set_cond_scope(USYNC_THREAD);
 if (UsePthreads) {
 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("pthread_mutex_lock")));
 os::Solaris::set_cond_wait(CAST_TO_FN_PTR(int_fnP_cond_tP_mutex_tP, resolve_symbol("pthread_cond_wait")));
 os::Solaris::set_cond_signal(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_signal")));
 os::Solaris::set_cond_broadcast(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_broadcast")));
 os::Solaris::set_cond_init(pthread_cond_default_init);
 os::Solaris::set_cond_destroy(CAST_TO_FN_PTR(int_fnP_cond_tP, resolve_symbol("pthread_cond_destroy")));
-}
+} else {
-else {
 os::Solaris::set_mutex_lock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_lock")));
 os::Solaris::set_mutex_trylock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_trylock")));
 os::Solaris::set_mutex_unlock(CAST_TO_FN_PTR(int_fnP_mutex_tP, resolve_symbol("mutex_unlock")));
 os::Solaris::set_mutex_init(::mutex_init);
 os::Solaris::set_mutex_destroy(::mutex_destroy);
 max_hrtime = first_hrtime = gethrtime();
 init_random(1234567);
 page_size = sysconf(_SC_PAGESIZE);
-if (page_size == -1)
+if (page_size == -1) {
 fatal(err_msg("os_solaris.cpp: os::init: sysconf failed (%s)",
 strerror(errno)));
+}
 init_page_sizes((size_t) page_size);
 Solaris::initialize_system_info();
 // Initialize misc. symbols as soon as possible, so we can use them
 // check if dladdr1() exists; dladdr1 can provide more information than
 // dladdr for os::dll_address_to_function_name. It comes with SunOS 5.9
 // and is available on linker patches for 5.7 and 5.8.
 // libdl.so must have been loaded, this call is just an entry lookup
 void * hdl = dlopen("libdl.so", RTLD_NOW);
-if (hdl)
+if (hdl) {
 dladdr1_func = CAST_TO_FN_PTR(dladdr1_func_type, dlsym(hdl, "dladdr1"));
+}
 // (Solaris only) this switches to calls that actually do locking.
 ThreadCritical::initialize();
 main_thread = thr_self();
 }
 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)Solaris::mmap_chunk(NULL, page_size, MAP_PRIVATE, PROT_READ | PROT_WRITE);
 guarantee(mem_serialize_page != NULL, "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
 }
 // Check minimum allowable stack size for thread creation and to initialize
 // the java system classes, including StackOverflowError - depends on page
 // 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");
+}
 }
 }
 }
 // Calculate theoretical max. size of Threads to guard gainst
 return;
 }
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
-if (mprotect((char *)_polling_page, page_size, PROT_NONE) != 0)
+if (mprotect((char *)_polling_page, page_size, PROT_NONE) != 0) {
 fatal("Could not disable polling page");
-};
+}
+}
 // Mark the polling page as readable
 void os::make_polling_page_readable(void) {
-if (mprotect((char *)_polling_page, page_size, PROT_READ) != 0)
+if (mprotect((char *)_polling_page, page_size, PROT_READ) != 0) {
 fatal("Could not enable polling page");
-};
+}
+}
 // OS interface.
 bool os::check_heap(bool force) { return true; }
 int local_vsnprintf(char* buf, size_t count, const char* fmt, va_list argptr) {
 if (!sol_vsnprintf) {
 //search  for the named symbol in the objects that were loaded after libjvm
 void* where = RTLD_NEXT;
-if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL)
+if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL) {
 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf"));
+}
 if (!sol_vsnprintf){
 //search  for the named symbol in the objects that were loaded before libjvm
 where = RTLD_DEFAULT;
-if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL)
+if ((sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "__vsnprintf"))) == NULL) {
 sol_vsnprintf = CAST_TO_FN_PTR(vsnprintf_t, dlsym(where, "vsnprintf"));
+}
 assert(sol_vsnprintf != NULL, "vsnprintf not found");
 }
 }
 return (*sol_vsnprintf)(buf, count, fmt, argptr);
 }
 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];
 struct dirent *dbuf = (struct dirent *) buf;
 while (result && (ptr = readdir(dir, dbuf)) != NULL) {
 if (strcmp(ptr->d_name, ".") != 0 && strcmp(ptr->d_name, "..") != 0) {
 // 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
 oflag = oflag & ~O_DELETE;
 fd = ::open64(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 stat64 buf64;
 int ret = ::fstat64(fd, &buf64);
 int st_mode = buf64.st_mode;
 } else {
 ::close(fd);
 return -1;
 }
 }
-/*
-* 32-bit Solaris systems suffer from:
+// 32-bit Solaris systems suffer from:
-*
+//
-* - an historical default soft limit of 256 per-process file
+// - an historical default soft limit of 256 per-process file
-*   descriptors that is too low for many Java programs.
+//   descriptors that is too low for many Java programs.
-*
+//
-* - a design flaw where file descriptors created using stdio
+// - a design flaw where file descriptors created using stdio
-*   fopen must be less than 256, _even_ when the first limit above
+//   fopen must be less than 256, _even_ when the first limit above
-*   has been raised.  This can cause calls to fopen (but not calls to
+//   has been raised.  This can cause calls to fopen (but not calls to
-*   open, for example) to fail mysteriously, perhaps in 3rd party
+//   open, for example) to fail mysteriously, perhaps in 3rd party
-*   native code (although the JDK itself uses fopen).  One can hardly
+//   native code (although the JDK itself uses fopen).  One can hardly
-*   criticize them for using this most standard of all functions.
+//   criticize them for using this most standard of all functions.
-*
+//
-* We attempt to make everything work anyways by:
+// We attempt to make everything work anyways by:
-*
+//
-* - raising the soft limit on per-process file descriptors beyond
+// - raising the soft limit on per-process file descriptors beyond
-*   256
+//   256
-*
+//
-* - As of Solaris 10u4, we can request that Solaris raise the 256
+// - As of Solaris 10u4, we can request that Solaris raise the 256
-*   stdio fopen limit by calling function enable_extended_FILE_stdio.
+//   stdio fopen limit by calling function enable_extended_FILE_stdio.
-*   This is done in init_2 and recorded in enabled_extended_FILE_stdio
+//   This is done in init_2 and recorded in enabled_extended_FILE_stdio
-*
+//
-* - If we are stuck on an old (pre 10u4) Solaris system, we can
+// - If we are stuck on an old (pre 10u4) Solaris system, we can
-*   workaround the bug by remapping non-stdio file descriptors below
+//   workaround the bug by remapping non-stdio file descriptors below
-*   256 to ones beyond 256, which is done below.
+//   256 to ones beyond 256, which is done below.
-*
+//
-* See:
+// See:
-* 1085341: 32-bit stdio routines should support file descriptors >255
+// 1085341: 32-bit stdio routines should support file descriptors >255
-* 6533291: Work around 32-bit Solaris stdio limit of 256 open files
+// 6533291: Work around 32-bit Solaris stdio limit of 256 open files
-* 6431278: Netbeans crash on 32 bit Solaris: need to call
+// 6431278: Netbeans crash on 32 bit Solaris: need to call
-*          enable_extended_FILE_stdio() in VM initialisation
+//          enable_extended_FILE_stdio() in VM initialisation
-* Giri Mandalika's blog
+// Giri Mandalika's blog
-* http://technopark02.blogspot.com/2005_05_01_archive.html
+// http://technopark02.blogspot.com/2005_05_01_archive.html
-*/
+//
 #ifndef  _LP64
 if ((!enabled_extended_FILE_stdio) && fd < 256) {
 int newfd = ::fcntl(fd, F_DUPFD, 256);
 if (newfd != -1) {
 ::close(fd);
 fd = newfd;
 }
 }
 #endif // 32-bit Solaris
-/*
-* 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);
 void record_synch(char* name, bool returning);  // defined below
 class RecordSynch {
 char* _name;
 public:
-RecordSynch(char* name) :_name(name)
+RecordSynch(char* name) :_name(name) { record_synch(_name, false); }
-{ record_synch(_name, false); }
+~RecordSynch()                       { record_synch(_name, true); }
-~RecordSynch() { record_synch(_name,   true);  }
 };
 #define CHECK_SYNCH_OP(ret, name, params, args, inner)          \
 extern "C" ret name params {                                    \
 typedef ret name##_t params;                                  \
 if (!CHECK_POINTER_OK(cv)) fatal("Condvar must be in C heap only.");
 #define CHECK_P(p) \
 if (!CHECK_POINTER_OK(p))  fatal(false,  "Pointer must be in C heap only.");
 #define CHECK_MUTEX(mutex_op) \
 CHECK_SYNCH_OP(int, mutex_op, (mutex_t *mu), (mu), CHECK_MU);
 CHECK_MUTEX(   mutex_lock)
 CHECK_MUTEX(  _mutex_lock)
 CHECK_MUTEX( mutex_unlock)
 CHECK_MUTEX(_mutex_unlock)
 CHECK_MUTEX( mutex_trylock)
 CHECK_MUTEX(_mutex_trylock)
 #define CHECK_COND(cond_op) \
-CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU;CHECK_CV);
+CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu), (cv, mu), CHECK_MU; CHECK_CV);
 CHECK_COND( cond_wait);
 CHECK_COND(_cond_wait);
 CHECK_COND(_cond_wait_cancel);
 #define CHECK_COND2(cond_op) \
-CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU;CHECK_CV);
+CHECK_SYNCH_OP(int, cond_op, (cond_t *cv, mutex_t *mu, timestruc_t* ts), (cv, mu, ts), CHECK_MU; CHECK_CV);
 CHECK_COND2( cond_timedwait);
 CHECK_COND2(_cond_timedwait);
 CHECK_COND2(_cond_timedwait_cancel);
 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+%#lx", dlinfo.dli_sname, addr-(intptr_t)dlinfo.dli_saddr);
-} else if (dlinfo.dli_fbase != NULL)
+} else if (dlinfo.dli_fbase != NULL) {
 st->print("<offset %#lx>", addr-(intptr_t)dlinfo.dli_fbase);
-else
+} else {
 st->print("<absolute address>");
+}
 if (dlinfo.dli_fname != NULL) {
 st->print(" in %s", dlinfo.dli_fname);
 }
 if (dlinfo.dli_fbase != NULL) {
 st->print(" at " PTR_FORMAT, dlinfo.dli_fbase);
 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;
 }
 // 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 _counter.
-* mutex/condvar pair, plus _counter.
+// Park decrements _counter if > 0, else does a condvar wait.  Unpark
-* Park decrements _counter 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 linux and solaris and will be moved to a
+// This code is common to linux 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 Linux) we have to watch for
+// a signed-32-bit value (except on 64-bit Linux) 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(timespec* absTime, bool isAbsolute, jlong time) {
 assert(time > 0, "convertTime");
 struct timeval now;
 int status = gettimeofday(&now, NULL);
 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
 // 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;
 if (res == OS_ERR && errno == EINTR) {
 if (timeout != -1) {
 gettimeofday(&t, &aNull);
 newtime = ((julong)t.tv_sec * 1000)  +  t.tv_usec /1000;
 timeout -= newtime - prevtime;
-if (timeout <= 0)
+if (timeout <= 0) {
 return OS_OK;
+}
 prevtime = newtime;
 }
 } else return res;
 }
 }
 //                      connection  attempt  has  not yet been com-
 //                      pleted.
 //
 //     EISCONN          The socket is already connected.
 if (_result == OS_ERR && errno == EINTR) {
-/* restarting a connect() changes its errno semantics */
+// restarting a connect() changes its errno semantics
 RESTARTABLE(::connect(fd, him, len), _result);
-/* undo these changes */
+// undo these changes
 if (_result == OS_ERR) {
 if (errno == EALREADY) {
-errno = EINPROGRESS; /* fall through */
+errno = EINPROGRESS; // fall through
 } else if (errno == EISCONN) {
 errno = 0;
 return OS_OK;
 }
 }

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 26685	aa239a0dfbea