1 /* 2 * Copyright (c) 2003, 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.inline.hpp" 27 #include "classfile/systemDictionary.hpp" 28 #include "classfile/vmClasses.hpp" 29 #include "classfile/vmSymbols.hpp" 30 #include "gc/shared/oopStorageSet.hpp" 31 #include "memory/allocation.hpp" 32 #include "memory/heapInspection.hpp" 33 #include "memory/oopFactory.hpp" 34 #include "memory/resourceArea.hpp" 35 #include "memory/universe.hpp" 36 #include "oops/instanceKlass.hpp" 37 #include "oops/klass.inline.hpp" 38 #include "oops/objArrayKlass.hpp" 39 #include "oops/objArrayOop.inline.hpp" 40 #include "oops/oop.inline.hpp" 41 #include "oops/oopHandle.inline.hpp" 42 #include "prims/jvmtiRawMonitor.hpp" 43 #include "runtime/atomic.hpp" 44 #include "runtime/handles.inline.hpp" 45 #include "runtime/init.hpp" 46 #include "runtime/javaThread.inline.hpp" 47 #include "runtime/objectMonitor.inline.hpp" 48 #include "runtime/synchronizer.hpp" 49 #include "runtime/thread.inline.hpp" 50 #include "runtime/threads.hpp" 51 #include "runtime/threadSMR.inline.hpp" 52 #include "runtime/vframe.hpp" 53 #include "runtime/vmThread.hpp" 54 #include "runtime/vmOperations.hpp" 55 #include "services/threadService.hpp" 56 57 // TODO: we need to define a naming convention for perf counters 58 // to distinguish counters for: 59 // - standard JSR174 use 60 // - Hotspot extension (public and committed) 61 // - Hotspot extension (private/internal and uncommitted) 62 63 // Default is disabled. 64 bool ThreadService::_thread_monitoring_contention_enabled = false; 65 bool ThreadService::_thread_cpu_time_enabled = false; 66 bool ThreadService::_thread_allocated_memory_enabled = false; 67 68 PerfCounter* ThreadService::_total_threads_count = nullptr; 69 PerfVariable* ThreadService::_live_threads_count = nullptr; 70 PerfVariable* ThreadService::_peak_threads_count = nullptr; 71 PerfVariable* ThreadService::_daemon_threads_count = nullptr; 72 volatile int ThreadService::_atomic_threads_count = 0; 73 volatile int ThreadService::_atomic_daemon_threads_count = 0; 74 75 volatile jlong ThreadService::_exited_allocated_bytes = 0; 76 77 ThreadDumpResult* ThreadService::_threaddump_list = nullptr; 78 79 static const int INITIAL_ARRAY_SIZE = 10; 80 81 // OopStorage for thread stack sampling 82 static OopStorage* _thread_service_storage = nullptr; 83 84 void ThreadService::init() { 85 EXCEPTION_MARK; 86 87 // These counters are for java.lang.management API support. 88 // They are created even if -XX:-UsePerfData is set and in 89 // that case, they will be allocated on C heap. 90 91 _total_threads_count = 92 PerfDataManager::create_counter(JAVA_THREADS, "started", 93 PerfData::U_Events, CHECK); 94 95 _live_threads_count = 96 PerfDataManager::create_variable(JAVA_THREADS, "live", 97 PerfData::U_None, CHECK); 98 99 _peak_threads_count = 100 PerfDataManager::create_variable(JAVA_THREADS, "livePeak", 101 PerfData::U_None, CHECK); 102 103 _daemon_threads_count = 104 PerfDataManager::create_variable(JAVA_THREADS, "daemon", 105 PerfData::U_None, CHECK); 106 107 if (os::is_thread_cpu_time_supported()) { 108 _thread_cpu_time_enabled = true; 109 } 110 111 _thread_allocated_memory_enabled = true; // Always on, so enable it 112 113 // Initialize OopStorage for thread stack sampling walking 114 _thread_service_storage = OopStorageSet::create_strong("ThreadService OopStorage", 115 mtServiceability); 116 } 117 118 void ThreadService::reset_peak_thread_count() { 119 // Acquire the lock to update the peak thread count 120 // to synchronize with thread addition and removal. 121 MutexLocker mu(Threads_lock); 122 _peak_threads_count->set_value(get_live_thread_count()); 123 } 124 125 static bool is_hidden_thread(JavaThread *thread) { 126 // hide VM internal or JVMTI agent threads 127 return thread->is_hidden_from_external_view() || thread->is_jvmti_agent_thread(); 128 } 129 130 void ThreadService::add_thread(JavaThread* thread, bool daemon) { 131 assert(Threads_lock->owned_by_self(), "must have threads lock"); 132 133 // Do not count hidden threads 134 if (is_hidden_thread(thread)) { 135 return; 136 } 137 138 _total_threads_count->inc(); 139 _live_threads_count->inc(); 140 Atomic::inc(&_atomic_threads_count); 141 int count = _atomic_threads_count; 142 143 if (count > _peak_threads_count->get_value()) { 144 _peak_threads_count->set_value(count); 145 } 146 147 if (daemon) { 148 _daemon_threads_count->inc(); 149 Atomic::inc(&_atomic_daemon_threads_count); 150 } 151 } 152 153 void ThreadService::decrement_thread_counts(JavaThread* jt, bool daemon) { 154 Atomic::dec(&_atomic_threads_count); 155 156 if (daemon) { 157 Atomic::dec(&_atomic_daemon_threads_count); 158 } 159 } 160 161 void ThreadService::remove_thread(JavaThread* thread, bool daemon) { 162 assert(Threads_lock->owned_by_self(), "must have threads lock"); 163 164 // Include hidden thread allcations in exited_allocated_bytes 165 ThreadService::incr_exited_allocated_bytes(thread->cooked_allocated_bytes()); 166 167 // Do not count hidden threads 168 if (is_hidden_thread(thread)) { 169 return; 170 } 171 172 assert(!thread->is_terminated(), "must not be terminated"); 173 if (!thread->is_exiting()) { 174 // We did not get here via JavaThread::exit() so current_thread_exiting() 175 // was not called, e.g., JavaThread::cleanup_failed_attach_current_thread(). 176 decrement_thread_counts(thread, daemon); 177 } 178 179 int daemon_count = _atomic_daemon_threads_count; 180 int count = _atomic_threads_count; 181 182 // Counts are incremented at the same time, but atomic counts are 183 // decremented earlier than perf counts. 184 assert(_live_threads_count->get_value() > count, 185 "thread count mismatch %d : %d", 186 (int)_live_threads_count->get_value(), count); 187 188 _live_threads_count->dec(1); 189 if (daemon) { 190 assert(_daemon_threads_count->get_value() > daemon_count, 191 "thread count mismatch %d : %d", 192 (int)_daemon_threads_count->get_value(), daemon_count); 193 194 _daemon_threads_count->dec(1); 195 } 196 197 // Counts are incremented at the same time, but atomic counts are 198 // decremented earlier than perf counts. 199 assert(_daemon_threads_count->get_value() >= daemon_count, 200 "thread count mismatch %d : %d", 201 (int)_daemon_threads_count->get_value(), daemon_count); 202 assert(_live_threads_count->get_value() >= count, 203 "thread count mismatch %d : %d", 204 (int)_live_threads_count->get_value(), count); 205 assert(_live_threads_count->get_value() > 0 || 206 (_live_threads_count->get_value() == 0 && count == 0 && 207 _daemon_threads_count->get_value() == 0 && daemon_count == 0), 208 "thread counts should reach 0 at the same time, live %d,%d daemon %d,%d", 209 (int)_live_threads_count->get_value(), count, 210 (int)_daemon_threads_count->get_value(), daemon_count); 211 assert(_daemon_threads_count->get_value() > 0 || 212 (_daemon_threads_count->get_value() == 0 && daemon_count == 0), 213 "thread counts should reach 0 at the same time, daemon %d,%d", 214 (int)_daemon_threads_count->get_value(), daemon_count); 215 } 216 217 void ThreadService::current_thread_exiting(JavaThread* jt, bool daemon) { 218 // Do not count hidden threads 219 if (is_hidden_thread(jt)) { 220 return; 221 } 222 223 assert(jt == JavaThread::current(), "Called by current thread"); 224 assert(!jt->is_terminated() && jt->is_exiting(), "must be exiting"); 225 226 decrement_thread_counts(jt, daemon); 227 } 228 229 // FIXME: JVMTI should call this function 230 Handle ThreadService::get_current_contended_monitor(JavaThread* thread) { 231 assert(thread != nullptr, "should be non-null"); 232 debug_only(Thread::check_for_dangling_thread_pointer(thread);) 233 234 // This function can be called on a target JavaThread that is not 235 // the caller and we are not at a safepoint. So it is possible for 236 // the waiting or pending condition to be over/stale and for the 237 // first stage of async deflation to clear the object field in 238 // the ObjectMonitor. It is also possible for the object to be 239 // inflated again and to be associated with a completely different 240 // ObjectMonitor by the time this object reference is processed 241 // by the caller. 242 ObjectMonitor *wait_obj = thread->current_waiting_monitor(); 243 244 oop obj = nullptr; 245 if (wait_obj != nullptr) { 246 // thread is doing an Object.wait() call 247 obj = wait_obj->object(); 248 } else { 249 ObjectMonitor *enter_obj = thread->current_pending_monitor(); 250 if (enter_obj != nullptr) { 251 // thread is trying to enter() an ObjectMonitor. 252 obj = enter_obj->object(); 253 } 254 } 255 256 Handle h(Thread::current(), obj); 257 return h; 258 } 259 260 bool ThreadService::set_thread_monitoring_contention(bool flag) { 261 MutexLocker m(Management_lock); 262 263 bool prev = _thread_monitoring_contention_enabled; 264 _thread_monitoring_contention_enabled = flag; 265 266 return prev; 267 } 268 269 bool ThreadService::set_thread_cpu_time_enabled(bool flag) { 270 MutexLocker m(Management_lock); 271 272 bool prev = _thread_cpu_time_enabled; 273 _thread_cpu_time_enabled = flag; 274 275 return prev; 276 } 277 278 bool ThreadService::set_thread_allocated_memory_enabled(bool flag) { 279 MutexLocker m(Management_lock); 280 281 bool prev = _thread_allocated_memory_enabled; 282 _thread_allocated_memory_enabled = flag; 283 284 return prev; 285 } 286 287 void ThreadService::metadata_do(void f(Metadata*)) { 288 for (ThreadDumpResult* dump = _threaddump_list; dump != nullptr; dump = dump->next()) { 289 dump->metadata_do(f); 290 } 291 } 292 293 void ThreadService::add_thread_dump(ThreadDumpResult* dump) { 294 MutexLocker ml(Management_lock); 295 if (_threaddump_list == nullptr) { 296 _threaddump_list = dump; 297 } else { 298 dump->set_next(_threaddump_list); 299 _threaddump_list = dump; 300 } 301 } 302 303 void ThreadService::remove_thread_dump(ThreadDumpResult* dump) { 304 MutexLocker ml(Management_lock); 305 306 ThreadDumpResult* prev = nullptr; 307 bool found = false; 308 for (ThreadDumpResult* d = _threaddump_list; d != nullptr; prev = d, d = d->next()) { 309 if (d == dump) { 310 if (prev == nullptr) { 311 _threaddump_list = dump->next(); 312 } else { 313 prev->set_next(dump->next()); 314 } 315 found = true; 316 break; 317 } 318 } 319 assert(found, "The threaddump result to be removed must exist."); 320 } 321 322 // Dump stack trace of threads specified in the given threads array. 323 // Returns StackTraceElement[][] each element is the stack trace of a thread in 324 // the corresponding entry in the given threads array 325 Handle ThreadService::dump_stack_traces(GrowableArray<instanceHandle>* threads, 326 int num_threads, 327 TRAPS) { 328 assert(num_threads > 0, "just checking"); 329 330 ThreadDumpResult dump_result; 331 VM_ThreadDump op(&dump_result, 332 threads, 333 num_threads, 334 -1, /* entire stack */ 335 false, /* with locked monitors */ 336 false /* with locked synchronizers */); 337 VMThread::execute(&op); 338 339 // Allocate the resulting StackTraceElement[][] object 340 341 ResourceMark rm(THREAD); 342 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_StackTraceElement_array(), true, CHECK_NH); 343 ObjArrayKlass* ik = ObjArrayKlass::cast(k); 344 objArrayOop r = oopFactory::new_objArray(ik, num_threads, CHECK_NH); 345 objArrayHandle result_obj(THREAD, r); 346 347 int num_snapshots = dump_result.num_snapshots(); 348 assert(num_snapshots == num_threads, "Must have num_threads thread snapshots"); 349 assert(num_snapshots == 0 || dump_result.t_list_has_been_set(), "ThreadsList must have been set if we have a snapshot"); 350 int i = 0; 351 for (ThreadSnapshot* ts = dump_result.snapshots(); ts != nullptr; i++, ts = ts->next()) { 352 ThreadStackTrace* stacktrace = ts->get_stack_trace(); 353 if (stacktrace == nullptr) { 354 // No stack trace 355 result_obj->obj_at_put(i, nullptr); 356 } else { 357 // Construct an array of java/lang/StackTraceElement object 358 Handle backtrace_h = stacktrace->allocate_fill_stack_trace_element_array(CHECK_NH); 359 result_obj->obj_at_put(i, backtrace_h()); 360 } 361 } 362 363 return result_obj; 364 } 365 366 void ThreadService::reset_contention_count_stat(JavaThread* thread) { 367 ThreadStatistics* stat = thread->get_thread_stat(); 368 if (stat != nullptr) { 369 stat->reset_count_stat(); 370 } 371 } 372 373 void ThreadService::reset_contention_time_stat(JavaThread* thread) { 374 ThreadStatistics* stat = thread->get_thread_stat(); 375 if (stat != nullptr) { 376 stat->reset_time_stat(); 377 } 378 } 379 380 bool ThreadService::is_virtual_or_carrier_thread(JavaThread* jt) { 381 oop threadObj = jt->threadObj(); 382 if (threadObj != nullptr && threadObj->is_a(vmClasses::BaseVirtualThread_klass())) { 383 // a virtual thread backed by JavaThread 384 return true; 385 } 386 if (jt->is_vthread_mounted()) { 387 // carrier thread 388 return true; 389 } 390 return false; 391 } 392 393 // Find deadlocks involving raw monitors, object monitors and concurrent locks 394 // if concurrent_locks is true. 395 // We skip virtual thread carriers under the assumption that the current scheduler, ForkJoinPool, 396 // doesn't hold any locks while mounting a virtual thread, so any owned monitor (or j.u.c., lock for that matter) 397 // on that JavaThread must be owned by the virtual thread, and we don't support deadlock detection for virtual threads. 398 DeadlockCycle* ThreadService::find_deadlocks_at_safepoint(ThreadsList * t_list, bool concurrent_locks) { 399 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); 400 401 // This code was modified from the original Threads::find_deadlocks code. 402 int globalDfn = 0, thisDfn; 403 ObjectMonitor* waitingToLockMonitor = nullptr; 404 JvmtiRawMonitor* waitingToLockRawMonitor = nullptr; 405 oop waitingToLockBlocker = nullptr; 406 bool blocked_on_monitor = false; 407 JavaThread *currentThread, *previousThread; 408 int num_deadlocks = 0; 409 410 // Initialize the depth-first-number for each JavaThread. 411 JavaThreadIterator jti(t_list); 412 for (JavaThread* jt = jti.first(); jt != nullptr; jt = jti.next()) { 413 if (!is_virtual_or_carrier_thread(jt)) { 414 jt->set_depth_first_number(-1); 415 } 416 } 417 418 DeadlockCycle* deadlocks = nullptr; 419 DeadlockCycle* last = nullptr; 420 DeadlockCycle* cycle = new DeadlockCycle(); 421 for (JavaThread* jt = jti.first(); jt != nullptr; jt = jti.next()) { 422 if (is_virtual_or_carrier_thread(jt)) { 423 // skip virtual and carrier threads 424 continue; 425 } 426 if (jt->depth_first_number() >= 0) { 427 // this thread was already visited 428 continue; 429 } 430 431 thisDfn = globalDfn; 432 jt->set_depth_first_number(globalDfn++); 433 previousThread = jt; 434 currentThread = jt; 435 436 cycle->reset(); 437 438 // The ObjectMonitor* can't be async deflated since we are at a safepoint. 439 // When there is a deadlock, all the monitors involved in the dependency 440 // cycle must be contended and heavyweight. So we only care about the 441 // heavyweight monitor a thread is waiting to lock. 442 waitingToLockMonitor = jt->current_pending_monitor(); 443 // JVM TI raw monitors can also be involved in deadlocks, and we can be 444 // waiting to lock both a raw monitor and ObjectMonitor at the same time. 445 // It isn't clear how to make deadlock detection work correctly if that 446 // happens. 447 waitingToLockRawMonitor = jt->current_pending_raw_monitor(); 448 449 if (concurrent_locks) { 450 waitingToLockBlocker = jt->current_park_blocker(); 451 } 452 453 while (waitingToLockMonitor != nullptr || 454 waitingToLockRawMonitor != nullptr || 455 waitingToLockBlocker != nullptr) { 456 cycle->add_thread(currentThread); 457 // Give preference to the raw monitor 458 if (waitingToLockRawMonitor != nullptr) { 459 Thread* owner = waitingToLockRawMonitor->owner(); 460 if (owner != nullptr && // the raw monitor could be released at any time 461 owner->is_Java_thread()) { 462 currentThread = JavaThread::cast(owner); 463 } 464 } else if (waitingToLockMonitor != nullptr) { 465 if (waitingToLockMonitor->has_owner()) { 466 currentThread = Threads::owning_thread_from_monitor(t_list, waitingToLockMonitor); 467 if (currentThread == nullptr) { 468 // This function is called at a safepoint so the JavaThread 469 // that owns waitingToLockMonitor should be findable, but 470 // if it is not findable, then the previous currentThread is 471 // blocked permanently. We record this as a deadlock. 472 num_deadlocks++; 473 474 // add this cycle to the deadlocks list 475 if (deadlocks == nullptr) { 476 deadlocks = cycle; 477 } else { 478 last->set_next(cycle); 479 } 480 last = cycle; 481 cycle = new DeadlockCycle(); 482 break; 483 } 484 } 485 } else { 486 if (concurrent_locks) { 487 if (waitingToLockBlocker->is_a(vmClasses::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass())) { 488 oop threadObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker); 489 // This JavaThread (if there is one) is protected by the 490 // ThreadsListSetter in VM_FindDeadlocks::doit(). 491 currentThread = threadObj != nullptr ? java_lang_Thread::thread(threadObj) : nullptr; 492 } else { 493 currentThread = nullptr; 494 } 495 } 496 } 497 498 if (currentThread == nullptr || is_virtual_or_carrier_thread(currentThread)) { 499 // No dependency on another thread 500 break; 501 } 502 if (currentThread->depth_first_number() < 0) { 503 // First visit to this thread 504 currentThread->set_depth_first_number(globalDfn++); 505 } else if (currentThread->depth_first_number() < thisDfn) { 506 // Thread already visited, and not on a (new) cycle 507 break; 508 } else if (currentThread == previousThread) { 509 // Self-loop, ignore 510 break; 511 } else { 512 // We have a (new) cycle 513 num_deadlocks++; 514 515 // add this cycle to the deadlocks list 516 if (deadlocks == nullptr) { 517 deadlocks = cycle; 518 } else { 519 last->set_next(cycle); 520 } 521 last = cycle; 522 cycle = new DeadlockCycle(); 523 break; 524 } 525 previousThread = currentThread; 526 waitingToLockMonitor = (ObjectMonitor*)currentThread->current_pending_monitor(); 527 if (concurrent_locks) { 528 waitingToLockBlocker = currentThread->current_park_blocker(); 529 } 530 } 531 532 } 533 delete cycle; 534 return deadlocks; 535 } 536 537 ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(nullptr), _last(nullptr), _next(nullptr), _setter() { 538 539 // Create a new ThreadDumpResult object and append to the list. 540 // If GC happens before this function returns, Method* 541 // in the stack trace will be visited. 542 ThreadService::add_thread_dump(this); 543 } 544 545 ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(nullptr), _last(nullptr), _next(nullptr), _setter() { 546 // Create a new ThreadDumpResult object and append to the list. 547 // If GC happens before this function returns, oops 548 // will be visited. 549 ThreadService::add_thread_dump(this); 550 } 551 552 ThreadDumpResult::~ThreadDumpResult() { 553 ThreadService::remove_thread_dump(this); 554 555 // free all the ThreadSnapshot objects created during 556 // the VM_ThreadDump operation 557 ThreadSnapshot* ts = _snapshots; 558 while (ts != nullptr) { 559 ThreadSnapshot* p = ts; 560 ts = ts->next(); 561 delete p; 562 } 563 } 564 565 ThreadSnapshot* ThreadDumpResult::add_thread_snapshot() { 566 ThreadSnapshot* ts = new ThreadSnapshot(); 567 link_thread_snapshot(ts); 568 return ts; 569 } 570 571 ThreadSnapshot* ThreadDumpResult::add_thread_snapshot(JavaThread* thread) { 572 ThreadSnapshot* ts = new ThreadSnapshot(); 573 link_thread_snapshot(ts); 574 ts->initialize(t_list(), thread); 575 return ts; 576 } 577 578 void ThreadDumpResult::link_thread_snapshot(ThreadSnapshot* ts) { 579 assert(_num_threads == 0 || _num_snapshots < _num_threads, 580 "_num_snapshots must be less than _num_threads"); 581 _num_snapshots++; 582 if (_snapshots == nullptr) { 583 _snapshots = ts; 584 } else { 585 _last->set_next(ts); 586 } 587 _last = ts; 588 } 589 590 void ThreadDumpResult::metadata_do(void f(Metadata*)) { 591 for (ThreadSnapshot* ts = _snapshots; ts != nullptr; ts = ts->next()) { 592 ts->metadata_do(f); 593 } 594 } 595 596 ThreadsList* ThreadDumpResult::t_list() { 597 return _setter.list(); 598 } 599 600 StackFrameInfo::StackFrameInfo(javaVFrame* jvf, bool with_lock_info) { 601 _method = jvf->method(); 602 _bci = jvf->bci(); 603 _class_holder = OopHandle(_thread_service_storage, _method->method_holder()->klass_holder()); 604 _locked_monitors = nullptr; 605 if (with_lock_info) { 606 Thread* current_thread = Thread::current(); 607 ResourceMark rm(current_thread); 608 HandleMark hm(current_thread); 609 GrowableArray<MonitorInfo*>* list = jvf->locked_monitors(); 610 int length = list->length(); 611 if (length > 0) { 612 _locked_monitors = new (mtServiceability) GrowableArray<OopHandle>(length, mtServiceability); 613 for (int i = 0; i < length; i++) { 614 MonitorInfo* monitor = list->at(i); 615 assert(monitor->owner() != nullptr, "This monitor must have an owning object"); 616 _locked_monitors->append(OopHandle(_thread_service_storage, monitor->owner())); 617 } 618 } 619 } 620 } 621 622 StackFrameInfo::~StackFrameInfo() { 623 if (_locked_monitors != nullptr) { 624 for (int i = 0; i < _locked_monitors->length(); i++) { 625 _locked_monitors->at(i).release(_thread_service_storage); 626 } 627 delete _locked_monitors; 628 } 629 _class_holder.release(_thread_service_storage); 630 } 631 632 void StackFrameInfo::metadata_do(void f(Metadata*)) { 633 f(_method); 634 } 635 636 void StackFrameInfo::print_on(outputStream* st) const { 637 ResourceMark rm; 638 java_lang_Throwable::print_stack_element(st, method(), bci()); 639 int len = (_locked_monitors != nullptr ? _locked_monitors->length() : 0); 640 for (int i = 0; i < len; i++) { 641 oop o = _locked_monitors->at(i).resolve(); 642 st->print_cr("\t- locked <" INTPTR_FORMAT "> (a %s)", p2i(o), o->klass()->external_name()); 643 } 644 } 645 646 // Iterate through monitor cache to find JNI locked monitors 647 class InflatedMonitorsClosure: public MonitorClosure { 648 private: 649 ThreadStackTrace* _stack_trace; 650 public: 651 InflatedMonitorsClosure(ThreadStackTrace* st) { 652 _stack_trace = st; 653 } 654 void do_monitor(ObjectMonitor* mid) { 655 oop object = mid->object(); 656 if (!_stack_trace->is_owned_monitor_on_stack(object)) { 657 _stack_trace->add_jni_locked_monitor(object); 658 } 659 } 660 }; 661 662 ThreadStackTrace::ThreadStackTrace(JavaThread* t, bool with_locked_monitors) { 663 _thread = t; 664 _frames = new (mtServiceability) GrowableArray<StackFrameInfo*>(INITIAL_ARRAY_SIZE, mtServiceability); 665 _depth = 0; 666 _with_locked_monitors = with_locked_monitors; 667 if (_with_locked_monitors) { 668 _jni_locked_monitors = new (mtServiceability) GrowableArray<OopHandle>(INITIAL_ARRAY_SIZE, mtServiceability); 669 } else { 670 _jni_locked_monitors = nullptr; 671 } 672 } 673 674 void ThreadStackTrace::add_jni_locked_monitor(oop object) { 675 _jni_locked_monitors->append(OopHandle(_thread_service_storage, object)); 676 } 677 678 ThreadStackTrace::~ThreadStackTrace() { 679 for (int i = 0; i < _frames->length(); i++) { 680 delete _frames->at(i); 681 } 682 delete _frames; 683 if (_jni_locked_monitors != nullptr) { 684 for (int i = 0; i < _jni_locked_monitors->length(); i++) { 685 _jni_locked_monitors->at(i).release(_thread_service_storage); 686 } 687 delete _jni_locked_monitors; 688 } 689 } 690 691 void ThreadStackTrace::dump_stack_at_safepoint(int maxDepth, ObjectMonitorsView* monitors, bool full) { 692 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); 693 694 if (_thread->has_last_Java_frame()) { 695 RegisterMap reg_map(_thread, 696 RegisterMap::UpdateMap::include, 697 RegisterMap::ProcessFrames::include, 698 RegisterMap::WalkContinuation::skip); 699 ResourceMark rm(VMThread::vm_thread()); 700 // If full, we want to print both vthread and carrier frames 701 vframe* start_vf = !full && _thread->is_vthread_mounted() 702 ? _thread->carrier_last_java_vframe(®_map) 703 : _thread->last_java_vframe(®_map); 704 int count = 0; 705 for (vframe* f = start_vf; f; f = f->sender() ) { 706 if (maxDepth >= 0 && count == maxDepth) { 707 // Skip frames if more than maxDepth 708 break; 709 } 710 if (!full && f->is_vthread_entry()) { 711 break; 712 } 713 if (f->is_java_frame()) { 714 javaVFrame* jvf = javaVFrame::cast(f); 715 add_stack_frame(jvf); 716 count++; 717 } else { 718 // Ignore non-Java frames 719 } 720 } 721 } 722 723 if (_with_locked_monitors) { 724 // Iterate inflated monitors and find monitors locked by this thread 725 // that are not found in the stack, e.g. JNI locked monitors: 726 InflatedMonitorsClosure imc(this); 727 monitors->visit(&imc, _thread); 728 } 729 } 730 731 732 bool ThreadStackTrace::is_owned_monitor_on_stack(oop object) { 733 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); 734 735 bool found = false; 736 int num_frames = get_stack_depth(); 737 for (int depth = 0; depth < num_frames; depth++) { 738 StackFrameInfo* frame = stack_frame_at(depth); 739 int len = frame->num_locked_monitors(); 740 GrowableArray<OopHandle>* locked_monitors = frame->locked_monitors(); 741 for (int j = 0; j < len; j++) { 742 oop monitor = locked_monitors->at(j).resolve(); 743 assert(monitor != nullptr, "must be a Java object"); 744 if (monitor == object) { 745 found = true; 746 break; 747 } 748 } 749 } 750 return found; 751 } 752 753 Handle ThreadStackTrace::allocate_fill_stack_trace_element_array(TRAPS) { 754 InstanceKlass* ik = vmClasses::StackTraceElement_klass(); 755 assert(ik != nullptr, "must be loaded in 1.4+"); 756 757 // Allocate an array of java/lang/StackTraceElement object 758 objArrayOop ste = oopFactory::new_objArray(ik, _depth, CHECK_NH); 759 objArrayHandle backtrace(THREAD, ste); 760 for (int j = 0; j < _depth; j++) { 761 StackFrameInfo* frame = _frames->at(j); 762 methodHandle mh(THREAD, frame->method()); 763 oop element = java_lang_StackTraceElement::create(mh, frame->bci(), CHECK_NH); 764 backtrace->obj_at_put(j, element); 765 } 766 return backtrace; 767 } 768 769 void ThreadStackTrace::add_stack_frame(javaVFrame* jvf) { 770 StackFrameInfo* frame = new StackFrameInfo(jvf, _with_locked_monitors); 771 _frames->append(frame); 772 _depth++; 773 } 774 775 void ThreadStackTrace::metadata_do(void f(Metadata*)) { 776 int length = _frames->length(); 777 for (int i = 0; i < length; i++) { 778 _frames->at(i)->metadata_do(f); 779 } 780 } 781 782 783 ConcurrentLocksDump::~ConcurrentLocksDump() { 784 if (_retain_map_on_free) { 785 return; 786 } 787 788 for (ThreadConcurrentLocks* t = _map; t != nullptr;) { 789 ThreadConcurrentLocks* tcl = t; 790 t = t->next(); 791 delete tcl; 792 } 793 } 794 795 void ConcurrentLocksDump::dump_at_safepoint() { 796 // dump all locked concurrent locks 797 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); 798 799 GrowableArray<oop>* aos_objects = new (mtServiceability) GrowableArray<oop>(INITIAL_ARRAY_SIZE, mtServiceability); 800 801 // Find all instances of AbstractOwnableSynchronizer 802 HeapInspection::find_instances_at_safepoint(vmClasses::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass(), 803 aos_objects); 804 // Build a map of thread to its owned AQS locks 805 build_map(aos_objects); 806 807 delete aos_objects; 808 } 809 810 811 // build a map of JavaThread to all its owned AbstractOwnableSynchronizer 812 void ConcurrentLocksDump::build_map(GrowableArray<oop>* aos_objects) { 813 int length = aos_objects->length(); 814 for (int i = 0; i < length; i++) { 815 oop o = aos_objects->at(i); 816 oop owner_thread_obj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(o); 817 if (owner_thread_obj != nullptr) { 818 // See comments in ThreadConcurrentLocks to see how this 819 // JavaThread* is protected. 820 JavaThread* thread = java_lang_Thread::thread(owner_thread_obj); 821 assert(o->is_instance(), "Must be an instanceOop"); 822 add_lock(thread, (instanceOop) o); 823 } 824 } 825 } 826 827 void ConcurrentLocksDump::add_lock(JavaThread* thread, instanceOop o) { 828 ThreadConcurrentLocks* tcl = thread_concurrent_locks(thread); 829 if (tcl != nullptr) { 830 tcl->add_lock(o); 831 return; 832 } 833 834 // First owned lock found for this thread 835 tcl = new ThreadConcurrentLocks(thread); 836 tcl->add_lock(o); 837 if (_map == nullptr) { 838 _map = tcl; 839 } else { 840 _last->set_next(tcl); 841 } 842 _last = tcl; 843 } 844 845 ThreadConcurrentLocks* ConcurrentLocksDump::thread_concurrent_locks(JavaThread* thread) { 846 for (ThreadConcurrentLocks* tcl = _map; tcl != nullptr; tcl = tcl->next()) { 847 if (tcl->java_thread() == thread) { 848 return tcl; 849 } 850 } 851 return nullptr; 852 } 853 854 void ConcurrentLocksDump::print_locks_on(JavaThread* t, outputStream* st) { 855 st->print_cr(" Locked ownable synchronizers:"); 856 ThreadConcurrentLocks* tcl = thread_concurrent_locks(t); 857 GrowableArray<OopHandle>* locks = (tcl != nullptr ? tcl->owned_locks() : nullptr); 858 if (locks == nullptr || locks->is_empty()) { 859 st->print_cr("\t- None"); 860 st->cr(); 861 return; 862 } 863 864 for (int i = 0; i < locks->length(); i++) { 865 oop obj = locks->at(i).resolve(); 866 st->print_cr("\t- <" INTPTR_FORMAT "> (a %s)", p2i(obj), obj->klass()->external_name()); 867 } 868 st->cr(); 869 } 870 871 ThreadConcurrentLocks::ThreadConcurrentLocks(JavaThread* thread) { 872 _thread = thread; 873 _owned_locks = new (mtServiceability) GrowableArray<OopHandle>(INITIAL_ARRAY_SIZE, mtServiceability); 874 _next = nullptr; 875 } 876 877 ThreadConcurrentLocks::~ThreadConcurrentLocks() { 878 for (int i = 0; i < _owned_locks->length(); i++) { 879 _owned_locks->at(i).release(_thread_service_storage); 880 } 881 delete _owned_locks; 882 } 883 884 void ThreadConcurrentLocks::add_lock(instanceOop o) { 885 _owned_locks->append(OopHandle(_thread_service_storage, o)); 886 } 887 888 ThreadStatistics::ThreadStatistics() { 889 _contended_enter_count = 0; 890 _monitor_wait_count = 0; 891 _sleep_count = 0; 892 _count_pending_reset = false; 893 _timer_pending_reset = false; 894 memset((void*) _perf_recursion_counts, 0, sizeof(_perf_recursion_counts)); 895 } 896 897 oop ThreadSnapshot::threadObj() const { return _threadObj.resolve(); } 898 899 void ThreadSnapshot::initialize(ThreadsList * t_list, JavaThread* thread) { 900 _thread = thread; 901 oop threadObj = thread->threadObj(); 902 _threadObj = OopHandle(_thread_service_storage, threadObj); 903 904 ThreadStatistics* stat = thread->get_thread_stat(); 905 _contended_enter_ticks = stat->contended_enter_ticks(); 906 _contended_enter_count = stat->contended_enter_count(); 907 _monitor_wait_ticks = stat->monitor_wait_ticks(); 908 _monitor_wait_count = stat->monitor_wait_count(); 909 _sleep_ticks = stat->sleep_ticks(); 910 _sleep_count = stat->sleep_count(); 911 912 // If thread is still attaching then threadObj will be null. 913 _thread_status = threadObj == nullptr ? JavaThreadStatus::NEW 914 : java_lang_Thread::get_thread_status(threadObj); 915 916 _is_suspended = thread->is_suspended(); 917 _is_in_native = (thread->thread_state() == _thread_in_native); 918 919 Handle obj = ThreadService::get_current_contended_monitor(thread); 920 921 oop blocker_object = nullptr; 922 oop blocker_object_owner = nullptr; 923 924 if (thread->is_vthread_mounted() && thread->vthread() != threadObj) { // ThreadSnapshot only captures platform threads 925 _thread_status = JavaThreadStatus::IN_OBJECT_WAIT; 926 oop vthread = thread->vthread(); 927 assert(vthread != nullptr, ""); 928 blocker_object = vthread; 929 blocker_object_owner = vthread; 930 } else if (_thread_status == JavaThreadStatus::BLOCKED_ON_MONITOR_ENTER || 931 _thread_status == JavaThreadStatus::IN_OBJECT_WAIT || 932 _thread_status == JavaThreadStatus::IN_OBJECT_WAIT_TIMED) { 933 934 if (obj() == nullptr) { 935 // monitor no longer exists; thread is not blocked 936 _thread_status = JavaThreadStatus::RUNNABLE; 937 } else { 938 blocker_object = obj(); 939 JavaThread* owner = ObjectSynchronizer::get_lock_owner(t_list, obj); 940 if ((owner == nullptr && _thread_status == JavaThreadStatus::BLOCKED_ON_MONITOR_ENTER) 941 || (owner != nullptr && owner->is_attaching_via_jni())) { 942 // ownership information of the monitor is not available 943 // (may no longer be owned or releasing to some other thread) 944 // make this thread in RUNNABLE state. 945 // And when the owner thread is in attaching state, the java thread 946 // is not completely initialized. For example thread name and id 947 // and may not be set, so hide the attaching thread. 948 _thread_status = JavaThreadStatus::RUNNABLE; 949 blocker_object = nullptr; 950 } else if (owner != nullptr) { 951 blocker_object_owner = owner->threadObj(); 952 } 953 } 954 } else if (_thread_status == JavaThreadStatus::PARKED || _thread_status == JavaThreadStatus::PARKED_TIMED) { 955 blocker_object = thread->current_park_blocker(); 956 if (blocker_object != nullptr && blocker_object->is_a(vmClasses::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass())) { 957 blocker_object_owner = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(blocker_object); 958 } 959 } 960 961 if (blocker_object != nullptr) { 962 _blocker_object = OopHandle(_thread_service_storage, blocker_object); 963 } 964 if (blocker_object_owner != nullptr) { 965 _blocker_object_owner = OopHandle(_thread_service_storage, blocker_object_owner); 966 } 967 } 968 969 oop ThreadSnapshot::blocker_object() const { return _blocker_object.resolve(); } 970 oop ThreadSnapshot::blocker_object_owner() const { return _blocker_object_owner.resolve(); } 971 972 ThreadSnapshot::~ThreadSnapshot() { 973 _blocker_object.release(_thread_service_storage); 974 _blocker_object_owner.release(_thread_service_storage); 975 _threadObj.release(_thread_service_storage); 976 977 delete _stack_trace; 978 delete _concurrent_locks; 979 } 980 981 void ThreadSnapshot::dump_stack_at_safepoint(int max_depth, bool with_locked_monitors, 982 ObjectMonitorsView* monitors, bool full) { 983 _stack_trace = new ThreadStackTrace(_thread, with_locked_monitors); 984 _stack_trace->dump_stack_at_safepoint(max_depth, monitors, full); 985 } 986 987 988 void ThreadSnapshot::metadata_do(void f(Metadata*)) { 989 if (_stack_trace != nullptr) { 990 _stack_trace->metadata_do(f); 991 } 992 } 993 994 995 DeadlockCycle::DeadlockCycle() { 996 _threads = new (mtServiceability) GrowableArray<JavaThread*>(INITIAL_ARRAY_SIZE, mtServiceability); 997 _next = nullptr; 998 } 999 1000 DeadlockCycle::~DeadlockCycle() { 1001 delete _threads; 1002 } 1003 1004 void DeadlockCycle::print_on_with(ThreadsList * t_list, outputStream* st) const { 1005 st->cr(); 1006 st->print_cr("Found one Java-level deadlock:"); 1007 st->print("============================="); 1008 1009 JavaThread* currentThread; 1010 JvmtiRawMonitor* waitingToLockRawMonitor; 1011 oop waitingToLockBlocker; 1012 int len = _threads->length(); 1013 for (int i = 0; i < len; i++) { 1014 currentThread = _threads->at(i); 1015 // The ObjectMonitor* can't be async deflated since we are at a safepoint. 1016 ObjectMonitor* waitingToLockMonitor = currentThread->current_pending_monitor(); 1017 waitingToLockRawMonitor = currentThread->current_pending_raw_monitor(); 1018 waitingToLockBlocker = currentThread->current_park_blocker(); 1019 st->cr(); 1020 st->print_cr("\"%s\":", currentThread->name()); 1021 const char* owner_desc = ",\n which is held by"; 1022 1023 // Note: As the JVM TI "monitor contended enter" event callback is executed after ObjectMonitor 1024 // sets the current pending monitor, it is possible to then see a pending raw monitor as well. 1025 if (waitingToLockRawMonitor != nullptr) { 1026 st->print(" waiting to lock JVM TI raw monitor " INTPTR_FORMAT, p2i(waitingToLockRawMonitor)); 1027 Thread* owner = waitingToLockRawMonitor->owner(); 1028 // Could be null as the raw monitor could be released at any time if held by non-JavaThread 1029 if (owner != nullptr) { 1030 if (owner->is_Java_thread()) { 1031 currentThread = JavaThread::cast(owner); 1032 st->print_cr("%s \"%s\"", owner_desc, currentThread->name()); 1033 } else { 1034 st->print_cr(",\n which has now been released"); 1035 } 1036 } else { 1037 st->print_cr("%s non-Java thread=" PTR_FORMAT, owner_desc, p2i(owner)); 1038 } 1039 } 1040 1041 if (waitingToLockMonitor != nullptr) { 1042 st->print(" waiting to lock monitor " INTPTR_FORMAT, p2i(waitingToLockMonitor)); 1043 oop obj = waitingToLockMonitor->object(); 1044 st->print(" (object " INTPTR_FORMAT ", a %s)", p2i(obj), 1045 obj->klass()->external_name()); 1046 1047 if (!currentThread->current_pending_monitor_is_from_java()) { 1048 owner_desc = "\n in JNI, which is held by"; 1049 } 1050 currentThread = Threads::owning_thread_from_monitor(t_list, waitingToLockMonitor); 1051 if (currentThread == nullptr) { 1052 // The deadlock was detected at a safepoint so the JavaThread 1053 // that owns waitingToLockMonitor should be findable, but 1054 // if it is not findable, then the previous currentThread is 1055 // blocked permanently. 1056 st->print_cr("%s UNKNOWN_owner_addr=" PTR_FORMAT, owner_desc, 1057 p2i(waitingToLockMonitor->owner())); 1058 continue; 1059 } 1060 } else { 1061 st->print(" waiting for ownable synchronizer " INTPTR_FORMAT ", (a %s)", 1062 p2i(waitingToLockBlocker), 1063 waitingToLockBlocker->klass()->external_name()); 1064 assert(waitingToLockBlocker->is_a(vmClasses::java_util_concurrent_locks_AbstractOwnableSynchronizer_klass()), 1065 "Must be an AbstractOwnableSynchronizer"); 1066 oop ownerObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker); 1067 currentThread = java_lang_Thread::thread(ownerObj); 1068 assert(currentThread != nullptr, "AbstractOwnableSynchronizer owning thread is unexpectedly null"); 1069 } 1070 st->print_cr("%s \"%s\"", owner_desc, currentThread->name()); 1071 } 1072 1073 st->cr(); 1074 1075 // Print stack traces 1076 bool oldJavaMonitorsInStackTrace = JavaMonitorsInStackTrace; 1077 JavaMonitorsInStackTrace = true; 1078 st->print_cr("Java stack information for the threads listed above:"); 1079 st->print_cr("==================================================="); 1080 for (int j = 0; j < len; j++) { 1081 currentThread = _threads->at(j); 1082 st->print_cr("\"%s\":", currentThread->name()); 1083 currentThread->print_stack_on(st); 1084 } 1085 JavaMonitorsInStackTrace = oldJavaMonitorsInStackTrace; 1086 } 1087 1088 ThreadsListEnumerator::ThreadsListEnumerator(Thread* cur_thread, 1089 bool include_jvmti_agent_threads, 1090 bool include_jni_attaching_threads, 1091 bool include_bound_virtual_threads) { 1092 assert(cur_thread == Thread::current(), "Check current thread"); 1093 1094 int init_size = ThreadService::get_live_thread_count(); 1095 _threads_array = new GrowableArray<instanceHandle>(init_size); 1096 1097 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *jt = jtiwh.next(); ) { 1098 // skips JavaThreads in the process of exiting 1099 // and also skips VM internal JavaThreads 1100 // Threads in _thread_new or _thread_new_trans state are included. 1101 // i.e. threads have been started but not yet running. 1102 if (jt->threadObj() == nullptr || 1103 jt->is_exiting() || 1104 !java_lang_Thread::is_alive(jt->threadObj()) || 1105 jt->is_hidden_from_external_view()) { 1106 continue; 1107 } 1108 1109 // skip agent threads 1110 if (!include_jvmti_agent_threads && jt->is_jvmti_agent_thread()) { 1111 continue; 1112 } 1113 1114 // skip jni threads in the process of attaching 1115 if (!include_jni_attaching_threads && jt->is_attaching_via_jni()) { 1116 continue; 1117 } 1118 1119 // skip instances of BoundVirtualThread 1120 if (!include_bound_virtual_threads && jt->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) { 1121 continue; 1122 } 1123 1124 instanceHandle h(cur_thread, (instanceOop) jt->threadObj()); 1125 _threads_array->append(h); 1126 } 1127 }