rev 57079 : imported patch 8234796

   1 /*
   2  * Copyright (c) 2017, 2019, 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/handshake.hpp"
  30 #include "runtime/interfaceSupport.inline.hpp"
  31 #include "runtime/orderAccess.hpp"
  32 #include "runtime/osThread.hpp"
  33 #include "runtime/semaphore.inline.hpp"
  34 #include "runtime/task.hpp"
  35 #include "runtime/timerTrace.hpp"
  36 #include "runtime/thread.hpp"
  37 #include "runtime/vmThread.hpp"
  38 #include "utilities/formatBuffer.hpp"
  39 #include "utilities/preserveException.hpp"
  40 
  41 Semaphore HandshakeOperation::_done(0);






















  42 
  43 class VM_Handshake: public VM_Operation {
  44   const jlong _handshake_timeout;
  45  public:
  46   bool evaluate_at_safepoint() const { return false; }
  47 
  48   bool evaluate_concurrently() const { return false; }
  49 
  50  protected:
  51   HandshakeOperation* const _op;
  52 
  53   VM_Handshake(HandshakeOperation* op) :
  54       _handshake_timeout(TimeHelper::millis_to_counter(HandshakeTimeout)), _op(op) {}
  55 
  56   void set_handshake(JavaThread* target) {
  57     target->set_handshake_operation(_op);
  58   }
  59 
  60   // This method returns true for threads completed their operation
  61   // and true for threads canceled their operation.
  62   // A cancellation can happen if the thread is exiting.
  63   bool poll_for_completed_thread() { return _op->thread_has_completed(); }
  64 
  65   bool handshake_has_timed_out(jlong start_time);
  66   static void handle_timeout();
  67 };
  68 
  69 bool VM_Handshake::handshake_has_timed_out(jlong start_time) {
  70   // Check if handshake operation has timed out
  71   if (_handshake_timeout > 0) {
  72     return os::elapsed_counter() >= (start_time + _handshake_timeout);
  73   }
  74   return false;
  75 }
  76 
  77 void VM_Handshake::handle_timeout() {
  78   LogStreamHandle(Warning, handshake) log_stream;
  79   for (JavaThreadIteratorWithHandle jtiwh; JavaThread *thr = jtiwh.next(); ) {
  80     if (thr->has_handshake()) {
  81       log_stream.print("Thread " PTR_FORMAT " has not cleared its handshake op", p2i(thr));
  82       thr->print_thread_state_on(&log_stream);
  83     }
  84   }
  85   log_stream.flush();
  86   fatal("Handshake operation timed out");
  87 }
  88 
  89 class VM_HandshakeOneThread: public VM_Handshake {
  90   JavaThread* _target;
  91  public:
  92   VM_HandshakeOneThread(HandshakeOperation* op, JavaThread* target) :
  93     VM_Handshake(op), _target(target) {}
  94 
  95   void doit() {
  96     DEBUG_ONLY(_op->check_state();)
  97     TraceTime timer("Finished executing single-target operation (VM_HandshakeOneThread::doit)", TRACETIME_LOG(Info, handshake));
  98 
  99     ThreadsListHandle tlh;
 100     if (tlh.includes(_target)) {
 101       set_handshake(_target);
 102     } else {
 103       log_trace(handshake)("JavaThread " INTPTR_FORMAT " is not alive", p2i(_target));
 104       return;
 105     }
 106 
 107     log_trace(handshake)("JavaThread " INTPTR_FORMAT " signaled, begin attempt to process by VMThtread", p2i(_target));
 108     jlong start_time = os::elapsed_counter();
 109     do {
 110       if (handshake_has_timed_out(start_time)) {
 111         handle_timeout();
 112       }
 113 
 114       // We need to re-think this with SMR ThreadsList.
 115       // There is an assumption in the code that the Threads_lock should be
 116       // locked during certain phases.
 117       {
 118         MutexLocker ml(Threads_lock);
 119         _target->handshake_process_by_vmthread();
 120       }
 121     } while (!poll_for_completed_thread());
 122     DEBUG_ONLY(_op->check_state();)
 123   }
 124 
 125   VMOp_Type type() const { return VMOp_HandshakeOneThread; }
 126 
 127   bool executed() const { return _op->executed(); }
 128 };
 129 
 130 class VM_HandshakeAllThreads: public VM_Handshake {
 131  public:
 132   VM_HandshakeAllThreads(HandshakeOperation* op) : VM_Handshake(op) {}
 133 
 134   void doit() {
 135     DEBUG_ONLY(_op->check_state();)
 136     TraceTime timer("Finished executing multi-target operation (VM_HandshakeAllThreads::doit)", TRACETIME_LOG(Info, handshake));
 137 
 138     JavaThreadIteratorWithHandle jtiwh;
 139     int number_of_threads_issued = 0;
 140     for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 141       set_handshake(thr);
 142       number_of_threads_issued++;
 143     }
 144 
 145     if (number_of_threads_issued < 1) {
 146       log_debug(handshake)("No threads to handshake.");
 147       return;
 148     }
 149 
 150     log_debug(handshake)("Threads signaled, begin processing blocked threads by VMThtread");
 151     const jlong start_time = os::elapsed_counter();
 152     int number_of_threads_completed = 0;
 153     do {
 154       // Check if handshake operation has timed out
 155       if (handshake_has_timed_out(start_time)) {
 156         handle_timeout();
 157       }
 158 
 159       // Have VM thread perform the handshake operation for blocked threads.
 160       // Observing a blocked state may of course be transient but the processing is guarded
 161       // by semaphores and we optimistically begin by working on the blocked threads
 162       {
 163           // We need to re-think this with SMR ThreadsList.
 164           // There is an assumption in the code that the Threads_lock should
 165           // be locked during certain phases.
 166           jtiwh.rewind();
 167           MutexLocker ml(Threads_lock);
 168           for (JavaThread *thr = jtiwh.next(); thr != NULL; thr = jtiwh.next()) {
 169             // A new thread on the ThreadsList will not have an operation,
 170             // hence it is skipped in handshake_process_by_vmthread.
 171             thr->handshake_process_by_vmthread();
 172           }
 173       }
 174 
 175       while (poll_for_completed_thread()) {
 176         // Includes canceled operations by exiting threads.
 177         number_of_threads_completed++;
 178       }
 179 
 180     } while (number_of_threads_issued > number_of_threads_completed);
 181     assert(number_of_threads_issued == number_of_threads_completed, "Must be the same");
 182     DEBUG_ONLY(_op->check_state();)
 183   }
 184 
 185   VMOp_Type type() const { return VMOp_HandshakeAllThreads; }
 186 };
 187 
 188 class VM_HandshakeFallbackOperation : public VM_Operation {
 189   HandshakeOperation* _hs_op;
 190   Thread* _target_thread;
 191   bool _all_threads;
 192   bool _executed;
 193 public:
 194   VM_HandshakeFallbackOperation(HandshakeOperation* hs_op) :
 195       _hs_op(hs_op), _target_thread(NULL), _all_threads(true), _executed(false) {}
 196   VM_HandshakeFallbackOperation(HandshakeOperation* hs_op, Thread* target) :
 197       _hs_op(hs_op), _target_thread(target), _all_threads(false), _executed(false) {}
 198 
 199   void doit() {
 200     log_trace(handshake)("VMThread executing VM_HandshakeFallbackOperation");
 201     for (JavaThreadIteratorWithHandle jtiwh; JavaThread *t = jtiwh.next(); ) {
 202       if (_all_threads || t == _target_thread) {
 203         if (t == _target_thread) {
 204           _executed = true;
 205         }
 206         _hs_op->do_thread(t);
 207       }
 208     }
 209   }
 210 
 211   VMOp_Type type() const { return VMOp_HandshakeFallback; }
 212   bool executed() const { return _executed; }
 213 };
 214 
 215 void HandshakeOperation::do_handshake(JavaThread* thread) {
 216   ResourceMark rm;
 217   FormatBufferResource message("Operation for thread " PTR_FORMAT ", is_vm_thread: %s",
 218                                p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()));
 219   TraceTime timer(message, TRACETIME_LOG(Debug, handshake, task));
 220 
 221   // Only actually execute the operation for non terminated threads.
 222   if (!thread->is_terminated()) {
 223     do_thread(thread);
 224     _executed = true;
 225   }
 226 
 227   // Use the semaphore to inform the VM thread that we have completed the operation
 228   _done.signal();
 229 }
 230 
 231 void Handshake::execute(HandshakeOperation* hs_op) {
 232   if (ThreadLocalHandshakes) {
 233     VM_HandshakeAllThreads handshake(hs_op);

 234     VMThread::execute(&handshake);
 235   } else {
 236     VM_HandshakeFallbackOperation op(hs_op);
 237     VMThread::execute(&op);
 238   }
 239 }
 240 
 241 bool Handshake::execute(HandshakeOperation* hs_op, JavaThread* target) {
 242   if (ThreadLocalHandshakes) {
 243     VM_HandshakeOneThread handshake(hs_op, target);

 244     VMThread::execute(&handshake);
 245     return handshake.executed();
 246   } else {
 247     VM_HandshakeFallbackOperation op(hs_op, target);
 248     VMThread::execute(&op);
 249     return op.executed();
 250   }
 251 }
 252 
 253 HandshakeState::HandshakeState() : _operation(NULL), _semaphore(1), _thread_in_process_handshake(false) {}
 254 
 255 void HandshakeState::set_operation(JavaThread* target, HandshakeOperation* op) {
 256   _operation = op;
 257   SafepointMechanism::arm_local_poll_release(target);
 258 }
 259 
 260 void HandshakeState::clear_handshake(JavaThread* target) {
 261   _operation = NULL;
 262   SafepointMechanism::disarm_if_needed(target, true /* release */);
 263 }
 264 
 265 void HandshakeState::process_self_inner(JavaThread* thread) {
 266   assert(Thread::current() == thread, "should call from thread");
 267   assert(!thread->is_terminated(), "should not be a terminated thread");
 268 
 269   ThreadInVMForHandshake tivm(thread);
 270   if (!_semaphore.trywait()) {
 271     _semaphore.wait_with_safepoint_check(thread);
 272   }
 273   HandshakeOperation* op = OrderAccess::load_acquire(&_operation);
 274   if (op != NULL) {
 275     HandleMark hm(thread);
 276     CautiouslyPreserveExceptionMark pem(thread);
 277     // Disarm before execute the operation
 278     clear_handshake(thread);
 279     op->do_handshake(thread);
 280   }
 281   _semaphore.signal();
 282 }
 283 
 284 bool HandshakeState::vmthread_can_process_handshake(JavaThread* target) {
 285   // handshake_safe may only be called with polls armed.
 286   // VM thread controls this by first claiming the handshake via claim_handshake_for_vmthread.
 287   return SafepointSynchronize::handshake_safe(target);
 288 }
 289 
 290 static bool possibly_vmthread_can_process_handshake(JavaThread* target) {
 291   // An externally suspended thread cannot be resumed while the
 292   // Threads_lock is held so it is safe.
 293   // Note that this method is allowed to produce false positives.
 294   assert(Threads_lock->owned_by_self(), "Not holding Threads_lock.");
 295   if (target->is_ext_suspended()) {
 296     return true;
 297   }
 298   if (target->is_terminated()) {
 299     return true;
 300   }
 301   switch (target->thread_state()) {
 302   case _thread_in_native:
 303     // native threads are safe if they have no java stack or have walkable stack
 304     return !target->has_last_Java_frame() || target->frame_anchor()->walkable();
 305 
 306   case _thread_blocked:
 307     return true;
 308 
 309   default:
 310     return false;
 311   }
 312 }
 313 
 314 bool HandshakeState::claim_handshake_for_vmthread() {
 315   if (!_semaphore.trywait()) {
 316     return false;
 317   }
 318   if (has_operation()) {
 319     return true;
 320   }
 321   _semaphore.signal();
 322   return false;
 323 }
 324 
 325 void HandshakeState::process_by_vmthread(JavaThread* target) {
 326   assert(Thread::current()->is_VM_thread(), "should call from vm thread");
 327   // Threads_lock must be held here, but that is assert()ed in
 328   // possibly_vmthread_can_process_handshake().
 329 
 330   if (!has_operation()) {
 331     // JT has already cleared its handshake
 332     return;
 333   }
 334 
 335   if (!possibly_vmthread_can_process_handshake(target)) {
 336     // JT is observed in an unsafe state, it must notice the handshake itself
 337     return;
 338   }
 339 
 340   // Claim the semaphore if there still an operation to be executed.
 341   if (!claim_handshake_for_vmthread()) {
 342     return;
 343   }
 344 
 345   // If we own the semaphore at this point and while owning the semaphore
 346   // can observe a safe state the thread cannot possibly continue without
 347   // getting caught by the semaphore.
 348   if (vmthread_can_process_handshake(target)) {
 349     guarantee(!_semaphore.trywait(), "we should already own the semaphore");
 350     log_trace(handshake)("Processing handshake by VMThtread");
 351     _operation->do_handshake(target);
 352     // Disarm after VM thread have executed the operation.
 353     clear_handshake(target);
 354     // Release the thread
 355   }
 356 
 357   _semaphore.signal();
 358 }
--- EOF ---