changeset 59774:36e49db57f6d

8237756: Backout: JDK-8230594: Allow direct handshakes without VMThread intervention Summary: Backout JDK-8230594 Reviewed-by: coleenp, dcubed
author pchilanomate
date Thu, 23 Jan 2020 17:26:52 +0000
parents 34138fe5f9f7
children f2eeb97f9b3d
files src/hotspot/share/runtime/biasedLocking.cpp src/hotspot/share/runtime/handshake.cpp src/hotspot/share/runtime/handshake.hpp src/hotspot/share/runtime/mutexLocker.cpp src/hotspot/share/runtime/safepoint.cpp src/hotspot/share/runtime/safepointMechanism.inline.hpp src/hotspot/share/runtime/thread.cpp src/hotspot/share/runtime/thread.hpp test/hotspot/jtreg/runtime/handshake/HandshakeDirectTest.java
diffstat 9 files changed, 158 insertions(+), 343 deletions(-) [+]
line wrap: on
line diff
--- a/src/hotspot/share/runtime/biasedLocking.cpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/biasedLocking.cpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2019, 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
@@ -622,7 +622,7 @@
                                      p2i(biaser), p2i(obj()));
 
   RevokeOneBias revoke(obj, requester, biaser);
-  bool executed = Handshake::execute_direct(&revoke, biaser);
+  bool executed = Handshake::execute(&revoke, biaser);
   if (revoke.status_code() == NOT_REVOKED) {
     return NOT_REVOKED;
   }
@@ -668,8 +668,7 @@
 void BiasedLocking::walk_stack_and_revoke(oop obj, JavaThread* biased_locker) {
   assert(!SafepointSynchronize::is_at_safepoint() || !SafepointMechanism::uses_thread_local_poll(),
          "if SafepointMechanism::uses_thread_local_poll() is enabled this should always be executed outside safepoints");
-  Thread* cur = Thread::current();
-  assert(cur == biased_locker || cur == biased_locker->get_active_handshaker() || cur->is_VM_thread(), "wrong thread");
+  assert(Thread::current() == biased_locker || Thread::current()->is_VM_thread(), "wrong thread");
 
   markWord mark = obj->mark();
   assert(mark.biased_locker() == biased_locker &&
@@ -678,14 +677,14 @@
   log_trace(biasedlocking)("%s(" INTPTR_FORMAT ") revoking object " INTPTR_FORMAT ", mark "
                            INTPTR_FORMAT ", type %s, prototype header " INTPTR_FORMAT
                            ", biaser " INTPTR_FORMAT " %s",
-                           cur->is_VM_thread() ? "VMThread" : "JavaThread",
-                           p2i(cur),
+                           Thread::current()->is_VM_thread() ? "VMThread" : "JavaThread",
+                           p2i(Thread::current()),
                            p2i(obj),
                            mark.value(),
                            obj->klass()->external_name(),
                            obj->klass()->prototype_header().value(),
                            p2i(biased_locker),
-                           cur->is_VM_thread() ? "" : "(walking own stack)");
+                           Thread::current()->is_VM_thread() ? "" : "(walking own stack)");
 
   markWord unbiased_prototype = markWord::prototype().set_age(obj->mark().age());
 
--- a/src/hotspot/share/runtime/handshake.cpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/handshake.cpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2019, 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
@@ -37,49 +37,51 @@
 #include "utilities/formatBuffer.hpp"
 #include "utilities/preserveException.hpp"
 
+class HandshakeOperation: public StackObj {
+public:
+  virtual void do_handshake(JavaThread* thread) = 0;
+};
 
-class HandshakeOperation: public StackObj {
+class HandshakeThreadsOperation: public HandshakeOperation {
+  static Semaphore _done;
   HandshakeClosure* _handshake_cl;
-  int32_t _pending_threads;
   bool _executed;
-  bool _is_direct;
 public:
-  HandshakeOperation(HandshakeClosure* cl, bool is_direct = false) :
-    _handshake_cl(cl),
-    _pending_threads(1),
-    _executed(false),
-    _is_direct(is_direct) {}
-
+  HandshakeThreadsOperation(HandshakeClosure* cl) : _handshake_cl(cl), _executed(false) {}
   void do_handshake(JavaThread* thread);
-  bool is_completed() {
-    int64_t val = Atomic::load(&_pending_threads);
-    assert(val >= 0, "_pending_threads cannot be negative");
-    return val == 0;
-  }
-  void add_target_count(int count) { Atomic::add(&_pending_threads, count); }
+  bool thread_has_completed() { return _done.trywait(); }
   bool executed() const { return _executed; }
   const char* name() { return _handshake_cl->name(); }
 
-  bool is_direct() { return _is_direct; }
-
 #ifdef ASSERT
   void check_state() {
-    assert(_pending_threads == 0, "Must be zero");
+    assert(!_done.trywait(), "Must be zero");
   }
 #endif
 };
 
+Semaphore HandshakeThreadsOperation::_done(0);
+
 class VM_Handshake: public VM_Operation {
   const jlong _handshake_timeout;
  public:
   bool evaluate_at_safepoint() const { return false; }
 
  protected:
-  HandshakeOperation* const _op;
+  HandshakeThreadsOperation* const _op;
 
-  VM_Handshake(HandshakeOperation* op) :
+  VM_Handshake(HandshakeThreadsOperation* op) :
       _handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
 
+  void set_handshake(JavaThread* target) {
+    target->set_handshake_operation(_op);
+  }
+
+  // This method returns true for threads completed their operation
+  // and true for threads canceled their operation.
+  // A cancellation can happen if the thread is exiting.
+  bool poll_for_completed_thread() { return _op->thread_has_completed(); }
+
   bool handshake_has_timed_out(jlong start_time);
   static void handle_timeout();
 };
@@ -119,10 +121,12 @@
 class VM_HandshakeOneThread: public VM_Handshake {
   JavaThread* _target;
  public:
-  VM_HandshakeOneThread(HandshakeOperation* op, JavaThread* target) :
+  VM_HandshakeOneThread(HandshakeThreadsOperation* op, JavaThread* target) :
     VM_Handshake(op), _target(target) {}
 
   void doit() {
+    DEBUG_ONLY(_op->check_state();)
+
     jlong start_time_ns = 0;
     if (log_is_enabled(Info, handshake)) {
       start_time_ns = os::javaTimeNanos();
@@ -130,7 +134,7 @@
 
     ThreadsListHandle tlh;
     if (tlh.includes(_target)) {
-      _target->set_handshake_operation(_op);
+      set_handshake(_target);
     } else {
       log_handshake_info(start_time_ns, _op->name(), 0, 0, "(thread dead)");
       return;
@@ -143,8 +147,8 @@
       if (handshake_has_timed_out(timeout_start_time)) {
         handle_timeout();
       }
-      by_vm_thread = _target->handshake_try_process(_op);
-    } while (!_op->is_completed());
+      by_vm_thread = _target->handshake_try_process_by_vmThread();
+    } while (!poll_for_completed_thread());
     DEBUG_ONLY(_op->check_state();)
     log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0);
   }
@@ -156,9 +160,11 @@
 
 class VM_HandshakeAllThreads: public VM_Handshake {
  public:
-  VM_HandshakeAllThreads(HandshakeOperation* op) : VM_Handshake(op) {}
+  VM_HandshakeAllThreads(HandshakeThreadsOperation* op) : VM_Handshake(op) {}
 
   void doit() {
+    DEBUG_ONLY(_op->check_state();)
+
     jlong start_time_ns = 0;
     if (log_is_enabled(Info, handshake)) {
       start_time_ns = os::javaTimeNanos();
@@ -168,7 +174,7 @@
     JavaThreadIteratorWithHandle jtiwh;
     int number_of_threads_issued = 0;
     for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
-      thr->set_handshake_operation(_op);
+      set_handshake(thr);
       number_of_threads_issued++;
     }
 
@@ -176,11 +182,10 @@
       log_handshake_info(start_time_ns, _op->name(), 0, 0);
       return;
     }
-    // _op was created with a count == 1 so don't double count.
-    _op->add_target_count(number_of_threads_issued - 1);
 
     log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread");
     const jlong start_time = os::elapsed_counter();
+    int number_of_threads_completed = 0;
     do {
       // Check if handshake operation has timed out
       if (handshake_has_timed_out(start_time)) {
@@ -193,12 +198,18 @@
       jtiwh.rewind();
       for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
         // A new thread on the ThreadsList will not have an operation,
-        // hence it is skipped in handshake_try_process.
-        if (thr->handshake_try_process(_op)) {
+        // hence it is skipped in handshake_process_by_vmthread.
+        if (thr->handshake_try_process_by_vmThread()) {
           handshake_executed_by_vm_thread++;
         }
       }
-    } while (!_op->is_completed());
+      while (poll_for_completed_thread()) {
+        // Includes canceled operations by exiting threads.
+        number_of_threads_completed++;
+      }
+
+    } while (number_of_threads_issued > number_of_threads_completed);
+    assert(number_of_threads_issued == number_of_threads_completed, "Must be the same");
     DEBUG_ONLY(_op->check_state();)
 
     log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread);
@@ -234,7 +245,7 @@
   bool executed() const { return _executed; }
 };
 
-void HandshakeOperation::do_handshake(JavaThread* thread) {
+void HandshakeThreadsOperation::do_handshake(JavaThread* thread) {
   jlong start_time_ns = 0;
   if (log_is_enabled(Debug, handshake, task)) {
     start_time_ns = os::javaTimeNanos();
@@ -252,16 +263,16 @@
                                name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
   }
 
-  // Inform VMThread/Handshaker that we have completed the operation
-  Atomic::dec(&_pending_threads);
+  // Use the semaphore to inform the VM thread that we have completed the operation
+  _done.signal();
 
-  // It is no longer safe to refer to 'this' as the VMThread/Handshaker may have destroyed this operation
+  // It is no longer safe to refer to 'this' as the VMThread may have destroyed this operation
 }
 
 void Handshake::execute(HandshakeClosure* thread_cl) {
   if (SafepointMechanism::uses_thread_local_poll()) {
-    HandshakeOperation ho(thread_cl);
-    VM_HandshakeAllThreads handshake(&ho);
+    HandshakeThreadsOperation cto(thread_cl);
+    VM_HandshakeAllThreads handshake(&cto);
     VMThread::execute(&handshake);
   } else {
     VM_HandshakeFallbackOperation op(thread_cl);
@@ -271,8 +282,8 @@
 
 bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
   if (SafepointMechanism::uses_thread_local_poll()) {
-    HandshakeOperation ho(thread_cl);
-    VM_HandshakeOneThread handshake(&ho, target);
+    HandshakeThreadsOperation cto(thread_cl);
+    VM_HandshakeOneThread handshake(&cto, target);
     VMThread::execute(&handshake);
     return handshake.executed();
   } else {
@@ -282,125 +293,61 @@
   }
 }
 
-bool Handshake::execute_direct(HandshakeClosure* thread_cl, JavaThread* target) {
-  if (!SafepointMechanism::uses_thread_local_poll()) {
-    VM_HandshakeFallbackOperation op(thread_cl, target);
-    VMThread::execute(&op);
-    return op.executed();
-  }
-  JavaThread* self = JavaThread::current();
-  HandshakeOperation op(thread_cl, /*is_direct*/ true);
-
-  jlong start_time_ns = 0;
-  if (log_is_enabled(Info, handshake)) {
-    start_time_ns = os::javaTimeNanos();
-  }
-
-  ThreadsListHandle tlh;
-  if (tlh.includes(target)) {
-    target->set_handshake_operation(&op);
-  } else {
-    log_handshake_info(start_time_ns, op.name(), 0, 0, "(thread dead)");
-    return false;
-  }
-
-  bool by_handshaker = false;
-  while (!op.is_completed()) {
-    by_handshaker = target->handshake_try_process(&op);
-    // Check for pending handshakes to avoid possible deadlocks where our
-    // target is trying to handshake us.
-    if (SafepointMechanism::should_block(self)) {
-      ThreadBlockInVM tbivm(self);
-    }
-  }
-  DEBUG_ONLY(op.check_state();)
-  log_handshake_info(start_time_ns, op.name(), 1, by_handshaker ? 1 : 0);
-
-  return op.executed();
+HandshakeState::HandshakeState() : _operation(NULL), _semaphore(1), _thread_in_process_handshake(false) {
+  DEBUG_ONLY(_vmthread_processing_handshake = false;)
 }
 
-HandshakeState::HandshakeState() :
-  _operation(NULL),
-  _operation_direct(NULL),
-  _handshake_turn_sem(1),
-  _processing_sem(1),
-  _thread_in_process_handshake(false)
-{
-  DEBUG_ONLY(_active_handshaker = NULL;)
+void HandshakeState::set_operation(JavaThread* target, HandshakeOperation* op) {
+  _operation = op;
+  SafepointMechanism::arm_local_poll_release(target);
 }
 
-void HandshakeState::set_operation(HandshakeOperation* op) {
-  if (!op->is_direct()) {
-    assert(Thread::current()->is_VM_thread(), "should be the VMThread");
-    _operation = op;
-  } else {
-    assert(Thread::current()->is_Java_thread(), "should be a JavaThread");
-    // Serialize direct handshakes so that only one proceeds at a time for a given target
-    _handshake_turn_sem.wait_with_safepoint_check(JavaThread::current());
-    _operation_direct = op;
-  }
-  SafepointMechanism::arm_local_poll_release(_handshakee);
+void HandshakeState::clear_handshake(JavaThread* target) {
+  _operation = NULL;
+  SafepointMechanism::disarm_if_needed(target, true /* release */);
 }
 
-void HandshakeState::clear_handshake(bool is_direct) {
-  if (!is_direct) {
-    _operation = NULL;
-  } else {
-    _operation_direct = NULL;
-    _handshake_turn_sem.signal();
-  }
-}
-
-void HandshakeState::process_self_inner() {
-  assert(Thread::current() == _handshakee, "should call from _handshakee");
-  assert(!_handshakee->is_terminated(), "should not be a terminated thread");
-  assert(_handshakee->thread_state() != _thread_blocked, "should not be in a blocked state");
-  assert(_handshakee->thread_state() != _thread_in_native, "should not be in native");
-  JavaThread* self = _handshakee;
+void HandshakeState::process_self_inner(JavaThread* thread) {
+  assert(Thread::current() == thread, "should call from thread");
+  assert(!thread->is_terminated(), "should not be a terminated thread");
+  assert(thread->thread_state() != _thread_blocked, "should not be in a blocked state");
+  assert(thread->thread_state() != _thread_in_native, "should not be in native");
 
   do {
-    ThreadInVMForHandshake tivm(self);
-    if (!_processing_sem.trywait()) {
-      _processing_sem.wait_with_safepoint_check(self);
+    ThreadInVMForHandshake tivm(thread);
+    if (!_semaphore.trywait()) {
+      _semaphore.wait_with_safepoint_check(thread);
     }
-    if (has_operation()) {
-      HandleMark hm(self);
-      CautiouslyPreserveExceptionMark pem(self);
-      HandshakeOperation * op = _operation;
-      if (op != NULL) {
-        // Disarm before executing the operation
-        clear_handshake(/*is_direct*/ false);
-        op->do_handshake(self);
-      }
-      op = _operation_direct;
-      if (op != NULL) {
-        // Disarm before executing the operation
-        clear_handshake(/*is_direct*/ true);
-        op->do_handshake(self);
-      }
+    HandshakeOperation* op = Atomic::load_acquire(&_operation);
+    if (op != NULL) {
+      HandleMark hm(thread);
+      CautiouslyPreserveExceptionMark pem(thread);
+      // Disarm before execute the operation
+      clear_handshake(thread);
+      op->do_handshake(thread);
     }
-    _processing_sem.signal();
+    _semaphore.signal();
   } while (has_operation());
 }
 
-bool HandshakeState::can_process_handshake() {
+bool HandshakeState::vmthread_can_process_handshake(JavaThread* target) {
   // handshake_safe may only be called with polls armed.
-  // Handshaker controls this by first claiming the handshake via claim_handshake().
-  return SafepointSynchronize::handshake_safe(_handshakee);
+  // VM thread controls this by first claiming the handshake via claim_handshake_for_vmthread.
+  return SafepointSynchronize::handshake_safe(target);
 }
 
-bool HandshakeState::possibly_can_process_handshake() {
+static bool possibly_vmthread_can_process_handshake(JavaThread* target) {
   // Note that this method is allowed to produce false positives.
-  if (_handshakee->is_ext_suspended()) {
+  if (target->is_ext_suspended()) {
     return true;
   }
-  if (_handshakee->is_terminated()) {
+  if (target->is_terminated()) {
     return true;
   }
-  switch (_handshakee->thread_state()) {
+  switch (target->thread_state()) {
   case _thread_in_native:
     // native threads are safe if they have no java stack or have walkable stack
-    return !_handshakee->has_last_Java_frame() || _handshakee->frame_anchor()->walkable();
+    return !target->has_last_Java_frame() || target->frame_anchor()->walkable();
 
   case _thread_blocked:
     return true;
@@ -410,40 +357,32 @@
   }
 }
 
-bool HandshakeState::claim_handshake(bool is_direct) {
-  if (!_processing_sem.trywait()) {
+bool HandshakeState::claim_handshake_for_vmthread() {
+  if (!_semaphore.trywait()) {
     return false;
   }
-  if (has_specific_operation(is_direct)){
+  if (has_operation()) {
     return true;
   }
-  _processing_sem.signal();
+  _semaphore.signal();
   return false;
 }
 
-bool HandshakeState::try_process(HandshakeOperation* op) {
-  bool is_direct = op->is_direct();
+bool HandshakeState::try_process_by_vmThread(JavaThread* target) {
+  assert(Thread::current()->is_VM_thread(), "should call from vm thread");
 
-  if (!has_specific_operation(is_direct)){
+  if (!has_operation()) {
     // JT has already cleared its handshake
     return false;
   }
 
-  if (!possibly_can_process_handshake()) {
+  if (!possibly_vmthread_can_process_handshake(target)) {
     // JT is observed in an unsafe state, it must notice the handshake itself
     return false;
   }
 
   // Claim the semaphore if there still an operation to be executed.
-  if (!claim_handshake(is_direct)) {
-    return false;
-  }
-
-  // Check if the handshake operation is the same as the one we meant to execute. The
-  // handshake could have been already processed by the handshakee and a new handshake
-  // by another JavaThread might be in progress.
-  if ( (is_direct && op != _operation_direct)) {
-    _processing_sem.signal();
+  if (!claim_handshake_for_vmthread()) {
     return false;
   }
 
@@ -451,19 +390,19 @@
   // can observe a safe state the thread cannot possibly continue without
   // getting caught by the semaphore.
   bool executed = false;
-  if (can_process_handshake()) {
-    guarantee(!_processing_sem.trywait(), "we should already own the semaphore");
-    log_trace(handshake)("Processing handshake by %s", Thread::current()->is_VM_thread() ? "VMThread" : "Handshaker");
-    DEBUG_ONLY(_active_handshaker = Thread::current();)
-    op->do_handshake(_handshakee);
-    DEBUG_ONLY(_active_handshaker = NULL;)
-    // Disarm after we have executed the operation.
-    clear_handshake(is_direct);
+  if (vmthread_can_process_handshake(target)) {
+    guarantee(!_semaphore.trywait(), "we should already own the semaphore");
+    log_trace(handshake)("Processing handshake by VMThtread");
+    DEBUG_ONLY(_vmthread_processing_handshake = true;)
+    _operation->do_handshake(target);
+    DEBUG_ONLY(_vmthread_processing_handshake = false;)
+    // Disarm after VM thread have executed the operation.
+    clear_handshake(target);
     executed = true;
   }
 
   // Release the thread
-  _processing_sem.signal();
+  _semaphore.signal();
 
   return executed;
 }
--- a/src/hotspot/share/runtime/handshake.hpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/handshake.hpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2019, 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
@@ -30,17 +30,13 @@
 #include "runtime/flags/flagSetting.hpp"
 #include "runtime/semaphore.hpp"
 
-class HandshakeOperation;
 class JavaThread;
 
 // A handshake closure is a callback that is executed for each JavaThread
 // while that thread is in a safepoint safe state. The callback is executed
-// either by the target JavaThread itself or by the VMThread while keeping
-// the target thread in a blocked state. A handshake can be performed with a
-// single JavaThread as well. In that case, the callback is executed either
-// by the target JavaThread itself or, depending on whether the operation is
-// a direct handshake or not, by the JavaThread that requested the handshake
-// or the VMThread respectively.
+// either by the thread itself or by the VM thread while keeping the thread
+// in a blocked state. A handshake can be performed with a single
+// JavaThread as well.
 class HandshakeClosure : public ThreadClosure {
   const char* const _name;
  public:
@@ -56,51 +52,47 @@
   // Execution of handshake operation
   static void execute(HandshakeClosure* hs_cl);
   static bool execute(HandshakeClosure* hs_cl, JavaThread* target);
-  static bool execute_direct(HandshakeClosure* hs_cl, JavaThread* target);
 };
 
-// The HandshakeState keeps track of an ongoing handshake for this JavaThread.
-// VMThread/Handshaker and JavaThread are serialized with semaphore _processing_sem
-// making sure the operation is only done by either VMThread/Handshaker on behalf
-// of the JavaThread or by the target JavaThread itself.
+class HandshakeOperation;
+
+// The HandshakeState keep tracks of an ongoing handshake for one JavaThread.
+// VM thread and JavaThread are serialized with the semaphore making sure
+// the operation is only done by either VM thread on behalf of the JavaThread
+// or the JavaThread itself.
 class HandshakeState {
-  JavaThread* _handshakee;
   HandshakeOperation* volatile _operation;
-  HandshakeOperation* volatile _operation_direct;
 
-  Semaphore _handshake_turn_sem;  // Used to serialize direct handshakes for this JavaThread.
-  Semaphore _processing_sem;
+  Semaphore _semaphore;
   bool _thread_in_process_handshake;
 
-  bool claim_handshake(bool is_direct);
-  bool possibly_can_process_handshake();
-  bool can_process_handshake();
-  void clear_handshake(bool is_direct);
+  bool claim_handshake_for_vmthread();
+  bool vmthread_can_process_handshake(JavaThread* target);
 
-  void process_self_inner();
+  void clear_handshake(JavaThread* thread);
 
+  void process_self_inner(JavaThread* thread);
 public:
   HandshakeState();
 
-  void set_thread(JavaThread* thread) { _handshakee = thread; }
+  void set_operation(JavaThread* thread, HandshakeOperation* op);
 
-  void set_operation(HandshakeOperation* op);
-  bool has_operation() const { return _operation != NULL || _operation_direct != NULL; }
-  bool has_specific_operation(bool is_direct) const {
-    return is_direct ? _operation_direct != NULL : _operation != NULL;
+  bool has_operation() const {
+    return _operation != NULL;
   }
 
-  void process_by_self() {
+  void process_by_self(JavaThread* thread) {
     if (!_thread_in_process_handshake) {
       FlagSetting fs(_thread_in_process_handshake, true);
-      process_self_inner();
+      process_self_inner(thread);
     }
   }
-  bool try_process(HandshakeOperation* op);
+
+  bool try_process_by_vmThread(JavaThread* target);
 
 #ifdef ASSERT
-  Thread* _active_handshaker;
-  Thread* get_active_handshaker() const { return _active_handshaker; }
+  bool _vmthread_processing_handshake;
+  bool is_vmthread_processing_handshake() const { return _vmthread_processing_handshake; }
 #endif
 
 };
--- a/src/hotspot/share/runtime/mutexLocker.cpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/mutexLocker.cpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2019, 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
@@ -189,7 +189,7 @@
 }
 
 void assert_locked_or_safepoint_or_handshake(const Mutex* lock, const JavaThread* thread) {
-  if (Thread::current() == thread->get_active_handshaker()) return;
+  if (Thread::current()->is_VM_thread() && thread->is_vmthread_processing_handshake()) return;
   assert_locked_or_safepoint(lock);
 }
 #endif
--- a/src/hotspot/share/runtime/safepoint.cpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/safepoint.cpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2019, 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
@@ -494,6 +494,8 @@
       assert(!cur_state->is_running(), "Thread not suspended at safepoint");
       cur_state->restart(); // TSS _running
       assert(cur_state->is_running(), "safepoint state has not been reset");
+
+      SafepointMechanism::disarm_if_needed(current, false /* NO release */);
     }
   } // ~JavaThreadIteratorWithHandle
 
@@ -734,6 +736,7 @@
 }
 
 bool SafepointSynchronize::handshake_safe(JavaThread *thread) {
+  assert(Thread::current()->is_VM_thread(), "Must be VMThread");
   if (thread->is_ext_suspended() || thread->is_terminated()) {
     return true;
   }
--- a/src/hotspot/share/runtime/safepointMechanism.inline.hpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/safepointMechanism.inline.hpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2019, 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
@@ -70,6 +70,19 @@
   thread->set_polling_page(poll_disarmed_value());
 }
 
+void SafepointMechanism::disarm_if_needed(JavaThread* thread, bool memory_order_release) {
+  JavaThreadState jts = thread->thread_state();
+  if (jts == _thread_in_native || jts == _thread_in_native_trans) {
+    // JavaThread will disarm itself and execute cross_modify_fence() before continuing
+    return;
+  }
+  if (memory_order_release) {
+    thread->set_polling_page_release(poll_disarmed_value());
+  } else {
+    thread->set_polling_page(poll_disarmed_value());
+  }
+}
+
 void SafepointMechanism::arm_local_poll_release(JavaThread* thread) {
   thread->set_polling_page_release(poll_armed_value());
 }
--- a/src/hotspot/share/runtime/thread.cpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/thread.cpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1706,7 +1706,6 @@
   _SleepEvent = ParkEvent::Allocate(this);
   // Setup safepoint state info for this thread
   ThreadSafepointState::create(this);
-  _handshake.set_thread(this);
 
   debug_only(_java_call_counter = 0);
 
--- a/src/hotspot/share/runtime/thread.hpp	Thu Jan 23 14:43:37 2020 +0000
+++ b/src/hotspot/share/runtime/thread.hpp	Thu Jan 23 17:26:52 2020 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2019, 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
@@ -1318,7 +1318,7 @@
   HandshakeState _handshake;
  public:
   void set_handshake_operation(HandshakeOperation* op) {
-    _handshake.set_operation(op);
+    _handshake.set_operation(this, op);
   }
 
   bool has_handshake() const {
@@ -1326,16 +1326,16 @@
   }
 
   void handshake_process_by_self() {
-    _handshake.process_by_self();
+    _handshake.process_by_self(this);
   }
 
-  bool handshake_try_process(HandshakeOperation* op) {
-    return _handshake.try_process(op);
+  bool handshake_try_process_by_vmThread() {
+    return _handshake.try_process_by_vmThread(this);
   }
 
 #ifdef ASSERT
-  Thread* get_active_handshaker() const {
-    return _handshake.get_active_handshaker();
+  bool is_vmthread_processing_handshake() const {
+    return _handshake.is_vmthread_processing_handshake();
   }
 #endif
 
--- a/test/hotspot/jtreg/runtime/handshake/HandshakeDirectTest.java	Thu Jan 23 14:43:37 2020 +0000
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,130 +0,0 @@
-/*
- * Copyright (c) 2020, 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.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- *
- */
-
-/*
- * @test HandshakeDirectTest
- * @summary This test tries to stress direct handshakes between threads while suspending them.
- * @library /testlibrary /test/lib
- * @build HandshakeDirectTest
- * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:+SafepointALot -XX:BiasedLockingDecayTime=100000000 -XX:BiasedLockingBulkRebiasThreshold=1000000 -XX:BiasedLockingBulkRevokeThreshold=1000000 HandshakeDirectTest
- * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:GuaranteedSafepointInterval=10 -XX:+HandshakeALot -XX:+SafepointALot -XX:BiasedLockingDecayTime=100000000 -XX:BiasedLockingBulkRebiasThreshold=1000000 -XX:BiasedLockingBulkRevokeThreshold=1000000 HandshakeDirectTest
- */
-
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.concurrent.Semaphore;
-import java.io.*;
-
-public class HandshakeDirectTest  implements Runnable {
-    static final int WORKING_THREADS = 32;
-    static final int DIRECT_HANDSHAKES_MARK = 50000;
-    static Thread[] workingThreads = new Thread[WORKING_THREADS];
-    static Semaphore[] handshakeSem = new Semaphore[WORKING_THREADS];
-    static Object[] locks = new Object[WORKING_THREADS];
-    static boolean[] isBiased = new boolean[WORKING_THREADS];
-    static AtomicInteger handshakeCount = new AtomicInteger(0);
-
-    @Override
-    public void run() {
-        int me = Integer.parseInt(Thread.currentThread().getName());
-
-        while (true) {
-            try {
-                if (!isBiased[me]) {
-                    handshakeSem[me].acquire();
-                    synchronized(locks[me]) {
-                        isBiased[me] = true;
-                    }
-                    handshakeSem[me].release();
-                }
-
-                // Handshake directly some other worker
-                int handshakee = ThreadLocalRandom.current().nextInt(0, WORKING_THREADS-1);
-                if (handshakee == me) {
-                    handshakee = handshakee != 0 ? handshakee - 1 : handshakee + 1;
-                }
-                handshakeSem[handshakee].acquire();
-                if (isBiased[handshakee]) {
-                    // Revoke biased lock
-                    synchronized(locks[handshakee]) {
-                        handshakeCount.incrementAndGet();
-                    }
-                    // Create new lock to be biased
-                    locks[handshakee] = new Object();
-                    isBiased[handshakee] = false;
-                }
-                handshakeSem[handshakee].release();
-                if (handshakeCount.get() >= DIRECT_HANDSHAKES_MARK) {
-                    break;
-                }
-            } catch(InterruptedException ie) {
-                throw new Error("Unexpected interrupt");
-            }
-        }
-    }
-
-    public static void main(String... args) throws Exception {
-        HandshakeDirectTest test = new HandshakeDirectTest();
-
-        // Initialize semaphores
-        for (int i = 0; i < WORKING_THREADS; i++) {
-            handshakeSem[i] = new Semaphore(1);
-        }
-
-        // Initialize locks
-        for (int i = 0; i < WORKING_THREADS; i++) {
-            locks[i] = new Object();
-        }
-
-        // Fire-up working threads.
-        for (int i = 0; i < WORKING_THREADS; i++) {
-            workingThreads[i] = new Thread(test, Integer.toString(i));
-            workingThreads[i].start();
-        }
-
-        // Fire-up suspend-resume thread
-        Thread suspendResumeThread = new Thread() {
-            @Override
-            public void run() {
-                while (true) {
-                    int i = ThreadLocalRandom.current().nextInt(0, WORKING_THREADS-1);
-                    workingThreads[i].suspend();
-                    try {
-                        Thread.sleep(1); // sleep for 1 ms
-                    } catch(InterruptedException ie) {
-                    }
-                    workingThreads[i].resume();
-                }
-            }
-        };
-        suspendResumeThread.setDaemon(true);
-        suspendResumeThread.start();
-
-        // Wait until the desired number of direct handshakes is reached
-        // and check that all workers exited
-        for (int i = 0; i < WORKING_THREADS; i++) {
-            workingThreads[i].join();
-        }
-    }
-}