Mercurial > hg > truffle
annotate src/share/vm/runtime/thread.cpp @ 1483:ba37b9335e1e
New option "-graal" that sets up the correct boot class path and C1X options using only the two environment variables MAXINE and GRAAL.
This greatly simplifies command line arguments necessary to start the Graal VM.
| author | Thomas Wuerthinger <wuerthinger@ssw.jku.at> |
|---|---|
| date | Mon, 29 Nov 2010 16:58:26 +0100 |
| parents | 7cf1952ec5fb |
| children | 2d26b0046e0d |
| rev | line source |
|---|---|
| 0 | 1 /* |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1166
diff
changeset
|
2 * Copyright 1997-2010 Sun Microsystems, Inc. All Rights Reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
| 19 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, | |
| 20 * CA 95054 USA or visit www.sun.com if you need additional information or | |
| 21 * have any questions. | |
| 22 * | |
| 23 */ | |
| 24 | |
| 25 # include "incls/_precompiled.incl" | |
| 26 # include "incls/_thread.cpp.incl" | |
| 27 | |
| 28 #ifdef DTRACE_ENABLED | |
| 29 | |
| 30 // Only bother with this argument setup if dtrace is available | |
| 31 | |
| 32 HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin); | |
| 33 HS_DTRACE_PROBE_DECL(hotspot, vm__init__end); | |
| 34 HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t, | |
| 35 intptr_t, intptr_t, bool); | |
| 36 HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t, | |
| 37 intptr_t, intptr_t, bool); | |
| 38 | |
| 39 #define DTRACE_THREAD_PROBE(probe, javathread) \ | |
| 40 { \ | |
| 41 ResourceMark rm(this); \ | |
| 42 int len = 0; \ | |
| 43 const char* name = (javathread)->get_thread_name(); \ | |
| 44 len = strlen(name); \ | |
| 45 HS_DTRACE_PROBE5(hotspot, thread__##probe, \ | |
| 46 name, len, \ | |
| 47 java_lang_Thread::thread_id((javathread)->threadObj()), \ | |
| 48 (javathread)->osthread()->thread_id(), \ | |
| 49 java_lang_Thread::is_daemon((javathread)->threadObj())); \ | |
| 50 } | |
| 51 | |
| 52 #else // ndef DTRACE_ENABLED | |
| 53 | |
| 54 #define DTRACE_THREAD_PROBE(probe, javathread) | |
| 55 | |
| 56 #endif // ndef DTRACE_ENABLED | |
| 57 | |
| 58 // Class hierarchy | |
| 59 // - Thread | |
| 60 // - VMThread | |
| 61 // - WatcherThread | |
| 62 // - ConcurrentMarkSweepThread | |
| 63 // - JavaThread | |
| 64 // - CompilerThread | |
| 65 | |
| 66 // ======= Thread ======== | |
| 67 | |
| 68 // Support for forcing alignment of thread objects for biased locking | |
| 69 void* Thread::operator new(size_t size) { | |
| 70 if (UseBiasedLocking) { | |
| 71 const int alignment = markOopDesc::biased_lock_alignment; | |
| 72 size_t aligned_size = size + (alignment - sizeof(intptr_t)); | |
| 73 void* real_malloc_addr = CHeapObj::operator new(aligned_size); | |
| 74 void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment); | |
| 75 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <= | |
| 76 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), | |
| 77 "JavaThread alignment code overflowed allocated storage"); | |
| 78 if (TraceBiasedLocking) { | |
| 79 if (aligned_addr != real_malloc_addr) | |
| 80 tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT, | |
| 81 real_malloc_addr, aligned_addr); | |
| 82 } | |
| 83 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; | |
| 84 return aligned_addr; | |
| 85 } else { | |
| 86 return CHeapObj::operator new(size); | |
| 87 } | |
| 88 } | |
| 89 | |
| 90 void Thread::operator delete(void* p) { | |
| 91 if (UseBiasedLocking) { | |
| 92 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address; | |
| 93 CHeapObj::operator delete(real_malloc_addr); | |
| 94 } else { | |
| 95 CHeapObj::operator delete(p); | |
| 96 } | |
| 97 } | |
| 98 | |
| 99 | |
| 100 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread, | |
| 101 // JavaThread | |
| 102 | |
| 103 | |
| 104 Thread::Thread() { | |
| 105 // stack | |
| 106 _stack_base = NULL; | |
| 107 _stack_size = 0; | |
| 108 _self_raw_id = 0; | |
| 109 _lgrp_id = -1; | |
| 110 _osthread = NULL; | |
| 111 | |
| 112 // allocated data structures | |
| 113 set_resource_area(new ResourceArea()); | |
| 114 set_handle_area(new HandleArea(NULL)); | |
| 115 set_active_handles(NULL); | |
| 116 set_free_handle_block(NULL); | |
| 117 set_last_handle_mark(NULL); | |
| 118 set_osthread(NULL); | |
| 119 | |
| 120 // This initial value ==> never claimed. | |
| 121 _oops_do_parity = 0; | |
| 122 | |
| 123 // the handle mark links itself to last_handle_mark | |
| 124 new HandleMark(this); | |
| 125 | |
| 126 // plain initialization | |
| 127 debug_only(_owned_locks = NULL;) | |
| 128 debug_only(_allow_allocation_count = 0;) | |
| 129 NOT_PRODUCT(_allow_safepoint_count = 0;) | |
|
806
821269eca479
6820167: GCALotAtAllSafepoints + FullGCALot(ScavengeALot) options crash JVM
ysr
parents:
702
diff
changeset
|
130 NOT_PRODUCT(_skip_gcalot = false;) |
| 0 | 131 CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;) |
| 132 _jvmti_env_iteration_count = 0; | |
| 133 _vm_operation_started_count = 0; | |
| 134 _vm_operation_completed_count = 0; | |
| 135 _current_pending_monitor = NULL; | |
| 136 _current_pending_monitor_is_from_java = true; | |
| 137 _current_waiting_monitor = NULL; | |
| 138 _num_nested_signal = 0; | |
| 139 omFreeList = NULL ; | |
| 140 omFreeCount = 0 ; | |
| 141 omFreeProvision = 32 ; | |
| 142 | |
| 143 _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true); | |
| 144 _suspend_flags = 0; | |
| 145 | |
| 146 // thread-specific hashCode stream generator state - Marsaglia shift-xor form | |
| 147 _hashStateX = os::random() ; | |
| 148 _hashStateY = 842502087 ; | |
| 149 _hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ; | |
| 150 _hashStateW = 273326509 ; | |
| 151 | |
| 152 _OnTrap = 0 ; | |
| 153 _schedctl = NULL ; | |
| 154 _Stalled = 0 ; | |
| 155 _TypeTag = 0x2BAD ; | |
| 156 | |
| 157 // Many of the following fields are effectively final - immutable | |
| 158 // Note that nascent threads can't use the Native Monitor-Mutex | |
| 159 // construct until the _MutexEvent is initialized ... | |
| 160 // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents | |
| 161 // we might instead use a stack of ParkEvents that we could provision on-demand. | |
| 162 // The stack would act as a cache to avoid calls to ParkEvent::Allocate() | |
| 163 // and ::Release() | |
| 164 _ParkEvent = ParkEvent::Allocate (this) ; | |
| 165 _SleepEvent = ParkEvent::Allocate (this) ; | |
| 166 _MutexEvent = ParkEvent::Allocate (this) ; | |
| 167 _MuxEvent = ParkEvent::Allocate (this) ; | |
| 168 | |
| 169 #ifdef CHECK_UNHANDLED_OOPS | |
| 170 if (CheckUnhandledOops) { | |
| 171 _unhandled_oops = new UnhandledOops(this); | |
| 172 } | |
| 173 #endif // CHECK_UNHANDLED_OOPS | |
| 174 #ifdef ASSERT | |
| 175 if (UseBiasedLocking) { | |
| 176 assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed"); | |
| 177 assert(this == _real_malloc_address || | |
| 178 this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment), | |
| 179 "bug in forced alignment of thread objects"); | |
| 180 } | |
| 181 #endif /* ASSERT */ | |
| 182 } | |
| 183 | |
| 184 void Thread::initialize_thread_local_storage() { | |
| 185 // Note: Make sure this method only calls | |
| 186 // non-blocking operations. Otherwise, it might not work | |
| 187 // with the thread-startup/safepoint interaction. | |
| 188 | |
| 189 // During Java thread startup, safepoint code should allow this | |
| 190 // method to complete because it may need to allocate memory to | |
| 191 // store information for the new thread. | |
| 192 | |
| 193 // initialize structure dependent on thread local storage | |
| 194 ThreadLocalStorage::set_thread(this); | |
| 195 | |
| 196 // set up any platform-specific state. | |
| 197 os::initialize_thread(); | |
| 198 | |
| 199 } | |
| 200 | |
| 201 void Thread::record_stack_base_and_size() { | |
| 202 set_stack_base(os::current_stack_base()); | |
| 203 set_stack_size(os::current_stack_size()); | |
| 204 } | |
| 205 | |
| 206 | |
| 207 Thread::~Thread() { | |
| 208 // Reclaim the objectmonitors from the omFreeList of the moribund thread. | |
| 209 ObjectSynchronizer::omFlush (this) ; | |
| 210 | |
| 211 // deallocate data structures | |
| 212 delete resource_area(); | |
| 213 // since the handle marks are using the handle area, we have to deallocated the root | |
| 214 // handle mark before deallocating the thread's handle area, | |
| 215 assert(last_handle_mark() != NULL, "check we have an element"); | |
| 216 delete last_handle_mark(); | |
| 217 assert(last_handle_mark() == NULL, "check we have reached the end"); | |
| 218 | |
| 219 // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads. | |
| 220 // We NULL out the fields for good hygiene. | |
| 221 ParkEvent::Release (_ParkEvent) ; _ParkEvent = NULL ; | |
| 222 ParkEvent::Release (_SleepEvent) ; _SleepEvent = NULL ; | |
| 223 ParkEvent::Release (_MutexEvent) ; _MutexEvent = NULL ; | |
| 224 ParkEvent::Release (_MuxEvent) ; _MuxEvent = NULL ; | |
| 225 | |
| 226 delete handle_area(); | |
| 227 | |
| 228 // osthread() can be NULL, if creation of thread failed. | |
| 229 if (osthread() != NULL) os::free_thread(osthread()); | |
| 230 | |
| 231 delete _SR_lock; | |
| 232 | |
| 233 // clear thread local storage if the Thread is deleting itself | |
| 234 if (this == Thread::current()) { | |
| 235 ThreadLocalStorage::set_thread(NULL); | |
| 236 } else { | |
| 237 // In the case where we're not the current thread, invalidate all the | |
| 238 // caches in case some code tries to get the current thread or the | |
| 239 // thread that was destroyed, and gets stale information. | |
| 240 ThreadLocalStorage::invalidate_all(); | |
| 241 } | |
| 242 CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();) | |
| 243 } | |
| 244 | |
| 245 // NOTE: dummy function for assertion purpose. | |
| 246 void Thread::run() { | |
| 247 ShouldNotReachHere(); | |
| 248 } | |
| 249 | |
| 250 #ifdef ASSERT | |
| 251 // Private method to check for dangling thread pointer | |
| 252 void check_for_dangling_thread_pointer(Thread *thread) { | |
| 253 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(), | |
| 254 "possibility of dangling Thread pointer"); | |
| 255 } | |
| 256 #endif | |
| 257 | |
| 258 | |
| 259 #ifndef PRODUCT | |
| 260 // Tracing method for basic thread operations | |
| 261 void Thread::trace(const char* msg, const Thread* const thread) { | |
| 262 if (!TraceThreadEvents) return; | |
| 263 ResourceMark rm; | |
| 264 ThreadCritical tc; | |
| 265 const char *name = "non-Java thread"; | |
| 266 int prio = -1; | |
| 267 if (thread->is_Java_thread() | |
| 268 && !thread->is_Compiler_thread()) { | |
| 269 // The Threads_lock must be held to get information about | |
| 270 // this thread but may not be in some situations when | |
| 271 // tracing thread events. | |
| 272 bool release_Threads_lock = false; | |
| 273 if (!Threads_lock->owned_by_self()) { | |
| 274 Threads_lock->lock(); | |
| 275 release_Threads_lock = true; | |
| 276 } | |
| 277 JavaThread* jt = (JavaThread *)thread; | |
| 278 name = (char *)jt->get_thread_name(); | |
| 279 oop thread_oop = jt->threadObj(); | |
| 280 if (thread_oop != NULL) { | |
| 281 prio = java_lang_Thread::priority(thread_oop); | |
| 282 } | |
| 283 if (release_Threads_lock) { | |
| 284 Threads_lock->unlock(); | |
| 285 } | |
| 286 } | |
| 287 tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio); | |
| 288 } | |
| 289 #endif | |
| 290 | |
| 291 | |
| 292 ThreadPriority Thread::get_priority(const Thread* const thread) { | |
| 293 trace("get priority", thread); | |
| 294 ThreadPriority priority; | |
| 295 // Can return an error! | |
| 296 (void)os::get_priority(thread, priority); | |
| 297 assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found"); | |
| 298 return priority; | |
| 299 } | |
| 300 | |
| 301 void Thread::set_priority(Thread* thread, ThreadPriority priority) { | |
| 302 trace("set priority", thread); | |
| 303 debug_only(check_for_dangling_thread_pointer(thread);) | |
| 304 // Can return an error! | |
| 305 (void)os::set_priority(thread, priority); | |
| 306 } | |
| 307 | |
| 308 | |
| 309 void Thread::start(Thread* thread) { | |
| 310 trace("start", thread); | |
| 311 // Start is different from resume in that its safety is guaranteed by context or | |
| 312 // being called from a Java method synchronized on the Thread object. | |
| 313 if (!DisableStartThread) { | |
| 314 if (thread->is_Java_thread()) { | |
| 315 // Initialize the thread state to RUNNABLE before starting this thread. | |
| 316 // Can not set it after the thread started because we do not know the | |
| 317 // exact thread state at that time. It could be in MONITOR_WAIT or | |
| 318 // in SLEEPING or some other state. | |
| 319 java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(), | |
| 320 java_lang_Thread::RUNNABLE); | |
| 321 } | |
| 322 os::start_thread(thread); | |
| 323 } | |
| 324 } | |
| 325 | |
| 326 // Enqueue a VM_Operation to do the job for us - sometime later | |
| 327 void Thread::send_async_exception(oop java_thread, oop java_throwable) { | |
| 328 VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable); | |
| 329 VMThread::execute(vm_stop); | |
| 330 } | |
| 331 | |
| 332 | |
| 333 // | |
| 334 // Check if an external suspend request has completed (or has been | |
| 335 // cancelled). Returns true if the thread is externally suspended and | |
| 336 // false otherwise. | |
| 337 // | |
| 338 // The bits parameter returns information about the code path through | |
| 339 // the routine. Useful for debugging: | |
| 340 // | |
| 341 // set in is_ext_suspend_completed(): | |
| 342 // 0x00000001 - routine was entered | |
| 343 // 0x00000010 - routine return false at end | |
| 344 // 0x00000100 - thread exited (return false) | |
| 345 // 0x00000200 - suspend request cancelled (return false) | |
| 346 // 0x00000400 - thread suspended (return true) | |
| 347 // 0x00001000 - thread is in a suspend equivalent state (return true) | |
| 348 // 0x00002000 - thread is native and walkable (return true) | |
| 349 // 0x00004000 - thread is native_trans and walkable (needed retry) | |
| 350 // | |
| 351 // set in wait_for_ext_suspend_completion(): | |
| 352 // 0x00010000 - routine was entered | |
| 353 // 0x00020000 - suspend request cancelled before loop (return false) | |
| 354 // 0x00040000 - thread suspended before loop (return true) | |
| 355 // 0x00080000 - suspend request cancelled in loop (return false) | |
| 356 // 0x00100000 - thread suspended in loop (return true) | |
| 357 // 0x00200000 - suspend not completed during retry loop (return false) | |
| 358 // | |
| 359 | |
| 360 // Helper class for tracing suspend wait debug bits. | |
| 361 // | |
| 362 // 0x00000100 indicates that the target thread exited before it could | |
| 363 // self-suspend which is not a wait failure. 0x00000200, 0x00020000 and | |
| 364 // 0x00080000 each indicate a cancelled suspend request so they don't | |
| 365 // count as wait failures either. | |
| 366 #define DEBUG_FALSE_BITS (0x00000010 | 0x00200000) | |
| 367 | |
| 368 class TraceSuspendDebugBits : public StackObj { | |
| 369 private: | |
| 370 JavaThread * jt; | |
| 371 bool is_wait; | |
| 372 bool called_by_wait; // meaningful when !is_wait | |
| 373 uint32_t * bits; | |
| 374 | |
| 375 public: | |
| 376 TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait, | |
| 377 uint32_t *_bits) { | |
| 378 jt = _jt; | |
| 379 is_wait = _is_wait; | |
| 380 called_by_wait = _called_by_wait; | |
| 381 bits = _bits; | |
| 382 } | |
| 383 | |
| 384 ~TraceSuspendDebugBits() { | |
| 385 if (!is_wait) { | |
| 386 #if 1 | |
| 387 // By default, don't trace bits for is_ext_suspend_completed() calls. | |
| 388 // That trace is very chatty. | |
| 389 return; | |
| 390 #else | |
| 391 if (!called_by_wait) { | |
| 392 // If tracing for is_ext_suspend_completed() is enabled, then only | |
| 393 // trace calls to it from wait_for_ext_suspend_completion() | |
| 394 return; | |
| 395 } | |
| 396 #endif | |
| 397 } | |
| 398 | |
| 399 if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) { | |
| 400 if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) { | |
| 401 MutexLocker ml(Threads_lock); // needed for get_thread_name() | |
| 402 ResourceMark rm; | |
| 403 | |
| 404 tty->print_cr( | |
| 405 "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)", | |
| 406 jt->get_thread_name(), *bits); | |
| 407 | |
| 408 guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed"); | |
| 409 } | |
| 410 } | |
| 411 } | |
| 412 }; | |
| 413 #undef DEBUG_FALSE_BITS | |
| 414 | |
| 415 | |
| 416 bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) { | |
| 417 TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits); | |
| 418 | |
| 419 bool did_trans_retry = false; // only do thread_in_native_trans retry once | |
| 420 bool do_trans_retry; // flag to force the retry | |
| 421 | |
| 422 *bits |= 0x00000001; | |
| 423 | |
| 424 do { | |
| 425 do_trans_retry = false; | |
| 426 | |
| 427 if (is_exiting()) { | |
| 428 // Thread is in the process of exiting. This is always checked | |
| 429 // first to reduce the risk of dereferencing a freed JavaThread. | |
| 430 *bits |= 0x00000100; | |
| 431 return false; | |
| 432 } | |
| 433 | |
| 434 if (!is_external_suspend()) { | |
| 435 // Suspend request is cancelled. This is always checked before | |
| 436 // is_ext_suspended() to reduce the risk of a rogue resume | |
| 437 // confusing the thread that made the suspend request. | |
| 438 *bits |= 0x00000200; | |
| 439 return false; | |
| 440 } | |
| 441 | |
| 442 if (is_ext_suspended()) { | |
| 443 // thread is suspended | |
| 444 *bits |= 0x00000400; | |
| 445 return true; | |
| 446 } | |
| 447 | |
| 448 // Now that we no longer do hard suspends of threads running | |
| 449 // native code, the target thread can be changing thread state | |
| 450 // while we are in this routine: | |
| 451 // | |
| 452 // _thread_in_native -> _thread_in_native_trans -> _thread_blocked | |
| 453 // | |
| 454 // We save a copy of the thread state as observed at this moment | |
| 455 // and make our decision about suspend completeness based on the | |
| 456 // copy. This closes the race where the thread state is seen as | |
| 457 // _thread_in_native_trans in the if-thread_blocked check, but is | |
| 458 // seen as _thread_blocked in if-thread_in_native_trans check. | |
| 459 JavaThreadState save_state = thread_state(); | |
| 460 | |
| 461 if (save_state == _thread_blocked && is_suspend_equivalent()) { | |
| 462 // If the thread's state is _thread_blocked and this blocking | |
| 463 // condition is known to be equivalent to a suspend, then we can | |
| 464 // consider the thread to be externally suspended. This means that | |
| 465 // the code that sets _thread_blocked has been modified to do | |
| 466 // self-suspension if the blocking condition releases. We also | |
| 467 // used to check for CONDVAR_WAIT here, but that is now covered by | |
| 468 // the _thread_blocked with self-suspension check. | |
| 469 // | |
| 470 // Return true since we wouldn't be here unless there was still an | |
| 471 // external suspend request. | |
| 472 *bits |= 0x00001000; | |
| 473 return true; | |
| 474 } else if (save_state == _thread_in_native && frame_anchor()->walkable()) { | |
| 475 // Threads running native code will self-suspend on native==>VM/Java | |
| 476 // transitions. If its stack is walkable (should always be the case | |
| 477 // unless this function is called before the actual java_suspend() | |
| 478 // call), then the wait is done. | |
| 479 *bits |= 0x00002000; | |
| 480 return true; | |
| 481 } else if (!called_by_wait && !did_trans_retry && | |
| 482 save_state == _thread_in_native_trans && | |
| 483 frame_anchor()->walkable()) { | |
| 484 // The thread is transitioning from thread_in_native to another | |
| 485 // thread state. check_safepoint_and_suspend_for_native_trans() | |
| 486 // will force the thread to self-suspend. If it hasn't gotten | |
| 487 // there yet we may have caught the thread in-between the native | |
| 488 // code check above and the self-suspend. Lucky us. If we were | |
| 489 // called by wait_for_ext_suspend_completion(), then it | |
| 490 // will be doing the retries so we don't have to. | |
| 491 // | |
| 492 // Since we use the saved thread state in the if-statement above, | |
| 493 // there is a chance that the thread has already transitioned to | |
| 494 // _thread_blocked by the time we get here. In that case, we will | |
| 495 // make a single unnecessary pass through the logic below. This | |
| 496 // doesn't hurt anything since we still do the trans retry. | |
| 497 | |
| 498 *bits |= 0x00004000; | |
| 499 | |
| 500 // Once the thread leaves thread_in_native_trans for another | |
| 501 // thread state, we break out of this retry loop. We shouldn't | |
| 502 // need this flag to prevent us from getting back here, but | |
| 503 // sometimes paranoia is good. | |
| 504 did_trans_retry = true; | |
| 505 | |
| 506 // We wait for the thread to transition to a more usable state. | |
| 507 for (int i = 1; i <= SuspendRetryCount; i++) { | |
| 508 // We used to do an "os::yield_all(i)" call here with the intention | |
| 509 // that yielding would increase on each retry. However, the parameter | |
| 510 // is ignored on Linux which means the yield didn't scale up. Waiting | |
| 511 // on the SR_lock below provides a much more predictable scale up for | |
| 512 // the delay. It also provides a simple/direct point to check for any | |
| 513 // safepoint requests from the VMThread | |
| 514 | |
| 515 // temporarily drops SR_lock while doing wait with safepoint check | |
| 516 // (if we're a JavaThread - the WatcherThread can also call this) | |
| 517 // and increase delay with each retry | |
| 518 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay); | |
| 519 | |
| 520 // check the actual thread state instead of what we saved above | |
| 521 if (thread_state() != _thread_in_native_trans) { | |
| 522 // the thread has transitioned to another thread state so | |
| 523 // try all the checks (except this one) one more time. | |
| 524 do_trans_retry = true; | |
| 525 break; | |
| 526 } | |
| 527 } // end retry loop | |
| 528 | |
| 529 | |
| 530 } | |
| 531 } while (do_trans_retry); | |
| 532 | |
| 533 *bits |= 0x00000010; | |
| 534 return false; | |
| 535 } | |
| 536 | |
| 537 // | |
| 538 // Wait for an external suspend request to complete (or be cancelled). | |
| 539 // Returns true if the thread is externally suspended and false otherwise. | |
| 540 // | |
| 541 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay, | |
| 542 uint32_t *bits) { | |
| 543 TraceSuspendDebugBits tsdb(this, true /* is_wait */, | |
| 544 false /* !called_by_wait */, bits); | |
| 545 | |
| 546 // local flag copies to minimize SR_lock hold time | |
| 547 bool is_suspended; | |
| 548 bool pending; | |
| 549 uint32_t reset_bits; | |
| 550 | |
| 551 // set a marker so is_ext_suspend_completed() knows we are the caller | |
| 552 *bits |= 0x00010000; | |
| 553 | |
| 554 // We use reset_bits to reinitialize the bits value at the top of | |
| 555 // each retry loop. This allows the caller to make use of any | |
| 556 // unused bits for their own marking purposes. | |
| 557 reset_bits = *bits; | |
| 558 | |
| 559 { | |
| 560 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 561 is_suspended = is_ext_suspend_completed(true /* called_by_wait */, | |
| 562 delay, bits); | |
| 563 pending = is_external_suspend(); | |
| 564 } | |
| 565 // must release SR_lock to allow suspension to complete | |
| 566 | |
| 567 if (!pending) { | |
| 568 // A cancelled suspend request is the only false return from | |
| 569 // is_ext_suspend_completed() that keeps us from entering the | |
| 570 // retry loop. | |
| 571 *bits |= 0x00020000; | |
| 572 return false; | |
| 573 } | |
| 574 | |
| 575 if (is_suspended) { | |
| 576 *bits |= 0x00040000; | |
| 577 return true; | |
| 578 } | |
| 579 | |
| 580 for (int i = 1; i <= retries; i++) { | |
| 581 *bits = reset_bits; // reinit to only track last retry | |
| 582 | |
| 583 // We used to do an "os::yield_all(i)" call here with the intention | |
| 584 // that yielding would increase on each retry. However, the parameter | |
| 585 // is ignored on Linux which means the yield didn't scale up. Waiting | |
| 586 // on the SR_lock below provides a much more predictable scale up for | |
| 587 // the delay. It also provides a simple/direct point to check for any | |
| 588 // safepoint requests from the VMThread | |
| 589 | |
| 590 { | |
| 591 MutexLocker ml(SR_lock()); | |
| 592 // wait with safepoint check (if we're a JavaThread - the WatcherThread | |
| 593 // can also call this) and increase delay with each retry | |
| 594 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay); | |
| 595 | |
| 596 is_suspended = is_ext_suspend_completed(true /* called_by_wait */, | |
| 597 delay, bits); | |
| 598 | |
| 599 // It is possible for the external suspend request to be cancelled | |
| 600 // (by a resume) before the actual suspend operation is completed. | |
| 601 // Refresh our local copy to see if we still need to wait. | |
| 602 pending = is_external_suspend(); | |
| 603 } | |
| 604 | |
| 605 if (!pending) { | |
| 606 // A cancelled suspend request is the only false return from | |
| 607 // is_ext_suspend_completed() that keeps us from staying in the | |
| 608 // retry loop. | |
| 609 *bits |= 0x00080000; | |
| 610 return false; | |
| 611 } | |
| 612 | |
| 613 if (is_suspended) { | |
| 614 *bits |= 0x00100000; | |
| 615 return true; | |
| 616 } | |
| 617 } // end retry loop | |
| 618 | |
| 619 // thread did not suspend after all our retries | |
| 620 *bits |= 0x00200000; | |
| 621 return false; | |
| 622 } | |
| 623 | |
| 624 #ifndef PRODUCT | |
| 625 void JavaThread::record_jump(address target, address instr, const char* file, int line) { | |
| 626 | |
| 627 // This should not need to be atomic as the only way for simultaneous | |
| 628 // updates is via interrupts. Even then this should be rare or non-existant | |
| 629 // and we don't care that much anyway. | |
| 630 | |
| 631 int index = _jmp_ring_index; | |
| 632 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1); | |
| 633 _jmp_ring[index]._target = (intptr_t) target; | |
| 634 _jmp_ring[index]._instruction = (intptr_t) instr; | |
| 635 _jmp_ring[index]._file = file; | |
| 636 _jmp_ring[index]._line = line; | |
| 637 } | |
| 638 #endif /* PRODUCT */ | |
| 639 | |
| 640 // Called by flat profiler | |
| 641 // Callers have already called wait_for_ext_suspend_completion | |
| 642 // The assertion for that is currently too complex to put here: | |
| 643 bool JavaThread::profile_last_Java_frame(frame* _fr) { | |
| 644 bool gotframe = false; | |
| 645 // self suspension saves needed state. | |
| 646 if (has_last_Java_frame() && _anchor.walkable()) { | |
| 647 *_fr = pd_last_frame(); | |
| 648 gotframe = true; | |
| 649 } | |
| 650 return gotframe; | |
| 651 } | |
| 652 | |
| 653 void Thread::interrupt(Thread* thread) { | |
| 654 trace("interrupt", thread); | |
| 655 debug_only(check_for_dangling_thread_pointer(thread);) | |
| 656 os::interrupt(thread); | |
| 657 } | |
| 658 | |
| 659 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) { | |
| 660 trace("is_interrupted", thread); | |
| 661 debug_only(check_for_dangling_thread_pointer(thread);) | |
| 662 // Note: If clear_interrupted==false, this simply fetches and | |
| 663 // returns the value of the field osthread()->interrupted(). | |
| 664 return os::is_interrupted(thread, clear_interrupted); | |
| 665 } | |
| 666 | |
| 667 | |
| 668 // GC Support | |
| 669 bool Thread::claim_oops_do_par_case(int strong_roots_parity) { | |
| 670 jint thread_parity = _oops_do_parity; | |
| 671 if (thread_parity != strong_roots_parity) { | |
| 672 jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity); | |
| 673 if (res == thread_parity) return true; | |
| 674 else { | |
| 675 guarantee(res == strong_roots_parity, "Or else what?"); | |
| 676 assert(SharedHeap::heap()->n_par_threads() > 0, | |
| 677 "Should only fail when parallel."); | |
| 678 return false; | |
| 679 } | |
| 680 } | |
| 681 assert(SharedHeap::heap()->n_par_threads() > 0, | |
| 682 "Should only fail when parallel."); | |
| 683 return false; | |
| 684 } | |
| 685 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
686 void Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
| 0 | 687 active_handles()->oops_do(f); |
| 688 // Do oop for ThreadShadow | |
| 689 f->do_oop((oop*)&_pending_exception); | |
| 690 handle_area()->oops_do(f); | |
| 691 } | |
| 692 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
693 void Thread::nmethods_do(CodeBlobClosure* cf) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
694 // no nmethods in a generic thread... |
| 0 | 695 } |
| 696 | |
| 697 void Thread::print_on(outputStream* st) const { | |
| 698 // get_priority assumes osthread initialized | |
| 699 if (osthread() != NULL) { | |
| 700 st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this); | |
| 701 osthread()->print_on(st); | |
| 702 } | |
| 703 debug_only(if (WizardMode) print_owned_locks_on(st);) | |
| 704 } | |
| 705 | |
| 706 // Thread::print_on_error() is called by fatal error handler. Don't use | |
| 707 // any lock or allocate memory. | |
| 708 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const { | |
| 709 if (is_VM_thread()) st->print("VMThread"); | |
| 710 else if (is_Compiler_thread()) st->print("CompilerThread"); | |
| 711 else if (is_Java_thread()) st->print("JavaThread"); | |
| 712 else if (is_GC_task_thread()) st->print("GCTaskThread"); | |
| 713 else if (is_Watcher_thread()) st->print("WatcherThread"); | |
| 714 else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread"); | |
| 715 else st->print("Thread"); | |
| 716 | |
| 717 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]", | |
| 718 _stack_base - _stack_size, _stack_base); | |
| 719 | |
| 720 if (osthread()) { | |
| 721 st->print(" [id=%d]", osthread()->thread_id()); | |
| 722 } | |
| 723 } | |
| 724 | |
| 725 #ifdef ASSERT | |
| 726 void Thread::print_owned_locks_on(outputStream* st) const { | |
| 727 Monitor *cur = _owned_locks; | |
| 728 if (cur == NULL) { | |
| 729 st->print(" (no locks) "); | |
| 730 } else { | |
| 731 st->print_cr(" Locks owned:"); | |
| 732 while(cur) { | |
| 733 cur->print_on(st); | |
| 734 cur = cur->next(); | |
| 735 } | |
| 736 } | |
| 737 } | |
| 738 | |
| 739 static int ref_use_count = 0; | |
| 740 | |
| 741 bool Thread::owns_locks_but_compiled_lock() const { | |
| 742 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) { | |
| 743 if (cur != Compile_lock) return true; | |
| 744 } | |
| 745 return false; | |
| 746 } | |
| 747 | |
| 748 | |
| 749 #endif | |
| 750 | |
| 751 #ifndef PRODUCT | |
| 752 | |
| 753 // The flag: potential_vm_operation notifies if this particular safepoint state could potential | |
| 754 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that | |
| 755 // no threads which allow_vm_block's are held | |
| 756 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) { | |
| 757 // Check if current thread is allowed to block at a safepoint | |
| 758 if (!(_allow_safepoint_count == 0)) | |
| 759 fatal("Possible safepoint reached by thread that does not allow it"); | |
| 760 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) { | |
| 761 fatal("LEAF method calling lock?"); | |
| 762 } | |
| 763 | |
| 764 #ifdef ASSERT | |
| 765 if (potential_vm_operation && is_Java_thread() | |
| 766 && !Universe::is_bootstrapping()) { | |
| 767 // Make sure we do not hold any locks that the VM thread also uses. | |
| 768 // This could potentially lead to deadlocks | |
| 769 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) { | |
| 770 // Threads_lock is special, since the safepoint synchronization will not start before this is | |
| 771 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock, | |
| 772 // since it is used to transfer control between JavaThreads and the VMThread | |
| 773 // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first! | |
| 774 if ( (cur->allow_vm_block() && | |
| 775 cur != Threads_lock && | |
| 776 cur != Compile_lock && // Temporary: should not be necessary when we get spearate compilation | |
| 777 cur != VMOperationRequest_lock && | |
| 778 cur != VMOperationQueue_lock) || | |
| 779 cur->rank() == Mutex::special) { | |
| 780 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name()); | |
| 781 } | |
| 782 } | |
| 783 } | |
| 784 | |
| 785 if (GCALotAtAllSafepoints) { | |
| 786 // We could enter a safepoint here and thus have a gc | |
| 787 InterfaceSupport::check_gc_alot(); | |
| 788 } | |
| 789 #endif | |
| 790 } | |
| 791 #endif | |
| 792 | |
| 793 bool Thread::is_in_stack(address adr) const { | |
| 794 assert(Thread::current() == this, "is_in_stack can only be called from current thread"); | |
| 795 address end = os::current_stack_pointer(); | |
| 796 if (stack_base() >= adr && adr >= end) return true; | |
| 797 | |
| 798 return false; | |
| 799 } | |
| 800 | |
| 801 | |
| 802 // We had to move these methods here, because vm threads get into ObjectSynchronizer::enter | |
| 803 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being | |
| 804 // used for compilation in the future. If that change is made, the need for these methods | |
| 805 // should be revisited, and they should be removed if possible. | |
| 806 | |
| 807 bool Thread::is_lock_owned(address adr) const { | |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
808 return (_stack_base >= adr && adr >= (_stack_base - _stack_size)); |
| 0 | 809 } |
| 810 | |
| 811 bool Thread::set_as_starting_thread() { | |
| 812 // NOTE: this must be called inside the main thread. | |
| 813 return os::create_main_thread((JavaThread*)this); | |
| 814 } | |
| 815 | |
| 816 static void initialize_class(symbolHandle class_name, TRAPS) { | |
| 817 klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK); | |
| 818 instanceKlass::cast(klass)->initialize(CHECK); | |
| 819 } | |
| 820 | |
| 821 | |
| 822 // Creates the initial ThreadGroup | |
| 823 static Handle create_initial_thread_group(TRAPS) { | |
| 824 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH); | |
| 825 instanceKlassHandle klass (THREAD, k); | |
| 826 | |
| 827 Handle system_instance = klass->allocate_instance_handle(CHECK_NH); | |
| 828 { | |
| 829 JavaValue result(T_VOID); | |
| 830 JavaCalls::call_special(&result, | |
| 831 system_instance, | |
| 832 klass, | |
| 833 vmSymbolHandles::object_initializer_name(), | |
| 834 vmSymbolHandles::void_method_signature(), | |
| 835 CHECK_NH); | |
| 836 } | |
| 837 Universe::set_system_thread_group(system_instance()); | |
| 838 | |
| 839 Handle main_instance = klass->allocate_instance_handle(CHECK_NH); | |
| 840 { | |
| 841 JavaValue result(T_VOID); | |
| 842 Handle string = java_lang_String::create_from_str("main", CHECK_NH); | |
| 843 JavaCalls::call_special(&result, | |
| 844 main_instance, | |
| 845 klass, | |
| 846 vmSymbolHandles::object_initializer_name(), | |
| 847 vmSymbolHandles::threadgroup_string_void_signature(), | |
| 848 system_instance, | |
| 849 string, | |
| 850 CHECK_NH); | |
| 851 } | |
| 852 return main_instance; | |
| 853 } | |
| 854 | |
| 855 // Creates the initial Thread | |
| 856 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) { | |
| 857 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL); | |
| 858 instanceKlassHandle klass (THREAD, k); | |
| 859 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL); | |
| 860 | |
| 861 java_lang_Thread::set_thread(thread_oop(), thread); | |
| 862 java_lang_Thread::set_priority(thread_oop(), NormPriority); | |
| 863 thread->set_threadObj(thread_oop()); | |
| 864 | |
| 865 Handle string = java_lang_String::create_from_str("main", CHECK_NULL); | |
| 866 | |
| 867 JavaValue result(T_VOID); | |
| 868 JavaCalls::call_special(&result, thread_oop, | |
| 869 klass, | |
| 870 vmSymbolHandles::object_initializer_name(), | |
| 871 vmSymbolHandles::threadgroup_string_void_signature(), | |
| 872 thread_group, | |
| 873 string, | |
| 874 CHECK_NULL); | |
| 875 return thread_oop(); | |
| 876 } | |
| 877 | |
| 878 static void call_initializeSystemClass(TRAPS) { | |
| 879 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK); | |
| 880 instanceKlassHandle klass (THREAD, k); | |
| 881 | |
| 882 JavaValue result(T_VOID); | |
| 883 JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(), | |
| 884 vmSymbolHandles::void_method_signature(), CHECK); | |
| 885 } | |
| 886 | |
|
1115
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
887 #ifdef KERNEL |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
888 static void set_jkernel_boot_classloader_hook(TRAPS) { |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
889 klassOop k = SystemDictionary::sun_jkernel_DownloadManager_klass(); |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
890 instanceKlassHandle klass (THREAD, k); |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
891 |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
892 if (k == NULL) { |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
893 // sun.jkernel.DownloadManager may not present in the JDK; just return |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
894 return; |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
895 } |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
896 |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
897 JavaValue result(T_VOID); |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
898 JavaCalls::call_static(&result, klass, vmSymbolHandles::setBootClassLoaderHook_name(), |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
899 vmSymbolHandles::void_method_signature(), CHECK); |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
900 } |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
901 #endif // KERNEL |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
902 |
| 0 | 903 static void reset_vm_info_property(TRAPS) { |
| 904 // the vm info string | |
| 905 ResourceMark rm(THREAD); | |
| 906 const char *vm_info = VM_Version::vm_info_string(); | |
| 907 | |
| 908 // java.lang.System class | |
| 909 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK); | |
| 910 instanceKlassHandle klass (THREAD, k); | |
| 911 | |
| 912 // setProperty arguments | |
| 913 Handle key_str = java_lang_String::create_from_str("java.vm.info", CHECK); | |
| 914 Handle value_str = java_lang_String::create_from_str(vm_info, CHECK); | |
| 915 | |
| 916 // return value | |
| 917 JavaValue r(T_OBJECT); | |
| 918 | |
| 919 // public static String setProperty(String key, String value); | |
| 920 JavaCalls::call_static(&r, | |
| 921 klass, | |
| 922 vmSymbolHandles::setProperty_name(), | |
| 923 vmSymbolHandles::string_string_string_signature(), | |
| 924 key_str, | |
| 925 value_str, | |
| 926 CHECK); | |
| 927 } | |
| 928 | |
| 929 | |
| 930 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) { | |
| 931 assert(thread_group.not_null(), "thread group should be specified"); | |
| 932 assert(threadObj() == NULL, "should only create Java thread object once"); | |
| 933 | |
| 934 klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK); | |
| 935 instanceKlassHandle klass (THREAD, k); | |
| 936 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK); | |
| 937 | |
| 938 java_lang_Thread::set_thread(thread_oop(), this); | |
| 939 java_lang_Thread::set_priority(thread_oop(), NormPriority); | |
| 940 set_threadObj(thread_oop()); | |
| 941 | |
| 942 JavaValue result(T_VOID); | |
| 943 if (thread_name != NULL) { | |
| 944 Handle name = java_lang_String::create_from_str(thread_name, CHECK); | |
| 945 // Thread gets assigned specified name and null target | |
| 946 JavaCalls::call_special(&result, | |
| 947 thread_oop, | |
| 948 klass, | |
| 949 vmSymbolHandles::object_initializer_name(), | |
| 950 vmSymbolHandles::threadgroup_string_void_signature(), | |
| 951 thread_group, // Argument 1 | |
| 952 name, // Argument 2 | |
| 953 THREAD); | |
| 954 } else { | |
| 955 // Thread gets assigned name "Thread-nnn" and null target | |
| 956 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument) | |
| 957 JavaCalls::call_special(&result, | |
| 958 thread_oop, | |
| 959 klass, | |
| 960 vmSymbolHandles::object_initializer_name(), | |
| 961 vmSymbolHandles::threadgroup_runnable_void_signature(), | |
| 962 thread_group, // Argument 1 | |
| 963 Handle(), // Argument 2 | |
| 964 THREAD); | |
| 965 } | |
| 966 | |
| 967 | |
| 968 if (daemon) { | |
| 969 java_lang_Thread::set_daemon(thread_oop()); | |
| 970 } | |
| 971 | |
| 972 if (HAS_PENDING_EXCEPTION) { | |
| 973 return; | |
| 974 } | |
| 975 | |
| 1142 | 976 KlassHandle group(this, SystemDictionary::ThreadGroup_klass()); |
| 0 | 977 Handle threadObj(this, this->threadObj()); |
| 978 | |
| 979 JavaCalls::call_special(&result, | |
| 980 thread_group, | |
| 981 group, | |
| 982 vmSymbolHandles::add_method_name(), | |
| 983 vmSymbolHandles::thread_void_signature(), | |
| 984 threadObj, // Arg 1 | |
| 985 THREAD); | |
| 986 | |
| 987 | |
| 988 } | |
| 989 | |
| 990 // NamedThread -- non-JavaThread subclasses with multiple | |
| 991 // uniquely named instances should derive from this. | |
| 992 NamedThread::NamedThread() : Thread() { | |
| 993 _name = NULL; | |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
994 _processed_thread = NULL; |
| 0 | 995 } |
| 996 | |
| 997 NamedThread::~NamedThread() { | |
| 998 if (_name != NULL) { | |
| 999 FREE_C_HEAP_ARRAY(char, _name); | |
| 1000 _name = NULL; | |
| 1001 } | |
| 1002 } | |
| 1003 | |
| 1004 void NamedThread::set_name(const char* format, ...) { | |
| 1005 guarantee(_name == NULL, "Only get to set name once."); | |
| 1006 _name = NEW_C_HEAP_ARRAY(char, max_name_len); | |
| 1007 guarantee(_name != NULL, "alloc failure"); | |
| 1008 va_list ap; | |
| 1009 va_start(ap, format); | |
| 1010 jio_vsnprintf(_name, max_name_len, format, ap); | |
| 1011 va_end(ap); | |
| 1012 } | |
| 1013 | |
| 1014 // ======= WatcherThread ======== | |
| 1015 | |
| 1016 // The watcher thread exists to simulate timer interrupts. It should | |
| 1017 // be replaced by an abstraction over whatever native support for | |
| 1018 // timer interrupts exists on the platform. | |
| 1019 | |
| 1020 WatcherThread* WatcherThread::_watcher_thread = NULL; | |
| 1021 bool WatcherThread::_should_terminate = false; | |
| 1022 | |
| 1023 WatcherThread::WatcherThread() : Thread() { | |
| 1024 assert(watcher_thread() == NULL, "we can only allocate one WatcherThread"); | |
| 1025 if (os::create_thread(this, os::watcher_thread)) { | |
| 1026 _watcher_thread = this; | |
| 1027 | |
| 1028 // Set the watcher thread to the highest OS priority which should not be | |
| 1029 // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY | |
| 1030 // is created. The only normal thread using this priority is the reference | |
| 1031 // handler thread, which runs for very short intervals only. | |
| 1032 // If the VMThread's priority is not lower than the WatcherThread profiling | |
| 1033 // will be inaccurate. | |
| 1034 os::set_priority(this, MaxPriority); | |
| 1035 if (!DisableStartThread) { | |
| 1036 os::start_thread(this); | |
| 1037 } | |
| 1038 } | |
| 1039 } | |
| 1040 | |
| 1041 void WatcherThread::run() { | |
| 1042 assert(this == watcher_thread(), "just checking"); | |
| 1043 | |
| 1044 this->record_stack_base_and_size(); | |
| 1045 this->initialize_thread_local_storage(); | |
| 1046 this->set_active_handles(JNIHandleBlock::allocate_block()); | |
| 1047 while(!_should_terminate) { | |
| 1048 assert(watcher_thread() == Thread::current(), "thread consistency check"); | |
| 1049 assert(watcher_thread() == this, "thread consistency check"); | |
| 1050 | |
| 1051 // Calculate how long it'll be until the next PeriodicTask work | |
| 1052 // should be done, and sleep that amount of time. | |
| 1053 const size_t time_to_wait = PeriodicTask::time_to_wait(); | |
| 1054 os::sleep(this, time_to_wait, false); | |
| 1055 | |
| 1056 if (is_error_reported()) { | |
| 1057 // A fatal error has happened, the error handler(VMError::report_and_die) | |
| 1058 // should abort JVM after creating an error log file. However in some | |
| 1059 // rare cases, the error handler itself might deadlock. Here we try to | |
| 1060 // kill JVM if the fatal error handler fails to abort in 2 minutes. | |
| 1061 // | |
| 1062 // This code is in WatcherThread because WatcherThread wakes up | |
| 1063 // periodically so the fatal error handler doesn't need to do anything; | |
| 1064 // also because the WatcherThread is less likely to crash than other | |
| 1065 // threads. | |
| 1066 | |
| 1067 for (;;) { | |
| 1068 if (!ShowMessageBoxOnError | |
| 1069 && (OnError == NULL || OnError[0] == '\0') | |
| 1070 && Arguments::abort_hook() == NULL) { | |
| 1071 os::sleep(this, 2 * 60 * 1000, false); | |
| 1072 fdStream err(defaultStream::output_fd()); | |
| 1073 err.print_raw_cr("# [ timer expired, abort... ]"); | |
| 1074 // skip atexit/vm_exit/vm_abort hooks | |
| 1075 os::die(); | |
| 1076 } | |
| 1077 | |
| 1078 // Wake up 5 seconds later, the fatal handler may reset OnError or | |
| 1079 // ShowMessageBoxOnError when it is ready to abort. | |
| 1080 os::sleep(this, 5 * 1000, false); | |
| 1081 } | |
| 1082 } | |
| 1083 | |
| 1084 PeriodicTask::real_time_tick(time_to_wait); | |
| 1085 | |
| 1086 // If we have no more tasks left due to dynamic disenrollment, | |
| 1087 // shut down the thread since we don't currently support dynamic enrollment | |
| 1088 if (PeriodicTask::num_tasks() == 0) { | |
| 1089 _should_terminate = true; | |
| 1090 } | |
| 1091 } | |
| 1092 | |
| 1093 // Signal that it is terminated | |
| 1094 { | |
| 1095 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag); | |
| 1096 _watcher_thread = NULL; | |
| 1097 Terminator_lock->notify(); | |
| 1098 } | |
| 1099 | |
| 1100 // Thread destructor usually does this.. | |
| 1101 ThreadLocalStorage::set_thread(NULL); | |
| 1102 } | |
| 1103 | |
| 1104 void WatcherThread::start() { | |
| 1105 if (watcher_thread() == NULL) { | |
| 1106 _should_terminate = false; | |
| 1107 // Create the single instance of WatcherThread | |
| 1108 new WatcherThread(); | |
| 1109 } | |
| 1110 } | |
| 1111 | |
| 1112 void WatcherThread::stop() { | |
| 1113 // it is ok to take late safepoints here, if needed | |
| 1114 MutexLocker mu(Terminator_lock); | |
| 1115 _should_terminate = true; | |
| 1116 while(watcher_thread() != NULL) { | |
| 1117 // This wait should make safepoint checks, wait without a timeout, | |
| 1118 // and wait as a suspend-equivalent condition. | |
| 1119 // | |
| 1120 // Note: If the FlatProfiler is running, then this thread is waiting | |
| 1121 // for the WatcherThread to terminate and the WatcherThread, via the | |
| 1122 // FlatProfiler task, is waiting for the external suspend request on | |
| 1123 // this thread to complete. wait_for_ext_suspend_completion() will | |
| 1124 // eventually timeout, but that takes time. Making this wait a | |
| 1125 // suspend-equivalent condition solves that timeout problem. | |
| 1126 // | |
| 1127 Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0, | |
| 1128 Mutex::_as_suspend_equivalent_flag); | |
| 1129 } | |
| 1130 } | |
| 1131 | |
| 1132 void WatcherThread::print_on(outputStream* st) const { | |
| 1133 st->print("\"%s\" ", name()); | |
| 1134 Thread::print_on(st); | |
| 1135 st->cr(); | |
| 1136 } | |
| 1137 | |
| 1138 // ======= JavaThread ======== | |
| 1139 | |
| 1140 // A JavaThread is a normal Java thread | |
| 1141 | |
| 1142 void JavaThread::initialize() { | |
| 1143 // Initialize fields | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1144 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1145 // Set the claimed par_id to -1 (ie not claiming any par_ids) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1146 set_claimed_par_id(-1); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1147 |
| 0 | 1148 set_saved_exception_pc(NULL); |
| 1149 set_threadObj(NULL); | |
| 1150 _anchor.clear(); | |
| 1151 set_entry_point(NULL); | |
| 1152 set_jni_functions(jni_functions()); | |
| 1153 set_callee_target(NULL); | |
| 1154 set_vm_result(NULL); | |
| 1155 set_vm_result_2(NULL); | |
| 1156 set_vframe_array_head(NULL); | |
| 1157 set_vframe_array_last(NULL); | |
| 1158 set_deferred_locals(NULL); | |
| 1159 set_deopt_mark(NULL); | |
| 1160 clear_must_deopt_id(); | |
| 1161 set_monitor_chunks(NULL); | |
| 1162 set_next(NULL); | |
| 1163 set_thread_state(_thread_new); | |
| 1164 _terminated = _not_terminated; | |
| 1165 _privileged_stack_top = NULL; | |
| 1166 _array_for_gc = NULL; | |
| 1167 _suspend_equivalent = false; | |
| 1168 _in_deopt_handler = 0; | |
| 1169 _doing_unsafe_access = false; | |
| 1170 _stack_guard_state = stack_guard_unused; | |
| 1171 _exception_oop = NULL; | |
| 1172 _exception_pc = 0; | |
| 1173 _exception_handler_pc = 0; | |
| 1174 _exception_stack_size = 0; | |
| 1175 _jvmti_thread_state= NULL; | |
|
1213
6deeaebad47a
6902182: 4/4 Starting with jdwp agent should not incur performance penalty
dcubed
parents:
1166
diff
changeset
|
1176 _should_post_on_exceptions_flag = JNI_FALSE; |
| 0 | 1177 _jvmti_get_loaded_classes_closure = NULL; |
| 1178 _interp_only_mode = 0; | |
| 1179 _special_runtime_exit_condition = _no_async_condition; | |
| 1180 _pending_async_exception = NULL; | |
| 1181 _is_compiling = false; | |
| 1182 _thread_stat = NULL; | |
| 1183 _thread_stat = new ThreadStatistics(); | |
| 1184 _blocked_on_compilation = false; | |
| 1185 _jni_active_critical = 0; | |
| 1186 _do_not_unlock_if_synchronized = false; | |
| 1187 _cached_monitor_info = NULL; | |
| 1188 _parker = Parker::Allocate(this) ; | |
| 1189 | |
| 1190 #ifndef PRODUCT | |
| 1191 _jmp_ring_index = 0; | |
| 1192 for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) { | |
| 1193 record_jump(NULL, NULL, NULL, 0); | |
| 1194 } | |
| 1195 #endif /* PRODUCT */ | |
| 1196 | |
| 1197 set_thread_profiler(NULL); | |
| 1198 if (FlatProfiler::is_active()) { | |
| 1199 // This is where we would decide to either give each thread it's own profiler | |
| 1200 // or use one global one from FlatProfiler, | |
| 1201 // or up to some count of the number of profiled threads, etc. | |
| 1202 ThreadProfiler* pp = new ThreadProfiler(); | |
| 1203 pp->engage(); | |
| 1204 set_thread_profiler(pp); | |
| 1205 } | |
| 1206 | |
| 1207 // Setup safepoint state info for this thread | |
| 1208 ThreadSafepointState::create(this); | |
| 1209 | |
| 1210 debug_only(_java_call_counter = 0); | |
| 1211 | |
| 1212 // JVMTI PopFrame support | |
| 1213 _popframe_condition = popframe_inactive; | |
| 1214 _popframe_preserved_args = NULL; | |
| 1215 _popframe_preserved_args_size = 0; | |
| 1216 | |
| 1217 pd_initialize(); | |
| 1218 } | |
| 1219 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1220 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1221 SATBMarkQueueSet JavaThread::_satb_mark_queue_set; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1222 DirtyCardQueueSet JavaThread::_dirty_card_queue_set; |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1223 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1224 |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1225 JavaThread::JavaThread(bool is_attaching) : |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1226 Thread() |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1227 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1228 , _satb_mark_queue(&_satb_mark_queue_set), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1229 _dirty_card_queue(&_dirty_card_queue_set) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1230 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1231 { |
| 0 | 1232 initialize(); |
| 1233 _is_attaching = is_attaching; | |
|
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
997
diff
changeset
|
1234 assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor"); |
| 0 | 1235 } |
| 1236 | |
| 1237 bool JavaThread::reguard_stack(address cur_sp) { | |
| 1238 if (_stack_guard_state != stack_guard_yellow_disabled) { | |
| 1239 return true; // Stack already guarded or guard pages not needed. | |
| 1240 } | |
| 1241 | |
| 1242 if (register_stack_overflow()) { | |
| 1243 // For those architectures which have separate register and | |
| 1244 // memory stacks, we must check the register stack to see if | |
| 1245 // it has overflowed. | |
| 1246 return false; | |
| 1247 } | |
| 1248 | |
| 1249 // Java code never executes within the yellow zone: the latter is only | |
| 1250 // there to provoke an exception during stack banging. If java code | |
| 1251 // is executing there, either StackShadowPages should be larger, or | |
| 1252 // some exception code in c1, c2 or the interpreter isn't unwinding | |
| 1253 // when it should. | |
| 1254 guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages"); | |
| 1255 | |
| 1256 enable_stack_yellow_zone(); | |
| 1257 return true; | |
| 1258 } | |
| 1259 | |
| 1260 bool JavaThread::reguard_stack(void) { | |
| 1261 return reguard_stack(os::current_stack_pointer()); | |
| 1262 } | |
| 1263 | |
| 1264 | |
| 1265 void JavaThread::block_if_vm_exited() { | |
| 1266 if (_terminated == _vm_exited) { | |
| 1267 // _vm_exited is set at safepoint, and Threads_lock is never released | |
| 1268 // we will block here forever | |
| 1269 Threads_lock->lock_without_safepoint_check(); | |
| 1270 ShouldNotReachHere(); | |
| 1271 } | |
| 1272 } | |
| 1273 | |
| 1274 | |
| 1275 // Remove this ifdef when C1 is ported to the compiler interface. | |
| 1276 static void compiler_thread_entry(JavaThread* thread, TRAPS); | |
| 1277 | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1278 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) : |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1279 Thread() |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1280 #ifndef SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1281 , _satb_mark_queue(&_satb_mark_queue_set), |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1282 _dirty_card_queue(&_dirty_card_queue_set) |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1283 #endif // !SERIALGC |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
1284 { |
| 0 | 1285 if (TraceThreadEvents) { |
| 1286 tty->print_cr("creating thread %p", this); | |
| 1287 } | |
| 1288 initialize(); | |
| 1289 _is_attaching = false; | |
| 1290 set_entry_point(entry_point); | |
| 1291 // Create the native thread itself. | |
| 1292 // %note runtime_23 | |
| 1293 os::ThreadType thr_type = os::java_thread; | |
| 1294 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : | |
| 1295 os::java_thread; | |
| 1296 os::create_thread(this, thr_type, stack_sz); | |
| 1297 | |
| 1298 // The _osthread may be NULL here because we ran out of memory (too many threads active). | |
| 1299 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller | |
| 1300 // may hold a lock and all locks must be unlocked before throwing the exception (throwing | |
| 1301 // the exception consists of creating the exception object & initializing it, initialization | |
| 1302 // will leave the VM via a JavaCall and then all locks must be unlocked). | |
| 1303 // | |
| 1304 // The thread is still suspended when we reach here. Thread must be explicit started | |
| 1305 // by creator! Furthermore, the thread must also explicitly be added to the Threads list | |
| 1306 // by calling Threads:add. The reason why this is not done here, is because the thread | |
| 1307 // object must be fully initialized (take a look at JVM_Start) | |
| 1308 } | |
| 1309 | |
| 1310 JavaThread::~JavaThread() { | |
| 1311 if (TraceThreadEvents) { | |
| 1312 tty->print_cr("terminate thread %p", this); | |
| 1313 } | |
| 1314 | |
| 1315 // JSR166 -- return the parker to the free list | |
| 1316 Parker::Release(_parker); | |
| 1317 _parker = NULL ; | |
| 1318 | |
| 1319 // Free any remaining previous UnrollBlock | |
| 1320 vframeArray* old_array = vframe_array_last(); | |
| 1321 | |
| 1322 if (old_array != NULL) { | |
| 1323 Deoptimization::UnrollBlock* old_info = old_array->unroll_block(); | |
| 1324 old_array->set_unroll_block(NULL); | |
| 1325 delete old_info; | |
| 1326 delete old_array; | |
| 1327 } | |
| 1328 | |
| 1329 GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred = deferred_locals(); | |
| 1330 if (deferred != NULL) { | |
| 1331 // This can only happen if thread is destroyed before deoptimization occurs. | |
| 1332 assert(deferred->length() != 0, "empty array!"); | |
| 1333 do { | |
| 1334 jvmtiDeferredLocalVariableSet* dlv = deferred->at(0); | |
| 1335 deferred->remove_at(0); | |
| 1336 // individual jvmtiDeferredLocalVariableSet are CHeapObj's | |
| 1337 delete dlv; | |
| 1338 } while (deferred->length() != 0); | |
| 1339 delete deferred; | |
| 1340 } | |
| 1341 | |
| 1342 // All Java related clean up happens in exit | |
| 1343 ThreadSafepointState::destroy(this); | |
| 1344 if (_thread_profiler != NULL) delete _thread_profiler; | |
| 1345 if (_thread_stat != NULL) delete _thread_stat; | |
| 1346 } | |
| 1347 | |
| 1348 | |
| 1349 // The first routine called by a new Java thread | |
| 1350 void JavaThread::run() { | |
| 1351 // initialize thread-local alloc buffer related fields | |
| 1352 this->initialize_tlab(); | |
| 1353 | |
| 1354 // used to test validitity of stack trace backs | |
| 1355 this->record_base_of_stack_pointer(); | |
| 1356 | |
| 1357 // Record real stack base and size. | |
| 1358 this->record_stack_base_and_size(); | |
| 1359 | |
| 1360 // Initialize thread local storage; set before calling MutexLocker | |
| 1361 this->initialize_thread_local_storage(); | |
| 1362 | |
| 1363 this->create_stack_guard_pages(); | |
| 1364 | |
| 1365 // Thread is now sufficient initialized to be handled by the safepoint code as being | |
| 1366 // in the VM. Change thread state from _thread_new to _thread_in_vm | |
| 1367 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm); | |
| 1368 | |
| 1369 assert(JavaThread::current() == this, "sanity check"); | |
| 1370 assert(!Thread::current()->owns_locks(), "sanity check"); | |
| 1371 | |
| 1372 DTRACE_THREAD_PROBE(start, this); | |
| 1373 | |
| 1374 // This operation might block. We call that after all safepoint checks for a new thread has | |
| 1375 // been completed. | |
| 1376 this->set_active_handles(JNIHandleBlock::allocate_block()); | |
| 1377 | |
| 1378 if (JvmtiExport::should_post_thread_life()) { | |
| 1379 JvmtiExport::post_thread_start(this); | |
| 1380 } | |
| 1381 | |
| 1382 // We call another function to do the rest so we are sure that the stack addresses used | |
| 1383 // from there will be lower than the stack base just computed | |
| 1384 thread_main_inner(); | |
| 1385 | |
| 1386 // Note, thread is no longer valid at this point! | |
| 1387 } | |
| 1388 | |
| 1389 | |
| 1390 void JavaThread::thread_main_inner() { | |
| 1391 assert(JavaThread::current() == this, "sanity check"); | |
| 1392 assert(this->threadObj() != NULL, "just checking"); | |
| 1393 | |
| 1394 // Execute thread entry point. If this thread is being asked to restart, | |
| 1395 // or has been stopped before starting, do not reexecute entry point. | |
| 1396 // Note: Due to JVM_StopThread we can have pending exceptions already! | |
| 1397 if (!this->has_pending_exception() && !java_lang_Thread::is_stillborn(this->threadObj())) { | |
| 1398 // enter the thread's entry point only if we have no pending exceptions | |
| 1399 HandleMark hm(this); | |
| 1400 this->entry_point()(this, this); | |
| 1401 } | |
| 1402 | |
| 1403 DTRACE_THREAD_PROBE(stop, this); | |
| 1404 | |
| 1405 this->exit(false); | |
| 1406 delete this; | |
| 1407 } | |
| 1408 | |
| 1409 | |
| 1410 static void ensure_join(JavaThread* thread) { | |
| 1411 // We do not need to grap the Threads_lock, since we are operating on ourself. | |
| 1412 Handle threadObj(thread, thread->threadObj()); | |
| 1413 assert(threadObj.not_null(), "java thread object must exist"); | |
| 1414 ObjectLocker lock(threadObj, thread); | |
| 1415 // Ignore pending exception (ThreadDeath), since we are exiting anyway | |
| 1416 thread->clear_pending_exception(); | |
| 1417 // It is of profound importance that we set the stillborn bit and reset the thread object, | |
| 1418 // before we do the notify. Since, changing these two variable will make JVM_IsAlive return | |
| 1419 // false. So in case another thread is doing a join on this thread , it will detect that the thread | |
| 1420 // is dead when it gets notified. | |
| 1421 java_lang_Thread::set_stillborn(threadObj()); | |
| 1422 // Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED. | |
| 1423 java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED); | |
| 1424 java_lang_Thread::set_thread(threadObj(), NULL); | |
| 1425 lock.notify_all(thread); | |
| 1426 // Ignore pending exception (ThreadDeath), since we are exiting anyway | |
| 1427 thread->clear_pending_exception(); | |
| 1428 } | |
| 1429 | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1430 |
| 0 | 1431 // For any new cleanup additions, please check to see if they need to be applied to |
| 1432 // cleanup_failed_attach_current_thread as well. | |
| 1433 void JavaThread::exit(bool destroy_vm, ExitType exit_type) { | |
| 1434 assert(this == JavaThread::current(), "thread consistency check"); | |
| 1435 if (!InitializeJavaLangSystem) return; | |
| 1436 | |
| 1437 HandleMark hm(this); | |
| 1438 Handle uncaught_exception(this, this->pending_exception()); | |
| 1439 this->clear_pending_exception(); | |
| 1440 Handle threadObj(this, this->threadObj()); | |
| 1441 assert(threadObj.not_null(), "Java thread object should be created"); | |
| 1442 | |
| 1443 if (get_thread_profiler() != NULL) { | |
| 1444 get_thread_profiler()->disengage(); | |
| 1445 ResourceMark rm; | |
| 1446 get_thread_profiler()->print(get_thread_name()); | |
| 1447 } | |
| 1448 | |
| 1449 | |
| 1450 // FIXIT: This code should be moved into else part, when reliable 1.2/1.3 check is in place | |
| 1451 { | |
| 1452 EXCEPTION_MARK; | |
| 1453 | |
| 1454 CLEAR_PENDING_EXCEPTION; | |
| 1455 } | |
| 1456 // FIXIT: The is_null check is only so it works better on JDK1.2 VM's. This | |
| 1457 // has to be fixed by a runtime query method | |
| 1458 if (!destroy_vm || JDK_Version::is_jdk12x_version()) { | |
| 1459 // JSR-166: change call from from ThreadGroup.uncaughtException to | |
| 1460 // java.lang.Thread.dispatchUncaughtException | |
| 1461 if (uncaught_exception.not_null()) { | |
| 1462 Handle group(this, java_lang_Thread::threadGroup(threadObj())); | |
| 1463 Events::log("uncaught exception INTPTR_FORMAT " " INTPTR_FORMAT " " INTPTR_FORMAT", | |
| 1464 (address)uncaught_exception(), (address)threadObj(), (address)group()); | |
| 1465 { | |
| 1466 EXCEPTION_MARK; | |
| 1467 // Check if the method Thread.dispatchUncaughtException() exists. If so | |
| 1468 // call it. Otherwise we have an older library without the JSR-166 changes, | |
| 1469 // so call ThreadGroup.uncaughtException() | |
| 1470 KlassHandle recvrKlass(THREAD, threadObj->klass()); | |
| 1471 CallInfo callinfo; | |
| 1142 | 1472 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass()); |
| 0 | 1473 LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass, |
| 1474 vmSymbolHandles::dispatchUncaughtException_name(), | |
| 1475 vmSymbolHandles::throwable_void_signature(), | |
| 1476 KlassHandle(), false, false, THREAD); | |
| 1477 CLEAR_PENDING_EXCEPTION; | |
| 1478 methodHandle method = callinfo.selected_method(); | |
| 1479 if (method.not_null()) { | |
| 1480 JavaValue result(T_VOID); | |
| 1481 JavaCalls::call_virtual(&result, | |
| 1482 threadObj, thread_klass, | |
| 1483 vmSymbolHandles::dispatchUncaughtException_name(), | |
| 1484 vmSymbolHandles::throwable_void_signature(), | |
| 1485 uncaught_exception, | |
| 1486 THREAD); | |
| 1487 } else { | |
| 1142 | 1488 KlassHandle thread_group(THREAD, SystemDictionary::ThreadGroup_klass()); |
| 0 | 1489 JavaValue result(T_VOID); |
| 1490 JavaCalls::call_virtual(&result, | |
| 1491 group, thread_group, | |
| 1492 vmSymbolHandles::uncaughtException_name(), | |
| 1493 vmSymbolHandles::thread_throwable_void_signature(), | |
| 1494 threadObj, // Arg 1 | |
| 1495 uncaught_exception, // Arg 2 | |
| 1496 THREAD); | |
| 1497 } | |
| 1498 CLEAR_PENDING_EXCEPTION; | |
| 1499 } | |
| 1500 } | |
| 1501 | |
| 1502 // Call Thread.exit(). We try 3 times in case we got another Thread.stop during | |
| 1503 // the execution of the method. If that is not enough, then we don't really care. Thread.stop | |
| 1504 // is deprecated anyhow. | |
| 1505 { int count = 3; | |
| 1506 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) { | |
| 1507 EXCEPTION_MARK; | |
| 1508 JavaValue result(T_VOID); | |
| 1142 | 1509 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass()); |
| 0 | 1510 JavaCalls::call_virtual(&result, |
| 1511 threadObj, thread_klass, | |
| 1512 vmSymbolHandles::exit_method_name(), | |
| 1513 vmSymbolHandles::void_method_signature(), | |
| 1514 THREAD); | |
| 1515 CLEAR_PENDING_EXCEPTION; | |
| 1516 } | |
| 1517 } | |
| 1518 | |
| 1519 // notify JVMTI | |
| 1520 if (JvmtiExport::should_post_thread_life()) { | |
| 1521 JvmtiExport::post_thread_end(this); | |
| 1522 } | |
| 1523 | |
| 1524 // We have notified the agents that we are exiting, before we go on, | |
| 1525 // we must check for a pending external suspend request and honor it | |
| 1526 // in order to not surprise the thread that made the suspend request. | |
| 1527 while (true) { | |
| 1528 { | |
| 1529 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 1530 if (!is_external_suspend()) { | |
| 1531 set_terminated(_thread_exiting); | |
| 1532 ThreadService::current_thread_exiting(this); | |
| 1533 break; | |
| 1534 } | |
| 1535 // Implied else: | |
| 1536 // Things get a little tricky here. We have a pending external | |
| 1537 // suspend request, but we are holding the SR_lock so we | |
| 1538 // can't just self-suspend. So we temporarily drop the lock | |
| 1539 // and then self-suspend. | |
| 1540 } | |
| 1541 | |
| 1542 ThreadBlockInVM tbivm(this); | |
| 1543 java_suspend_self(); | |
| 1544 | |
| 1545 // We're done with this suspend request, but we have to loop around | |
| 1546 // and check again. Eventually we will get SR_lock without a pending | |
| 1547 // external suspend request and will be able to mark ourselves as | |
| 1548 // exiting. | |
| 1549 } | |
| 1550 // no more external suspends are allowed at this point | |
| 1551 } else { | |
| 1552 // before_exit() has already posted JVMTI THREAD_END events | |
| 1553 } | |
| 1554 | |
| 1555 // Notify waiters on thread object. This has to be done after exit() is called | |
| 1556 // on the thread (if the thread is the last thread in a daemon ThreadGroup the | |
| 1557 // group should have the destroyed bit set before waiters are notified). | |
| 1558 ensure_join(this); | |
| 1559 assert(!this->has_pending_exception(), "ensure_join should have cleared"); | |
| 1560 | |
| 1561 // 6282335 JNI DetachCurrentThread spec states that all Java monitors | |
| 1562 // held by this thread must be released. A detach operation must only | |
| 1563 // get here if there are no Java frames on the stack. Therefore, any | |
| 1564 // owned monitors at this point MUST be JNI-acquired monitors which are | |
| 1565 // pre-inflated and in the monitor cache. | |
| 1566 // | |
| 1567 // ensure_join() ignores IllegalThreadStateExceptions, and so does this. | |
| 1568 if (exit_type == jni_detach && JNIDetachReleasesMonitors) { | |
| 1569 assert(!this->has_last_Java_frame(), "detaching with Java frames?"); | |
| 1570 ObjectSynchronizer::release_monitors_owned_by_thread(this); | |
| 1571 assert(!this->has_pending_exception(), "release_monitors should have cleared"); | |
| 1572 } | |
| 1573 | |
| 1574 // These things needs to be done while we are still a Java Thread. Make sure that thread | |
| 1575 // is in a consistent state, in case GC happens | |
| 1576 assert(_privileged_stack_top == NULL, "must be NULL when we get here"); | |
| 1577 | |
| 1578 if (active_handles() != NULL) { | |
| 1579 JNIHandleBlock* block = active_handles(); | |
| 1580 set_active_handles(NULL); | |
| 1581 JNIHandleBlock::release_block(block); | |
| 1582 } | |
| 1583 | |
| 1584 if (free_handle_block() != NULL) { | |
| 1585 JNIHandleBlock* block = free_handle_block(); | |
| 1586 set_free_handle_block(NULL); | |
| 1587 JNIHandleBlock::release_block(block); | |
| 1588 } | |
| 1589 | |
| 1590 // These have to be removed while this is still a valid thread. | |
| 1591 remove_stack_guard_pages(); | |
| 1592 | |
| 1593 if (UseTLAB) { | |
| 1594 tlab().make_parsable(true); // retire TLAB | |
| 1595 } | |
| 1596 | |
|
49
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1597 if (jvmti_thread_state() != NULL) { |
|
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1598 JvmtiExport::cleanup_thread(this); |
|
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1599 } |
|
31000d79ec71
6453355: 4/4 new No_Safepoint_Verifier uses fail during GC
dcubed
parents:
0
diff
changeset
|
1600 |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1601 #ifndef SERIALGC |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1602 // We must flush G1-related buffers before removing a thread from |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1603 // the list of active threads. |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1604 if (UseG1GC) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1605 flush_barrier_queues(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1606 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1607 #endif |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1608 |
| 0 | 1609 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread |
| 1610 Threads::remove(this); | |
| 1611 } | |
| 1612 | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1613 #ifndef SERIALGC |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1614 // Flush G1-related queues. |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1615 void JavaThread::flush_barrier_queues() { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1616 satb_mark_queue().flush(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1617 dirty_card_queue().flush(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1618 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1619 #endif |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1620 |
| 0 | 1621 void JavaThread::cleanup_failed_attach_current_thread() { |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1622 if (get_thread_profiler() != NULL) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1623 get_thread_profiler()->disengage(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1624 ResourceMark rm; |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1625 get_thread_profiler()->print(get_thread_name()); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1626 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1627 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1628 if (active_handles() != NULL) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1629 JNIHandleBlock* block = active_handles(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1630 set_active_handles(NULL); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1631 JNIHandleBlock::release_block(block); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1632 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1633 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1634 if (free_handle_block() != NULL) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1635 JNIHandleBlock* block = free_handle_block(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1636 set_free_handle_block(NULL); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1637 JNIHandleBlock::release_block(block); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1638 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1639 |
|
1290
c8a467bf56ad
6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents:
1213
diff
changeset
|
1640 // These have to be removed while this is still a valid thread. |
|
c8a467bf56ad
6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents:
1213
diff
changeset
|
1641 remove_stack_guard_pages(); |
|
c8a467bf56ad
6914050: jvm assertion "guard pages must be in use" in -Xcomp mode
coleenp
parents:
1213
diff
changeset
|
1642 |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1643 if (UseTLAB) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1644 tlab().make_parsable(true); // retire TLAB, if any |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1645 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1646 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1647 #ifndef SERIALGC |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1648 if (UseG1GC) { |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1649 flush_barrier_queues(); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1650 } |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1651 #endif |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1652 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1653 Threads::remove(this); |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1654 delete this; |
| 0 | 1655 } |
| 1656 | |
| 1657 | |
|
441
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1658 |
|
da9cb4e97a5f
6770608: G1: Mutator thread can flush barrier and satb queues during safepoint
iveresov
parents:
383
diff
changeset
|
1659 |
| 0 | 1660 JavaThread* JavaThread::active() { |
| 1661 Thread* thread = ThreadLocalStorage::thread(); | |
| 1662 assert(thread != NULL, "just checking"); | |
| 1663 if (thread->is_Java_thread()) { | |
| 1664 return (JavaThread*) thread; | |
| 1665 } else { | |
| 1666 assert(thread->is_VM_thread(), "this must be a vm thread"); | |
| 1667 VM_Operation* op = ((VMThread*) thread)->vm_operation(); | |
| 1668 JavaThread *ret=op == NULL ? NULL : (JavaThread *)op->calling_thread(); | |
| 1669 assert(ret->is_Java_thread(), "must be a Java thread"); | |
| 1670 return ret; | |
| 1671 } | |
| 1672 } | |
| 1673 | |
| 1674 bool JavaThread::is_lock_owned(address adr) const { | |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
1675 if (Thread::is_lock_owned(adr)) return true; |
| 0 | 1676 |
| 1677 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { | |
| 1678 if (chunk->contains(adr)) return true; | |
| 1679 } | |
| 1680 | |
| 1681 return false; | |
| 1682 } | |
| 1683 | |
| 1684 | |
| 1685 void JavaThread::add_monitor_chunk(MonitorChunk* chunk) { | |
| 1686 chunk->set_next(monitor_chunks()); | |
| 1687 set_monitor_chunks(chunk); | |
| 1688 } | |
| 1689 | |
| 1690 void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) { | |
| 1691 guarantee(monitor_chunks() != NULL, "must be non empty"); | |
| 1692 if (monitor_chunks() == chunk) { | |
| 1693 set_monitor_chunks(chunk->next()); | |
| 1694 } else { | |
| 1695 MonitorChunk* prev = monitor_chunks(); | |
| 1696 while (prev->next() != chunk) prev = prev->next(); | |
| 1697 prev->set_next(chunk->next()); | |
| 1698 } | |
| 1699 } | |
| 1700 | |
| 1701 // JVM support. | |
| 1702 | |
| 1703 // Note: this function shouldn't block if it's called in | |
| 1704 // _thread_in_native_trans state (such as from | |
| 1705 // check_special_condition_for_native_trans()). | |
| 1706 void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) { | |
| 1707 | |
| 1708 if (has_last_Java_frame() && has_async_condition()) { | |
| 1709 // If we are at a polling page safepoint (not a poll return) | |
| 1710 // then we must defer async exception because live registers | |
| 1711 // will be clobbered by the exception path. Poll return is | |
| 1712 // ok because the call we a returning from already collides | |
| 1713 // with exception handling registers and so there is no issue. | |
| 1714 // (The exception handling path kills call result registers but | |
| 1715 // this is ok since the exception kills the result anyway). | |
| 1716 | |
| 1717 if (is_at_poll_safepoint()) { | |
| 1718 // if the code we are returning to has deoptimized we must defer | |
| 1719 // the exception otherwise live registers get clobbered on the | |
| 1720 // exception path before deoptimization is able to retrieve them. | |
| 1721 // | |
| 1722 RegisterMap map(this, false); | |
| 1723 frame caller_fr = last_frame().sender(&map); | |
| 1724 assert(caller_fr.is_compiled_frame(), "what?"); | |
| 1725 if (caller_fr.is_deoptimized_frame()) { | |
| 1726 if (TraceExceptions) { | |
| 1727 ResourceMark rm; | |
| 1728 tty->print_cr("deferred async exception at compiled safepoint"); | |
| 1729 } | |
| 1730 return; | |
| 1731 } | |
| 1732 } | |
| 1733 } | |
| 1734 | |
| 1735 JavaThread::AsyncRequests condition = clear_special_runtime_exit_condition(); | |
| 1736 if (condition == _no_async_condition) { | |
| 1737 // Conditions have changed since has_special_runtime_exit_condition() | |
| 1738 // was called: | |
| 1739 // - if we were here only because of an external suspend request, | |
| 1740 // then that was taken care of above (or cancelled) so we are done | |
| 1741 // - if we were here because of another async request, then it has | |
| 1742 // been cleared between the has_special_runtime_exit_condition() | |
| 1743 // and now so again we are done | |
| 1744 return; | |
| 1745 } | |
| 1746 | |
| 1747 // Check for pending async. exception | |
| 1748 if (_pending_async_exception != NULL) { | |
| 1749 // Only overwrite an already pending exception, if it is not a threadDeath. | |
| 1142 | 1750 if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())) { |
| 0 | 1751 |
| 1752 // We cannot call Exceptions::_throw(...) here because we cannot block | |
| 1753 set_pending_exception(_pending_async_exception, __FILE__, __LINE__); | |
| 1754 | |
| 1755 if (TraceExceptions) { | |
| 1756 ResourceMark rm; | |
| 1757 tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this); | |
| 1758 if (has_last_Java_frame() ) { | |
| 1759 frame f = last_frame(); | |
| 1760 tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp()); | |
| 1761 } | |
| 1762 tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name()); | |
| 1763 } | |
| 1764 _pending_async_exception = NULL; | |
| 1765 clear_has_async_exception(); | |
| 1766 } | |
| 1767 } | |
| 1768 | |
| 1769 if (check_unsafe_error && | |
| 1770 condition == _async_unsafe_access_error && !has_pending_exception()) { | |
| 1771 condition = _no_async_condition; // done | |
| 1772 switch (thread_state()) { | |
| 1773 case _thread_in_vm: | |
| 1774 { | |
| 1775 JavaThread* THREAD = this; | |
| 1776 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); | |
| 1777 } | |
| 1778 case _thread_in_native: | |
| 1779 { | |
| 1780 ThreadInVMfromNative tiv(this); | |
| 1781 JavaThread* THREAD = this; | |
| 1782 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation"); | |
| 1783 } | |
| 1784 case _thread_in_Java: | |
| 1785 { | |
| 1786 ThreadInVMfromJava tiv(this); | |
| 1787 JavaThread* THREAD = this; | |
| 1788 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code"); | |
| 1789 } | |
| 1790 default: | |
| 1791 ShouldNotReachHere(); | |
| 1792 } | |
| 1793 } | |
| 1794 | |
| 1795 assert(condition == _no_async_condition || has_pending_exception() || | |
| 1796 (!check_unsafe_error && condition == _async_unsafe_access_error), | |
| 1797 "must have handled the async condition, if no exception"); | |
| 1798 } | |
| 1799 | |
| 1800 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) { | |
| 1801 // | |
| 1802 // Check for pending external suspend. Internal suspend requests do | |
| 1803 // not use handle_special_runtime_exit_condition(). | |
| 1804 // If JNIEnv proxies are allowed, don't self-suspend if the target | |
| 1805 // thread is not the current thread. In older versions of jdbx, jdbx | |
| 1806 // threads could call into the VM with another thread's JNIEnv so we | |
| 1807 // can be here operating on behalf of a suspended thread (4432884). | |
| 1808 bool do_self_suspend = is_external_suspend_with_lock(); | |
| 1809 if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) { | |
| 1810 // | |
| 1811 // Because thread is external suspended the safepoint code will count | |
| 1812 // thread as at a safepoint. This can be odd because we can be here | |
| 1813 // as _thread_in_Java which would normally transition to _thread_blocked | |
| 1814 // at a safepoint. We would like to mark the thread as _thread_blocked | |
| 1815 // before calling java_suspend_self like all other callers of it but | |
| 1816 // we must then observe proper safepoint protocol. (We can't leave | |
| 1817 // _thread_blocked with a safepoint in progress). However we can be | |
| 1818 // here as _thread_in_native_trans so we can't use a normal transition | |
| 1819 // constructor/destructor pair because they assert on that type of | |
| 1820 // transition. We could do something like: | |
| 1821 // | |
| 1822 // JavaThreadState state = thread_state(); | |
| 1823 // set_thread_state(_thread_in_vm); | |
| 1824 // { | |
| 1825 // ThreadBlockInVM tbivm(this); | |
| 1826 // java_suspend_self() | |
| 1827 // } | |
| 1828 // set_thread_state(_thread_in_vm_trans); | |
| 1829 // if (safepoint) block; | |
| 1830 // set_thread_state(state); | |
| 1831 // | |
| 1832 // but that is pretty messy. Instead we just go with the way the | |
| 1833 // code has worked before and note that this is the only path to | |
| 1834 // java_suspend_self that doesn't put the thread in _thread_blocked | |
| 1835 // mode. | |
| 1836 | |
| 1837 frame_anchor()->make_walkable(this); | |
| 1838 java_suspend_self(); | |
| 1839 | |
| 1840 // We might be here for reasons in addition to the self-suspend request | |
| 1841 // so check for other async requests. | |
| 1842 } | |
| 1843 | |
| 1844 if (check_asyncs) { | |
| 1845 check_and_handle_async_exceptions(); | |
| 1846 } | |
| 1847 } | |
| 1848 | |
| 1849 void JavaThread::send_thread_stop(oop java_throwable) { | |
| 1850 assert(Thread::current()->is_VM_thread(), "should be in the vm thread"); | |
| 1851 assert(Threads_lock->is_locked(), "Threads_lock should be locked by safepoint code"); | |
| 1852 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped"); | |
| 1853 | |
| 1854 // Do not throw asynchronous exceptions against the compiler thread | |
| 1855 // (the compiler thread should not be a Java thread -- fix in 1.4.2) | |
|
1410
b30a2cd5e3a2
Added methods to c1x_VMExits.cpp
Thomas Wuerthinger <thomas.wuerthinger@gmail.com>
parents:
1320
diff
changeset
|
1856 |
|
b30a2cd5e3a2
Added methods to c1x_VMExits.cpp
Thomas Wuerthinger <thomas.wuerthinger@gmail.com>
parents:
1320
diff
changeset
|
1857 // (tw) May we do this? |
|
b30a2cd5e3a2
Added methods to c1x_VMExits.cpp
Thomas Wuerthinger <thomas.wuerthinger@gmail.com>
parents:
1320
diff
changeset
|
1858 //if (is_Compiler_thread()) return; |
| 0 | 1859 |
| 1860 // This is a change from JDK 1.1, but JDK 1.2 will also do it: | |
| 1142 | 1861 if (java_throwable->is_a(SystemDictionary::ThreadDeath_klass())) { |
| 0 | 1862 java_lang_Thread::set_stillborn(threadObj()); |
| 1863 } | |
| 1864 | |
| 1865 { | |
| 1866 // Actually throw the Throwable against the target Thread - however | |
| 1867 // only if there is no thread death exception installed already. | |
| 1142 | 1868 if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::ThreadDeath_klass())) { |
| 0 | 1869 // If the topmost frame is a runtime stub, then we are calling into |
| 1870 // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..) | |
| 1871 // must deoptimize the caller before continuing, as the compiled exception handler table | |
| 1872 // may not be valid | |
| 1873 if (has_last_Java_frame()) { | |
| 1874 frame f = last_frame(); | |
| 1875 if (f.is_runtime_frame() || f.is_safepoint_blob_frame()) { | |
| 1876 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
| 1877 RegisterMap reg_map(this, UseBiasedLocking); | |
| 1878 frame compiled_frame = f.sender(®_map); | |
| 1879 if (compiled_frame.can_be_deoptimized()) { | |
| 1880 Deoptimization::deoptimize(this, compiled_frame, ®_map); | |
| 1881 } | |
| 1882 } | |
| 1883 } | |
| 1884 | |
| 1885 // Set async. pending exception in thread. | |
| 1886 set_pending_async_exception(java_throwable); | |
| 1887 | |
| 1888 if (TraceExceptions) { | |
| 1889 ResourceMark rm; | |
| 1890 tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name()); | |
| 1891 } | |
| 1892 // for AbortVMOnException flag | |
| 1893 NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name())); | |
| 1894 } | |
| 1895 } | |
| 1896 | |
| 1897 | |
| 1898 // Interrupt thread so it will wake up from a potential wait() | |
| 1899 Thread::interrupt(this); | |
| 1900 } | |
| 1901 | |
| 1902 // External suspension mechanism. | |
| 1903 // | |
| 1904 // Tell the VM to suspend a thread when ever it knows that it does not hold on | |
| 1905 // to any VM_locks and it is at a transition | |
| 1906 // Self-suspension will happen on the transition out of the vm. | |
| 1907 // Catch "this" coming in from JNIEnv pointers when the thread has been freed | |
| 1908 // | |
| 1909 // Guarantees on return: | |
| 1910 // + Target thread will not execute any new bytecode (that's why we need to | |
| 1911 // force a safepoint) | |
| 1912 // + Target thread will not enter any new monitors | |
| 1913 // | |
| 1914 void JavaThread::java_suspend() { | |
| 1915 { MutexLocker mu(Threads_lock); | |
| 1916 if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) { | |
| 1917 return; | |
| 1918 } | |
| 1919 } | |
| 1920 | |
| 1921 { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 1922 if (!is_external_suspend()) { | |
| 1923 // a racing resume has cancelled us; bail out now | |
| 1924 return; | |
| 1925 } | |
| 1926 | |
| 1927 // suspend is done | |
| 1928 uint32_t debug_bits = 0; | |
| 1929 // Warning: is_ext_suspend_completed() may temporarily drop the | |
| 1930 // SR_lock to allow the thread to reach a stable thread state if | |
| 1931 // it is currently in a transient thread state. | |
| 1932 if (is_ext_suspend_completed(false /* !called_by_wait */, | |
| 1933 SuspendRetryDelay, &debug_bits) ) { | |
| 1934 return; | |
| 1935 } | |
| 1936 } | |
| 1937 | |
| 1938 VM_ForceSafepoint vm_suspend; | |
| 1939 VMThread::execute(&vm_suspend); | |
| 1940 } | |
| 1941 | |
| 1942 // Part II of external suspension. | |
| 1943 // A JavaThread self suspends when it detects a pending external suspend | |
| 1944 // request. This is usually on transitions. It is also done in places | |
| 1945 // where continuing to the next transition would surprise the caller, | |
| 1946 // e.g., monitor entry. | |
| 1947 // | |
| 1948 // Returns the number of times that the thread self-suspended. | |
| 1949 // | |
| 1950 // Note: DO NOT call java_suspend_self() when you just want to block current | |
| 1951 // thread. java_suspend_self() is the second stage of cooperative | |
| 1952 // suspension for external suspend requests and should only be used | |
| 1953 // to complete an external suspend request. | |
| 1954 // | |
| 1955 int JavaThread::java_suspend_self() { | |
| 1956 int ret = 0; | |
| 1957 | |
| 1958 // we are in the process of exiting so don't suspend | |
| 1959 if (is_exiting()) { | |
| 1960 clear_external_suspend(); | |
| 1961 return ret; | |
| 1962 } | |
| 1963 | |
| 1964 assert(_anchor.walkable() || | |
| 1965 (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()), | |
| 1966 "must have walkable stack"); | |
| 1967 | |
| 1968 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 1969 | |
| 979 | 1970 assert(!this->is_ext_suspended(), |
| 0 | 1971 "a thread trying to self-suspend should not already be suspended"); |
| 1972 | |
| 1973 if (this->is_suspend_equivalent()) { | |
| 1974 // If we are self-suspending as a result of the lifting of a | |
| 1975 // suspend equivalent condition, then the suspend_equivalent | |
| 1976 // flag is not cleared until we set the ext_suspended flag so | |
| 1977 // that wait_for_ext_suspend_completion() returns consistent | |
| 1978 // results. | |
| 1979 this->clear_suspend_equivalent(); | |
| 1980 } | |
| 1981 | |
| 1982 // A racing resume may have cancelled us before we grabbed SR_lock | |
| 1983 // above. Or another external suspend request could be waiting for us | |
| 1984 // by the time we return from SR_lock()->wait(). The thread | |
| 1985 // that requested the suspension may already be trying to walk our | |
| 1986 // stack and if we return now, we can change the stack out from under | |
| 1987 // it. This would be a "bad thing (TM)" and cause the stack walker | |
| 1988 // to crash. We stay self-suspended until there are no more pending | |
| 1989 // external suspend requests. | |
| 1990 while (is_external_suspend()) { | |
| 1991 ret++; | |
| 1992 this->set_ext_suspended(); | |
| 1993 | |
| 1994 // _ext_suspended flag is cleared by java_resume() | |
| 1995 while (is_ext_suspended()) { | |
| 1996 this->SR_lock()->wait(Mutex::_no_safepoint_check_flag); | |
| 1997 } | |
| 1998 } | |
| 1999 | |
| 2000 return ret; | |
| 2001 } | |
| 2002 | |
| 2003 #ifdef ASSERT | |
| 2004 // verify the JavaThread has not yet been published in the Threads::list, and | |
| 2005 // hence doesn't need protection from concurrent access at this stage | |
| 2006 void JavaThread::verify_not_published() { | |
| 2007 if (!Threads_lock->owned_by_self()) { | |
| 2008 MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag); | |
| 2009 assert( !Threads::includes(this), | |
| 2010 "java thread shouldn't have been published yet!"); | |
| 2011 } | |
| 2012 else { | |
| 2013 assert( !Threads::includes(this), | |
| 2014 "java thread shouldn't have been published yet!"); | |
| 2015 } | |
| 2016 } | |
| 2017 #endif | |
| 2018 | |
| 2019 // Slow path when the native==>VM/Java barriers detect a safepoint is in | |
| 2020 // progress or when _suspend_flags is non-zero. | |
| 2021 // Current thread needs to self-suspend if there is a suspend request and/or | |
| 2022 // block if a safepoint is in progress. | |
| 2023 // Async exception ISN'T checked. | |
| 2024 // Note only the ThreadInVMfromNative transition can call this function | |
| 2025 // directly and when thread state is _thread_in_native_trans | |
| 2026 void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) { | |
| 2027 assert(thread->thread_state() == _thread_in_native_trans, "wrong state"); | |
| 2028 | |
| 2029 JavaThread *curJT = JavaThread::current(); | |
| 2030 bool do_self_suspend = thread->is_external_suspend(); | |
| 2031 | |
| 2032 assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition"); | |
| 2033 | |
| 2034 // If JNIEnv proxies are allowed, don't self-suspend if the target | |
| 2035 // thread is not the current thread. In older versions of jdbx, jdbx | |
| 2036 // threads could call into the VM with another thread's JNIEnv so we | |
| 2037 // can be here operating on behalf of a suspended thread (4432884). | |
| 2038 if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) { | |
| 2039 JavaThreadState state = thread->thread_state(); | |
| 2040 | |
| 2041 // We mark this thread_blocked state as a suspend-equivalent so | |
| 2042 // that a caller to is_ext_suspend_completed() won't be confused. | |
| 2043 // The suspend-equivalent state is cleared by java_suspend_self(). | |
| 2044 thread->set_suspend_equivalent(); | |
| 2045 | |
| 2046 // If the safepoint code sees the _thread_in_native_trans state, it will | |
| 2047 // wait until the thread changes to other thread state. There is no | |
| 2048 // guarantee on how soon we can obtain the SR_lock and complete the | |
| 2049 // self-suspend request. It would be a bad idea to let safepoint wait for | |
| 2050 // too long. Temporarily change the state to _thread_blocked to | |
| 2051 // let the VM thread know that this thread is ready for GC. The problem | |
| 2052 // of changing thread state is that safepoint could happen just after | |
| 2053 // java_suspend_self() returns after being resumed, and VM thread will | |
| 2054 // see the _thread_blocked state. We must check for safepoint | |
| 2055 // after restoring the state and make sure we won't leave while a safepoint | |
| 2056 // is in progress. | |
| 2057 thread->set_thread_state(_thread_blocked); | |
| 2058 thread->java_suspend_self(); | |
| 2059 thread->set_thread_state(state); | |
| 2060 // Make sure new state is seen by VM thread | |
| 2061 if (os::is_MP()) { | |
| 2062 if (UseMembar) { | |
| 2063 // Force a fence between the write above and read below | |
| 2064 OrderAccess::fence(); | |
| 2065 } else { | |
| 2066 // Must use this rather than serialization page in particular on Windows | |
| 2067 InterfaceSupport::serialize_memory(thread); | |
| 2068 } | |
| 2069 } | |
| 2070 } | |
| 2071 | |
| 2072 if (SafepointSynchronize::do_call_back()) { | |
| 2073 // If we are safepointing, then block the caller which may not be | |
| 2074 // the same as the target thread (see above). | |
| 2075 SafepointSynchronize::block(curJT); | |
| 2076 } | |
| 2077 | |
| 2078 if (thread->is_deopt_suspend()) { | |
| 2079 thread->clear_deopt_suspend(); | |
| 2080 RegisterMap map(thread, false); | |
| 2081 frame f = thread->last_frame(); | |
| 2082 while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) { | |
| 2083 f = f.sender(&map); | |
| 2084 } | |
| 2085 if (f.id() == thread->must_deopt_id()) { | |
| 2086 thread->clear_must_deopt_id(); | |
| 2087 // Since we know we're safe to deopt the current state is a safe state | |
| 2088 f.deoptimize(thread, true); | |
| 2089 } else { | |
| 2090 fatal("missed deoptimization!"); | |
| 2091 } | |
| 2092 } | |
| 2093 } | |
| 2094 | |
| 2095 // Slow path when the native==>VM/Java barriers detect a safepoint is in | |
| 2096 // progress or when _suspend_flags is non-zero. | |
| 2097 // Current thread needs to self-suspend if there is a suspend request and/or | |
| 2098 // block if a safepoint is in progress. | |
| 2099 // Also check for pending async exception (not including unsafe access error). | |
| 2100 // Note only the native==>VM/Java barriers can call this function and when | |
| 2101 // thread state is _thread_in_native_trans. | |
| 2102 void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) { | |
| 2103 check_safepoint_and_suspend_for_native_trans(thread); | |
| 2104 | |
| 2105 if (thread->has_async_exception()) { | |
| 2106 // We are in _thread_in_native_trans state, don't handle unsafe | |
| 2107 // access error since that may block. | |
| 2108 thread->check_and_handle_async_exceptions(false); | |
| 2109 } | |
| 2110 } | |
| 2111 | |
| 2112 // We need to guarantee the Threads_lock here, since resumes are not | |
| 2113 // allowed during safepoint synchronization | |
| 2114 // Can only resume from an external suspension | |
| 2115 void JavaThread::java_resume() { | |
| 2116 assert_locked_or_safepoint(Threads_lock); | |
| 2117 | |
| 2118 // Sanity check: thread is gone, has started exiting or the thread | |
| 2119 // was not externally suspended. | |
| 2120 if (!Threads::includes(this) || is_exiting() || !is_external_suspend()) { | |
| 2121 return; | |
| 2122 } | |
| 2123 | |
| 2124 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag); | |
| 2125 | |
| 2126 clear_external_suspend(); | |
| 2127 | |
| 2128 if (is_ext_suspended()) { | |
| 2129 clear_ext_suspended(); | |
| 2130 SR_lock()->notify_all(); | |
| 2131 } | |
| 2132 } | |
| 2133 | |
| 2134 void JavaThread::create_stack_guard_pages() { | |
| 2135 if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return; | |
| 2136 address low_addr = stack_base() - stack_size(); | |
| 2137 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size(); | |
| 2138 | |
| 2139 int allocate = os::allocate_stack_guard_pages(); | |
| 2140 // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len); | |
| 2141 | |
|
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1290
diff
changeset
|
2142 if (allocate && !os::create_stack_guard_pages((char *) low_addr, len)) { |
| 0 | 2143 warning("Attempt to allocate stack guard pages failed."); |
| 2144 return; | |
| 2145 } | |
| 2146 | |
| 2147 if (os::guard_memory((char *) low_addr, len)) { | |
| 2148 _stack_guard_state = stack_guard_enabled; | |
| 2149 } else { | |
| 2150 warning("Attempt to protect stack guard pages failed."); | |
| 2151 if (os::uncommit_memory((char *) low_addr, len)) { | |
| 2152 warning("Attempt to deallocate stack guard pages failed."); | |
| 2153 } | |
| 2154 } | |
| 2155 } | |
| 2156 | |
| 2157 void JavaThread::remove_stack_guard_pages() { | |
| 2158 if (_stack_guard_state == stack_guard_unused) return; | |
| 2159 address low_addr = stack_base() - stack_size(); | |
| 2160 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size(); | |
| 2161 | |
| 2162 if (os::allocate_stack_guard_pages()) { | |
|
1320
3b3d12e645e7
6929067: Stack guard pages should be removed when thread is detached
coleenp
parents:
1290
diff
changeset
|
2163 if (os::remove_stack_guard_pages((char *) low_addr, len)) { |
| 0 | 2164 _stack_guard_state = stack_guard_unused; |
| 2165 } else { | |
| 2166 warning("Attempt to deallocate stack guard pages failed."); | |
| 2167 } | |
| 2168 } else { | |
| 2169 if (_stack_guard_state == stack_guard_unused) return; | |
| 2170 if (os::unguard_memory((char *) low_addr, len)) { | |
| 2171 _stack_guard_state = stack_guard_unused; | |
| 2172 } else { | |
| 2173 warning("Attempt to unprotect stack guard pages failed."); | |
| 2174 } | |
| 2175 } | |
| 2176 } | |
| 2177 | |
| 2178 void JavaThread::enable_stack_yellow_zone() { | |
| 2179 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2180 assert(_stack_guard_state != stack_guard_enabled, "already enabled"); | |
| 2181 | |
| 2182 // The base notation is from the stacks point of view, growing downward. | |
| 2183 // We need to adjust it to work correctly with guard_memory() | |
| 2184 address base = stack_yellow_zone_base() - stack_yellow_zone_size(); | |
| 2185 | |
| 2186 guarantee(base < stack_base(),"Error calculating stack yellow zone"); | |
| 2187 guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone"); | |
| 2188 | |
| 2189 if (os::guard_memory((char *) base, stack_yellow_zone_size())) { | |
| 2190 _stack_guard_state = stack_guard_enabled; | |
| 2191 } else { | |
| 2192 warning("Attempt to guard stack yellow zone failed."); | |
| 2193 } | |
| 2194 enable_register_stack_guard(); | |
| 2195 } | |
| 2196 | |
| 2197 void JavaThread::disable_stack_yellow_zone() { | |
| 2198 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2199 assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled"); | |
| 2200 | |
| 2201 // Simply return if called for a thread that does not use guard pages. | |
| 2202 if (_stack_guard_state == stack_guard_unused) return; | |
| 2203 | |
| 2204 // The base notation is from the stacks point of view, growing downward. | |
| 2205 // We need to adjust it to work correctly with guard_memory() | |
| 2206 address base = stack_yellow_zone_base() - stack_yellow_zone_size(); | |
| 2207 | |
| 2208 if (os::unguard_memory((char *)base, stack_yellow_zone_size())) { | |
| 2209 _stack_guard_state = stack_guard_yellow_disabled; | |
| 2210 } else { | |
| 2211 warning("Attempt to unguard stack yellow zone failed."); | |
| 2212 } | |
| 2213 disable_register_stack_guard(); | |
| 2214 } | |
| 2215 | |
| 2216 void JavaThread::enable_stack_red_zone() { | |
| 2217 // The base notation is from the stacks point of view, growing downward. | |
| 2218 // We need to adjust it to work correctly with guard_memory() | |
| 2219 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2220 address base = stack_red_zone_base() - stack_red_zone_size(); | |
| 2221 | |
| 2222 guarantee(base < stack_base(),"Error calculating stack red zone"); | |
| 2223 guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone"); | |
| 2224 | |
| 2225 if(!os::guard_memory((char *) base, stack_red_zone_size())) { | |
| 2226 warning("Attempt to guard stack red zone failed."); | |
| 2227 } | |
| 2228 } | |
| 2229 | |
| 2230 void JavaThread::disable_stack_red_zone() { | |
| 2231 // The base notation is from the stacks point of view, growing downward. | |
| 2232 // We need to adjust it to work correctly with guard_memory() | |
| 2233 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages."); | |
| 2234 address base = stack_red_zone_base() - stack_red_zone_size(); | |
| 2235 if (!os::unguard_memory((char *)base, stack_red_zone_size())) { | |
| 2236 warning("Attempt to unguard stack red zone failed."); | |
| 2237 } | |
| 2238 } | |
| 2239 | |
| 2240 void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) { | |
| 2241 // ignore is there is no stack | |
| 2242 if (!has_last_Java_frame()) return; | |
| 2243 // traverse the stack frames. Starts from top frame. | |
| 2244 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2245 frame* fr = fst.current(); | |
| 2246 f(fr, fst.register_map()); | |
| 2247 } | |
| 2248 } | |
| 2249 | |
| 2250 | |
| 2251 #ifndef PRODUCT | |
| 2252 // Deoptimization | |
| 2253 // Function for testing deoptimization | |
| 2254 void JavaThread::deoptimize() { | |
| 2255 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
| 2256 StackFrameStream fst(this, UseBiasedLocking); | |
| 2257 bool deopt = false; // Dump stack only if a deopt actually happens. | |
| 2258 bool only_at = strlen(DeoptimizeOnlyAt) > 0; | |
| 2259 // Iterate over all frames in the thread and deoptimize | |
| 2260 for(; !fst.is_done(); fst.next()) { | |
| 2261 if(fst.current()->can_be_deoptimized()) { | |
| 2262 | |
| 2263 if (only_at) { | |
| 2264 // Deoptimize only at particular bcis. DeoptimizeOnlyAt | |
| 2265 // consists of comma or carriage return separated numbers so | |
| 2266 // search for the current bci in that string. | |
| 2267 address pc = fst.current()->pc(); | |
| 2268 nmethod* nm = (nmethod*) fst.current()->cb(); | |
| 2269 ScopeDesc* sd = nm->scope_desc_at( pc); | |
| 2270 char buffer[8]; | |
| 2271 jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci()); | |
| 2272 size_t len = strlen(buffer); | |
| 2273 const char * found = strstr(DeoptimizeOnlyAt, buffer); | |
| 2274 while (found != NULL) { | |
| 2275 if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') && | |
| 2276 (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) { | |
| 2277 // Check that the bci found is bracketed by terminators. | |
| 2278 break; | |
| 2279 } | |
| 2280 found = strstr(found + 1, buffer); | |
| 2281 } | |
| 2282 if (!found) { | |
| 2283 continue; | |
| 2284 } | |
| 2285 } | |
| 2286 | |
| 2287 if (DebugDeoptimization && !deopt) { | |
| 2288 deopt = true; // One-time only print before deopt | |
| 2289 tty->print_cr("[BEFORE Deoptimization]"); | |
| 2290 trace_frames(); | |
| 2291 trace_stack(); | |
| 2292 } | |
| 2293 Deoptimization::deoptimize(this, *fst.current(), fst.register_map()); | |
| 2294 } | |
| 2295 } | |
| 2296 | |
| 2297 if (DebugDeoptimization && deopt) { | |
| 2298 tty->print_cr("[AFTER Deoptimization]"); | |
| 2299 trace_frames(); | |
| 2300 } | |
| 2301 } | |
| 2302 | |
| 2303 | |
| 2304 // Make zombies | |
| 2305 void JavaThread::make_zombies() { | |
| 2306 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2307 if (fst.current()->can_be_deoptimized()) { | |
| 2308 // it is a Java nmethod | |
| 2309 nmethod* nm = CodeCache::find_nmethod(fst.current()->pc()); | |
| 2310 nm->make_not_entrant(); | |
| 2311 } | |
| 2312 } | |
| 2313 } | |
| 2314 #endif // PRODUCT | |
| 2315 | |
| 2316 | |
| 2317 void JavaThread::deoptimized_wrt_marked_nmethods() { | |
| 2318 if (!has_last_Java_frame()) return; | |
| 2319 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass | |
| 2320 StackFrameStream fst(this, UseBiasedLocking); | |
| 2321 for(; !fst.is_done(); fst.next()) { | |
| 2322 if (fst.current()->should_be_deoptimized()) { | |
| 2323 Deoptimization::deoptimize(this, *fst.current(), fst.register_map()); | |
| 2324 } | |
| 2325 } | |
| 2326 } | |
| 2327 | |
| 2328 | |
| 2329 // GC support | |
| 2330 static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); } | |
| 2331 | |
| 2332 void JavaThread::gc_epilogue() { | |
| 2333 frames_do(frame_gc_epilogue); | |
| 2334 } | |
| 2335 | |
| 2336 | |
| 2337 static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); } | |
| 2338 | |
| 2339 void JavaThread::gc_prologue() { | |
| 2340 frames_do(frame_gc_prologue); | |
| 2341 } | |
| 2342 | |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2343 // If the caller is a NamedThread, then remember, in the current scope, |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2344 // the given JavaThread in its _processed_thread field. |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2345 class RememberProcessedThread: public StackObj { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2346 NamedThread* _cur_thr; |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2347 public: |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2348 RememberProcessedThread(JavaThread* jthr) { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2349 Thread* thread = Thread::current(); |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2350 if (thread->is_Named_thread()) { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2351 _cur_thr = (NamedThread *)thread; |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2352 _cur_thr->set_processed_thread(jthr); |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2353 } else { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2354 _cur_thr = NULL; |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2355 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2356 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2357 |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2358 ~RememberProcessedThread() { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2359 if (_cur_thr) { |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2360 _cur_thr->set_processed_thread(NULL); |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2361 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2362 } |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2363 }; |
| 0 | 2364 |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2365 void JavaThread::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
| 1166 | 2366 // Verify that the deferred card marks have been flushed. |
| 2367 assert(deferred_card_mark().is_empty(), "Should be empty during GC"); | |
|
1027
39b01ab7035a
6888898: CMS: ReduceInitialCardMarks unsafe in the presence of cms precleaning
ysr
parents:
997
diff
changeset
|
2368 |
| 0 | 2369 // The ThreadProfiler oops_do is done from FlatProfiler::oops_do |
| 2370 // since there may be more than one thread using each ThreadProfiler. | |
| 2371 | |
| 2372 // Traverse the GCHandles | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2373 Thread::oops_do(f, cf); |
| 0 | 2374 |
| 2375 assert( (!has_last_Java_frame() && java_call_counter() == 0) || | |
| 2376 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!"); | |
| 2377 | |
| 2378 if (has_last_Java_frame()) { | |
|
1119
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2379 // Record JavaThread to GC thread |
|
547f81740344
6361589: Print out stack trace for target thread of GC crash
minqi
parents:
1115
diff
changeset
|
2380 RememberProcessedThread rpt(this); |
| 0 | 2381 |
| 2382 // Traverse the privileged stack | |
| 2383 if (_privileged_stack_top != NULL) { | |
| 2384 _privileged_stack_top->oops_do(f); | |
| 2385 } | |
| 2386 | |
| 2387 // traverse the registered growable array | |
| 2388 if (_array_for_gc != NULL) { | |
| 2389 for (int index = 0; index < _array_for_gc->length(); index++) { | |
| 2390 f->do_oop(_array_for_gc->adr_at(index)); | |
| 2391 } | |
| 2392 } | |
| 2393 | |
| 2394 // Traverse the monitor chunks | |
| 2395 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) { | |
| 2396 chunk->oops_do(f); | |
| 2397 } | |
| 2398 | |
| 2399 // Traverse the execution stack | |
| 2400 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2401 fst.current()->oops_do(f, cf, fst.register_map()); |
| 0 | 2402 } |
| 2403 } | |
| 2404 | |
| 2405 // callee_target is never live across a gc point so NULL it here should | |
| 2406 // it still contain a methdOop. | |
| 2407 | |
| 2408 set_callee_target(NULL); | |
| 2409 | |
| 2410 assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!"); | |
| 2411 // If we have deferred set_locals there might be oops waiting to be | |
| 2412 // written | |
| 2413 GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals(); | |
| 2414 if (list != NULL) { | |
| 2415 for (int i = 0; i < list->length(); i++) { | |
| 2416 list->at(i)->oops_do(f); | |
| 2417 } | |
| 2418 } | |
| 2419 | |
| 2420 // Traverse instance variables at the end since the GC may be moving things | |
| 2421 // around using this function | |
| 2422 f->do_oop((oop*) &_threadObj); | |
| 2423 f->do_oop((oop*) &_vm_result); | |
| 2424 f->do_oop((oop*) &_vm_result_2); | |
| 2425 f->do_oop((oop*) &_exception_oop); | |
| 2426 f->do_oop((oop*) &_pending_async_exception); | |
| 2427 | |
| 2428 if (jvmti_thread_state() != NULL) { | |
| 2429 jvmti_thread_state()->oops_do(f); | |
| 2430 } | |
| 2431 } | |
| 2432 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2433 void JavaThread::nmethods_do(CodeBlobClosure* cf) { |
|
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2434 Thread::nmethods_do(cf); // (super method is a no-op) |
| 0 | 2435 |
| 2436 assert( (!has_last_Java_frame() && java_call_counter() == 0) || | |
| 2437 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!"); | |
| 2438 | |
| 2439 if (has_last_Java_frame()) { | |
| 2440 // Traverse the execution stack | |
| 2441 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2442 fst.current()->nmethods_do(cf); |
| 0 | 2443 } |
| 2444 } | |
| 2445 } | |
| 2446 | |
| 2447 // Printing | |
| 2448 const char* _get_thread_state_name(JavaThreadState _thread_state) { | |
| 2449 switch (_thread_state) { | |
| 2450 case _thread_uninitialized: return "_thread_uninitialized"; | |
| 2451 case _thread_new: return "_thread_new"; | |
| 2452 case _thread_new_trans: return "_thread_new_trans"; | |
| 2453 case _thread_in_native: return "_thread_in_native"; | |
| 2454 case _thread_in_native_trans: return "_thread_in_native_trans"; | |
| 2455 case _thread_in_vm: return "_thread_in_vm"; | |
| 2456 case _thread_in_vm_trans: return "_thread_in_vm_trans"; | |
| 2457 case _thread_in_Java: return "_thread_in_Java"; | |
| 2458 case _thread_in_Java_trans: return "_thread_in_Java_trans"; | |
| 2459 case _thread_blocked: return "_thread_blocked"; | |
| 2460 case _thread_blocked_trans: return "_thread_blocked_trans"; | |
| 2461 default: return "unknown thread state"; | |
| 2462 } | |
| 2463 } | |
| 2464 | |
| 2465 #ifndef PRODUCT | |
| 2466 void JavaThread::print_thread_state_on(outputStream *st) const { | |
| 2467 st->print_cr(" JavaThread state: %s", _get_thread_state_name(_thread_state)); | |
| 2468 }; | |
| 2469 void JavaThread::print_thread_state() const { | |
| 2470 print_thread_state_on(tty); | |
| 2471 }; | |
| 2472 #endif // PRODUCT | |
| 2473 | |
| 2474 // Called by Threads::print() for VM_PrintThreads operation | |
| 2475 void JavaThread::print_on(outputStream *st) const { | |
| 2476 st->print("\"%s\" ", get_thread_name()); | |
| 2477 oop thread_oop = threadObj(); | |
| 2478 if (thread_oop != NULL && java_lang_Thread::is_daemon(thread_oop)) st->print("daemon "); | |
| 2479 Thread::print_on(st); | |
| 2480 // print guess for valid stack memory region (assume 4K pages); helps lock debugging | |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
2481 st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12)); |
| 0 | 2482 if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) { |
| 2483 st->print_cr(" java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop)); | |
| 2484 } | |
| 2485 #ifndef PRODUCT | |
| 2486 print_thread_state_on(st); | |
| 2487 _safepoint_state->print_on(st); | |
| 2488 #endif // PRODUCT | |
| 2489 } | |
| 2490 | |
| 2491 // Called by fatal error handler. The difference between this and | |
| 2492 // JavaThread::print() is that we can't grab lock or allocate memory. | |
| 2493 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const { | |
| 2494 st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen)); | |
| 2495 oop thread_obj = threadObj(); | |
| 2496 if (thread_obj != NULL) { | |
| 2497 if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon"); | |
| 2498 } | |
| 2499 st->print(" ["); | |
| 2500 st->print("%s", _get_thread_state_name(_thread_state)); | |
| 2501 if (osthread()) { | |
| 2502 st->print(", id=%d", osthread()->thread_id()); | |
| 2503 } | |
| 2504 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")", | |
| 2505 _stack_base - _stack_size, _stack_base); | |
| 2506 st->print("]"); | |
| 2507 return; | |
| 2508 } | |
| 2509 | |
| 2510 // Verification | |
| 2511 | |
| 2512 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); } | |
| 2513 | |
| 2514 void JavaThread::verify() { | |
| 2515 // Verify oops in the thread. | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
2516 oops_do(&VerifyOopClosure::verify_oop, NULL); |
| 0 | 2517 |
| 2518 // Verify the stack frames. | |
| 2519 frames_do(frame_verify); | |
| 2520 } | |
| 2521 | |
| 2522 // CR 6300358 (sub-CR 2137150) | |
| 2523 // Most callers of this method assume that it can't return NULL but a | |
| 2524 // thread may not have a name whilst it is in the process of attaching to | |
| 2525 // the VM - see CR 6412693, and there are places where a JavaThread can be | |
| 2526 // seen prior to having it's threadObj set (eg JNI attaching threads and | |
| 2527 // if vm exit occurs during initialization). These cases can all be accounted | |
| 2528 // for such that this method never returns NULL. | |
| 2529 const char* JavaThread::get_thread_name() const { | |
| 2530 #ifdef ASSERT | |
| 2531 // early safepoints can hit while current thread does not yet have TLS | |
| 2532 if (!SafepointSynchronize::is_at_safepoint()) { | |
| 2533 Thread *cur = Thread::current(); | |
| 2534 if (!(cur->is_Java_thread() && cur == this)) { | |
| 2535 // Current JavaThreads are allowed to get their own name without | |
| 2536 // the Threads_lock. | |
| 2537 assert_locked_or_safepoint(Threads_lock); | |
| 2538 } | |
| 2539 } | |
| 2540 #endif // ASSERT | |
| 2541 return get_thread_name_string(); | |
| 2542 } | |
| 2543 | |
| 2544 // Returns a non-NULL representation of this thread's name, or a suitable | |
| 2545 // descriptive string if there is no set name | |
| 2546 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const { | |
| 2547 const char* name_str; | |
| 2548 oop thread_obj = threadObj(); | |
| 2549 if (thread_obj != NULL) { | |
| 2550 typeArrayOop name = java_lang_Thread::name(thread_obj); | |
| 2551 if (name != NULL) { | |
| 2552 if (buf == NULL) { | |
| 2553 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 2554 } | |
| 2555 else { | |
| 2556 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen); | |
| 2557 } | |
| 2558 } | |
| 2559 else if (is_attaching()) { // workaround for 6412693 - see 6404306 | |
| 2560 name_str = "<no-name - thread is attaching>"; | |
| 2561 } | |
| 2562 else { | |
| 2563 name_str = Thread::name(); | |
| 2564 } | |
| 2565 } | |
| 2566 else { | |
| 2567 name_str = Thread::name(); | |
| 2568 } | |
| 2569 assert(name_str != NULL, "unexpected NULL thread name"); | |
| 2570 return name_str; | |
| 2571 } | |
| 2572 | |
| 2573 | |
| 2574 const char* JavaThread::get_threadgroup_name() const { | |
| 2575 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);) | |
| 2576 oop thread_obj = threadObj(); | |
| 2577 if (thread_obj != NULL) { | |
| 2578 oop thread_group = java_lang_Thread::threadGroup(thread_obj); | |
| 2579 if (thread_group != NULL) { | |
| 2580 typeArrayOop name = java_lang_ThreadGroup::name(thread_group); | |
| 2581 // ThreadGroup.name can be null | |
| 2582 if (name != NULL) { | |
| 2583 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 2584 return str; | |
| 2585 } | |
| 2586 } | |
| 2587 } | |
| 2588 return NULL; | |
| 2589 } | |
| 2590 | |
| 2591 const char* JavaThread::get_parent_name() const { | |
| 2592 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);) | |
| 2593 oop thread_obj = threadObj(); | |
| 2594 if (thread_obj != NULL) { | |
| 2595 oop thread_group = java_lang_Thread::threadGroup(thread_obj); | |
| 2596 if (thread_group != NULL) { | |
| 2597 oop parent = java_lang_ThreadGroup::parent(thread_group); | |
| 2598 if (parent != NULL) { | |
| 2599 typeArrayOop name = java_lang_ThreadGroup::name(parent); | |
| 2600 // ThreadGroup.name can be null | |
| 2601 if (name != NULL) { | |
| 2602 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); | |
| 2603 return str; | |
| 2604 } | |
| 2605 } | |
| 2606 } | |
| 2607 } | |
| 2608 return NULL; | |
| 2609 } | |
| 2610 | |
| 2611 ThreadPriority JavaThread::java_priority() const { | |
| 2612 oop thr_oop = threadObj(); | |
| 2613 if (thr_oop == NULL) return NormPriority; // Bootstrapping | |
| 2614 ThreadPriority priority = java_lang_Thread::priority(thr_oop); | |
| 2615 assert(MinPriority <= priority && priority <= MaxPriority, "sanity check"); | |
| 2616 return priority; | |
| 2617 } | |
| 2618 | |
| 2619 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) { | |
| 2620 | |
| 2621 assert(Threads_lock->owner() == Thread::current(), "must have threads lock"); | |
| 2622 // Link Java Thread object <-> C++ Thread | |
| 2623 | |
| 2624 // Get the C++ thread object (an oop) from the JNI handle (a jthread) | |
| 2625 // and put it into a new Handle. The Handle "thread_oop" can then | |
| 2626 // be used to pass the C++ thread object to other methods. | |
| 2627 | |
| 2628 // Set the Java level thread object (jthread) field of the | |
| 2629 // new thread (a JavaThread *) to C++ thread object using the | |
| 2630 // "thread_oop" handle. | |
| 2631 | |
| 2632 // Set the thread field (a JavaThread *) of the | |
| 2633 // oop representing the java_lang_Thread to the new thread (a JavaThread *). | |
| 2634 | |
| 2635 Handle thread_oop(Thread::current(), | |
| 2636 JNIHandles::resolve_non_null(jni_thread)); | |
| 2637 assert(instanceKlass::cast(thread_oop->klass())->is_linked(), | |
| 2638 "must be initialized"); | |
| 2639 set_threadObj(thread_oop()); | |
| 2640 java_lang_Thread::set_thread(thread_oop(), this); | |
| 2641 | |
| 2642 if (prio == NoPriority) { | |
| 2643 prio = java_lang_Thread::priority(thread_oop()); | |
| 2644 assert(prio != NoPriority, "A valid priority should be present"); | |
| 2645 } | |
| 2646 | |
| 2647 // Push the Java priority down to the native thread; needs Threads_lock | |
| 2648 Thread::set_priority(this, prio); | |
| 2649 | |
| 2650 // Add the new thread to the Threads list and set it in motion. | |
| 2651 // We must have threads lock in order to call Threads::add. | |
| 2652 // It is crucial that we do not block before the thread is | |
| 2653 // added to the Threads list for if a GC happens, then the java_thread oop | |
| 2654 // will not be visited by GC. | |
| 2655 Threads::add(this); | |
| 2656 } | |
| 2657 | |
| 2658 oop JavaThread::current_park_blocker() { | |
| 2659 // Support for JSR-166 locks | |
| 2660 oop thread_oop = threadObj(); | |
| 242 | 2661 if (thread_oop != NULL && |
| 2662 JDK_Version::current().supports_thread_park_blocker()) { | |
| 0 | 2663 return java_lang_Thread::park_blocker(thread_oop); |
| 2664 } | |
| 2665 return NULL; | |
| 2666 } | |
| 2667 | |
| 2668 | |
| 2669 void JavaThread::print_stack_on(outputStream* st) { | |
| 2670 if (!has_last_Java_frame()) return; | |
| 2671 ResourceMark rm; | |
| 2672 HandleMark hm; | |
| 2673 | |
| 2674 RegisterMap reg_map(this); | |
| 2675 vframe* start_vf = last_java_vframe(®_map); | |
| 2676 int count = 0; | |
| 2677 for (vframe* f = start_vf; f; f = f->sender() ) { | |
| 2678 if (f->is_java_frame()) { | |
| 2679 javaVFrame* jvf = javaVFrame::cast(f); | |
| 2680 java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci()); | |
| 2681 | |
| 2682 // Print out lock information | |
| 2683 if (JavaMonitorsInStackTrace) { | |
| 2684 jvf->print_lock_info_on(st, count); | |
| 2685 } | |
| 2686 } else { | |
| 2687 // Ignore non-Java frames | |
| 2688 } | |
| 2689 | |
| 2690 // Bail-out case for too deep stacks | |
| 2691 count++; | |
| 2692 if (MaxJavaStackTraceDepth == count) return; | |
| 2693 } | |
| 2694 } | |
| 2695 | |
| 2696 | |
| 2697 // JVMTI PopFrame support | |
| 2698 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { | |
| 2699 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); | |
| 2700 if (in_bytes(size_in_bytes) != 0) { | |
| 2701 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes)); | |
| 2702 _popframe_preserved_args_size = in_bytes(size_in_bytes); | |
| 2703 Copy::conjoint_bytes(start, _popframe_preserved_args, _popframe_preserved_args_size); | |
| 2704 } | |
| 2705 } | |
| 2706 | |
| 2707 void* JavaThread::popframe_preserved_args() { | |
| 2708 return _popframe_preserved_args; | |
| 2709 } | |
| 2710 | |
| 2711 ByteSize JavaThread::popframe_preserved_args_size() { | |
| 2712 return in_ByteSize(_popframe_preserved_args_size); | |
| 2713 } | |
| 2714 | |
| 2715 WordSize JavaThread::popframe_preserved_args_size_in_words() { | |
| 2716 int sz = in_bytes(popframe_preserved_args_size()); | |
| 2717 assert(sz % wordSize == 0, "argument size must be multiple of wordSize"); | |
| 2718 return in_WordSize(sz / wordSize); | |
| 2719 } | |
| 2720 | |
| 2721 void JavaThread::popframe_free_preserved_args() { | |
| 2722 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); | |
| 2723 FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args); | |
| 2724 _popframe_preserved_args = NULL; | |
| 2725 _popframe_preserved_args_size = 0; | |
| 2726 } | |
| 2727 | |
| 2728 #ifndef PRODUCT | |
| 2729 | |
| 2730 void JavaThread::trace_frames() { | |
| 2731 tty->print_cr("[Describe stack]"); | |
| 2732 int frame_no = 1; | |
| 2733 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) { | |
| 2734 tty->print(" %d. ", frame_no++); | |
| 2735 fst.current()->print_value_on(tty,this); | |
| 2736 tty->cr(); | |
| 2737 } | |
| 2738 } | |
| 2739 | |
| 2740 | |
| 2741 void JavaThread::trace_stack_from(vframe* start_vf) { | |
| 2742 ResourceMark rm; | |
| 2743 int vframe_no = 1; | |
| 2744 for (vframe* f = start_vf; f; f = f->sender() ) { | |
| 2745 if (f->is_java_frame()) { | |
| 2746 javaVFrame::cast(f)->print_activation(vframe_no++); | |
| 2747 } else { | |
| 2748 f->print(); | |
| 2749 } | |
| 2750 if (vframe_no > StackPrintLimit) { | |
| 2751 tty->print_cr("...<more frames>..."); | |
| 2752 return; | |
| 2753 } | |
| 2754 } | |
| 2755 } | |
| 2756 | |
| 2757 | |
| 2758 void JavaThread::trace_stack() { | |
| 2759 if (!has_last_Java_frame()) return; | |
| 2760 ResourceMark rm; | |
| 2761 HandleMark hm; | |
| 2762 RegisterMap reg_map(this); | |
| 2763 trace_stack_from(last_java_vframe(®_map)); | |
| 2764 } | |
| 2765 | |
| 2766 | |
| 2767 #endif // PRODUCT | |
| 2768 | |
| 2769 | |
| 2770 javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) { | |
| 2771 assert(reg_map != NULL, "a map must be given"); | |
| 2772 frame f = last_frame(); | |
| 2773 for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) { | |
| 2774 if (vf->is_java_frame()) return javaVFrame::cast(vf); | |
| 2775 } | |
| 2776 return NULL; | |
| 2777 } | |
| 2778 | |
| 2779 | |
| 2780 klassOop JavaThread::security_get_caller_class(int depth) { | |
| 2781 vframeStream vfst(this); | |
| 2782 vfst.security_get_caller_frame(depth); | |
| 2783 if (!vfst.at_end()) { | |
| 2784 return vfst.method()->method_holder(); | |
| 2785 } | |
| 2786 return NULL; | |
| 2787 } | |
| 2788 | |
| 2789 static void compiler_thread_entry(JavaThread* thread, TRAPS) { | |
| 2790 assert(thread->is_Compiler_thread(), "must be compiler thread"); | |
| 2791 CompileBroker::compiler_thread_loop(); | |
| 2792 } | |
| 2793 | |
| 2794 // Create a CompilerThread | |
| 2795 CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters) | |
| 2796 : JavaThread(&compiler_thread_entry) { | |
| 2797 _env = NULL; | |
| 2798 _log = NULL; | |
| 2799 _task = NULL; | |
| 2800 _queue = queue; | |
| 2801 _counters = counters; | |
|
1454
7cf1952ec5fb
Added flag -XX:BootstrapC1X that precompiles Object::<init> and then every method in the compilation queue until it is empty.
Thomas Wuerthinger <wuerthinger@ssw.jku.at>
parents:
1410
diff
changeset
|
2802 _is_compiling = false; |
| 0 | 2803 |
| 2804 #ifndef PRODUCT | |
| 2805 _ideal_graph_printer = NULL; | |
| 2806 #endif | |
| 2807 } | |
| 2808 | |
| 2809 | |
| 2810 // ======= Threads ======== | |
| 2811 | |
| 2812 // The Threads class links together all active threads, and provides | |
| 2813 // operations over all threads. It is protected by its own Mutex | |
| 2814 // lock, which is also used in other contexts to protect thread | |
| 2815 // operations from having the thread being operated on from exiting | |
| 2816 // and going away unexpectedly (e.g., safepoint synchronization) | |
| 2817 | |
| 2818 JavaThread* Threads::_thread_list = NULL; | |
| 2819 int Threads::_number_of_threads = 0; | |
| 2820 int Threads::_number_of_non_daemon_threads = 0; | |
| 2821 int Threads::_return_code = 0; | |
| 2822 size_t JavaThread::_stack_size_at_create = 0; | |
| 2823 | |
| 2824 // All JavaThreads | |
| 2825 #define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next()) | |
| 2826 | |
| 2827 void os_stream(); | |
| 2828 | |
| 2829 // All JavaThreads + all non-JavaThreads (i.e., every thread in the system) | |
| 2830 void Threads::threads_do(ThreadClosure* tc) { | |
| 2831 assert_locked_or_safepoint(Threads_lock); | |
| 2832 // ALL_JAVA_THREADS iterates through all JavaThreads | |
| 2833 ALL_JAVA_THREADS(p) { | |
| 2834 tc->do_thread(p); | |
| 2835 } | |
| 2836 // Someday we could have a table or list of all non-JavaThreads. | |
| 2837 // For now, just manually iterate through them. | |
| 2838 tc->do_thread(VMThread::vm_thread()); | |
| 2839 Universe::heap()->gc_threads_do(tc); | |
|
323
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2840 WatcherThread *wt = WatcherThread::watcher_thread(); |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2841 // Strictly speaking, the following NULL check isn't sufficient to make sure |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2842 // the data for WatcherThread is still valid upon being examined. However, |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2843 // considering that WatchThread terminates when the VM is on the way to |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2844 // exit at safepoint, the chance of the above is extremely small. The right |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2845 // way to prevent termination of WatcherThread would be to acquire |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2846 // Terminator_lock, but we can't do that without violating the lock rank |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2847 // checking in some cases. |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2848 if (wt != NULL) |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2849 tc->do_thread(wt); |
|
b33eef719520
6740526: sun/management/HotspotThreadMBean/GetInternalThreads.java test failed
xlu
parents:
286
diff
changeset
|
2850 |
| 0 | 2851 // If CompilerThreads ever become non-JavaThreads, add them here |
| 2852 } | |
| 2853 | |
| 2854 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) { | |
| 2855 | |
| 242 | 2856 extern void JDK_Version_init(); |
| 2857 | |
| 0 | 2858 // Check version |
| 2859 if (!is_supported_jni_version(args->version)) return JNI_EVERSION; | |
| 2860 | |
| 2861 // Initialize the output stream module | |
| 2862 ostream_init(); | |
| 2863 | |
| 2864 // Process java launcher properties. | |
| 2865 Arguments::process_sun_java_launcher_properties(args); | |
| 2866 | |
| 2867 // Initialize the os module before using TLS | |
| 2868 os::init(); | |
| 2869 | |
| 2870 // Initialize system properties. | |
| 2871 Arguments::init_system_properties(); | |
| 2872 | |
| 242 | 2873 // So that JDK version can be used as a discrimintor when parsing arguments |
| 2874 JDK_Version_init(); | |
| 2875 | |
| 0 | 2876 // Parse arguments |
| 2877 jint parse_result = Arguments::parse(args); | |
| 2878 if (parse_result != JNI_OK) return parse_result; | |
| 2879 | |
| 2880 if (PauseAtStartup) { | |
| 2881 os::pause(); | |
| 2882 } | |
| 2883 | |
| 2884 HS_DTRACE_PROBE(hotspot, vm__init__begin); | |
| 2885 | |
| 2886 // Record VM creation timing statistics | |
| 2887 TraceVmCreationTime create_vm_timer; | |
| 2888 create_vm_timer.start(); | |
| 2889 | |
| 2890 // Timing (must come after argument parsing) | |
| 2891 TraceTime timer("Create VM", TraceStartupTime); | |
| 2892 | |
| 2893 // Initialize the os module after parsing the args | |
| 2894 jint os_init_2_result = os::init_2(); | |
| 2895 if (os_init_2_result != JNI_OK) return os_init_2_result; | |
| 2896 | |
| 2897 // Initialize output stream logging | |
| 2898 ostream_init_log(); | |
| 2899 | |
| 2900 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad | |
| 2901 // Must be before create_vm_init_agents() | |
| 2902 if (Arguments::init_libraries_at_startup()) { | |
| 2903 convert_vm_init_libraries_to_agents(); | |
| 2904 } | |
| 2905 | |
| 2906 // Launch -agentlib/-agentpath and converted -Xrun agents | |
| 2907 if (Arguments::init_agents_at_startup()) { | |
| 2908 create_vm_init_agents(); | |
| 2909 } | |
| 2910 | |
| 2911 // Initialize Threads state | |
| 2912 _thread_list = NULL; | |
| 2913 _number_of_threads = 0; | |
| 2914 _number_of_non_daemon_threads = 0; | |
| 2915 | |
| 2916 // Initialize TLS | |
| 2917 ThreadLocalStorage::init(); | |
| 2918 | |
| 2919 // Initialize global data structures and create system classes in heap | |
| 2920 vm_init_globals(); | |
| 2921 | |
| 2922 // Attach the main thread to this os thread | |
| 2923 JavaThread* main_thread = new JavaThread(); | |
| 2924 main_thread->set_thread_state(_thread_in_vm); | |
| 2925 // must do this before set_active_handles and initialize_thread_local_storage | |
| 2926 // Note: on solaris initialize_thread_local_storage() will (indirectly) | |
| 2927 // change the stack size recorded here to one based on the java thread | |
| 2928 // stacksize. This adjusted size is what is used to figure the placement | |
| 2929 // of the guard pages. | |
| 2930 main_thread->record_stack_base_and_size(); | |
| 2931 main_thread->initialize_thread_local_storage(); | |
| 2932 | |
| 2933 main_thread->set_active_handles(JNIHandleBlock::allocate_block()); | |
| 2934 | |
| 2935 if (!main_thread->set_as_starting_thread()) { | |
| 2936 vm_shutdown_during_initialization( | |
| 2937 "Failed necessary internal allocation. Out of swap space"); | |
| 2938 delete main_thread; | |
| 2939 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again | |
| 2940 return JNI_ENOMEM; | |
| 2941 } | |
| 2942 | |
| 2943 // Enable guard page *after* os::create_main_thread(), otherwise it would | |
| 2944 // crash Linux VM, see notes in os_linux.cpp. | |
| 2945 main_thread->create_stack_guard_pages(); | |
| 2946 | |
| 2947 // Initialize Java-Leve synchronization subsystem | |
| 2948 ObjectSynchronizer::Initialize() ; | |
| 2949 | |
| 2950 // Initialize global modules | |
| 2951 jint status = init_globals(); | |
| 2952 if (status != JNI_OK) { | |
| 2953 delete main_thread; | |
| 2954 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again | |
| 2955 return status; | |
| 2956 } | |
| 2957 | |
| 2958 HandleMark hm; | |
| 2959 | |
| 2960 { MutexLocker mu(Threads_lock); | |
| 2961 Threads::add(main_thread); | |
| 2962 } | |
| 2963 | |
| 2964 // Any JVMTI raw monitors entered in onload will transition into | |
| 2965 // real raw monitor. VM is setup enough here for raw monitor enter. | |
| 2966 JvmtiExport::transition_pending_onload_raw_monitors(); | |
| 2967 | |
| 2968 if (VerifyBeforeGC && | |
| 2969 Universe::heap()->total_collections() >= VerifyGCStartAt) { | |
| 2970 Universe::heap()->prepare_for_verify(); | |
| 2971 Universe::verify(); // make sure we're starting with a clean slate | |
| 2972 } | |
| 2973 | |
| 2974 // Create the VMThread | |
| 2975 { TraceTime timer("Start VMThread", TraceStartupTime); | |
| 2976 VMThread::create(); | |
| 2977 Thread* vmthread = VMThread::vm_thread(); | |
| 2978 | |
| 2979 if (!os::create_thread(vmthread, os::vm_thread)) | |
| 2980 vm_exit_during_initialization("Cannot create VM thread. Out of system resources."); | |
| 2981 | |
| 2982 // Wait for the VM thread to become ready, and VMThread::run to initialize | |
| 2983 // Monitors can have spurious returns, must always check another state flag | |
| 2984 { | |
| 2985 MutexLocker ml(Notify_lock); | |
| 2986 os::start_thread(vmthread); | |
| 2987 while (vmthread->active_handles() == NULL) { | |
| 2988 Notify_lock->wait(); | |
| 2989 } | |
| 2990 } | |
| 2991 } | |
| 2992 | |
| 2993 assert (Universe::is_fully_initialized(), "not initialized"); | |
| 2994 EXCEPTION_MARK; | |
| 2995 | |
| 2996 // At this point, the Universe is initialized, but we have not executed | |
| 2997 // any byte code. Now is a good time (the only time) to dump out the | |
| 2998 // internal state of the JVM for sharing. | |
| 2999 | |
| 3000 if (DumpSharedSpaces) { | |
| 3001 Universe::heap()->preload_and_dump(CHECK_0); | |
| 3002 ShouldNotReachHere(); | |
| 3003 } | |
| 3004 | |
| 3005 // Always call even when there are not JVMTI environments yet, since environments | |
| 3006 // may be attached late and JVMTI must track phases of VM execution | |
| 3007 JvmtiExport::enter_start_phase(); | |
| 3008 | |
| 3009 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents. | |
| 3010 JvmtiExport::post_vm_start(); | |
| 3011 | |
| 3012 { | |
| 3013 TraceTime timer("Initialize java.lang classes", TraceStartupTime); | |
| 3014 | |
| 3015 if (EagerXrunInit && Arguments::init_libraries_at_startup()) { | |
| 3016 create_vm_init_libraries(); | |
| 3017 } | |
| 3018 | |
| 3019 if (InitializeJavaLangString) { | |
| 3020 initialize_class(vmSymbolHandles::java_lang_String(), CHECK_0); | |
| 3021 } else { | |
| 3022 warning("java.lang.String not initialized"); | |
| 3023 } | |
| 3024 | |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3025 if (AggressiveOpts) { |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3026 { |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3027 // Forcibly initialize java/util/HashMap and mutate the private |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3028 // static final "frontCacheEnabled" field before we start creating instances |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3029 #ifdef ASSERT |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3030 klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3031 assert(tmp_k == NULL, "java/util/HashMap should not be loaded yet"); |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3032 #endif |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3033 klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3034 KlassHandle k = KlassHandle(THREAD, k_o); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3035 guarantee(k.not_null(), "Must find java/util/HashMap"); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3036 instanceKlassHandle ik = instanceKlassHandle(THREAD, k()); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3037 ik->initialize(CHECK_0); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3038 fieldDescriptor fd; |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3039 // Possible we might not find this field; if so, don't break |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3040 if (ik->find_local_field(vmSymbols::frontCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) { |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3041 k()->bool_field_put(fd.offset(), true); |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3042 } |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3043 } |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3044 |
|
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3045 if (UseStringCache) { |
|
669
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3046 // Forcibly initialize java/lang/StringValue and mutate the private |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3047 // static final "stringCacheEnabled" field before we start creating instances |
|
669
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3048 klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_StringValue(), Handle(), Handle(), CHECK_0); |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3049 // Possible that StringValue isn't present: if so, silently don't break |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3050 if (k_o != NULL) { |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3051 KlassHandle k = KlassHandle(THREAD, k_o); |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3052 instanceKlassHandle ik = instanceKlassHandle(THREAD, k()); |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3053 ik->initialize(CHECK_0); |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3054 fieldDescriptor fd; |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3055 // Possible we might not find this field: if so, silently don't break |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3056 if (ik->find_local_field(vmSymbols::stringCacheEnabled_name(), vmSymbols::bool_signature(), &fd)) { |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3057 k()->bool_field_put(fd.offset(), true); |
|
eca19a8425b5
6810653: Change String cache class used by Hotspot from String to StringValue
phh
parents:
441
diff
changeset
|
3058 } |
|
192
6d13fcb3663f
6714404: Add UseStringCache switch to enable String caching under AggressiveOpts
kvn
parents:
62
diff
changeset
|
3059 } |
|
18
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3060 } |
|
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3061 } |
|
c7d713375c94
6621621: HashMap front cache should be enabled only with AggressiveOpts
phh
parents:
0
diff
changeset
|
3062 |
| 0 | 3063 // Initialize java_lang.System (needed before creating the thread) |
| 3064 if (InitializeJavaLangSystem) { | |
| 3065 initialize_class(vmSymbolHandles::java_lang_System(), CHECK_0); | |
| 3066 initialize_class(vmSymbolHandles::java_lang_ThreadGroup(), CHECK_0); | |
| 3067 Handle thread_group = create_initial_thread_group(CHECK_0); | |
| 3068 Universe::set_main_thread_group(thread_group()); | |
| 3069 initialize_class(vmSymbolHandles::java_lang_Thread(), CHECK_0); | |
| 3070 oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0); | |
| 3071 main_thread->set_threadObj(thread_object); | |
| 3072 // Set thread status to running since main thread has | |
| 3073 // been started and running. | |
| 3074 java_lang_Thread::set_thread_status(thread_object, | |
| 3075 java_lang_Thread::RUNNABLE); | |
| 3076 | |
| 3077 // The VM preresolve methods to these classes. Make sure that get initialized | |
| 3078 initialize_class(vmSymbolHandles::java_lang_reflect_Method(), CHECK_0); | |
| 3079 initialize_class(vmSymbolHandles::java_lang_ref_Finalizer(), CHECK_0); | |
| 3080 // The VM creates & returns objects of this class. Make sure it's initialized. | |
| 3081 initialize_class(vmSymbolHandles::java_lang_Class(), CHECK_0); | |
| 3082 call_initializeSystemClass(CHECK_0); | |
| 3083 } else { | |
| 3084 warning("java.lang.System not initialized"); | |
| 3085 } | |
| 3086 | |
| 3087 // an instance of OutOfMemory exception has been allocated earlier | |
| 3088 if (InitializeJavaLangExceptionsErrors) { | |
| 3089 initialize_class(vmSymbolHandles::java_lang_OutOfMemoryError(), CHECK_0); | |
| 3090 initialize_class(vmSymbolHandles::java_lang_NullPointerException(), CHECK_0); | |
| 3091 initialize_class(vmSymbolHandles::java_lang_ClassCastException(), CHECK_0); | |
| 3092 initialize_class(vmSymbolHandles::java_lang_ArrayStoreException(), CHECK_0); | |
| 3093 initialize_class(vmSymbolHandles::java_lang_ArithmeticException(), CHECK_0); | |
| 3094 initialize_class(vmSymbolHandles::java_lang_StackOverflowError(), CHECK_0); | |
| 3095 initialize_class(vmSymbolHandles::java_lang_IllegalMonitorStateException(), CHECK_0); | |
| 3096 } else { | |
| 3097 warning("java.lang.OutOfMemoryError has not been initialized"); | |
| 3098 warning("java.lang.NullPointerException has not been initialized"); | |
| 3099 warning("java.lang.ClassCastException has not been initialized"); | |
| 3100 warning("java.lang.ArrayStoreException has not been initialized"); | |
| 3101 warning("java.lang.ArithmeticException has not been initialized"); | |
| 3102 warning("java.lang.StackOverflowError has not been initialized"); | |
| 3103 } | |
|
1135
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3104 |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3105 if (EnableInvokeDynamic) { |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3106 // JSR 292: An intialized java.dyn.InvokeDynamic is required in |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3107 // the compiler. |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3108 initialize_class(vmSymbolHandles::java_dyn_InvokeDynamic(), CHECK_0); |
|
e66fd840cb6b
6893081: method handle & invokedynamic code needs additional cleanup (post 6815692, 6858164)
twisti
parents:
1027
diff
changeset
|
3109 } |
| 0 | 3110 } |
| 3111 | |
| 3112 // See : bugid 4211085. | |
| 3113 // Background : the static initializer of java.lang.Compiler tries to read | |
| 3114 // property"java.compiler" and read & write property "java.vm.info". | |
| 3115 // When a security manager is installed through the command line | |
| 3116 // option "-Djava.security.manager", the above properties are not | |
| 3117 // readable and the static initializer for java.lang.Compiler fails | |
| 3118 // resulting in a NoClassDefFoundError. This can happen in any | |
| 3119 // user code which calls methods in java.lang.Compiler. | |
| 3120 // Hack : the hack is to pre-load and initialize this class, so that only | |
| 3121 // system domains are on the stack when the properties are read. | |
| 3122 // Currently even the AWT code has calls to methods in java.lang.Compiler. | |
| 3123 // On the classic VM, java.lang.Compiler is loaded very early to load the JIT. | |
| 3124 // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and | |
| 3125 // read and write"java.vm.info" in the default policy file. See bugid 4211383 | |
| 3126 // Once that is done, we should remove this hack. | |
| 3127 initialize_class(vmSymbolHandles::java_lang_Compiler(), CHECK_0); | |
| 3128 | |
| 3129 // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to | |
| 3130 // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot | |
| 3131 // compiler does not get loaded through java.lang.Compiler). "java -version" with the | |
| 3132 // hotspot vm says "nojit" all the time which is confusing. So, we reset it here. | |
| 3133 // This should also be taken out as soon as 4211383 gets fixed. | |
| 3134 reset_vm_info_property(CHECK_0); | |
| 3135 | |
| 3136 quicken_jni_functions(); | |
| 3137 | |
| 3138 // Set flag that basic initialization has completed. Used by exceptions and various | |
| 3139 // debug stuff, that does not work until all basic classes have been initialized. | |
| 3140 set_init_completed(); | |
| 3141 | |
| 3142 HS_DTRACE_PROBE(hotspot, vm__init__end); | |
| 3143 | |
| 3144 // record VM initialization completion time | |
| 3145 Management::record_vm_init_completed(); | |
| 3146 | |
| 3147 // Compute system loader. Note that this has to occur after set_init_completed, since | |
| 3148 // valid exceptions may be thrown in the process. | |
| 3149 // Note that we do not use CHECK_0 here since we are inside an EXCEPTION_MARK and | |
| 3150 // set_init_completed has just been called, causing exceptions not to be shortcut | |
| 3151 // anymore. We call vm_exit_during_initialization directly instead. | |
| 3152 SystemDictionary::compute_java_system_loader(THREAD); | |
| 3153 if (HAS_PENDING_EXCEPTION) { | |
| 3154 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); | |
| 3155 } | |
| 3156 | |
|
1115
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3157 #ifdef KERNEL |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3158 if (JDK_Version::is_gte_jdk17x_version()) { |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3159 set_jkernel_boot_classloader_hook(THREAD); |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3160 } |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3161 #endif // KERNEL |
|
4b966d9946a3
6888880: JKernel VM to inject the sun.jkernel.DownloadManager as a boot classloader hook
mchung
parents:
1027
diff
changeset
|
3162 |
| 0 | 3163 #ifndef SERIALGC |
| 3164 // Support for ConcurrentMarkSweep. This should be cleaned up | |
|
342
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3165 // and better encapsulated. The ugly nested if test would go away |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3166 // once things are properly refactored. XXX YSR |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3167 if (UseConcMarkSweepGC || UseG1GC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3168 if (UseConcMarkSweepGC) { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3169 ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3170 } else { |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3171 ConcurrentMarkThread::makeSurrogateLockerThread(THREAD); |
|
37f87013dfd8
6711316: Open source the Garbage-First garbage collector
ysr
parents:
62
diff
changeset
|
3172 } |
| 0 | 3173 if (HAS_PENDING_EXCEPTION) { |
| 3174 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION)); | |
| 3175 } | |
| 3176 } | |
| 3177 #endif // SERIALGC | |
| 3178 | |
| 3179 // Always call even when there are not JVMTI environments yet, since environments | |
| 3180 // may be attached late and JVMTI must track phases of VM execution | |
| 3181 JvmtiExport::enter_live_phase(); | |
| 3182 | |
| 3183 // Signal Dispatcher needs to be started before VMInit event is posted | |
| 3184 os::signal_init(); | |
| 3185 | |
| 3186 // Start Attach Listener if +StartAttachListener or it can't be started lazily | |
| 3187 if (!DisableAttachMechanism) { | |
| 3188 if (StartAttachListener || AttachListener::init_at_startup()) { | |
| 3189 AttachListener::init(); | |
| 3190 } | |
| 3191 } | |
| 3192 | |
| 3193 // Launch -Xrun agents | |
| 3194 // Must be done in the JVMTI live phase so that for backward compatibility the JDWP | |
| 3195 // back-end can launch with -Xdebug -Xrunjdwp. | |
| 3196 if (!EagerXrunInit && Arguments::init_libraries_at_startup()) { | |
| 3197 create_vm_init_libraries(); | |
| 3198 } | |
| 3199 | |
| 3200 // Notify JVMTI agents that VM initialization is complete - nop if no agents. | |
| 3201 JvmtiExport::post_vm_initialized(); | |
| 3202 | |
| 3203 Chunk::start_chunk_pool_cleaner_task(); | |
| 3204 | |
| 3205 // initialize compiler(s) | |
| 3206 CompileBroker::compilation_init(); | |
| 3207 | |
| 3208 Management::initialize(THREAD); | |
| 3209 if (HAS_PENDING_EXCEPTION) { | |
| 3210 // management agent fails to start possibly due to | |
| 3211 // configuration problem and is responsible for printing | |
| 3212 // stack trace if appropriate. Simply exit VM. | |
| 3213 vm_exit(1); | |
| 3214 } | |
| 3215 | |
| 3216 if (Arguments::has_profile()) FlatProfiler::engage(main_thread, true); | |
| 3217 if (Arguments::has_alloc_profile()) AllocationProfiler::engage(); | |
| 3218 if (MemProfiling) MemProfiler::engage(); | |
| 3219 StatSampler::engage(); | |
| 3220 if (CheckJNICalls) JniPeriodicChecker::engage(); | |
| 3221 | |
| 3222 BiasedLocking::init(); | |
| 3223 | |
| 3224 | |
| 3225 // Start up the WatcherThread if there are any periodic tasks | |
| 3226 // NOTE: All PeriodicTasks should be registered by now. If they | |
| 3227 // aren't, late joiners might appear to start slowly (we might | |
| 3228 // take a while to process their first tick). | |
| 3229 if (PeriodicTask::num_tasks() > 0) { | |
| 3230 WatcherThread::start(); | |
| 3231 } | |
| 3232 | |
| 3233 create_vm_timer.end(); | |
| 3234 return JNI_OK; | |
| 3235 } | |
| 3236 | |
| 3237 // type for the Agent_OnLoad and JVM_OnLoad entry points | |
| 3238 extern "C" { | |
| 3239 typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *); | |
| 3240 } | |
| 3241 // Find a command line agent library and return its entry point for | |
| 3242 // -agentlib: -agentpath: -Xrun | |
| 3243 // num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array. | |
| 3244 static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) { | |
| 3245 OnLoadEntry_t on_load_entry = NULL; | |
| 3246 void *library = agent->os_lib(); // check if we have looked it up before | |
| 3247 | |
| 3248 if (library == NULL) { | |
| 3249 char buffer[JVM_MAXPATHLEN]; | |
| 3250 char ebuf[1024]; | |
| 3251 const char *name = agent->name(); | |
| 3252 | |
| 3253 if (agent->is_absolute_path()) { | |
| 3254 library = hpi::dll_load(name, ebuf, sizeof ebuf); | |
| 3255 if (library == NULL) { | |
| 3256 // If we can't find the agent, exit. | |
| 3257 vm_exit_during_initialization("Could not find agent library in absolute path", name); | |
| 3258 } | |
| 3259 } else { | |
| 3260 // Try to load the agent from the standard dll directory | |
| 3261 hpi::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), name); | |
| 3262 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
| 3263 #ifdef KERNEL | |
| 3264 // Download instrument dll | |
| 3265 if (library == NULL && strcmp(name, "instrument") == 0) { | |
| 3266 char *props = Arguments::get_kernel_properties(); | |
| 3267 char *home = Arguments::get_java_home(); | |
| 3268 const char *fmt = "%s/bin/java %s -Dkernel.background.download=false" | |
| 3269 " sun.jkernel.DownloadManager -download client_jvm"; | |
| 3270 int length = strlen(props) + strlen(home) + strlen(fmt) + 1; | |
| 3271 char *cmd = AllocateHeap(length); | |
| 3272 jio_snprintf(cmd, length, fmt, home, props); | |
| 3273 int status = os::fork_and_exec(cmd); | |
| 3274 FreeHeap(props); | |
| 3275 FreeHeap(cmd); | |
| 3276 if (status == -1) { | |
| 3277 warning(cmd); | |
| 3278 vm_exit_during_initialization("fork_and_exec failed: %s", | |
| 3279 strerror(errno)); | |
| 3280 } | |
| 3281 // when this comes back the instrument.dll should be where it belongs. | |
| 3282 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
| 3283 } | |
| 3284 #endif // KERNEL | |
| 3285 if (library == NULL) { // Try the local directory | |
| 3286 char ns[1] = {0}; | |
| 3287 hpi::dll_build_name(buffer, sizeof(buffer), ns, name); | |
| 3288 library = hpi::dll_load(buffer, ebuf, sizeof ebuf); | |
| 3289 if (library == NULL) { | |
| 3290 // If we can't find the agent, exit. | |
| 3291 vm_exit_during_initialization("Could not find agent library on the library path or in the local directory", name); | |
| 3292 } | |
| 3293 } | |
| 3294 } | |
| 3295 agent->set_os_lib(library); | |
| 3296 } | |
| 3297 | |
| 3298 // Find the OnLoad function. | |
| 3299 for (size_t symbol_index = 0; symbol_index < num_symbol_entries; symbol_index++) { | |
| 3300 on_load_entry = CAST_TO_FN_PTR(OnLoadEntry_t, hpi::dll_lookup(library, on_load_symbols[symbol_index])); | |
| 3301 if (on_load_entry != NULL) break; | |
| 3302 } | |
| 3303 return on_load_entry; | |
| 3304 } | |
| 3305 | |
| 3306 // Find the JVM_OnLoad entry point | |
| 3307 static OnLoadEntry_t lookup_jvm_on_load(AgentLibrary* agent) { | |
| 3308 const char *on_load_symbols[] = JVM_ONLOAD_SYMBOLS; | |
| 3309 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); | |
| 3310 } | |
| 3311 | |
| 3312 // Find the Agent_OnLoad entry point | |
| 3313 static OnLoadEntry_t lookup_agent_on_load(AgentLibrary* agent) { | |
| 3314 const char *on_load_symbols[] = AGENT_ONLOAD_SYMBOLS; | |
| 3315 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*)); | |
| 3316 } | |
| 3317 | |
| 3318 // For backwards compatibility with -Xrun | |
| 3319 // Convert libraries with no JVM_OnLoad, but which have Agent_OnLoad to be | |
| 3320 // treated like -agentpath: | |
| 3321 // Must be called before agent libraries are created | |
| 3322 void Threads::convert_vm_init_libraries_to_agents() { | |
| 3323 AgentLibrary* agent; | |
| 3324 AgentLibrary* next; | |
| 3325 | |
| 3326 for (agent = Arguments::libraries(); agent != NULL; agent = next) { | |
| 3327 next = agent->next(); // cache the next agent now as this agent may get moved off this list | |
| 3328 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); | |
| 3329 | |
| 3330 // If there is an JVM_OnLoad function it will get called later, | |
| 3331 // otherwise see if there is an Agent_OnLoad | |
| 3332 if (on_load_entry == NULL) { | |
| 3333 on_load_entry = lookup_agent_on_load(agent); | |
| 3334 if (on_load_entry != NULL) { | |
| 3335 // switch it to the agent list -- so that Agent_OnLoad will be called, | |
| 3336 // JVM_OnLoad won't be attempted and Agent_OnUnload will | |
| 3337 Arguments::convert_library_to_agent(agent); | |
| 3338 } else { | |
| 3339 vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name()); | |
| 3340 } | |
| 3341 } | |
| 3342 } | |
| 3343 } | |
| 3344 | |
| 3345 // Create agents for -agentlib: -agentpath: and converted -Xrun | |
| 3346 // Invokes Agent_OnLoad | |
| 3347 // Called very early -- before JavaThreads exist | |
| 3348 void Threads::create_vm_init_agents() { | |
| 3349 extern struct JavaVM_ main_vm; | |
| 3350 AgentLibrary* agent; | |
| 3351 | |
| 3352 JvmtiExport::enter_onload_phase(); | |
| 3353 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) { | |
| 3354 OnLoadEntry_t on_load_entry = lookup_agent_on_load(agent); | |
| 3355 | |
| 3356 if (on_load_entry != NULL) { | |
| 3357 // Invoke the Agent_OnLoad function | |
| 3358 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); | |
| 3359 if (err != JNI_OK) { | |
| 3360 vm_exit_during_initialization("agent library failed to init", agent->name()); | |
| 3361 } | |
| 3362 } else { | |
| 3363 vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name()); | |
| 3364 } | |
| 3365 } | |
| 3366 JvmtiExport::enter_primordial_phase(); | |
| 3367 } | |
| 3368 | |
| 3369 extern "C" { | |
| 3370 typedef void (JNICALL *Agent_OnUnload_t)(JavaVM *); | |
| 3371 } | |
| 3372 | |
| 3373 void Threads::shutdown_vm_agents() { | |
| 3374 // Send any Agent_OnUnload notifications | |
| 3375 const char *on_unload_symbols[] = AGENT_ONUNLOAD_SYMBOLS; | |
| 3376 extern struct JavaVM_ main_vm; | |
| 3377 for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) { | |
| 3378 | |
| 3379 // Find the Agent_OnUnload function. | |
| 3380 for (uint symbol_index = 0; symbol_index < ARRAY_SIZE(on_unload_symbols); symbol_index++) { | |
| 3381 Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t, | |
| 3382 hpi::dll_lookup(agent->os_lib(), on_unload_symbols[symbol_index])); | |
| 3383 | |
| 3384 // Invoke the Agent_OnUnload function | |
| 3385 if (unload_entry != NULL) { | |
| 3386 JavaThread* thread = JavaThread::current(); | |
| 3387 ThreadToNativeFromVM ttn(thread); | |
| 3388 HandleMark hm(thread); | |
| 3389 (*unload_entry)(&main_vm); | |
| 3390 break; | |
| 3391 } | |
| 3392 } | |
| 3393 } | |
| 3394 } | |
| 3395 | |
| 3396 // Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries | |
| 3397 // Invokes JVM_OnLoad | |
| 3398 void Threads::create_vm_init_libraries() { | |
| 3399 extern struct JavaVM_ main_vm; | |
| 3400 AgentLibrary* agent; | |
| 3401 | |
| 3402 for (agent = Arguments::libraries(); agent != NULL; agent = agent->next()) { | |
| 3403 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent); | |
| 3404 | |
| 3405 if (on_load_entry != NULL) { | |
| 3406 // Invoke the JVM_OnLoad function | |
| 3407 JavaThread* thread = JavaThread::current(); | |
| 3408 ThreadToNativeFromVM ttn(thread); | |
| 3409 HandleMark hm(thread); | |
| 3410 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL); | |
| 3411 if (err != JNI_OK) { | |
| 3412 vm_exit_during_initialization("-Xrun library failed to init", agent->name()); | |
| 3413 } | |
| 3414 } else { | |
| 3415 vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name()); | |
| 3416 } | |
| 3417 } | |
| 3418 } | |
| 3419 | |
| 3420 // Last thread running calls java.lang.Shutdown.shutdown() | |
| 3421 void JavaThread::invoke_shutdown_hooks() { | |
| 3422 HandleMark hm(this); | |
| 3423 | |
| 3424 // We could get here with a pending exception, if so clear it now. | |
| 3425 if (this->has_pending_exception()) { | |
| 3426 this->clear_pending_exception(); | |
| 3427 } | |
| 3428 | |
| 3429 EXCEPTION_MARK; | |
| 3430 klassOop k = | |
| 3431 SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_Shutdown(), | |
| 3432 THREAD); | |
| 3433 if (k != NULL) { | |
| 3434 // SystemDictionary::resolve_or_null will return null if there was | |
| 3435 // an exception. If we cannot load the Shutdown class, just don't | |
| 3436 // call Shutdown.shutdown() at all. This will mean the shutdown hooks | |
| 3437 // and finalizers (if runFinalizersOnExit is set) won't be run. | |
| 3438 // Note that if a shutdown hook was registered or runFinalizersOnExit | |
| 3439 // was called, the Shutdown class would have already been loaded | |
| 3440 // (Runtime.addShutdownHook and runFinalizersOnExit will load it). | |
| 3441 instanceKlassHandle shutdown_klass (THREAD, k); | |
| 3442 JavaValue result(T_VOID); | |
| 3443 JavaCalls::call_static(&result, | |
| 3444 shutdown_klass, | |
| 3445 vmSymbolHandles::shutdown_method_name(), | |
| 3446 vmSymbolHandles::void_method_signature(), | |
| 3447 THREAD); | |
| 3448 } | |
| 3449 CLEAR_PENDING_EXCEPTION; | |
| 3450 } | |
| 3451 | |
| 3452 // Threads::destroy_vm() is normally called from jni_DestroyJavaVM() when | |
| 3453 // the program falls off the end of main(). Another VM exit path is through | |
| 3454 // vm_exit() when the program calls System.exit() to return a value or when | |
| 3455 // there is a serious error in VM. The two shutdown paths are not exactly | |
| 3456 // the same, but they share Shutdown.shutdown() at Java level and before_exit() | |
| 3457 // and VM_Exit op at VM level. | |
| 3458 // | |
| 3459 // Shutdown sequence: | |
| 3460 // + Wait until we are the last non-daemon thread to execute | |
| 3461 // <-- every thing is still working at this moment --> | |
| 3462 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level | |
| 3463 // shutdown hooks, run finalizers if finalization-on-exit | |
| 3464 // + Call before_exit(), prepare for VM exit | |
| 3465 // > run VM level shutdown hooks (they are registered through JVM_OnExit(), | |
| 3466 // currently the only user of this mechanism is File.deleteOnExit()) | |
| 3467 // > stop flat profiler, StatSampler, watcher thread, CMS threads, | |
| 3468 // post thread end and vm death events to JVMTI, | |
| 3469 // stop signal thread | |
| 3470 // + Call JavaThread::exit(), it will: | |
| 3471 // > release JNI handle blocks, remove stack guard pages | |
| 3472 // > remove this thread from Threads list | |
| 3473 // <-- no more Java code from this thread after this point --> | |
| 3474 // + Stop VM thread, it will bring the remaining VM to a safepoint and stop | |
| 3475 // the compiler threads at safepoint | |
| 3476 // <-- do not use anything that could get blocked by Safepoint --> | |
| 3477 // + Disable tracing at JNI/JVM barriers | |
| 3478 // + Set _vm_exited flag for threads that are still running native code | |
| 3479 // + Delete this thread | |
| 3480 // + Call exit_globals() | |
| 3481 // > deletes tty | |
| 3482 // > deletes PerfMemory resources | |
| 3483 // + Return to caller | |
| 3484 | |
| 3485 bool Threads::destroy_vm() { | |
| 3486 JavaThread* thread = JavaThread::current(); | |
| 3487 | |
| 3488 // Wait until we are the last non-daemon thread to execute | |
| 3489 { MutexLocker nu(Threads_lock); | |
| 3490 while (Threads::number_of_non_daemon_threads() > 1 ) | |
| 3491 // This wait should make safepoint checks, wait without a timeout, | |
| 3492 // and wait as a suspend-equivalent condition. | |
| 3493 // | |
| 3494 // Note: If the FlatProfiler is running and this thread is waiting | |
| 3495 // for another non-daemon thread to finish, then the FlatProfiler | |
| 3496 // is waiting for the external suspend request on this thread to | |
| 3497 // complete. wait_for_ext_suspend_completion() will eventually | |
| 3498 // timeout, but that takes time. Making this wait a suspend- | |
| 3499 // equivalent condition solves that timeout problem. | |
| 3500 // | |
| 3501 Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0, | |
| 3502 Mutex::_as_suspend_equivalent_flag); | |
| 3503 } | |
| 3504 | |
| 3505 // Hang forever on exit if we are reporting an error. | |
| 3506 if (ShowMessageBoxOnError && is_error_reported()) { | |
| 3507 os::infinite_sleep(); | |
| 3508 } | |
| 3509 | |
| 3510 if (JDK_Version::is_jdk12x_version()) { | |
| 3511 // We are the last thread running, so check if finalizers should be run. | |
| 3512 // For 1.3 or later this is done in thread->invoke_shutdown_hooks() | |
| 3513 HandleMark rm(thread); | |
| 3514 Universe::run_finalizers_on_exit(); | |
| 3515 } else { | |
| 3516 // run Java level shutdown hooks | |
| 3517 thread->invoke_shutdown_hooks(); | |
| 3518 } | |
| 3519 | |
| 3520 before_exit(thread); | |
| 3521 | |
| 3522 thread->exit(true); | |
| 3523 | |
| 3524 // Stop VM thread. | |
| 3525 { | |
| 3526 // 4945125 The vm thread comes to a safepoint during exit. | |
| 3527 // GC vm_operations can get caught at the safepoint, and the | |
| 3528 // heap is unparseable if they are caught. Grab the Heap_lock | |
| 3529 // to prevent this. The GC vm_operations will not be able to | |
| 3530 // queue until after the vm thread is dead. | |
| 3531 MutexLocker ml(Heap_lock); | |
| 3532 | |
| 3533 VMThread::wait_for_vm_thread_exit(); | |
| 3534 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint"); | |
| 3535 VMThread::destroy(); | |
| 3536 } | |
| 3537 | |
| 3538 // clean up ideal graph printers | |
| 3539 #if defined(COMPILER2) && !defined(PRODUCT) | |
| 3540 IdealGraphPrinter::clean_up(); | |
| 3541 #endif | |
| 3542 | |
| 3543 // Now, all Java threads are gone except daemon threads. Daemon threads | |
| 3544 // running Java code or in VM are stopped by the Safepoint. However, | |
| 3545 // daemon threads executing native code are still running. But they | |
| 3546 // will be stopped at native=>Java/VM barriers. Note that we can't | |
| 3547 // simply kill or suspend them, as it is inherently deadlock-prone. | |
| 3548 | |
| 3549 #ifndef PRODUCT | |
| 3550 // disable function tracing at JNI/JVM barriers | |
| 3551 TraceHPI = false; | |
| 3552 TraceJNICalls = false; | |
| 3553 TraceJVMCalls = false; | |
| 3554 TraceRuntimeCalls = false; | |
| 3555 #endif | |
| 3556 | |
| 3557 VM_Exit::set_vm_exited(); | |
| 3558 | |
| 3559 notify_vm_shutdown(); | |
| 3560 | |
| 3561 delete thread; | |
| 3562 | |
| 3563 // exit_globals() will delete tty | |
| 3564 exit_globals(); | |
| 3565 | |
| 3566 return true; | |
| 3567 } | |
| 3568 | |
| 3569 | |
| 3570 jboolean Threads::is_supported_jni_version_including_1_1(jint version) { | |
| 3571 if (version == JNI_VERSION_1_1) return JNI_TRUE; | |
| 3572 return is_supported_jni_version(version); | |
| 3573 } | |
| 3574 | |
| 3575 | |
| 3576 jboolean Threads::is_supported_jni_version(jint version) { | |
| 3577 if (version == JNI_VERSION_1_2) return JNI_TRUE; | |
| 3578 if (version == JNI_VERSION_1_4) return JNI_TRUE; | |
| 3579 if (version == JNI_VERSION_1_6) return JNI_TRUE; | |
| 3580 return JNI_FALSE; | |
| 3581 } | |
| 3582 | |
| 3583 | |
| 3584 void Threads::add(JavaThread* p, bool force_daemon) { | |
| 3585 // The threads lock must be owned at this point | |
| 3586 assert_locked_or_safepoint(Threads_lock); | |
| 3587 p->set_next(_thread_list); | |
| 3588 _thread_list = p; | |
| 3589 _number_of_threads++; | |
| 3590 oop threadObj = p->threadObj(); | |
| 3591 bool daemon = true; | |
| 3592 // Bootstrapping problem: threadObj can be null for initial | |
| 3593 // JavaThread (or for threads attached via JNI) | |
| 3594 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) { | |
| 3595 _number_of_non_daemon_threads++; | |
| 3596 daemon = false; | |
| 3597 } | |
| 3598 | |
| 3599 ThreadService::add_thread(p, daemon); | |
| 3600 | |
| 3601 // Possible GC point. | |
| 3602 Events::log("Thread added: " INTPTR_FORMAT, p); | |
| 3603 } | |
| 3604 | |
| 3605 void Threads::remove(JavaThread* p) { | |
| 3606 // Extra scope needed for Thread_lock, so we can check | |
| 3607 // that we do not remove thread without safepoint code notice | |
| 3608 { MutexLocker ml(Threads_lock); | |
| 3609 | |
| 3610 assert(includes(p), "p must be present"); | |
| 3611 | |
| 3612 JavaThread* current = _thread_list; | |
| 3613 JavaThread* prev = NULL; | |
| 3614 | |
| 3615 while (current != p) { | |
| 3616 prev = current; | |
| 3617 current = current->next(); | |
| 3618 } | |
| 3619 | |
| 3620 if (prev) { | |
| 3621 prev->set_next(current->next()); | |
| 3622 } else { | |
| 3623 _thread_list = p->next(); | |
| 3624 } | |
| 3625 _number_of_threads--; | |
| 3626 oop threadObj = p->threadObj(); | |
| 3627 bool daemon = true; | |
| 3628 if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) { | |
| 3629 _number_of_non_daemon_threads--; | |
| 3630 daemon = false; | |
| 3631 | |
| 3632 // Only one thread left, do a notify on the Threads_lock so a thread waiting | |
| 3633 // on destroy_vm will wake up. | |
| 3634 if (number_of_non_daemon_threads() == 1) | |
| 3635 Threads_lock->notify_all(); | |
| 3636 } | |
| 3637 ThreadService::remove_thread(p, daemon); | |
| 3638 | |
| 3639 // Make sure that safepoint code disregard this thread. This is needed since | |
| 3640 // the thread might mess around with locks after this point. This can cause it | |
| 3641 // to do callbacks into the safepoint code. However, the safepoint code is not aware | |
| 3642 // of this thread since it is removed from the queue. | |
| 3643 p->set_terminated_value(); | |
| 3644 } // unlock Threads_lock | |
| 3645 | |
| 3646 // Since Events::log uses a lock, we grab it outside the Threads_lock | |
| 3647 Events::log("Thread exited: " INTPTR_FORMAT, p); | |
| 3648 } | |
| 3649 | |
| 3650 // Threads_lock must be held when this is called (or must be called during a safepoint) | |
| 3651 bool Threads::includes(JavaThread* p) { | |
| 3652 assert(Threads_lock->is_locked(), "sanity check"); | |
| 3653 ALL_JAVA_THREADS(q) { | |
| 3654 if (q == p ) { | |
| 3655 return true; | |
| 3656 } | |
| 3657 } | |
| 3658 return false; | |
| 3659 } | |
| 3660 | |
| 3661 // Operations on the Threads list for GC. These are not explicitly locked, | |
| 3662 // but the garbage collector must provide a safe context for them to run. | |
| 3663 // In particular, these things should never be called when the Threads_lock | |
| 3664 // is held by some other thread. (Note: the Safepoint abstraction also | |
| 3665 // uses the Threads_lock to gurantee this property. It also makes sure that | |
| 3666 // all threads gets blocked when exiting or starting). | |
| 3667 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3668 void Threads::oops_do(OopClosure* f, CodeBlobClosure* cf) { |
| 0 | 3669 ALL_JAVA_THREADS(p) { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3670 p->oops_do(f, cf); |
| 0 | 3671 } |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3672 VMThread::vm_thread()->oops_do(f, cf); |
| 0 | 3673 } |
| 3674 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3675 void Threads::possibly_parallel_oops_do(OopClosure* f, CodeBlobClosure* cf) { |
| 0 | 3676 // Introduce a mechanism allowing parallel threads to claim threads as |
| 3677 // root groups. Overhead should be small enough to use all the time, | |
| 3678 // even in sequential code. | |
| 3679 SharedHeap* sh = SharedHeap::heap(); | |
| 3680 bool is_par = (sh->n_par_threads() > 0); | |
| 3681 int cp = SharedHeap::heap()->strong_roots_parity(); | |
| 3682 ALL_JAVA_THREADS(p) { | |
| 3683 if (p->claim_oops_do(is_par, cp)) { | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3684 p->oops_do(f, cf); |
| 0 | 3685 } |
| 3686 } | |
| 3687 VMThread* vmt = VMThread::vm_thread(); | |
| 3688 if (vmt->claim_oops_do(is_par, cp)) | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3689 vmt->oops_do(f, cf); |
| 0 | 3690 } |
| 3691 | |
| 3692 #ifndef SERIALGC | |
| 3693 // Used by ParallelScavenge | |
| 3694 void Threads::create_thread_roots_tasks(GCTaskQueue* q) { | |
| 3695 ALL_JAVA_THREADS(p) { | |
| 3696 q->enqueue(new ThreadRootsTask(p)); | |
| 3697 } | |
| 3698 q->enqueue(new ThreadRootsTask(VMThread::vm_thread())); | |
| 3699 } | |
| 3700 | |
| 3701 // Used by Parallel Old | |
| 3702 void Threads::create_thread_roots_marking_tasks(GCTaskQueue* q) { | |
| 3703 ALL_JAVA_THREADS(p) { | |
| 3704 q->enqueue(new ThreadRootsMarkingTask(p)); | |
| 3705 } | |
| 3706 q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread())); | |
| 3707 } | |
| 3708 #endif // SERIALGC | |
| 3709 | |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3710 void Threads::nmethods_do(CodeBlobClosure* cf) { |
| 0 | 3711 ALL_JAVA_THREADS(p) { |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3712 p->nmethods_do(cf); |
| 0 | 3713 } |
|
989
148e5441d916
6863023: need non-perm oops in code cache for JSR 292
jrose
parents:
844
diff
changeset
|
3714 VMThread::vm_thread()->nmethods_do(cf); |
| 0 | 3715 } |
| 3716 | |
| 3717 void Threads::gc_epilogue() { | |
| 3718 ALL_JAVA_THREADS(p) { | |
| 3719 p->gc_epilogue(); | |
| 3720 } | |
| 3721 } | |
| 3722 | |
| 3723 void Threads::gc_prologue() { | |
| 3724 ALL_JAVA_THREADS(p) { | |
| 3725 p->gc_prologue(); | |
| 3726 } | |
| 3727 } | |
| 3728 | |
| 3729 void Threads::deoptimized_wrt_marked_nmethods() { | |
| 3730 ALL_JAVA_THREADS(p) { | |
| 3731 p->deoptimized_wrt_marked_nmethods(); | |
| 3732 } | |
| 3733 } | |
| 3734 | |
| 3735 | |
| 3736 // Get count Java threads that are waiting to enter the specified monitor. | |
| 3737 GrowableArray<JavaThread*>* Threads::get_pending_threads(int count, | |
| 3738 address monitor, bool doLock) { | |
| 3739 assert(doLock || SafepointSynchronize::is_at_safepoint(), | |
| 3740 "must grab Threads_lock or be at safepoint"); | |
| 3741 GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count); | |
| 3742 | |
| 3743 int i = 0; | |
| 3744 { | |
| 3745 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
| 3746 ALL_JAVA_THREADS(p) { | |
|
1410
b30a2cd5e3a2
Added methods to c1x_VMExits.cpp
Thomas Wuerthinger <thomas.wuerthinger@gmail.com>
parents:
1320
diff
changeset
|
3747 |
|
b30a2cd5e3a2
Added methods to c1x_VMExits.cpp
Thomas Wuerthinger <thomas.wuerthinger@gmail.com>
parents:
1320
diff
changeset
|
3748 // (tw) May we do this? |
|
b30a2cd5e3a2
Added methods to c1x_VMExits.cpp
Thomas Wuerthinger <thomas.wuerthinger@gmail.com>
parents:
1320
diff
changeset
|
3749 //if (p->is_Compiler_thread()) continue; |
| 0 | 3750 |
| 3751 address pending = (address)p->current_pending_monitor(); | |
| 3752 if (pending == monitor) { // found a match | |
| 3753 if (i < count) result->append(p); // save the first count matches | |
| 3754 i++; | |
| 3755 } | |
| 3756 } | |
| 3757 } | |
| 3758 return result; | |
| 3759 } | |
| 3760 | |
| 3761 | |
| 3762 JavaThread *Threads::owning_thread_from_monitor_owner(address owner, bool doLock) { | |
| 3763 assert(doLock || | |
| 3764 Threads_lock->owned_by_self() || | |
| 3765 SafepointSynchronize::is_at_safepoint(), | |
| 3766 "must grab Threads_lock or be at safepoint"); | |
| 3767 | |
| 3768 // NULL owner means not locked so we can skip the search | |
| 3769 if (owner == NULL) return NULL; | |
| 3770 | |
| 3771 { | |
| 3772 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
| 3773 ALL_JAVA_THREADS(p) { | |
| 3774 // first, see if owner is the address of a Java thread | |
| 3775 if (owner == (address)p) return p; | |
| 3776 } | |
| 3777 } | |
| 3778 assert(UseHeavyMonitors == false, "Did not find owning Java thread with UseHeavyMonitors enabled"); | |
| 3779 if (UseHeavyMonitors) return NULL; | |
| 3780 | |
| 3781 // | |
| 3782 // If we didn't find a matching Java thread and we didn't force use of | |
| 3783 // heavyweight monitors, then the owner is the stack address of the | |
| 3784 // Lock Word in the owning Java thread's stack. | |
| 3785 // | |
| 3786 JavaThread* the_owner = NULL; | |
| 3787 { | |
| 3788 MutexLockerEx ml(doLock ? Threads_lock : NULL); | |
| 3789 ALL_JAVA_THREADS(q) { | |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
3790 if (q->is_lock_owned(owner)) { |
| 0 | 3791 the_owner = q; |
|
702
b9fba36710f2
6699669: Hotspot server leaves synchronized block with monitor in bad state
xlu
parents:
669
diff
changeset
|
3792 break; |
| 0 | 3793 } |
| 3794 } | |
| 3795 } | |
| 3796 assert(the_owner != NULL, "Did not find owning Java thread for lock word address"); | |
| 3797 return the_owner; | |
| 3798 } | |
| 3799 | |
| 3800 // Threads::print_on() is called at safepoint by VM_PrintThreads operation. | |
| 3801 void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) { | |
| 3802 char buf[32]; | |
| 3803 st->print_cr(os::local_time_string(buf, sizeof(buf))); | |
| 3804 | |
| 3805 st->print_cr("Full thread dump %s (%s %s):", | |
| 3806 Abstract_VM_Version::vm_name(), | |
| 3807 Abstract_VM_Version::vm_release(), | |
| 3808 Abstract_VM_Version::vm_info_string() | |
| 3809 ); | |
| 3810 st->cr(); | |
| 3811 | |
| 3812 #ifndef SERIALGC | |
| 3813 // Dump concurrent locks | |
| 3814 ConcurrentLocksDump concurrent_locks; | |
| 3815 if (print_concurrent_locks) { | |
| 3816 concurrent_locks.dump_at_safepoint(); | |
| 3817 } | |
| 3818 #endif // SERIALGC | |
| 3819 | |
| 3820 ALL_JAVA_THREADS(p) { | |
| 3821 ResourceMark rm; | |
| 3822 p->print_on(st); | |
| 3823 if (print_stacks) { | |
| 3824 if (internal_format) { | |
| 3825 p->trace_stack(); | |
| 3826 } else { | |
| 3827 p->print_stack_on(st); | |
| 3828 } | |
| 3829 } | |
| 3830 st->cr(); | |
| 3831 #ifndef SERIALGC | |
| 3832 if (print_concurrent_locks) { | |
| 3833 concurrent_locks.print_locks_on(p, st); | |
| 3834 } | |
| 3835 #endif // SERIALGC | |
| 3836 } | |
| 3837 | |
| 3838 VMThread::vm_thread()->print_on(st); | |
| 3839 st->cr(); | |
| 3840 Universe::heap()->print_gc_threads_on(st); | |
| 3841 WatcherThread* wt = WatcherThread::watcher_thread(); | |
| 3842 if (wt != NULL) wt->print_on(st); | |
| 3843 st->cr(); | |
| 3844 CompileBroker::print_compiler_threads_on(st); | |
| 3845 st->flush(); | |
| 3846 } | |
| 3847 | |
| 3848 // Threads::print_on_error() is called by fatal error handler. It's possible | |
| 3849 // that VM is not at safepoint and/or current thread is inside signal handler. | |
| 3850 // Don't print stack trace, as the stack may not be walkable. Don't allocate | |
| 3851 // memory (even in resource area), it might deadlock the error handler. | |
| 3852 void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) { | |
| 3853 bool found_current = false; | |
| 3854 st->print_cr("Java Threads: ( => current thread )"); | |
| 3855 ALL_JAVA_THREADS(thread) { | |
| 3856 bool is_current = (current == thread); | |
| 3857 found_current = found_current || is_current; | |
| 3858 | |
| 3859 st->print("%s", is_current ? "=>" : " "); | |
| 3860 | |
| 3861 st->print(PTR_FORMAT, thread); | |
| 3862 st->print(" "); | |
| 3863 thread->print_on_error(st, buf, buflen); | |
| 3864 st->cr(); | |
| 3865 } | |
| 3866 st->cr(); | |
| 3867 | |
| 3868 st->print_cr("Other Threads:"); | |
| 3869 if (VMThread::vm_thread()) { | |
| 3870 bool is_current = (current == VMThread::vm_thread()); | |
| 3871 found_current = found_current || is_current; | |
| 3872 st->print("%s", current == VMThread::vm_thread() ? "=>" : " "); | |
| 3873 | |
| 3874 st->print(PTR_FORMAT, VMThread::vm_thread()); | |
| 3875 st->print(" "); | |
| 3876 VMThread::vm_thread()->print_on_error(st, buf, buflen); | |
| 3877 st->cr(); | |
| 3878 } | |
| 3879 WatcherThread* wt = WatcherThread::watcher_thread(); | |
| 3880 if (wt != NULL) { | |
| 3881 bool is_current = (current == wt); | |
| 3882 found_current = found_current || is_current; | |
| 3883 st->print("%s", is_current ? "=>" : " "); | |
| 3884 | |
| 3885 st->print(PTR_FORMAT, wt); | |
| 3886 st->print(" "); | |
| 3887 wt->print_on_error(st, buf, buflen); | |
| 3888 st->cr(); | |
| 3889 } | |
| 3890 if (!found_current) { | |
| 3891 st->cr(); | |
| 3892 st->print("=>" PTR_FORMAT " (exited) ", current); | |
| 3893 current->print_on_error(st, buf, buflen); | |
| 3894 st->cr(); | |
| 3895 } | |
| 3896 } | |
| 3897 | |
| 3898 | |
| 3899 // Lifecycle management for TSM ParkEvents. | |
| 3900 // ParkEvents are type-stable (TSM). | |
| 3901 // In our particular implementation they happen to be immortal. | |
| 3902 // | |
| 3903 // We manage concurrency on the FreeList with a CAS-based | |
| 3904 // detach-modify-reattach idiom that avoids the ABA problems | |
| 3905 // that would otherwise be present in a simple CAS-based | |
| 3906 // push-pop implementation. (push-one and pop-all) | |
| 3907 // | |
| 3908 // Caveat: Allocate() and Release() may be called from threads | |
| 3909 // other than the thread associated with the Event! | |
| 3910 // If we need to call Allocate() when running as the thread in | |
| 3911 // question then look for the PD calls to initialize native TLS. | |
| 3912 // Native TLS (Win32/Linux/Solaris) can only be initialized or | |
| 3913 // accessed by the associated thread. | |
| 3914 // See also pd_initialize(). | |
| 3915 // | |
| 3916 // Note that we could defer associating a ParkEvent with a thread | |
| 3917 // until the 1st time the thread calls park(). unpark() calls to | |
| 3918 // an unprovisioned thread would be ignored. The first park() call | |
| 3919 // for a thread would allocate and associate a ParkEvent and return | |
| 3920 // immediately. | |
| 3921 | |
| 3922 volatile int ParkEvent::ListLock = 0 ; | |
| 3923 ParkEvent * volatile ParkEvent::FreeList = NULL ; | |
| 3924 | |
| 3925 ParkEvent * ParkEvent::Allocate (Thread * t) { | |
| 3926 // In rare cases -- JVM_RawMonitor* operations -- we can find t == null. | |
| 3927 ParkEvent * ev ; | |
| 3928 | |
| 3929 // Start by trying to recycle an existing but unassociated | |
| 3930 // ParkEvent from the global free list. | |
| 3931 for (;;) { | |
| 3932 ev = FreeList ; | |
| 3933 if (ev == NULL) break ; | |
| 3934 // 1: Detach - sequester or privatize the list | |
| 3935 // Tantamount to ev = Swap (&FreeList, NULL) | |
| 3936 if (Atomic::cmpxchg_ptr (NULL, &FreeList, ev) != ev) { | |
| 3937 continue ; | |
| 3938 } | |
| 3939 | |
| 3940 // We've detached the list. The list in-hand is now | |
| 3941 // local to this thread. This thread can operate on the | |
| 3942 // list without risk of interference from other threads. | |
| 3943 // 2: Extract -- pop the 1st element from the list. | |
| 3944 ParkEvent * List = ev->FreeNext ; | |
| 3945 if (List == NULL) break ; | |
| 3946 for (;;) { | |
| 3947 // 3: Try to reattach the residual list | |
| 3948 guarantee (List != NULL, "invariant") ; | |
| 3949 ParkEvent * Arv = (ParkEvent *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ; | |
| 3950 if (Arv == NULL) break ; | |
| 3951 | |
| 3952 // New nodes arrived. Try to detach the recent arrivals. | |
| 3953 if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) { | |
| 3954 continue ; | |
| 3955 } | |
| 3956 guarantee (Arv != NULL, "invariant") ; | |
| 3957 // 4: Merge Arv into List | |
| 3958 ParkEvent * Tail = List ; | |
| 3959 while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ; | |
| 3960 Tail->FreeNext = Arv ; | |
| 3961 } | |
| 3962 break ; | |
| 3963 } | |
| 3964 | |
| 3965 if (ev != NULL) { | |
| 3966 guarantee (ev->AssociatedWith == NULL, "invariant") ; | |
| 3967 } else { | |
| 3968 // Do this the hard way -- materialize a new ParkEvent. | |
| 3969 // In rare cases an allocating thread might detach a long list -- | |
| 3970 // installing null into FreeList -- and then stall or be obstructed. | |
| 3971 // A 2nd thread calling Allocate() would see FreeList == null. | |
| 3972 // The list held privately by the 1st thread is unavailable to the 2nd thread. | |
| 3973 // In that case the 2nd thread would have to materialize a new ParkEvent, | |
| 3974 // even though free ParkEvents existed in the system. In this case we end up | |
| 3975 // with more ParkEvents in circulation than we need, but the race is | |
| 3976 // rare and the outcome is benign. Ideally, the # of extant ParkEvents | |
| 3977 // is equal to the maximum # of threads that existed at any one time. | |
| 3978 // Because of the race mentioned above, segments of the freelist | |
| 3979 // can be transiently inaccessible. At worst we may end up with the | |
| 3980 // # of ParkEvents in circulation slightly above the ideal. | |
| 3981 // Note that if we didn't have the TSM/immortal constraint, then | |
| 3982 // when reattaching, above, we could trim the list. | |
| 3983 ev = new ParkEvent () ; | |
| 3984 guarantee ((intptr_t(ev) & 0xFF) == 0, "invariant") ; | |
| 3985 } | |
| 3986 ev->reset() ; // courtesy to caller | |
| 3987 ev->AssociatedWith = t ; // Associate ev with t | |
| 3988 ev->FreeNext = NULL ; | |
| 3989 return ev ; | |
| 3990 } | |
| 3991 | |
| 3992 void ParkEvent::Release (ParkEvent * ev) { | |
| 3993 if (ev == NULL) return ; | |
| 3994 guarantee (ev->FreeNext == NULL , "invariant") ; | |
| 3995 ev->AssociatedWith = NULL ; | |
| 3996 for (;;) { | |
| 3997 // Push ev onto FreeList | |
| 3998 // The mechanism is "half" lock-free. | |
| 3999 ParkEvent * List = FreeList ; | |
| 4000 ev->FreeNext = List ; | |
| 4001 if (Atomic::cmpxchg_ptr (ev, &FreeList, List) == List) break ; | |
| 4002 } | |
| 4003 } | |
| 4004 | |
| 4005 // Override operator new and delete so we can ensure that the | |
| 4006 // least significant byte of ParkEvent addresses is 0. | |
| 4007 // Beware that excessive address alignment is undesirable | |
| 4008 // as it can result in D$ index usage imbalance as | |
| 4009 // well as bank access imbalance on Niagara-like platforms, | |
| 4010 // although Niagara's hash function should help. | |
| 4011 | |
| 4012 void * ParkEvent::operator new (size_t sz) { | |
| 4013 return (void *) ((intptr_t (CHeapObj::operator new (sz + 256)) + 256) & -256) ; | |
| 4014 } | |
| 4015 | |
| 4016 void ParkEvent::operator delete (void * a) { | |
| 4017 // ParkEvents are type-stable and immortal ... | |
| 4018 ShouldNotReachHere(); | |
| 4019 } | |
| 4020 | |
| 4021 | |
| 4022 // 6399321 As a temporary measure we copied & modified the ParkEvent:: | |
| 4023 // allocate() and release() code for use by Parkers. The Parker:: forms | |
| 4024 // will eventually be removed as we consolide and shift over to ParkEvents | |
| 4025 // for both builtin synchronization and JSR166 operations. | |
| 4026 | |
| 4027 volatile int Parker::ListLock = 0 ; | |
| 4028 Parker * volatile Parker::FreeList = NULL ; | |
| 4029 | |
| 4030 Parker * Parker::Allocate (JavaThread * t) { | |
| 4031 guarantee (t != NULL, "invariant") ; | |
| 4032 Parker * p ; | |
| 4033 | |
| 4034 // Start by trying to recycle an existing but unassociated | |
| 4035 // Parker from the global free list. | |
| 4036 for (;;) { | |
| 4037 p = FreeList ; | |
| 4038 if (p == NULL) break ; | |
| 4039 // 1: Detach | |
| 4040 // Tantamount to p = Swap (&FreeList, NULL) | |
| 4041 if (Atomic::cmpxchg_ptr (NULL, &FreeList, p) != p) { | |
| 4042 continue ; | |
| 4043 } | |
| 4044 | |
| 4045 // We've detached the list. The list in-hand is now | |
| 4046 // local to this thread. This thread can operate on the | |
| 4047 // list without risk of interference from other threads. | |
| 4048 // 2: Extract -- pop the 1st element from the list. | |
| 4049 Parker * List = p->FreeNext ; | |
| 4050 if (List == NULL) break ; | |
| 4051 for (;;) { | |
| 4052 // 3: Try to reattach the residual list | |
| 4053 guarantee (List != NULL, "invariant") ; | |
| 4054 Parker * Arv = (Parker *) Atomic::cmpxchg_ptr (List, &FreeList, NULL) ; | |
| 4055 if (Arv == NULL) break ; | |
| 4056 | |
| 4057 // New nodes arrived. Try to detach the recent arrivals. | |
| 4058 if (Atomic::cmpxchg_ptr (NULL, &FreeList, Arv) != Arv) { | |
| 4059 continue ; | |
| 4060 } | |
| 4061 guarantee (Arv != NULL, "invariant") ; | |
| 4062 // 4: Merge Arv into List | |
| 4063 Parker * Tail = List ; | |
| 4064 while (Tail->FreeNext != NULL) Tail = Tail->FreeNext ; | |
| 4065 Tail->FreeNext = Arv ; | |
| 4066 } | |
| 4067 break ; | |
| 4068 } | |
| 4069 | |
| 4070 if (p != NULL) { | |
| 4071 guarantee (p->AssociatedWith == NULL, "invariant") ; | |
| 4072 } else { | |
| 4073 // Do this the hard way -- materialize a new Parker.. | |
| 4074 // In rare cases an allocating thread might detach | |
| 4075 // a long list -- installing null into FreeList --and | |
| 4076 // then stall. Another thread calling Allocate() would see | |
| 4077 // FreeList == null and then invoke the ctor. In this case we | |
| 4078 // end up with more Parkers in circulation than we need, but | |
| 4079 // the race is rare and the outcome is benign. | |
| 4080 // Ideally, the # of extant Parkers is equal to the | |
| 4081 // maximum # of threads that existed at any one time. | |
| 4082 // Because of the race mentioned above, segments of the | |
| 4083 // freelist can be transiently inaccessible. At worst | |
| 4084 // we may end up with the # of Parkers in circulation | |
| 4085 // slightly above the ideal. | |
| 4086 p = new Parker() ; | |
| 4087 } | |
| 4088 p->AssociatedWith = t ; // Associate p with t | |
| 4089 p->FreeNext = NULL ; | |
| 4090 return p ; | |
| 4091 } | |
| 4092 | |
| 4093 | |
| 4094 void Parker::Release (Parker * p) { | |
| 4095 if (p == NULL) return ; | |
| 4096 guarantee (p->AssociatedWith != NULL, "invariant") ; | |
| 4097 guarantee (p->FreeNext == NULL , "invariant") ; | |
| 4098 p->AssociatedWith = NULL ; | |
| 4099 for (;;) { | |
| 4100 // Push p onto FreeList | |
| 4101 Parker * List = FreeList ; | |
| 4102 p->FreeNext = List ; | |
| 4103 if (Atomic::cmpxchg_ptr (p, &FreeList, List) == List) break ; | |
| 4104 } | |
| 4105 } | |
| 4106 | |
| 4107 void Threads::verify() { | |
| 4108 ALL_JAVA_THREADS(p) { | |
| 4109 p->verify(); | |
| 4110 } | |
| 4111 VMThread* thread = VMThread::vm_thread(); | |
| 4112 if (thread != NULL) thread->verify(); | |
| 4113 } |