1 /* 2 * Copyright (c) 2017, 2023, 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 "classfile/javaClasses.hpp" 27 #include "classfile/vmSymbols.hpp" 28 #include "jvm_io.h" 29 #include "logging/log.hpp" 30 #include "logging/logStream.hpp" 31 #include "memory/resourceArea.hpp" 32 #include "runtime/atomic.hpp" 33 #include "runtime/globals.hpp" 34 #include "runtime/handshake.hpp" 35 #include "runtime/interfaceSupport.inline.hpp" 36 #include "runtime/javaThread.inline.hpp" 37 #include "runtime/os.hpp" 38 #include "runtime/osThread.hpp" 39 #include "runtime/stackWatermarkSet.hpp" 40 #include "runtime/task.hpp" 41 #include "runtime/threadSMR.hpp" 42 #include "runtime/vmThread.hpp" 43 #include "utilities/formatBuffer.hpp" 44 #include "utilities/filterQueue.inline.hpp" 45 #include "utilities/globalDefinitions.hpp" 46 #include "utilities/preserveException.hpp" 47 #include "utilities/systemMemoryBarrier.hpp" 48 49 class HandshakeOperation : public CHeapObj<mtThread> { 50 friend class HandshakeState; 51 protected: 52 HandshakeClosure* _handshake_cl; 53 // Keeps track of emitted and completed handshake operations. 54 // Once it reaches zero all handshake operations have been performed. 55 int32_t _pending_threads; 56 JavaThread* _target; 57 Thread* _requester; 58 59 // Must use AsyncHandshakeOperation when using AsyncHandshakeClosure. 60 HandshakeOperation(AsyncHandshakeClosure* cl, JavaThread* target, Thread* requester) : 61 _handshake_cl(cl), 62 _pending_threads(1), 63 _target(target), 64 _requester(requester) {} 65 66 public: 67 HandshakeOperation(HandshakeClosure* cl, JavaThread* target, Thread* requester) : 68 _handshake_cl(cl), 69 _pending_threads(1), 70 _target(target), 71 _requester(requester) {} 72 virtual ~HandshakeOperation() {} 73 void prepare(JavaThread* current_target, Thread* executing_thread); 74 void do_handshake(JavaThread* thread); 75 bool is_completed() { 76 int32_t val = Atomic::load(&_pending_threads); 77 assert(val >= 0, "_pending_threads=%d cannot be negative", val); 78 return val == 0; 79 } 80 void add_target_count(int count) { Atomic::add(&_pending_threads, count); } 81 int32_t pending_threads() { return Atomic::load(&_pending_threads); } 82 const char* name() { return _handshake_cl->name(); } 83 bool is_async() { return _handshake_cl->is_async(); } 84 bool is_suspend() { return _handshake_cl->is_suspend(); } 85 bool is_async_exception() { return _handshake_cl->is_async_exception(); } 86 }; 87 88 class AsyncHandshakeOperation : public HandshakeOperation { 89 private: 90 jlong _start_time_ns; 91 public: 92 AsyncHandshakeOperation(AsyncHandshakeClosure* cl, JavaThread* target, jlong start_ns) 93 : HandshakeOperation(cl, target, nullptr), _start_time_ns(start_ns) {} 94 virtual ~AsyncHandshakeOperation() { delete _handshake_cl; } 95 jlong start_time() const { return _start_time_ns; } 96 }; 97 98 // Performing handshakes requires a custom yielding strategy because without it 99 // there is a clear performance regression vs plain spinning. We keep track of 100 // when we last saw progress by looking at why each targeted thread has not yet 101 // completed its handshake. After spinning for a while with no progress we will 102 // yield, but as long as there is progress, we keep spinning. Thus we avoid 103 // yielding when there is potential work to be done or the handshake is close 104 // to being finished. 105 class HandshakeSpinYield : public StackObj { 106 private: 107 jlong _start_time_ns; 108 jlong _last_spin_start_ns; 109 jlong _spin_time_ns; 110 111 int _result_count[2][HandshakeState::_number_states]; 112 int _prev_result_pos; 113 114 int current_result_pos() { return (_prev_result_pos + 1) & 0x1; } 115 116 void wait_raw(jlong now) { 117 // We start with fine-grained nanosleeping until a millisecond has 118 // passed, at which point we resort to plain naked_short_sleep. 119 if (now - _start_time_ns < NANOSECS_PER_MILLISEC) { 120 os::naked_short_nanosleep(10 * (NANOUNITS / MICROUNITS)); 121 } else { 122 os::naked_short_sleep(1); 123 } 124 } 125 126 void wait_blocked(JavaThread* self, jlong now) { 127 ThreadBlockInVM tbivm(self); 128 wait_raw(now); 129 } 130 131 bool state_changed() { 132 for (int i = 0; i < HandshakeState::_number_states; i++) { 133 if (_result_count[0][i] != _result_count[1][i]) { 134 return true; 135 } 136 } 137 return false; 138 } 139 140 void reset_state() { 141 _prev_result_pos++; 142 for (int i = 0; i < HandshakeState::_number_states; i++) { 143 _result_count[current_result_pos()][i] = 0; 144 } 145 } 146 147 public: 148 HandshakeSpinYield(jlong start_time) : 149 _start_time_ns(start_time), _last_spin_start_ns(start_time), 150 _spin_time_ns(0), _result_count(), _prev_result_pos(0) { 151 152 const jlong max_spin_time_ns = 100 /* us */ * (NANOUNITS / MICROUNITS); 153 int free_cpus = os::active_processor_count() - 1; 154 _spin_time_ns = (5 /* us */ * (NANOUNITS / MICROUNITS)) * free_cpus; // zero on UP 155 _spin_time_ns = _spin_time_ns > max_spin_time_ns ? max_spin_time_ns : _spin_time_ns; 156 } 157 158 void add_result(HandshakeState::ProcessResult pr) { 159 _result_count[current_result_pos()][pr]++; 160 } 161 162 void process() { 163 jlong now = os::javaTimeNanos(); 164 if (state_changed()) { 165 reset_state(); 166 // We spin for x amount of time since last state change. 167 _last_spin_start_ns = now; 168 return; 169 } 170 jlong wait_target = _last_spin_start_ns + _spin_time_ns; 171 if (wait_target < now) { 172 // On UP this is always true. 173 Thread* self = Thread::current(); 174 if (self->is_Java_thread()) { 175 wait_blocked(JavaThread::cast(self), now); 176 } else { 177 wait_raw(now); 178 } 179 _last_spin_start_ns = os::javaTimeNanos(); 180 } 181 reset_state(); 182 } 183 }; 184 185 static void handle_timeout(HandshakeOperation* op, JavaThread* target) { 186 JavaThreadIteratorWithHandle jtiwh; 187 188 log_error(handshake)("Handshake timeout: %s(" INTPTR_FORMAT "), pending threads: " INT32_FORMAT, 189 op->name(), p2i(op), op->pending_threads()); 190 191 if (target == nullptr) { 192 for ( ; JavaThread* thr = jtiwh.next(); ) { 193 if (thr->handshake_state()->operation_pending(op)) { 194 log_error(handshake)("JavaThread " INTPTR_FORMAT " has not cleared handshake op: " INTPTR_FORMAT, p2i(thr), p2i(op)); 195 // Remember the last one found for more diagnostics below. 196 target = thr; 197 } 198 } 199 } else { 200 log_error(handshake)("JavaThread " INTPTR_FORMAT " has not cleared handshake op: " INTPTR_FORMAT, p2i(target), p2i(op)); 201 } 202 203 if (target != nullptr) { 204 if (os::signal_thread(target, SIGILL, "cannot be handshaked")) { 205 // Give target a chance to report the error and terminate the VM. 206 os::naked_sleep(3000); 207 } 208 } else { 209 log_error(handshake)("No thread with an unfinished handshake op(" INTPTR_FORMAT ") found.", p2i(op)); 210 } 211 fatal("Handshake timeout"); 212 } 213 214 static void check_handshake_timeout(jlong start_time, HandshakeOperation* op, JavaThread* target = nullptr) { 215 // Check if handshake operation has timed out 216 jlong timeout_ns = millis_to_nanos(HandshakeTimeout); 217 if (timeout_ns > 0) { 218 if (os::javaTimeNanos() >= (start_time + timeout_ns)) { 219 handle_timeout(op, target); 220 } 221 } 222 } 223 224 static void log_handshake_info(jlong start_time_ns, const char* name, int targets, int emitted_handshakes_executed, const char* extra = nullptr) { 225 if (log_is_enabled(Info, handshake)) { 226 jlong completion_time = os::javaTimeNanos() - start_time_ns; 227 log_info(handshake)("Handshake \"%s\", Targeted threads: %d, Executed by requesting thread: %d, Total completion time: " JLONG_FORMAT " ns%s%s", 228 name, targets, 229 emitted_handshakes_executed, 230 completion_time, 231 extra != nullptr ? ", " : "", 232 extra != nullptr ? extra : ""); 233 } 234 } 235 236 class VM_HandshakeAllThreads: public VM_Operation { 237 HandshakeOperation* const _op; 238 public: 239 VM_HandshakeAllThreads(HandshakeOperation* op) : _op(op) {} 240 241 const char* cause() const { return _op->name(); } 242 243 bool evaluate_at_safepoint() const { return false; } 244 245 void doit() { 246 jlong start_time_ns = os::javaTimeNanos(); 247 248 JavaThreadIteratorWithHandle jtiwh; 249 int number_of_threads_issued = 0; 250 for (JavaThread* thr = jtiwh.next(); thr != nullptr; thr = jtiwh.next()) { 251 thr->handshake_state()->add_operation(_op); 252 number_of_threads_issued++; 253 } 254 if (UseSystemMemoryBarrier) { 255 SystemMemoryBarrier::emit(); 256 } 257 258 if (number_of_threads_issued < 1) { 259 log_handshake_info(start_time_ns, _op->name(), 0, 0, "no threads alive"); 260 return; 261 } 262 // _op was created with a count == 1 so don't double count. 263 _op->add_target_count(number_of_threads_issued - 1); 264 265 log_trace(handshake)("Threads signaled, begin processing blocked threads by VMThread"); 266 HandshakeSpinYield hsy(start_time_ns); 267 // Keeps count on how many of own emitted handshakes 268 // this thread execute. 269 int emitted_handshakes_executed = 0; 270 do { 271 // Check if handshake operation has timed out 272 check_handshake_timeout(start_time_ns, _op); 273 274 // Have VM thread perform the handshake operation for blocked threads. 275 // Observing a blocked state may of course be transient but the processing is guarded 276 // by mutexes and we optimistically begin by working on the blocked threads 277 jtiwh.rewind(); 278 for (JavaThread* thr = jtiwh.next(); thr != nullptr; thr = jtiwh.next()) { 279 // A new thread on the ThreadsList will not have an operation, 280 // hence it is skipped in handshake_try_process. 281 HandshakeState::ProcessResult pr = thr->handshake_state()->try_process(_op); 282 hsy.add_result(pr); 283 if (pr == HandshakeState::_succeeded) { 284 emitted_handshakes_executed++; 285 } 286 } 287 hsy.process(); 288 } while (!_op->is_completed()); 289 290 // This pairs up with the release store in do_handshake(). It prevents future 291 // loads from floating above the load of _pending_threads in is_completed() 292 // and thus prevents reading stale data modified in the handshake closure 293 // by the Handshakee. 294 OrderAccess::acquire(); 295 296 log_handshake_info(start_time_ns, _op->name(), number_of_threads_issued, emitted_handshakes_executed); 297 } 298 299 VMOp_Type type() const { return VMOp_HandshakeAllThreads; } 300 }; 301 302 void HandshakeOperation::prepare(JavaThread* current_target, Thread* executing_thread) { 303 if (current_target->is_terminated()) { 304 // Will never execute any handshakes on this thread. 305 return; 306 } 307 if (current_target != executing_thread) { 308 // Only when the target is not executing the handshake itself. 309 StackWatermarkSet::start_processing(current_target, StackWatermarkKind::gc); 310 } 311 if (_requester != nullptr && _requester != executing_thread && _requester->is_Java_thread()) { 312 // The handshake closure may contain oop Handles from the _requester. 313 // We must make sure we can use them. 314 StackWatermarkSet::start_processing(JavaThread::cast(_requester), StackWatermarkKind::gc); 315 } 316 } 317 318 void HandshakeOperation::do_handshake(JavaThread* thread) { 319 jlong start_time_ns = 0; 320 if (log_is_enabled(Debug, handshake, task)) { 321 start_time_ns = os::javaTimeNanos(); 322 } 323 324 // Only actually execute the operation for non terminated threads. 325 if (!thread->is_terminated()) { 326 _handshake_cl->do_thread(thread); 327 } 328 329 if (start_time_ns != 0) { 330 jlong completion_time = os::javaTimeNanos() - start_time_ns; 331 log_debug(handshake, task)("Operation: %s for thread " PTR_FORMAT ", is_vm_thread: %s, completed in " JLONG_FORMAT " ns", 332 name(), p2i(thread), BOOL_TO_STR(Thread::current()->is_VM_thread()), completion_time); 333 } 334 335 // Inform VMThread/Handshaker that we have completed the operation. 336 // When this is executed by the Handshakee we need a release store 337 // here to make sure memory operations executed in the handshake 338 // closure are visible to the VMThread/Handshaker after it reads 339 // that the operation has completed. 340 Atomic::dec(&_pending_threads); 341 // Trailing fence, used to make sure removal of the operation strictly 342 // happened after we completed the operation. 343 344 // It is no longer safe to refer to 'this' as the VMThread/Handshaker may have destroyed this operation 345 } 346 347 void Handshake::execute(HandshakeClosure* hs_cl) { 348 HandshakeOperation cto(hs_cl, nullptr, Thread::current()); 349 VM_HandshakeAllThreads handshake(&cto); 350 VMThread::execute(&handshake); 351 } 352 353 void Handshake::execute(HandshakeClosure* hs_cl, JavaThread* target) { 354 // tlh == nullptr means we rely on a ThreadsListHandle somewhere 355 // in the caller's context (and we sanity check for that). 356 Handshake::execute(hs_cl, nullptr, target); 357 } 358 359 void Handshake::execute(HandshakeClosure* hs_cl, ThreadsListHandle* tlh, JavaThread* target) { 360 JavaThread* self = JavaThread::current(); 361 HandshakeOperation op(hs_cl, target, Thread::current()); 362 363 jlong start_time_ns = os::javaTimeNanos(); 364 365 guarantee(target != nullptr, "must be"); 366 if (tlh == nullptr) { 367 guarantee(Thread::is_JavaThread_protected_by_TLH(target), 368 "missing ThreadsListHandle in calling context."); 369 target->handshake_state()->add_operation(&op); 370 } else if (tlh->includes(target)) { 371 target->handshake_state()->add_operation(&op); 372 } else { 373 char buf[128]; 374 jio_snprintf(buf, sizeof(buf), "(thread= " INTPTR_FORMAT " dead)", p2i(target)); 375 log_handshake_info(start_time_ns, op.name(), 0, 0, buf); 376 return; 377 } 378 379 // Separate the arming of the poll in add_operation() above from 380 // the read of JavaThread state in the try_process() call below. 381 if (UseSystemMemoryBarrier) { 382 SystemMemoryBarrier::emit(); 383 } 384 385 // Keeps count on how many of own emitted handshakes 386 // this thread execute. 387 int emitted_handshakes_executed = 0; 388 HandshakeSpinYield hsy(start_time_ns); 389 while (!op.is_completed()) { 390 HandshakeState::ProcessResult pr = target->handshake_state()->try_process(&op); 391 if (pr == HandshakeState::_succeeded) { 392 emitted_handshakes_executed++; 393 } 394 if (op.is_completed()) { 395 break; 396 } 397 398 // Check if handshake operation has timed out 399 check_handshake_timeout(start_time_ns, &op, target); 400 401 hsy.add_result(pr); 402 // Check for pending handshakes to avoid possible deadlocks where our 403 // target is trying to handshake us. 404 if (SafepointMechanism::should_process(self)) { 405 // Will not suspend here. 406 ThreadBlockInVM tbivm(self); 407 } 408 hsy.process(); 409 } 410 411 // This pairs up with the release store in do_handshake(). It prevents future 412 // loads from floating above the load of _pending_threads in is_completed() 413 // and thus prevents reading stale data modified in the handshake closure 414 // by the Handshakee. 415 OrderAccess::acquire(); 416 417 log_handshake_info(start_time_ns, op.name(), 1, emitted_handshakes_executed); 418 } 419 420 void Handshake::execute(AsyncHandshakeClosure* hs_cl, JavaThread* target) { 421 jlong start_time_ns = os::javaTimeNanos(); 422 AsyncHandshakeOperation* op = new AsyncHandshakeOperation(hs_cl, target, start_time_ns); 423 424 guarantee(target != nullptr, "must be"); 425 426 Thread* current = Thread::current(); 427 if (current != target) { 428 // Another thread is handling the request and it must be protecting 429 // the target. 430 guarantee(Thread::is_JavaThread_protected_by_TLH(target), 431 "missing ThreadsListHandle in calling context."); 432 } 433 // Implied else: 434 // The target is handling the request itself so it can't be dead. 435 436 target->handshake_state()->add_operation(op); 437 } 438 439 // Filters 440 static bool handshaker_filter(HandshakeOperation* op) { 441 return !op->is_async(); 442 } 443 static bool no_async_exception_filter(HandshakeOperation* op) { 444 return !op->is_async_exception(); 445 } 446 static bool async_exception_filter(HandshakeOperation* op) { 447 return op->is_async_exception(); 448 } 449 static bool no_suspend_no_async_exception_filter(HandshakeOperation* op) { 450 return !op->is_suspend() && !op->is_async_exception(); 451 } 452 static bool all_ops_filter(HandshakeOperation* op) { 453 return true; 454 } 455 456 HandshakeState::HandshakeState(JavaThread* target) : 457 _handshakee(target), 458 _queue(), 459 _lock(Monitor::nosafepoint, "HandshakeState_lock"), 460 _active_handshaker(), 461 _async_exceptions_blocked(false), 462 _suspended(false), 463 _async_suspend_handshake(false) { 464 } 465 466 HandshakeState::~HandshakeState() { 467 while (has_operation()) { 468 HandshakeOperation* op = _queue.pop(all_ops_filter); 469 guarantee(op->is_async(), "Only async operations may still be present on queue"); 470 delete op; 471 } 472 } 473 474 void HandshakeState::add_operation(HandshakeOperation* op) { 475 // Adds are done lock free and so is arming. 476 _queue.push(op); 477 SafepointMechanism::arm_local_poll_release(_handshakee); 478 } 479 480 bool HandshakeState::operation_pending(HandshakeOperation* op) { 481 ConditionalMutexLocker ml(&_lock, !_lock.owned_by_self(), Mutex::_no_safepoint_check_flag); 482 MatchOp mo(op); 483 return _queue.contains(mo); 484 } 485 486 HandshakeOperation* HandshakeState::get_op_for_self(bool allow_suspend, bool check_async_exception) { 487 assert(_handshakee == Thread::current(), "Must be called by self"); 488 assert(_lock.owned_by_self(), "Lock must be held"); 489 assert(allow_suspend || !check_async_exception, "invalid case"); 490 #if INCLUDE_JVMTI 491 if (allow_suspend && _handshakee->is_disable_suspend()) { 492 // filter out suspend operations while JavaThread is in disable_suspend mode 493 allow_suspend = false; 494 } 495 #endif 496 if (!allow_suspend) { 497 return _queue.peek(no_suspend_no_async_exception_filter); 498 } else if (check_async_exception && !_async_exceptions_blocked) { 499 return _queue.peek(); 500 } else { 501 return _queue.peek(no_async_exception_filter); 502 } 503 } 504 505 bool HandshakeState::has_operation(bool allow_suspend, bool check_async_exception) { 506 // We must not block here as that could lead to deadlocks if we already hold an 507 // "external" mutex. If the try_lock fails then we assume that there is an operation 508 // and force the caller to check more carefully in a safer context. If we can't get 509 // the lock it means another thread is trying to handshake with us, so it can't 510 // happen during thread termination and destruction. 511 bool ret = true; 512 if (_lock.try_lock()) { 513 ret = get_op_for_self(allow_suspend, check_async_exception) != nullptr; 514 _lock.unlock(); 515 } 516 return ret; 517 } 518 519 bool HandshakeState::has_async_exception_operation() { 520 if (!has_operation()) return false; 521 ConditionalMutexLocker ml(&_lock, !_lock.owned_by_self(), Mutex::_no_safepoint_check_flag); 522 return _queue.peek(async_exception_filter) != nullptr; 523 } 524 525 void HandshakeState::clean_async_exception_operation() { 526 while (has_async_exception_operation()) { 527 MutexLocker ml(&_lock, Mutex::_no_safepoint_check_flag); 528 HandshakeOperation* op; 529 op = _queue.peek(async_exception_filter); 530 remove_op(op); 531 delete op; 532 } 533 } 534 535 bool HandshakeState::has_handshaker_operation() { 536 assert(_handshakee != Thread::current(), "Must not be called by self"); 537 assert(_lock.owned_by_self(), "Lock must be held"); 538 return _queue.contains(handshaker_filter); 539 } 540 541 HandshakeOperation* HandshakeState::get_op_for_handshaker() { 542 assert(_handshakee != Thread::current(), "Must not be called by self"); 543 assert(_lock.owned_by_self(), "Lock must be held"); 544 return _queue.peek(handshaker_filter); 545 } 546 547 void HandshakeState::remove_op(HandshakeOperation* op) { 548 assert(_lock.owned_by_self(), "Lock must be held"); 549 MatchOp mo(op); 550 HandshakeOperation* ret = _queue.pop(mo); 551 assert(ret == op, "Popped op must match requested op"); 552 } 553 554 bool HandshakeState::process_by_self(bool allow_suspend, bool check_async_exception) { 555 assert(Thread::current() == _handshakee, "should call from _handshakee"); 556 assert(!_handshakee->is_terminated(), "should not be a terminated thread"); 557 558 _handshakee->frame_anchor()->make_walkable(); 559 // Threads shouldn't block if they are in the middle of printing, but... 560 ttyLocker::break_tty_lock_for_safepoint(os::current_thread_id()); 561 562 while (has_operation()) { 563 // Handshakes cannot safely safepoint. The exceptions to this rule are 564 // the asynchronous suspension and unsafe access error handshakes. 565 MutexLocker ml(&_lock, Mutex::_no_safepoint_check_flag); 566 567 HandshakeOperation* op = get_op_for_self(allow_suspend, check_async_exception); 568 if (op != nullptr) { 569 assert(op->_target == nullptr || op->_target == Thread::current(), "Wrong thread"); 570 bool async = op->is_async(); 571 log_trace(handshake)("Proc handshake %s " INTPTR_FORMAT " on " INTPTR_FORMAT " by self", 572 async ? "asynchronous" : "synchronous", p2i(op), p2i(_handshakee)); 573 op->prepare(_handshakee, _handshakee); 574 if (!async) { 575 HandleMark hm(_handshakee); 576 PreserveExceptionMark pem(_handshakee); 577 op->do_handshake(_handshakee); // acquire, op removed after 578 remove_op(op); 579 } else { 580 // An asynchronous handshake may put the JavaThread in blocked state (safepoint safe). 581 // The destructor ~PreserveExceptionMark touches the exception oop so it must not be executed, 582 // since a safepoint may be in-progress when returning from the async handshake. 583 remove_op(op); 584 op->do_handshake(_handshakee); 585 log_handshake_info(((AsyncHandshakeOperation*)op)->start_time(), op->name(), 1, 0, "asynchronous"); 586 delete op; 587 return true; // Must check for safepoints 588 } 589 } else { 590 return false; 591 } 592 } 593 return false; 594 } 595 596 bool HandshakeState::can_process_handshake() { 597 // handshake_safe may only be called with polls armed. 598 // Handshaker controls this by first claiming the handshake via claim_handshake(). 599 return SafepointSynchronize::handshake_safe(_handshakee); 600 } 601 602 bool HandshakeState::possibly_can_process_handshake() { 603 // Note that this method is allowed to produce false positives. 604 if (_handshakee->is_terminated()) { 605 return true; 606 } 607 switch (_handshakee->thread_state()) { 608 case _thread_in_native: 609 // native threads are safe if they have no java stack or have walkable stack 610 return !_handshakee->has_last_Java_frame() || _handshakee->frame_anchor()->walkable(); 611 612 case _thread_blocked: 613 return true; 614 615 default: 616 return false; 617 } 618 } 619 620 bool HandshakeState::claim_handshake() { 621 if (!_lock.try_lock()) { 622 return false; 623 } 624 // Operations are added lock free and then the poll is armed. 625 // If all handshake operations for the handshakee are finished and someone 626 // just adds an operation we may see it here. But if the handshakee is not 627 // armed yet it is not safe to proceed. 628 if (has_handshaker_operation()) { 629 OrderAccess::loadload(); // Matches the implicit storestore in add_operation() 630 if (SafepointMechanism::local_poll_armed(_handshakee)) { 631 return true; 632 } 633 } 634 _lock.unlock(); 635 return false; 636 } 637 638 HandshakeState::ProcessResult HandshakeState::try_process(HandshakeOperation* match_op) { 639 if (!has_operation()) { 640 // JT has already cleared its handshake 641 return HandshakeState::_no_operation; 642 } 643 644 if (!possibly_can_process_handshake()) { 645 // JT is observed in an unsafe state, it must notice the handshake itself 646 return HandshakeState::_not_safe; 647 } 648 649 // Claim the mutex if there still an operation to be executed. 650 if (!claim_handshake()) { 651 return HandshakeState::_claim_failed; 652 } 653 654 // If we own the mutex at this point and while owning the mutex we 655 // can observe a safe state the thread cannot possibly continue without 656 // getting caught by the mutex. 657 if (!can_process_handshake()) { 658 _lock.unlock(); 659 return HandshakeState::_not_safe; 660 } 661 662 Thread* current_thread = Thread::current(); 663 664 HandshakeOperation* op = get_op_for_handshaker(); 665 666 assert(op != nullptr, "Must have an op"); 667 assert(SafepointMechanism::local_poll_armed(_handshakee), "Must be"); 668 assert(op->_target == nullptr || _handshakee == op->_target, "Wrong thread"); 669 670 log_trace(handshake)("Processing handshake " INTPTR_FORMAT " by %s(%s)", p2i(op), 671 op == match_op ? "handshaker" : "cooperative", 672 current_thread->is_VM_thread() ? "VM Thread" : "JavaThread"); 673 674 op->prepare(_handshakee, current_thread); 675 676 set_active_handshaker(current_thread); 677 op->do_handshake(_handshakee); // acquire, op removed after 678 set_active_handshaker(nullptr); 679 remove_op(op); 680 681 _lock.unlock(); 682 683 log_trace(handshake)("%s(" INTPTR_FORMAT ") executed an op for JavaThread: " INTPTR_FORMAT " %s target op: " INTPTR_FORMAT, 684 current_thread->is_VM_thread() ? "VM Thread" : "JavaThread", 685 p2i(current_thread), p2i(_handshakee), 686 op == match_op ? "including" : "excluding", p2i(match_op)); 687 688 return op == match_op ? HandshakeState::_succeeded : HandshakeState::_processed; 689 } 690 691 void HandshakeState::do_self_suspend() { 692 assert(Thread::current() == _handshakee, "should call from _handshakee"); 693 assert(_lock.owned_by_self(), "Lock must be held"); 694 assert(!_handshakee->has_last_Java_frame() || _handshakee->frame_anchor()->walkable(), "should have walkable stack"); 695 assert(_handshakee->thread_state() == _thread_blocked, "Caller should have transitioned to _thread_blocked"); 696 697 while (is_suspended()) { 698 log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " suspended", p2i(_handshakee)); 699 _lock.wait_without_safepoint_check(); 700 } 701 log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " resumed", p2i(_handshakee)); 702 } 703 704 // This is the closure that prevents a suspended JavaThread from 705 // escaping the suspend request. 706 class ThreadSelfSuspensionHandshake : public AsyncHandshakeClosure { 707 public: 708 ThreadSelfSuspensionHandshake() : AsyncHandshakeClosure("ThreadSelfSuspensionHandshake") {} 709 void do_thread(Thread* thr) { 710 JavaThread* current = JavaThread::cast(thr); 711 assert(current == Thread::current(), "Must be self executed."); 712 JavaThreadState jts = current->thread_state(); 713 714 current->set_thread_state(_thread_blocked); 715 current->handshake_state()->do_self_suspend(); 716 current->set_thread_state(jts); 717 current->handshake_state()->set_async_suspend_handshake(false); 718 } 719 virtual bool is_suspend() { return true; } 720 }; 721 722 bool HandshakeState::suspend_with_handshake() { 723 assert(_handshakee->threadObj() != nullptr, "cannot suspend with a null threadObj"); 724 if (_handshakee->is_exiting()) { 725 log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " exiting", p2i(_handshakee)); 726 return false; 727 } 728 if (has_async_suspend_handshake()) { 729 if (is_suspended()) { 730 // Target is already suspended. 731 log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " already suspended", p2i(_handshakee)); 732 return false; 733 } else { 734 // Target is going to wake up and leave suspension. 735 // Let's just stop the thread from doing that. 736 log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " re-suspended", p2i(_handshakee)); 737 set_suspended(true); 738 return true; 739 } 740 } 741 // no suspend request 742 assert(!is_suspended(), "cannot be suspended without a suspend request"); 743 // Thread is safe, so it must execute the request, thus we can count it as suspended 744 // from this point. 745 set_suspended(true); 746 set_async_suspend_handshake(true); 747 log_trace(thread, suspend)("JavaThread:" INTPTR_FORMAT " suspended, arming ThreadSuspension", p2i(_handshakee)); 748 ThreadSelfSuspensionHandshake* ts = new ThreadSelfSuspensionHandshake(); 749 Handshake::execute(ts, _handshakee); 750 return true; 751 } 752 753 // This is the closure that synchronously honors the suspend request. 754 class SuspendThreadHandshake : public HandshakeClosure { 755 bool _did_suspend; 756 public: 757 SuspendThreadHandshake() : HandshakeClosure("SuspendThread"), _did_suspend(false) {} 758 void do_thread(Thread* thr) { 759 JavaThread* target = JavaThread::cast(thr); 760 _did_suspend = target->handshake_state()->suspend_with_handshake(); 761 } 762 bool did_suspend() { return _did_suspend; } 763 }; 764 765 bool HandshakeState::suspend() { 766 JVMTI_ONLY(assert(!_handshakee->is_in_VTMS_transition(), "no suspend allowed in VTMS transition");) 767 JavaThread* self = JavaThread::current(); 768 if (_handshakee == self) { 769 // If target is the current thread we can bypass the handshake machinery 770 // and just suspend directly 771 ThreadBlockInVM tbivm(self); 772 MutexLocker ml(&_lock, Mutex::_no_safepoint_check_flag); 773 set_suspended(true); 774 do_self_suspend(); 775 return true; 776 } else { 777 SuspendThreadHandshake st; 778 Handshake::execute(&st, _handshakee); 779 return st.did_suspend(); 780 } 781 } 782 783 bool HandshakeState::resume() { 784 if (!is_suspended()) { 785 return false; 786 } 787 MutexLocker ml(&_lock, Mutex::_no_safepoint_check_flag); 788 if (!is_suspended()) { 789 assert(!_handshakee->is_suspended(), "cannot be suspended without a suspend request"); 790 return false; 791 } 792 // Resume the thread. 793 set_suspended(false); 794 _lock.notify(); 795 return true; 796 } 797 798 void HandshakeState::handle_unsafe_access_error() { 799 if (is_suspended()) { 800 // A suspend handshake was added to the queue after the 801 // unsafe access error. Since the suspender has already 802 // considered this JT as suspended and assumes it won't go 803 // back to Java until resumed we cannot create the exception 804 // object yet. Add a new unsafe access error operation to 805 // the end of the queue and try again in the next attempt. 806 Handshake::execute(new UnsafeAccessErrorHandshake(), _handshakee); 807 log_info(handshake)("JavaThread " INTPTR_FORMAT " skipping unsafe access processing due to suspend.", p2i(_handshakee)); 808 return; 809 } 810 // Release the handshake lock before constructing the oop to 811 // avoid deadlocks since that can block. This will allow the 812 // JavaThread to execute normally as if it was outside a handshake. 813 // We will reacquire the handshake lock at return from ~MutexUnlocker. 814 MutexUnlocker ml(&_lock, Mutex::_no_safepoint_check_flag); 815 // We may be at method entry which requires we save the do-not-unlock flag. 816 UnlockFlagSaver fs(_handshakee); 817 Handle h_exception = Exceptions::new_exception(_handshakee, vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); 818 if (h_exception()->is_a(vmClasses::InternalError_klass())) { 819 java_lang_InternalError::set_during_unsafe_access(h_exception()); 820 } 821 _handshakee->handle_async_exception(h_exception()); 822 }