truffle: src/os/linux/vm/os_linux.cpp comparison

comparison src/os/linux/vm/os_linux.cpp @ 14518:d8041d695d19

Merged with jdk9/dev/hotspot changeset 3812c088b945

author	twisti
date	Tue, 11 Mar 2014 18:45:59 -0700
parents	096c224171c4 bb9356ec5967
children	b51e29501f30 4ca6dc0799b6

comparison

equal deleted inserted replaced

-:f97c5ec83832
+:d8041d695d19
 /*
-* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 static int clock_tics_per_sec = 100;
 // For diagnostics to print a message once. see run_periodic_checks
 static sigset_t check_signal_done;
-static bool check_signals = true;;
+static bool check_signals = true;
 static pid_t _initial_pid = 0;
 /* Signal number used to suspend/resume a thread */
 static char cpu_arch[] = "i386";
 #elif defined(AMD64)
 static char cpu_arch[] = "amd64";
 #elif defined(ARM)
 static char cpu_arch[] = "arm";
-#elif defined(PPC)
+#elif defined(PPC32)
 static char cpu_arch[] = "ppc";
+#elif defined(PPC64)
+static char cpu_arch[] = "ppc64";
 #elif defined(SPARC)
 #  ifdef _LP64
 static char cpu_arch[] = "sparcv9";
 #  else
 static char cpu_arch[] = "sparc";
 sigemptyset(&allowdebug_blocked_sigs);
 sigaddset(&unblocked_sigs, SIGILL);
 sigaddset(&unblocked_sigs, SIGSEGV);
 sigaddset(&unblocked_sigs, SIGBUS);
 sigaddset(&unblocked_sigs, SIGFPE);
+#if defined(PPC64)
+sigaddset(&unblocked_sigs, SIGTRAP);
+#endif
 sigaddset(&unblocked_sigs, SR_signum);
 if (!ReduceSignalUsage) {
 if (!os::Linux::is_sig_ignored(SHUTDOWN1_SIGNAL)) {
 sigaddset(&unblocked_sigs, SHUTDOWN1_SIGNAL);
 _pthread_getcpuclockid = pthread_getcpuclockid_func;
 }
 }
 jlong os::javaTimeNanos() {
-if (Linux::supports_monotonic_clock()) {
+if (os::supports_monotonic_clock()) {
 struct timespec tp;
 int status = Linux::clock_gettime(CLOCK_MONOTONIC, &tp);
 assert(status == 0, "gettime error");
 jlong result = jlong(tp.tv_sec) * (1000 * 1000 * 1000) + jlong(tp.tv_nsec);
 return result;
 return 1000 * usecs;
 }
 }
 void os::javaTimeNanos_info(jvmtiTimerInfo *info_ptr) {
-if (Linux::supports_monotonic_clock()) {
+if (os::supports_monotonic_clock()) {
 info_ptr->max_value = ALL_64_BITS;
 // CLOCK_MONOTONIC - amount of time since some arbitrary point in the past
 info_ptr->may_skip_backward = false;      // not subject to resetting or drifting
 info_ptr->may_skip_forward = false;       // not subject to resetting or drifting
 void* res = dlsym(handle, name);
 pthread_mutex_unlock(&dl_mutex);
 return res;
 }
+void* os::get_default_process_handle() {
+return (void*)::dlopen(NULL, RTLD_LAZY);
+}
 static bool _print_ascii_file(const char* filename, outputStream* st) {
 int fd = ::open(filename, O_RDONLY);
 if (fd == -1) {
 return false;
 st->print("  <Not Available>");
 }
 st->cr();
 }
-// Taken from /usr/include/bits/siginfo.h  Supposed to be architecture specific
-// but they're the same for all the linux arch that we support
-// and they're the same for solaris but there's no common place to put this.
-const char *ill_names[] = { "ILL0", "ILL_ILLOPC", "ILL_ILLOPN", "ILL_ILLADR",
-"ILL_ILLTRP", "ILL_PRVOPC", "ILL_PRVREG",
-"ILL_COPROC", "ILL_BADSTK" };
-const char *fpe_names[] = { "FPE0", "FPE_INTDIV", "FPE_INTOVF", "FPE_FLTDIV",
-"FPE_FLTOVF", "FPE_FLTUND", "FPE_FLTRES",
-"FPE_FLTINV", "FPE_FLTSUB", "FPE_FLTDEN" };
-const char *segv_names[] = { "SEGV0", "SEGV_MAPERR", "SEGV_ACCERR" };
-const char *bus_names[] = { "BUS0", "BUS_ADRALN", "BUS_ADRERR", "BUS_OBJERR" };
 void os::print_siginfo(outputStream* st, void* siginfo) {
-st->print("siginfo:");
+const siginfo_t* si = (const siginfo_t*)siginfo;
-const int buflen = 100;
+os::Posix::print_siginfo_brief(st, si);
-char buf[buflen];
-siginfo_t *si = (siginfo_t*)siginfo;
+if (si && (si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
-st->print("si_signo=%s: ", os::exception_name(si->si_signo, buf, buflen));
-if (si->si_errno != 0 && strerror_r(si->si_errno, buf, buflen) == 0) {
-st->print("si_errno=%s", buf);
-} else {
-st->print("si_errno=%d", si->si_errno);
-}
-const int c = si->si_code;
-assert(c > 0, "unexpected si_code");
-switch (si->si_signo) {
-case SIGILL:
-st->print(", si_code=%d (%s)", c, c > 8 ? "" : ill_names[c]);
-st->print(", si_addr=" PTR_FORMAT, si->si_addr);
-break;
-case SIGFPE:
-st->print(", si_code=%d (%s)", c, c > 9 ? "" : fpe_names[c]);
-st->print(", si_addr=" PTR_FORMAT, si->si_addr);
-break;
-case SIGSEGV:
-st->print(", si_code=%d (%s)", c, c > 2 ? "" : segv_names[c]);
-st->print(", si_addr=" PTR_FORMAT, si->si_addr);
-break;
-case SIGBUS:
-st->print(", si_code=%d (%s)", c, c > 3 ? "" : bus_names[c]);
-st->print(", si_addr=" PTR_FORMAT, si->si_addr);
-break;
-default:
-st->print(", si_code=%d", si->si_code);
-// no si_addr
-}
-if ((si->si_signo == SIGBUS || si->si_signo == SIGSEGV) &&
 UseSharedSpaces) {
 FileMapInfo* mapinfo = FileMapInfo::current_info();
 if (mapinfo->is_in_shared_space(si->si_addr)) {
 st->print("\n\nError accessing class data sharing archive."   \
 " Mapped file inaccessible during execution, "      \
 print_signal_handler(st, SR_signum, buf, buflen);
 print_signal_handler(st, SHUTDOWN1_SIGNAL, buf, buflen);
 print_signal_handler(st, SHUTDOWN2_SIGNAL , buf, buflen);
 print_signal_handler(st, SHUTDOWN3_SIGNAL , buf, buflen);
 print_signal_handler(st, BREAK_SIGNAL, buf, buflen);
+#if defined(PPC64)
+print_signal_handler(st, SIGTRAP, buf, buflen);
+#endif
 }
 static char saved_jvm_path[MAXPATHLEN] = {0};
 // Find the full path to the current module, libjvm.so
 rp = realpath(dli_fname, buf);
 }
 if (rp == NULL)
 return;
-if (Arguments::created_by_gamma_launcher()) {
+if (Arguments::sun_java_launcher_is_altjvm()) {
-// Support for the gamma launcher.  Typical value for buf is
+// Support for the java launcher's '-XXaltjvm=<path>' option. Typical
-// "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".  If "/jre/lib/" appears at
+// value for buf is "<JAVA_HOME>/jre/lib/<arch>/<vmtype>/libjvm.so".
-// the right place in the string, then assume we are installed in a JDK and
+// If "/jre/lib/" appears at the right place in the string, then
-// we're done.  Otherwise, check for a JAVA_HOME environment variable and fix
+// assume we are installed in a JDK and we're done. Otherwise, check
-// up the path so it looks like libjvm.so is installed there (append a
+// for a JAVA_HOME environment variable and fix up the path so it
-// fake suffix hotspot/libjvm.so).
+// looks like libjvm.so is installed there (append a fake suffix
+// hotspot/libjvm.so).
 const char *p = buf + strlen(buf) - 1;
 for (int count = 0; p > buf && count < 5; ++count) {
 for (--p; p > buf && *p != '/'; --p)
 /* empty */ ;
 }
 size_t page_sz = os::vm_page_size();
 unsigned pages = size / page_sz;
 unsigned char vec[1];
 unsigned imin = 1, imax = pages + 1, imid;
-int mincore_return_value;
+int mincore_return_value = 0;
+assert(imin <= imax, "Unexpected page size");
 while (imin < imax) {
 imid = (imax + imin) / 2;
 nbot = ntop - (imid * page_sz);
 size_t os::read(int fd, void *buf, unsigned int nBytes) {
 return ::read(fd, buf, nBytes);
 }
-// TODO-FIXME: reconcile Solaris' os::sleep with the linux variation.
+//
-// Solaris uses poll(), linux uses park().
+// Short sleep, direct OS call.
-// Poll() is likely a better choice, assuming that Thread.interrupt()
+//
-// generates a SIGUSRx signal. Note that SIGUSR1 can interfere with
+// Note: certain versions of Linux CFS scheduler (since 2.6.23) do not guarantee
-// SIGSEGV, see 4355769.
+// sched_yield(2) will actually give up the CPU:
+//
-int os::sleep(Thread* thread, jlong millis, bool interruptible) {
+//   * Alone on this pariticular CPU, keeps running.
-assert(thread == Thread::current(),  "thread consistency check");
+//   * Before the introduction of "skip_buddy" with "compat_yield" disabled
+//     (pre 2.6.39).
-ParkEvent * const slp = thread->_SleepEvent ;
+//
-slp->reset() ;
+// So calling this with 0 is an alternative.
-OrderAccess::fence() ;
+//
+void os::naked_short_sleep(jlong ms) {
-if (interruptible) {
+struct timespec req;
-jlong prevtime = javaTimeNanos();
+assert(ms < 1000, "Un-interruptable sleep, short time use only");
-for (;;) {
+req.tv_sec = 0;
-if (os::is_interrupted(thread, true)) {
+if (ms > 0) {
-return OS_INTRPT;
+req.tv_nsec = (ms % 1000) * 1000000;
 }
+else {
-jlong newtime = javaTimeNanos();
+req.tv_nsec = 1;
+}
-if (newtime - prevtime < 0) {
-// time moving backwards, should only happen if no monotonic clock
+nanosleep(&req, NULL);
-// not a guarantee() because JVM should not abort on kernel/glibc bugs
-assert(!Linux::supports_monotonic_clock(), "time moving backwards");
+return;
-} else {
-millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
-}
-if(millis <= 0) {
-return OS_OK;
-}
-prevtime = newtime;
-{
-assert(thread->is_Java_thread(), "sanity check");
-JavaThread *jt = (JavaThread *) thread;
-ThreadBlockInVM tbivm(jt);
-OSThreadWaitState osts(jt->osthread(), false /* not Object.wait() */);
-jt->set_suspend_equivalent();
-// cleared by handle_special_suspend_equivalent_condition() or
-// java_suspend_self() via check_and_wait_while_suspended()
-slp->park(millis);
-// were we externally suspended while we were waiting?
-jt->check_and_wait_while_suspended();
-}
-}
-} else {
-OSThreadWaitState osts(thread->osthread(), false /* not Object.wait() */);
-jlong prevtime = javaTimeNanos();
-for (;;) {
-// It'd be nice to avoid the back-to-back javaTimeNanos() calls on
-// the 1st iteration ...
-jlong newtime = javaTimeNanos();
-if (newtime - prevtime < 0) {
-// time moving backwards, should only happen if no monotonic clock
-// not a guarantee() because JVM should not abort on kernel/glibc bugs
-assert(!Linux::supports_monotonic_clock(), "time moving backwards");
-} else {
-millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
-}
-if(millis <= 0) break ;
-prevtime = newtime;
-slp->park(millis);
-}
-return OS_OK ;
-}
-}
-int os::naked_sleep() {
-// %% make the sleep time an integer flag. for now use 1 millisec.
-return os::sleep(Thread::current(), 1, false);
 }
 // Sleep forever; naked call to OS-specific sleep; use with CAUTION
 void os::infinite_sleep() {
 while (true) {    // sleep forever ...
 ShouldNotReachHere();
 }
 }
 guarantee(osthread->sr.is_running(), "Must be running!");
-}
-////////////////////////////////////////////////////////////////////////////////
-// interrupt support
-void os::interrupt(Thread* thread) {
-assert(Thread::current() == thread || Threads_lock->owned_by_self(),
-"possibility of dangling Thread pointer");
-OSThread* osthread = thread->osthread();
-if (!osthread->interrupted()) {
-osthread->set_interrupted(true);
-// More than one thread can get here with the same value of osthread,
-// resulting in multiple notifications.  We do, however, want the store
-// to interrupted() to be visible to other threads before we execute unpark().
-OrderAccess::fence();
-ParkEvent * const slp = thread->_SleepEvent ;
-if (slp != NULL) slp->unpark() ;
-}
-// For JSR166. Unpark even if interrupt status already was set
-if (thread->is_Java_thread())
-((JavaThread*)thread)->parker()->unpark();
-ParkEvent * ev = thread->_ParkEvent ;
-if (ev != NULL) ev->unpark() ;
-}
-bool os::is_interrupted(Thread* thread, bool clear_interrupted) {
-assert(Thread::current() == thread || Threads_lock->owned_by_self(),
-"possibility of dangling Thread pointer");
-OSThread* osthread = thread->osthread();
-bool interrupted = osthread->interrupted();
-if (interrupted && clear_interrupted) {
-osthread->set_interrupted(false);
-// consider thread->_SleepEvent->reset() ... optional optimization
-}
-return interrupted;
 }
 ///////////////////////////////////////////////////////////////////////////////////
 // signal handling (except suspend/resume)
 set_signal_handler(SIGSEGV, true);
 set_signal_handler(SIGPIPE, true);
 set_signal_handler(SIGBUS, true);
 set_signal_handler(SIGILL, true);
 set_signal_handler(SIGFPE, true);
+#if defined(PPC64)
+set_signal_handler(SIGTRAP, true);
+#endif
 set_signal_handler(SIGXFSZ, true);
 if (libjsig_is_loaded) {
 // Tell libjsig jvm finishes setting signal handlers
 (*end_signal_setting)();
 st->print("SIG_IGN");
 } else {
 st->print("[%s]", get_signal_handler_name(handler, buf, buflen));
 }
-st->print(", sa_mask[0]=" PTR32_FORMAT, *(uint32_t*)&sa.sa_mask);
+st->print(", sa_mask[0]=");
+os::Posix::print_signal_set_short(st, &sa.sa_mask);
 address rh = VMError::get_resetted_sighandler(sig);
 // May be, handler was resetted by VMError?
 if(rh != NULL) {
 handler = rh;
 sa.sa_flags = VMError::get_resetted_sigflags(sig) & SIGNIFICANT_SIGNAL_MASK;
 }
-st->print(", sa_flags="   PTR32_FORMAT, sa.sa_flags);
+st->print(", sa_flags=");
+os::Posix::print_sa_flags(st, sa.sa_flags);
 // Check: is it our handler?
 if(handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)signalHandler) ||
 handler == CAST_FROM_FN_PTR(address, (sa_sigaction_t)SR_handler)) {
 // It is our signal handler
 DO_SIGNAL_CHECK(SIGILL);
 DO_SIGNAL_CHECK(SIGFPE);
 DO_SIGNAL_CHECK(SIGBUS);
 DO_SIGNAL_CHECK(SIGPIPE);
 DO_SIGNAL_CHECK(SIGXFSZ);
+#if defined(PPC64)
+DO_SIGNAL_CHECK(SIGTRAP);
+#endif
 // ReduceSignalUsage allows the user to override these handlers
 // see comments at the very top and jvm_solaris.h
 if (!ReduceSignalUsage) {
 DO_SIGNAL_CHECK(SHUTDOWN1_SIGNAL);
 pthread_condattr_t* _condattr = os::Linux::condAttr();
 if ((status = pthread_condattr_init(_condattr)) != 0) {
 fatal(err_msg("pthread_condattr_init: %s", strerror(status)));
 }
 // Only set the clock if CLOCK_MONOTONIC is available
-if (Linux::supports_monotonic_clock()) {
+if (os::supports_monotonic_clock()) {
 if ((status = pthread_condattr_setclock(_condattr, CLOCK_MONOTONIC)) != 0) {
 if (status == EINVAL) {
 warning("Unable to use monotonic clock with relative timed-waits" \
 " - changes to the time-of-day clock may have adverse affects");
 } else {
 // note: perfMemory_exit_helper atexit function may be removed in
 // the future if the appropriate cleanup code can be added to the
 // VM_Exit VMOperation's doit method.
 if (atexit(perfMemory_exit_helper) != 0) {
-warning("os::init2 atexit(perfMemory_exit_helper) failed");
+warning("os::init_2 atexit(perfMemory_exit_helper) failed");
 }
 }
 // initialize thread priority policy
 prio_init();
 return JNI_OK;
 }
 // this is called at the end of vm_initialization
-void os::init_3(void)
+void os::init_3(void) {
-{
 #ifdef JAVASE_EMBEDDED
 // Start the MemNotifyThread
 if (LowMemoryProtection) {
 MemNotifyThread::start();
 }
 millis %= 1000;
 if (seconds > 50000000) { // see man cond_timedwait(3T)
 seconds = 50000000;
 }
-if (os::Linux::supports_monotonic_clock()) {
+if (os::supports_monotonic_clock()) {
 struct timespec now;
 int status = os::Linux::clock_gettime(CLOCK_MONOTONIC, &now);
 assert_status(status == 0, status, "clock_gettime");
 abstime->tv_sec = now.tv_sec  + seconds;
 long nanos = now.tv_nsec + millis * NANOSECS_PER_MILLISEC;
 static void unpackTime(timespec* absTime, bool isAbsolute, jlong time) {
 assert (time > 0, "convertTime");
 time_t max_secs = 0;
-if (!os::Linux::supports_monotonic_clock() || isAbsolute) {
+if (!os::supports_monotonic_clock() || isAbsolute) {
 struct timeval now;
 int status = gettimeofday(&now, NULL);
 assert(status == 0, "gettimeofday");
 max_secs = now.tv_sec + MAX_SECS;

Mercurial > hg > truffle

comparison src/os/linux/vm/os_linux.cpp @ 14518:d8041d695d19