1 /*
   2  * Copyright (c) 2017, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "logging/log.hpp"
  27 #include "logging/logStream.hpp"
  28 #include "memory/resourceArea.hpp"
  29 #include "runtime/atomic.hpp"
  30 #include "runtime/handshake.hpp"
  31 #include "runtime/interfaceSupport.inline.hpp"
  32 #include "runtime/osThread.hpp"
  33 #include "runtime/semaphore.inline.hpp"
  34 #include "runtime/task.hpp"
  35 #include "runtime/thread.hpp"
  36 #include "runtime/vmThread.hpp"
  37 #include "utilities/formatBuffer.hpp"
  38 #include "utilities/preserveException.hpp"
  39 
  40 class HandshakeOperation: public StackObj {
  41 public:
  42   virtual void do_handshake(JavaThread* thread) = 0;
  43 };
  44 
  45 class HandshakeThreadsOperation: public HandshakeOperation {
  46   static Semaphore _done;
  47   HandshakeClosure* _handshake_cl;

  48   bool _executed;

  49 public:
  50   HandshakeThreadsOperation(HandshakeClosure* cl) : _handshake_cl(cl), _executed(false) {}





  51   void do_handshake(JavaThread* thread);
  52   bool thread_has_completed() { return _done.trywait(); }





  53   bool executed() const { return _executed; }
  54   const char* name() { return _handshake_cl->name(); }
  55 
  56 #ifdef ASSERT
  57   void check_state() {
  58     assert(!_done.trywait(), "Must be zero");
  59   }
  60 #endif
  61 };
  62 
  63 Semaphore HandshakeThreadsOperation::_done(0);
  64 
  65 class VM_Handshake: public VM_Operation {
  66   const jlong _handshake_timeout;
  67  public:
  68   bool evaluate_at_safepoint() const { return false; }
  69 
  70  protected:
  71   HandshakeThreadsOperation* const _op;
  72 
  73   VM_Handshake(HandshakeThreadsOperation* op) :
  74       _handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
  75 
  76   void set_handshake(JavaThread* target) {
  77     target->set_handshake_operation(_op);
  78   }
  79 
  80   // This method returns true for threads completed their operation
  81   // and true for threads canceled their operation.
  82   // A cancellation can happen if the thread is exiting.
  83   bool poll_for_completed_thread() { return _op->thread_has_completed(); }
  84 
  85   bool handshake_has_timed_out(jlong start_time);
  86   static void handle_timeout();
  87 };
  88 
  89 bool VM_Handshake::handshake_has_timed_out(jlong start_time) {
  90   // Check if handshake operation has timed out
  91   if (_handshake_timeout > 0) {
  92     return os::elapsed_counter() >= (start_time + _handshake_timeout);
  93   }
  94   return false;
  95 }
  96 
  97 void VM_Handshake::handle_timeout() {
  98   LogStreamHandle(Warning, handshake) log_stream;
  99   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
 100     if (thr->has_handshake()) {
 101       log_stream.print("Thread " PTR_FORMAT " has not cleared its handshake op", p2i(thr));
 102       thr->print_thread_state_on(&log_stream);
 103     }
 104   }
 105   log_stream.flush();
 106   fatal("Handshake operation timed out");
 107 }
 108 
 109 static void log_handshake_info(jlong start_time_ns, const char* name, int targets, int vmt_executed, const char* extra = NULL) {
 110   if (start_time_ns != 0) {
 111     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 112     log_info(handshake)("Handshake \"%s\", Targeted threads: %d, Executed by targeted threads: %d, Total completion time: " JLONG_FORMAT " ns%s%s",
 113                         name, targets,
 114                         targets - vmt_executed,
 115                         completion_time,
 116                         extra != NULL ? ", " : "",
 117                         extra != NULL ? extra : "");
 118   }
 119 }
 120 
 121 class VM_HandshakeOneThread: public VM_Handshake {
 122   JavaThread* _target;
 123  public:
 124   VM_HandshakeOneThread(HandshakeThreadsOperation* op, JavaThread* target) :
 125     VM_Handshake(op), _target(target) {}
 126 
 127   void doit() {
 128     DEBUG_ONLY(_op->check_state();)
 129 
 130     jlong start_time_ns = 0;
 131     if (log_is_enabled(Info, handshake)) {
 132       start_time_ns = os::javaTimeNanos();
 133     }
 134 
 135     ThreadsListHandle tlh;
 136     if (tlh.includes(_target)) {
 137       set_handshake(_target);
 138     } else {
 139       log_handshake_info(start_time_ns, _op->name(), 0, 0, "(thread dead)");
 140       return;
 141     }
 142 
 143     log_trace(handshake)("JavaThread " INTPTR_FORMAT " signaled, begin attempt to process by VMThtread", p2i(_target));
 144     jlong timeout_start_time = os::elapsed_counter();
 145     bool by_vm_thread = false;
 146     do {
 147       if (handshake_has_timed_out(timeout_start_time)) {
 148         handle_timeout();
 149       }
 150       by_vm_thread = _target->handshake_try_process_by_vmThread();
 151     } while (!poll_for_completed_thread());
 152     DEBUG_ONLY(_op->check_state();)






 153     log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0);
 154   }
 155 
 156   VMOp_Type type() const { return VMOp_HandshakeOneThread; }
 157 
 158   bool executed() const { return _op->executed(); }
 159 };
 160 
 161 class VM_HandshakeAllThreads: public VM_Handshake {
 162  public:
 163   VM_HandshakeAllThreads(HandshakeThreadsOperation* op) : VM_Handshake(op) {}
 164 
 165   void doit() {
 166     DEBUG_ONLY(_op->check_state();)
 167 
 168     jlong start_time_ns = 0;
 169     if (log_is_enabled(Info, handshake)) {
 170       start_time_ns = os::javaTimeNanos();
 171     }
 172     int handshake_executed_by_vm_thread = 0;
 173 
 174     JavaThreadIteratorWithHandle jtiwh;
 175     int number_of_threads_issued = 0;
 176     for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 177       set_handshake(thr);
 178       number_of_threads_issued++;
 179     }
 180 
 181     if (number_of_threads_issued < 1) {
 182       log_handshake_info(start_time_ns, _op->name(), 0, 0);
 183       return;
 184     }


 185 
 186     log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread");
 187     const jlong start_time = os::elapsed_counter();
 188     int number_of_threads_completed = 0;
 189     do {
 190       // Check if handshake operation has timed out
 191       if (handshake_has_timed_out(start_time)) {
 192         handle_timeout();
 193       }
 194 
 195       // Have VM thread perform the handshake operation for blocked threads.
 196       // Observing a blocked state may of course be transient but the processing is guarded
 197       // by semaphores and we optimistically begin by working on the blocked threads
 198       jtiwh.rewind();
 199       for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 200         // A new thread on the ThreadsList will not have an operation,
 201         // hence it is skipped in handshake_process_by_vmthread.
 202         if (thr->handshake_try_process_by_vmThread()) {
 203           handshake_executed_by_vm_thread++;
 204         }
 205       }
 206       while (poll_for_completed_thread()) {
 207         // Includes canceled operations by exiting threads.
 208         number_of_threads_completed++;
 209       }
 210 
 211     } while (number_of_threads_issued > number_of_threads_completed);
 212     assert(number_of_threads_issued == number_of_threads_completed, "Must be the same");
 213     DEBUG_ONLY(_op->check_state();)


 214 
 215     log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread);
 216   }
 217 
 218   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 219 };
 220 
 221 void HandshakeThreadsOperation::do_handshake(JavaThread* thread) {
 222   jlong start_time_ns = 0;
 223   if (log_is_enabled(Debug, handshake, task)) {
 224     start_time_ns = os::javaTimeNanos();
 225   }
 226 
 227   // Only actually execute the operation for non terminated threads.
 228   if (!thread->is_terminated()) {
 229     _handshake_cl->do_thread(thread);
 230     _executed = true;
 231   }
 232 
 233   if (start_time_ns != 0) {
 234     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 235     log_debug(handshake, task)("Operation: %s for thread " PTR_FORMAT ", is_vm_thread: %s, completed in " JLONG_FORMAT " ns",
 236                                name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
 237   }
 238 
 239   // Use the semaphore to inform the VM thread that we have completed the operation
 240   _done.signal();




 241 
 242   // It is no longer safe to refer to 'this' as the VMThread may have destroyed this operation
 243 }
 244 
 245 void Handshake::execute(HandshakeClosure* thread_cl) {
 246   HandshakeThreadsOperation cto(thread_cl);
 247   VM_HandshakeAllThreads handshake(&cto);
 248   VMThread::execute(&handshake);
 249 }
 250 
 251 bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
 252   HandshakeThreadsOperation cto(thread_cl);
 253   VM_HandshakeOneThread handshake(&cto, target);
 254   VMThread::execute(&handshake);
 255   return handshake.executed();
 256 }
 257 
 258 HandshakeState::HandshakeState() : _operation(NULL), _semaphore(1), _thread_in_process_handshake(false) {
 259   DEBUG_ONLY(_vmthread_processing_handshake = false;)












































 260 }
 261 
 262 void HandshakeState::set_operation(JavaThread* target, HandshakeOperation* op) {


 263   _operation = op;
 264   SafepointMechanism::arm_local_poll_release(target);






 265 }
 266 
 267 void HandshakeState::clear_handshake(JavaThread* target) {

 268   _operation = NULL;
 269   SafepointMechanism::disarm_if_needed(target, true /* release */);



 270 }
 271 
 272 void HandshakeState::process_self_inner(JavaThread* thread) {
 273   assert(Thread::current() == thread, "should call from thread");
 274   assert(!thread->is_terminated(), "should not be a terminated thread");
 275   assert(thread->thread_state() != _thread_blocked, "should not be in a blocked state");
 276   assert(thread->thread_state() != _thread_in_native, "should not be in native");

 277 
 278   do {
 279     ThreadInVMForHandshake tivm(thread);
 280     if (!_semaphore.trywait()) {
 281       _semaphore.wait_with_safepoint_check(thread);









 282     }
 283     HandshakeOperation* op = Atomic::load_acquire(&_operation);
 284     if (op != NULL) {
 285       HandleMark hm(thread);
 286       CautiouslyPreserveExceptionMark pem(thread);
 287       // Disarm before execute the operation
 288       clear_handshake(thread);
 289       op->do_handshake(thread);
 290     }
 291     _semaphore.signal();

 292   } while (has_operation());
 293 }
 294 
 295 bool HandshakeState::vmthread_can_process_handshake(JavaThread* target) {
 296   // handshake_safe may only be called with polls armed.
 297   // VM thread controls this by first claiming the handshake via claim_handshake_for_vmthread.
 298   return SafepointSynchronize::handshake_safe(target);
 299 }
 300 
 301 static bool possibly_vmthread_can_process_handshake(JavaThread* target) {
 302   // Note that this method is allowed to produce false positives.
 303   if (target->is_ext_suspended()) {
 304     return true;
 305   }
 306   if (target->is_terminated()) {
 307     return true;
 308   }
 309   switch (target->thread_state()) {
 310   case _thread_in_native:
 311     // native threads are safe if they have no java stack or have walkable stack
 312     return !target->has_last_Java_frame() || target->frame_anchor()->walkable();
 313 
 314   case _thread_blocked:
 315     return true;
 316 
 317   default:
 318     return false;
 319   }
 320 }
 321 
 322 bool HandshakeState::claim_handshake_for_vmthread() {
 323   if (!_semaphore.trywait()) {
 324     return false;
 325   }
 326   if (has_operation()) {
 327     return true;
 328   }
 329   _semaphore.signal();
 330   return false;
 331 }
 332 
 333 bool HandshakeState::try_process_by_vmThread(JavaThread* target) {
 334   assert(Thread::current()->is_VM_thread(), "should call from vm thread");
 335 
 336   if (!has_operation()) {
 337     // JT has already cleared its handshake
 338     return false;
 339   }
 340 
 341   if (!possibly_vmthread_can_process_handshake(target)) {
 342     // JT is observed in an unsafe state, it must notice the handshake itself
 343     return false;
 344   }
 345 
 346   // Claim the semaphore if there still an operation to be executed.
 347   if (!claim_handshake_for_vmthread()) {








 348     return false;
 349   }
 350 
 351   // If we own the semaphore at this point and while owning the semaphore
 352   // can observe a safe state the thread cannot possibly continue without
 353   // getting caught by the semaphore.
 354   bool executed = false;
 355   if (vmthread_can_process_handshake(target)) {
 356     guarantee(!_semaphore.trywait(), "we should already own the semaphore");
 357     log_trace(handshake)("Processing handshake by VMThtread");
 358     DEBUG_ONLY(_vmthread_processing_handshake = true;)
 359     _operation->do_handshake(target);
 360     DEBUG_ONLY(_vmthread_processing_handshake = false;)
 361     // Disarm after VM thread have executed the operation.
 362     clear_handshake(target);
 363     executed = true;
 364   }
 365 
 366   // Release the thread
 367   _semaphore.signal();
 368 
 369   return executed;
 370 }
--- EOF ---