1 /* 2 * Copyright (c) 1997, 2022, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2021, Azul Systems, Inc. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #include "precompiled.hpp" 27 #include "jvm.h" 28 #include "cds/dynamicArchive.hpp" 29 #include "cds/metaspaceShared.hpp" 30 #include "classfile/classLoader.hpp" 31 #include "classfile/javaClasses.hpp" 32 #include "classfile/javaThreadStatus.hpp" 33 #include "classfile/systemDictionary.hpp" 34 #include "classfile/vmClasses.hpp" 35 #include "classfile/vmSymbols.hpp" 36 #include "code/codeCache.hpp" 37 #include "code/scopeDesc.hpp" 38 #include "compiler/compileBroker.hpp" 39 #include "compiler/compileTask.hpp" 40 #include "compiler/compilerThread.hpp" 41 #include "gc/shared/barrierSet.hpp" 42 #include "gc/shared/collectedHeap.hpp" 43 #include "gc/shared/gcId.hpp" 44 #include "gc/shared/gcLocker.inline.hpp" 45 #include "gc/shared/gcVMOperations.hpp" 46 #include "gc/shared/oopStorage.hpp" 47 #include "gc/shared/oopStorageSet.hpp" 48 #include "gc/shared/stringdedup/stringDedup.hpp" 49 #include "gc/shared/tlab_globals.hpp" 50 #include "interpreter/interpreter.hpp" 51 #include "interpreter/linkResolver.hpp" 52 #include "interpreter/oopMapCache.hpp" 53 #include "jfr/jfrEvents.hpp" 54 #include "jvmtifiles/jvmtiEnv.hpp" 55 #include "logging/log.hpp" 56 #include "logging/logAsyncWriter.hpp" 57 #include "logging/logConfiguration.hpp" 58 #include "logging/logStream.hpp" 59 #include "memory/allocation.inline.hpp" 60 #include "memory/iterator.hpp" 61 #include "memory/oopFactory.hpp" 62 #include "memory/resourceArea.hpp" 63 #include "memory/universe.hpp" 64 #include "oops/access.inline.hpp" 65 #include "oops/instanceKlass.hpp" 66 #include "oops/klass.inline.hpp" 67 #include "oops/objArrayOop.hpp" 68 #include "oops/oop.inline.hpp" 69 #include "oops/oopHandle.inline.hpp" 70 #include "oops/symbol.hpp" 71 #include "oops/typeArrayOop.inline.hpp" 72 #include "oops/verifyOopClosure.hpp" 73 #include "prims/jvm_misc.hpp" 74 #include "prims/jvmtiDeferredUpdates.hpp" 75 #include "prims/jvmtiExport.hpp" 76 #include "prims/jvmtiThreadState.hpp" 77 #include "runtime/arguments.hpp" 78 #include "runtime/atomic.hpp" 79 #include "runtime/fieldDescriptor.inline.hpp" 80 #include "runtime/flags/jvmFlagLimit.hpp" 81 #include "runtime/deoptimization.hpp" 82 #include "runtime/frame.inline.hpp" 83 #include "runtime/handles.inline.hpp" 84 #include "runtime/handshake.hpp" 85 #include "runtime/init.hpp" 86 #include "runtime/interfaceSupport.inline.hpp" 87 #include "runtime/java.hpp" 88 #include "runtime/javaCalls.hpp" 89 #include "runtime/jniHandles.inline.hpp" 90 #include "runtime/jniPeriodicChecker.hpp" 91 #include "runtime/monitorDeflationThread.hpp" 92 #include "runtime/mutexLocker.hpp" 93 #include "runtime/nonJavaThread.hpp" 94 #include "runtime/objectMonitor.hpp" 95 #include "runtime/orderAccess.hpp" 96 #include "runtime/osThread.hpp" 97 #include "runtime/safepoint.hpp" 98 #include "runtime/safepointMechanism.inline.hpp" 99 #include "runtime/safepointVerifiers.hpp" 100 #include "runtime/serviceThread.hpp" 101 #include "runtime/sharedRuntime.hpp" 102 #include "runtime/stackFrameStream.inline.hpp" 103 #include "runtime/stackWatermarkSet.hpp" 104 #include "runtime/statSampler.hpp" 105 #include "runtime/task.hpp" 106 #include "runtime/thread.inline.hpp" 107 #include "runtime/threadCritical.hpp" 108 #include "runtime/threadSMR.inline.hpp" 109 #include "runtime/threadStatisticalInfo.hpp" 110 #include "runtime/threadWXSetters.inline.hpp" 111 #include "runtime/timer.hpp" 112 #include "runtime/timerTrace.hpp" 113 #include "runtime/vframe.inline.hpp" 114 #include "runtime/vframeArray.hpp" 115 #include "runtime/vframe_hp.hpp" 116 #include "runtime/vmThread.hpp" 117 #include "runtime/vmOperations.hpp" 118 #include "runtime/vm_version.hpp" 119 #include "services/attachListener.hpp" 120 #include "services/heapObjectStatistics.hpp" 121 #include "services/management.hpp" 122 #include "services/memTracker.hpp" 123 #include "services/threadService.hpp" 124 #include "utilities/align.hpp" 125 #include "utilities/copy.hpp" 126 #include "utilities/defaultStream.hpp" 127 #include "utilities/dtrace.hpp" 128 #include "utilities/events.hpp" 129 #include "utilities/macros.hpp" 130 #include "utilities/preserveException.hpp" 131 #include "utilities/spinYield.hpp" 132 #include "utilities/vmError.hpp" 133 #if INCLUDE_JVMCI 134 #include "jvmci/jvmci.hpp" 135 #include "jvmci/jvmciEnv.hpp" 136 #endif 137 #ifdef COMPILER1 138 #include "c1/c1_Compiler.hpp" 139 #endif 140 #ifdef COMPILER2 141 #include "opto/c2compiler.hpp" 142 #include "opto/idealGraphPrinter.hpp" 143 #endif 144 #if INCLUDE_RTM_OPT 145 #include "runtime/rtmLocking.hpp" 146 #endif 147 #if INCLUDE_JFR 148 #include "jfr/jfr.hpp" 149 #endif 150 151 // Initialization after module runtime initialization 152 void universe_post_module_init(); // must happen after call_initPhase2 153 154 #ifdef DTRACE_ENABLED 155 156 // Only bother with this argument setup if dtrace is available 157 158 #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_START 159 #define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_STOP 160 161 #define DTRACE_THREAD_PROBE(probe, javathread) \ 162 { \ 163 ResourceMark rm(this); \ 164 int len = 0; \ 165 const char* name = (javathread)->name(); \ 166 len = strlen(name); \ 167 HOTSPOT_THREAD_PROBE_##probe(/* probe = start, stop */ \ 168 (char *) name, len, \ 169 java_lang_Thread::thread_id((javathread)->threadObj()), \ 170 (uintptr_t) (javathread)->osthread()->thread_id(), \ 171 java_lang_Thread::is_daemon((javathread)->threadObj())); \ 172 } 173 174 #else // ndef DTRACE_ENABLED 175 176 #define DTRACE_THREAD_PROBE(probe, javathread) 177 178 #endif // ndef DTRACE_ENABLED 179 180 #ifndef USE_LIBRARY_BASED_TLS_ONLY 181 // Current thread is maintained as a thread-local variable 182 THREAD_LOCAL Thread* Thread::_thr_current = NULL; 183 #endif 184 185 // ======= Thread ======== 186 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) { 187 return throw_excpt ? AllocateHeap(size, flags, CURRENT_PC) 188 : AllocateHeap(size, flags, CURRENT_PC, AllocFailStrategy::RETURN_NULL); 189 } 190 191 void Thread::operator delete(void* p) { 192 FreeHeap(p); 193 } 194 195 void JavaThread::smr_delete() { 196 if (_on_thread_list) { 197 ThreadsSMRSupport::smr_delete(this); 198 } else { 199 delete this; 200 } 201 } 202 203 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread, 204 // JavaThread 205 206 DEBUG_ONLY(Thread* Thread::_starting_thread = NULL;) 207 208 Thread::Thread() { 209 210 DEBUG_ONLY(_run_state = PRE_CALL_RUN;) 211 212 // stack and get_thread 213 set_stack_base(NULL); 214 set_stack_size(0); 215 set_lgrp_id(-1); 216 DEBUG_ONLY(clear_suspendible_thread();) 217 218 // allocated data structures 219 set_osthread(NULL); 220 set_resource_area(new (mtThread)ResourceArea()); 221 DEBUG_ONLY(_current_resource_mark = NULL;) 222 set_handle_area(new (mtThread) HandleArea(NULL)); 223 set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(30, mtClass)); 224 set_last_handle_mark(NULL); 225 DEBUG_ONLY(_missed_ic_stub_refill_verifier = NULL); 226 227 // Initial value of zero ==> never claimed. 228 _threads_do_token = 0; 229 _threads_hazard_ptr = NULL; 230 _threads_list_ptr = NULL; 231 _nested_threads_hazard_ptr_cnt = 0; 232 _rcu_counter = 0; 233 234 // the handle mark links itself to last_handle_mark 235 new HandleMark(this); 236 237 // plain initialization 238 debug_only(_owned_locks = NULL;) 239 NOT_PRODUCT(_skip_gcalot = false;) 240 _jvmti_env_iteration_count = 0; 241 set_allocated_bytes(0); 242 _current_pending_raw_monitor = NULL; 243 244 // thread-specific hashCode stream generator state - Marsaglia shift-xor form 245 _hashStateX = os::random(); 246 _hashStateY = 842502087; 247 _hashStateZ = 0x8767; // (int)(3579807591LL & 0xffff) ; 248 _hashStateW = 273326509; 249 250 // Many of the following fields are effectively final - immutable 251 // Note that nascent threads can't use the Native Monitor-Mutex 252 // construct until the _MutexEvent is initialized ... 253 // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents 254 // we might instead use a stack of ParkEvents that we could provision on-demand. 255 // The stack would act as a cache to avoid calls to ParkEvent::Allocate() 256 // and ::Release() 257 _ParkEvent = ParkEvent::Allocate(this); 258 259 #ifdef CHECK_UNHANDLED_OOPS 260 if (CheckUnhandledOops) { 261 _unhandled_oops = new UnhandledOops(this); 262 } 263 #endif // CHECK_UNHANDLED_OOPS 264 265 // Notify the barrier set that a thread is being created. The initial 266 // thread is created before the barrier set is available. The call to 267 // BarrierSet::on_thread_create() for this thread is therefore deferred 268 // to BarrierSet::set_barrier_set(). 269 BarrierSet* const barrier_set = BarrierSet::barrier_set(); 270 if (barrier_set != NULL) { 271 barrier_set->on_thread_create(this); 272 } else { 273 // Only the main thread should be created before the barrier set 274 // and that happens just before Thread::current is set. No other thread 275 // can attach as the VM is not created yet, so they can't execute this code. 276 // If the main thread creates other threads before the barrier set that is an error. 277 assert(Thread::current_or_null() == NULL, "creating thread before barrier set"); 278 } 279 280 MACOS_AARCH64_ONLY(DEBUG_ONLY(_wx_init = false)); 281 } 282 283 void Thread::initialize_tlab() { 284 if (UseTLAB) { 285 tlab().initialize(); 286 } 287 } 288 289 void Thread::initialize_thread_current() { 290 #ifndef USE_LIBRARY_BASED_TLS_ONLY 291 assert(_thr_current == NULL, "Thread::current already initialized"); 292 _thr_current = this; 293 #endif 294 assert(ThreadLocalStorage::thread() == NULL, "ThreadLocalStorage::thread already initialized"); 295 ThreadLocalStorage::set_thread(this); 296 assert(Thread::current() == ThreadLocalStorage::thread(), "TLS mismatch!"); 297 } 298 299 void Thread::clear_thread_current() { 300 assert(Thread::current() == ThreadLocalStorage::thread(), "TLS mismatch!"); 301 #ifndef USE_LIBRARY_BASED_TLS_ONLY 302 _thr_current = NULL; 303 #endif 304 ThreadLocalStorage::set_thread(NULL); 305 } 306 307 void Thread::record_stack_base_and_size() { 308 // Note: at this point, Thread object is not yet initialized. Do not rely on 309 // any members being initialized. Do not rely on Thread::current() being set. 310 // If possible, refrain from doing anything which may crash or assert since 311 // quite probably those crash dumps will be useless. 312 set_stack_base(os::current_stack_base()); 313 set_stack_size(os::current_stack_size()); 314 315 // Set stack limits after thread is initialized. 316 if (is_Java_thread()) { 317 JavaThread::cast(this)->stack_overflow_state()->initialize(stack_base(), stack_end()); 318 } 319 } 320 321 void Thread::register_thread_stack_with_NMT() { 322 MemTracker::record_thread_stack(stack_end(), stack_size()); 323 } 324 325 void Thread::unregister_thread_stack_with_NMT() { 326 MemTracker::release_thread_stack(stack_end(), stack_size()); 327 } 328 329 void Thread::call_run() { 330 DEBUG_ONLY(_run_state = CALL_RUN;) 331 332 // At this point, Thread object should be fully initialized and 333 // Thread::current() should be set. 334 335 assert(Thread::current_or_null() != NULL, "current thread is unset"); 336 assert(Thread::current_or_null() == this, "current thread is wrong"); 337 338 // Perform common initialization actions 339 340 MACOS_AARCH64_ONLY(this->init_wx()); 341 342 register_thread_stack_with_NMT(); 343 344 JFR_ONLY(Jfr::on_thread_start(this);) 345 346 log_debug(os, thread)("Thread " UINTX_FORMAT " stack dimensions: " 347 PTR_FORMAT "-" PTR_FORMAT " (" SIZE_FORMAT "k).", 348 os::current_thread_id(), p2i(stack_end()), 349 p2i(stack_base()), stack_size()/1024); 350 351 // Perform <ChildClass> initialization actions 352 DEBUG_ONLY(_run_state = PRE_RUN;) 353 this->pre_run(); 354 355 // Invoke <ChildClass>::run() 356 DEBUG_ONLY(_run_state = RUN;) 357 this->run(); 358 // Returned from <ChildClass>::run(). Thread finished. 359 360 // Perform common tear-down actions 361 362 assert(Thread::current_or_null() != NULL, "current thread is unset"); 363 assert(Thread::current_or_null() == this, "current thread is wrong"); 364 365 // Perform <ChildClass> tear-down actions 366 DEBUG_ONLY(_run_state = POST_RUN;) 367 this->post_run(); 368 369 // Note: at this point the thread object may already have deleted itself, 370 // so from here on do not dereference *this*. Not all thread types currently 371 // delete themselves when they terminate. But no thread should ever be deleted 372 // asynchronously with respect to its termination - that is what _run_state can 373 // be used to check. 374 375 assert(Thread::current_or_null() == NULL, "current thread still present"); 376 } 377 378 Thread::~Thread() { 379 380 // Attached threads will remain in PRE_CALL_RUN, as will threads that don't actually 381 // get started due to errors etc. Any active thread should at least reach post_run 382 // before it is deleted (usually in post_run()). 383 assert(_run_state == PRE_CALL_RUN || 384 _run_state == POST_RUN, "Active Thread deleted before post_run(): " 385 "_run_state=%d", (int)_run_state); 386 387 // Notify the barrier set that a thread is being destroyed. Note that a barrier 388 // set might not be available if we encountered errors during bootstrapping. 389 BarrierSet* const barrier_set = BarrierSet::barrier_set(); 390 if (barrier_set != NULL) { 391 barrier_set->on_thread_destroy(this); 392 } 393 394 // deallocate data structures 395 delete resource_area(); 396 // since the handle marks are using the handle area, we have to deallocated the root 397 // handle mark before deallocating the thread's handle area, 398 assert(last_handle_mark() != NULL, "check we have an element"); 399 delete last_handle_mark(); 400 assert(last_handle_mark() == NULL, "check we have reached the end"); 401 402 ParkEvent::Release(_ParkEvent); 403 // Set to NULL as a termination indicator for has_terminated(). 404 Atomic::store(&_ParkEvent, (ParkEvent*)NULL); 405 406 delete handle_area(); 407 delete metadata_handles(); 408 409 // osthread() can be NULL, if creation of thread failed. 410 if (osthread() != NULL) os::free_thread(osthread()); 411 412 // Clear Thread::current if thread is deleting itself and it has not 413 // already been done. This must be done before the memory is deallocated. 414 // Needed to ensure JNI correctly detects non-attached threads. 415 if (this == Thread::current_or_null()) { 416 Thread::clear_thread_current(); 417 } 418 419 CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();) 420 } 421 422 #ifdef ASSERT 423 // A JavaThread is considered dangling if it not handshake-safe with respect to 424 // the current thread, it is not on a ThreadsList, or not at safepoint. 425 void Thread::check_for_dangling_thread_pointer(Thread *thread) { 426 assert(!thread->is_Java_thread() || 427 JavaThread::cast(thread)->is_handshake_safe_for(Thread::current()) || 428 !JavaThread::cast(thread)->on_thread_list() || 429 SafepointSynchronize::is_at_safepoint() || 430 ThreadsSMRSupport::is_a_protected_JavaThread_with_lock(JavaThread::cast(thread)), 431 "possibility of dangling Thread pointer"); 432 } 433 #endif 434 435 // Is the target JavaThread protected by the calling Thread or by some other 436 // mechanism? 437 // 438 bool Thread::is_JavaThread_protected(const JavaThread* target) { 439 Thread* current_thread = Thread::current(); 440 441 // Do the simplest check first: 442 if (SafepointSynchronize::is_at_safepoint()) { 443 // The target is protected since JavaThreads cannot exit 444 // while we're at a safepoint. 445 return true; 446 } 447 448 // If the target hasn't been started yet then it is trivially 449 // "protected". We assume the caller is the thread that will do 450 // the starting. 451 if (target->osthread() == NULL || target->osthread()->get_state() <= INITIALIZED) { 452 return true; 453 } 454 455 // Now make the simple checks based on who the caller is: 456 if (current_thread == target || Threads_lock->owner() == current_thread) { 457 // Target JavaThread is self or calling thread owns the Threads_lock. 458 // Second check is the same as Threads_lock->owner_is_self(), 459 // but we already have the current thread so check directly. 460 return true; 461 } 462 463 // Check the ThreadsLists associated with the calling thread (if any) 464 // to see if one of them protects the target JavaThread: 465 if (is_JavaThread_protected_by_TLH(target)) { 466 return true; 467 } 468 469 // Use this debug code with -XX:+UseNewCode to diagnose locations that 470 // are missing a ThreadsListHandle or other protection mechanism: 471 // guarantee(!UseNewCode, "current_thread=" INTPTR_FORMAT " is not protecting target=" 472 // INTPTR_FORMAT, p2i(current_thread), p2i(target)); 473 474 // Note: Since 'target' isn't protected by a TLH, the call to 475 // target->is_handshake_safe_for() may crash, but we have debug bits so 476 // we'll be able to figure out what protection mechanism is missing. 477 assert(target->is_handshake_safe_for(current_thread), "JavaThread=" INTPTR_FORMAT 478 " is not protected and not handshake safe.", p2i(target)); 479 480 // The target JavaThread is not protected so it is not safe to query: 481 return false; 482 } 483 484 // Is the target JavaThread protected by a ThreadsListHandle (TLH) associated 485 // with the calling Thread? 486 // 487 bool Thread::is_JavaThread_protected_by_TLH(const JavaThread* target) { 488 Thread* current_thread = Thread::current(); 489 490 // Check the ThreadsLists associated with the calling thread (if any) 491 // to see if one of them protects the target JavaThread: 492 for (SafeThreadsListPtr* stlp = current_thread->_threads_list_ptr; 493 stlp != NULL; stlp = stlp->previous()) { 494 if (stlp->list()->includes(target)) { 495 // The target JavaThread is protected by this ThreadsList: 496 return true; 497 } 498 } 499 500 // The target JavaThread is not protected by a TLH so it is not safe to query: 501 return false; 502 } 503 504 ThreadPriority Thread::get_priority(const Thread* const thread) { 505 ThreadPriority priority; 506 // Can return an error! 507 (void)os::get_priority(thread, priority); 508 assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found"); 509 return priority; 510 } 511 512 void Thread::set_priority(Thread* thread, ThreadPriority priority) { 513 debug_only(check_for_dangling_thread_pointer(thread);) 514 // Can return an error! 515 (void)os::set_priority(thread, priority); 516 } 517 518 519 void Thread::start(Thread* thread) { 520 // Start is different from resume in that its safety is guaranteed by context or 521 // being called from a Java method synchronized on the Thread object. 522 if (thread->is_Java_thread()) { 523 // Initialize the thread state to RUNNABLE before starting this thread. 524 // Can not set it after the thread started because we do not know the 525 // exact thread state at that time. It could be in MONITOR_WAIT or 526 // in SLEEPING or some other state. 527 java_lang_Thread::set_thread_status(JavaThread::cast(thread)->threadObj(), 528 JavaThreadStatus::RUNNABLE); 529 } 530 os::start_thread(thread); 531 } 532 533 // GC Support 534 bool Thread::claim_par_threads_do(uintx claim_token) { 535 uintx token = _threads_do_token; 536 if (token != claim_token) { 537 uintx res = Atomic::cmpxchg(&_threads_do_token, token, claim_token); 538 if (res == token) { 539 return true; 540 } 541 guarantee(res == claim_token, "invariant"); 542 } 543 return false; 544 } 545 546 void Thread::oops_do_no_frames(OopClosure* f, CodeBlobClosure* cf) { 547 // Do oop for ThreadShadow 548 f->do_oop((oop*)&_pending_exception); 549 handle_area()->oops_do(f); 550 } 551 552 // If the caller is a NamedThread, then remember, in the current scope, 553 // the given JavaThread in its _processed_thread field. 554 class RememberProcessedThread: public StackObj { 555 NamedThread* _cur_thr; 556 public: 557 RememberProcessedThread(Thread* thread) { 558 Thread* self = Thread::current(); 559 if (self->is_Named_thread()) { 560 _cur_thr = (NamedThread *)self; 561 assert(_cur_thr->processed_thread() == NULL, "nesting not supported"); 562 _cur_thr->set_processed_thread(thread); 563 } else { 564 _cur_thr = NULL; 565 } 566 } 567 568 ~RememberProcessedThread() { 569 if (_cur_thr) { 570 assert(_cur_thr->processed_thread() != NULL, "nesting not supported"); 571 _cur_thr->set_processed_thread(NULL); 572 } 573 } 574 }; 575 576 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) { 577 // Record JavaThread to GC thread 578 RememberProcessedThread rpt(this); 579 oops_do_no_frames(f, cf); 580 oops_do_frames(f, cf); 581 } 582 583 void Thread::metadata_handles_do(void f(Metadata*)) { 584 // Only walk the Handles in Thread. 585 if (metadata_handles() != NULL) { 586 for (int i = 0; i< metadata_handles()->length(); i++) { 587 f(metadata_handles()->at(i)); 588 } 589 } 590 } 591 592 void Thread::print_on(outputStream* st, bool print_extended_info) const { 593 // get_priority assumes osthread initialized 594 if (osthread() != NULL) { 595 int os_prio; 596 if (os::get_native_priority(this, &os_prio) == OS_OK) { 597 st->print("os_prio=%d ", os_prio); 598 } 599 600 st->print("cpu=%.2fms ", 601 os::thread_cpu_time(const_cast<Thread*>(this), true) / 1000000.0 602 ); 603 st->print("elapsed=%.2fs ", 604 _statistical_info.getElapsedTime() / 1000.0 605 ); 606 if (is_Java_thread() && (PrintExtendedThreadInfo || print_extended_info)) { 607 size_t allocated_bytes = (size_t) const_cast<Thread*>(this)->cooked_allocated_bytes(); 608 st->print("allocated=" SIZE_FORMAT "%s ", 609 byte_size_in_proper_unit(allocated_bytes), 610 proper_unit_for_byte_size(allocated_bytes) 611 ); 612 st->print("defined_classes=" INT64_FORMAT " ", _statistical_info.getDefineClassCount()); 613 } 614 615 st->print("tid=" INTPTR_FORMAT " ", p2i(this)); 616 osthread()->print_on(st); 617 } 618 ThreadsSMRSupport::print_info_on(this, st); 619 st->print(" "); 620 debug_only(if (WizardMode) print_owned_locks_on(st);) 621 } 622 623 void Thread::print() const { print_on(tty); } 624 625 // Thread::print_on_error() is called by fatal error handler. Don't use 626 // any lock or allocate memory. 627 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const { 628 assert(!(is_Compiler_thread() || is_Java_thread()), "Can't call name() here if it allocates"); 629 630 st->print("%s \"%s\"", type_name(), name()); 631 632 OSThread* os_thr = osthread(); 633 if (os_thr != NULL) { 634 if (os_thr->get_state() != ZOMBIE) { 635 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]", 636 p2i(stack_end()), p2i(stack_base())); 637 st->print(" [id=%d]", osthread()->thread_id()); 638 } else { 639 st->print(" terminated"); 640 } 641 } else { 642 st->print(" unknown state (no osThread)"); 643 } 644 ThreadsSMRSupport::print_info_on(this, st); 645 } 646 647 void Thread::print_value_on(outputStream* st) const { 648 if (is_Named_thread()) { 649 st->print(" \"%s\" ", name()); 650 } 651 st->print(INTPTR_FORMAT, p2i(this)); // print address 652 } 653 654 #ifdef ASSERT 655 void Thread::print_owned_locks_on(outputStream* st) const { 656 Mutex* cur = _owned_locks; 657 if (cur == NULL) { 658 st->print(" (no locks) "); 659 } else { 660 st->print_cr(" Locks owned:"); 661 while (cur) { 662 cur->print_on(st); 663 cur = cur->next(); 664 } 665 } 666 } 667 #endif // ASSERT 668 669 // We had to move these methods here, because vm threads get into ObjectSynchronizer::enter 670 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being 671 // used for compilation in the future. If that change is made, the need for these methods 672 // should be revisited, and they should be removed if possible. 673 674 bool Thread::is_lock_owned(address adr) const { 675 return is_in_full_stack(adr); 676 } 677 678 bool Thread::set_as_starting_thread() { 679 assert(_starting_thread == NULL, "already initialized: " 680 "_starting_thread=" INTPTR_FORMAT, p2i(_starting_thread)); 681 // NOTE: this must be called inside the main thread. 682 DEBUG_ONLY(_starting_thread = this;) 683 return os::create_main_thread(JavaThread::cast(this)); 684 } 685 686 static void initialize_class(Symbol* class_name, TRAPS) { 687 Klass* klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK); 688 InstanceKlass::cast(klass)->initialize(CHECK); 689 } 690 691 692 // Creates the initial ThreadGroup 693 static Handle create_initial_thread_group(TRAPS) { 694 Handle system_instance = JavaCalls::construct_new_instance( 695 vmClasses::ThreadGroup_klass(), 696 vmSymbols::void_method_signature(), 697 CHECK_NH); 698 Universe::set_system_thread_group(system_instance()); 699 700 Handle string = java_lang_String::create_from_str("main", CHECK_NH); 701 Handle main_instance = JavaCalls::construct_new_instance( 702 vmClasses::ThreadGroup_klass(), 703 vmSymbols::threadgroup_string_void_signature(), 704 system_instance, 705 string, 706 CHECK_NH); 707 return main_instance; 708 } 709 710 // Creates the initial Thread, and sets it to running. 711 static void create_initial_thread(Handle thread_group, JavaThread* thread, 712 TRAPS) { 713 InstanceKlass* ik = vmClasses::Thread_klass(); 714 assert(ik->is_initialized(), "must be"); 715 instanceHandle thread_oop = ik->allocate_instance_handle(CHECK); 716 717 // Cannot use JavaCalls::construct_new_instance because the java.lang.Thread 718 // constructor calls Thread.current(), which must be set here for the 719 // initial thread. 720 java_lang_Thread::set_thread(thread_oop(), thread); 721 java_lang_Thread::set_priority(thread_oop(), NormPriority); 722 thread->set_threadObj(thread_oop()); 723 724 Handle string = java_lang_String::create_from_str("main", CHECK); 725 726 JavaValue result(T_VOID); 727 JavaCalls::call_special(&result, thread_oop, 728 ik, 729 vmSymbols::object_initializer_name(), 730 vmSymbols::threadgroup_string_void_signature(), 731 thread_group, 732 string, 733 CHECK); 734 735 // Set thread status to running since main thread has 736 // been started and running. 737 java_lang_Thread::set_thread_status(thread_oop(), 738 JavaThreadStatus::RUNNABLE); 739 } 740 741 // Extract version and vendor specific information from 742 // java.lang.VersionProps fields. 743 // Returned char* is allocated in the thread's resource area 744 // so must be copied for permanency. 745 static const char* get_java_version_info(InstanceKlass* ik, 746 Symbol* field_name) { 747 fieldDescriptor fd; 748 bool found = ik != NULL && 749 ik->find_local_field(field_name, 750 vmSymbols::string_signature(), &fd); 751 if (found) { 752 oop name_oop = ik->java_mirror()->obj_field(fd.offset()); 753 if (name_oop == NULL) { 754 return NULL; 755 } 756 const char* name = java_lang_String::as_utf8_string(name_oop); 757 return name; 758 } else { 759 return NULL; 760 } 761 } 762 763 // General purpose hook into Java code, run once when the VM is initialized. 764 // The Java library method itself may be changed independently from the VM. 765 static void call_postVMInitHook(TRAPS) { 766 Klass* klass = SystemDictionary::resolve_or_null(vmSymbols::jdk_internal_vm_PostVMInitHook(), THREAD); 767 if (klass != NULL) { 768 JavaValue result(T_VOID); 769 JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(), 770 vmSymbols::void_method_signature(), 771 CHECK); 772 } 773 } 774 775 // Initialized by VMThread at vm_global_init 776 static OopStorage* _thread_oop_storage = NULL; 777 778 oop JavaThread::threadObj() const { 779 return _threadObj.resolve(); 780 } 781 782 void JavaThread::set_threadObj(oop p) { 783 assert(_thread_oop_storage != NULL, "not yet initialized"); 784 _threadObj = OopHandle(_thread_oop_storage, p); 785 } 786 787 OopStorage* JavaThread::thread_oop_storage() { 788 assert(_thread_oop_storage != NULL, "not yet initialized"); 789 return _thread_oop_storage; 790 } 791 792 void JavaThread::allocate_threadObj(Handle thread_group, const char* thread_name, 793 bool daemon, TRAPS) { 794 assert(thread_group.not_null(), "thread group should be specified"); 795 assert(threadObj() == NULL, "should only create Java thread object once"); 796 797 InstanceKlass* ik = vmClasses::Thread_klass(); 798 assert(ik->is_initialized(), "must be"); 799 instanceHandle thread_oop = ik->allocate_instance_handle(CHECK); 800 801 // We are called from jni_AttachCurrentThread/jni_AttachCurrentThreadAsDaemon. 802 // We cannot use JavaCalls::construct_new_instance because the java.lang.Thread 803 // constructor calls Thread.current(), which must be set here. 804 java_lang_Thread::set_thread(thread_oop(), this); 805 java_lang_Thread::set_priority(thread_oop(), NormPriority); 806 set_threadObj(thread_oop()); 807 808 JavaValue result(T_VOID); 809 if (thread_name != NULL) { 810 Handle name = java_lang_String::create_from_str(thread_name, CHECK); 811 // Thread gets assigned specified name and null target 812 JavaCalls::call_special(&result, 813 thread_oop, 814 ik, 815 vmSymbols::object_initializer_name(), 816 vmSymbols::threadgroup_string_void_signature(), 817 thread_group, 818 name, 819 THREAD); 820 } else { 821 // Thread gets assigned name "Thread-nnn" and null target 822 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument) 823 JavaCalls::call_special(&result, 824 thread_oop, 825 ik, 826 vmSymbols::object_initializer_name(), 827 vmSymbols::threadgroup_runnable_void_signature(), 828 thread_group, 829 Handle(), 830 THREAD); 831 } 832 833 834 if (daemon) { 835 java_lang_Thread::set_daemon(thread_oop()); 836 } 837 838 if (HAS_PENDING_EXCEPTION) { 839 return; 840 } 841 842 Klass* group = vmClasses::ThreadGroup_klass(); 843 Handle threadObj(THREAD, this->threadObj()); 844 845 JavaCalls::call_special(&result, 846 thread_group, 847 group, 848 vmSymbols::add_method_name(), 849 vmSymbols::thread_void_signature(), 850 threadObj, // Arg 1 851 THREAD); 852 } 853 854 // ======= JavaThread ======== 855 856 #if INCLUDE_JVMCI 857 858 jlong* JavaThread::_jvmci_old_thread_counters; 859 860 bool jvmci_counters_include(JavaThread* thread) { 861 return !JVMCICountersExcludeCompiler || !thread->is_Compiler_thread(); 862 } 863 864 void JavaThread::collect_counters(jlong* array, int length) { 865 assert(length == JVMCICounterSize, "wrong value"); 866 for (int i = 0; i < length; i++) { 867 array[i] = _jvmci_old_thread_counters[i]; 868 } 869 for (JavaThread* tp : ThreadsListHandle()) { 870 if (jvmci_counters_include(tp)) { 871 for (int i = 0; i < length; i++) { 872 array[i] += tp->_jvmci_counters[i]; 873 } 874 } 875 } 876 } 877 878 // Attempt to enlarge the array for per thread counters. 879 jlong* resize_counters_array(jlong* old_counters, int current_size, int new_size) { 880 jlong* new_counters = NEW_C_HEAP_ARRAY_RETURN_NULL(jlong, new_size, mtJVMCI); 881 if (new_counters == NULL) { 882 return NULL; 883 } 884 if (old_counters == NULL) { 885 old_counters = new_counters; 886 memset(old_counters, 0, sizeof(jlong) * new_size); 887 } else { 888 for (int i = 0; i < MIN2((int) current_size, new_size); i++) { 889 new_counters[i] = old_counters[i]; 890 } 891 if (new_size > current_size) { 892 memset(new_counters + current_size, 0, sizeof(jlong) * (new_size - current_size)); 893 } 894 FREE_C_HEAP_ARRAY(jlong, old_counters); 895 } 896 return new_counters; 897 } 898 899 // Attempt to enlarge the array for per thread counters. 900 bool JavaThread::resize_counters(int current_size, int new_size) { 901 jlong* new_counters = resize_counters_array(_jvmci_counters, current_size, new_size); 902 if (new_counters == NULL) { 903 return false; 904 } else { 905 _jvmci_counters = new_counters; 906 return true; 907 } 908 } 909 910 class VM_JVMCIResizeCounters : public VM_Operation { 911 private: 912 int _new_size; 913 bool _failed; 914 915 public: 916 VM_JVMCIResizeCounters(int new_size) : _new_size(new_size), _failed(false) { } 917 VMOp_Type type() const { return VMOp_JVMCIResizeCounters; } 918 bool allow_nested_vm_operations() const { return true; } 919 void doit() { 920 // Resize the old thread counters array 921 jlong* new_counters = resize_counters_array(JavaThread::_jvmci_old_thread_counters, JVMCICounterSize, _new_size); 922 if (new_counters == NULL) { 923 _failed = true; 924 return; 925 } else { 926 JavaThread::_jvmci_old_thread_counters = new_counters; 927 } 928 929 // Now resize each threads array 930 for (JavaThread* tp : ThreadsListHandle()) { 931 if (!tp->resize_counters(JVMCICounterSize, _new_size)) { 932 _failed = true; 933 break; 934 } 935 } 936 if (!_failed) { 937 JVMCICounterSize = _new_size; 938 } 939 } 940 941 bool failed() { return _failed; } 942 }; 943 944 bool JavaThread::resize_all_jvmci_counters(int new_size) { 945 VM_JVMCIResizeCounters op(new_size); 946 VMThread::execute(&op); 947 return !op.failed(); 948 } 949 950 #endif // INCLUDE_JVMCI 951 952 #ifdef ASSERT 953 // Checks safepoint allowed and clears unhandled oops at potential safepoints. 954 void JavaThread::check_possible_safepoint() { 955 if (_no_safepoint_count > 0) { 956 print_owned_locks(); 957 assert(false, "Possible safepoint reached by thread that does not allow it"); 958 } 959 #ifdef CHECK_UNHANDLED_OOPS 960 // Clear unhandled oops in JavaThreads so we get a crash right away. 961 clear_unhandled_oops(); 962 #endif // CHECK_UNHANDLED_OOPS 963 964 // Macos/aarch64 should be in the right state for safepoint (e.g. 965 // deoptimization needs WXWrite). Crashes caused by the wrong state rarely 966 // happens in practice, making such issues hard to find and reproduce. 967 #if defined(__APPLE__) && defined(AARCH64) 968 if (AssertWXAtThreadSync) { 969 assert_wx_state(WXWrite); 970 } 971 #endif 972 } 973 974 void JavaThread::check_for_valid_safepoint_state() { 975 // Check NoSafepointVerifier, which is implied by locks taken that can be 976 // shared with the VM thread. This makes sure that no locks with allow_vm_block 977 // are held. 978 check_possible_safepoint(); 979 980 if (thread_state() != _thread_in_vm) { 981 fatal("LEAF method calling lock?"); 982 } 983 984 if (GCALotAtAllSafepoints) { 985 // We could enter a safepoint here and thus have a gc 986 InterfaceSupport::check_gc_alot(); 987 } 988 } 989 #endif // ASSERT 990 991 // A JavaThread is a normal Java thread 992 993 JavaThread::JavaThread() : 994 // Initialize fields 995 996 _on_thread_list(false), 997 DEBUG_ONLY(_java_call_counter(0) COMMA) 998 _entry_point(nullptr), 999 _deopt_mark(nullptr), 1000 _deopt_nmethod(nullptr), 1001 _vframe_array_head(nullptr), 1002 _vframe_array_last(nullptr), 1003 _jvmti_deferred_updates(nullptr), 1004 _callee_target(nullptr), 1005 _vm_result(nullptr), 1006 _vm_result_2(nullptr), 1007 1008 _current_pending_monitor(NULL), 1009 _current_pending_monitor_is_from_java(true), 1010 _current_waiting_monitor(NULL), 1011 _active_handles(NULL), 1012 _free_handle_block(NULL), 1013 _Stalled(0), 1014 1015 _monitor_chunks(nullptr), 1016 1017 _suspend_flags(0), 1018 1019 _thread_state(_thread_new), 1020 _saved_exception_pc(nullptr), 1021 #ifdef ASSERT 1022 _no_safepoint_count(0), 1023 _visited_for_critical_count(false), 1024 #endif 1025 1026 _terminated(_not_terminated), 1027 _in_deopt_handler(0), 1028 _doing_unsafe_access(false), 1029 _do_not_unlock_if_synchronized(false), 1030 _jni_attach_state(_not_attaching_via_jni), 1031 #if INCLUDE_JVMCI 1032 _pending_deoptimization(-1), 1033 _pending_monitorenter(false), 1034 _pending_transfer_to_interpreter(false), 1035 _in_retryable_allocation(false), 1036 _pending_failed_speculation(0), 1037 _jvmci{nullptr}, 1038 _libjvmci_runtime(nullptr), 1039 _jvmci_counters(nullptr), 1040 _jvmci_reserved0(0), 1041 _jvmci_reserved1(0), 1042 _jvmci_reserved_oop0(nullptr), 1043 #endif // INCLUDE_JVMCI 1044 1045 _exception_oop(oop()), 1046 _exception_pc(0), 1047 _exception_handler_pc(0), 1048 _is_method_handle_return(0), 1049 1050 _jni_active_critical(0), 1051 _pending_jni_exception_check_fn(nullptr), 1052 _depth_first_number(0), 1053 1054 // JVMTI PopFrame support 1055 _popframe_condition(popframe_inactive), 1056 _frames_to_pop_failed_realloc(0), 1057 1058 _handshake(this), 1059 1060 _popframe_preserved_args(nullptr), 1061 _popframe_preserved_args_size(0), 1062 1063 _jvmti_thread_state(nullptr), 1064 _interp_only_mode(0), 1065 _should_post_on_exceptions_flag(JNI_FALSE), 1066 _thread_stat(new ThreadStatistics()), 1067 1068 _parker(), 1069 1070 _class_to_be_initialized(nullptr), 1071 1072 _SleepEvent(ParkEvent::Allocate(this)) 1073 { 1074 set_jni_functions(jni_functions()); 1075 1076 #if INCLUDE_JVMCI 1077 assert(_jvmci._implicit_exception_pc == nullptr, "must be"); 1078 if (JVMCICounterSize > 0) { 1079 resize_counters(0, (int) JVMCICounterSize); 1080 } 1081 #endif // INCLUDE_JVMCI 1082 1083 // Setup safepoint state info for this thread 1084 ThreadSafepointState::create(this); 1085 1086 SafepointMechanism::initialize_header(this); 1087 1088 set_requires_cross_modify_fence(false); 1089 1090 pd_initialize(); 1091 assert(deferred_card_mark().is_empty(), "Default MemRegion ctor"); 1092 } 1093 1094 JavaThread::JavaThread(bool is_attaching_via_jni) : JavaThread() { 1095 if (is_attaching_via_jni) { 1096 _jni_attach_state = _attaching_via_jni; 1097 } 1098 } 1099 1100 1101 // interrupt support 1102 1103 void JavaThread::interrupt() { 1104 // All callers should have 'this' thread protected by a 1105 // ThreadsListHandle so that it cannot terminate and deallocate 1106 // itself. 1107 debug_only(check_for_dangling_thread_pointer(this);) 1108 1109 // For Windows _interrupt_event 1110 WINDOWS_ONLY(osthread()->set_interrupted(true);) 1111 1112 // For Thread.sleep 1113 _SleepEvent->unpark(); 1114 1115 // For JSR166 LockSupport.park 1116 parker()->unpark(); 1117 1118 // For ObjectMonitor and JvmtiRawMonitor 1119 _ParkEvent->unpark(); 1120 } 1121 1122 1123 bool JavaThread::is_interrupted(bool clear_interrupted) { 1124 debug_only(check_for_dangling_thread_pointer(this);) 1125 1126 if (_threadObj.peek() == NULL) { 1127 // If there is no j.l.Thread then it is impossible to have 1128 // been interrupted. We can find NULL during VM initialization 1129 // or when a JNI thread is still in the process of attaching. 1130 // In such cases this must be the current thread. 1131 assert(this == Thread::current(), "invariant"); 1132 return false; 1133 } 1134 1135 bool interrupted = java_lang_Thread::interrupted(threadObj()); 1136 1137 // NOTE that since there is no "lock" around the interrupt and 1138 // is_interrupted operations, there is the possibility that the 1139 // interrupted flag will be "false" but that the 1140 // low-level events will be in the signaled state. This is 1141 // intentional. The effect of this is that Object.wait() and 1142 // LockSupport.park() will appear to have a spurious wakeup, which 1143 // is allowed and not harmful, and the possibility is so rare that 1144 // it is not worth the added complexity to add yet another lock. 1145 // For the sleep event an explicit reset is performed on entry 1146 // to JavaThread::sleep, so there is no early return. It has also been 1147 // recommended not to put the interrupted flag into the "event" 1148 // structure because it hides the issue. 1149 // Also, because there is no lock, we must only clear the interrupt 1150 // state if we are going to report that we were interrupted; otherwise 1151 // an interrupt that happens just after we read the field would be lost. 1152 if (interrupted && clear_interrupted) { 1153 assert(this == Thread::current(), "only the current thread can clear"); 1154 java_lang_Thread::set_interrupted(threadObj(), false); 1155 WINDOWS_ONLY(osthread()->set_interrupted(false);) 1156 } 1157 1158 return interrupted; 1159 } 1160 1161 void JavaThread::block_if_vm_exited() { 1162 if (_terminated == _vm_exited) { 1163 // _vm_exited is set at safepoint, and Threads_lock is never released 1164 // we will block here forever. 1165 // Here we can be doing a jump from a safe state to an unsafe state without 1166 // proper transition, but it happens after the final safepoint has begun. 1167 set_thread_state(_thread_in_vm); 1168 Threads_lock->lock(); 1169 ShouldNotReachHere(); 1170 } 1171 } 1172 1173 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : JavaThread() { 1174 _jni_attach_state = _not_attaching_via_jni; 1175 set_entry_point(entry_point); 1176 // Create the native thread itself. 1177 // %note runtime_23 1178 os::ThreadType thr_type = os::java_thread; 1179 thr_type = entry_point == &CompilerThread::thread_entry ? os::compiler_thread : 1180 os::java_thread; 1181 os::create_thread(this, thr_type, stack_sz); 1182 // The _osthread may be NULL here because we ran out of memory (too many threads active). 1183 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller 1184 // may hold a lock and all locks must be unlocked before throwing the exception (throwing 1185 // the exception consists of creating the exception object & initializing it, initialization 1186 // will leave the VM via a JavaCall and then all locks must be unlocked). 1187 // 1188 // The thread is still suspended when we reach here. Thread must be explicit started 1189 // by creator! Furthermore, the thread must also explicitly be added to the Threads list 1190 // by calling Threads:add. The reason why this is not done here, is because the thread 1191 // object must be fully initialized (take a look at JVM_Start) 1192 } 1193 1194 JavaThread::~JavaThread() { 1195 1196 // Ask ServiceThread to release the threadObj OopHandle 1197 ServiceThread::add_oop_handle_release(_threadObj); 1198 1199 // Return the sleep event to the free list 1200 ParkEvent::Release(_SleepEvent); 1201 _SleepEvent = NULL; 1202 1203 // Free any remaining previous UnrollBlock 1204 vframeArray* old_array = vframe_array_last(); 1205 1206 if (old_array != NULL) { 1207 Deoptimization::UnrollBlock* old_info = old_array->unroll_block(); 1208 old_array->set_unroll_block(NULL); 1209 delete old_info; 1210 delete old_array; 1211 } 1212 1213 JvmtiDeferredUpdates* updates = deferred_updates(); 1214 if (updates != NULL) { 1215 // This can only happen if thread is destroyed before deoptimization occurs. 1216 assert(updates->count() > 0, "Updates holder not deleted"); 1217 // free deferred updates. 1218 delete updates; 1219 set_deferred_updates(NULL); 1220 } 1221 1222 // All Java related clean up happens in exit 1223 ThreadSafepointState::destroy(this); 1224 if (_thread_stat != NULL) delete _thread_stat; 1225 1226 #if INCLUDE_JVMCI 1227 if (JVMCICounterSize > 0) { 1228 FREE_C_HEAP_ARRAY(jlong, _jvmci_counters); 1229 } 1230 #endif // INCLUDE_JVMCI 1231 } 1232 1233 1234 // First JavaThread specific code executed by a new Java thread. 1235 void JavaThread::pre_run() { 1236 // empty - see comments in run() 1237 } 1238 1239 // The main routine called by a new Java thread. This isn't overridden 1240 // by subclasses, instead different subclasses define a different "entry_point" 1241 // which defines the actual logic for that kind of thread. 1242 void JavaThread::run() { 1243 // initialize thread-local alloc buffer related fields 1244 initialize_tlab(); 1245 1246 _stack_overflow_state.create_stack_guard_pages(); 1247 1248 cache_global_variables(); 1249 1250 // Thread is now sufficiently initialized to be handled by the safepoint code as being 1251 // in the VM. Change thread state from _thread_new to _thread_in_vm 1252 assert(this->thread_state() == _thread_new, "wrong thread state"); 1253 set_thread_state(_thread_in_vm); 1254 1255 // Before a thread is on the threads list it is always safe, so after leaving the 1256 // _thread_new we should emit a instruction barrier. The distance to modified code 1257 // from here is probably far enough, but this is consistent and safe. 1258 OrderAccess::cross_modify_fence(); 1259 1260 assert(JavaThread::current() == this, "sanity check"); 1261 assert(!Thread::current()->owns_locks(), "sanity check"); 1262 1263 DTRACE_THREAD_PROBE(start, this); 1264 1265 // This operation might block. We call that after all safepoint checks for a new thread has 1266 // been completed. 1267 set_active_handles(JNIHandleBlock::allocate_block()); 1268 1269 if (JvmtiExport::should_post_thread_life()) { 1270 JvmtiExport::post_thread_start(this); 1271 1272 } 1273 1274 // We call another function to do the rest so we are sure that the stack addresses used 1275 // from there will be lower than the stack base just computed. 1276 thread_main_inner(); 1277 } 1278 1279 void JavaThread::thread_main_inner() { 1280 assert(JavaThread::current() == this, "sanity check"); 1281 assert(_threadObj.peek() != NULL, "just checking"); 1282 1283 // Execute thread entry point unless this thread has a pending exception 1284 // or has been stopped before starting. 1285 // Note: Due to JVM_StopThread we can have pending exceptions already! 1286 if (!this->has_pending_exception() && 1287 !java_lang_Thread::is_stillborn(this->threadObj())) { 1288 { 1289 ResourceMark rm(this); 1290 this->set_native_thread_name(this->name()); 1291 } 1292 HandleMark hm(this); 1293 this->entry_point()(this, this); 1294 } 1295 1296 DTRACE_THREAD_PROBE(stop, this); 1297 1298 // Cleanup is handled in post_run() 1299 } 1300 1301 // Shared teardown for all JavaThreads 1302 void JavaThread::post_run() { 1303 this->exit(false); 1304 this->unregister_thread_stack_with_NMT(); 1305 // Defer deletion to here to ensure 'this' is still referenceable in call_run 1306 // for any shared tear-down. 1307 this->smr_delete(); 1308 } 1309 1310 static void ensure_join(JavaThread* thread) { 1311 // We do not need to grab the Threads_lock, since we are operating on ourself. 1312 Handle threadObj(thread, thread->threadObj()); 1313 assert(threadObj.not_null(), "java thread object must exist"); 1314 ObjectLocker lock(threadObj, thread); 1315 // Ignore pending exception (ThreadDeath), since we are exiting anyway 1316 thread->clear_pending_exception(); 1317 // Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED. 1318 java_lang_Thread::set_thread_status(threadObj(), JavaThreadStatus::TERMINATED); 1319 // Clear the native thread instance - this makes isAlive return false and allows the join() 1320 // to complete once we've done the notify_all below 1321 java_lang_Thread::set_thread(threadObj(), NULL); 1322 lock.notify_all(thread); 1323 // Ignore pending exception (ThreadDeath), since we are exiting anyway 1324 thread->clear_pending_exception(); 1325 } 1326 1327 static bool is_daemon(oop threadObj) { 1328 return (threadObj != NULL && java_lang_Thread::is_daemon(threadObj)); 1329 } 1330 1331 // For any new cleanup additions, please check to see if they need to be applied to 1332 // cleanup_failed_attach_current_thread as well. 1333 void JavaThread::exit(bool destroy_vm, ExitType exit_type) { 1334 assert(this == JavaThread::current(), "thread consistency check"); 1335 1336 elapsedTimer _timer_exit_phase1; 1337 elapsedTimer _timer_exit_phase2; 1338 elapsedTimer _timer_exit_phase3; 1339 elapsedTimer _timer_exit_phase4; 1340 1341 if (log_is_enabled(Debug, os, thread, timer)) { 1342 _timer_exit_phase1.start(); 1343 } 1344 1345 HandleMark hm(this); 1346 Handle uncaught_exception(this, this->pending_exception()); 1347 this->clear_pending_exception(); 1348 Handle threadObj(this, this->threadObj()); 1349 assert(threadObj.not_null(), "Java thread object should be created"); 1350 1351 if (!destroy_vm) { 1352 if (uncaught_exception.not_null()) { 1353 EXCEPTION_MARK; 1354 // Call method Thread.dispatchUncaughtException(). 1355 Klass* thread_klass = vmClasses::Thread_klass(); 1356 JavaValue result(T_VOID); 1357 JavaCalls::call_virtual(&result, 1358 threadObj, thread_klass, 1359 vmSymbols::dispatchUncaughtException_name(), 1360 vmSymbols::throwable_void_signature(), 1361 uncaught_exception, 1362 THREAD); 1363 if (HAS_PENDING_EXCEPTION) { 1364 ResourceMark rm(this); 1365 jio_fprintf(defaultStream::error_stream(), 1366 "\nException: %s thrown from the UncaughtExceptionHandler" 1367 " in thread \"%s\"\n", 1368 pending_exception()->klass()->external_name(), 1369 name()); 1370 CLEAR_PENDING_EXCEPTION; 1371 } 1372 } 1373 1374 if (!is_Compiler_thread()) { 1375 // We have finished executing user-defined Java code and now have to do the 1376 // implementation specific clean-up by calling Thread.exit(). We prevent any 1377 // asynchronous exceptions from being delivered while in Thread.exit() 1378 // to ensure the clean-up is not corrupted. 1379 NoAsyncExceptionDeliveryMark _no_async(this); 1380 1381 EXCEPTION_MARK; 1382 JavaValue result(T_VOID); 1383 Klass* thread_klass = vmClasses::Thread_klass(); 1384 JavaCalls::call_virtual(&result, 1385 threadObj, thread_klass, 1386 vmSymbols::exit_method_name(), 1387 vmSymbols::void_method_signature(), 1388 THREAD); 1389 CLEAR_PENDING_EXCEPTION; 1390 } 1391 1392 // notify JVMTI 1393 if (JvmtiExport::should_post_thread_life()) { 1394 JvmtiExport::post_thread_end(this); 1395 } 1396 1397 // The careful dance between thread suspension and exit is handled here. 1398 // Since we are in thread_in_vm state and suspension is done with handshakes, 1399 // we can just put in the exiting state and it will be correctly handled. 1400 set_terminated(_thread_exiting); 1401 1402 ThreadService::current_thread_exiting(this, is_daemon(threadObj())); 1403 } else { 1404 assert(!is_terminated() && !is_exiting(), "must not be exiting"); 1405 // before_exit() has already posted JVMTI THREAD_END events 1406 } 1407 1408 if (log_is_enabled(Debug, os, thread, timer)) { 1409 _timer_exit_phase1.stop(); 1410 _timer_exit_phase2.start(); 1411 } 1412 1413 // Capture daemon status before the thread is marked as terminated. 1414 bool daemon = is_daemon(threadObj()); 1415 1416 // Notify waiters on thread object. This has to be done after exit() is called 1417 // on the thread (if the thread is the last thread in a daemon ThreadGroup the 1418 // group should have the destroyed bit set before waiters are notified). 1419 ensure_join(this); 1420 assert(!this->has_pending_exception(), "ensure_join should have cleared"); 1421 1422 if (log_is_enabled(Debug, os, thread, timer)) { 1423 _timer_exit_phase2.stop(); 1424 _timer_exit_phase3.start(); 1425 } 1426 // 6282335 JNI DetachCurrentThread spec states that all Java monitors 1427 // held by this thread must be released. The spec does not distinguish 1428 // between JNI-acquired and regular Java monitors. We can only see 1429 // regular Java monitors here if monitor enter-exit matching is broken. 1430 // 1431 // ensure_join() ignores IllegalThreadStateExceptions, and so does 1432 // ObjectSynchronizer::release_monitors_owned_by_thread(). 1433 if (exit_type == jni_detach) { 1434 // Sanity check even though JNI DetachCurrentThread() would have 1435 // returned JNI_ERR if there was a Java frame. JavaThread exit 1436 // should be done executing Java code by the time we get here. 1437 assert(!this->has_last_Java_frame(), 1438 "should not have a Java frame when detaching or exiting"); 1439 ObjectSynchronizer::release_monitors_owned_by_thread(this); 1440 assert(!this->has_pending_exception(), "release_monitors should have cleared"); 1441 } 1442 1443 // These things needs to be done while we are still a Java Thread. Make sure that thread 1444 // is in a consistent state, in case GC happens 1445 JFR_ONLY(Jfr::on_thread_exit(this);) 1446 1447 if (active_handles() != NULL) { 1448 JNIHandleBlock* block = active_handles(); 1449 set_active_handles(NULL); 1450 JNIHandleBlock::release_block(block); 1451 } 1452 1453 if (free_handle_block() != NULL) { 1454 JNIHandleBlock* block = free_handle_block(); 1455 set_free_handle_block(NULL); 1456 JNIHandleBlock::release_block(block); 1457 } 1458 1459 // These have to be removed while this is still a valid thread. 1460 _stack_overflow_state.remove_stack_guard_pages(); 1461 1462 if (UseTLAB) { 1463 tlab().retire(); 1464 } 1465 1466 if (JvmtiEnv::environments_might_exist()) { 1467 JvmtiExport::cleanup_thread(this); 1468 } 1469 1470 // We need to cache the thread name for logging purposes below as once 1471 // we have called on_thread_detach this thread must not access any oops. 1472 char* thread_name = NULL; 1473 if (log_is_enabled(Debug, os, thread, timer)) { 1474 ResourceMark rm(this); 1475 thread_name = os::strdup(name()); 1476 } 1477 1478 log_info(os, thread)("JavaThread %s (tid: " UINTX_FORMAT ").", 1479 exit_type == JavaThread::normal_exit ? "exiting" : "detaching", 1480 os::current_thread_id()); 1481 1482 if (log_is_enabled(Debug, os, thread, timer)) { 1483 _timer_exit_phase3.stop(); 1484 _timer_exit_phase4.start(); 1485 } 1486 1487 #if INCLUDE_JVMCI 1488 if (JVMCICounterSize > 0) { 1489 if (jvmci_counters_include(this)) { 1490 for (int i = 0; i < JVMCICounterSize; i++) { 1491 _jvmci_old_thread_counters[i] += _jvmci_counters[i]; 1492 } 1493 } 1494 } 1495 #endif // INCLUDE_JVMCI 1496 1497 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread 1498 Threads::remove(this, daemon); 1499 1500 if (log_is_enabled(Debug, os, thread, timer)) { 1501 _timer_exit_phase4.stop(); 1502 log_debug(os, thread, timer)("name='%s'" 1503 ", exit-phase1=" JLONG_FORMAT 1504 ", exit-phase2=" JLONG_FORMAT 1505 ", exit-phase3=" JLONG_FORMAT 1506 ", exit-phase4=" JLONG_FORMAT, 1507 thread_name, 1508 _timer_exit_phase1.milliseconds(), 1509 _timer_exit_phase2.milliseconds(), 1510 _timer_exit_phase3.milliseconds(), 1511 _timer_exit_phase4.milliseconds()); 1512 os::free(thread_name); 1513 } 1514 } 1515 1516 void JavaThread::cleanup_failed_attach_current_thread(bool is_daemon) { 1517 if (active_handles() != NULL) { 1518 JNIHandleBlock* block = active_handles(); 1519 set_active_handles(NULL); 1520 JNIHandleBlock::release_block(block); 1521 } 1522 1523 if (free_handle_block() != NULL) { 1524 JNIHandleBlock* block = free_handle_block(); 1525 set_free_handle_block(NULL); 1526 JNIHandleBlock::release_block(block); 1527 } 1528 1529 // These have to be removed while this is still a valid thread. 1530 _stack_overflow_state.remove_stack_guard_pages(); 1531 1532 if (UseTLAB) { 1533 tlab().retire(); 1534 } 1535 1536 Threads::remove(this, is_daemon); 1537 this->smr_delete(); 1538 } 1539 1540 JavaThread* JavaThread::active() { 1541 Thread* thread = Thread::current(); 1542 if (thread->is_Java_thread()) { 1543 return JavaThread::cast(thread); 1544 } else { 1545 assert(thread->is_VM_thread(), "this must be a vm thread"); 1546 VM_Operation* op = ((VMThread*) thread)->vm_operation(); 1547 JavaThread *ret = op == NULL ? NULL : JavaThread::cast(op->calling_thread()); 1548 return ret; 1549 } 1550 } 1551 1552 bool JavaThread::is_lock_owned(address adr) const { 1553 if (Thread::is_lock_owned(adr)) return true; 1554 1555 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { 1556 if (chunk->contains(adr)) return true; 1557 } 1558 1559 return false; 1560 } 1561 1562 oop JavaThread::exception_oop() const { 1563 return Atomic::load(&_exception_oop); 1564 } 1565 1566 void JavaThread::set_exception_oop(oop o) { 1567 Atomic::store(&_exception_oop, o); 1568 } 1569 1570 void JavaThread::add_monitor_chunk(MonitorChunk* chunk) { 1571 chunk->set_next(monitor_chunks()); 1572 set_monitor_chunks(chunk); 1573 } 1574 1575 void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) { 1576 guarantee(monitor_chunks() != NULL, "must be non empty"); 1577 if (monitor_chunks() == chunk) { 1578 set_monitor_chunks(chunk->next()); 1579 } else { 1580 MonitorChunk* prev = monitor_chunks(); 1581 while (prev->next() != chunk) prev = prev->next(); 1582 prev->set_next(chunk->next()); 1583 } 1584 } 1585 1586 void JavaThread::handle_special_runtime_exit_condition() { 1587 if (is_obj_deopt_suspend()) { 1588 frame_anchor()->make_walkable(this); 1589 wait_for_object_deoptimization(); 1590 } 1591 JFR_ONLY(SUSPEND_THREAD_CONDITIONAL(this);) 1592 } 1593 1594 1595 // Asynchronous exceptions support 1596 // 1597 void JavaThread::handle_async_exception(oop java_throwable) { 1598 assert(java_throwable != NULL, "should have an _async_exception to throw"); 1599 assert(!is_at_poll_safepoint(), "should have never called this method"); 1600 1601 if (has_last_Java_frame()) { 1602 frame f = last_frame(); 1603 if (f.is_runtime_frame()) { 1604 // If the topmost frame is a runtime stub, then we are calling into 1605 // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..) 1606 // must deoptimize the caller before continuing, as the compiled exception 1607 // handler table may not be valid. 1608 RegisterMap reg_map(this, false); 1609 frame compiled_frame = f.sender(®_map); 1610 if (!StressCompiledExceptionHandlers && compiled_frame.can_be_deoptimized()) { 1611 Deoptimization::deoptimize(this, compiled_frame); 1612 } 1613 } 1614 } 1615 1616 // Only overwrite an already pending exception if it is not a ThreadDeath. 1617 if (!has_pending_exception() || !pending_exception()->is_a(vmClasses::ThreadDeath_klass())) { 1618 1619 // We cannot call Exceptions::_throw(...) here because we cannot block 1620 set_pending_exception(java_throwable, __FILE__, __LINE__); 1621 1622 LogTarget(Info, exceptions) lt; 1623 if (lt.is_enabled()) { 1624 ResourceMark rm; 1625 LogStream ls(lt); 1626 ls.print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", p2i(this)); 1627 if (has_last_Java_frame()) { 1628 frame f = last_frame(); 1629 ls.print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", p2i(f.pc()), p2i(f.sp())); 1630 } 1631 ls.print_cr(" of type: %s", java_throwable->klass()->external_name()); 1632 } 1633 } 1634 } 1635 1636 void JavaThread::install_async_exception(AsyncExceptionHandshake* aeh) { 1637 // Do not throw asynchronous exceptions against the compiler thread. 1638 if (!can_call_java()) { 1639 delete aeh; 1640 return; 1641 } 1642 1643 // Don't install a new pending async exception if there is already 1644 // a pending ThreadDeath one. Just interrupt thread from potential 1645 // wait()/sleep()/park() and return. 1646 if (has_async_exception_condition(true /* ThreadDeath_only */)) { 1647 java_lang_Thread::set_interrupted(threadObj(), true); 1648 this->interrupt(); 1649 delete aeh; 1650 return; 1651 } 1652 1653 oop exception = aeh->exception(); 1654 Handshake::execute(aeh, this); // Install asynchronous handshake 1655 1656 ResourceMark rm; 1657 if (log_is_enabled(Info, exceptions)) { 1658 log_info(exceptions)("Pending Async. exception installed of type: %s", 1659 InstanceKlass::cast(exception->klass())->external_name()); 1660 } 1661 // for AbortVMOnException flag 1662 Exceptions::debug_check_abort(exception->klass()->external_name()); 1663 1664 // Interrupt thread so it will wake up from a potential wait()/sleep()/park() 1665 java_lang_Thread::set_interrupted(threadObj(), true); 1666 this->interrupt(); 1667 } 1668 1669 class InstallAsyncExceptionHandshake : public HandshakeClosure { 1670 AsyncExceptionHandshake* _aeh; 1671 public: 1672 InstallAsyncExceptionHandshake(AsyncExceptionHandshake* aeh) : 1673 HandshakeClosure("InstallAsyncException"), _aeh(aeh) {} 1674 void do_thread(Thread* thr) { 1675 JavaThread* target = JavaThread::cast(thr); 1676 target->install_async_exception(_aeh); 1677 } 1678 }; 1679 1680 void JavaThread::send_async_exception(JavaThread* target, oop java_throwable) { 1681 OopHandle e(Universe::vm_global(), java_throwable); 1682 InstallAsyncExceptionHandshake iaeh(new AsyncExceptionHandshake(e)); 1683 Handshake::execute(&iaeh, target); 1684 } 1685 1686 1687 // External suspension mechanism. 1688 // 1689 // Guarantees on return (for a valid target thread): 1690 // - Target thread will not execute any new bytecode. 1691 // - Target thread will not enter any new monitors. 1692 // 1693 bool JavaThread::java_suspend() { 1694 guarantee(Thread::is_JavaThread_protected_by_TLH(/* target */ this), 1695 "missing ThreadsListHandle in calling context."); 1696 return this->handshake_state()->suspend(); 1697 } 1698 1699 bool JavaThread::java_resume() { 1700 guarantee(Thread::is_JavaThread_protected_by_TLH(/* target */ this), 1701 "missing ThreadsListHandle in calling context."); 1702 return this->handshake_state()->resume(); 1703 } 1704 1705 // Wait for another thread to perform object reallocation and relocking on behalf of 1706 // this thread. The current thread is required to change to _thread_blocked in order 1707 // to be seen to be safepoint/handshake safe whilst suspended and only after becoming 1708 // handshake safe, the other thread can complete the handshake used to synchronize 1709 // with this thread and then perform the reallocation and relocking. 1710 // See EscapeBarrier::sync_and_suspend_*() 1711 1712 void JavaThread::wait_for_object_deoptimization() { 1713 assert(!has_last_Java_frame() || frame_anchor()->walkable(), "should have walkable stack"); 1714 assert(this == Thread::current(), "invariant"); 1715 1716 bool spin_wait = os::is_MP(); 1717 do { 1718 ThreadBlockInVM tbivm(this, true /* allow_suspend */); 1719 // Wait for object deoptimization if requested. 1720 if (spin_wait) { 1721 // A single deoptimization is typically very short. Microbenchmarks 1722 // showed 5% better performance when spinning. 1723 const uint spin_limit = 10 * SpinYield::default_spin_limit; 1724 SpinYield spin(spin_limit); 1725 for (uint i = 0; is_obj_deopt_suspend() && i < spin_limit; i++) { 1726 spin.wait(); 1727 } 1728 // Spin just once 1729 spin_wait = false; 1730 } else { 1731 MonitorLocker ml(this, EscapeBarrier_lock, Monitor::_no_safepoint_check_flag); 1732 if (is_obj_deopt_suspend()) { 1733 ml.wait(); 1734 } 1735 } 1736 // A handshake for obj. deoptimization suspend could have been processed so 1737 // we must check after processing. 1738 } while (is_obj_deopt_suspend()); 1739 } 1740 1741 #ifdef ASSERT 1742 // Verify the JavaThread has not yet been published in the Threads::list, and 1743 // hence doesn't need protection from concurrent access at this stage. 1744 void JavaThread::verify_not_published() { 1745 // Cannot create a ThreadsListHandle here and check !tlh.includes(this) 1746 // since an unpublished JavaThread doesn't participate in the 1747 // Thread-SMR protocol for keeping a ThreadsList alive. 1748 assert(!on_thread_list(), "JavaThread shouldn't have been published yet!"); 1749 } 1750 #endif 1751 1752 // Slow path when the native==>Java barriers detect a safepoint/handshake is 1753 // pending, when _suspend_flags is non-zero or when we need to process a stack 1754 // watermark. Also check for pending async exceptions (except unsafe access error). 1755 // Note only the native==>Java barriers can call this function when thread state 1756 // is _thread_in_native_trans. 1757 void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) { 1758 assert(thread->thread_state() == _thread_in_native_trans, "wrong state"); 1759 assert(!thread->has_last_Java_frame() || thread->frame_anchor()->walkable(), "Unwalkable stack in native->Java transition"); 1760 1761 thread->set_thread_state(_thread_in_vm); 1762 1763 // Enable WXWrite: called directly from interpreter native wrapper. 1764 MACOS_AARCH64_ONLY(ThreadWXEnable wx(WXWrite, thread)); 1765 1766 SafepointMechanism::process_if_requested_with_exit_check(thread, true /* check asyncs */); 1767 1768 // After returning from native, it could be that the stack frames are not 1769 // yet safe to use. We catch such situations in the subsequent stack watermark 1770 // barrier, which will trap unsafe stack frames. 1771 StackWatermarkSet::before_unwind(thread); 1772 } 1773 1774 #ifndef PRODUCT 1775 // Deoptimization 1776 // Function for testing deoptimization 1777 void JavaThread::deoptimize() { 1778 StackFrameStream fst(this, false /* update */, true /* process_frames */); 1779 bool deopt = false; // Dump stack only if a deopt actually happens. 1780 bool only_at = strlen(DeoptimizeOnlyAt) > 0; 1781 // Iterate over all frames in the thread and deoptimize 1782 for (; !fst.is_done(); fst.next()) { 1783 if (fst.current()->can_be_deoptimized()) { 1784 1785 if (only_at) { 1786 // Deoptimize only at particular bcis. DeoptimizeOnlyAt 1787 // consists of comma or carriage return separated numbers so 1788 // search for the current bci in that string. 1789 address pc = fst.current()->pc(); 1790 nmethod* nm = (nmethod*) fst.current()->cb(); 1791 ScopeDesc* sd = nm->scope_desc_at(pc); 1792 char buffer[8]; 1793 jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci()); 1794 size_t len = strlen(buffer); 1795 const char * found = strstr(DeoptimizeOnlyAt, buffer); 1796 while (found != NULL) { 1797 if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') && 1798 (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) { 1799 // Check that the bci found is bracketed by terminators. 1800 break; 1801 } 1802 found = strstr(found + 1, buffer); 1803 } 1804 if (!found) { 1805 continue; 1806 } 1807 } 1808 1809 if (DebugDeoptimization && !deopt) { 1810 deopt = true; // One-time only print before deopt 1811 tty->print_cr("[BEFORE Deoptimization]"); 1812 trace_frames(); 1813 trace_stack(); 1814 } 1815 Deoptimization::deoptimize(this, *fst.current()); 1816 } 1817 } 1818 1819 if (DebugDeoptimization && deopt) { 1820 tty->print_cr("[AFTER Deoptimization]"); 1821 trace_frames(); 1822 } 1823 } 1824 1825 1826 // Make zombies 1827 void JavaThread::make_zombies() { 1828 for (StackFrameStream fst(this, true /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 1829 if (fst.current()->can_be_deoptimized()) { 1830 // it is a Java nmethod 1831 nmethod* nm = CodeCache::find_nmethod(fst.current()->pc()); 1832 nm->make_not_entrant(); 1833 } 1834 } 1835 } 1836 #endif // PRODUCT 1837 1838 1839 void JavaThread::deoptimize_marked_methods() { 1840 if (!has_last_Java_frame()) return; 1841 StackFrameStream fst(this, false /* update */, true /* process_frames */); 1842 for (; !fst.is_done(); fst.next()) { 1843 if (fst.current()->should_be_deoptimized()) { 1844 Deoptimization::deoptimize(this, *fst.current()); 1845 } 1846 } 1847 } 1848 1849 #ifdef ASSERT 1850 void JavaThread::verify_frame_info() { 1851 assert((!has_last_Java_frame() && java_call_counter() == 0) || 1852 (has_last_Java_frame() && java_call_counter() > 0), 1853 "unexpected frame info: has_last_frame=%s, java_call_counter=%d", 1854 has_last_Java_frame() ? "true" : "false", java_call_counter()); 1855 } 1856 #endif 1857 1858 // Push on a new block of JNI handles. 1859 void JavaThread::push_jni_handle_block() { 1860 // Allocate a new block for JNI handles. 1861 // Inlined code from jni_PushLocalFrame() 1862 JNIHandleBlock* old_handles = active_handles(); 1863 JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(this); 1864 assert(old_handles != NULL && new_handles != NULL, "should not be NULL"); 1865 new_handles->set_pop_frame_link(old_handles); // make sure java handles get gc'd. 1866 set_active_handles(new_handles); 1867 } 1868 1869 // Pop off the current block of JNI handles. 1870 void JavaThread::pop_jni_handle_block() { 1871 // Release our JNI handle block 1872 JNIHandleBlock* old_handles = active_handles(); 1873 JNIHandleBlock* new_handles = old_handles->pop_frame_link(); 1874 assert(new_handles != nullptr, "should never set active handles to null"); 1875 set_active_handles(new_handles); 1876 old_handles->set_pop_frame_link(NULL); 1877 JNIHandleBlock::release_block(old_handles, this); 1878 } 1879 1880 void JavaThread::oops_do_no_frames(OopClosure* f, CodeBlobClosure* cf) { 1881 // Verify that the deferred card marks have been flushed. 1882 assert(deferred_card_mark().is_empty(), "Should be empty during GC"); 1883 1884 // Traverse the GCHandles 1885 Thread::oops_do_no_frames(f, cf); 1886 1887 if (active_handles() != NULL) { 1888 active_handles()->oops_do(f); 1889 } 1890 1891 DEBUG_ONLY(verify_frame_info();) 1892 1893 if (has_last_Java_frame()) { 1894 // Traverse the monitor chunks 1895 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { 1896 chunk->oops_do(f); 1897 } 1898 } 1899 1900 assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!"); 1901 // If we have deferred set_locals there might be oops waiting to be 1902 // written 1903 GrowableArray<jvmtiDeferredLocalVariableSet*>* list = JvmtiDeferredUpdates::deferred_locals(this); 1904 if (list != NULL) { 1905 for (int i = 0; i < list->length(); i++) { 1906 list->at(i)->oops_do(f); 1907 } 1908 } 1909 1910 // Traverse instance variables at the end since the GC may be moving things 1911 // around using this function 1912 f->do_oop((oop*) &_vm_result); 1913 f->do_oop((oop*) &_exception_oop); 1914 #if INCLUDE_JVMCI 1915 f->do_oop((oop*) &_jvmci_reserved_oop0); 1916 #endif 1917 1918 if (jvmti_thread_state() != NULL) { 1919 jvmti_thread_state()->oops_do(f, cf); 1920 } 1921 } 1922 1923 void JavaThread::oops_do_frames(OopClosure* f, CodeBlobClosure* cf) { 1924 if (!has_last_Java_frame()) { 1925 return; 1926 } 1927 // Finish any pending lazy GC activity for the frames 1928 StackWatermarkSet::finish_processing(this, NULL /* context */, StackWatermarkKind::gc); 1929 // Traverse the execution stack 1930 for (StackFrameStream fst(this, true /* update */, false /* process_frames */); !fst.is_done(); fst.next()) { 1931 fst.current()->oops_do(f, cf, fst.register_map()); 1932 } 1933 } 1934 1935 #ifdef ASSERT 1936 void JavaThread::verify_states_for_handshake() { 1937 // This checks that the thread has a correct frame state during a handshake. 1938 verify_frame_info(); 1939 } 1940 #endif 1941 1942 void JavaThread::nmethods_do(CodeBlobClosure* cf) { 1943 DEBUG_ONLY(verify_frame_info();) 1944 1945 if (has_last_Java_frame()) { 1946 // Traverse the execution stack 1947 for (StackFrameStream fst(this, true /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 1948 fst.current()->nmethods_do(cf); 1949 } 1950 } 1951 1952 if (jvmti_thread_state() != NULL) { 1953 jvmti_thread_state()->nmethods_do(cf); 1954 } 1955 } 1956 1957 void JavaThread::metadata_do(MetadataClosure* f) { 1958 if (has_last_Java_frame()) { 1959 // Traverse the execution stack to call f() on the methods in the stack 1960 for (StackFrameStream fst(this, true /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 1961 fst.current()->metadata_do(f); 1962 } 1963 } else if (is_Compiler_thread()) { 1964 // need to walk ciMetadata in current compile tasks to keep alive. 1965 CompilerThread* ct = (CompilerThread*)this; 1966 if (ct->env() != NULL) { 1967 ct->env()->metadata_do(f); 1968 } 1969 CompileTask* task = ct->task(); 1970 if (task != NULL) { 1971 task->metadata_do(f); 1972 } 1973 } 1974 } 1975 1976 // Printing 1977 const char* _get_thread_state_name(JavaThreadState _thread_state) { 1978 switch (_thread_state) { 1979 case _thread_uninitialized: return "_thread_uninitialized"; 1980 case _thread_new: return "_thread_new"; 1981 case _thread_new_trans: return "_thread_new_trans"; 1982 case _thread_in_native: return "_thread_in_native"; 1983 case _thread_in_native_trans: return "_thread_in_native_trans"; 1984 case _thread_in_vm: return "_thread_in_vm"; 1985 case _thread_in_vm_trans: return "_thread_in_vm_trans"; 1986 case _thread_in_Java: return "_thread_in_Java"; 1987 case _thread_in_Java_trans: return "_thread_in_Java_trans"; 1988 case _thread_blocked: return "_thread_blocked"; 1989 case _thread_blocked_trans: return "_thread_blocked_trans"; 1990 default: return "unknown thread state"; 1991 } 1992 } 1993 1994 #ifndef PRODUCT 1995 void JavaThread::print_thread_state_on(outputStream *st) const { 1996 st->print_cr(" JavaThread state: %s", _get_thread_state_name(_thread_state)); 1997 }; 1998 #endif // PRODUCT 1999 2000 // Called by Threads::print() for VM_PrintThreads operation 2001 void JavaThread::print_on(outputStream *st, bool print_extended_info) const { 2002 st->print_raw("\""); 2003 st->print_raw(name()); 2004 st->print_raw("\" "); 2005 oop thread_oop = threadObj(); 2006 if (thread_oop != NULL) { 2007 st->print("#" INT64_FORMAT " ", (int64_t)java_lang_Thread::thread_id(thread_oop)); 2008 if (java_lang_Thread::is_daemon(thread_oop)) st->print("daemon "); 2009 st->print("prio=%d ", java_lang_Thread::priority(thread_oop)); 2010 } 2011 Thread::print_on(st, print_extended_info); 2012 // print guess for valid stack memory region (assume 4K pages); helps lock debugging 2013 st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12)); 2014 if (thread_oop != NULL) { 2015 st->print_cr(" java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop)); 2016 } 2017 #ifndef PRODUCT 2018 _safepoint_state->print_on(st); 2019 #endif // PRODUCT 2020 if (is_Compiler_thread()) { 2021 CompileTask *task = ((CompilerThread*)this)->task(); 2022 if (task != NULL) { 2023 st->print(" Compiling: "); 2024 task->print(st, NULL, true, false); 2025 } else { 2026 st->print(" No compile task"); 2027 } 2028 st->cr(); 2029 } 2030 } 2031 2032 void JavaThread::print() const { print_on(tty); } 2033 2034 void JavaThread::print_name_on_error(outputStream* st, char *buf, int buflen) const { 2035 st->print("%s", get_thread_name_string(buf, buflen)); 2036 } 2037 2038 // Called by fatal error handler. The difference between this and 2039 // JavaThread::print() is that we can't grab lock or allocate memory. 2040 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const { 2041 st->print("%s \"%s\"", type_name(), get_thread_name_string(buf, buflen)); 2042 oop thread_obj = threadObj(); 2043 if (thread_obj != NULL) { 2044 if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon"); 2045 } 2046 st->print(" ["); 2047 st->print("%s", _get_thread_state_name(_thread_state)); 2048 if (osthread()) { 2049 st->print(", id=%d", osthread()->thread_id()); 2050 } 2051 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")", 2052 p2i(stack_end()), p2i(stack_base())); 2053 st->print("]"); 2054 2055 ThreadsSMRSupport::print_info_on(this, st); 2056 return; 2057 } 2058 2059 2060 // Verification 2061 2062 void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) { 2063 // ignore if there is no stack 2064 if (!has_last_Java_frame()) return; 2065 // traverse the stack frames. Starts from top frame. 2066 for (StackFrameStream fst(this, true /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 2067 frame* fr = fst.current(); 2068 f(fr, fst.register_map()); 2069 } 2070 } 2071 2072 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); } 2073 2074 void JavaThread::verify() { 2075 // Verify oops in the thread. 2076 oops_do(&VerifyOopClosure::verify_oop, NULL); 2077 2078 // Verify the stack frames. 2079 frames_do(frame_verify); 2080 } 2081 2082 // CR 6300358 (sub-CR 2137150) 2083 // Most callers of this method assume that it can't return NULL but a 2084 // thread may not have a name whilst it is in the process of attaching to 2085 // the VM - see CR 6412693, and there are places where a JavaThread can be 2086 // seen prior to having its threadObj set (e.g., JNI attaching threads and 2087 // if vm exit occurs during initialization). These cases can all be accounted 2088 // for such that this method never returns NULL. 2089 const char* JavaThread::name() const { 2090 if (Thread::is_JavaThread_protected(/* target */ this)) { 2091 // The target JavaThread is protected so get_thread_name_string() is safe: 2092 return get_thread_name_string(); 2093 } 2094 2095 // The target JavaThread is not protected so we return the default: 2096 return Thread::name(); 2097 } 2098 2099 // Returns a non-NULL representation of this thread's name, or a suitable 2100 // descriptive string if there is no set name. 2101 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const { 2102 const char* name_str; 2103 oop thread_obj = threadObj(); 2104 if (thread_obj != NULL) { 2105 oop name = java_lang_Thread::name(thread_obj); 2106 if (name != NULL) { 2107 if (buf == NULL) { 2108 name_str = java_lang_String::as_utf8_string(name); 2109 } else { 2110 name_str = java_lang_String::as_utf8_string(name, buf, buflen); 2111 } 2112 } else if (is_attaching_via_jni()) { // workaround for 6412693 - see 6404306 2113 name_str = "<no-name - thread is attaching>"; 2114 } else { 2115 name_str = "<un-named>"; 2116 } 2117 } else { 2118 name_str = Thread::name(); 2119 } 2120 assert(name_str != NULL, "unexpected NULL thread name"); 2121 return name_str; 2122 } 2123 2124 // Helper to extract the name from the thread oop for logging. 2125 const char* JavaThread::name_for(oop thread_obj) { 2126 assert(thread_obj != NULL, "precondition"); 2127 oop name = java_lang_Thread::name(thread_obj); 2128 const char* name_str; 2129 if (name != NULL) { 2130 name_str = java_lang_String::as_utf8_string(name); 2131 } else { 2132 name_str = "<un-named>"; 2133 } 2134 return name_str; 2135 } 2136 2137 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) { 2138 2139 assert(Threads_lock->owner() == Thread::current(), "must have threads lock"); 2140 assert(NoPriority <= prio && prio <= MaxPriority, "sanity check"); 2141 // Link Java Thread object <-> C++ Thread 2142 2143 // Get the C++ thread object (an oop) from the JNI handle (a jthread) 2144 // and put it into a new Handle. The Handle "thread_oop" can then 2145 // be used to pass the C++ thread object to other methods. 2146 2147 // Set the Java level thread object (jthread) field of the 2148 // new thread (a JavaThread *) to C++ thread object using the 2149 // "thread_oop" handle. 2150 2151 // Set the thread field (a JavaThread *) of the 2152 // oop representing the java_lang_Thread to the new thread (a JavaThread *). 2153 2154 Handle thread_oop(Thread::current(), 2155 JNIHandles::resolve_non_null(jni_thread)); 2156 assert(InstanceKlass::cast(thread_oop->klass())->is_linked(), 2157 "must be initialized"); 2158 set_threadObj(thread_oop()); 2159 java_lang_Thread::set_thread(thread_oop(), this); 2160 2161 if (prio == NoPriority) { 2162 prio = java_lang_Thread::priority(thread_oop()); 2163 assert(prio != NoPriority, "A valid priority should be present"); 2164 } 2165 2166 // Push the Java priority down to the native thread; needs Threads_lock 2167 Thread::set_priority(this, prio); 2168 2169 // Add the new thread to the Threads list and set it in motion. 2170 // We must have threads lock in order to call Threads::add. 2171 // It is crucial that we do not block before the thread is 2172 // added to the Threads list for if a GC happens, then the java_thread oop 2173 // will not be visited by GC. 2174 Threads::add(this); 2175 } 2176 2177 oop JavaThread::current_park_blocker() { 2178 // Support for JSR-166 locks 2179 oop thread_oop = threadObj(); 2180 if (thread_oop != NULL) { 2181 return java_lang_Thread::park_blocker(thread_oop); 2182 } 2183 return NULL; 2184 } 2185 2186 2187 void JavaThread::print_stack_on(outputStream* st) { 2188 if (!has_last_Java_frame()) return; 2189 2190 Thread* current_thread = Thread::current(); 2191 ResourceMark rm(current_thread); 2192 HandleMark hm(current_thread); 2193 2194 RegisterMap reg_map(this); 2195 vframe* start_vf = last_java_vframe(®_map); 2196 int count = 0; 2197 for (vframe* f = start_vf; f != NULL; f = f->sender()) { 2198 if (f->is_java_frame()) { 2199 javaVFrame* jvf = javaVFrame::cast(f); 2200 java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci()); 2201 2202 // Print out lock information 2203 if (JavaMonitorsInStackTrace) { 2204 jvf->print_lock_info_on(st, count); 2205 } 2206 } else { 2207 // Ignore non-Java frames 2208 } 2209 2210 // Bail-out case for too deep stacks if MaxJavaStackTraceDepth > 0 2211 count++; 2212 if (MaxJavaStackTraceDepth > 0 && MaxJavaStackTraceDepth == count) return; 2213 } 2214 } 2215 2216 2217 // JVMTI PopFrame support 2218 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { 2219 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); 2220 if (in_bytes(size_in_bytes) != 0) { 2221 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes), mtThread); 2222 _popframe_preserved_args_size = in_bytes(size_in_bytes); 2223 Copy::conjoint_jbytes(start, _popframe_preserved_args, _popframe_preserved_args_size); 2224 } 2225 } 2226 2227 void* JavaThread::popframe_preserved_args() { 2228 return _popframe_preserved_args; 2229 } 2230 2231 ByteSize JavaThread::popframe_preserved_args_size() { 2232 return in_ByteSize(_popframe_preserved_args_size); 2233 } 2234 2235 WordSize JavaThread::popframe_preserved_args_size_in_words() { 2236 int sz = in_bytes(popframe_preserved_args_size()); 2237 assert(sz % wordSize == 0, "argument size must be multiple of wordSize"); 2238 return in_WordSize(sz / wordSize); 2239 } 2240 2241 void JavaThread::popframe_free_preserved_args() { 2242 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); 2243 FREE_C_HEAP_ARRAY(char, (char*)_popframe_preserved_args); 2244 _popframe_preserved_args = NULL; 2245 _popframe_preserved_args_size = 0; 2246 } 2247 2248 #ifndef PRODUCT 2249 2250 void JavaThread::trace_frames() { 2251 tty->print_cr("[Describe stack]"); 2252 int frame_no = 1; 2253 for (StackFrameStream fst(this, true /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 2254 tty->print(" %d. ", frame_no++); 2255 fst.current()->print_value_on(tty, this); 2256 tty->cr(); 2257 } 2258 } 2259 2260 class PrintAndVerifyOopClosure: public OopClosure { 2261 protected: 2262 template <class T> inline void do_oop_work(T* p) { 2263 oop obj = RawAccess<>::oop_load(p); 2264 if (obj == NULL) return; 2265 tty->print(INTPTR_FORMAT ": ", p2i(p)); 2266 if (oopDesc::is_oop_or_null(obj)) { 2267 if (obj->is_objArray()) { 2268 tty->print_cr("valid objArray: " INTPTR_FORMAT, p2i(obj)); 2269 } else { 2270 obj->print(); 2271 } 2272 } else { 2273 tty->print_cr("invalid oop: " INTPTR_FORMAT, p2i(obj)); 2274 } 2275 tty->cr(); 2276 } 2277 public: 2278 virtual void do_oop(oop* p) { do_oop_work(p); } 2279 virtual void do_oop(narrowOop* p) { do_oop_work(p); } 2280 }; 2281 2282 #ifdef ASSERT 2283 // Print or validate the layout of stack frames 2284 void JavaThread::print_frame_layout(int depth, bool validate_only) { 2285 ResourceMark rm; 2286 PreserveExceptionMark pm(this); 2287 FrameValues values; 2288 int frame_no = 0; 2289 for (StackFrameStream fst(this, false /* update */, true /* process_frames */); !fst.is_done(); fst.next()) { 2290 fst.current()->describe(values, ++frame_no); 2291 if (depth == frame_no) break; 2292 } 2293 if (validate_only) { 2294 values.validate(); 2295 } else { 2296 tty->print_cr("[Describe stack layout]"); 2297 values.print(this); 2298 } 2299 } 2300 #endif 2301 2302 void JavaThread::trace_stack_from(vframe* start_vf) { 2303 ResourceMark rm; 2304 int vframe_no = 1; 2305 for (vframe* f = start_vf; f; f = f->sender()) { 2306 if (f->is_java_frame()) { 2307 javaVFrame::cast(f)->print_activation(vframe_no++); 2308 } else { 2309 f->print(); 2310 } 2311 if (vframe_no > StackPrintLimit) { 2312 tty->print_cr("...<more frames>..."); 2313 return; 2314 } 2315 } 2316 } 2317 2318 2319 void JavaThread::trace_stack() { 2320 if (!has_last_Java_frame()) return; 2321 Thread* current_thread = Thread::current(); 2322 ResourceMark rm(current_thread); 2323 HandleMark hm(current_thread); 2324 RegisterMap reg_map(this); 2325 trace_stack_from(last_java_vframe(®_map)); 2326 } 2327 2328 2329 #endif // PRODUCT 2330 2331 2332 javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) { 2333 assert(reg_map != NULL, "a map must be given"); 2334 frame f = last_frame(); 2335 for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender()) { 2336 if (vf->is_java_frame()) return javaVFrame::cast(vf); 2337 } 2338 return NULL; 2339 } 2340 2341 2342 Klass* JavaThread::security_get_caller_class(int depth) { 2343 vframeStream vfst(this); 2344 vfst.security_get_caller_frame(depth); 2345 if (!vfst.at_end()) { 2346 return vfst.method()->method_holder(); 2347 } 2348 return NULL; 2349 } 2350 2351 // java.lang.Thread.sleep support 2352 // Returns true if sleep time elapsed as expected, and false 2353 // if the thread was interrupted. 2354 bool JavaThread::sleep(jlong millis) { 2355 assert(this == Thread::current(), "thread consistency check"); 2356 2357 ParkEvent * const slp = this->_SleepEvent; 2358 // Because there can be races with thread interruption sending an unpark() 2359 // to the event, we explicitly reset it here to avoid an immediate return. 2360 // The actual interrupt state will be checked before we park(). 2361 slp->reset(); 2362 // Thread interruption establishes a happens-before ordering in the 2363 // Java Memory Model, so we need to ensure we synchronize with the 2364 // interrupt state. 2365 OrderAccess::fence(); 2366 2367 jlong prevtime = os::javaTimeNanos(); 2368 2369 for (;;) { 2370 // interruption has precedence over timing out 2371 if (this->is_interrupted(true)) { 2372 return false; 2373 } 2374 2375 if (millis <= 0) { 2376 return true; 2377 } 2378 2379 { 2380 ThreadBlockInVM tbivm(this); 2381 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */); 2382 slp->park(millis); 2383 } 2384 2385 // Update elapsed time tracking 2386 jlong newtime = os::javaTimeNanos(); 2387 if (newtime - prevtime < 0) { 2388 // time moving backwards, should only happen if no monotonic clock 2389 // not a guarantee() because JVM should not abort on kernel/glibc bugs 2390 assert(false, 2391 "unexpected time moving backwards detected in JavaThread::sleep()"); 2392 } else { 2393 millis -= (newtime - prevtime) / NANOSECS_PER_MILLISEC; 2394 } 2395 prevtime = newtime; 2396 } 2397 } 2398 2399 2400 // ======= Threads ======== 2401 2402 // The Threads class links together all active threads, and provides 2403 // operations over all threads. It is protected by the Threads_lock, 2404 // which is also used in other global contexts like safepointing. 2405 // ThreadsListHandles are used to safely perform operations on one 2406 // or more threads without the risk of the thread exiting during the 2407 // operation. 2408 // 2409 // Note: The Threads_lock is currently more widely used than we 2410 // would like. We are actively migrating Threads_lock uses to other 2411 // mechanisms in order to reduce Threads_lock contention. 2412 2413 int Threads::_number_of_threads = 0; 2414 int Threads::_number_of_non_daemon_threads = 0; 2415 int Threads::_return_code = 0; 2416 uintx Threads::_thread_claim_token = 1; // Never zero. 2417 size_t JavaThread::_stack_size_at_create = 0; 2418 2419 #ifdef ASSERT 2420 bool Threads::_vm_complete = false; 2421 #endif 2422 2423 // All NonJavaThreads (i.e., every non-JavaThread in the system). 2424 void Threads::non_java_threads_do(ThreadClosure* tc) { 2425 NoSafepointVerifier nsv; 2426 for (NonJavaThread::Iterator njti; !njti.end(); njti.step()) { 2427 tc->do_thread(njti.current()); 2428 } 2429 } 2430 2431 // All JavaThreads 2432 #define ALL_JAVA_THREADS(X) \ 2433 for (JavaThread* X : *ThreadsSMRSupport::get_java_thread_list()) 2434 2435 // All JavaThreads 2436 void Threads::java_threads_do(ThreadClosure* tc) { 2437 assert_locked_or_safepoint(Threads_lock); 2438 // ALL_JAVA_THREADS iterates through all JavaThreads. 2439 ALL_JAVA_THREADS(p) { 2440 tc->do_thread(p); 2441 } 2442 } 2443 2444 void Threads::java_threads_and_vm_thread_do(ThreadClosure* tc) { 2445 assert_locked_or_safepoint(Threads_lock); 2446 java_threads_do(tc); 2447 tc->do_thread(VMThread::vm_thread()); 2448 } 2449 2450 // All JavaThreads + all non-JavaThreads (i.e., every thread in the system). 2451 void Threads::threads_do(ThreadClosure* tc) { 2452 assert_locked_or_safepoint(Threads_lock); 2453 java_threads_do(tc); 2454 non_java_threads_do(tc); 2455 } 2456 2457 void Threads::possibly_parallel_threads_do(bool is_par, ThreadClosure* tc) { 2458 uintx claim_token = Threads::thread_claim_token(); 2459 ALL_JAVA_THREADS(p) { 2460 if (p->claim_threads_do(is_par, claim_token)) { 2461 tc->do_thread(p); 2462 } 2463 } 2464 VMThread* vmt = VMThread::vm_thread(); 2465 if (vmt->claim_threads_do(is_par, claim_token)) { 2466 tc->do_thread(vmt); 2467 } 2468 } 2469 2470 // The system initialization in the library has three phases. 2471 // 2472 // Phase 1: java.lang.System class initialization 2473 // java.lang.System is a primordial class loaded and initialized 2474 // by the VM early during startup. java.lang.System.<clinit> 2475 // only does registerNatives and keeps the rest of the class 2476 // initialization work later until thread initialization completes. 2477 // 2478 // System.initPhase1 initializes the system properties, the static 2479 // fields in, out, and err. Set up java signal handlers, OS-specific 2480 // system settings, and thread group of the main thread. 2481 static void call_initPhase1(TRAPS) { 2482 Klass* klass = vmClasses::System_klass(); 2483 JavaValue result(T_VOID); 2484 JavaCalls::call_static(&result, klass, vmSymbols::initPhase1_name(), 2485 vmSymbols::void_method_signature(), CHECK); 2486 } 2487 2488 // Phase 2. Module system initialization 2489 // This will initialize the module system. Only java.base classes 2490 // can be loaded until phase 2 completes. 2491 // 2492 // Call System.initPhase2 after the compiler initialization and jsr292 2493 // classes get initialized because module initialization runs a lot of java 2494 // code, that for performance reasons, should be compiled. Also, this will 2495 // enable the startup code to use lambda and other language features in this 2496 // phase and onward. 2497 // 2498 // After phase 2, The VM will begin search classes from -Xbootclasspath/a. 2499 static void call_initPhase2(TRAPS) { 2500 TraceTime timer("Initialize module system", TRACETIME_LOG(Info, startuptime)); 2501 2502 Klass* klass = vmClasses::System_klass(); 2503 2504 JavaValue result(T_INT); 2505 JavaCallArguments args; 2506 args.push_int(DisplayVMOutputToStderr); 2507 args.push_int(log_is_enabled(Debug, init)); // print stack trace if exception thrown 2508 JavaCalls::call_static(&result, klass, vmSymbols::initPhase2_name(), 2509 vmSymbols::boolean_boolean_int_signature(), &args, CHECK); 2510 if (result.get_jint() != JNI_OK) { 2511 vm_exit_during_initialization(); // no message or exception 2512 } 2513 2514 universe_post_module_init(); 2515 } 2516 2517 // Phase 3. final setup - set security manager, system class loader and TCCL 2518 // 2519 // This will instantiate and set the security manager, set the system class 2520 // loader as well as the thread context class loader. The security manager 2521 // and system class loader may be a custom class loaded from -Xbootclasspath/a, 2522 // other modules or the application's classpath. 2523 static void call_initPhase3(TRAPS) { 2524 Klass* klass = vmClasses::System_klass(); 2525 JavaValue result(T_VOID); 2526 JavaCalls::call_static(&result, klass, vmSymbols::initPhase3_name(), 2527 vmSymbols::void_method_signature(), CHECK); 2528 } 2529 2530 void Threads::initialize_java_lang_classes(JavaThread* main_thread, TRAPS) { 2531 TraceTime timer("Initialize java.lang classes", TRACETIME_LOG(Info, startuptime)); 2532 2533 if (EagerXrunInit && Arguments::init_libraries_at_startup()) { 2534 create_vm_init_libraries(); 2535 } 2536 2537 initialize_class(vmSymbols::java_lang_String(), CHECK); 2538 2539 // Inject CompactStrings value after the static initializers for String ran. 2540 java_lang_String::set_compact_strings(CompactStrings); 2541 2542 // Initialize java_lang.System (needed before creating the thread) 2543 initialize_class(vmSymbols::java_lang_System(), CHECK); 2544 // The VM creates & returns objects of this class. Make sure it's initialized. 2545 initialize_class(vmSymbols::java_lang_Class(), CHECK); 2546 initialize_class(vmSymbols::java_lang_ThreadGroup(), CHECK); 2547 Handle thread_group = create_initial_thread_group(CHECK); 2548 Universe::set_main_thread_group(thread_group()); 2549 initialize_class(vmSymbols::java_lang_Thread(), CHECK); 2550 create_initial_thread(thread_group, main_thread, CHECK); 2551 2552 // The VM creates objects of this class. 2553 initialize_class(vmSymbols::java_lang_Module(), CHECK); 2554 2555 #ifdef ASSERT 2556 InstanceKlass *k = vmClasses::UnsafeConstants_klass(); 2557 assert(k->is_not_initialized(), "UnsafeConstants should not already be initialized"); 2558 #endif 2559 2560 // initialize the hardware-specific constants needed by Unsafe 2561 initialize_class(vmSymbols::jdk_internal_misc_UnsafeConstants(), CHECK); 2562 jdk_internal_misc_UnsafeConstants::set_unsafe_constants(); 2563 2564 // The VM preresolves methods to these classes. Make sure that they get initialized 2565 initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK); 2566 initialize_class(vmSymbols::java_lang_ref_Finalizer(), CHECK); 2567 2568 // Phase 1 of the system initialization in the library, java.lang.System class initialization 2569 call_initPhase1(CHECK); 2570 2571 // Get the Java runtime name, version, and vendor info after java.lang.System is initialized. 2572 // Some values are actually configure-time constants but some can be set via the jlink tool and 2573 // so must be read dynamically. We treat them all the same. 2574 InstanceKlass* ik = SystemDictionary::find_instance_klass(vmSymbols::java_lang_VersionProps(), 2575 Handle(), Handle()); 2576 { 2577 ResourceMark rm(main_thread); 2578 JDK_Version::set_java_version(get_java_version_info(ik, vmSymbols::java_version_name())); 2579 2580 JDK_Version::set_runtime_name(get_java_version_info(ik, vmSymbols::java_runtime_name_name())); 2581 2582 JDK_Version::set_runtime_version(get_java_version_info(ik, vmSymbols::java_runtime_version_name())); 2583 2584 JDK_Version::set_runtime_vendor_version(get_java_version_info(ik, vmSymbols::java_runtime_vendor_version_name())); 2585 2586 JDK_Version::set_runtime_vendor_vm_bug_url(get_java_version_info(ik, vmSymbols::java_runtime_vendor_vm_bug_url_name())); 2587 } 2588 2589 // an instance of OutOfMemory exception has been allocated earlier 2590 initialize_class(vmSymbols::java_lang_OutOfMemoryError(), CHECK); 2591 initialize_class(vmSymbols::java_lang_NullPointerException(), CHECK); 2592 initialize_class(vmSymbols::java_lang_ClassCastException(), CHECK); 2593 initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK); 2594 initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK); 2595 initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK); 2596 initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK); 2597 initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK); 2598 } 2599 2600 void Threads::initialize_jsr292_core_classes(TRAPS) { 2601 TraceTime timer("Initialize java.lang.invoke classes", TRACETIME_LOG(Info, startuptime)); 2602 2603 initialize_class(vmSymbols::java_lang_invoke_MethodHandle(), CHECK); 2604 initialize_class(vmSymbols::java_lang_invoke_ResolvedMethodName(), CHECK); 2605 initialize_class(vmSymbols::java_lang_invoke_MemberName(), CHECK); 2606 initialize_class(vmSymbols::java_lang_invoke_MethodHandleNatives(), CHECK); 2607 } 2608 2609 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { 2610 extern void JDK_Version_init(); 2611 2612 // Preinitialize version info. 2613 VM_Version::early_initialize(); 2614 2615 // Check version 2616 if (!is_supported_jni_version(args->version)) return JNI_EVERSION; 2617 2618 // Initialize library-based TLS 2619 ThreadLocalStorage::init(); 2620 2621 // Initialize the output stream module 2622 ostream_init(); 2623 2624 // Process java launcher properties. 2625 Arguments::process_sun_java_launcher_properties(args); 2626 2627 // Initialize the os module 2628 os::init(); 2629 2630 MACOS_AARCH64_ONLY(os::current_thread_enable_wx(WXWrite)); 2631 2632 // Record VM creation timing statistics 2633 TraceVmCreationTime create_vm_timer; 2634 create_vm_timer.start(); 2635 2636 // Initialize system properties. 2637 Arguments::init_system_properties(); 2638 2639 // So that JDK version can be used as a discriminator when parsing arguments 2640 JDK_Version_init(); 2641 2642 // Update/Initialize System properties after JDK version number is known 2643 Arguments::init_version_specific_system_properties(); 2644 2645 // Make sure to initialize log configuration *before* parsing arguments 2646 LogConfiguration::initialize(create_vm_timer.begin_time()); 2647 2648 // Parse arguments 2649 // Note: this internally calls os::init_container_support() 2650 jint parse_result = Arguments::parse(args); 2651 if (parse_result != JNI_OK) return parse_result; 2652 2653 // Initialize NMT right after argument parsing to keep the pre-NMT-init window small. 2654 MemTracker::initialize(); 2655 2656 os::init_before_ergo(); 2657 2658 jint ergo_result = Arguments::apply_ergo(); 2659 if (ergo_result != JNI_OK) return ergo_result; 2660 2661 // Final check of all ranges after ergonomics which may change values. 2662 if (!JVMFlagLimit::check_all_ranges()) { 2663 return JNI_EINVAL; 2664 } 2665 2666 // Final check of all 'AfterErgo' constraints after ergonomics which may change values. 2667 bool constraint_result = JVMFlagLimit::check_all_constraints(JVMFlagConstraintPhase::AfterErgo); 2668 if (!constraint_result) { 2669 return JNI_EINVAL; 2670 } 2671 2672 if (PauseAtStartup) { 2673 os::pause(); 2674 } 2675 2676 HOTSPOT_VM_INIT_BEGIN(); 2677 2678 // Timing (must come after argument parsing) 2679 TraceTime timer("Create VM", TRACETIME_LOG(Info, startuptime)); 2680 2681 // Initialize the os module after parsing the args 2682 jint os_init_2_result = os::init_2(); 2683 if (os_init_2_result != JNI_OK) return os_init_2_result; 2684 2685 #ifdef CAN_SHOW_REGISTERS_ON_ASSERT 2686 // Initialize assert poison page mechanism. 2687 if (ShowRegistersOnAssert) { 2688 initialize_assert_poison(); 2689 } 2690 #endif // CAN_SHOW_REGISTERS_ON_ASSERT 2691 2692 SafepointMechanism::initialize(); 2693 2694 jint adjust_after_os_result = Arguments::adjust_after_os(); 2695 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result; 2696 2697 // Initialize output stream logging 2698 ostream_init_log(); 2699 2700 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad 2701 // Must be before create_vm_init_agents() 2702 if (Arguments::init_libraries_at_startup()) { 2703 convert_vm_init_libraries_to_agents(); 2704 } 2705 2706 // Launch -agentlib/-agentpath and converted -Xrun agents 2707 if (Arguments::init_agents_at_startup()) { 2708 create_vm_init_agents(); 2709 } 2710 2711 // Initialize Threads state 2712 _number_of_threads = 0; 2713 _number_of_non_daemon_threads = 0; 2714 2715 // Initialize global data structures and create system classes in heap 2716 vm_init_globals(); 2717 2718 #if INCLUDE_JVMCI 2719 if (JVMCICounterSize > 0) { 2720 JavaThread::_jvmci_old_thread_counters = NEW_C_HEAP_ARRAY(jlong, JVMCICounterSize, mtJVMCI); 2721 memset(JavaThread::_jvmci_old_thread_counters, 0, sizeof(jlong) * JVMCICounterSize); 2722 } else { 2723 JavaThread::_jvmci_old_thread_counters = NULL; 2724 } 2725 #endif // INCLUDE_JVMCI 2726 2727 // Initialize OopStorage for threadObj 2728 _thread_oop_storage = OopStorageSet::create_strong("Thread OopStorage", mtThread); 2729 2730 // Attach the main thread to this os thread 2731 JavaThread* main_thread = new JavaThread(); 2732 main_thread->set_thread_state(_thread_in_vm); 2733 main_thread->initialize_thread_current(); 2734 // must do this before set_active_handles 2735 main_thread->record_stack_base_and_size(); 2736 main_thread->register_thread_stack_with_NMT(); 2737 main_thread->set_active_handles(JNIHandleBlock::allocate_block()); 2738 MACOS_AARCH64_ONLY(main_thread->init_wx()); 2739 2740 if (!main_thread->set_as_starting_thread()) { 2741 vm_shutdown_during_initialization( 2742 "Failed necessary internal allocation. Out of swap space"); 2743 main_thread->smr_delete(); 2744 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again 2745 return JNI_ENOMEM; 2746 } 2747 2748 // Enable guard page *after* os::create_main_thread(), otherwise it would 2749 // crash Linux VM, see notes in os_linux.cpp. 2750 main_thread->stack_overflow_state()->create_stack_guard_pages(); 2751 2752 // Initialize Java-Level synchronization subsystem 2753 ObjectMonitor::Initialize(); 2754 ObjectSynchronizer::initialize(); 2755 2756 // Initialize global modules 2757 jint status = init_globals(); 2758 if (status != JNI_OK) { 2759 main_thread->smr_delete(); 2760 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again 2761 return status; 2762 } 2763 2764 JFR_ONLY(Jfr::on_create_vm_1();) 2765 2766 // Should be done after the heap is fully created 2767 main_thread->cache_global_variables(); 2768 2769 { MutexLocker mu(Threads_lock); 2770 Threads::add(main_thread); 2771 } 2772 2773 // Any JVMTI raw monitors entered in onload will transition into 2774 // real raw monitor. VM is setup enough here for raw monitor enter. 2775 JvmtiExport::transition_pending_onload_raw_monitors(); 2776 2777 // Create the VMThread 2778 { TraceTime timer("Start VMThread", TRACETIME_LOG(Info, startuptime)); 2779 2780 VMThread::create(); 2781 VMThread* vmthread = VMThread::vm_thread(); 2782 2783 if (!os::create_thread(vmthread, os::vm_thread)) { 2784 vm_exit_during_initialization("Cannot create VM thread. " 2785 "Out of system resources."); 2786 } 2787 2788 // Wait for the VM thread to become ready, and VMThread::run to initialize 2789 // Monitors can have spurious returns, must always check another state flag 2790 { 2791 MonitorLocker ml(Notify_lock); 2792 os::start_thread(vmthread); 2793 while (!vmthread->is_running()) { 2794 ml.wait(); 2795 } 2796 } 2797 } 2798 2799 assert(Universe::is_fully_initialized(), "not initialized"); 2800 if (VerifyDuringStartup) { 2801 // Make sure we're starting with a clean slate. 2802 VM_Verify verify_op; 2803 VMThread::execute(&verify_op); 2804 } 2805 2806 // We need this to update the java.vm.info property in case any flags used 2807 // to initially define it have been changed. This is needed for both CDS 2808 // since UseSharedSpaces may be changed after java.vm.info 2809 // is initially computed. See Abstract_VM_Version::vm_info_string(). 2810 // This update must happen before we initialize the java classes, but 2811 // after any initialization logic that might modify the flags. 2812 Arguments::update_vm_info_property(VM_Version::vm_info_string()); 2813 2814 JavaThread* THREAD = JavaThread::current(); // For exception macros. 2815 HandleMark hm(THREAD); 2816 2817 // Always call even when there are not JVMTI environments yet, since environments 2818 // may be attached late and JVMTI must track phases of VM execution 2819 JvmtiExport::enter_early_start_phase(); 2820 2821 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents. 2822 JvmtiExport::post_early_vm_start(); 2823 2824 initialize_java_lang_classes(main_thread, CHECK_JNI_ERR); 2825 2826 quicken_jni_functions(); 2827 2828 // No more stub generation allowed after that point. 2829 StubCodeDesc::freeze(); 2830 2831 // Set flag that basic initialization has completed. Used by exceptions and various 2832 // debug stuff, that does not work until all basic classes have been initialized. 2833 set_init_completed(); 2834 2835 LogConfiguration::post_initialize(); 2836 Metaspace::post_initialize(); 2837 2838 HOTSPOT_VM_INIT_END(); 2839 2840 // record VM initialization completion time 2841 #if INCLUDE_MANAGEMENT 2842 Management::record_vm_init_completed(); 2843 #endif // INCLUDE_MANAGEMENT 2844 2845 // Signal Dispatcher needs to be started before VMInit event is posted 2846 os::initialize_jdk_signal_support(CHECK_JNI_ERR); 2847 2848 // Start Attach Listener if +StartAttachListener or it can't be started lazily 2849 if (!DisableAttachMechanism) { 2850 AttachListener::vm_start(); 2851 if (StartAttachListener || AttachListener::init_at_startup()) { 2852 AttachListener::init(); 2853 } 2854 } 2855 2856 // Launch -Xrun agents 2857 // Must be done in the JVMTI live phase so that for backward compatibility the JDWP 2858 // back-end can launch with -Xdebug -Xrunjdwp. 2859 if (!EagerXrunInit && Arguments::init_libraries_at_startup()) { 2860 create_vm_init_libraries(); 2861 } 2862 2863 Chunk::start_chunk_pool_cleaner_task(); 2864 2865 // Start the service thread 2866 // The service thread enqueues JVMTI deferred events and does various hashtable 2867 // and other cleanups. Needs to start before the compilers start posting events. 2868 ServiceThread::initialize(); 2869 2870 // Start the monitor deflation thread: 2871 MonitorDeflationThread::initialize(); 2872 2873 // Start heap object statistics sampling 2874 HeapObjectStatistics::initialize(); 2875 2876 // initialize compiler(s) 2877 #if defined(COMPILER1) || COMPILER2_OR_JVMCI 2878 #if INCLUDE_JVMCI 2879 bool force_JVMCI_intialization = false; 2880 if (EnableJVMCI) { 2881 // Initialize JVMCI eagerly when it is explicitly requested. 2882 // Or when JVMCILibDumpJNIConfig or JVMCIPrintProperties is enabled. 2883 force_JVMCI_intialization = EagerJVMCI || JVMCIPrintProperties || JVMCILibDumpJNIConfig; 2884 2885 if (!force_JVMCI_intialization) { 2886 // 8145270: Force initialization of JVMCI runtime otherwise requests for blocking 2887 // compilations via JVMCI will not actually block until JVMCI is initialized. 2888 force_JVMCI_intialization = UseJVMCICompiler && (!UseInterpreter || !BackgroundCompilation); 2889 } 2890 } 2891 #endif 2892 CompileBroker::compilation_init_phase1(CHECK_JNI_ERR); 2893 // Postpone completion of compiler initialization to after JVMCI 2894 // is initialized to avoid timeouts of blocking compilations. 2895 if (JVMCI_ONLY(!force_JVMCI_intialization) NOT_JVMCI(true)) { 2896 CompileBroker::compilation_init_phase2(); 2897 } 2898 #endif 2899 2900 // Pre-initialize some JSR292 core classes to avoid deadlock during class loading. 2901 // It is done after compilers are initialized, because otherwise compilations of 2902 // signature polymorphic MH intrinsics can be missed 2903 // (see SystemDictionary::find_method_handle_intrinsic). 2904 initialize_jsr292_core_classes(CHECK_JNI_ERR); 2905 2906 // This will initialize the module system. Only java.base classes can be 2907 // loaded until phase 2 completes 2908 call_initPhase2(CHECK_JNI_ERR); 2909 2910 JFR_ONLY(Jfr::on_create_vm_2();) 2911 2912 // Always call even when there are not JVMTI environments yet, since environments 2913 // may be attached late and JVMTI must track phases of VM execution 2914 JvmtiExport::enter_start_phase(); 2915 2916 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents. 2917 JvmtiExport::post_vm_start(); 2918 2919 // Final system initialization including security manager and system class loader 2920 call_initPhase3(CHECK_JNI_ERR); 2921 2922 // cache the system and platform class loaders 2923 SystemDictionary::compute_java_loaders(CHECK_JNI_ERR); 2924 2925 #if INCLUDE_CDS 2926 // capture the module path info from the ModuleEntryTable 2927 ClassLoader::initialize_module_path(THREAD); 2928 if (HAS_PENDING_EXCEPTION) { 2929 java_lang_Throwable::print(PENDING_EXCEPTION, tty); 2930 vm_exit_during_initialization("ClassLoader::initialize_module_path() failed unexpectedly"); 2931 } 2932 #endif 2933 2934 #if INCLUDE_JVMCI 2935 if (force_JVMCI_intialization) { 2936 JVMCI::initialize_compiler(CHECK_JNI_ERR); 2937 CompileBroker::compilation_init_phase2(); 2938 } 2939 #endif 2940 2941 // Always call even when there are not JVMTI environments yet, since environments 2942 // may be attached late and JVMTI must track phases of VM execution 2943 JvmtiExport::enter_live_phase(); 2944 2945 // Make perfmemory accessible 2946 PerfMemory::set_accessible(true); 2947 2948 // Notify JVMTI agents that VM initialization is complete - nop if no agents. 2949 JvmtiExport::post_vm_initialized(); 2950 2951 JFR_ONLY(Jfr::on_create_vm_3();) 2952 2953 #if INCLUDE_MANAGEMENT 2954 Management::initialize(THREAD); 2955 2956 if (HAS_PENDING_EXCEPTION) { 2957 // management agent fails to start possibly due to 2958 // configuration problem and is responsible for printing 2959 // stack trace if appropriate. Simply exit VM. 2960 vm_exit(1); 2961 } 2962 #endif // INCLUDE_MANAGEMENT 2963 2964 StatSampler::engage(); 2965 if (CheckJNICalls) JniPeriodicChecker::engage(); 2966 2967 #if INCLUDE_RTM_OPT 2968 RTMLockingCounters::init(); 2969 #endif 2970 2971 call_postVMInitHook(THREAD); 2972 // The Java side of PostVMInitHook.run must deal with all 2973 // exceptions and provide means of diagnosis. 2974 if (HAS_PENDING_EXCEPTION) { 2975 CLEAR_PENDING_EXCEPTION; 2976 } 2977 2978 { 2979 MutexLocker ml(PeriodicTask_lock); 2980 // Make sure the WatcherThread can be started by WatcherThread::start() 2981 // or by dynamic enrollment. 2982 WatcherThread::make_startable(); 2983 // Start up the WatcherThread if there are any periodic tasks 2984 // NOTE: All PeriodicTasks should be registered by now. If they 2985 // aren't, late joiners might appear to start slowly (we might 2986 // take a while to process their first tick). 2987 if (PeriodicTask::num_tasks() > 0) { 2988 WatcherThread::start(); 2989 } 2990 } 2991 2992 create_vm_timer.end(); 2993 #ifdef ASSERT 2994 _vm_complete = true; 2995 #endif 2996 2997 if (DumpSharedSpaces) { 2998 MetaspaceShared::preload_and_dump(); 2999 ShouldNotReachHere(); 3000 } 3001 3002 return JNI_OK; 3003 } 3004 3005 // type for the Agent_OnLoad and JVM_OnLoad entry points 3006 extern "C" { 3007 typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *); 3008 } 3009 // Find a command line agent library and return its entry point for 3010 // -agentlib: -agentpath: -Xrun 3011 // num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array. 3012 static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, 3013 const char *on_load_symbols[], 3014 size_t num_symbol_entries) { 3015 OnLoadEntry_t on_load_entry = NULL; 3016 void *library = NULL; 3017 3018 if (!agent->valid()) { 3019 char buffer[JVM_MAXPATHLEN]; 3020 char ebuf[1024] = ""; 3021 const char *name = agent->name(); 3022 const char *msg = "Could not find agent library "; 3023 3024 // First check to see if agent is statically linked into executable 3025 if (os::find_builtin_agent(agent, on_load_symbols, num_symbol_entries)) { 3026 library = agent->os_lib(); 3027 } else if (agent->is_absolute_path()) { 3028 library = os::dll_load(name, ebuf, sizeof ebuf); 3029 if (library == NULL) { 3030 const char *sub_msg = " in absolute path, with error: "; 3031 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; 3032 char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread); 3033 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); 3034 // If we can't find the agent, exit. 3035 vm_exit_during_initialization(buf, NULL); 3036 FREE_C_HEAP_ARRAY(char, buf); 3037 } 3038 } else { 3039 // Try to load the agent from the standard dll directory 3040 if (os::dll_locate_lib(buffer, sizeof(buffer), Arguments::get_dll_dir(), 3041 name)) { 3042 library = os::dll_load(buffer, ebuf, sizeof ebuf); 3043 } 3044 if (library == NULL) { // Try the library path directory. 3045 if (os::dll_build_name(buffer, sizeof(buffer), name)) { 3046 library = os::dll_load(buffer, ebuf, sizeof ebuf); 3047 } 3048 if (library == NULL) { 3049 const char *sub_msg = " on the library path, with error: "; 3050 const char *sub_msg2 = "\nModule java.instrument may be missing from runtime image."; 3051 3052 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + 3053 strlen(ebuf) + strlen(sub_msg2) + 1; 3054 char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread); 3055 if (!agent->is_instrument_lib()) { 3056 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); 3057 } else { 3058 jio_snprintf(buf, len, "%s%s%s%s%s", msg, name, sub_msg, ebuf, sub_msg2); 3059 } 3060 // If we can't find the agent, exit. 3061 vm_exit_during_initialization(buf, NULL); 3062 FREE_C_HEAP_ARRAY(char, buf); 3063 } 3064 } 3065 } 3066 agent->set_os_lib(library); 3067 agent->set_valid(); 3068 } 3069 3070 // Find the OnLoad function. 3071 on_load_entry = 3072 CAST_TO_FN_PTR(OnLoadEntry_t, os::find_agent_function(agent, 3073 false, 3074 on_load_symbols, 3075 num_symbol_entries)); 3076 return on_load_entry; 3077 } 3078 3079 // Find the JVM_OnLoad entry point 3080 static OnLoadEntry_t lookup_jvm_on_load(AgentLibrary* agent) { 3081 const char *on_load_symbols[] = JVM_ONLOAD_SYMBOLS; 3082 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); 3083 } 3084 3085 // Find the Agent_OnLoad entry point 3086 static OnLoadEntry_t lookup_agent_on_load(AgentLibrary* agent) { 3087 const char *on_load_symbols[] = AGENT_ONLOAD_SYMBOLS; 3088 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); 3089 } 3090 3091 // For backwards compatibility with -Xrun 3092 // Convert libraries with no JVM_OnLoad, but which have Agent_OnLoad to be 3093 // treated like -agentpath: 3094 // Must be called before agent libraries are created 3095 void Threads::convert_vm_init_libraries_to_agents() { 3096 AgentLibrary* agent; 3097 AgentLibrary* next; 3098 3099 for (agent = Arguments::libraries(); agent != NULL; agent = next) { 3100 next = agent->next(); // cache the next agent now as this agent may get moved off this list 3101 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); 3102 3103 // If there is an JVM_OnLoad function it will get called later, 3104 // otherwise see if there is an Agent_OnLoad 3105 if (on_load_entry == NULL) { 3106 on_load_entry = lookup_agent_on_load(agent); 3107 if (on_load_entry != NULL) { 3108 // switch it to the agent list -- so that Agent_OnLoad will be called, 3109 // JVM_OnLoad won't be attempted and Agent_OnUnload will 3110 Arguments::convert_library_to_agent(agent); 3111 } else { 3112 vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name()); 3113 } 3114 } 3115 } 3116 } 3117 3118 // Create agents for -agentlib: -agentpath: and converted -Xrun 3119 // Invokes Agent_OnLoad 3120 // Called very early -- before JavaThreads exist 3121 void Threads::create_vm_init_agents() { 3122 extern struct JavaVM_ main_vm; 3123 AgentLibrary* agent; 3124 3125 JvmtiExport::enter_onload_phase(); 3126 3127 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) { 3128 // CDS dumping does not support native JVMTI agent. 3129 // CDS dumping supports Java agent if the AllowArchivingWithJavaAgent diagnostic option is specified. 3130 if (Arguments::is_dumping_archive()) { 3131 if(!agent->is_instrument_lib()) { 3132 vm_exit_during_cds_dumping("CDS dumping does not support native JVMTI agent, name", agent->name()); 3133 } else if (!AllowArchivingWithJavaAgent) { 3134 vm_exit_during_cds_dumping( 3135 "Must enable AllowArchivingWithJavaAgent in order to run Java agent during CDS dumping"); 3136 } 3137 } 3138 3139 OnLoadEntry_t on_load_entry = lookup_agent_on_load(agent); 3140 3141 if (on_load_entry != NULL) { 3142 // Invoke the Agent_OnLoad function 3143 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); 3144 if (err != JNI_OK) { 3145 vm_exit_during_initialization("agent library failed to init", agent->name()); 3146 } 3147 } else { 3148 vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name()); 3149 } 3150 } 3151 3152 JvmtiExport::enter_primordial_phase(); 3153 } 3154 3155 extern "C" { 3156 typedef void (JNICALL *Agent_OnUnload_t)(JavaVM *); 3157 } 3158 3159 void Threads::shutdown_vm_agents() { 3160 // Send any Agent_OnUnload notifications 3161 const char *on_unload_symbols[] = AGENT_ONUNLOAD_SYMBOLS; 3162 size_t num_symbol_entries = ARRAY_SIZE(on_unload_symbols); 3163 extern struct JavaVM_ main_vm; 3164 for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) { 3165 3166 // Find the Agent_OnUnload function. 3167 Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t, 3168 os::find_agent_function(agent, 3169 false, 3170 on_unload_symbols, 3171 num_symbol_entries)); 3172 3173 // Invoke the Agent_OnUnload function 3174 if (unload_entry != NULL) { 3175 JavaThread* thread = JavaThread::current(); 3176 ThreadToNativeFromVM ttn(thread); 3177 HandleMark hm(thread); 3178 (*unload_entry)(&main_vm); 3179 } 3180 } 3181 } 3182 3183 // Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries 3184 // Invokes JVM_OnLoad 3185 void Threads::create_vm_init_libraries() { 3186 extern struct JavaVM_ main_vm; 3187 AgentLibrary* agent; 3188 3189 for (agent = Arguments::libraries(); agent != NULL; agent = agent->next()) { 3190 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); 3191 3192 if (on_load_entry != NULL) { 3193 // Invoke the JVM_OnLoad function 3194 JavaThread* thread = JavaThread::current(); 3195 ThreadToNativeFromVM ttn(thread); 3196 HandleMark hm(thread); 3197 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); 3198 if (err != JNI_OK) { 3199 vm_exit_during_initialization("-Xrun library failed to init", agent->name()); 3200 } 3201 } else { 3202 vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name()); 3203 } 3204 } 3205 } 3206 3207 3208 // Last thread running calls java.lang.Shutdown.shutdown() 3209 void JavaThread::invoke_shutdown_hooks() { 3210 HandleMark hm(this); 3211 3212 // We could get here with a pending exception, if so clear it now or 3213 // it will cause MetaspaceShared::link_shared_classes to 3214 // fail for dynamic dump. 3215 if (this->has_pending_exception()) { 3216 this->clear_pending_exception(); 3217 } 3218 3219 #if INCLUDE_CDS 3220 // Link all classes for dynamic CDS dumping before vm exit. 3221 // Same operation is being done in JVM_BeforeHalt for handling the 3222 // case where the application calls System.exit(). 3223 if (DynamicArchive::should_dump_at_vm_exit()) { 3224 DynamicArchive::prepare_for_dump_at_exit(); 3225 } 3226 #endif 3227 3228 EXCEPTION_MARK; 3229 Klass* shutdown_klass = 3230 SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(), 3231 THREAD); 3232 if (shutdown_klass != NULL) { 3233 // SystemDictionary::resolve_or_null will return null if there was 3234 // an exception. If we cannot load the Shutdown class, just don't 3235 // call Shutdown.shutdown() at all. This will mean the shutdown hooks 3236 // won't be run. Note that if a shutdown hook was registered, 3237 // the Shutdown class would have already been loaded 3238 // (Runtime.addShutdownHook will load it). 3239 JavaValue result(T_VOID); 3240 JavaCalls::call_static(&result, 3241 shutdown_klass, 3242 vmSymbols::shutdown_name(), 3243 vmSymbols::void_method_signature(), 3244 THREAD); 3245 } 3246 CLEAR_PENDING_EXCEPTION; 3247 } 3248 3249 // Threads::destroy_vm() is normally called from jni_DestroyJavaVM() when 3250 // the program falls off the end of main(). Another VM exit path is through 3251 // vm_exit() when the program calls System.exit() to return a value or when 3252 // there is a serious error in VM. The two shutdown paths are not exactly 3253 // the same, but they share Shutdown.shutdown() at Java level and before_exit() 3254 // and VM_Exit op at VM level. 3255 // 3256 // Shutdown sequence: 3257 // + Shutdown native memory tracking if it is on 3258 // + Wait until we are the last non-daemon thread to execute 3259 // <-- every thing is still working at this moment --> 3260 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level 3261 // shutdown hooks 3262 // + Call before_exit(), prepare for VM exit 3263 // > run VM level shutdown hooks (they are registered through JVM_OnExit(), 3264 // currently the only user of this mechanism is File.deleteOnExit()) 3265 // > stop StatSampler, watcher thread, 3266 // post thread end and vm death events to JVMTI, 3267 // stop signal thread 3268 // + Call JavaThread::exit(), it will: 3269 // > release JNI handle blocks, remove stack guard pages 3270 // > remove this thread from Threads list 3271 // <-- no more Java code from this thread after this point --> 3272 // + Stop VM thread, it will bring the remaining VM to a safepoint and stop 3273 // the compiler threads at safepoint 3274 // <-- do not use anything that could get blocked by Safepoint --> 3275 // + Disable tracing at JNI/JVM barriers 3276 // + Set _vm_exited flag for threads that are still running native code 3277 // + Call exit_globals() 3278 // > deletes tty 3279 // > deletes PerfMemory resources 3280 // + Delete this thread 3281 // + Return to caller 3282 3283 void Threads::destroy_vm() { 3284 JavaThread* thread = JavaThread::current(); 3285 3286 #ifdef ASSERT 3287 _vm_complete = false; 3288 #endif 3289 // Wait until we are the last non-daemon thread to execute 3290 { 3291 MonitorLocker nu(Threads_lock); 3292 while (Threads::number_of_non_daemon_threads() > 1) 3293 // This wait should make safepoint checks, wait without a timeout. 3294 nu.wait(0); 3295 } 3296 3297 EventShutdown e; 3298 if (e.should_commit()) { 3299 e.set_reason("No remaining non-daemon Java threads"); 3300 e.commit(); 3301 } 3302 3303 // Hang forever on exit if we are reporting an error. 3304 if (ShowMessageBoxOnError && VMError::is_error_reported()) { 3305 os::infinite_sleep(); 3306 } 3307 os::wait_for_keypress_at_exit(); 3308 3309 // run Java level shutdown hooks 3310 thread->invoke_shutdown_hooks(); 3311 3312 before_exit(thread); 3313 3314 thread->exit(true); 3315 3316 // We are no longer on the main thread list but could still be in a 3317 // secondary list where another thread may try to interact with us. 3318 // So wait until all such interactions are complete before we bring 3319 // the VM to the termination safepoint. Normally this would be done 3320 // using thread->smr_delete() below where we delete the thread, but 3321 // we can't call that after the termination safepoint is active as 3322 // we will deadlock on the Threads_lock. Once all interactions are 3323 // complete it is safe to directly delete the thread at any time. 3324 ThreadsSMRSupport::wait_until_not_protected(thread); 3325 3326 HeapObjectStatistics::shutdown(); 3327 3328 // Stop VM thread. 3329 { 3330 // 4945125 The vm thread comes to a safepoint during exit. 3331 // GC vm_operations can get caught at the safepoint, and the 3332 // heap is unparseable if they are caught. Grab the Heap_lock 3333 // to prevent this. The GC vm_operations will not be able to 3334 // queue until after the vm thread is dead. After this point, 3335 // we'll never emerge out of the safepoint before the VM exits. 3336 // Assert that the thread is terminated so that acquiring the 3337 // Heap_lock doesn't cause the terminated thread to participate in 3338 // the safepoint protocol. 3339 3340 assert(thread->is_terminated(), "must be terminated here"); 3341 MutexLocker ml(Heap_lock); 3342 3343 VMThread::wait_for_vm_thread_exit(); 3344 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint"); 3345 VMThread::destroy(); 3346 } 3347 3348 // Now, all Java threads are gone except daemon threads. Daemon threads 3349 // running Java code or in VM are stopped by the Safepoint. However, 3350 // daemon threads executing native code are still running. But they 3351 // will be stopped at native=>Java/VM barriers. Note that we can't 3352 // simply kill or suspend them, as it is inherently deadlock-prone. 3353 3354 VM_Exit::set_vm_exited(); 3355 3356 // Clean up ideal graph printers after the VMThread has started 3357 // the final safepoint which will block all the Compiler threads. 3358 // Note that this Thread has already logically exited so the 3359 // clean_up() function's use of a JavaThreadIteratorWithHandle 3360 // would be a problem except set_vm_exited() has remembered the 3361 // shutdown thread which is granted a policy exception. 3362 #if defined(COMPILER2) && !defined(PRODUCT) 3363 IdealGraphPrinter::clean_up(); 3364 #endif 3365 3366 notify_vm_shutdown(); 3367 3368 // exit_globals() will delete tty 3369 exit_globals(); 3370 3371 // Deleting the shutdown thread here is safe. See comment on 3372 // wait_until_not_protected() above. 3373 delete thread; 3374 3375 #if INCLUDE_JVMCI 3376 if (JVMCICounterSize > 0) { 3377 FREE_C_HEAP_ARRAY(jlong, JavaThread::_jvmci_old_thread_counters); 3378 } 3379 #endif 3380 3381 LogConfiguration::finalize(); 3382 } 3383 3384 3385 jboolean Threads::is_supported_jni_version_including_1_1(jint version) { 3386 if (version == JNI_VERSION_1_1) return JNI_TRUE; 3387 return is_supported_jni_version(version); 3388 } 3389 3390 3391 jboolean Threads::is_supported_jni_version(jint version) { 3392 if (version == JNI_VERSION_1_2) return JNI_TRUE; 3393 if (version == JNI_VERSION_1_4) return JNI_TRUE; 3394 if (version == JNI_VERSION_1_6) return JNI_TRUE; 3395 if (version == JNI_VERSION_1_8) return JNI_TRUE; 3396 if (version == JNI_VERSION_9) return JNI_TRUE; 3397 if (version == JNI_VERSION_10) return JNI_TRUE; 3398 return JNI_FALSE; 3399 } 3400 3401 3402 void Threads::add(JavaThread* p, bool force_daemon) { 3403 // The threads lock must be owned at this point 3404 assert(Threads_lock->owned_by_self(), "must have threads lock"); 3405 3406 BarrierSet::barrier_set()->on_thread_attach(p); 3407 3408 // Once a JavaThread is added to the Threads list, smr_delete() has 3409 // to be used to delete it. Otherwise we can just delete it directly. 3410 p->set_on_thread_list(); 3411 3412 _number_of_threads++; 3413 oop threadObj = p->threadObj(); 3414 bool daemon = true; 3415 // Bootstrapping problem: threadObj can be null for initial 3416 // JavaThread (or for threads attached via JNI) 3417 if ((!force_daemon) && !is_daemon((threadObj))) { 3418 _number_of_non_daemon_threads++; 3419 daemon = false; 3420 } 3421 3422 ThreadService::add_thread(p, daemon); 3423 3424 // Maintain fast thread list 3425 ThreadsSMRSupport::add_thread(p); 3426 3427 // Increase the ObjectMonitor ceiling for the new thread. 3428 ObjectSynchronizer::inc_in_use_list_ceiling(); 3429 3430 // Possible GC point. 3431 Events::log(p, "Thread added: " INTPTR_FORMAT, p2i(p)); 3432 3433 // Make new thread known to active EscapeBarrier 3434 EscapeBarrier::thread_added(p); 3435 } 3436 3437 void Threads::remove(JavaThread* p, bool is_daemon) { 3438 // Extra scope needed for Thread_lock, so we can check 3439 // that we do not remove thread without safepoint code notice 3440 { MonitorLocker ml(Threads_lock); 3441 3442 // BarrierSet state must be destroyed after the last thread transition 3443 // before the thread terminates. Thread transitions result in calls to 3444 // StackWatermarkSet::on_safepoint(), which performs GC processing, 3445 // requiring the GC state to be alive. 3446 BarrierSet::barrier_set()->on_thread_detach(p); 3447 3448 assert(ThreadsSMRSupport::get_java_thread_list()->includes(p), "p must be present"); 3449 3450 // Maintain fast thread list 3451 ThreadsSMRSupport::remove_thread(p); 3452 3453 _number_of_threads--; 3454 if (!is_daemon) { 3455 _number_of_non_daemon_threads--; 3456 3457 // Only one thread left, do a notify on the Threads_lock so a thread waiting 3458 // on destroy_vm will wake up. 3459 if (number_of_non_daemon_threads() == 1) { 3460 ml.notify_all(); 3461 } 3462 } 3463 ThreadService::remove_thread(p, is_daemon); 3464 3465 // Make sure that safepoint code disregard this thread. This is needed since 3466 // the thread might mess around with locks after this point. This can cause it 3467 // to do callbacks into the safepoint code. However, the safepoint code is not aware 3468 // of this thread since it is removed from the queue. 3469 p->set_terminated(JavaThread::_thread_terminated); 3470 3471 // Notify threads waiting in EscapeBarriers 3472 EscapeBarrier::thread_removed(p); 3473 } // unlock Threads_lock 3474 3475 // Reduce the ObjectMonitor ceiling for the exiting thread. 3476 ObjectSynchronizer::dec_in_use_list_ceiling(); 3477 3478 // Since Events::log uses a lock, we grab it outside the Threads_lock 3479 Events::log(p, "Thread exited: " INTPTR_FORMAT, p2i(p)); 3480 } 3481 3482 // Operations on the Threads list for GC. These are not explicitly locked, 3483 // but the garbage collector must provide a safe context for them to run. 3484 // In particular, these things should never be called when the Threads_lock 3485 // is held by some other thread. (Note: the Safepoint abstraction also 3486 // uses the Threads_lock to guarantee this property. It also makes sure that 3487 // all threads gets blocked when exiting or starting). 3488 3489 void Threads::oops_do(OopClosure* f, CodeBlobClosure* cf) { 3490 ALL_JAVA_THREADS(p) { 3491 p->oops_do(f, cf); 3492 } 3493 VMThread::vm_thread()->oops_do(f, cf); 3494 } 3495 3496 void Threads::change_thread_claim_token() { 3497 if (++_thread_claim_token == 0) { 3498 // On overflow of the token counter, there is a risk of future 3499 // collisions between a new global token value and a stale token 3500 // for a thread, because not all iterations visit all threads. 3501 // (Though it's pretty much a theoretical concern for non-trivial 3502 // token counter sizes.) To deal with the possibility, reset all 3503 // the thread tokens to zero on global token overflow. 3504 struct ResetClaims : public ThreadClosure { 3505 virtual void do_thread(Thread* t) { 3506 t->claim_threads_do(false, 0); 3507 } 3508 } reset_claims; 3509 Threads::threads_do(&reset_claims); 3510 // On overflow, update the global token to non-zero, to 3511 // avoid the special "never claimed" initial thread value. 3512 _thread_claim_token = 1; 3513 } 3514 } 3515 3516 #ifdef ASSERT 3517 void assert_thread_claimed(const char* kind, Thread* t, uintx expected) { 3518 const uintx token = t->threads_do_token(); 3519 assert(token == expected, 3520 "%s " PTR_FORMAT " has incorrect value " UINTX_FORMAT " != " 3521 UINTX_FORMAT, kind, p2i(t), token, expected); 3522 } 3523 3524 void Threads::assert_all_threads_claimed() { 3525 ALL_JAVA_THREADS(p) { 3526 assert_thread_claimed("Thread", p, _thread_claim_token); 3527 } 3528 assert_thread_claimed("VMThread", VMThread::vm_thread(), _thread_claim_token); 3529 } 3530 #endif // ASSERT 3531 3532 class ParallelOopsDoThreadClosure : public ThreadClosure { 3533 private: 3534 OopClosure* _f; 3535 CodeBlobClosure* _cf; 3536 public: 3537 ParallelOopsDoThreadClosure(OopClosure* f, CodeBlobClosure* cf) : _f(f), _cf(cf) {} 3538 void do_thread(Thread* t) { 3539 t->oops_do(_f, _cf); 3540 } 3541 }; 3542 3543 void Threads::possibly_parallel_oops_do(bool is_par, OopClosure* f, CodeBlobClosure* cf) { 3544 ParallelOopsDoThreadClosure tc(f, cf); 3545 possibly_parallel_threads_do(is_par, &tc); 3546 } 3547 3548 void Threads::metadata_do(MetadataClosure* f) { 3549 ALL_JAVA_THREADS(p) { 3550 p->metadata_do(f); 3551 } 3552 } 3553 3554 class ThreadHandlesClosure : public ThreadClosure { 3555 void (*_f)(Metadata*); 3556 public: 3557 ThreadHandlesClosure(void f(Metadata*)) : _f(f) {} 3558 virtual void do_thread(Thread* thread) { 3559 thread->metadata_handles_do(_f); 3560 } 3561 }; 3562 3563 void Threads::metadata_handles_do(void f(Metadata*)) { 3564 // Only walk the Handles in Thread. 3565 ThreadHandlesClosure handles_closure(f); 3566 threads_do(&handles_closure); 3567 } 3568 3569 // Get count Java threads that are waiting to enter the specified monitor. 3570 GrowableArray<JavaThread*>* Threads::get_pending_threads(ThreadsList * t_list, 3571 int count, 3572 address monitor) { 3573 GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count); 3574 3575 int i = 0; 3576 for (JavaThread* p : *t_list) { 3577 if (!p->can_call_java()) continue; 3578 3579 // The first stage of async deflation does not affect any field 3580 // used by this comparison so the ObjectMonitor* is usable here. 3581 address pending = (address)p->current_pending_monitor(); 3582 if (pending == monitor) { // found a match 3583 if (i < count) result->append(p); // save the first count matches 3584 i++; 3585 } 3586 } 3587 3588 return result; 3589 } 3590 3591 3592 JavaThread *Threads::owning_thread_from_monitor_owner(ThreadsList * t_list, 3593 address owner) { 3594 // NULL owner means not locked so we can skip the search 3595 if (owner == NULL) return NULL; 3596 3597 for (JavaThread* p : *t_list) { 3598 // first, see if owner is the address of a Java thread 3599 if (owner == (address)p) return p; 3600 } 3601 3602 // Cannot assert on lack of success here since this function may be 3603 // used by code that is trying to report useful problem information 3604 // like deadlock detection. 3605 if (UseHeavyMonitors) return NULL; 3606 3607 // If we didn't find a matching Java thread and we didn't force use of 3608 // heavyweight monitors, then the owner is the stack address of the 3609 // Lock Word in the owning Java thread's stack. 3610 // 3611 JavaThread* the_owner = NULL; 3612 for (JavaThread* q : *t_list) { 3613 if (q->is_lock_owned(owner)) { 3614 the_owner = q; 3615 break; 3616 } 3617 } 3618 3619 // cannot assert on lack of success here; see above comment 3620 return the_owner; 3621 } 3622 3623 class PrintOnClosure : public ThreadClosure { 3624 private: 3625 outputStream* _st; 3626 3627 public: 3628 PrintOnClosure(outputStream* st) : 3629 _st(st) {} 3630 3631 virtual void do_thread(Thread* thread) { 3632 if (thread != NULL) { 3633 thread->print_on(_st); 3634 _st->cr(); 3635 } 3636 } 3637 }; 3638 3639 // Threads::print_on() is called at safepoint by VM_PrintThreads operation. 3640 void Threads::print_on(outputStream* st, bool print_stacks, 3641 bool internal_format, bool print_concurrent_locks, 3642 bool print_extended_info) { 3643 char buf[32]; 3644 st->print_raw_cr(os::local_time_string(buf, sizeof(buf))); 3645 3646 st->print_cr("Full thread dump %s (%s %s):", 3647 VM_Version::vm_name(), 3648 VM_Version::vm_release(), 3649 VM_Version::vm_info_string()); 3650 st->cr(); 3651 3652 #if INCLUDE_SERVICES 3653 // Dump concurrent locks 3654 ConcurrentLocksDump concurrent_locks; 3655 if (print_concurrent_locks) { 3656 concurrent_locks.dump_at_safepoint(); 3657 } 3658 #endif // INCLUDE_SERVICES 3659 3660 ThreadsSMRSupport::print_info_on(st); 3661 st->cr(); 3662 3663 ALL_JAVA_THREADS(p) { 3664 ResourceMark rm; 3665 p->print_on(st, print_extended_info); 3666 if (print_stacks) { 3667 if (internal_format) { 3668 p->trace_stack(); 3669 } else { 3670 p->print_stack_on(st); 3671 } 3672 } 3673 st->cr(); 3674 #if INCLUDE_SERVICES 3675 if (print_concurrent_locks) { 3676 concurrent_locks.print_locks_on(p, st); 3677 } 3678 #endif // INCLUDE_SERVICES 3679 } 3680 3681 PrintOnClosure cl(st); 3682 cl.do_thread(VMThread::vm_thread()); 3683 Universe::heap()->gc_threads_do(&cl); 3684 if (StringDedup::is_enabled()) { 3685 StringDedup::threads_do(&cl); 3686 } 3687 cl.do_thread(WatcherThread::watcher_thread()); 3688 cl.do_thread(AsyncLogWriter::instance()); 3689 3690 st->flush(); 3691 } 3692 3693 void Threads::print_on_error(Thread* this_thread, outputStream* st, Thread* current, char* buf, 3694 int buflen, bool* found_current) { 3695 if (this_thread != NULL) { 3696 bool is_current = (current == this_thread); 3697 *found_current = *found_current || is_current; 3698 st->print("%s", is_current ? "=>" : " "); 3699 3700 st->print(PTR_FORMAT, p2i(this_thread)); 3701 st->print(" "); 3702 this_thread->print_on_error(st, buf, buflen); 3703 st->cr(); 3704 } 3705 } 3706 3707 class PrintOnErrorClosure : public ThreadClosure { 3708 outputStream* _st; 3709 Thread* _current; 3710 char* _buf; 3711 int _buflen; 3712 bool* _found_current; 3713 public: 3714 PrintOnErrorClosure(outputStream* st, Thread* current, char* buf, 3715 int buflen, bool* found_current) : 3716 _st(st), _current(current), _buf(buf), _buflen(buflen), _found_current(found_current) {} 3717 3718 virtual void do_thread(Thread* thread) { 3719 Threads::print_on_error(thread, _st, _current, _buf, _buflen, _found_current); 3720 } 3721 }; 3722 3723 // Threads::print_on_error() is called by fatal error handler. It's possible 3724 // that VM is not at safepoint and/or current thread is inside signal handler. 3725 // Don't print stack trace, as the stack may not be walkable. Don't allocate 3726 // memory (even in resource area), it might deadlock the error handler. 3727 void Threads::print_on_error(outputStream* st, Thread* current, char* buf, 3728 int buflen) { 3729 ThreadsSMRSupport::print_info_on(st); 3730 st->cr(); 3731 3732 bool found_current = false; 3733 st->print_cr("Java Threads: ( => current thread )"); 3734 ALL_JAVA_THREADS(thread) { 3735 print_on_error(thread, st, current, buf, buflen, &found_current); 3736 } 3737 st->cr(); 3738 3739 st->print_cr("Other Threads:"); 3740 print_on_error(VMThread::vm_thread(), st, current, buf, buflen, &found_current); 3741 print_on_error(WatcherThread::watcher_thread(), st, current, buf, buflen, &found_current); 3742 print_on_error(AsyncLogWriter::instance(), st, current, buf, buflen, &found_current); 3743 3744 if (Universe::heap() != NULL) { 3745 PrintOnErrorClosure print_closure(st, current, buf, buflen, &found_current); 3746 Universe::heap()->gc_threads_do(&print_closure); 3747 } 3748 3749 if (StringDedup::is_enabled()) { 3750 PrintOnErrorClosure print_closure(st, current, buf, buflen, &found_current); 3751 StringDedup::threads_do(&print_closure); 3752 } 3753 3754 if (!found_current) { 3755 st->cr(); 3756 st->print("=>" PTR_FORMAT " (exited) ", p2i(current)); 3757 current->print_on_error(st, buf, buflen); 3758 st->cr(); 3759 } 3760 st->cr(); 3761 3762 st->print_cr("Threads with active compile tasks:"); 3763 print_threads_compiling(st, buf, buflen); 3764 } 3765 3766 void Threads::print_threads_compiling(outputStream* st, char* buf, int buflen, bool short_form) { 3767 ALL_JAVA_THREADS(thread) { 3768 if (thread->is_Compiler_thread()) { 3769 CompilerThread* ct = (CompilerThread*) thread; 3770 3771 // Keep task in local variable for NULL check. 3772 // ct->_task might be set to NULL by concurring compiler thread 3773 // because it completed the compilation. The task is never freed, 3774 // though, just returned to a free list. 3775 CompileTask* task = ct->task(); 3776 if (task != NULL) { 3777 thread->print_name_on_error(st, buf, buflen); 3778 st->print(" "); 3779 task->print(st, NULL, short_form, true); 3780 } 3781 } 3782 } 3783 } 3784 3785 3786 // Ad-hoc mutual exclusion primitives: SpinLock 3787 // 3788 // We employ SpinLocks _only for low-contention, fixed-length 3789 // short-duration critical sections where we're concerned 3790 // about native mutex_t or HotSpot Mutex:: latency. 3791 // 3792 // TODO-FIXME: ListLock should be of type SpinLock. 3793 // We should make this a 1st-class type, integrated into the lock 3794 // hierarchy as leaf-locks. Critically, the SpinLock structure 3795 // should have sufficient padding to avoid false-sharing and excessive 3796 // cache-coherency traffic. 3797 3798 3799 typedef volatile int SpinLockT; 3800 3801 void Thread::SpinAcquire(volatile int * adr, const char * LockName) { 3802 if (Atomic::cmpxchg(adr, 0, 1) == 0) { 3803 return; // normal fast-path return 3804 } 3805 3806 // Slow-path : We've encountered contention -- Spin/Yield/Block strategy. 3807 int ctr = 0; 3808 int Yields = 0; 3809 for (;;) { 3810 while (*adr != 0) { 3811 ++ctr; 3812 if ((ctr & 0xFFF) == 0 || !os::is_MP()) { 3813 if (Yields > 5) { 3814 os::naked_short_sleep(1); 3815 } else { 3816 os::naked_yield(); 3817 ++Yields; 3818 } 3819 } else { 3820 SpinPause(); 3821 } 3822 } 3823 if (Atomic::cmpxchg(adr, 0, 1) == 0) return; 3824 } 3825 } 3826 3827 void Thread::SpinRelease(volatile int * adr) { 3828 assert(*adr != 0, "invariant"); 3829 OrderAccess::fence(); // guarantee at least release consistency. 3830 // Roach-motel semantics. 3831 // It's safe if subsequent LDs and STs float "up" into the critical section, 3832 // but prior LDs and STs within the critical section can't be allowed 3833 // to reorder or float past the ST that releases the lock. 3834 // Loads and stores in the critical section - which appear in program 3835 // order before the store that releases the lock - must also appear 3836 // before the store that releases the lock in memory visibility order. 3837 // Conceptually we need a #loadstore|#storestore "release" MEMBAR before 3838 // the ST of 0 into the lock-word which releases the lock, so fence 3839 // more than covers this on all platforms. 3840 *adr = 0; 3841 } 3842 3843 3844 void Threads::verify() { 3845 ALL_JAVA_THREADS(p) { 3846 p->verify(); 3847 } 3848 VMThread* thread = VMThread::vm_thread(); 3849 if (thread != NULL) thread->verify(); 3850 } 3851 3852 #ifndef PRODUCT 3853 void JavaThread::verify_cross_modify_fence_failure(JavaThread *thread) { 3854 report_vm_error(__FILE__, __LINE__, "Cross modify fence failure", "%p", thread); 3855 } 3856 #endif 3857 3858 // Helper function to create the java.lang.Thread object for a 3859 // VM-internal thread. The thread will have the given name, be 3860 // part of the System ThreadGroup and if is_visible is true will be 3861 // discoverable via the system ThreadGroup. 3862 Handle JavaThread::create_system_thread_object(const char* name, 3863 bool is_visible, TRAPS) { 3864 Handle string = java_lang_String::create_from_str(name, CHECK_NH); 3865 3866 // Initialize thread_oop to put it into the system threadGroup. 3867 // This is done by calling the Thread(ThreadGroup tg, String name) 3868 // constructor, which adds the new thread to the group as an unstarted 3869 // thread. 3870 Handle thread_group(THREAD, Universe::system_thread_group()); 3871 Handle thread_oop = 3872 JavaCalls::construct_new_instance(vmClasses::Thread_klass(), 3873 vmSymbols::threadgroup_string_void_signature(), 3874 thread_group, 3875 string, 3876 CHECK_NH); 3877 3878 // If the Thread is intended to be visible then we have to mimic what 3879 // Thread.start() would do, by adding it to its ThreadGroup: tg.add(t). 3880 if (is_visible) { 3881 Klass* group = vmClasses::ThreadGroup_klass(); 3882 JavaValue result(T_VOID); 3883 JavaCalls::call_special(&result, 3884 thread_group, 3885 group, 3886 vmSymbols::add_method_name(), 3887 vmSymbols::thread_void_signature(), 3888 thread_oop, 3889 CHECK_NH); 3890 } 3891 3892 return thread_oop; 3893 } 3894 3895 // Starts the target JavaThread as a daemon of the given priority, and 3896 // bound to the given java.lang.Thread instance. 3897 // The Threads_lock is held for the duration. 3898 void JavaThread::start_internal_daemon(JavaThread* current, JavaThread* target, 3899 Handle thread_oop, ThreadPriority prio) { 3900 3901 assert(target->osthread() != NULL, "target thread is not properly initialized"); 3902 3903 MutexLocker mu(current, Threads_lock); 3904 3905 // Initialize the fields of the thread_oop first. 3906 3907 java_lang_Thread::set_thread(thread_oop(), target); // isAlive == true now 3908 3909 if (prio != NoPriority) { 3910 java_lang_Thread::set_priority(thread_oop(), prio); 3911 // Note: we don't call os::set_priority here. Possibly we should, 3912 // else all threads should call it themselves when they first run. 3913 } 3914 3915 java_lang_Thread::set_daemon(thread_oop()); 3916 3917 // Now bind the thread_oop to the target JavaThread. 3918 target->set_threadObj(thread_oop()); 3919 3920 Threads::add(target); // target is now visible for safepoint/handshake 3921 Thread::start(target); 3922 } 3923 3924 void JavaThread::vm_exit_on_osthread_failure(JavaThread* thread) { 3925 // At this point it may be possible that no osthread was created for the 3926 // JavaThread due to lack of resources. However, since this must work 3927 // for critical system threads just check and abort if this fails. 3928 if (thread->osthread() == nullptr) { 3929 // This isn't really an OOM condition, but historically this is what 3930 // we report. 3931 vm_exit_during_initialization("java.lang.OutOfMemoryError", 3932 os::native_thread_creation_failed_msg()); 3933 } 3934 }