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