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 
  41 class HandshakeOperation: public StackObj {
  42   HandshakeClosure* _handshake_cl;
  43   int32_t _pending_threads;
  44   bool _executed;
  45   bool _is_direct;
  46 public:
  47   HandshakeOperation(HandshakeClosure* cl, bool is_direct = false) :
  48     _handshake_cl(cl),
  49     _pending_threads(1),
  50     _executed(false),
  51     _is_direct(is_direct) {}
  52 
  53   void do_handshake(JavaThread* thread);
  54   bool is_completed() {
  55     int64_t val = Atomic::load(&_pending_threads);
  56     assert(val >= 0, "_pending_threads cannot be negative");
  57     return val == 0;
  58   }
  59   void add_target_count(int count) { Atomic::add(&_pending_threads, count); }
  60   bool executed() const { return _executed; }
  61   const char* name() { return _handshake_cl->name(); }
  62 
  63   bool is_direct() { return _is_direct; }
  64 
  65 #ifdef ASSERT
  66   void check_state() {
  67     assert(_pending_threads == 0, "Must be zero");
  68   }
  69 #endif
  70 };
  71 
  72 class VM_Handshake: public VM_Operation {
  73   const jlong _handshake_timeout;
  74  public:
  75   bool evaluate_at_safepoint() const { return false; }
  76 
  77  protected:
  78   HandshakeOperation* const _op;
  79 
  80   VM_Handshake(HandshakeOperation* op) :
  81       _handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
  82 
  83   bool handshake_has_timed_out(jlong start_time);
  84   static void handle_timeout();
  85 };
  86 
  87 bool VM_Handshake::handshake_has_timed_out(jlong start_time) {
  88   // Check if handshake operation has timed out
  89   if (_handshake_timeout > 0) {
  90     return os::elapsed_counter() >= (start_time + _handshake_timeout);
  91   }
  92   return false;
  93 }
  94 
  95 void VM_Handshake::handle_timeout() {
  96   LogStreamHandle(Warning, handshake) log_stream;
  97   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
  98     if (thr->has_handshake()) {
  99       log_stream.print("Thread " PTR_FORMAT " has not cleared its handshake op", p2i(thr));
 100       thr->print_thread_state_on(&log_stream);
 101     }
 102   }
 103   log_stream.flush();
 104   fatal("Handshake operation timed out");
 105 }
 106 
 107 static void log_handshake_info(jlong start_time_ns, const char* name, int targets, int vmt_executed, const char* extra = NULL) {
 108   if (start_time_ns != 0) {
 109     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 110     log_info(handshake)("Handshake \"%s\", Targeted threads: %d, Executed by targeted threads: %d, Total completion time: " JLONG_FORMAT " ns%s%s",
 111                         name, targets,
 112                         targets - vmt_executed,
 113                         completion_time,
 114                         extra != NULL ? ", " : "",
 115                         extra != NULL ? extra : "");
 116   }
 117 }
 118 
 119 class VM_HandshakeOneThread: public VM_Handshake {
 120   JavaThread* _target;
 121  public:
 122   VM_HandshakeOneThread(HandshakeOperation* op, JavaThread* target) :
 123     VM_Handshake(op), _target(target) {}
 124 
 125   void doit() {
 126     jlong start_time_ns = 0;
 127     if (log_is_enabled(Info, handshake)) {
 128       start_time_ns = os::javaTimeNanos();
 129     }
 130 
 131     ThreadsListHandle tlh;
 132     if (tlh.includes(_target)) {
 133       _target->set_handshake_operation(_op);
 134     } else {
 135       log_handshake_info(start_time_ns, _op->name(), 0, 0, "(thread dead)");
 136       return;
 137     }
 138 
 139     log_trace(handshake)("JavaThread " INTPTR_FORMAT " signaled, begin attempt to process by VMThtread", p2i(_target));
 140     jlong timeout_start_time = os::elapsed_counter();
 141     bool by_vm_thread = false;
 142     do {
 143       if (handshake_has_timed_out(timeout_start_time)) {
 144         handle_timeout();
 145       }
 146       by_vm_thread = _target->handshake_try_process(_op);
 147     } while (!_op->is_completed());
 148     DEBUG_ONLY(_op->check_state();)
 149     log_handshake_info(start_time_ns, _op->name(), 1, by_vm_thread ? 1 : 0);
 150   }
 151 
 152   VMOp_Type type() const { return VMOp_HandshakeOneThread; }
 153 
 154   bool executed() const { return _op->executed(); }
 155 };
 156 
 157 class VM_HandshakeAllThreads: public VM_Handshake {
 158  public:
 159   VM_HandshakeAllThreads(HandshakeOperation* op) : VM_Handshake(op) {}
 160 
 161   void doit() {
 162     jlong start_time_ns = 0;
 163     if (log_is_enabled(Info, handshake)) {
 164       start_time_ns = os::javaTimeNanos();
 165     }
 166     int handshake_executed_by_vm_thread = 0;
 167 
 168     JavaThreadIteratorWithHandle jtiwh;
 169     int number_of_threads_issued = 0;
 170     for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 171       thr->set_handshake_operation(_op);
 172       number_of_threads_issued++;
 173     }
 174 
 175     if (number_of_threads_issued < 1) {
 176       log_handshake_info(start_time_ns, _op->name(), 0, 0);
 177       return;
 178     }
 179     // _op was created with a count == 1 so don't double count.
 180     _op->add_target_count(number_of_threads_issued - 1);
 181 
 182     log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread");
 183     const jlong start_time = os::elapsed_counter();
 184     do {
 185       // Check if handshake operation has timed out
 186       if (handshake_has_timed_out(start_time)) {
 187         handle_timeout();
 188       }
 189 
 190       // Have VM thread perform the handshake operation for blocked threads.
 191       // Observing a blocked state may of course be transient but the processing is guarded
 192       // by semaphores and we optimistically begin by working on the blocked threads
 193       jtiwh.rewind();
 194       for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 195         // A new thread on the ThreadsList will not have an operation,
 196         // hence it is skipped in handshake_try_process.
 197         if (thr->handshake_try_process(_op)) {
 198           handshake_executed_by_vm_thread++;
 199         }
 200       }
 201     } while (!_op->is_completed());
 202     DEBUG_ONLY(_op->check_state();)
 203 
 204     log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, handshake_executed_by_vm_thread);
 205   }
 206 
 207   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 208 };
 209 
 210 class VM_HandshakeFallbackOperation : public VM_Operation {
 211   HandshakeClosure* _handshake_cl;
 212   Thread* _target_thread;
 213   bool _all_threads;
 214   bool _executed;
 215 public:
 216   VM_HandshakeFallbackOperation(HandshakeClosure* cl) :
 217       _handshake_cl(cl), _target_thread(NULL), _all_threads(true), _executed(false) {}
 218   VM_HandshakeFallbackOperation(HandshakeClosure* cl, Thread* target) :
 219       _handshake_cl(cl), _target_thread(target), _all_threads(false), _executed(false) {}
 220 
 221   void doit() {
 222     log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation, operation: %s", name());
 223     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 224       if (_all_threads || t == _target_thread) {
 225         if (t == _target_thread) {
 226           _executed = true;
 227         }
 228         _handshake_cl->do_thread(t);
 229       }
 230     }
 231   }
 232 
 233   VMOp_Type type() const { return VMOp_HandshakeFallback; }
 234   bool executed() const { return _executed; }
 235 };
 236 
 237 void HandshakeOperation::do_handshake(JavaThread* thread) {
 238   jlong start_time_ns = 0;
 239   if (log_is_enabled(Debug, handshake, task)) {
 240     start_time_ns = os::javaTimeNanos();
 241   }
 242 
 243   // Only actually execute the operation for non terminated threads.
 244   if (!thread->is_terminated()) {
 245     _handshake_cl->do_thread(thread);
 246     _executed = true;
 247   }
 248 
 249   if (start_time_ns != 0) {
 250     jlong completion_time = os::javaTimeNanos() - start_time_ns;
 251     log_debug(handshake, task)("Operation: %s for thread " PTR_FORMAT ", is_vm_thread: %s, completed in " JLONG_FORMAT " ns",
 252                                name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time);
 253   }
 254 
 255   // Inform VMThread/Handshaker that we have completed the operation
 256   Atomic::dec(&_pending_threads);
 257 
 258   // It is no longer safe to refer to 'this' as the VMThread/Handshaker may have destroyed this operation
 259 }
 260 
 261 void Handshake::execute(HandshakeClosure* thread_cl) {
 262   if (SafepointMechanism::uses_thread_local_poll()) {
 263     HandshakeOperation ho(thread_cl);
 264     VM_HandshakeAllThreads handshake(&ho);
 265     VMThread::execute(&handshake);
 266   } else {
 267     VM_HandshakeFallbackOperation op(thread_cl);
 268     VMThread::execute(&op);
 269   }
 270 }
 271 
 272 bool Handshake::execute(HandshakeClosure* thread_cl, JavaThread* target) {
 273   if (SafepointMechanism::uses_thread_local_poll()) {
 274     HandshakeOperation ho(thread_cl);
 275     VM_HandshakeOneThread handshake(&ho, target);
 276     VMThread::execute(&handshake);
 277     return handshake.executed();
 278   } else {
 279     VM_HandshakeFallbackOperation op(thread_cl, target);
 280     VMThread::execute(&op);
 281     return op.executed();
 282   }
 283 }
 284 
 285 bool Handshake::execute_direct(HandshakeClosure* thread_cl, JavaThread* target) {
 286   if (!SafepointMechanism::uses_thread_local_poll()) {
 287     VM_HandshakeFallbackOperation op(thread_cl, target);
 288     VMThread::execute(&op);
 289     return op.executed();
 290   }
 291   JavaThread* self = JavaThread::current();
 292   HandshakeOperation op(thread_cl, /*is_direct*/ true);
 293 
 294   jlong start_time_ns = 0;
 295   if (log_is_enabled(Info, handshake)) {
 296     start_time_ns = os::javaTimeNanos();
 297   }
 298 
 299   ThreadsListHandle tlh;
 300   if (tlh.includes(target)) {
 301     target->set_handshake_operation(&op);
 302   } else {
 303     log_handshake_info(start_time_ns, op.name(), 0, 0, "(thread dead)");
 304     return false;
 305   }
 306 
 307   bool by_handshaker = false;
 308   while (!op.is_completed()) {
 309     by_handshaker = target->handshake_try_process(&op);
 310     // Check for pending handshakes to avoid possible deadlocks where our
 311     // target is trying to handshake us.
 312     if (SafepointMechanism::should_block(self)) {
 313       ThreadBlockInVM tbivm(self);
 314     }
 315   }
 316   DEBUG_ONLY(op.check_state();)
 317   log_handshake_info(start_time_ns, op.name(), 1, by_handshaker ? 1 : 0);
 318 
 319   return op.executed();
 320 }
 321 
 322 HandshakeState::HandshakeState() :
 323   _operation(NULL),
 324   _operation_direct(NULL),
 325   _handshake_turn_sem(1),
 326   _processing_sem(1),
 327   _thread_in_process_handshake(false)
 328 {
 329   DEBUG_ONLY(_active_handshaker = NULL;)
 330 }
 331 
 332 void HandshakeState::set_operation(HandshakeOperation* op) {
 333   if (!op->is_direct()) {
 334     assert(Thread::current()->is_VM_thread(), "should be the VMThread");
 335     _operation = op;
 336   } else {
 337     assert(Thread::current()->is_Java_thread(), "should be a JavaThread");
 338     // Serialize direct handshakes so that only one proceeds at a time for a given target
 339     _handshake_turn_sem.wait_with_safepoint_check(JavaThread::current());
 340     _operation_direct = op;
 341   }
 342   SafepointMechanism::arm_local_poll_release(_handshakee);
 343 }
 344 
 345 void HandshakeState::clear_handshake(bool is_direct) {
 346   if (!is_direct) {
 347     _operation = NULL;
 348   } else {
 349     _operation_direct = NULL;
 350     _handshake_turn_sem.signal();
 351   }
 352 }
 353 
 354 void HandshakeState::process_self_inner() {
 355   assert(Thread::current() == _handshakee, "should call from _handshakee");
 356   assert(!_handshakee->is_terminated(), "should not be a terminated thread");
 357   assert(_handshakee->thread_state() != _thread_blocked, "should not be in a blocked state");
 358   assert(_handshakee->thread_state() != _thread_in_native, "should not be in native");
 359   JavaThread* self = _handshakee;
 360 
 361   do {
 362     ThreadInVMForHandshake tivm(self);
 363     if (!_processing_sem.trywait()) {
 364       _processing_sem.wait_with_safepoint_check(self);
 365     }
 366     if (has_operation()) {
 367       HandleMark hm(self);
 368       CautiouslyPreserveExceptionMark pem(self);
 369       HandshakeOperation * op = _operation;
 370       if (op != NULL) {
 371         // Disarm before executing the operation
 372         clear_handshake(/*is_direct*/ false);
 373         op->do_handshake(self);
 374       }
 375       op = _operation_direct;
 376       if (op != NULL) {
 377         // Disarm before executing the operation
 378         clear_handshake(/*is_direct*/ true);
 379         op->do_handshake(self);
 380       }
 381     }
 382     _processing_sem.signal();
 383   } while (has_operation());
 384 }
 385 
 386 bool HandshakeState::can_process_handshake() {
 387   // handshake_safe may only be called with polls armed.
 388   // Handshaker controls this by first claiming the handshake via claim_handshake().
 389   return SafepointSynchronize::handshake_safe(_handshakee);
 390 }
 391 
 392 bool HandshakeState::possibly_can_process_handshake() {
 393   // Note that this method is allowed to produce false positives.
 394   if (_handshakee->is_ext_suspended()) {
 395     return true;
 396   }
 397   if (_handshakee->is_terminated()) {
 398     return true;
 399   }
 400   switch (_handshakee->thread_state()) {
 401   case _thread_in_native:
 402     // native threads are safe if they have no java stack or have walkable stack
 403     return !_handshakee->has_last_Java_frame() || _handshakee->frame_anchor()->walkable();
 404 
 405   case _thread_blocked:
 406     return true;
 407 
 408   default:
 409     return false;
 410   }
 411 }
 412 
 413 bool HandshakeState::claim_handshake(bool is_direct) {
 414   if (!_processing_sem.trywait()) {
 415     return false;
 416   }
 417   if (has_specific_operation(is_direct)){
 418     return true;
 419   }
 420   _processing_sem.signal();
 421   return false;
 422 }
 423 
 424 bool HandshakeState::try_process(HandshakeOperation* op) {
 425   bool is_direct = op->is_direct();
 426 
 427   if (!has_specific_operation(is_direct)){
 428     // JT has already cleared its handshake
 429     return false;
 430   }
 431 
 432   if (!possibly_can_process_handshake()) {
 433     // JT is observed in an unsafe state, it must notice the handshake itself
 434     return false;
 435   }
 436 
 437   // Claim the semaphore if there still an operation to be executed.
 438   if (!claim_handshake(is_direct)) {
 439     return false;
 440   }
 441 
 442   // Check if the handshake operation is the same as the one we meant to execute. The
 443   // handshake could have been already processed by the handshakee and a new handshake
 444   // by another JavaThread might be in progress.
 445   if ( (is_direct && op != _operation_direct)) {
 446     _processing_sem.signal();
 447     return false;
 448   }
 449 
 450   // If we own the semaphore at this point and while owning the semaphore
 451   // can observe a safe state the thread cannot possibly continue without
 452   // getting caught by the semaphore.
 453   bool executed = false;
 454   if (can_process_handshake()) {
 455     guarantee(!_processing_sem.trywait(), "we should already own the semaphore");
 456     log_trace(handshake)("Processing handshake by %s", Thread::current()->is_VM_thread() ? "VMThread" : "Handshaker");
 457     DEBUG_ONLY(_active_handshaker = Thread::current();)
 458     op->do_handshake(_handshakee);
 459     DEBUG_ONLY(_active_handshaker = NULL;)
 460     // Disarm after we have executed the operation.
 461     clear_handshake(is_direct);
 462     executed = true;
 463   }
 464 
 465   // Release the thread
 466   _processing_sem.signal();
 467 
 468   return executed;
 469 }