truffle: src/os/posix/vm/os_posix.cpp comparison

comparison src/os/posix/vm/os_posix.cpp @ 14475:6c9332549827

6546236: Thread interrupt() of Thread.sleep() can be lost on Solaris due to race with signal handler Reviewed-by: dholmes, dcubed

author	fparain
date	Wed, 19 Feb 2014 16:22:15 +0000
parents	c250880a6673
children	bb9356ec5967

comparison

equal deleted inserted replaced

-:de7f1b016d55
+:6c9332549827
 /*
-* 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.
 *
 */
 #include "prims/jvm.h"
 #include "runtime/frame.inline.hpp"
+#include "runtime/interfaceSupport.hpp"
 #include "runtime/os.hpp"
 #include "utilities/vmError.hpp"
 #include <unistd.h>
 #include <sys/resource.h>
 strncat(agent_entry_name, lib_name, name_len);
 }
 return agent_entry_name;
 }
+int os::sleep(Thread* thread, jlong millis, bool interruptible) {
+assert(thread == Thread::current(),  "thread consistency check");
+ParkEvent * const slp = thread->_SleepEvent ;
+slp->reset() ;
+OrderAccess::fence() ;
+if (interruptible) {
+jlong prevtime = javaTimeNanos();
+for (;;) {
+if (os::is_interrupted(thread, true)) {
+return OS_INTRPT;
+}
+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(!os::supports_monotonic_clock(), "unexpected time moving backwards detected in os::sleep(interruptible)");
+} 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(!os::supports_monotonic_clock(), "unexpected time moving backwards detected on os::sleep(!interruptible)");
+} else {
+millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC;
+}
+if (millis <= 0) break ;
+prevtime = newtime;
+slp->park(millis);
+}
+return OS_OK ;
+}
+}
+////////////////////////////////////////////////////////////////////////////////
+// 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();
+// NOTE that since there is no "lock" around the interrupt and
+// is_interrupted operations, there is the possibility that the
+// interrupted flag (in osThread) will be "false" but that the
+// low-level events will be in the signaled state. This is
+// intentional. The effect of this is that Object.wait() and
+// LockSupport.park() will appear to have a spurious wakeup, which
+// is allowed and not harmful, and the possibility is so rare that
+// it is not worth the added complexity to add yet another lock.
+// For the sleep event an explicit reset is performed on entry
+// to os::sleep, so there is no early return. It has also been
+// recommended not to put the interrupted flag into the "event"
+// structure because it hides the issue.
+if (interrupted && clear_interrupted) {
+osthread->set_interrupted(false);
+// consider thread->_SleepEvent->reset() ... optional optimization
+}
+return interrupted;
+}
 os::WatcherThreadCrashProtection::WatcherThreadCrashProtection() {
 assert(Thread::current()->is_Watcher_thread(), "Must be WatcherThread");
 }
 /*

Mercurial > hg > truffle

comparison src/os/posix/vm/os_posix.cpp @ 14475:6c9332549827