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

equal deleted inserted replaced

-:a02753d5a0b2
+:d1221849ea3d
 # include <inttypes.h>
 # include <sys/ioctl.h>
 # include <sys/syscall.h>
 #if defined(__FreeBSD__) || defined(__NetBSD__)
-# include <elf.h>
+#include <elf.h>
 #endif
 #ifdef __APPLE__
-# include <mach/mach.h> // semaphore_* API
+#include <mach/mach.h> // semaphore_* API
-# include <mach-o/dyld.h>
+#include <mach-o/dyld.h>
-# include <sys/proc_info.h>
+#include <sys/proc_info.h>
-# include <objc/objc-auto.h>
+#include <objc/objc-auto.h>
 #endif
 #ifndef MAP_ANONYMOUS
 #define MAP_ANONYMOUS MAP_ANON
 #endif
 #define MAX_PATH    (2 * K)
 // for timer info max values which include all bits
 static sigset_t check_signal_done;
 static bool check_signals = true;
 static pid_t _initial_pid = 0;
-/* Signal number used to suspend/resume a thread */
+// Signal number used to suspend/resume a thread
-/* do not use any signal number less than SIGSEGV, see 4355769 */
+// do not use any signal number less than SIGSEGV, see 4355769
 static int SR_signum = SIGUSR2;
 sigset_t SR_sigset;
 ////////////////////////////////////////////////////////////////////////////////
 #elif defined(ARM)
 static char cpu_arch[] = "arm";
 #elif defined(PPC32)
 static char cpu_arch[] = "ppc";
 #elif defined(SPARC)
-#  ifdef _LP64
+#ifdef _LP64
 static char cpu_arch[] = "sparcv9";
-#  else
+#else
 static char cpu_arch[] = "sparc";
-#  endif
+#endif
 #else
 #error Add appropriate cpu_arch setting
 #endif
 // Compiler variant
 #ifdef COMPILER2
 #define COMPILER_VARIANT "server"
 #else
 #define COMPILER_VARIANT "client"
 #endif
 void os::Bsd::initialize_system_info() {
 int mib[2];
 size_t len;
 int cpu_val;
 julong mem_val;
-/* get processors count via hw.ncpus sysctl */
+// get processors count via hw.ncpus sysctl
 mib[0] = CTL_HW;
 mib[1] = HW_NCPU;
 len = sizeof(cpu_val);
 if (sysctl(mib, 2, &cpu_val, &len, NULL, 0) != -1 && cpu_val >= 1) {
 assert(len == sizeof(cpu_val), "unexpected data size");
 set_processor_count(cpu_val);
-}
+} else {
-else {
 set_processor_count(1);   // fallback
 }
-/* get physical memory via hw.memsize sysctl (hw.memsize is used
+// get physical memory via hw.memsize sysctl (hw.memsize is used
-* since it returns a 64 bit value)
+// since it returns a 64 bit value)
-*/
 mib[0] = CTL_HW;
 #if defined (HW_MEMSIZE) // Apple
 mib[1] = HW_MEMSIZE;
 #elif defined(HW_PHYSMEM) // Most of BSD
 len = sizeof(mem_val);
 if (sysctl(mib, 2, &mem_val, &len, NULL, 0) != -1) {
 assert(len == sizeof(mem_val), "unexpected data size");
 _physical_memory = mem_val;
 } else {
-_physical_memory = 256*1024*1024;       // fallback (XXXBSD?)
+_physical_memory = 256 * 1024 * 1024;       // fallback (XXXBSD?)
 }
 #ifdef __OpenBSD__
 {
 // limit _physical_memory memory view on OpenBSD since
 // Otherwise exit.
 //
 // Important note: if the location of libjvm.so changes this
 // code needs to be changed accordingly.
 // See ld(1):
 //      The linker uses the following search paths to locate required
 //      shared libraries:
 //        1: ...
 //        ...
 //        7: The default directories, normally /lib and /usr/lib.
 #ifndef DEFAULT_LIBPATH
 #define DEFAULT_LIBPATH "/lib:/usr/lib"
 #endif
 // Base path of extensions installed on the system.
 #define SYS_EXT_DIR     "/usr/java/packages"
 #define EXTENSIONS_DIR  "/lib/ext"
 FREE_C_HEAP_ARRAY(char, buf, mtInternal);
 #else // __APPLE__
 #define SYS_EXTENSIONS_DIR   "/Library/Java/Extensions"
 #define SYS_EXTENSIONS_DIRS  SYS_EXTENSIONS_DIR ":/Network" SYS_EXTENSIONS_DIR ":/System" SYS_EXTENSIONS_DIR ":/usr/lib/java"
 const char *user_home_dir = get_home();
 // The null in SYS_EXTENSIONS_DIRS counts for the size of the colon after user_home_dir.
 size_t system_ext_size = strlen(user_home_dir) + sizeof(SYS_EXTENSIONS_DIR) +
 sizeof(SYS_EXTENSIONS_DIRS);
 bool os::Bsd::is_sig_ignored(int sig) {
 struct sigaction oact;
 sigaction(sig, (struct sigaction*)NULL, &oact);
 void* ohlr = oact.sa_sigaction ? CAST_FROM_FN_PTR(void*,  oact.sa_sigaction)
 : CAST_FROM_FN_PTR(void*,  oact.sa_handler);
-if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN))
+if (ohlr == CAST_FROM_FN_PTR(void*, SIG_IGN)) {
 return true;
-else
+} else {
 return false;
+}
 }
 void os::Bsd::signal_sets_init() {
 // Should also have an assertion stating we are still single-threaded.
 assert(!signal_sets_initialized, "Already initialized");
 sigaddset(&allowdebug_blocked_sigs, SHUTDOWN3_SIGNAL);
 }
 }
 // Fill in signals that are blocked by all but the VM thread.
 sigemptyset(&vm_sigs);
-if (!ReduceSignalUsage)
+if (!ReduceSignalUsage) {
 sigaddset(&vm_sigs, BREAK_SIGNAL);
+}
 debug_only(signal_sets_initialized = true);
 }
 // These are signals that are unblocked while a thread is running Java.
 }
 #ifdef __APPLE__
 // library handle for calling objc_registerThreadWithCollector()
 // without static linking to the libobjc library
 #define OBJC_LIB "/usr/lib/libobjc.dylib"
 #define OBJC_GCREGISTER "objc_registerThreadWithCollector"
 typedef void (*objc_registerThreadWithCollector_t)();
 extern "C" objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction;
 objc_registerThreadWithCollector_t objc_registerThreadWithCollectorFunction = NULL;
 #endif
 assert(status != -1, "bsd error");
 return jlong(time.tv_sec) * 1000  +  jlong(time.tv_usec / 1000);
 }
 #ifndef __APPLE__
 #ifndef CLOCK_MONOTONIC
 #define CLOCK_MONOTONIC (1)
 #endif
 #endif
 #ifdef __APPLE__
 void os::Bsd::clock_init() {
 mach_timebase_info(&_timebase_info);
 // This method is a copy of JDK's sysGetLastErrorString
 // from src/solaris/hpi/src/system_md.c
 size_t os::lasterror(char *buf, size_t len) {
 if (errno == 0)  return 0;
 const char *s = ::strerror(errno);
 size_t n = ::strlen(s);
 if (n >= len) {
 // DLL functions
 #define JNI_LIB_PREFIX "lib"
 #ifdef __APPLE__
 #define JNI_LIB_SUFFIX ".dylib"
 #else
 #define JNI_LIB_SUFFIX ".so"
 #endif
 const char* os::dll_file_extension() { return JNI_LIB_SUFFIX; }
 // This must be hard coded because it's the system's temporary
 }
 temp_path = temp_path_storage;
 }
 return temp_path;
 }
-#else /* __APPLE__ */
+#else // __APPLE__
 const char* os::get_temp_directory() { return "/tmp"; }
-#endif /* __APPLE__ */
+#endif // __APPLE__
 static bool file_exists(const char* filename) {
 struct stat statbuf;
 if (filename == NULL || strlen(filename) == 0) {
 return false;
 }
 }
 // Handle non-dynamic manually:
 if (dlinfo.dli_fbase != NULL &&
-Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset,
+Decoder::decode(addr, localbuf, MACH_MAXSYMLEN, offset, dlinfo.dli_fbase)) {
-dlinfo.dli_fbase)) {
 if (!Decoder::demangle(localbuf, buf, buflen)) {
 jio_snprintf(buf, buflen, "%s", localbuf);
 }
 return true;
 }
 ebuf[ebuflen-1]='\0';
 return NULL;
 }
 #else
-void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
+void * os::dll_load(const char *filename, char *ebuf, int ebuflen) {
-{
 void * result= ::dlopen(filename, RTLD_LAZY);
 if (result != NULL) {
 // Successful loading
 return result;
 }
 char        endianess;    // MSB or LSB
 char*       name;         // String representation
 } arch_t;
 #ifndef EM_486
 #define EM_486          6               /* Intel 80486 */
 #endif
 #ifndef EM_MIPS_RS3_LE
 #define EM_MIPS_RS3_LE  10              /* MIPS */
 #endif
 #ifndef EM_PPC64
 #define EM_PPC64        21              /* PowerPC64 */
 #endif
 #ifndef EM_S390
 #define EM_S390         22              /* IBM System/390 */
 #endif
 #ifndef EM_IA_64
 #define EM_IA_64        50              /* HP/Intel IA-64 */
 #endif
 #ifndef EM_X86_64
 #define EM_X86_64       62              /* AMD x86-64 */
 #endif
 static const arch_t arch_array[]={
 {EM_386,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
 {EM_486,         EM_386,     ELFCLASS32, ELFDATA2LSB, (char*)"IA 32"},
 }
 }
 return NULL;
 }
-#endif /* !__APPLE__ */
+#endif // !__APPLE__
 void* os::get_default_process_handle() {
 #ifdef __APPLE__
 // MacOS X needs to use RTLD_FIRST instead of RTLD_LAZY
 // to avoid finding unexpected symbols on second (or later)
 assert(ret, "cannot locate libjvm");
 char *rp = NULL;
 if (ret && dli_fname[0] != '\0') {
 rp = realpath(dli_fname, buf);
 }
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 if (Arguments::sun_java_launcher_is_altjvm()) {
 // Support for the java launcher's '-XXaltjvm=<path>' option. Typical
 // value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so"
 // or "<JAVA_HOME>/jre/lib/<vmtype>/libjvm.dylib". If "/jre/lib/"
 // Check the current module name "libjvm"
 p = strrchr(buf, '/');
 assert(strstr(p, "/libjvm") == p, "invalid library name");
 rp = realpath(java_home_var, buf);
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 // determine if this is a legacy image or modules image
 // modules image doesn't have "jre" subdirectory
 len = strlen(buf);
 assert(len < buflen, "Ran out of buffer space");
 len = strlen(buf);
 snprintf(buf + len, buflen-len, "/libjvm%s", JNI_LIB_SUFFIX);
 } else {
 // Fall back to path of current library
 rp = realpath(dli_fname, buf);
-if (rp == NULL)
+if (rp == NULL) {
 return;
+}
 }
 }
 }
 }
 ////////////////////////////////////////////////////////////////////////////////
 // sun.misc.Signal support
 static volatile jint sigint_count = 0;
-static void
+static void UserHandler(int sig, void *siginfo, void *context) {
-UserHandler(int sig, void *siginfo, void *context) {
 // 4511530 - sem_post is serialized and handled by the manager thread. When
 // the program is interrupted by Ctrl-C, SIGINT is sent to every thread. We
 // don't want to flood the manager thread with sem_post requests.
-if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1)
+if (sig == SIGINT && Atomic::add(1, &sigint_count) > 1) {
 return;
+}
 // Ctrl-C is pressed during error reporting, likely because the error
 // handler fails to abort. Let VM die immediately.
 if (sig == SIGINT && is_error_reported()) {
 os::die();
 void os::signal_raise(int signal_number) {
 ::raise(signal_number);
 }
-/*
+// The following code is moved from os.cpp for making this
-* The following code is moved from os.cpp for making this
+// code platform specific, which it is by its very nature.
-* code platform specific, which it is by its very nature.
-*/
 // Will be modified when max signal is changed to be dynamic
 int os::sigexitnum_pd() {
 return NSIG;
 }
 static volatile jint pending_signals[NSIG+1] = { 0 };
 // Bsd(POSIX) specific hand shaking semaphore.
 #ifdef __APPLE__
 typedef semaphore_t os_semaphore_t;
-#define SEM_INIT(sem, value)    semaphore_create(mach_task_self(), &sem, SYNC_POLICY_FIFO, value)
-#define SEM_WAIT(sem)           semaphore_wait(sem)
+#define SEM_INIT(sem, value)    semaphore_create(mach_task_self(), &sem, SYNC_POLICY_FIFO, value)
-#define SEM_POST(sem)           semaphore_signal(sem)
+#define SEM_WAIT(sem)           semaphore_wait(sem)
-#define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)
+#define SEM_POST(sem)           semaphore_signal(sem)
+#define SEM_DESTROY(sem)        semaphore_destroy(mach_task_self(), sem)
 #else
 typedef sem_t os_semaphore_t;
-#define SEM_INIT(sem, value)    sem_init(&sem, 0, value)
-#define SEM_WAIT(sem)           sem_wait(&sem)
+#define SEM_INIT(sem, value)    sem_init(&sem, 0, value)
-#define SEM_POST(sem)           sem_post(&sem)
+#define SEM_WAIT(sem)           sem_wait(&sem)
-#define SEM_DESTROY(sem)        sem_destroy(&sem)
+#define SEM_POST(sem)           sem_post(&sem)
+#define SEM_DESTROY(sem)        sem_destroy(&sem)
 #endif
 class Semaphore : public StackObj {
 public:
 Semaphore();
 ::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);
 key_t key = IPC_PRIVATE;
 char *addr;
 bool warn_on_failure = UseLargePages &&
 (!FLAG_IS_DEFAULT(UseLargePages) ||
-!FLAG_IS_DEFAULT(LargePageSizeInBytes)
+!FLAG_IS_DEFAULT(LargePageSizeInBytes));
-);
 // Create a large shared memory region to attach to based on size.
 // Currently, size is the total size of the heap
 int shmid = shmget(key, bytes, IPC_CREAT|SHM_R|SHM_W);
 if (shmid == -1) {
 assert(ms < 1000, "Un-interruptable sleep, short time use only");
 req.tv_sec = 0;
 if (ms > 0) {
 req.tv_nsec = (ms % 1000) * 1000000;
-}
+} else {
-else {
 req.tv_nsec = 1;
 }
 nanosleep(&req, NULL);
 31,              // 10 MaxPriority
 31               // 11 CriticalPriority
 };
 #else
-/* Using Mach high-level priority assignments */
+// Using Mach high-level priority assignments
 int os::java_to_os_priority[CriticalPriority + 1] = {
 0,              // 0 Entry should never be used (MINPRI_USER)
 27,              // 1 MinPriority
 28,              // 2
 #elif defined(__APPLE__) || defined(__NetBSD__)
 struct sched_param sp;
 int policy;
 pthread_t self = pthread_self();
-if (pthread_getschedparam(self, &policy, &sp) != 0)
+if (pthread_getschedparam(self, &policy, &sp) != 0) {
 return OS_ERR;
+}
 sp.sched_priority = newpri;
-if (pthread_setschedparam(self, policy, &sp) != 0)
+if (pthread_setschedparam(self, policy, &sp) != 0) {
 return OS_ERR;
+}
 return OS_OK;
 #else
 int ret = setpriority(PRIO_PROCESS, thread->osthread()->thread_id(), newpri);
 return (ret == 0) ? OS_OK : OS_ERR;
 //  - resume:
 //      - sets target osthread state to continue
 //      - sends signal to end the sigsuspend loop in the SR_handler
 //
 //  Note that the SR_lock plays no role in this suspend/resume protocol.
-//
 static void resume_clear_context(OSThread *osthread) {
 osthread->set_ucontext(NULL);
 osthread->set_siginfo(NULL);
 }
 static void suspend_save_context(OSThread *osthread, siginfo_t* siginfo, ucontext_t* context) {
 osthread->set_ucontext(context);
 osthread->set_siginfo(siginfo);
 }
-//
 // Handler function invoked when a thread's execution is suspended or
 // resumed. We have to be careful that only async-safe functions are
 // called here (Note: most pthread functions are not async safe and
 // should be avoided.)
 //
 static int SR_initialize() {
 struct sigaction act;
 char *s;
-/* Get signal number to use for suspend/resume */
+// Get signal number to use for suspend/resume
 if ((s = ::getenv("_JAVA_SR_SIGNUM")) != 0) {
 int sig = ::strtol(s, 0, 10);
 if (sig > 0 || sig < NSIG) {
 SR_signum = sig;
 }
 "SR_signum must be greater than max(SIGSEGV, SIGBUS), see 4355769");
 sigemptyset(&SR_sigset);
 sigaddset(&SR_sigset, SR_signum);
-/* Set up signal handler for suspend/resume */
+// Set up signal handler for suspend/resume
 act.sa_flags = SA_RESTART|SA_SIGINFO;
 act.sa_handler = (void (*)(int)) SR_handler;
 // SR_signum is blocked by default.
 // 4528190 - We also need to block pthread restart signal (32 on all
 // the sa_flags field passed to sigaction() includes SA_SIGINFO and SA_RESTART.
 //
 // Note that the VM will print warnings if it detects conflicting signal
 // handlers, unless invoked with the option "-XX:+AllowUserSignalHandlers".
 //
-extern "C" JNIEXPORT int
+extern "C" JNIEXPORT int JVM_handle_bsd_signal(int signo, siginfo_t* siginfo,
-JVM_handle_bsd_signal(int signo, siginfo_t* siginfo,
+void* ucontext,
-void* ucontext, int abort_if_unrecognized);
+int abort_if_unrecognized);
 void signalHandler(int sig, siginfo_t* info, void* uc) {
 assert(info != NULL && uc != NULL, "it must be old kernel");
 int orig_errno = errno;  // Preserve errno value over signal handler.
 JVM_handle_bsd_signal(sig, info, uc, true);
 // 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::Bsd::check_signal_handler(sig)
+if (!sigismember(&check_signal_done, sig)) {  \
+os::Bsd::check_signal_handler(sig);         \
+}                                             \
+} while (0)
 // This method is a periodic task to check for misbehaving JNI applications
 // under CheckJNI, we can add any periodic checks here
 void os::run_periodic_checks() {
 if (sigismember(&check_signal_done, sig)) {
 print_signal_handlers(tty, buf, O_BUFLEN);
 }
 }
-extern void report_error(char* file_name, int line_no, char* title, char* format, ...);
+extern void report_error(char* file_name, int line_no, char* title,
+char* format, ...);
 extern bool signal_name(int signo, char* buf, size_t len);
 const char* os::exception_name(int exception_code, char* buf, size_t size) {
 if (0 < exception_code && exception_code <= SIGRTMAX) {
 }
 }
 // this is called _before_ the most of global arguments have been parsed
 void os::init(void) {
-char dummy;   /* used to get a guess on initial stack address */
+char dummy;   // used to get a guess on initial stack address
 //  first_hrtime = gethrtime();
 // With BsdThreads the JavaMain thread pid (primordial thread)
 // is different than the pid of the java launcher thread.
 // So, on Bsd, the launcher thread pid is passed to the VM
 perfMemory_exit();
 }
 }
 // this is called _after_ the global arguments have been parsed
-jint os::init_2(void)
+jint os::init_2(void) {
-{
 // Allocate a single page and mark it as readable for safepoint polling
 address polling_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 guarantee(polling_page != MAP_FAILED, "os::init_2: failed to allocate polling page");
 os::set_polling_page(polling_page);
 #ifndef PRODUCT
-if (Verbose && PrintMiscellaneous)
+if (Verbose && PrintMiscellaneous) {
-tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n", (intptr_t)polling_page);
+tty->print("[SafePoint Polling address: " INTPTR_FORMAT "]\n",
+(intptr_t)polling_page);
+}
 #endif
 if (!UseMembar) {
 address mem_serialize_page = (address) ::mmap(NULL, Bsd::page_size(), PROT_READ | PROT_WRITE, MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 guarantee(mem_serialize_page != MAP_FAILED, "mmap Failed for memory serialize page");
 os::set_memory_serialize_page(mem_serialize_page);
 #ifndef PRODUCT
-if (Verbose && PrintMiscellaneous)
+if (Verbose && PrintMiscellaneous) {
-tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n", (intptr_t)mem_serialize_page);
+tty->print("[Memory Serialize  Page address: " INTPTR_FORMAT "]\n",
+(intptr_t)mem_serialize_page);
+}
 #endif
 }
 // initialize suspend/resume support - must do this before signal_sets_init()
 if (SR_initialize() != 0) {
 // set the number of file descriptors to max. print out error
 // if getrlimit/setrlimit fails but continue regardless.
 struct rlimit nbr_files;
 int status = getrlimit(RLIMIT_NOFILE, &nbr_files);
 if (status != 0) {
-if (PrintMiscellaneous && (Verbose || WizardMode))
+if (PrintMiscellaneous && (Verbose || WizardMode)) {
 perror("os::init_2 getrlimit failed");
+}
 } else {
 nbr_files.rlim_cur = nbr_files.rlim_max;
 #ifdef __APPLE__
 // Darwin returns RLIM_INFINITY for rlim_max, but fails with EINVAL if
 nbr_files.rlim_cur = MIN(OPEN_MAX, nbr_files.rlim_cur);
 #endif
 status = setrlimit(RLIMIT_NOFILE, &nbr_files);
 if (status != 0) {
-if (PrintMiscellaneous && (Verbose || WizardMode))
+if (PrintMiscellaneous && (Verbose || WizardMode)) {
 perror("os::init_2 setrlimit failed");
+}
 }
 }
 }
 // at-exit methods are called in the reverse order of their registration.
 // this is called at the end of vm_initialization
 void os::init_3(void) { }
 // Mark the polling page as unreadable
 void os::make_polling_page_unreadable(void) {
-if (!guard_memory((char*)_polling_page, Bsd::page_size()))
+if (!guard_memory((char*)_polling_page, Bsd::page_size())) {
 fatal("Could not disable polling page");
-};
+}
+}
 // Mark the polling page as readable
 void os::make_polling_page_readable(void) {
 if (!bsd_mprotect((char *)_polling_page, Bsd::page_size(), PROT_READ)) {
 fatal("Could not enable polling page");
 }
-};
+}
 int os::active_processor_count() {
 return _processor_count;
 }
 PcFetcher fetcher(thread);
 fetcher.run();
 return fetcher.result();
 }
-int os::Bsd::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex, const struct timespec *_abstime)
+int os::Bsd::safe_cond_timedwait(pthread_cond_t *_cond,
-{
+pthread_mutex_t *_mutex,
+const struct timespec *_abstime) {
 return pthread_cond_timedwait(_cond, _mutex, _abstime);
 }
 ////////////////////////////////////////////////////////////////////////////////
 // debug support
 address       lowest = (address) dlinfo.dli_sname;
 if (!lowest)  lowest = (address) dlinfo.dli_fbase;
 if (begin < lowest)  begin = lowest;
 Dl_info dlinfo2;
 if (dladdr(end, &dlinfo2) != 0 && dlinfo2.dli_saddr != dlinfo.dli_saddr
-&& end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin)
+&& end > dlinfo2.dli_saddr && dlinfo2.dli_saddr > begin) {
 end = (address) dlinfo2.dli_saddr;
+}
 Disassembler::decode(begin, end, st);
 }
 return true;
 }
 return false;
 // misc
 // This does not do anything on Bsd. This is basically a hook for being
 // able to use structured exception handling (thread-local exception filters)
 // on, e.g., Win32.
-void
+void os::os_exception_wrapper(java_call_t f, JavaValue* value,
-os::os_exception_wrapper(java_call_t f, JavaValue* value, methodHandle* method,
+methodHandle* method, JavaCallArguments* args,
-JavaCallArguments* args, Thread* thread) {
+Thread* thread) {
 f(value, method, args, thread);
 }
 void os::print_statistics() {
 }
 bool os::check_heap(bool force) {
 return true;
 }
 ATTRIBUTE_PRINTF(3, 0)
-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;
 oflag = oflag & ~O_DELETE;
 fd = ::open(path, oflag, mode);
 if (fd == -1) return -1;
-//If the open succeeded, the file might still be a directory
+// If the open succeeded, the file might still be a directory
 {
 struct stat buf;
 int ret = ::fstat(fd, &buf);
 int st_mode = buf.st_mode;
 ::close(fd);
 return -1;
 }
 }
-/*
+// All file descriptors that are opened in the JVM and not
-* All file descriptors that are opened in the JVM and not
+// specifically destined for a subprocess should have the
-* specifically destined for a subprocess should have the
+// close-on-exec flag set.  If we don't set it, then careless 3rd
-* close-on-exec flag set.  If we don't set it, then careless 3rd
+// party native code might fork and exec without closing all
-* party native code might fork and exec without closing all
+// appropriate file descriptors (e.g. as we do in closeDescriptors in
-* appropriate file descriptors (e.g. as we do in closeDescriptors in
+// UNIXProcess.c), and this in turn might:
-* UNIXProcess.c), and this in turn might:
+//
-*
+// - cause end-of-file to fail to be detected on some file
-* - cause end-of-file to fail to be detected on some file
+//   descriptors, resulting in mysterious hangs, or
-*   descriptors, resulting in mysterious hangs, or
+//
-*
+// - might cause an fopen in the subprocess to fail on a system
-* - might cause an fopen in the subprocess to fail on a system
+//   suffering from bug 1085341.
-*   suffering from bug 1085341.
+//
-*
+// (Yes, the default setting of the close-on-exec flag is a Unix
-* (Yes, the default setting of the close-on-exec flag is a Unix
+// design flaw)
-* design flaw)
+//
-*
+// See:
-* See:
+// 1085341: 32-bit stdio routines should support file descriptors >255
-* 1085341: 32-bit stdio routines should support file descriptors >255
+// 4843136: (process) pipe file descriptor from Runtime.exec not being closed
-* 4843136: (process) pipe file descriptor from Runtime.exec not being closed
+// 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
-* 6339493: (process) Runtime.exec does not close all file descriptors on Solaris 9
+//
-*/
 #ifdef FD_CLOEXEC
 {
 int flags = ::fcntl(fd, F_GETFD);
-if (flags != -1)
+if (flags != -1) {
 ::fcntl(fd, F_SETFD, flags | FD_CLOEXEC);
+}
 }
 #endif
 if (o_delete != 0) {
 ::unlink(path);
 struct stat buf;
 if (::fstat(fd, &buf) >= 0) {
 mode = buf.st_mode;
 if (S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) {
-/*
+// XXX: is the following call interruptible? If so, this might
-* XXX: is the following call interruptible? If so, this might
+// need to go through the INTERRUPT_IO() wrapper as for other
-* need to go through the INTERRUPT_IO() wrapper as for other
+// blocking, interruptible calls in this file.
-* blocking, interruptible calls in this file.
-*/
 int n;
 if (::ioctl(fd, FIONREAD, &n) >= 0) {
 *bytes = n;
 return 1;
 }
 *bytes = end - cur;
 return 1;
 }
 int os::socket_available(int fd, jint *pbytes) {
-if (fd < 0)
+if (fd < 0) {
 return OS_OK;
+}
 int ret;
 RESTARTABLE(::ioctl(fd, FIONREAD, pbytes), ret);
 kern_return_t kr;
 thread_t mach_thread;
 mach_thread = thread->osthread()->thread_id();
 kr = thread_info(mach_thread, THREAD_BASIC_INFO, (thread_info_t)&tinfo, &tcount);
-if (kr != KERN_SUCCESS)
+if (kr != KERN_SUCCESS) {
 return -1;
+}
 if (user_sys_cpu_time) {
 jlong nanos;
 nanos = ((jlong) tinfo.system_time.seconds + tinfo.user_time.seconds) * (jlong)1000000000;
 nanos += ((jlong) tinfo.system_time.microseconds + (jlong) tinfo.user_time.microseconds) * (jlong)1000;
 // utility to compute the abstime argument to timedwait:
 // millis is the relative timeout time
 // abstime will be the absolute timeout time
 // TODO: replace compute_abstime() with unpackTime()
-static struct timespec* compute_abstime(struct timespec* abstime, jlong millis) {
+static struct timespec* compute_abstime(struct timespec* abstime,
+jlong millis) {
 if (millis < 0)  millis = 0;
 struct timeval now;
 int status = gettimeofday(&now, NULL);
 assert(status == 0, "gettimeofday");
 jlong seconds = millis / 1000;
 // JSR166
 // -------------------------------------------------------
-/*
+// The solaris and bsd implementations of park/unpark are fairly
-* The solaris and bsd implementations of park/unpark are fairly
+// conservative for now, but can be improved. They currently use a
-* conservative for now, but can be improved. They currently use a
+// mutex/condvar pair, plus a a count.
-* mutex/condvar pair, plus a a count.
+// Park decrements count if > 0, else does a condvar wait.  Unpark
-* Park decrements count if > 0, else does a condvar wait.  Unpark
+// sets count to 1 and signals condvar.  Only one thread ever waits
-* sets count to 1 and signals condvar.  Only one thread ever waits
+// on the condvar. Contention seen when trying to park implies that someone
-* on the condvar. Contention seen when trying to park implies that someone
+// is unparking you, so don't wait. And spurious returns are fine, so there
-* is unparking you, so don't wait. And spurious returns are fine, so there
+// is no need to track notifications.
-* is no need to track notifications.
-*/
 #define MAX_SECS 100000000
-/*
-* This code is common to bsd and solaris and will be moved to a
+// This code is common to bsd and solaris and will be moved to a
-* common place in dolphin.
+// common place in dolphin.
-*
+//
-* The passed in time value is either a relative time in nanoseconds
+// The passed in time value is either a relative time in nanoseconds
-* or an absolute time in milliseconds. Either way it has to be unpacked
+// or an absolute time in milliseconds. Either way it has to be unpacked
-* into suitable seconds and nanoseconds components and stored in the
+// into suitable seconds and nanoseconds components and stored in the
-* given timespec structure.
+// given timespec structure.
-* Given time is a 64-bit value and the time_t used in the timespec is only
+// Given time is a 64-bit value and the time_t used in the timespec is only
-* a signed-32-bit value (except on 64-bit Bsd) we have to watch for
+// a signed-32-bit value (except on 64-bit Bsd) we have to watch for
-* overflow if times way in the future are given. Further on Solaris versions
+// overflow if times way in the future are given. Further on Solaris versions
-* prior to 10 there is a restriction (see cond_timedwait) that the specified
+// prior to 10 there is a restriction (see cond_timedwait) that the specified
-* number of seconds, in abstime, is less than current_time  + 100,000,000.
+// number of seconds, in abstime, is less than current_time  + 100,000,000.
-* As it will be 28 years before "now + 100000000" will overflow we can
+// As it will be 28 years before "now + 100000000" will overflow we can
-* ignore overflow and just impose a hard-limit on seconds using the value
+// ignore overflow and just impose a hard-limit on seconds using the value
-* of "now + 100,000,000". This places a limit on the timeout of about 3.17
+// of "now + 100,000,000". This places a limit on the timeout of about 3.17
-* years from "now".
+// years from "now".
-*/
 static void unpackTime(struct timespec* absTime, bool isAbsolute, jlong time) {
 assert(time > 0, "convertTime");
 struct timeval now;
 if (isAbsolute) {
 jlong secs = time / 1000;
 if (secs > max_secs) {
 absTime->tv_sec = max_secs;
-}
+} else {
-else {
 absTime->tv_sec = secs;
 }
 absTime->tv_nsec = (time % 1000) * NANOSECS_PER_MILLISEC;
-}
+} else {
-else {
 jlong secs = time / NANOSECS_PER_SEC;
 if (secs >= MAX_SECS) {
 absTime->tv_sec = max_secs;
 absTime->tv_nsec = 0;
-}
+} else {
-else {
 absTime->tv_sec = now.tv_sec + secs;
 absTime->tv_nsec = (time % NANOSECS_PER_SEC) + now.tv_usec*1000;
 if (absTime->tv_nsec >= NANOSECS_PER_SEC) {
 absTime->tv_nsec -= NANOSECS_PER_SEC;
 ++absTime->tv_sec; // note: this must be <= max_secs
 assert(status == 0, "invariant");
 }
 }
-/* Darwin has no "environ" in a dynamic library. */
+// Darwin has no "environ" in a dynamic library.
 #ifdef __APPLE__
 #include <crt_externs.h>
 #define environ (*_NSGetEnviron())
 #else
 extern char** environ;
 #endif
 // Run the specified command in a separate process. Return its exit value,
 // 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;

changeset 26684	d1221849ea3d
parent 26683	a02753d5a0b2
child 26685	aa239a0dfbea