diff -r fc4e54527641 -r 244218e6ec0a hotspot/src/os/linux/vm/os_linux.cpp --- a/hotspot/src/os/linux/vm/os_linux.cpp Fri Jun 13 19:07:11 2014 -0700 +++ b/hotspot/src/os/linux/vm/os_linux.cpp Tue Jun 17 12:54:01 2014 -0700 @@ -862,7 +862,7 @@ case os::java_thread: // Java threads use ThreadStackSize which default value can be // changed with the flag -Xss - assert (JavaThread::stack_size_at_create() > 0, "this should be set"); + assert(JavaThread::stack_size_at_create() > 0, "this should be set"); stack_size = JavaThread::stack_size_at_create(); break; case os::compiler_thread: @@ -1097,7 +1097,7 @@ if (low <= addr && addr < high) { if (vma_low) *vma_low = low; if (vma_high) *vma_high = high; - fclose (fp); + fclose(fp); return true; } } @@ -1420,7 +1420,7 @@ // must return at least tp.tv_sec == 0 which means a resolution // better than 1 sec. This is extra check for reliability. - if(pthread_getcpuclockid_func && + if (pthread_getcpuclockid_func && pthread_getcpuclockid_func(_main_thread, &clockid) == 0 && sys_clock_getres(clockid, &tp) == 0 && tp.tv_sec == 0) { @@ -1630,7 +1630,7 @@ if (pelements == NULL) { return false; } - for (int i = 0 ; i < n ; i++) { + for (int i = 0; i < n; i++) { // Really shouldn't be NULL, but check can't hurt if (pelements[i] == NULL || strlen(pelements[i]) == 0) { continue; // skip the empty path values @@ -1642,7 +1642,7 @@ } } // release the storage - for (int i = 0 ; i < n ; i++) { + for (int i = 0; i < n; i++) { if (pelements[i] != NULL) { FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal); } @@ -1906,7 +1906,7 @@ bool failed_to_read_elf_head= (sizeof(elf_head)!= - (::read(file_descriptor, &elf_head,sizeof(elf_head)))) ; + (::read(file_descriptor, &elf_head,sizeof(elf_head)))); ::close(file_descriptor); if (failed_to_read_elf_head) { @@ -1988,7 +1988,7 @@ arch_t lib_arch={elf_head.e_machine,0,elf_head.e_ident[EI_CLASS], elf_head.e_ident[EI_DATA], NULL}; int running_arch_index=-1; - for (unsigned int i=0 ; i < ARRAY_SIZE(arch_array) ; i++ ) { + for (unsigned int i=0; i < ARRAY_SIZE(arch_array); i++) { if (running_arch_code == arch_array[i].code) { running_arch_index = i; } @@ -2019,7 +2019,7 @@ #endif // !S390 if (lib_arch.compat_class != arch_array[running_arch_index].compat_class) { - if ( lib_arch.name!=NULL ) { + 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); @@ -3793,7 +3793,7 @@ sched_yield(); } -os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN ;} +os::YieldResult os::NakedYield() { sched_yield(); return os::YIELD_UNKNOWN; } void os::yield_all() { // Yields to all threads, including threads with lower priorities @@ -3858,14 +3858,14 @@ } OSReturn os::set_native_priority(Thread* thread, int newpri) { - if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) return OS_OK; + if (!UseThreadPriorities || ThreadPriorityPolicy == 0) return OS_OK; 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) { - if ( !UseThreadPriorities || ThreadPriorityPolicy == 0 ) { + if (!UseThreadPriorities || ThreadPriorityPolicy == 0) { *priority_ptr = java_to_os_priority[NormPriority]; return OS_OK; } @@ -4219,7 +4219,7 @@ } struct sigaction* os::Linux::get_preinstalled_handler(int sig) { - if ((( (unsigned int)1 << sig ) & sigs) != 0) { + if ((((unsigned int)1 << sig) & sigs) != 0) { return &sigact[sig]; } return NULL; @@ -4423,7 +4423,7 @@ address rh = VMError::get_resetted_sighandler(sig); // May be, handler was resetted by VMError? - if(rh != NULL) { + if (rh != NULL) { handler = rh; sa.sa_flags = VMError::get_resetted_sigflags(sig) & SIGNIFICANT_SIGNAL_MASK; } @@ -4432,11 +4432,11 @@ 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) || + 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::Linux::get_our_sigflags(sig)) { + if ((int)sa.sa_flags != os::Linux::get_our_sigflags(sig)) { st->print( ", flags was changed from " PTR32_FORMAT ", consider using jsig library", os::Linux::get_our_sigflags(sig)); @@ -4507,10 +4507,10 @@ address thisHandler = (act.sa_flags & SA_SIGINFO) ? CAST_FROM_FN_PTR(address, act.sa_sigaction) - : CAST_FROM_FN_PTR(address, act.sa_handler) ; - - - switch(sig) { + : CAST_FROM_FN_PTR(address, act.sa_handler); + + + switch (sig) { case SIGSEGV: case SIGBUS: case SIGFPE: @@ -4662,22 +4662,22 @@ // 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 ); + 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); #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 ); + 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); #endif } @@ -4819,13 +4819,13 @@ // 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)) { + if (!linux_mprotect((char *)_polling_page, Linux::page_size(), PROT_READ)) { fatal("Could not enable polling page"); } }; @@ -5288,7 +5288,7 @@ snprintf(proc_name, 64, "/proc/self/task/%d/stat", tid); fp = fopen(proc_name, "r"); - if ( fp == NULL ) return -1; + if (fp == NULL) return -1; statlen = fread(stat, 1, 2047, fp); stat[statlen] = '\0'; fclose(fp); @@ -5300,7 +5300,7 @@ // We don't really need to know the command string, just find the last // occurrence of ")" and then start parsing from there. See bug 4726580. s = strrchr(stat, ')'); - if (s == NULL ) return -1; + if (s == NULL) return -1; // Skip blank chars do s++; while (isspace(*s)); @@ -5309,7 +5309,7 @@ &cdummy, &idummy, &idummy, &idummy, &idummy, &idummy, &ldummy, &ldummy, &ldummy, &ldummy, &ldummy, &user_time, &sys_time); - if ( count != 13 ) return -1; + if (count != 13) return -1; if (user_sys_cpu_time) { return ((jlong)sys_time + (jlong)user_time) * (1000000000 / clock_tics_per_sec); } else { @@ -5468,9 +5468,9 @@ int os::PlatformEvent::TryPark() { for (;;) { - const int v = _Event ; - guarantee ((v == 0) || (v == 1), "invariant") ; - if (Atomic::cmpxchg (0, &_Event, v) == v) return v ; + const int v = _Event; + guarantee((v == 0) || (v == 1), "invariant"); + if (Atomic::cmpxchg(0, &_Event, v) == v) return v; } } @@ -5478,18 +5478,18 @@ // Invariant: Only the thread associated with the Event/PlatformEvent // may call park(). // TODO: assert that _Assoc != NULL or _Assoc == Self - int v ; + int v; for (;;) { - v = _Event ; - if (Atomic::cmpxchg (v-1, &_Event, v) == v) break ; - } - guarantee (v >= 0, "invariant") ; + 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 ; + 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 ... @@ -5497,28 +5497,28 @@ if (status == ETIME) { status = EINTR; } assert_status(status == 0 || status == EINTR, status, "cond_wait"); } - -- _nParked ; - - _Event = 0 ; + --_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") ; + guarantee(_Event >= 0, "invariant"); } int os::PlatformEvent::park(jlong millis) { - guarantee (_nParked == 0, "invariant") ; - - int v ; + 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 ; + 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. // Consider enforcing a minimum timeout value. @@ -5528,8 +5528,8 @@ int ret = OS_TIMEOUT; int status = pthread_mutex_lock(_mutex); assert_status(status == 0, status, "mutex_lock"); - guarantee (_nParked == 0, "invariant") ; - ++_nParked ; + guarantee(_nParked == 0, "invariant"); + ++_nParked; // Object.wait(timo) will return because of // (a) notification @@ -5547,24 +5547,24 @@ while (_Event < 0) { status = os::Linux::safe_cond_timedwait(_cond, _mutex, &abst); if (status != 0 && WorkAroundNPTLTimedWaitHang) { - pthread_cond_destroy (_cond); - pthread_cond_init (_cond, os::Linux::condAttr()) ; + pthread_cond_destroy(_cond); + pthread_cond_init(_cond, os::Linux::condAttr()); } assert_status(status == 0 || status == EINTR || status == ETIME || status == ETIMEDOUT, status, "cond_timedwait"); - if (!FilterSpuriousWakeups) break ; // previous semantics - if (status == ETIME || status == ETIMEDOUT) break ; + if (!FilterSpuriousWakeups) break; // previous semantics + if (status == ETIME || status == ETIMEDOUT) break; // We consume and ignore EINTR and spurious wakeups. } - --_nParked ; + --_nParked; if (_Event >= 0) { ret = OS_OK; } - _Event = 0 ; + _Event = 0; status = pthread_mutex_unlock(_mutex); assert_status(status == 0, status, "mutex_unlock"); - assert (_nParked == 0, "invariant") ; + assert(_nParked == 0, "invariant"); // Paranoia to ensure our locked and lock-free paths interact // correctly with each other. OrderAccess::fence(); @@ -5647,7 +5647,7 @@ */ static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) { - assert (time > 0, "convertTime"); + assert(time > 0, "convertTime"); time_t max_secs = 0; if (!os::supports_monotonic_clock() || isAbsolute) { @@ -5726,7 +5726,7 @@ // Next, demultiplex/decode time arguments timespec absTime; - if (time < 0 || (isAbsolute && time == 0) ) { // don't wait at all + if (time < 0 || (isAbsolute && time == 0)) { // don't wait at all return; } if (time > 0) { @@ -5748,11 +5748,11 @@ return; } - int status ; + int status; if (_counter > 0) { // no wait needed _counter = 0; status = pthread_mutex_unlock(_mutex); - assert (status == 0, "invariant") ; + assert(status == 0, "invariant"); // Paranoia to ensure our locked and lock-free paths interact // correctly with each other and Java-level accesses. OrderAccess::fence(); @@ -5774,13 +5774,13 @@ assert(_cur_index == -1, "invariant"); if (time == 0) { _cur_index = REL_INDEX; // arbitrary choice when not timed - status = pthread_cond_wait (&_cond[_cur_index], _mutex) ; + status = pthread_cond_wait(&_cond[_cur_index], _mutex); } else { _cur_index = isAbsolute ? ABS_INDEX : REL_INDEX; - status = os::Linux::safe_cond_timedwait (&_cond[_cur_index], _mutex, &absTime) ; + status = os::Linux::safe_cond_timedwait(&_cond[_cur_index], _mutex, &absTime); if (status != 0 && WorkAroundNPTLTimedWaitHang) { - pthread_cond_destroy (&_cond[_cur_index]) ; - pthread_cond_init (&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr()); + pthread_cond_destroy(&_cond[_cur_index]); + pthread_cond_init(&_cond[_cur_index], isAbsolute ? NULL : os::Linux::condAttr()); } } _cur_index = -1; @@ -5792,9 +5792,9 @@ pthread_sigmask(SIG_SETMASK, &oldsigs, NULL); #endif - _counter = 0 ; - status = pthread_mutex_unlock(_mutex) ; - assert_status(status == 0, status, "invariant") ; + _counter = 0; + status = pthread_mutex_unlock(_mutex); + assert_status(status == 0, status, "invariant"); // Paranoia to ensure our locked and lock-free paths interact // correctly with each other and Java-level accesses. OrderAccess::fence(); @@ -5806,9 +5806,9 @@ } void Parker::unpark() { - int s, status ; + int s, status; status = pthread_mutex_lock(_mutex); - assert (status == 0, "invariant") ; + assert(status == 0, "invariant"); s = _counter; _counter = 1; if (s < 1) { @@ -5817,22 +5817,22 @@ // thread is definitely parked if (WorkAroundNPTLTimedWaitHang) { status = pthread_cond_signal (&_cond[_cur_index]); - assert (status == 0, "invariant"); + assert(status == 0, "invariant"); status = pthread_mutex_unlock(_mutex); - assert (status == 0, "invariant"); + assert(status == 0, "invariant"); } else { status = pthread_mutex_unlock(_mutex); - assert (status == 0, "invariant"); + assert(status == 0, "invariant"); status = pthread_cond_signal (&_cond[_cur_index]); - assert (status == 0, "invariant"); + assert(status == 0, "invariant"); } } else { pthread_mutex_unlock(_mutex); - assert (status == 0, "invariant") ; + assert(status == 0, "invariant"); } } else { pthread_mutex_unlock(_mutex); - assert (status == 0, "invariant") ; + assert(status == 0, "invariant"); } }