< prev index next >
src/hotspot/share/runtime/mutex.cpp
Print this page
*** 824,833 ****
--- 824,845 ----
assert(ILocked(), "invariant");
return WasOnWaitSet != 0; // return true IFF timeout
}
+ #ifndef PRODUCT
+ void Monitor::check_safepoint_state(Thread* Self, bool do_safepoint_check) {
+ // If you check for safepoint, verify that the lock wasn't created with safepoint_check_never
+ // to allow safepoint_check_sometimes.
+ SafepointCheckRequired not_allowed = do_safepoint_check ?
+ Monitor::_safepoint_check_never :
+ Monitor::_safepoint_check_always;
+ assert(!Self->is_Java_thread() || _safepoint_check_required != not_allowed,
+ "This lock should %s have a safepoint check: %s",
+ _safepoint_check_required ? "always" : "never", name());
+ }
+ #endif
// ON THE VMTHREAD SNEAKING PAST HELD LOCKS:
// In particular, there are certain types of global lock that may be held
// by a Java thread while it is blocked at a safepoint but before it has
// written the _owner field. These locks may be sneakily acquired by the
*** 862,873 ****
// sneaking or dependence on any any clever invariants or subtle implementation properties
// of Mutex-Monitor and instead directly address the underlying design flaw.
void Monitor::lock(Thread * Self) {
// Ensure that the Monitor requires/allows safepoint checks.
! assert(_safepoint_check_required != Monitor::_safepoint_check_never,
! "This lock should never have a safepoint check: %s", name());
#ifdef CHECK_UNHANDLED_OOPS
// Clear unhandled oops so we get a crash right away. Only clear for non-vm
// or GC threads.
if (Self->is_Java_thread()) {
--- 874,884 ----
// sneaking or dependence on any any clever invariants or subtle implementation properties
// of Mutex-Monitor and instead directly address the underlying design flaw.
void Monitor::lock(Thread * Self) {
// Ensure that the Monitor requires/allows safepoint checks.
! check_safepoint_state(Self, true);
#ifdef CHECK_UNHANDLED_OOPS
// Clear unhandled oops so we get a crash right away. Only clear for non-vm
// or GC threads.
if (Self->is_Java_thread()) {
*** 924,935 ****
// that is guaranteed not to block while running inside the VM. If this is called with
// thread state set to be in VM, the safepoint synchronization code will deadlock!
void Monitor::lock_without_safepoint_check(Thread * Self) {
// Ensure that the Monitor does not require or allow safepoint checks.
! assert(_safepoint_check_required != Monitor::_safepoint_check_always,
! "This lock should always have a safepoint check: %s", name());
assert(_owner != Self, "invariant");
ILock(Self);
assert(_owner == NULL, "invariant");
set_owner(Self);
}
--- 935,945 ----
// that is guaranteed not to block while running inside the VM. If this is called with
// thread state set to be in VM, the safepoint synchronization code will deadlock!
void Monitor::lock_without_safepoint_check(Thread * Self) {
// Ensure that the Monitor does not require or allow safepoint checks.
! check_safepoint_state(Self, false);
assert(_owner != Self, "invariant");
ILock(Self);
assert(_owner == NULL, "invariant");
set_owner(Self);
}
*** 1055,1071 ****
IUnlock(false);
}
bool Monitor::wait(bool no_safepoint_check, long timeout,
bool as_suspend_equivalent) {
- // Make sure safepoint checking is used properly.
- assert(!(_safepoint_check_required == Monitor::_safepoint_check_never && no_safepoint_check == false),
- "This lock should never have a safepoint check: %s", name());
- assert(!(_safepoint_check_required == Monitor::_safepoint_check_always && no_safepoint_check == true),
- "This lock should always have a safepoint check: %s", name());
-
Thread * const Self = Thread::current();
assert(_owner == Self, "invariant");
assert(ILocked(), "invariant");
// as_suspend_equivalent logically implies !no_safepoint_check
guarantee(!as_suspend_equivalent || !no_safepoint_check, "invariant");
--- 1065,1078 ----
IUnlock(false);
}
bool Monitor::wait(bool no_safepoint_check, long timeout,
bool as_suspend_equivalent) {
Thread * const Self = Thread::current();
+
+ // Make sure safepoint checking is used properly.
+ check_safepoint_state(Self, !no_safepoint_check);
assert(_owner == Self, "invariant");
assert(ILocked(), "invariant");
// as_suspend_equivalent logically implies !no_safepoint_check
guarantee(!as_suspend_equivalent || !no_safepoint_check, "invariant");
*** 1085,1095 ****
int wait_status;
// conceptually set the owner to NULL in anticipation of
// abdicating the lock in wait
set_owner(NULL);
! if (no_safepoint_check) {
wait_status = IWait(Self, timeout);
} else {
assert(Self->is_Java_thread(), "invariant");
JavaThread *jt = (JavaThread *)Self;
--- 1092,1102 ----
int wait_status;
// conceptually set the owner to NULL in anticipation of
// abdicating the lock in wait
set_owner(NULL);
! if (no_safepoint_check || !Self->is_Java_thread()) {
wait_status = IWait(Self, timeout);
} else {
assert(Self->is_Java_thread(), "invariant");
JavaThread *jt = (JavaThread *)Self;
< prev index next >