Wed, 11 Sep 2013 16:25:02 +0200
8010722: assert: failed: heap size is too big for compressed oops
Summary: Use conservative assumptions of required alignment for the various garbage collector components into account when determining the maximum heap size that supports compressed oops. Using this conservative value avoids several circular dependencies in the calculation.
Reviewed-by: stefank, dholmes
1 /*
2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
25 #include "precompiled.hpp"
26 #include "classfile/classLoader.hpp"
27 #include "classfile/javaClasses.hpp"
28 #include "classfile/systemDictionary.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "code/scopeDesc.hpp"
31 #include "compiler/compileBroker.hpp"
32 #include "interpreter/interpreter.hpp"
33 #include "interpreter/linkResolver.hpp"
34 #include "interpreter/oopMapCache.hpp"
35 #include "jvmtifiles/jvmtiEnv.hpp"
36 #include "memory/gcLocker.inline.hpp"
37 #include "memory/metaspaceShared.hpp"
38 #include "memory/oopFactory.hpp"
39 #include "memory/universe.inline.hpp"
40 #include "oops/instanceKlass.hpp"
41 #include "oops/objArrayOop.hpp"
42 #include "oops/oop.inline.hpp"
43 #include "oops/symbol.hpp"
44 #include "prims/jvm_misc.hpp"
45 #include "prims/jvmtiExport.hpp"
46 #include "prims/jvmtiThreadState.hpp"
47 #include "prims/privilegedStack.hpp"
48 #include "runtime/arguments.hpp"
49 #include "runtime/biasedLocking.hpp"
50 #include "runtime/deoptimization.hpp"
51 #include "runtime/fprofiler.hpp"
52 #include "runtime/frame.inline.hpp"
53 #include "runtime/init.hpp"
54 #include "runtime/interfaceSupport.hpp"
55 #include "runtime/java.hpp"
56 #include "runtime/javaCalls.hpp"
57 #include "runtime/jniPeriodicChecker.hpp"
58 #include "runtime/memprofiler.hpp"
59 #include "runtime/mutexLocker.hpp"
60 #include "runtime/objectMonitor.hpp"
61 #include "runtime/osThread.hpp"
62 #include "runtime/safepoint.hpp"
63 #include "runtime/sharedRuntime.hpp"
64 #include "runtime/statSampler.hpp"
65 #include "runtime/stubRoutines.hpp"
66 #include "runtime/task.hpp"
67 #include "runtime/thread.inline.hpp"
68 #include "runtime/threadCritical.hpp"
69 #include "runtime/threadLocalStorage.hpp"
70 #include "runtime/vframe.hpp"
71 #include "runtime/vframeArray.hpp"
72 #include "runtime/vframe_hp.hpp"
73 #include "runtime/vmThread.hpp"
74 #include "runtime/vm_operations.hpp"
75 #include "services/attachListener.hpp"
76 #include "services/management.hpp"
77 #include "services/memTracker.hpp"
78 #include "services/threadService.hpp"
79 #include "trace/tracing.hpp"
80 #include "trace/traceMacros.hpp"
81 #include "utilities/defaultStream.hpp"
82 #include "utilities/dtrace.hpp"
83 #include "utilities/events.hpp"
84 #include "utilities/preserveException.hpp"
85 #include "utilities/macros.hpp"
86 #ifdef TARGET_OS_FAMILY_linux
87 # include "os_linux.inline.hpp"
88 #endif
89 #ifdef TARGET_OS_FAMILY_solaris
90 # include "os_solaris.inline.hpp"
91 #endif
92 #ifdef TARGET_OS_FAMILY_windows
93 # include "os_windows.inline.hpp"
94 #endif
95 #ifdef TARGET_OS_FAMILY_bsd
96 # include "os_bsd.inline.hpp"
97 #endif
98 #if INCLUDE_ALL_GCS
99 #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
100 #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
101 #include "gc_implementation/parallelScavenge/pcTasks.hpp"
102 #endif // INCLUDE_ALL_GCS
103 #ifdef COMPILER1
104 #include "c1/c1_Compiler.hpp"
105 #endif
106 #ifdef COMPILER2
107 #include "opto/c2compiler.hpp"
108 #include "opto/idealGraphPrinter.hpp"
109 #endif
111 #ifdef DTRACE_ENABLED
113 // Only bother with this argument setup if dtrace is available
115 #ifndef USDT2
116 HS_DTRACE_PROBE_DECL(hotspot, vm__init__begin);
117 HS_DTRACE_PROBE_DECL(hotspot, vm__init__end);
118 HS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,
119 intptr_t, intptr_t, bool);
120 HS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
121 intptr_t, intptr_t, bool);
123 #define DTRACE_THREAD_PROBE(probe, javathread) \
124 { \
125 ResourceMark rm(this); \
126 int len = 0; \
127 const char* name = (javathread)->get_thread_name(); \
128 len = strlen(name); \
129 HS_DTRACE_PROBE5(hotspot, thread__##probe, \
130 name, len, \
131 java_lang_Thread::thread_id((javathread)->threadObj()), \
132 (javathread)->osthread()->thread_id(), \
133 java_lang_Thread::is_daemon((javathread)->threadObj())); \
134 }
136 #else /* USDT2 */
138 #define HOTSPOT_THREAD_PROBE_start HOTSPOT_THREAD_PROBE_START
139 #define HOTSPOT_THREAD_PROBE_stop HOTSPOT_THREAD_PROBE_STOP
141 #define DTRACE_THREAD_PROBE(probe, javathread) \
142 { \
143 ResourceMark rm(this); \
144 int len = 0; \
145 const char* name = (javathread)->get_thread_name(); \
146 len = strlen(name); \
147 HOTSPOT_THREAD_PROBE_##probe( /* probe = start, stop */ \
148 (char *) name, len, \
149 java_lang_Thread::thread_id((javathread)->threadObj()), \
150 (uintptr_t) (javathread)->osthread()->thread_id(), \
151 java_lang_Thread::is_daemon((javathread)->threadObj())); \
152 }
154 #endif /* USDT2 */
156 #else // ndef DTRACE_ENABLED
158 #define DTRACE_THREAD_PROBE(probe, javathread)
160 #endif // ndef DTRACE_ENABLED
163 // Class hierarchy
164 // - Thread
165 // - VMThread
166 // - WatcherThread
167 // - ConcurrentMarkSweepThread
168 // - JavaThread
169 // - CompilerThread
171 // ======= Thread ========
172 // Support for forcing alignment of thread objects for biased locking
173 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) {
174 if (UseBiasedLocking) {
175 const int alignment = markOopDesc::biased_lock_alignment;
176 size_t aligned_size = size + (alignment - sizeof(intptr_t));
177 void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC)
178 : AllocateHeap(aligned_size, flags, CURRENT_PC,
179 AllocFailStrategy::RETURN_NULL);
180 void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
181 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
182 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
183 "JavaThread alignment code overflowed allocated storage");
184 if (TraceBiasedLocking) {
185 if (aligned_addr != real_malloc_addr)
186 tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
187 real_malloc_addr, aligned_addr);
188 }
189 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
190 return aligned_addr;
191 } else {
192 return throw_excpt? AllocateHeap(size, flags, CURRENT_PC)
193 : AllocateHeap(size, flags, CURRENT_PC, AllocFailStrategy::RETURN_NULL);
194 }
195 }
197 void Thread::operator delete(void* p) {
198 if (UseBiasedLocking) {
199 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;
200 FreeHeap(real_malloc_addr, mtThread);
201 } else {
202 FreeHeap(p, mtThread);
203 }
204 }
207 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,
208 // JavaThread
211 Thread::Thread() {
212 // stack and get_thread
213 set_stack_base(NULL);
214 set_stack_size(0);
215 set_self_raw_id(0);
216 set_lgrp_id(-1);
218 // allocated data structures
219 set_osthread(NULL);
220 set_resource_area(new (mtThread)ResourceArea());
221 DEBUG_ONLY(_current_resource_mark = NULL;)
222 set_handle_area(new (mtThread) HandleArea(NULL));
223 set_metadata_handles(new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(30, true));
224 set_active_handles(NULL);
225 set_free_handle_block(NULL);
226 set_last_handle_mark(NULL);
228 // This initial value ==> never claimed.
229 _oops_do_parity = 0;
231 // the handle mark links itself to last_handle_mark
232 new HandleMark(this);
234 // plain initialization
235 debug_only(_owned_locks = NULL;)
236 debug_only(_allow_allocation_count = 0;)
237 NOT_PRODUCT(_allow_safepoint_count = 0;)
238 NOT_PRODUCT(_skip_gcalot = false;)
239 CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)
240 _jvmti_env_iteration_count = 0;
241 set_allocated_bytes(0);
242 _vm_operation_started_count = 0;
243 _vm_operation_completed_count = 0;
244 _current_pending_monitor = NULL;
245 _current_pending_monitor_is_from_java = true;
246 _current_waiting_monitor = NULL;
247 _num_nested_signal = 0;
248 omFreeList = NULL ;
249 omFreeCount = 0 ;
250 omFreeProvision = 32 ;
251 omInUseList = NULL ;
252 omInUseCount = 0 ;
254 #ifdef ASSERT
255 _visited_for_critical_count = false;
256 #endif
258 _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);
259 _suspend_flags = 0;
261 // thread-specific hashCode stream generator state - Marsaglia shift-xor form
262 _hashStateX = os::random() ;
263 _hashStateY = 842502087 ;
264 _hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ;
265 _hashStateW = 273326509 ;
267 _OnTrap = 0 ;
268 _schedctl = NULL ;
269 _Stalled = 0 ;
270 _TypeTag = 0x2BAD ;
272 // Many of the following fields are effectively final - immutable
273 // Note that nascent threads can't use the Native Monitor-Mutex
274 // construct until the _MutexEvent is initialized ...
275 // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents
276 // we might instead use a stack of ParkEvents that we could provision on-demand.
277 // The stack would act as a cache to avoid calls to ParkEvent::Allocate()
278 // and ::Release()
279 _ParkEvent = ParkEvent::Allocate (this) ;
280 _SleepEvent = ParkEvent::Allocate (this) ;
281 _MutexEvent = ParkEvent::Allocate (this) ;
282 _MuxEvent = ParkEvent::Allocate (this) ;
284 #ifdef CHECK_UNHANDLED_OOPS
285 if (CheckUnhandledOops) {
286 _unhandled_oops = new UnhandledOops(this);
287 }
288 #endif // CHECK_UNHANDLED_OOPS
289 #ifdef ASSERT
290 if (UseBiasedLocking) {
291 assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
292 assert(this == _real_malloc_address ||
293 this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),
294 "bug in forced alignment of thread objects");
295 }
296 #endif /* ASSERT */
297 }
299 void Thread::initialize_thread_local_storage() {
300 // Note: Make sure this method only calls
301 // non-blocking operations. Otherwise, it might not work
302 // with the thread-startup/safepoint interaction.
304 // During Java thread startup, safepoint code should allow this
305 // method to complete because it may need to allocate memory to
306 // store information for the new thread.
308 // initialize structure dependent on thread local storage
309 ThreadLocalStorage::set_thread(this);
310 }
312 void Thread::record_stack_base_and_size() {
313 set_stack_base(os::current_stack_base());
314 set_stack_size(os::current_stack_size());
315 // CR 7190089: on Solaris, primordial thread's stack is adjusted
316 // in initialize_thread(). Without the adjustment, stack size is
317 // incorrect if stack is set to unlimited (ulimit -s unlimited).
318 // So far, only Solaris has real implementation of initialize_thread().
319 //
320 // set up any platform-specific state.
321 os::initialize_thread(this);
323 #if INCLUDE_NMT
324 // record thread's native stack, stack grows downward
325 address stack_low_addr = stack_base() - stack_size();
326 MemTracker::record_thread_stack(stack_low_addr, stack_size(), this,
327 CURRENT_PC);
328 #endif // INCLUDE_NMT
329 }
332 Thread::~Thread() {
333 // Reclaim the objectmonitors from the omFreeList of the moribund thread.
334 ObjectSynchronizer::omFlush (this) ;
336 // stack_base can be NULL if the thread is never started or exited before
337 // record_stack_base_and_size called. Although, we would like to ensure
338 // that all started threads do call record_stack_base_and_size(), there is
339 // not proper way to enforce that.
340 #if INCLUDE_NMT
341 if (_stack_base != NULL) {
342 address low_stack_addr = stack_base() - stack_size();
343 MemTracker::release_thread_stack(low_stack_addr, stack_size(), this);
344 #ifdef ASSERT
345 set_stack_base(NULL);
346 #endif
347 }
348 #endif // INCLUDE_NMT
350 // deallocate data structures
351 delete resource_area();
352 // since the handle marks are using the handle area, we have to deallocated the root
353 // handle mark before deallocating the thread's handle area,
354 assert(last_handle_mark() != NULL, "check we have an element");
355 delete last_handle_mark();
356 assert(last_handle_mark() == NULL, "check we have reached the end");
358 // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.
359 // We NULL out the fields for good hygiene.
360 ParkEvent::Release (_ParkEvent) ; _ParkEvent = NULL ;
361 ParkEvent::Release (_SleepEvent) ; _SleepEvent = NULL ;
362 ParkEvent::Release (_MutexEvent) ; _MutexEvent = NULL ;
363 ParkEvent::Release (_MuxEvent) ; _MuxEvent = NULL ;
365 delete handle_area();
366 delete metadata_handles();
368 // osthread() can be NULL, if creation of thread failed.
369 if (osthread() != NULL) os::free_thread(osthread());
371 delete _SR_lock;
373 // clear thread local storage if the Thread is deleting itself
374 if (this == Thread::current()) {
375 ThreadLocalStorage::set_thread(NULL);
376 } else {
377 // In the case where we're not the current thread, invalidate all the
378 // caches in case some code tries to get the current thread or the
379 // thread that was destroyed, and gets stale information.
380 ThreadLocalStorage::invalidate_all();
381 }
382 CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)
383 }
385 // NOTE: dummy function for assertion purpose.
386 void Thread::run() {
387 ShouldNotReachHere();
388 }
390 #ifdef ASSERT
391 // Private method to check for dangling thread pointer
392 void check_for_dangling_thread_pointer(Thread *thread) {
393 assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
394 "possibility of dangling Thread pointer");
395 }
396 #endif
399 #ifndef PRODUCT
400 // Tracing method for basic thread operations
401 void Thread::trace(const char* msg, const Thread* const thread) {
402 if (!TraceThreadEvents) return;
403 ResourceMark rm;
404 ThreadCritical tc;
405 const char *name = "non-Java thread";
406 int prio = -1;
407 if (thread->is_Java_thread()
408 && !thread->is_Compiler_thread()) {
409 // The Threads_lock must be held to get information about
410 // this thread but may not be in some situations when
411 // tracing thread events.
412 bool release_Threads_lock = false;
413 if (!Threads_lock->owned_by_self()) {
414 Threads_lock->lock();
415 release_Threads_lock = true;
416 }
417 JavaThread* jt = (JavaThread *)thread;
418 name = (char *)jt->get_thread_name();
419 oop thread_oop = jt->threadObj();
420 if (thread_oop != NULL) {
421 prio = java_lang_Thread::priority(thread_oop);
422 }
423 if (release_Threads_lock) {
424 Threads_lock->unlock();
425 }
426 }
427 tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);
428 }
429 #endif
432 ThreadPriority Thread::get_priority(const Thread* const thread) {
433 trace("get priority", thread);
434 ThreadPriority priority;
435 // Can return an error!
436 (void)os::get_priority(thread, priority);
437 assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");
438 return priority;
439 }
441 void Thread::set_priority(Thread* thread, ThreadPriority priority) {
442 trace("set priority", thread);
443 debug_only(check_for_dangling_thread_pointer(thread);)
444 // Can return an error!
445 (void)os::set_priority(thread, priority);
446 }
449 void Thread::start(Thread* thread) {
450 trace("start", thread);
451 // Start is different from resume in that its safety is guaranteed by context or
452 // being called from a Java method synchronized on the Thread object.
453 if (!DisableStartThread) {
454 if (thread->is_Java_thread()) {
455 // Initialize the thread state to RUNNABLE before starting this thread.
456 // Can not set it after the thread started because we do not know the
457 // exact thread state at that time. It could be in MONITOR_WAIT or
458 // in SLEEPING or some other state.
459 java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
460 java_lang_Thread::RUNNABLE);
461 }
462 os::start_thread(thread);
463 }
464 }
466 // Enqueue a VM_Operation to do the job for us - sometime later
467 void Thread::send_async_exception(oop java_thread, oop java_throwable) {
468 VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);
469 VMThread::execute(vm_stop);
470 }
473 //
474 // Check if an external suspend request has completed (or has been
475 // cancelled). Returns true if the thread is externally suspended and
476 // false otherwise.
477 //
478 // The bits parameter returns information about the code path through
479 // the routine. Useful for debugging:
480 //
481 // set in is_ext_suspend_completed():
482 // 0x00000001 - routine was entered
483 // 0x00000010 - routine return false at end
484 // 0x00000100 - thread exited (return false)
485 // 0x00000200 - suspend request cancelled (return false)
486 // 0x00000400 - thread suspended (return true)
487 // 0x00001000 - thread is in a suspend equivalent state (return true)
488 // 0x00002000 - thread is native and walkable (return true)
489 // 0x00004000 - thread is native_trans and walkable (needed retry)
490 //
491 // set in wait_for_ext_suspend_completion():
492 // 0x00010000 - routine was entered
493 // 0x00020000 - suspend request cancelled before loop (return false)
494 // 0x00040000 - thread suspended before loop (return true)
495 // 0x00080000 - suspend request cancelled in loop (return false)
496 // 0x00100000 - thread suspended in loop (return true)
497 // 0x00200000 - suspend not completed during retry loop (return false)
498 //
500 // Helper class for tracing suspend wait debug bits.
501 //
502 // 0x00000100 indicates that the target thread exited before it could
503 // self-suspend which is not a wait failure. 0x00000200, 0x00020000 and
504 // 0x00080000 each indicate a cancelled suspend request so they don't
505 // count as wait failures either.
506 #define DEBUG_FALSE_BITS (0x00000010 | 0x00200000)
508 class TraceSuspendDebugBits : public StackObj {
509 private:
510 JavaThread * jt;
511 bool is_wait;
512 bool called_by_wait; // meaningful when !is_wait
513 uint32_t * bits;
515 public:
516 TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait,
517 uint32_t *_bits) {
518 jt = _jt;
519 is_wait = _is_wait;
520 called_by_wait = _called_by_wait;
521 bits = _bits;
522 }
524 ~TraceSuspendDebugBits() {
525 if (!is_wait) {
526 #if 1
527 // By default, don't trace bits for is_ext_suspend_completed() calls.
528 // That trace is very chatty.
529 return;
530 #else
531 if (!called_by_wait) {
532 // If tracing for is_ext_suspend_completed() is enabled, then only
533 // trace calls to it from wait_for_ext_suspend_completion()
534 return;
535 }
536 #endif
537 }
539 if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) {
540 if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {
541 MutexLocker ml(Threads_lock); // needed for get_thread_name()
542 ResourceMark rm;
544 tty->print_cr(
545 "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",
546 jt->get_thread_name(), *bits);
548 guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");
549 }
550 }
551 }
552 };
553 #undef DEBUG_FALSE_BITS
556 bool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) {
557 TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits);
559 bool did_trans_retry = false; // only do thread_in_native_trans retry once
560 bool do_trans_retry; // flag to force the retry
562 *bits |= 0x00000001;
564 do {
565 do_trans_retry = false;
567 if (is_exiting()) {
568 // Thread is in the process of exiting. This is always checked
569 // first to reduce the risk of dereferencing a freed JavaThread.
570 *bits |= 0x00000100;
571 return false;
572 }
574 if (!is_external_suspend()) {
575 // Suspend request is cancelled. This is always checked before
576 // is_ext_suspended() to reduce the risk of a rogue resume
577 // confusing the thread that made the suspend request.
578 *bits |= 0x00000200;
579 return false;
580 }
582 if (is_ext_suspended()) {
583 // thread is suspended
584 *bits |= 0x00000400;
585 return true;
586 }
588 // Now that we no longer do hard suspends of threads running
589 // native code, the target thread can be changing thread state
590 // while we are in this routine:
591 //
592 // _thread_in_native -> _thread_in_native_trans -> _thread_blocked
593 //
594 // We save a copy of the thread state as observed at this moment
595 // and make our decision about suspend completeness based on the
596 // copy. This closes the race where the thread state is seen as
597 // _thread_in_native_trans in the if-thread_blocked check, but is
598 // seen as _thread_blocked in if-thread_in_native_trans check.
599 JavaThreadState save_state = thread_state();
601 if (save_state == _thread_blocked && is_suspend_equivalent()) {
602 // If the thread's state is _thread_blocked and this blocking
603 // condition is known to be equivalent to a suspend, then we can
604 // consider the thread to be externally suspended. This means that
605 // the code that sets _thread_blocked has been modified to do
606 // self-suspension if the blocking condition releases. We also
607 // used to check for CONDVAR_WAIT here, but that is now covered by
608 // the _thread_blocked with self-suspension check.
609 //
610 // Return true since we wouldn't be here unless there was still an
611 // external suspend request.
612 *bits |= 0x00001000;
613 return true;
614 } else if (save_state == _thread_in_native && frame_anchor()->walkable()) {
615 // Threads running native code will self-suspend on native==>VM/Java
616 // transitions. If its stack is walkable (should always be the case
617 // unless this function is called before the actual java_suspend()
618 // call), then the wait is done.
619 *bits |= 0x00002000;
620 return true;
621 } else if (!called_by_wait && !did_trans_retry &&
622 save_state == _thread_in_native_trans &&
623 frame_anchor()->walkable()) {
624 // The thread is transitioning from thread_in_native to another
625 // thread state. check_safepoint_and_suspend_for_native_trans()
626 // will force the thread to self-suspend. If it hasn't gotten
627 // there yet we may have caught the thread in-between the native
628 // code check above and the self-suspend. Lucky us. If we were
629 // called by wait_for_ext_suspend_completion(), then it
630 // will be doing the retries so we don't have to.
631 //
632 // Since we use the saved thread state in the if-statement above,
633 // there is a chance that the thread has already transitioned to
634 // _thread_blocked by the time we get here. In that case, we will
635 // make a single unnecessary pass through the logic below. This
636 // doesn't hurt anything since we still do the trans retry.
638 *bits |= 0x00004000;
640 // Once the thread leaves thread_in_native_trans for another
641 // thread state, we break out of this retry loop. We shouldn't
642 // need this flag to prevent us from getting back here, but
643 // sometimes paranoia is good.
644 did_trans_retry = true;
646 // We wait for the thread to transition to a more usable state.
647 for (int i = 1; i <= SuspendRetryCount; i++) {
648 // We used to do an "os::yield_all(i)" call here with the intention
649 // that yielding would increase on each retry. However, the parameter
650 // is ignored on Linux which means the yield didn't scale up. Waiting
651 // on the SR_lock below provides a much more predictable scale up for
652 // the delay. It also provides a simple/direct point to check for any
653 // safepoint requests from the VMThread
655 // temporarily drops SR_lock while doing wait with safepoint check
656 // (if we're a JavaThread - the WatcherThread can also call this)
657 // and increase delay with each retry
658 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
660 // check the actual thread state instead of what we saved above
661 if (thread_state() != _thread_in_native_trans) {
662 // the thread has transitioned to another thread state so
663 // try all the checks (except this one) one more time.
664 do_trans_retry = true;
665 break;
666 }
667 } // end retry loop
670 }
671 } while (do_trans_retry);
673 *bits |= 0x00000010;
674 return false;
675 }
677 //
678 // Wait for an external suspend request to complete (or be cancelled).
679 // Returns true if the thread is externally suspended and false otherwise.
680 //
681 bool JavaThread::wait_for_ext_suspend_completion(int retries, int delay,
682 uint32_t *bits) {
683 TraceSuspendDebugBits tsdb(this, true /* is_wait */,
684 false /* !called_by_wait */, bits);
686 // local flag copies to minimize SR_lock hold time
687 bool is_suspended;
688 bool pending;
689 uint32_t reset_bits;
691 // set a marker so is_ext_suspend_completed() knows we are the caller
692 *bits |= 0x00010000;
694 // We use reset_bits to reinitialize the bits value at the top of
695 // each retry loop. This allows the caller to make use of any
696 // unused bits for their own marking purposes.
697 reset_bits = *bits;
699 {
700 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
701 is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
702 delay, bits);
703 pending = is_external_suspend();
704 }
705 // must release SR_lock to allow suspension to complete
707 if (!pending) {
708 // A cancelled suspend request is the only false return from
709 // is_ext_suspend_completed() that keeps us from entering the
710 // retry loop.
711 *bits |= 0x00020000;
712 return false;
713 }
715 if (is_suspended) {
716 *bits |= 0x00040000;
717 return true;
718 }
720 for (int i = 1; i <= retries; i++) {
721 *bits = reset_bits; // reinit to only track last retry
723 // We used to do an "os::yield_all(i)" call here with the intention
724 // that yielding would increase on each retry. However, the parameter
725 // is ignored on Linux which means the yield didn't scale up. Waiting
726 // on the SR_lock below provides a much more predictable scale up for
727 // the delay. It also provides a simple/direct point to check for any
728 // safepoint requests from the VMThread
730 {
731 MutexLocker ml(SR_lock());
732 // wait with safepoint check (if we're a JavaThread - the WatcherThread
733 // can also call this) and increase delay with each retry
734 SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
736 is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
737 delay, bits);
739 // It is possible for the external suspend request to be cancelled
740 // (by a resume) before the actual suspend operation is completed.
741 // Refresh our local copy to see if we still need to wait.
742 pending = is_external_suspend();
743 }
745 if (!pending) {
746 // A cancelled suspend request is the only false return from
747 // is_ext_suspend_completed() that keeps us from staying in the
748 // retry loop.
749 *bits |= 0x00080000;
750 return false;
751 }
753 if (is_suspended) {
754 *bits |= 0x00100000;
755 return true;
756 }
757 } // end retry loop
759 // thread did not suspend after all our retries
760 *bits |= 0x00200000;
761 return false;
762 }
764 #ifndef PRODUCT
765 void JavaThread::record_jump(address target, address instr, const char* file, int line) {
767 // This should not need to be atomic as the only way for simultaneous
768 // updates is via interrupts. Even then this should be rare or non-existant
769 // and we don't care that much anyway.
771 int index = _jmp_ring_index;
772 _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
773 _jmp_ring[index]._target = (intptr_t) target;
774 _jmp_ring[index]._instruction = (intptr_t) instr;
775 _jmp_ring[index]._file = file;
776 _jmp_ring[index]._line = line;
777 }
778 #endif /* PRODUCT */
780 // Called by flat profiler
781 // Callers have already called wait_for_ext_suspend_completion
782 // The assertion for that is currently too complex to put here:
783 bool JavaThread::profile_last_Java_frame(frame* _fr) {
784 bool gotframe = false;
785 // self suspension saves needed state.
786 if (has_last_Java_frame() && _anchor.walkable()) {
787 *_fr = pd_last_frame();
788 gotframe = true;
789 }
790 return gotframe;
791 }
793 void Thread::interrupt(Thread* thread) {
794 trace("interrupt", thread);
795 debug_only(check_for_dangling_thread_pointer(thread);)
796 os::interrupt(thread);
797 }
799 bool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
800 trace("is_interrupted", thread);
801 debug_only(check_for_dangling_thread_pointer(thread);)
802 // Note: If clear_interrupted==false, this simply fetches and
803 // returns the value of the field osthread()->interrupted().
804 return os::is_interrupted(thread, clear_interrupted);
805 }
808 // GC Support
809 bool Thread::claim_oops_do_par_case(int strong_roots_parity) {
810 jint thread_parity = _oops_do_parity;
811 if (thread_parity != strong_roots_parity) {
812 jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
813 if (res == thread_parity) {
814 return true;
815 } else {
816 guarantee(res == strong_roots_parity, "Or else what?");
817 assert(SharedHeap::heap()->workers()->active_workers() > 0,
818 "Should only fail when parallel.");
819 return false;
820 }
821 }
822 assert(SharedHeap::heap()->workers()->active_workers() > 0,
823 "Should only fail when parallel.");
824 return false;
825 }
827 void Thread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
828 active_handles()->oops_do(f);
829 // Do oop for ThreadShadow
830 f->do_oop((oop*)&_pending_exception);
831 handle_area()->oops_do(f);
832 }
834 void Thread::nmethods_do(CodeBlobClosure* cf) {
835 // no nmethods in a generic thread...
836 }
838 void Thread::metadata_do(void f(Metadata*)) {
839 if (metadata_handles() != NULL) {
840 for (int i = 0; i< metadata_handles()->length(); i++) {
841 f(metadata_handles()->at(i));
842 }
843 }
844 }
846 void Thread::print_on(outputStream* st) const {
847 // get_priority assumes osthread initialized
848 if (osthread() != NULL) {
849 int os_prio;
850 if (os::get_native_priority(this, &os_prio) == OS_OK) {
851 st->print("os_prio=%d ", os_prio);
852 }
853 st->print("tid=" INTPTR_FORMAT " ", this);
854 osthread()->print_on(st);
855 }
856 debug_only(if (WizardMode) print_owned_locks_on(st);)
857 }
859 // Thread::print_on_error() is called by fatal error handler. Don't use
860 // any lock or allocate memory.
861 void Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
862 if (is_VM_thread()) st->print("VMThread");
863 else if (is_Compiler_thread()) st->print("CompilerThread");
864 else if (is_Java_thread()) st->print("JavaThread");
865 else if (is_GC_task_thread()) st->print("GCTaskThread");
866 else if (is_Watcher_thread()) st->print("WatcherThread");
867 else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread");
868 else st->print("Thread");
870 st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
871 _stack_base - _stack_size, _stack_base);
873 if (osthread()) {
874 st->print(" [id=%d]", osthread()->thread_id());
875 }
876 }
878 #ifdef ASSERT
879 void Thread::print_owned_locks_on(outputStream* st) const {
880 Monitor *cur = _owned_locks;
881 if (cur == NULL) {
882 st->print(" (no locks) ");
883 } else {
884 st->print_cr(" Locks owned:");
885 while(cur) {
886 cur->print_on(st);
887 cur = cur->next();
888 }
889 }
890 }
892 static int ref_use_count = 0;
894 bool Thread::owns_locks_but_compiled_lock() const {
895 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
896 if (cur != Compile_lock) return true;
897 }
898 return false;
899 }
902 #endif
904 #ifndef PRODUCT
906 // The flag: potential_vm_operation notifies if this particular safepoint state could potential
907 // invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
908 // no threads which allow_vm_block's are held
909 void Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
910 // Check if current thread is allowed to block at a safepoint
911 if (!(_allow_safepoint_count == 0))
912 fatal("Possible safepoint reached by thread that does not allow it");
913 if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
914 fatal("LEAF method calling lock?");
915 }
917 #ifdef ASSERT
918 if (potential_vm_operation && is_Java_thread()
919 && !Universe::is_bootstrapping()) {
920 // Make sure we do not hold any locks that the VM thread also uses.
921 // This could potentially lead to deadlocks
922 for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
923 // Threads_lock is special, since the safepoint synchronization will not start before this is
924 // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
925 // since it is used to transfer control between JavaThreads and the VMThread
926 // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first!
927 if ( (cur->allow_vm_block() &&
928 cur != Threads_lock &&
929 cur != Compile_lock && // Temporary: should not be necessary when we get spearate compilation
930 cur != VMOperationRequest_lock &&
931 cur != VMOperationQueue_lock) ||
932 cur->rank() == Mutex::special) {
933 warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
934 }
935 }
936 }
938 if (GCALotAtAllSafepoints) {
939 // We could enter a safepoint here and thus have a gc
940 InterfaceSupport::check_gc_alot();
941 }
942 #endif
943 }
944 #endif
946 bool Thread::is_in_stack(address adr) const {
947 assert(Thread::current() == this, "is_in_stack can only be called from current thread");
948 address end = os::current_stack_pointer();
949 // Allow non Java threads to call this without stack_base
950 if (_stack_base == NULL) return true;
951 if (stack_base() >= adr && adr >= end) return true;
953 return false;
954 }
957 bool Thread::is_in_usable_stack(address adr) const {
958 size_t stack_guard_size = os::uses_stack_guard_pages() ? (StackYellowPages + StackRedPages) * os::vm_page_size() : 0;
959 size_t usable_stack_size = _stack_size - stack_guard_size;
961 return ((adr < stack_base()) && (adr >= stack_base() - usable_stack_size));
962 }
965 // We had to move these methods here, because vm threads get into ObjectSynchronizer::enter
966 // However, there is a note in JavaThread::is_lock_owned() about the VM threads not being
967 // used for compilation in the future. If that change is made, the need for these methods
968 // should be revisited, and they should be removed if possible.
970 bool Thread::is_lock_owned(address adr) const {
971 return on_local_stack(adr);
972 }
974 bool Thread::set_as_starting_thread() {
975 // NOTE: this must be called inside the main thread.
976 return os::create_main_thread((JavaThread*)this);
977 }
979 static void initialize_class(Symbol* class_name, TRAPS) {
980 Klass* klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
981 InstanceKlass::cast(klass)->initialize(CHECK);
982 }
985 // Creates the initial ThreadGroup
986 static Handle create_initial_thread_group(TRAPS) {
987 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ThreadGroup(), true, CHECK_NH);
988 instanceKlassHandle klass (THREAD, k);
990 Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
991 {
992 JavaValue result(T_VOID);
993 JavaCalls::call_special(&result,
994 system_instance,
995 klass,
996 vmSymbols::object_initializer_name(),
997 vmSymbols::void_method_signature(),
998 CHECK_NH);
999 }
1000 Universe::set_system_thread_group(system_instance());
1002 Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
1003 {
1004 JavaValue result(T_VOID);
1005 Handle string = java_lang_String::create_from_str("main", CHECK_NH);
1006 JavaCalls::call_special(&result,
1007 main_instance,
1008 klass,
1009 vmSymbols::object_initializer_name(),
1010 vmSymbols::threadgroup_string_void_signature(),
1011 system_instance,
1012 string,
1013 CHECK_NH);
1014 }
1015 return main_instance;
1016 }
1018 // Creates the initial Thread
1019 static oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) {
1020 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL);
1021 instanceKlassHandle klass (THREAD, k);
1022 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
1024 java_lang_Thread::set_thread(thread_oop(), thread);
1025 java_lang_Thread::set_priority(thread_oop(), NormPriority);
1026 thread->set_threadObj(thread_oop());
1028 Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
1030 JavaValue result(T_VOID);
1031 JavaCalls::call_special(&result, thread_oop,
1032 klass,
1033 vmSymbols::object_initializer_name(),
1034 vmSymbols::threadgroup_string_void_signature(),
1035 thread_group,
1036 string,
1037 CHECK_NULL);
1038 return thread_oop();
1039 }
1041 static void call_initializeSystemClass(TRAPS) {
1042 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
1043 instanceKlassHandle klass (THREAD, k);
1045 JavaValue result(T_VOID);
1046 JavaCalls::call_static(&result, klass, vmSymbols::initializeSystemClass_name(),
1047 vmSymbols::void_method_signature(), CHECK);
1048 }
1050 char java_runtime_name[128] = "";
1051 char java_runtime_version[128] = "";
1053 // extract the JRE name from sun.misc.Version.java_runtime_name
1054 static const char* get_java_runtime_name(TRAPS) {
1055 Klass* k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
1056 Handle(), Handle(), CHECK_AND_CLEAR_NULL);
1057 fieldDescriptor fd;
1058 bool found = k != NULL &&
1059 InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_name_name(),
1060 vmSymbols::string_signature(), &fd);
1061 if (found) {
1062 oop name_oop = k->java_mirror()->obj_field(fd.offset());
1063 if (name_oop == NULL)
1064 return NULL;
1065 const char* name = java_lang_String::as_utf8_string(name_oop,
1066 java_runtime_name,
1067 sizeof(java_runtime_name));
1068 return name;
1069 } else {
1070 return NULL;
1071 }
1072 }
1074 // extract the JRE version from sun.misc.Version.java_runtime_version
1075 static const char* get_java_runtime_version(TRAPS) {
1076 Klass* k = SystemDictionary::find(vmSymbols::sun_misc_Version(),
1077 Handle(), Handle(), CHECK_AND_CLEAR_NULL);
1078 fieldDescriptor fd;
1079 bool found = k != NULL &&
1080 InstanceKlass::cast(k)->find_local_field(vmSymbols::java_runtime_version_name(),
1081 vmSymbols::string_signature(), &fd);
1082 if (found) {
1083 oop name_oop = k->java_mirror()->obj_field(fd.offset());
1084 if (name_oop == NULL)
1085 return NULL;
1086 const char* name = java_lang_String::as_utf8_string(name_oop,
1087 java_runtime_version,
1088 sizeof(java_runtime_version));
1089 return name;
1090 } else {
1091 return NULL;
1092 }
1093 }
1095 // General purpose hook into Java code, run once when the VM is initialized.
1096 // The Java library method itself may be changed independently from the VM.
1097 static void call_postVMInitHook(TRAPS) {
1098 Klass* k = SystemDictionary::PostVMInitHook_klass();
1099 instanceKlassHandle klass (THREAD, k);
1100 if (klass.not_null()) {
1101 JavaValue result(T_VOID);
1102 JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(),
1103 vmSymbols::void_method_signature(),
1104 CHECK);
1105 }
1106 }
1108 static void reset_vm_info_property(TRAPS) {
1109 // the vm info string
1110 ResourceMark rm(THREAD);
1111 const char *vm_info = VM_Version::vm_info_string();
1113 // java.lang.System class
1114 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
1115 instanceKlassHandle klass (THREAD, k);
1117 // setProperty arguments
1118 Handle key_str = java_lang_String::create_from_str("java.vm.info", CHECK);
1119 Handle value_str = java_lang_String::create_from_str(vm_info, CHECK);
1121 // return value
1122 JavaValue r(T_OBJECT);
1124 // public static String setProperty(String key, String value);
1125 JavaCalls::call_static(&r,
1126 klass,
1127 vmSymbols::setProperty_name(),
1128 vmSymbols::string_string_string_signature(),
1129 key_str,
1130 value_str,
1131 CHECK);
1132 }
1135 void JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) {
1136 assert(thread_group.not_null(), "thread group should be specified");
1137 assert(threadObj() == NULL, "should only create Java thread object once");
1139 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
1140 instanceKlassHandle klass (THREAD, k);
1141 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
1143 java_lang_Thread::set_thread(thread_oop(), this);
1144 java_lang_Thread::set_priority(thread_oop(), NormPriority);
1145 set_threadObj(thread_oop());
1147 JavaValue result(T_VOID);
1148 if (thread_name != NULL) {
1149 Handle name = java_lang_String::create_from_str(thread_name, CHECK);
1150 // Thread gets assigned specified name and null target
1151 JavaCalls::call_special(&result,
1152 thread_oop,
1153 klass,
1154 vmSymbols::object_initializer_name(),
1155 vmSymbols::threadgroup_string_void_signature(),
1156 thread_group, // Argument 1
1157 name, // Argument 2
1158 THREAD);
1159 } else {
1160 // Thread gets assigned name "Thread-nnn" and null target
1161 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
1162 JavaCalls::call_special(&result,
1163 thread_oop,
1164 klass,
1165 vmSymbols::object_initializer_name(),
1166 vmSymbols::threadgroup_runnable_void_signature(),
1167 thread_group, // Argument 1
1168 Handle(), // Argument 2
1169 THREAD);
1170 }
1173 if (daemon) {
1174 java_lang_Thread::set_daemon(thread_oop());
1175 }
1177 if (HAS_PENDING_EXCEPTION) {
1178 return;
1179 }
1181 KlassHandle group(this, SystemDictionary::ThreadGroup_klass());
1182 Handle threadObj(this, this->threadObj());
1184 JavaCalls::call_special(&result,
1185 thread_group,
1186 group,
1187 vmSymbols::add_method_name(),
1188 vmSymbols::thread_void_signature(),
1189 threadObj, // Arg 1
1190 THREAD);
1193 }
1195 // NamedThread -- non-JavaThread subclasses with multiple
1196 // uniquely named instances should derive from this.
1197 NamedThread::NamedThread() : Thread() {
1198 _name = NULL;
1199 _processed_thread = NULL;
1200 }
1202 NamedThread::~NamedThread() {
1203 if (_name != NULL) {
1204 FREE_C_HEAP_ARRAY(char, _name, mtThread);
1205 _name = NULL;
1206 }
1207 }
1209 void NamedThread::set_name(const char* format, ...) {
1210 guarantee(_name == NULL, "Only get to set name once.");
1211 _name = NEW_C_HEAP_ARRAY(char, max_name_len, mtThread);
1212 guarantee(_name != NULL, "alloc failure");
1213 va_list ap;
1214 va_start(ap, format);
1215 jio_vsnprintf(_name, max_name_len, format, ap);
1216 va_end(ap);
1217 }
1219 // ======= WatcherThread ========
1221 // The watcher thread exists to simulate timer interrupts. It should
1222 // be replaced by an abstraction over whatever native support for
1223 // timer interrupts exists on the platform.
1225 WatcherThread* WatcherThread::_watcher_thread = NULL;
1226 bool WatcherThread::_startable = false;
1227 volatile bool WatcherThread::_should_terminate = false;
1229 WatcherThread::WatcherThread() : Thread(), _crash_protection(NULL) {
1230 assert(watcher_thread() == NULL, "we can only allocate one WatcherThread");
1231 if (os::create_thread(this, os::watcher_thread)) {
1232 _watcher_thread = this;
1234 // Set the watcher thread to the highest OS priority which should not be
1235 // used, unless a Java thread with priority java.lang.Thread.MAX_PRIORITY
1236 // is created. The only normal thread using this priority is the reference
1237 // handler thread, which runs for very short intervals only.
1238 // If the VMThread's priority is not lower than the WatcherThread profiling
1239 // will be inaccurate.
1240 os::set_priority(this, MaxPriority);
1241 if (!DisableStartThread) {
1242 os::start_thread(this);
1243 }
1244 }
1245 }
1247 int WatcherThread::sleep() const {
1248 MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
1250 // remaining will be zero if there are no tasks,
1251 // causing the WatcherThread to sleep until a task is
1252 // enrolled
1253 int remaining = PeriodicTask::time_to_wait();
1254 int time_slept = 0;
1256 // we expect this to timeout - we only ever get unparked when
1257 // we should terminate or when a new task has been enrolled
1258 OSThreadWaitState osts(this->osthread(), false /* not Object.wait() */);
1260 jlong time_before_loop = os::javaTimeNanos();
1262 for (;;) {
1263 bool timedout = PeriodicTask_lock->wait(Mutex::_no_safepoint_check_flag, remaining);
1264 jlong now = os::javaTimeNanos();
1266 if (remaining == 0) {
1267 // if we didn't have any tasks we could have waited for a long time
1268 // consider the time_slept zero and reset time_before_loop
1269 time_slept = 0;
1270 time_before_loop = now;
1271 } else {
1272 // need to recalulate since we might have new tasks in _tasks
1273 time_slept = (int) ((now - time_before_loop) / 1000000);
1274 }
1276 // Change to task list or spurious wakeup of some kind
1277 if (timedout || _should_terminate) {
1278 break;
1279 }
1281 remaining = PeriodicTask::time_to_wait();
1282 if (remaining == 0) {
1283 // Last task was just disenrolled so loop around and wait until
1284 // another task gets enrolled
1285 continue;
1286 }
1288 remaining -= time_slept;
1289 if (remaining <= 0)
1290 break;
1291 }
1293 return time_slept;
1294 }
1296 void WatcherThread::run() {
1297 assert(this == watcher_thread(), "just checking");
1299 this->record_stack_base_and_size();
1300 this->initialize_thread_local_storage();
1301 this->set_active_handles(JNIHandleBlock::allocate_block());
1302 while(!_should_terminate) {
1303 assert(watcher_thread() == Thread::current(), "thread consistency check");
1304 assert(watcher_thread() == this, "thread consistency check");
1306 // Calculate how long it'll be until the next PeriodicTask work
1307 // should be done, and sleep that amount of time.
1308 int time_waited = sleep();
1310 if (is_error_reported()) {
1311 // A fatal error has happened, the error handler(VMError::report_and_die)
1312 // should abort JVM after creating an error log file. However in some
1313 // rare cases, the error handler itself might deadlock. Here we try to
1314 // kill JVM if the fatal error handler fails to abort in 2 minutes.
1315 //
1316 // This code is in WatcherThread because WatcherThread wakes up
1317 // periodically so the fatal error handler doesn't need to do anything;
1318 // also because the WatcherThread is less likely to crash than other
1319 // threads.
1321 for (;;) {
1322 if (!ShowMessageBoxOnError
1323 && (OnError == NULL || OnError[0] == '\0')
1324 && Arguments::abort_hook() == NULL) {
1325 os::sleep(this, 2 * 60 * 1000, false);
1326 fdStream err(defaultStream::output_fd());
1327 err.print_raw_cr("# [ timer expired, abort... ]");
1328 // skip atexit/vm_exit/vm_abort hooks
1329 os::die();
1330 }
1332 // Wake up 5 seconds later, the fatal handler may reset OnError or
1333 // ShowMessageBoxOnError when it is ready to abort.
1334 os::sleep(this, 5 * 1000, false);
1335 }
1336 }
1338 PeriodicTask::real_time_tick(time_waited);
1339 }
1341 // Signal that it is terminated
1342 {
1343 MutexLockerEx mu(Terminator_lock, Mutex::_no_safepoint_check_flag);
1344 _watcher_thread = NULL;
1345 Terminator_lock->notify();
1346 }
1348 // Thread destructor usually does this..
1349 ThreadLocalStorage::set_thread(NULL);
1350 }
1352 void WatcherThread::start() {
1353 assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
1355 if (watcher_thread() == NULL && _startable) {
1356 _should_terminate = false;
1357 // Create the single instance of WatcherThread
1358 new WatcherThread();
1359 }
1360 }
1362 void WatcherThread::make_startable() {
1363 assert(PeriodicTask_lock->owned_by_self(), "PeriodicTask_lock required");
1364 _startable = true;
1365 }
1367 void WatcherThread::stop() {
1368 {
1369 MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
1370 _should_terminate = true;
1371 OrderAccess::fence(); // ensure WatcherThread sees update in main loop
1373 WatcherThread* watcher = watcher_thread();
1374 if (watcher != NULL)
1375 watcher->unpark();
1376 }
1378 // it is ok to take late safepoints here, if needed
1379 MutexLocker mu(Terminator_lock);
1381 while(watcher_thread() != NULL) {
1382 // This wait should make safepoint checks, wait without a timeout,
1383 // and wait as a suspend-equivalent condition.
1384 //
1385 // Note: If the FlatProfiler is running, then this thread is waiting
1386 // for the WatcherThread to terminate and the WatcherThread, via the
1387 // FlatProfiler task, is waiting for the external suspend request on
1388 // this thread to complete. wait_for_ext_suspend_completion() will
1389 // eventually timeout, but that takes time. Making this wait a
1390 // suspend-equivalent condition solves that timeout problem.
1391 //
1392 Terminator_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
1393 Mutex::_as_suspend_equivalent_flag);
1394 }
1395 }
1397 void WatcherThread::unpark() {
1398 MutexLockerEx ml(PeriodicTask_lock->owned_by_self() ? NULL : PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
1399 PeriodicTask_lock->notify();
1400 }
1402 void WatcherThread::print_on(outputStream* st) const {
1403 st->print("\"%s\" ", name());
1404 Thread::print_on(st);
1405 st->cr();
1406 }
1408 // ======= JavaThread ========
1410 // A JavaThread is a normal Java thread
1412 void JavaThread::initialize() {
1413 // Initialize fields
1415 // Set the claimed par_id to -1 (ie not claiming any par_ids)
1416 set_claimed_par_id(-1);
1418 set_saved_exception_pc(NULL);
1419 set_threadObj(NULL);
1420 _anchor.clear();
1421 set_entry_point(NULL);
1422 set_jni_functions(jni_functions());
1423 set_callee_target(NULL);
1424 set_vm_result(NULL);
1425 set_vm_result_2(NULL);
1426 set_vframe_array_head(NULL);
1427 set_vframe_array_last(NULL);
1428 set_deferred_locals(NULL);
1429 set_deopt_mark(NULL);
1430 set_deopt_nmethod(NULL);
1431 clear_must_deopt_id();
1432 set_monitor_chunks(NULL);
1433 set_next(NULL);
1434 set_thread_state(_thread_new);
1435 #if INCLUDE_NMT
1436 set_recorder(NULL);
1437 #endif
1438 _terminated = _not_terminated;
1439 _privileged_stack_top = NULL;
1440 _array_for_gc = NULL;
1441 _suspend_equivalent = false;
1442 _in_deopt_handler = 0;
1443 _doing_unsafe_access = false;
1444 _stack_guard_state = stack_guard_unused;
1445 _exception_oop = NULL;
1446 _exception_pc = 0;
1447 _exception_handler_pc = 0;
1448 _is_method_handle_return = 0;
1449 _jvmti_thread_state= NULL;
1450 _should_post_on_exceptions_flag = JNI_FALSE;
1451 _jvmti_get_loaded_classes_closure = NULL;
1452 _interp_only_mode = 0;
1453 _special_runtime_exit_condition = _no_async_condition;
1454 _pending_async_exception = NULL;
1455 _is_compiling = false;
1456 _thread_stat = NULL;
1457 _thread_stat = new ThreadStatistics();
1458 _blocked_on_compilation = false;
1459 _jni_active_critical = 0;
1460 _do_not_unlock_if_synchronized = false;
1461 _cached_monitor_info = NULL;
1462 _parker = Parker::Allocate(this) ;
1464 #ifndef PRODUCT
1465 _jmp_ring_index = 0;
1466 for (int ji = 0 ; ji < jump_ring_buffer_size ; ji++ ) {
1467 record_jump(NULL, NULL, NULL, 0);
1468 }
1469 #endif /* PRODUCT */
1471 set_thread_profiler(NULL);
1472 if (FlatProfiler::is_active()) {
1473 // This is where we would decide to either give each thread it's own profiler
1474 // or use one global one from FlatProfiler,
1475 // or up to some count of the number of profiled threads, etc.
1476 ThreadProfiler* pp = new ThreadProfiler();
1477 pp->engage();
1478 set_thread_profiler(pp);
1479 }
1481 // Setup safepoint state info for this thread
1482 ThreadSafepointState::create(this);
1484 debug_only(_java_call_counter = 0);
1486 // JVMTI PopFrame support
1487 _popframe_condition = popframe_inactive;
1488 _popframe_preserved_args = NULL;
1489 _popframe_preserved_args_size = 0;
1491 pd_initialize();
1492 }
1494 #if INCLUDE_ALL_GCS
1495 SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
1496 DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
1497 #endif // INCLUDE_ALL_GCS
1499 JavaThread::JavaThread(bool is_attaching_via_jni) :
1500 Thread()
1501 #if INCLUDE_ALL_GCS
1502 , _satb_mark_queue(&_satb_mark_queue_set),
1503 _dirty_card_queue(&_dirty_card_queue_set)
1504 #endif // INCLUDE_ALL_GCS
1505 {
1506 initialize();
1507 if (is_attaching_via_jni) {
1508 _jni_attach_state = _attaching_via_jni;
1509 } else {
1510 _jni_attach_state = _not_attaching_via_jni;
1511 }
1512 assert(deferred_card_mark().is_empty(), "Default MemRegion ctor");
1513 _safepoint_visible = false;
1514 }
1516 bool JavaThread::reguard_stack(address cur_sp) {
1517 if (_stack_guard_state != stack_guard_yellow_disabled) {
1518 return true; // Stack already guarded or guard pages not needed.
1519 }
1521 if (register_stack_overflow()) {
1522 // For those architectures which have separate register and
1523 // memory stacks, we must check the register stack to see if
1524 // it has overflowed.
1525 return false;
1526 }
1528 // Java code never executes within the yellow zone: the latter is only
1529 // there to provoke an exception during stack banging. If java code
1530 // is executing there, either StackShadowPages should be larger, or
1531 // some exception code in c1, c2 or the interpreter isn't unwinding
1532 // when it should.
1533 guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages");
1535 enable_stack_yellow_zone();
1536 return true;
1537 }
1539 bool JavaThread::reguard_stack(void) {
1540 return reguard_stack(os::current_stack_pointer());
1541 }
1544 void JavaThread::block_if_vm_exited() {
1545 if (_terminated == _vm_exited) {
1546 // _vm_exited is set at safepoint, and Threads_lock is never released
1547 // we will block here forever
1548 Threads_lock->lock_without_safepoint_check();
1549 ShouldNotReachHere();
1550 }
1551 }
1554 // Remove this ifdef when C1 is ported to the compiler interface.
1555 static void compiler_thread_entry(JavaThread* thread, TRAPS);
1557 JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
1558 Thread()
1559 #if INCLUDE_ALL_GCS
1560 , _satb_mark_queue(&_satb_mark_queue_set),
1561 _dirty_card_queue(&_dirty_card_queue_set)
1562 #endif // INCLUDE_ALL_GCS
1563 {
1564 if (TraceThreadEvents) {
1565 tty->print_cr("creating thread %p", this);
1566 }
1567 initialize();
1568 _jni_attach_state = _not_attaching_via_jni;
1569 set_entry_point(entry_point);
1570 // Create the native thread itself.
1571 // %note runtime_23
1572 os::ThreadType thr_type = os::java_thread;
1573 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread :
1574 os::java_thread;
1575 os::create_thread(this, thr_type, stack_sz);
1576 _safepoint_visible = false;
1577 // The _osthread may be NULL here because we ran out of memory (too many threads active).
1578 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller
1579 // may hold a lock and all locks must be unlocked before throwing the exception (throwing
1580 // the exception consists of creating the exception object & initializing it, initialization
1581 // will leave the VM via a JavaCall and then all locks must be unlocked).
1582 //
1583 // The thread is still suspended when we reach here. Thread must be explicit started
1584 // by creator! Furthermore, the thread must also explicitly be added to the Threads list
1585 // by calling Threads:add. The reason why this is not done here, is because the thread
1586 // object must be fully initialized (take a look at JVM_Start)
1587 }
1589 JavaThread::~JavaThread() {
1590 if (TraceThreadEvents) {
1591 tty->print_cr("terminate thread %p", this);
1592 }
1594 // By now, this thread should already be invisible to safepoint,
1595 // and its per-thread recorder also collected.
1596 assert(!is_safepoint_visible(), "wrong state");
1597 #if INCLUDE_NMT
1598 assert(get_recorder() == NULL, "Already collected");
1599 #endif // INCLUDE_NMT
1601 // JSR166 -- return the parker to the free list
1602 Parker::Release(_parker);
1603 _parker = NULL ;
1605 // Free any remaining previous UnrollBlock
1606 vframeArray* old_array = vframe_array_last();
1608 if (old_array != NULL) {
1609 Deoptimization::UnrollBlock* old_info = old_array->unroll_block();
1610 old_array->set_unroll_block(NULL);
1611 delete old_info;
1612 delete old_array;
1613 }
1615 GrowableArray<jvmtiDeferredLocalVariableSet*>* deferred = deferred_locals();
1616 if (deferred != NULL) {
1617 // This can only happen if thread is destroyed before deoptimization occurs.
1618 assert(deferred->length() != 0, "empty array!");
1619 do {
1620 jvmtiDeferredLocalVariableSet* dlv = deferred->at(0);
1621 deferred->remove_at(0);
1622 // individual jvmtiDeferredLocalVariableSet are CHeapObj's
1623 delete dlv;
1624 } while (deferred->length() != 0);
1625 delete deferred;
1626 }
1628 // All Java related clean up happens in exit
1629 ThreadSafepointState::destroy(this);
1630 if (_thread_profiler != NULL) delete _thread_profiler;
1631 if (_thread_stat != NULL) delete _thread_stat;
1632 }
1635 // The first routine called by a new Java thread
1636 void JavaThread::run() {
1637 // initialize thread-local alloc buffer related fields
1638 this->initialize_tlab();
1640 // used to test validitity of stack trace backs
1641 this->record_base_of_stack_pointer();
1643 // Record real stack base and size.
1644 this->record_stack_base_and_size();
1646 // Initialize thread local storage; set before calling MutexLocker
1647 this->initialize_thread_local_storage();
1649 this->create_stack_guard_pages();
1651 this->cache_global_variables();
1653 // Thread is now sufficient initialized to be handled by the safepoint code as being
1654 // in the VM. Change thread state from _thread_new to _thread_in_vm
1655 ThreadStateTransition::transition_and_fence(this, _thread_new, _thread_in_vm);
1657 assert(JavaThread::current() == this, "sanity check");
1658 assert(!Thread::current()->owns_locks(), "sanity check");
1660 DTRACE_THREAD_PROBE(start, this);
1662 // This operation might block. We call that after all safepoint checks for a new thread has
1663 // been completed.
1664 this->set_active_handles(JNIHandleBlock::allocate_block());
1666 if (JvmtiExport::should_post_thread_life()) {
1667 JvmtiExport::post_thread_start(this);
1668 }
1670 EventThreadStart event;
1671 if (event.should_commit()) {
1672 event.set_javalangthread(java_lang_Thread::thread_id(this->threadObj()));
1673 event.commit();
1674 }
1676 // We call another function to do the rest so we are sure that the stack addresses used
1677 // from there will be lower than the stack base just computed
1678 thread_main_inner();
1680 // Note, thread is no longer valid at this point!
1681 }
1684 void JavaThread::thread_main_inner() {
1685 assert(JavaThread::current() == this, "sanity check");
1686 assert(this->threadObj() != NULL, "just checking");
1688 // Execute thread entry point unless this thread has a pending exception
1689 // or has been stopped before starting.
1690 // Note: Due to JVM_StopThread we can have pending exceptions already!
1691 if (!this->has_pending_exception() &&
1692 !java_lang_Thread::is_stillborn(this->threadObj())) {
1693 {
1694 ResourceMark rm(this);
1695 this->set_native_thread_name(this->get_thread_name());
1696 }
1697 HandleMark hm(this);
1698 this->entry_point()(this, this);
1699 }
1701 DTRACE_THREAD_PROBE(stop, this);
1703 this->exit(false);
1704 delete this;
1705 }
1708 static void ensure_join(JavaThread* thread) {
1709 // We do not need to grap the Threads_lock, since we are operating on ourself.
1710 Handle threadObj(thread, thread->threadObj());
1711 assert(threadObj.not_null(), "java thread object must exist");
1712 ObjectLocker lock(threadObj, thread);
1713 // Ignore pending exception (ThreadDeath), since we are exiting anyway
1714 thread->clear_pending_exception();
1715 // Thread is exiting. So set thread_status field in java.lang.Thread class to TERMINATED.
1716 java_lang_Thread::set_thread_status(threadObj(), java_lang_Thread::TERMINATED);
1717 // Clear the native thread instance - this makes isAlive return false and allows the join()
1718 // to complete once we've done the notify_all below
1719 java_lang_Thread::set_thread(threadObj(), NULL);
1720 lock.notify_all(thread);
1721 // Ignore pending exception (ThreadDeath), since we are exiting anyway
1722 thread->clear_pending_exception();
1723 }
1726 // For any new cleanup additions, please check to see if they need to be applied to
1727 // cleanup_failed_attach_current_thread as well.
1728 void JavaThread::exit(bool destroy_vm, ExitType exit_type) {
1729 assert(this == JavaThread::current(), "thread consistency check");
1731 HandleMark hm(this);
1732 Handle uncaught_exception(this, this->pending_exception());
1733 this->clear_pending_exception();
1734 Handle threadObj(this, this->threadObj());
1735 assert(threadObj.not_null(), "Java thread object should be created");
1737 if (get_thread_profiler() != NULL) {
1738 get_thread_profiler()->disengage();
1739 ResourceMark rm;
1740 get_thread_profiler()->print(get_thread_name());
1741 }
1744 // FIXIT: This code should be moved into else part, when reliable 1.2/1.3 check is in place
1745 {
1746 EXCEPTION_MARK;
1748 CLEAR_PENDING_EXCEPTION;
1749 }
1750 // FIXIT: The is_null check is only so it works better on JDK1.2 VM's. This
1751 // has to be fixed by a runtime query method
1752 if (!destroy_vm || JDK_Version::is_jdk12x_version()) {
1753 // JSR-166: change call from from ThreadGroup.uncaughtException to
1754 // java.lang.Thread.dispatchUncaughtException
1755 if (uncaught_exception.not_null()) {
1756 Handle group(this, java_lang_Thread::threadGroup(threadObj()));
1757 {
1758 EXCEPTION_MARK;
1759 // Check if the method Thread.dispatchUncaughtException() exists. If so
1760 // call it. Otherwise we have an older library without the JSR-166 changes,
1761 // so call ThreadGroup.uncaughtException()
1762 KlassHandle recvrKlass(THREAD, threadObj->klass());
1763 CallInfo callinfo;
1764 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
1765 LinkResolver::resolve_virtual_call(callinfo, threadObj, recvrKlass, thread_klass,
1766 vmSymbols::dispatchUncaughtException_name(),
1767 vmSymbols::throwable_void_signature(),
1768 KlassHandle(), false, false, THREAD);
1769 CLEAR_PENDING_EXCEPTION;
1770 methodHandle method = callinfo.selected_method();
1771 if (method.not_null()) {
1772 JavaValue result(T_VOID);
1773 JavaCalls::call_virtual(&result,
1774 threadObj, thread_klass,
1775 vmSymbols::dispatchUncaughtException_name(),
1776 vmSymbols::throwable_void_signature(),
1777 uncaught_exception,
1778 THREAD);
1779 } else {
1780 KlassHandle thread_group(THREAD, SystemDictionary::ThreadGroup_klass());
1781 JavaValue result(T_VOID);
1782 JavaCalls::call_virtual(&result,
1783 group, thread_group,
1784 vmSymbols::uncaughtException_name(),
1785 vmSymbols::thread_throwable_void_signature(),
1786 threadObj, // Arg 1
1787 uncaught_exception, // Arg 2
1788 THREAD);
1789 }
1790 if (HAS_PENDING_EXCEPTION) {
1791 ResourceMark rm(this);
1792 jio_fprintf(defaultStream::error_stream(),
1793 "\nException: %s thrown from the UncaughtExceptionHandler"
1794 " in thread \"%s\"\n",
1795 pending_exception()->klass()->external_name(),
1796 get_thread_name());
1797 CLEAR_PENDING_EXCEPTION;
1798 }
1799 }
1800 }
1802 // Called before the java thread exit since we want to read info
1803 // from java_lang_Thread object
1804 EventThreadEnd event;
1805 if (event.should_commit()) {
1806 event.set_javalangthread(java_lang_Thread::thread_id(this->threadObj()));
1807 event.commit();
1808 }
1810 // Call after last event on thread
1811 EVENT_THREAD_EXIT(this);
1813 // Call Thread.exit(). We try 3 times in case we got another Thread.stop during
1814 // the execution of the method. If that is not enough, then we don't really care. Thread.stop
1815 // is deprecated anyhow.
1816 { int count = 3;
1817 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
1818 EXCEPTION_MARK;
1819 JavaValue result(T_VOID);
1820 KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
1821 JavaCalls::call_virtual(&result,
1822 threadObj, thread_klass,
1823 vmSymbols::exit_method_name(),
1824 vmSymbols::void_method_signature(),
1825 THREAD);
1826 CLEAR_PENDING_EXCEPTION;
1827 }
1828 }
1830 // notify JVMTI
1831 if (JvmtiExport::should_post_thread_life()) {
1832 JvmtiExport::post_thread_end(this);
1833 }
1835 // We have notified the agents that we are exiting, before we go on,
1836 // we must check for a pending external suspend request and honor it
1837 // in order to not surprise the thread that made the suspend request.
1838 while (true) {
1839 {
1840 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
1841 if (!is_external_suspend()) {
1842 set_terminated(_thread_exiting);
1843 ThreadService::current_thread_exiting(this);
1844 break;
1845 }
1846 // Implied else:
1847 // Things get a little tricky here. We have a pending external
1848 // suspend request, but we are holding the SR_lock so we
1849 // can't just self-suspend. So we temporarily drop the lock
1850 // and then self-suspend.
1851 }
1853 ThreadBlockInVM tbivm(this);
1854 java_suspend_self();
1856 // We're done with this suspend request, but we have to loop around
1857 // and check again. Eventually we will get SR_lock without a pending
1858 // external suspend request and will be able to mark ourselves as
1859 // exiting.
1860 }
1861 // no more external suspends are allowed at this point
1862 } else {
1863 // before_exit() has already posted JVMTI THREAD_END events
1864 }
1866 // Notify waiters on thread object. This has to be done after exit() is called
1867 // on the thread (if the thread is the last thread in a daemon ThreadGroup the
1868 // group should have the destroyed bit set before waiters are notified).
1869 ensure_join(this);
1870 assert(!this->has_pending_exception(), "ensure_join should have cleared");
1872 // 6282335 JNI DetachCurrentThread spec states that all Java monitors
1873 // held by this thread must be released. A detach operation must only
1874 // get here if there are no Java frames on the stack. Therefore, any
1875 // owned monitors at this point MUST be JNI-acquired monitors which are
1876 // pre-inflated and in the monitor cache.
1877 //
1878 // ensure_join() ignores IllegalThreadStateExceptions, and so does this.
1879 if (exit_type == jni_detach && JNIDetachReleasesMonitors) {
1880 assert(!this->has_last_Java_frame(), "detaching with Java frames?");
1881 ObjectSynchronizer::release_monitors_owned_by_thread(this);
1882 assert(!this->has_pending_exception(), "release_monitors should have cleared");
1883 }
1885 // These things needs to be done while we are still a Java Thread. Make sure that thread
1886 // is in a consistent state, in case GC happens
1887 assert(_privileged_stack_top == NULL, "must be NULL when we get here");
1889 if (active_handles() != NULL) {
1890 JNIHandleBlock* block = active_handles();
1891 set_active_handles(NULL);
1892 JNIHandleBlock::release_block(block);
1893 }
1895 if (free_handle_block() != NULL) {
1896 JNIHandleBlock* block = free_handle_block();
1897 set_free_handle_block(NULL);
1898 JNIHandleBlock::release_block(block);
1899 }
1901 // These have to be removed while this is still a valid thread.
1902 remove_stack_guard_pages();
1904 if (UseTLAB) {
1905 tlab().make_parsable(true); // retire TLAB
1906 }
1908 if (JvmtiEnv::environments_might_exist()) {
1909 JvmtiExport::cleanup_thread(this);
1910 }
1912 // We must flush any deferred card marks before removing a thread from
1913 // the list of active threads.
1914 Universe::heap()->flush_deferred_store_barrier(this);
1915 assert(deferred_card_mark().is_empty(), "Should have been flushed");
1917 #if INCLUDE_ALL_GCS
1918 // We must flush the G1-related buffers before removing a thread
1919 // from the list of active threads. We must do this after any deferred
1920 // card marks have been flushed (above) so that any entries that are
1921 // added to the thread's dirty card queue as a result are not lost.
1922 if (UseG1GC) {
1923 flush_barrier_queues();
1924 }
1925 #endif // INCLUDE_ALL_GCS
1927 // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
1928 Threads::remove(this);
1929 }
1931 #if INCLUDE_ALL_GCS
1932 // Flush G1-related queues.
1933 void JavaThread::flush_barrier_queues() {
1934 satb_mark_queue().flush();
1935 dirty_card_queue().flush();
1936 }
1938 void JavaThread::initialize_queues() {
1939 assert(!SafepointSynchronize::is_at_safepoint(),
1940 "we should not be at a safepoint");
1942 ObjPtrQueue& satb_queue = satb_mark_queue();
1943 SATBMarkQueueSet& satb_queue_set = satb_mark_queue_set();
1944 // The SATB queue should have been constructed with its active
1945 // field set to false.
1946 assert(!satb_queue.is_active(), "SATB queue should not be active");
1947 assert(satb_queue.is_empty(), "SATB queue should be empty");
1948 // If we are creating the thread during a marking cycle, we should
1949 // set the active field of the SATB queue to true.
1950 if (satb_queue_set.is_active()) {
1951 satb_queue.set_active(true);
1952 }
1954 DirtyCardQueue& dirty_queue = dirty_card_queue();
1955 // The dirty card queue should have been constructed with its
1956 // active field set to true.
1957 assert(dirty_queue.is_active(), "dirty card queue should be active");
1958 }
1959 #endif // INCLUDE_ALL_GCS
1961 void JavaThread::cleanup_failed_attach_current_thread() {
1962 if (get_thread_profiler() != NULL) {
1963 get_thread_profiler()->disengage();
1964 ResourceMark rm;
1965 get_thread_profiler()->print(get_thread_name());
1966 }
1968 if (active_handles() != NULL) {
1969 JNIHandleBlock* block = active_handles();
1970 set_active_handles(NULL);
1971 JNIHandleBlock::release_block(block);
1972 }
1974 if (free_handle_block() != NULL) {
1975 JNIHandleBlock* block = free_handle_block();
1976 set_free_handle_block(NULL);
1977 JNIHandleBlock::release_block(block);
1978 }
1980 // These have to be removed while this is still a valid thread.
1981 remove_stack_guard_pages();
1983 if (UseTLAB) {
1984 tlab().make_parsable(true); // retire TLAB, if any
1985 }
1987 #if INCLUDE_ALL_GCS
1988 if (UseG1GC) {
1989 flush_barrier_queues();
1990 }
1991 #endif // INCLUDE_ALL_GCS
1993 Threads::remove(this);
1994 delete this;
1995 }
2000 JavaThread* JavaThread::active() {
2001 Thread* thread = ThreadLocalStorage::thread();
2002 assert(thread != NULL, "just checking");
2003 if (thread->is_Java_thread()) {
2004 return (JavaThread*) thread;
2005 } else {
2006 assert(thread->is_VM_thread(), "this must be a vm thread");
2007 VM_Operation* op = ((VMThread*) thread)->vm_operation();
2008 JavaThread *ret=op == NULL ? NULL : (JavaThread *)op->calling_thread();
2009 assert(ret->is_Java_thread(), "must be a Java thread");
2010 return ret;
2011 }
2012 }
2014 bool JavaThread::is_lock_owned(address adr) const {
2015 if (Thread::is_lock_owned(adr)) return true;
2017 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
2018 if (chunk->contains(adr)) return true;
2019 }
2021 return false;
2022 }
2025 void JavaThread::add_monitor_chunk(MonitorChunk* chunk) {
2026 chunk->set_next(monitor_chunks());
2027 set_monitor_chunks(chunk);
2028 }
2030 void JavaThread::remove_monitor_chunk(MonitorChunk* chunk) {
2031 guarantee(monitor_chunks() != NULL, "must be non empty");
2032 if (monitor_chunks() == chunk) {
2033 set_monitor_chunks(chunk->next());
2034 } else {
2035 MonitorChunk* prev = monitor_chunks();
2036 while (prev->next() != chunk) prev = prev->next();
2037 prev->set_next(chunk->next());
2038 }
2039 }
2041 // JVM support.
2043 // Note: this function shouldn't block if it's called in
2044 // _thread_in_native_trans state (such as from
2045 // check_special_condition_for_native_trans()).
2046 void JavaThread::check_and_handle_async_exceptions(bool check_unsafe_error) {
2048 if (has_last_Java_frame() && has_async_condition()) {
2049 // If we are at a polling page safepoint (not a poll return)
2050 // then we must defer async exception because live registers
2051 // will be clobbered by the exception path. Poll return is
2052 // ok because the call we a returning from already collides
2053 // with exception handling registers and so there is no issue.
2054 // (The exception handling path kills call result registers but
2055 // this is ok since the exception kills the result anyway).
2057 if (is_at_poll_safepoint()) {
2058 // if the code we are returning to has deoptimized we must defer
2059 // the exception otherwise live registers get clobbered on the
2060 // exception path before deoptimization is able to retrieve them.
2061 //
2062 RegisterMap map(this, false);
2063 frame caller_fr = last_frame().sender(&map);
2064 assert(caller_fr.is_compiled_frame(), "what?");
2065 if (caller_fr.is_deoptimized_frame()) {
2066 if (TraceExceptions) {
2067 ResourceMark rm;
2068 tty->print_cr("deferred async exception at compiled safepoint");
2069 }
2070 return;
2071 }
2072 }
2073 }
2075 JavaThread::AsyncRequests condition = clear_special_runtime_exit_condition();
2076 if (condition == _no_async_condition) {
2077 // Conditions have changed since has_special_runtime_exit_condition()
2078 // was called:
2079 // - if we were here only because of an external suspend request,
2080 // then that was taken care of above (or cancelled) so we are done
2081 // - if we were here because of another async request, then it has
2082 // been cleared between the has_special_runtime_exit_condition()
2083 // and now so again we are done
2084 return;
2085 }
2087 // Check for pending async. exception
2088 if (_pending_async_exception != NULL) {
2089 // Only overwrite an already pending exception, if it is not a threadDeath.
2090 if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())) {
2092 // We cannot call Exceptions::_throw(...) here because we cannot block
2093 set_pending_exception(_pending_async_exception, __FILE__, __LINE__);
2095 if (TraceExceptions) {
2096 ResourceMark rm;
2097 tty->print("Async. exception installed at runtime exit (" INTPTR_FORMAT ")", this);
2098 if (has_last_Java_frame() ) {
2099 frame f = last_frame();
2100 tty->print(" (pc: " INTPTR_FORMAT " sp: " INTPTR_FORMAT " )", f.pc(), f.sp());
2101 }
2102 tty->print_cr(" of type: %s", InstanceKlass::cast(_pending_async_exception->klass())->external_name());
2103 }
2104 _pending_async_exception = NULL;
2105 clear_has_async_exception();
2106 }
2107 }
2109 if (check_unsafe_error &&
2110 condition == _async_unsafe_access_error && !has_pending_exception()) {
2111 condition = _no_async_condition; // done
2112 switch (thread_state()) {
2113 case _thread_in_vm:
2114 {
2115 JavaThread* THREAD = this;
2116 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
2117 }
2118 case _thread_in_native:
2119 {
2120 ThreadInVMfromNative tiv(this);
2121 JavaThread* THREAD = this;
2122 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
2123 }
2124 case _thread_in_Java:
2125 {
2126 ThreadInVMfromJava tiv(this);
2127 JavaThread* THREAD = this;
2128 THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code");
2129 }
2130 default:
2131 ShouldNotReachHere();
2132 }
2133 }
2135 assert(condition == _no_async_condition || has_pending_exception() ||
2136 (!check_unsafe_error && condition == _async_unsafe_access_error),
2137 "must have handled the async condition, if no exception");
2138 }
2140 void JavaThread::handle_special_runtime_exit_condition(bool check_asyncs) {
2141 //
2142 // Check for pending external suspend. Internal suspend requests do
2143 // not use handle_special_runtime_exit_condition().
2144 // If JNIEnv proxies are allowed, don't self-suspend if the target
2145 // thread is not the current thread. In older versions of jdbx, jdbx
2146 // threads could call into the VM with another thread's JNIEnv so we
2147 // can be here operating on behalf of a suspended thread (4432884).
2148 bool do_self_suspend = is_external_suspend_with_lock();
2149 if (do_self_suspend && (!AllowJNIEnvProxy || this == JavaThread::current())) {
2150 //
2151 // Because thread is external suspended the safepoint code will count
2152 // thread as at a safepoint. This can be odd because we can be here
2153 // as _thread_in_Java which would normally transition to _thread_blocked
2154 // at a safepoint. We would like to mark the thread as _thread_blocked
2155 // before calling java_suspend_self like all other callers of it but
2156 // we must then observe proper safepoint protocol. (We can't leave
2157 // _thread_blocked with a safepoint in progress). However we can be
2158 // here as _thread_in_native_trans so we can't use a normal transition
2159 // constructor/destructor pair because they assert on that type of
2160 // transition. We could do something like:
2161 //
2162 // JavaThreadState state = thread_state();
2163 // set_thread_state(_thread_in_vm);
2164 // {
2165 // ThreadBlockInVM tbivm(this);
2166 // java_suspend_self()
2167 // }
2168 // set_thread_state(_thread_in_vm_trans);
2169 // if (safepoint) block;
2170 // set_thread_state(state);
2171 //
2172 // but that is pretty messy. Instead we just go with the way the
2173 // code has worked before and note that this is the only path to
2174 // java_suspend_self that doesn't put the thread in _thread_blocked
2175 // mode.
2177 frame_anchor()->make_walkable(this);
2178 java_suspend_self();
2180 // We might be here for reasons in addition to the self-suspend request
2181 // so check for other async requests.
2182 }
2184 if (check_asyncs) {
2185 check_and_handle_async_exceptions();
2186 }
2187 }
2189 void JavaThread::send_thread_stop(oop java_throwable) {
2190 assert(Thread::current()->is_VM_thread(), "should be in the vm thread");
2191 assert(Threads_lock->is_locked(), "Threads_lock should be locked by safepoint code");
2192 assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
2194 // Do not throw asynchronous exceptions against the compiler thread
2195 // (the compiler thread should not be a Java thread -- fix in 1.4.2)
2196 if (is_Compiler_thread()) return;
2198 {
2199 // Actually throw the Throwable against the target Thread - however
2200 // only if there is no thread death exception installed already.
2201 if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::ThreadDeath_klass())) {
2202 // If the topmost frame is a runtime stub, then we are calling into
2203 // OptoRuntime from compiled code. Some runtime stubs (new, monitor_exit..)
2204 // must deoptimize the caller before continuing, as the compiled exception handler table
2205 // may not be valid
2206 if (has_last_Java_frame()) {
2207 frame f = last_frame();
2208 if (f.is_runtime_frame() || f.is_safepoint_blob_frame()) {
2209 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
2210 RegisterMap reg_map(this, UseBiasedLocking);
2211 frame compiled_frame = f.sender(®_map);
2212 if (!StressCompiledExceptionHandlers && compiled_frame.can_be_deoptimized()) {
2213 Deoptimization::deoptimize(this, compiled_frame, ®_map);
2214 }
2215 }
2216 }
2218 // Set async. pending exception in thread.
2219 set_pending_async_exception(java_throwable);
2221 if (TraceExceptions) {
2222 ResourceMark rm;
2223 tty->print_cr("Pending Async. exception installed of type: %s", InstanceKlass::cast(_pending_async_exception->klass())->external_name());
2224 }
2225 // for AbortVMOnException flag
2226 NOT_PRODUCT(Exceptions::debug_check_abort(InstanceKlass::cast(_pending_async_exception->klass())->external_name()));
2227 }
2228 }
2231 // Interrupt thread so it will wake up from a potential wait()
2232 Thread::interrupt(this);
2233 }
2235 // External suspension mechanism.
2236 //
2237 // Tell the VM to suspend a thread when ever it knows that it does not hold on
2238 // to any VM_locks and it is at a transition
2239 // Self-suspension will happen on the transition out of the vm.
2240 // Catch "this" coming in from JNIEnv pointers when the thread has been freed
2241 //
2242 // Guarantees on return:
2243 // + Target thread will not execute any new bytecode (that's why we need to
2244 // force a safepoint)
2245 // + Target thread will not enter any new monitors
2246 //
2247 void JavaThread::java_suspend() {
2248 { MutexLocker mu(Threads_lock);
2249 if (!Threads::includes(this) || is_exiting() || this->threadObj() == NULL) {
2250 return;
2251 }
2252 }
2254 { MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
2255 if (!is_external_suspend()) {
2256 // a racing resume has cancelled us; bail out now
2257 return;
2258 }
2260 // suspend is done
2261 uint32_t debug_bits = 0;
2262 // Warning: is_ext_suspend_completed() may temporarily drop the
2263 // SR_lock to allow the thread to reach a stable thread state if
2264 // it is currently in a transient thread state.
2265 if (is_ext_suspend_completed(false /* !called_by_wait */,
2266 SuspendRetryDelay, &debug_bits) ) {
2267 return;
2268 }
2269 }
2271 VM_ForceSafepoint vm_suspend;
2272 VMThread::execute(&vm_suspend);
2273 }
2275 // Part II of external suspension.
2276 // A JavaThread self suspends when it detects a pending external suspend
2277 // request. This is usually on transitions. It is also done in places
2278 // where continuing to the next transition would surprise the caller,
2279 // e.g., monitor entry.
2280 //
2281 // Returns the number of times that the thread self-suspended.
2282 //
2283 // Note: DO NOT call java_suspend_self() when you just want to block current
2284 // thread. java_suspend_self() is the second stage of cooperative
2285 // suspension for external suspend requests and should only be used
2286 // to complete an external suspend request.
2287 //
2288 int JavaThread::java_suspend_self() {
2289 int ret = 0;
2291 // we are in the process of exiting so don't suspend
2292 if (is_exiting()) {
2293 clear_external_suspend();
2294 return ret;
2295 }
2297 assert(_anchor.walkable() ||
2298 (is_Java_thread() && !((JavaThread*)this)->has_last_Java_frame()),
2299 "must have walkable stack");
2301 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
2303 assert(!this->is_ext_suspended(),
2304 "a thread trying to self-suspend should not already be suspended");
2306 if (this->is_suspend_equivalent()) {
2307 // If we are self-suspending as a result of the lifting of a
2308 // suspend equivalent condition, then the suspend_equivalent
2309 // flag is not cleared until we set the ext_suspended flag so
2310 // that wait_for_ext_suspend_completion() returns consistent
2311 // results.
2312 this->clear_suspend_equivalent();
2313 }
2315 // A racing resume may have cancelled us before we grabbed SR_lock
2316 // above. Or another external suspend request could be waiting for us
2317 // by the time we return from SR_lock()->wait(). The thread
2318 // that requested the suspension may already be trying to walk our
2319 // stack and if we return now, we can change the stack out from under
2320 // it. This would be a "bad thing (TM)" and cause the stack walker
2321 // to crash. We stay self-suspended until there are no more pending
2322 // external suspend requests.
2323 while (is_external_suspend()) {
2324 ret++;
2325 this->set_ext_suspended();
2327 // _ext_suspended flag is cleared by java_resume()
2328 while (is_ext_suspended()) {
2329 this->SR_lock()->wait(Mutex::_no_safepoint_check_flag);
2330 }
2331 }
2333 return ret;
2334 }
2336 #ifdef ASSERT
2337 // verify the JavaThread has not yet been published in the Threads::list, and
2338 // hence doesn't need protection from concurrent access at this stage
2339 void JavaThread::verify_not_published() {
2340 if (!Threads_lock->owned_by_self()) {
2341 MutexLockerEx ml(Threads_lock, Mutex::_no_safepoint_check_flag);
2342 assert( !Threads::includes(this),
2343 "java thread shouldn't have been published yet!");
2344 }
2345 else {
2346 assert( !Threads::includes(this),
2347 "java thread shouldn't have been published yet!");
2348 }
2349 }
2350 #endif
2352 // Slow path when the native==>VM/Java barriers detect a safepoint is in
2353 // progress or when _suspend_flags is non-zero.
2354 // Current thread needs to self-suspend if there is a suspend request and/or
2355 // block if a safepoint is in progress.
2356 // Async exception ISN'T checked.
2357 // Note only the ThreadInVMfromNative transition can call this function
2358 // directly and when thread state is _thread_in_native_trans
2359 void JavaThread::check_safepoint_and_suspend_for_native_trans(JavaThread *thread) {
2360 assert(thread->thread_state() == _thread_in_native_trans, "wrong state");
2362 JavaThread *curJT = JavaThread::current();
2363 bool do_self_suspend = thread->is_external_suspend();
2365 assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition");
2367 // If JNIEnv proxies are allowed, don't self-suspend if the target
2368 // thread is not the current thread. In older versions of jdbx, jdbx
2369 // threads could call into the VM with another thread's JNIEnv so we
2370 // can be here operating on behalf of a suspended thread (4432884).
2371 if (do_self_suspend && (!AllowJNIEnvProxy || curJT == thread)) {
2372 JavaThreadState state = thread->thread_state();
2374 // We mark this thread_blocked state as a suspend-equivalent so
2375 // that a caller to is_ext_suspend_completed() won't be confused.
2376 // The suspend-equivalent state is cleared by java_suspend_self().
2377 thread->set_suspend_equivalent();
2379 // If the safepoint code sees the _thread_in_native_trans state, it will
2380 // wait until the thread changes to other thread state. There is no
2381 // guarantee on how soon we can obtain the SR_lock and complete the
2382 // self-suspend request. It would be a bad idea to let safepoint wait for
2383 // too long. Temporarily change the state to _thread_blocked to
2384 // let the VM thread know that this thread is ready for GC. The problem
2385 // of changing thread state is that safepoint could happen just after
2386 // java_suspend_self() returns after being resumed, and VM thread will
2387 // see the _thread_blocked state. We must check for safepoint
2388 // after restoring the state and make sure we won't leave while a safepoint
2389 // is in progress.
2390 thread->set_thread_state(_thread_blocked);
2391 thread->java_suspend_self();
2392 thread->set_thread_state(state);
2393 // Make sure new state is seen by VM thread
2394 if (os::is_MP()) {
2395 if (UseMembar) {
2396 // Force a fence between the write above and read below
2397 OrderAccess::fence();
2398 } else {
2399 // Must use this rather than serialization page in particular on Windows
2400 InterfaceSupport::serialize_memory(thread);
2401 }
2402 }
2403 }
2405 if (SafepointSynchronize::do_call_back()) {
2406 // If we are safepointing, then block the caller which may not be
2407 // the same as the target thread (see above).
2408 SafepointSynchronize::block(curJT);
2409 }
2411 if (thread->is_deopt_suspend()) {
2412 thread->clear_deopt_suspend();
2413 RegisterMap map(thread, false);
2414 frame f = thread->last_frame();
2415 while ( f.id() != thread->must_deopt_id() && ! f.is_first_frame()) {
2416 f = f.sender(&map);
2417 }
2418 if (f.id() == thread->must_deopt_id()) {
2419 thread->clear_must_deopt_id();
2420 f.deoptimize(thread);
2421 } else {
2422 fatal("missed deoptimization!");
2423 }
2424 }
2425 }
2427 // Slow path when the native==>VM/Java barriers detect a safepoint is in
2428 // progress or when _suspend_flags is non-zero.
2429 // Current thread needs to self-suspend if there is a suspend request and/or
2430 // block if a safepoint is in progress.
2431 // Also check for pending async exception (not including unsafe access error).
2432 // Note only the native==>VM/Java barriers can call this function and when
2433 // thread state is _thread_in_native_trans.
2434 void JavaThread::check_special_condition_for_native_trans(JavaThread *thread) {
2435 check_safepoint_and_suspend_for_native_trans(thread);
2437 if (thread->has_async_exception()) {
2438 // We are in _thread_in_native_trans state, don't handle unsafe
2439 // access error since that may block.
2440 thread->check_and_handle_async_exceptions(false);
2441 }
2442 }
2444 // This is a variant of the normal
2445 // check_special_condition_for_native_trans with slightly different
2446 // semantics for use by critical native wrappers. It does all the
2447 // normal checks but also performs the transition back into
2448 // thread_in_Java state. This is required so that critical natives
2449 // can potentially block and perform a GC if they are the last thread
2450 // exiting the GC_locker.
2451 void JavaThread::check_special_condition_for_native_trans_and_transition(JavaThread *thread) {
2452 check_special_condition_for_native_trans(thread);
2454 // Finish the transition
2455 thread->set_thread_state(_thread_in_Java);
2457 if (thread->do_critical_native_unlock()) {
2458 ThreadInVMfromJavaNoAsyncException tiv(thread);
2459 GC_locker::unlock_critical(thread);
2460 thread->clear_critical_native_unlock();
2461 }
2462 }
2464 // We need to guarantee the Threads_lock here, since resumes are not
2465 // allowed during safepoint synchronization
2466 // Can only resume from an external suspension
2467 void JavaThread::java_resume() {
2468 assert_locked_or_safepoint(Threads_lock);
2470 // Sanity check: thread is gone, has started exiting or the thread
2471 // was not externally suspended.
2472 if (!Threads::includes(this) || is_exiting() || !is_external_suspend()) {
2473 return;
2474 }
2476 MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
2478 clear_external_suspend();
2480 if (is_ext_suspended()) {
2481 clear_ext_suspended();
2482 SR_lock()->notify_all();
2483 }
2484 }
2486 void JavaThread::create_stack_guard_pages() {
2487 if (! os::uses_stack_guard_pages() || _stack_guard_state != stack_guard_unused) return;
2488 address low_addr = stack_base() - stack_size();
2489 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
2491 int allocate = os::allocate_stack_guard_pages();
2492 // warning("Guarding at " PTR_FORMAT " for len " SIZE_FORMAT "\n", low_addr, len);
2494 if (allocate && !os::create_stack_guard_pages((char *) low_addr, len)) {
2495 warning("Attempt to allocate stack guard pages failed.");
2496 return;
2497 }
2499 if (os::guard_memory((char *) low_addr, len)) {
2500 _stack_guard_state = stack_guard_enabled;
2501 } else {
2502 warning("Attempt to protect stack guard pages failed.");
2503 if (os::uncommit_memory((char *) low_addr, len)) {
2504 warning("Attempt to deallocate stack guard pages failed.");
2505 }
2506 }
2507 }
2509 void JavaThread::remove_stack_guard_pages() {
2510 assert(Thread::current() == this, "from different thread");
2511 if (_stack_guard_state == stack_guard_unused) return;
2512 address low_addr = stack_base() - stack_size();
2513 size_t len = (StackYellowPages + StackRedPages) * os::vm_page_size();
2515 if (os::allocate_stack_guard_pages()) {
2516 if (os::remove_stack_guard_pages((char *) low_addr, len)) {
2517 _stack_guard_state = stack_guard_unused;
2518 } else {
2519 warning("Attempt to deallocate stack guard pages failed.");
2520 }
2521 } else {
2522 if (_stack_guard_state == stack_guard_unused) return;
2523 if (os::unguard_memory((char *) low_addr, len)) {
2524 _stack_guard_state = stack_guard_unused;
2525 } else {
2526 warning("Attempt to unprotect stack guard pages failed.");
2527 }
2528 }
2529 }
2531 void JavaThread::enable_stack_yellow_zone() {
2532 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2533 assert(_stack_guard_state != stack_guard_enabled, "already enabled");
2535 // The base notation is from the stacks point of view, growing downward.
2536 // We need to adjust it to work correctly with guard_memory()
2537 address base = stack_yellow_zone_base() - stack_yellow_zone_size();
2539 guarantee(base < stack_base(),"Error calculating stack yellow zone");
2540 guarantee(base < os::current_stack_pointer(),"Error calculating stack yellow zone");
2542 if (os::guard_memory((char *) base, stack_yellow_zone_size())) {
2543 _stack_guard_state = stack_guard_enabled;
2544 } else {
2545 warning("Attempt to guard stack yellow zone failed.");
2546 }
2547 enable_register_stack_guard();
2548 }
2550 void JavaThread::disable_stack_yellow_zone() {
2551 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2552 assert(_stack_guard_state != stack_guard_yellow_disabled, "already disabled");
2554 // Simply return if called for a thread that does not use guard pages.
2555 if (_stack_guard_state == stack_guard_unused) return;
2557 // The base notation is from the stacks point of view, growing downward.
2558 // We need to adjust it to work correctly with guard_memory()
2559 address base = stack_yellow_zone_base() - stack_yellow_zone_size();
2561 if (os::unguard_memory((char *)base, stack_yellow_zone_size())) {
2562 _stack_guard_state = stack_guard_yellow_disabled;
2563 } else {
2564 warning("Attempt to unguard stack yellow zone failed.");
2565 }
2566 disable_register_stack_guard();
2567 }
2569 void JavaThread::enable_stack_red_zone() {
2570 // The base notation is from the stacks point of view, growing downward.
2571 // We need to adjust it to work correctly with guard_memory()
2572 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2573 address base = stack_red_zone_base() - stack_red_zone_size();
2575 guarantee(base < stack_base(),"Error calculating stack red zone");
2576 guarantee(base < os::current_stack_pointer(),"Error calculating stack red zone");
2578 if(!os::guard_memory((char *) base, stack_red_zone_size())) {
2579 warning("Attempt to guard stack red zone failed.");
2580 }
2581 }
2583 void JavaThread::disable_stack_red_zone() {
2584 // The base notation is from the stacks point of view, growing downward.
2585 // We need to adjust it to work correctly with guard_memory()
2586 assert(_stack_guard_state != stack_guard_unused, "must be using guard pages.");
2587 address base = stack_red_zone_base() - stack_red_zone_size();
2588 if (!os::unguard_memory((char *)base, stack_red_zone_size())) {
2589 warning("Attempt to unguard stack red zone failed.");
2590 }
2591 }
2593 void JavaThread::frames_do(void f(frame*, const RegisterMap* map)) {
2594 // ignore is there is no stack
2595 if (!has_last_Java_frame()) return;
2596 // traverse the stack frames. Starts from top frame.
2597 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2598 frame* fr = fst.current();
2599 f(fr, fst.register_map());
2600 }
2601 }
2604 #ifndef PRODUCT
2605 // Deoptimization
2606 // Function for testing deoptimization
2607 void JavaThread::deoptimize() {
2608 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
2609 StackFrameStream fst(this, UseBiasedLocking);
2610 bool deopt = false; // Dump stack only if a deopt actually happens.
2611 bool only_at = strlen(DeoptimizeOnlyAt) > 0;
2612 // Iterate over all frames in the thread and deoptimize
2613 for(; !fst.is_done(); fst.next()) {
2614 if(fst.current()->can_be_deoptimized()) {
2616 if (only_at) {
2617 // Deoptimize only at particular bcis. DeoptimizeOnlyAt
2618 // consists of comma or carriage return separated numbers so
2619 // search for the current bci in that string.
2620 address pc = fst.current()->pc();
2621 nmethod* nm = (nmethod*) fst.current()->cb();
2622 ScopeDesc* sd = nm->scope_desc_at( pc);
2623 char buffer[8];
2624 jio_snprintf(buffer, sizeof(buffer), "%d", sd->bci());
2625 size_t len = strlen(buffer);
2626 const char * found = strstr(DeoptimizeOnlyAt, buffer);
2627 while (found != NULL) {
2628 if ((found[len] == ',' || found[len] == '\n' || found[len] == '\0') &&
2629 (found == DeoptimizeOnlyAt || found[-1] == ',' || found[-1] == '\n')) {
2630 // Check that the bci found is bracketed by terminators.
2631 break;
2632 }
2633 found = strstr(found + 1, buffer);
2634 }
2635 if (!found) {
2636 continue;
2637 }
2638 }
2640 if (DebugDeoptimization && !deopt) {
2641 deopt = true; // One-time only print before deopt
2642 tty->print_cr("[BEFORE Deoptimization]");
2643 trace_frames();
2644 trace_stack();
2645 }
2646 Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
2647 }
2648 }
2650 if (DebugDeoptimization && deopt) {
2651 tty->print_cr("[AFTER Deoptimization]");
2652 trace_frames();
2653 }
2654 }
2657 // Make zombies
2658 void JavaThread::make_zombies() {
2659 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2660 if (fst.current()->can_be_deoptimized()) {
2661 // it is a Java nmethod
2662 nmethod* nm = CodeCache::find_nmethod(fst.current()->pc());
2663 nm->make_not_entrant();
2664 }
2665 }
2666 }
2667 #endif // PRODUCT
2670 void JavaThread::deoptimized_wrt_marked_nmethods() {
2671 if (!has_last_Java_frame()) return;
2672 // BiasedLocking needs an updated RegisterMap for the revoke monitors pass
2673 StackFrameStream fst(this, UseBiasedLocking);
2674 for(; !fst.is_done(); fst.next()) {
2675 if (fst.current()->should_be_deoptimized()) {
2676 if (LogCompilation && xtty != NULL) {
2677 nmethod* nm = fst.current()->cb()->as_nmethod_or_null();
2678 xtty->elem("deoptimized thread='" UINTX_FORMAT "' compile_id='%d'",
2679 this->name(), nm != NULL ? nm->compile_id() : -1);
2680 }
2682 Deoptimization::deoptimize(this, *fst.current(), fst.register_map());
2683 }
2684 }
2685 }
2688 // GC support
2689 static void frame_gc_epilogue(frame* f, const RegisterMap* map) { f->gc_epilogue(); }
2691 void JavaThread::gc_epilogue() {
2692 frames_do(frame_gc_epilogue);
2693 }
2696 static void frame_gc_prologue(frame* f, const RegisterMap* map) { f->gc_prologue(); }
2698 void JavaThread::gc_prologue() {
2699 frames_do(frame_gc_prologue);
2700 }
2702 // If the caller is a NamedThread, then remember, in the current scope,
2703 // the given JavaThread in its _processed_thread field.
2704 class RememberProcessedThread: public StackObj {
2705 NamedThread* _cur_thr;
2706 public:
2707 RememberProcessedThread(JavaThread* jthr) {
2708 Thread* thread = Thread::current();
2709 if (thread->is_Named_thread()) {
2710 _cur_thr = (NamedThread *)thread;
2711 _cur_thr->set_processed_thread(jthr);
2712 } else {
2713 _cur_thr = NULL;
2714 }
2715 }
2717 ~RememberProcessedThread() {
2718 if (_cur_thr) {
2719 _cur_thr->set_processed_thread(NULL);
2720 }
2721 }
2722 };
2724 void JavaThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
2725 // Verify that the deferred card marks have been flushed.
2726 assert(deferred_card_mark().is_empty(), "Should be empty during GC");
2728 // The ThreadProfiler oops_do is done from FlatProfiler::oops_do
2729 // since there may be more than one thread using each ThreadProfiler.
2731 // Traverse the GCHandles
2732 Thread::oops_do(f, cld_f, cf);
2734 assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
2735 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
2737 if (has_last_Java_frame()) {
2738 // Record JavaThread to GC thread
2739 RememberProcessedThread rpt(this);
2741 // Traverse the privileged stack
2742 if (_privileged_stack_top != NULL) {
2743 _privileged_stack_top->oops_do(f);
2744 }
2746 // traverse the registered growable array
2747 if (_array_for_gc != NULL) {
2748 for (int index = 0; index < _array_for_gc->length(); index++) {
2749 f->do_oop(_array_for_gc->adr_at(index));
2750 }
2751 }
2753 // Traverse the monitor chunks
2754 for (MonitorChunk* chunk = monitor_chunks(); chunk != NULL; chunk = chunk->next()) {
2755 chunk->oops_do(f);
2756 }
2758 // Traverse the execution stack
2759 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2760 fst.current()->oops_do(f, cld_f, cf, fst.register_map());
2761 }
2762 }
2764 // callee_target is never live across a gc point so NULL it here should
2765 // it still contain a methdOop.
2767 set_callee_target(NULL);
2769 assert(vframe_array_head() == NULL, "deopt in progress at a safepoint!");
2770 // If we have deferred set_locals there might be oops waiting to be
2771 // written
2772 GrowableArray<jvmtiDeferredLocalVariableSet*>* list = deferred_locals();
2773 if (list != NULL) {
2774 for (int i = 0; i < list->length(); i++) {
2775 list->at(i)->oops_do(f);
2776 }
2777 }
2779 // Traverse instance variables at the end since the GC may be moving things
2780 // around using this function
2781 f->do_oop((oop*) &_threadObj);
2782 f->do_oop((oop*) &_vm_result);
2783 f->do_oop((oop*) &_exception_oop);
2784 f->do_oop((oop*) &_pending_async_exception);
2786 if (jvmti_thread_state() != NULL) {
2787 jvmti_thread_state()->oops_do(f);
2788 }
2789 }
2791 void JavaThread::nmethods_do(CodeBlobClosure* cf) {
2792 Thread::nmethods_do(cf); // (super method is a no-op)
2794 assert( (!has_last_Java_frame() && java_call_counter() == 0) ||
2795 (has_last_Java_frame() && java_call_counter() > 0), "wrong java_sp info!");
2797 if (has_last_Java_frame()) {
2798 // Traverse the execution stack
2799 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2800 fst.current()->nmethods_do(cf);
2801 }
2802 }
2803 }
2805 void JavaThread::metadata_do(void f(Metadata*)) {
2806 Thread::metadata_do(f);
2807 if (has_last_Java_frame()) {
2808 // Traverse the execution stack to call f() on the methods in the stack
2809 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
2810 fst.current()->metadata_do(f);
2811 }
2812 } else if (is_Compiler_thread()) {
2813 // need to walk ciMetadata in current compile tasks to keep alive.
2814 CompilerThread* ct = (CompilerThread*)this;
2815 if (ct->env() != NULL) {
2816 ct->env()->metadata_do(f);
2817 }
2818 }
2819 }
2821 // Printing
2822 const char* _get_thread_state_name(JavaThreadState _thread_state) {
2823 switch (_thread_state) {
2824 case _thread_uninitialized: return "_thread_uninitialized";
2825 case _thread_new: return "_thread_new";
2826 case _thread_new_trans: return "_thread_new_trans";
2827 case _thread_in_native: return "_thread_in_native";
2828 case _thread_in_native_trans: return "_thread_in_native_trans";
2829 case _thread_in_vm: return "_thread_in_vm";
2830 case _thread_in_vm_trans: return "_thread_in_vm_trans";
2831 case _thread_in_Java: return "_thread_in_Java";
2832 case _thread_in_Java_trans: return "_thread_in_Java_trans";
2833 case _thread_blocked: return "_thread_blocked";
2834 case _thread_blocked_trans: return "_thread_blocked_trans";
2835 default: return "unknown thread state";
2836 }
2837 }
2839 #ifndef PRODUCT
2840 void JavaThread::print_thread_state_on(outputStream *st) const {
2841 st->print_cr(" JavaThread state: %s", _get_thread_state_name(_thread_state));
2842 };
2843 void JavaThread::print_thread_state() const {
2844 print_thread_state_on(tty);
2845 };
2846 #endif // PRODUCT
2848 // Called by Threads::print() for VM_PrintThreads operation
2849 void JavaThread::print_on(outputStream *st) const {
2850 st->print("\"%s\" ", get_thread_name());
2851 oop thread_oop = threadObj();
2852 if (thread_oop != NULL) {
2853 st->print("#" INT64_FORMAT " ", java_lang_Thread::thread_id(thread_oop));
2854 if (java_lang_Thread::is_daemon(thread_oop)) st->print("daemon ");
2855 st->print("prio=%d ", java_lang_Thread::priority(thread_oop));
2856 }
2857 Thread::print_on(st);
2858 // print guess for valid stack memory region (assume 4K pages); helps lock debugging
2859 st->print_cr("[" INTPTR_FORMAT "]", (intptr_t)last_Java_sp() & ~right_n_bits(12));
2860 if (thread_oop != NULL && JDK_Version::is_gte_jdk15x_version()) {
2861 st->print_cr(" java.lang.Thread.State: %s", java_lang_Thread::thread_status_name(thread_oop));
2862 }
2863 #ifndef PRODUCT
2864 print_thread_state_on(st);
2865 _safepoint_state->print_on(st);
2866 #endif // PRODUCT
2867 }
2869 // Called by fatal error handler. The difference between this and
2870 // JavaThread::print() is that we can't grab lock or allocate memory.
2871 void JavaThread::print_on_error(outputStream* st, char *buf, int buflen) const {
2872 st->print("JavaThread \"%s\"", get_thread_name_string(buf, buflen));
2873 oop thread_obj = threadObj();
2874 if (thread_obj != NULL) {
2875 if (java_lang_Thread::is_daemon(thread_obj)) st->print(" daemon");
2876 }
2877 st->print(" [");
2878 st->print("%s", _get_thread_state_name(_thread_state));
2879 if (osthread()) {
2880 st->print(", id=%d", osthread()->thread_id());
2881 }
2882 st->print(", stack(" PTR_FORMAT "," PTR_FORMAT ")",
2883 _stack_base - _stack_size, _stack_base);
2884 st->print("]");
2885 return;
2886 }
2888 // Verification
2890 static void frame_verify(frame* f, const RegisterMap *map) { f->verify(map); }
2892 void JavaThread::verify() {
2893 // Verify oops in the thread.
2894 oops_do(&VerifyOopClosure::verify_oop, NULL, NULL);
2896 // Verify the stack frames.
2897 frames_do(frame_verify);
2898 }
2900 // CR 6300358 (sub-CR 2137150)
2901 // Most callers of this method assume that it can't return NULL but a
2902 // thread may not have a name whilst it is in the process of attaching to
2903 // the VM - see CR 6412693, and there are places where a JavaThread can be
2904 // seen prior to having it's threadObj set (eg JNI attaching threads and
2905 // if vm exit occurs during initialization). These cases can all be accounted
2906 // for such that this method never returns NULL.
2907 const char* JavaThread::get_thread_name() const {
2908 #ifdef ASSERT
2909 // early safepoints can hit while current thread does not yet have TLS
2910 if (!SafepointSynchronize::is_at_safepoint()) {
2911 Thread *cur = Thread::current();
2912 if (!(cur->is_Java_thread() && cur == this)) {
2913 // Current JavaThreads are allowed to get their own name without
2914 // the Threads_lock.
2915 assert_locked_or_safepoint(Threads_lock);
2916 }
2917 }
2918 #endif // ASSERT
2919 return get_thread_name_string();
2920 }
2922 // Returns a non-NULL representation of this thread's name, or a suitable
2923 // descriptive string if there is no set name
2924 const char* JavaThread::get_thread_name_string(char* buf, int buflen) const {
2925 const char* name_str;
2926 oop thread_obj = threadObj();
2927 if (thread_obj != NULL) {
2928 typeArrayOop name = java_lang_Thread::name(thread_obj);
2929 if (name != NULL) {
2930 if (buf == NULL) {
2931 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
2932 }
2933 else {
2934 name_str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length(), buf, buflen);
2935 }
2936 }
2937 else if (is_attaching_via_jni()) { // workaround for 6412693 - see 6404306
2938 name_str = "<no-name - thread is attaching>";
2939 }
2940 else {
2941 name_str = Thread::name();
2942 }
2943 }
2944 else {
2945 name_str = Thread::name();
2946 }
2947 assert(name_str != NULL, "unexpected NULL thread name");
2948 return name_str;
2949 }
2952 const char* JavaThread::get_threadgroup_name() const {
2953 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
2954 oop thread_obj = threadObj();
2955 if (thread_obj != NULL) {
2956 oop thread_group = java_lang_Thread::threadGroup(thread_obj);
2957 if (thread_group != NULL) {
2958 typeArrayOop name = java_lang_ThreadGroup::name(thread_group);
2959 // ThreadGroup.name can be null
2960 if (name != NULL) {
2961 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
2962 return str;
2963 }
2964 }
2965 }
2966 return NULL;
2967 }
2969 const char* JavaThread::get_parent_name() const {
2970 debug_only(if (JavaThread::current() != this) assert_locked_or_safepoint(Threads_lock);)
2971 oop thread_obj = threadObj();
2972 if (thread_obj != NULL) {
2973 oop thread_group = java_lang_Thread::threadGroup(thread_obj);
2974 if (thread_group != NULL) {
2975 oop parent = java_lang_ThreadGroup::parent(thread_group);
2976 if (parent != NULL) {
2977 typeArrayOop name = java_lang_ThreadGroup::name(parent);
2978 // ThreadGroup.name can be null
2979 if (name != NULL) {
2980 const char* str = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length());
2981 return str;
2982 }
2983 }
2984 }
2985 }
2986 return NULL;
2987 }
2989 ThreadPriority JavaThread::java_priority() const {
2990 oop thr_oop = threadObj();
2991 if (thr_oop == NULL) return NormPriority; // Bootstrapping
2992 ThreadPriority priority = java_lang_Thread::priority(thr_oop);
2993 assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");
2994 return priority;
2995 }
2997 void JavaThread::prepare(jobject jni_thread, ThreadPriority prio) {
2999 assert(Threads_lock->owner() == Thread::current(), "must have threads lock");
3000 // Link Java Thread object <-> C++ Thread
3002 // Get the C++ thread object (an oop) from the JNI handle (a jthread)
3003 // and put it into a new Handle. The Handle "thread_oop" can then
3004 // be used to pass the C++ thread object to other methods.
3006 // Set the Java level thread object (jthread) field of the
3007 // new thread (a JavaThread *) to C++ thread object using the
3008 // "thread_oop" handle.
3010 // Set the thread field (a JavaThread *) of the
3011 // oop representing the java_lang_Thread to the new thread (a JavaThread *).
3013 Handle thread_oop(Thread::current(),
3014 JNIHandles::resolve_non_null(jni_thread));
3015 assert(InstanceKlass::cast(thread_oop->klass())->is_linked(),
3016 "must be initialized");
3017 set_threadObj(thread_oop());
3018 java_lang_Thread::set_thread(thread_oop(), this);
3020 if (prio == NoPriority) {
3021 prio = java_lang_Thread::priority(thread_oop());
3022 assert(prio != NoPriority, "A valid priority should be present");
3023 }
3025 // Push the Java priority down to the native thread; needs Threads_lock
3026 Thread::set_priority(this, prio);
3028 // Add the new thread to the Threads list and set it in motion.
3029 // We must have threads lock in order to call Threads::add.
3030 // It is crucial that we do not block before the thread is
3031 // added to the Threads list for if a GC happens, then the java_thread oop
3032 // will not be visited by GC.
3033 Threads::add(this);
3034 }
3036 oop JavaThread::current_park_blocker() {
3037 // Support for JSR-166 locks
3038 oop thread_oop = threadObj();
3039 if (thread_oop != NULL &&
3040 JDK_Version::current().supports_thread_park_blocker()) {
3041 return java_lang_Thread::park_blocker(thread_oop);
3042 }
3043 return NULL;
3044 }
3047 void JavaThread::print_stack_on(outputStream* st) {
3048 if (!has_last_Java_frame()) return;
3049 ResourceMark rm;
3050 HandleMark hm;
3052 RegisterMap reg_map(this);
3053 vframe* start_vf = last_java_vframe(®_map);
3054 int count = 0;
3055 for (vframe* f = start_vf; f; f = f->sender() ) {
3056 if (f->is_java_frame()) {
3057 javaVFrame* jvf = javaVFrame::cast(f);
3058 java_lang_Throwable::print_stack_element(st, jvf->method(), jvf->bci());
3060 // Print out lock information
3061 if (JavaMonitorsInStackTrace) {
3062 jvf->print_lock_info_on(st, count);
3063 }
3064 } else {
3065 // Ignore non-Java frames
3066 }
3068 // Bail-out case for too deep stacks
3069 count++;
3070 if (MaxJavaStackTraceDepth == count) return;
3071 }
3072 }
3075 // JVMTI PopFrame support
3076 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) {
3077 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments");
3078 if (in_bytes(size_in_bytes) != 0) {
3079 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes), mtThread);
3080 _popframe_preserved_args_size = in_bytes(size_in_bytes);
3081 Copy::conjoint_jbytes(start, _popframe_preserved_args, _popframe_preserved_args_size);
3082 }
3083 }
3085 void* JavaThread::popframe_preserved_args() {
3086 return _popframe_preserved_args;
3087 }
3089 ByteSize JavaThread::popframe_preserved_args_size() {
3090 return in_ByteSize(_popframe_preserved_args_size);
3091 }
3093 WordSize JavaThread::popframe_preserved_args_size_in_words() {
3094 int sz = in_bytes(popframe_preserved_args_size());
3095 assert(sz % wordSize == 0, "argument size must be multiple of wordSize");
3096 return in_WordSize(sz / wordSize);
3097 }
3099 void JavaThread::popframe_free_preserved_args() {
3100 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice");
3101 FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args, mtThread);
3102 _popframe_preserved_args = NULL;
3103 _popframe_preserved_args_size = 0;
3104 }
3106 #ifndef PRODUCT
3108 void JavaThread::trace_frames() {
3109 tty->print_cr("[Describe stack]");
3110 int frame_no = 1;
3111 for(StackFrameStream fst(this); !fst.is_done(); fst.next()) {
3112 tty->print(" %d. ", frame_no++);
3113 fst.current()->print_value_on(tty,this);
3114 tty->cr();
3115 }
3116 }
3118 class PrintAndVerifyOopClosure: public OopClosure {
3119 protected:
3120 template <class T> inline void do_oop_work(T* p) {
3121 oop obj = oopDesc::load_decode_heap_oop(p);
3122 if (obj == NULL) return;
3123 tty->print(INTPTR_FORMAT ": ", p);
3124 if (obj->is_oop_or_null()) {
3125 if (obj->is_objArray()) {
3126 tty->print_cr("valid objArray: " INTPTR_FORMAT, (oopDesc*) obj);
3127 } else {
3128 obj->print();
3129 }
3130 } else {
3131 tty->print_cr("invalid oop: " INTPTR_FORMAT, (oopDesc*) obj);
3132 }
3133 tty->cr();
3134 }
3135 public:
3136 virtual void do_oop(oop* p) { do_oop_work(p); }
3137 virtual void do_oop(narrowOop* p) { do_oop_work(p); }
3138 };
3141 static void oops_print(frame* f, const RegisterMap *map) {
3142 PrintAndVerifyOopClosure print;
3143 f->print_value();
3144 f->oops_do(&print, NULL, NULL, (RegisterMap*)map);
3145 }
3147 // Print our all the locations that contain oops and whether they are
3148 // valid or not. This useful when trying to find the oldest frame
3149 // where an oop has gone bad since the frame walk is from youngest to
3150 // oldest.
3151 void JavaThread::trace_oops() {
3152 tty->print_cr("[Trace oops]");
3153 frames_do(oops_print);
3154 }
3157 #ifdef ASSERT
3158 // Print or validate the layout of stack frames
3159 void JavaThread::print_frame_layout(int depth, bool validate_only) {
3160 ResourceMark rm;
3161 PRESERVE_EXCEPTION_MARK;
3162 FrameValues values;
3163 int frame_no = 0;
3164 for(StackFrameStream fst(this, false); !fst.is_done(); fst.next()) {
3165 fst.current()->describe(values, ++frame_no);
3166 if (depth == frame_no) break;
3167 }
3168 if (validate_only) {
3169 values.validate();
3170 } else {
3171 tty->print_cr("[Describe stack layout]");
3172 values.print(this);
3173 }
3174 }
3175 #endif
3177 void JavaThread::trace_stack_from(vframe* start_vf) {
3178 ResourceMark rm;
3179 int vframe_no = 1;
3180 for (vframe* f = start_vf; f; f = f->sender() ) {
3181 if (f->is_java_frame()) {
3182 javaVFrame::cast(f)->print_activation(vframe_no++);
3183 } else {
3184 f->print();
3185 }
3186 if (vframe_no > StackPrintLimit) {
3187 tty->print_cr("...<more frames>...");
3188 return;
3189 }
3190 }
3191 }
3194 void JavaThread::trace_stack() {
3195 if (!has_last_Java_frame()) return;
3196 ResourceMark rm;
3197 HandleMark hm;
3198 RegisterMap reg_map(this);
3199 trace_stack_from(last_java_vframe(®_map));
3200 }
3203 #endif // PRODUCT
3206 javaVFrame* JavaThread::last_java_vframe(RegisterMap *reg_map) {
3207 assert(reg_map != NULL, "a map must be given");
3208 frame f = last_frame();
3209 for (vframe* vf = vframe::new_vframe(&f, reg_map, this); vf; vf = vf->sender() ) {
3210 if (vf->is_java_frame()) return javaVFrame::cast(vf);
3211 }
3212 return NULL;
3213 }
3216 Klass* JavaThread::security_get_caller_class(int depth) {
3217 vframeStream vfst(this);
3218 vfst.security_get_caller_frame(depth);
3219 if (!vfst.at_end()) {
3220 return vfst.method()->method_holder();
3221 }
3222 return NULL;
3223 }
3225 static void compiler_thread_entry(JavaThread* thread, TRAPS) {
3226 assert(thread->is_Compiler_thread(), "must be compiler thread");
3227 CompileBroker::compiler_thread_loop();
3228 }
3230 // Create a CompilerThread
3231 CompilerThread::CompilerThread(CompileQueue* queue, CompilerCounters* counters)
3232 : JavaThread(&compiler_thread_entry) {
3233 _env = NULL;
3234 _log = NULL;
3235 _task = NULL;
3236 _queue = queue;
3237 _counters = counters;
3238 _buffer_blob = NULL;
3239 _scanned_nmethod = NULL;
3241 #ifndef PRODUCT
3242 _ideal_graph_printer = NULL;
3243 #endif
3244 }
3246 void CompilerThread::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
3247 JavaThread::oops_do(f, cld_f, cf);
3248 if (_scanned_nmethod != NULL && cf != NULL) {
3249 // Safepoints can occur when the sweeper is scanning an nmethod so
3250 // process it here to make sure it isn't unloaded in the middle of
3251 // a scan.
3252 cf->do_code_blob(_scanned_nmethod);
3253 }
3254 }
3256 // ======= Threads ========
3258 // The Threads class links together all active threads, and provides
3259 // operations over all threads. It is protected by its own Mutex
3260 // lock, which is also used in other contexts to protect thread
3261 // operations from having the thread being operated on from exiting
3262 // and going away unexpectedly (e.g., safepoint synchronization)
3264 JavaThread* Threads::_thread_list = NULL;
3265 int Threads::_number_of_threads = 0;
3266 int Threads::_number_of_non_daemon_threads = 0;
3267 int Threads::_return_code = 0;
3268 size_t JavaThread::_stack_size_at_create = 0;
3269 #ifdef ASSERT
3270 bool Threads::_vm_complete = false;
3271 #endif
3273 // All JavaThreads
3274 #define ALL_JAVA_THREADS(X) for (JavaThread* X = _thread_list; X; X = X->next())
3276 void os_stream();
3278 // All JavaThreads + all non-JavaThreads (i.e., every thread in the system)
3279 void Threads::threads_do(ThreadClosure* tc) {
3280 assert_locked_or_safepoint(Threads_lock);
3281 // ALL_JAVA_THREADS iterates through all JavaThreads
3282 ALL_JAVA_THREADS(p) {
3283 tc->do_thread(p);
3284 }
3285 // Someday we could have a table or list of all non-JavaThreads.
3286 // For now, just manually iterate through them.
3287 tc->do_thread(VMThread::vm_thread());
3288 Universe::heap()->gc_threads_do(tc);
3289 WatcherThread *wt = WatcherThread::watcher_thread();
3290 // Strictly speaking, the following NULL check isn't sufficient to make sure
3291 // the data for WatcherThread is still valid upon being examined. However,
3292 // considering that WatchThread terminates when the VM is on the way to
3293 // exit at safepoint, the chance of the above is extremely small. The right
3294 // way to prevent termination of WatcherThread would be to acquire
3295 // Terminator_lock, but we can't do that without violating the lock rank
3296 // checking in some cases.
3297 if (wt != NULL)
3298 tc->do_thread(wt);
3300 // If CompilerThreads ever become non-JavaThreads, add them here
3301 }
3303 jint Threads::create_vm(JavaVMInitArgs* args, bool* canTryAgain) {
3305 extern void JDK_Version_init();
3307 // Check version
3308 if (!is_supported_jni_version(args->version)) return JNI_EVERSION;
3310 // Initialize the output stream module
3311 ostream_init();
3313 // Process java launcher properties.
3314 Arguments::process_sun_java_launcher_properties(args);
3316 // Initialize the os module before using TLS
3317 os::init();
3319 // Initialize system properties.
3320 Arguments::init_system_properties();
3322 // So that JDK version can be used as a discrimintor when parsing arguments
3323 JDK_Version_init();
3325 // Update/Initialize System properties after JDK version number is known
3326 Arguments::init_version_specific_system_properties();
3328 // Parse arguments
3329 jint parse_result = Arguments::parse(args);
3330 if (parse_result != JNI_OK) return parse_result;
3332 os::init_before_ergo();
3334 jint ergo_result = Arguments::apply_ergo();
3335 if (ergo_result != JNI_OK) return ergo_result;
3337 if (PauseAtStartup) {
3338 os::pause();
3339 }
3341 #ifndef USDT2
3342 HS_DTRACE_PROBE(hotspot, vm__init__begin);
3343 #else /* USDT2 */
3344 HOTSPOT_VM_INIT_BEGIN();
3345 #endif /* USDT2 */
3347 // Record VM creation timing statistics
3348 TraceVmCreationTime create_vm_timer;
3349 create_vm_timer.start();
3351 // Timing (must come after argument parsing)
3352 TraceTime timer("Create VM", TraceStartupTime);
3354 // Initialize the os module after parsing the args
3355 jint os_init_2_result = os::init_2();
3356 if (os_init_2_result != JNI_OK) return os_init_2_result;
3358 jint adjust_after_os_result = Arguments::adjust_after_os();
3359 if (adjust_after_os_result != JNI_OK) return adjust_after_os_result;
3361 // intialize TLS
3362 ThreadLocalStorage::init();
3364 // Bootstrap native memory tracking, so it can start recording memory
3365 // activities before worker thread is started. This is the first phase
3366 // of bootstrapping, VM is currently running in single-thread mode.
3367 MemTracker::bootstrap_single_thread();
3369 // Initialize output stream logging
3370 ostream_init_log();
3372 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad
3373 // Must be before create_vm_init_agents()
3374 if (Arguments::init_libraries_at_startup()) {
3375 convert_vm_init_libraries_to_agents();
3376 }
3378 // Launch -agentlib/-agentpath and converted -Xrun agents
3379 if (Arguments::init_agents_at_startup()) {
3380 create_vm_init_agents();
3381 }
3383 // Initialize Threads state
3384 _thread_list = NULL;
3385 _number_of_threads = 0;
3386 _number_of_non_daemon_threads = 0;
3388 // Initialize global data structures and create system classes in heap
3389 vm_init_globals();
3391 // Attach the main thread to this os thread
3392 JavaThread* main_thread = new JavaThread();
3393 main_thread->set_thread_state(_thread_in_vm);
3394 // must do this before set_active_handles and initialize_thread_local_storage
3395 // Note: on solaris initialize_thread_local_storage() will (indirectly)
3396 // change the stack size recorded here to one based on the java thread
3397 // stacksize. This adjusted size is what is used to figure the placement
3398 // of the guard pages.
3399 main_thread->record_stack_base_and_size();
3400 main_thread->initialize_thread_local_storage();
3402 main_thread->set_active_handles(JNIHandleBlock::allocate_block());
3404 if (!main_thread->set_as_starting_thread()) {
3405 vm_shutdown_during_initialization(
3406 "Failed necessary internal allocation. Out of swap space");
3407 delete main_thread;
3408 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
3409 return JNI_ENOMEM;
3410 }
3412 // Enable guard page *after* os::create_main_thread(), otherwise it would
3413 // crash Linux VM, see notes in os_linux.cpp.
3414 main_thread->create_stack_guard_pages();
3416 // Initialize Java-Level synchronization subsystem
3417 ObjectMonitor::Initialize() ;
3419 // Second phase of bootstrapping, VM is about entering multi-thread mode
3420 MemTracker::bootstrap_multi_thread();
3422 // Initialize global modules
3423 jint status = init_globals();
3424 if (status != JNI_OK) {
3425 delete main_thread;
3426 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again
3427 return status;
3428 }
3430 // Should be done after the heap is fully created
3431 main_thread->cache_global_variables();
3433 HandleMark hm;
3435 { MutexLocker mu(Threads_lock);
3436 Threads::add(main_thread);
3437 }
3439 // Any JVMTI raw monitors entered in onload will transition into
3440 // real raw monitor. VM is setup enough here for raw monitor enter.
3441 JvmtiExport::transition_pending_onload_raw_monitors();
3443 // Fully start NMT
3444 MemTracker::start();
3446 // Create the VMThread
3447 { TraceTime timer("Start VMThread", TraceStartupTime);
3448 VMThread::create();
3449 Thread* vmthread = VMThread::vm_thread();
3451 if (!os::create_thread(vmthread, os::vm_thread))
3452 vm_exit_during_initialization("Cannot create VM thread. Out of system resources.");
3454 // Wait for the VM thread to become ready, and VMThread::run to initialize
3455 // Monitors can have spurious returns, must always check another state flag
3456 {
3457 MutexLocker ml(Notify_lock);
3458 os::start_thread(vmthread);
3459 while (vmthread->active_handles() == NULL) {
3460 Notify_lock->wait();
3461 }
3462 }
3463 }
3465 assert (Universe::is_fully_initialized(), "not initialized");
3466 if (VerifyDuringStartup) {
3467 // Make sure we're starting with a clean slate.
3468 VM_Verify verify_op;
3469 VMThread::execute(&verify_op);
3470 }
3472 EXCEPTION_MARK;
3474 // At this point, the Universe is initialized, but we have not executed
3475 // any byte code. Now is a good time (the only time) to dump out the
3476 // internal state of the JVM for sharing.
3477 if (DumpSharedSpaces) {
3478 MetaspaceShared::preload_and_dump(CHECK_0);
3479 ShouldNotReachHere();
3480 }
3482 // Always call even when there are not JVMTI environments yet, since environments
3483 // may be attached late and JVMTI must track phases of VM execution
3484 JvmtiExport::enter_start_phase();
3486 // Notify JVMTI agents that VM has started (JNI is up) - nop if no agents.
3487 JvmtiExport::post_vm_start();
3489 {
3490 TraceTime timer("Initialize java.lang classes", TraceStartupTime);
3492 if (EagerXrunInit && Arguments::init_libraries_at_startup()) {
3493 create_vm_init_libraries();
3494 }
3496 initialize_class(vmSymbols::java_lang_String(), CHECK_0);
3498 // Initialize java_lang.System (needed before creating the thread)
3499 initialize_class(vmSymbols::java_lang_System(), CHECK_0);
3500 initialize_class(vmSymbols::java_lang_ThreadGroup(), CHECK_0);
3501 Handle thread_group = create_initial_thread_group(CHECK_0);
3502 Universe::set_main_thread_group(thread_group());
3503 initialize_class(vmSymbols::java_lang_Thread(), CHECK_0);
3504 oop thread_object = create_initial_thread(thread_group, main_thread, CHECK_0);
3505 main_thread->set_threadObj(thread_object);
3506 // Set thread status to running since main thread has
3507 // been started and running.
3508 java_lang_Thread::set_thread_status(thread_object,
3509 java_lang_Thread::RUNNABLE);
3511 // The VM creates & returns objects of this class. Make sure it's initialized.
3512 initialize_class(vmSymbols::java_lang_Class(), CHECK_0);
3514 // The VM preresolves methods to these classes. Make sure that they get initialized
3515 initialize_class(vmSymbols::java_lang_reflect_Method(), CHECK_0);
3516 initialize_class(vmSymbols::java_lang_ref_Finalizer(), CHECK_0);
3517 call_initializeSystemClass(CHECK_0);
3519 // get the Java runtime name after java.lang.System is initialized
3520 JDK_Version::set_runtime_name(get_java_runtime_name(THREAD));
3521 JDK_Version::set_runtime_version(get_java_runtime_version(THREAD));
3523 // an instance of OutOfMemory exception has been allocated earlier
3524 initialize_class(vmSymbols::java_lang_OutOfMemoryError(), CHECK_0);
3525 initialize_class(vmSymbols::java_lang_NullPointerException(), CHECK_0);
3526 initialize_class(vmSymbols::java_lang_ClassCastException(), CHECK_0);
3527 initialize_class(vmSymbols::java_lang_ArrayStoreException(), CHECK_0);
3528 initialize_class(vmSymbols::java_lang_ArithmeticException(), CHECK_0);
3529 initialize_class(vmSymbols::java_lang_StackOverflowError(), CHECK_0);
3530 initialize_class(vmSymbols::java_lang_IllegalMonitorStateException(), CHECK_0);
3531 initialize_class(vmSymbols::java_lang_IllegalArgumentException(), CHECK_0);
3532 }
3534 // See : bugid 4211085.
3535 // Background : the static initializer of java.lang.Compiler tries to read
3536 // property"java.compiler" and read & write property "java.vm.info".
3537 // When a security manager is installed through the command line
3538 // option "-Djava.security.manager", the above properties are not
3539 // readable and the static initializer for java.lang.Compiler fails
3540 // resulting in a NoClassDefFoundError. This can happen in any
3541 // user code which calls methods in java.lang.Compiler.
3542 // Hack : the hack is to pre-load and initialize this class, so that only
3543 // system domains are on the stack when the properties are read.
3544 // Currently even the AWT code has calls to methods in java.lang.Compiler.
3545 // On the classic VM, java.lang.Compiler is loaded very early to load the JIT.
3546 // Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and
3547 // read and write"java.vm.info" in the default policy file. See bugid 4211383
3548 // Once that is done, we should remove this hack.
3549 initialize_class(vmSymbols::java_lang_Compiler(), CHECK_0);
3551 // More hackery - the static initializer of java.lang.Compiler adds the string "nojit" to
3552 // the java.vm.info property if no jit gets loaded through java.lang.Compiler (the hotspot
3553 // compiler does not get loaded through java.lang.Compiler). "java -version" with the
3554 // hotspot vm says "nojit" all the time which is confusing. So, we reset it here.
3555 // This should also be taken out as soon as 4211383 gets fixed.
3556 reset_vm_info_property(CHECK_0);
3558 quicken_jni_functions();
3560 // Must be run after init_ft which initializes ft_enabled
3561 if (TRACE_INITIALIZE() != JNI_OK) {
3562 vm_exit_during_initialization("Failed to initialize tracing backend");
3563 }
3565 // Set flag that basic initialization has completed. Used by exceptions and various
3566 // debug stuff, that does not work until all basic classes have been initialized.
3567 set_init_completed();
3569 #ifndef USDT2
3570 HS_DTRACE_PROBE(hotspot, vm__init__end);
3571 #else /* USDT2 */
3572 HOTSPOT_VM_INIT_END();
3573 #endif /* USDT2 */
3575 // record VM initialization completion time
3576 #if INCLUDE_MANAGEMENT
3577 Management::record_vm_init_completed();
3578 #endif // INCLUDE_MANAGEMENT
3580 // Compute system loader. Note that this has to occur after set_init_completed, since
3581 // valid exceptions may be thrown in the process.
3582 // Note that we do not use CHECK_0 here since we are inside an EXCEPTION_MARK and
3583 // set_init_completed has just been called, causing exceptions not to be shortcut
3584 // anymore. We call vm_exit_during_initialization directly instead.
3585 SystemDictionary::compute_java_system_loader(THREAD);
3586 if (HAS_PENDING_EXCEPTION) {
3587 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
3588 }
3590 #if INCLUDE_ALL_GCS
3591 // Support for ConcurrentMarkSweep. This should be cleaned up
3592 // and better encapsulated. The ugly nested if test would go away
3593 // once things are properly refactored. XXX YSR
3594 if (UseConcMarkSweepGC || UseG1GC) {
3595 if (UseConcMarkSweepGC) {
3596 ConcurrentMarkSweepThread::makeSurrogateLockerThread(THREAD);
3597 } else {
3598 ConcurrentMarkThread::makeSurrogateLockerThread(THREAD);
3599 }
3600 if (HAS_PENDING_EXCEPTION) {
3601 vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
3602 }
3603 }
3604 #endif // INCLUDE_ALL_GCS
3606 // Always call even when there are not JVMTI environments yet, since environments
3607 // may be attached late and JVMTI must track phases of VM execution
3608 JvmtiExport::enter_live_phase();
3610 // Signal Dispatcher needs to be started before VMInit event is posted
3611 os::signal_init();
3613 // Start Attach Listener if +StartAttachListener or it can't be started lazily
3614 if (!DisableAttachMechanism) {
3615 AttachListener::vm_start();
3616 if (StartAttachListener || AttachListener::init_at_startup()) {
3617 AttachListener::init();
3618 }
3619 }
3621 // Launch -Xrun agents
3622 // Must be done in the JVMTI live phase so that for backward compatibility the JDWP
3623 // back-end can launch with -Xdebug -Xrunjdwp.
3624 if (!EagerXrunInit && Arguments::init_libraries_at_startup()) {
3625 create_vm_init_libraries();
3626 }
3628 // Notify JVMTI agents that VM initialization is complete - nop if no agents.
3629 JvmtiExport::post_vm_initialized();
3631 if (TRACE_START() != JNI_OK) {
3632 vm_exit_during_initialization("Failed to start tracing backend.");
3633 }
3635 if (CleanChunkPoolAsync) {
3636 Chunk::start_chunk_pool_cleaner_task();
3637 }
3639 // initialize compiler(s)
3640 #if defined(COMPILER1) || defined(COMPILER2) || defined(SHARK)
3641 CompileBroker::compilation_init();
3642 #endif
3644 if (EnableInvokeDynamic) {
3645 // Pre-initialize some JSR292 core classes to avoid deadlock during class loading.
3646 // It is done after compilers are initialized, because otherwise compilations of
3647 // signature polymorphic MH intrinsics can be missed
3648 // (see SystemDictionary::find_method_handle_intrinsic).
3649 initialize_class(vmSymbols::java_lang_invoke_MethodHandle(), CHECK_0);
3650 initialize_class(vmSymbols::java_lang_invoke_MemberName(), CHECK_0);
3651 initialize_class(vmSymbols::java_lang_invoke_MethodHandleNatives(), CHECK_0);
3652 }
3654 #if INCLUDE_MANAGEMENT
3655 Management::initialize(THREAD);
3656 #endif // INCLUDE_MANAGEMENT
3658 if (HAS_PENDING_EXCEPTION) {
3659 // management agent fails to start possibly due to
3660 // configuration problem and is responsible for printing
3661 // stack trace if appropriate. Simply exit VM.
3662 vm_exit(1);
3663 }
3665 if (Arguments::has_profile()) FlatProfiler::engage(main_thread, true);
3666 if (MemProfiling) MemProfiler::engage();
3667 StatSampler::engage();
3668 if (CheckJNICalls) JniPeriodicChecker::engage();
3670 BiasedLocking::init();
3672 if (JDK_Version::current().post_vm_init_hook_enabled()) {
3673 call_postVMInitHook(THREAD);
3674 // The Java side of PostVMInitHook.run must deal with all
3675 // exceptions and provide means of diagnosis.
3676 if (HAS_PENDING_EXCEPTION) {
3677 CLEAR_PENDING_EXCEPTION;
3678 }
3679 }
3681 {
3682 MutexLockerEx ml(PeriodicTask_lock, Mutex::_no_safepoint_check_flag);
3683 // Make sure the watcher thread can be started by WatcherThread::start()
3684 // or by dynamic enrollment.
3685 WatcherThread::make_startable();
3686 // Start up the WatcherThread if there are any periodic tasks
3687 // NOTE: All PeriodicTasks should be registered by now. If they
3688 // aren't, late joiners might appear to start slowly (we might
3689 // take a while to process their first tick).
3690 if (PeriodicTask::num_tasks() > 0) {
3691 WatcherThread::start();
3692 }
3693 }
3695 // Give os specific code one last chance to start
3696 os::init_3();
3698 create_vm_timer.end();
3699 #ifdef ASSERT
3700 _vm_complete = true;
3701 #endif
3702 return JNI_OK;
3703 }
3705 // type for the Agent_OnLoad and JVM_OnLoad entry points
3706 extern "C" {
3707 typedef jint (JNICALL *OnLoadEntry_t)(JavaVM *, char *, void *);
3708 }
3709 // Find a command line agent library and return its entry point for
3710 // -agentlib: -agentpath: -Xrun
3711 // num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array.
3712 static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) {
3713 OnLoadEntry_t on_load_entry = NULL;
3714 void *library = NULL;
3716 if (!agent->valid()) {
3717 char buffer[JVM_MAXPATHLEN];
3718 char ebuf[1024];
3719 const char *name = agent->name();
3720 const char *msg = "Could not find agent library ";
3722 // First check to see if agent is statcally linked into executable
3723 if (os::find_builtin_agent(agent, on_load_symbols, num_symbol_entries)) {
3724 library = agent->os_lib();
3725 } else if (agent->is_absolute_path()) {
3726 library = os::dll_load(name, ebuf, sizeof ebuf);
3727 if (library == NULL) {
3728 const char *sub_msg = " in absolute path, with error: ";
3729 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1;
3730 char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread);
3731 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf);
3732 // If we can't find the agent, exit.
3733 vm_exit_during_initialization(buf, NULL);
3734 FREE_C_HEAP_ARRAY(char, buf, mtThread);
3735 }
3736 } else {
3737 // Try to load the agent from the standard dll directory
3738 if (os::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(),
3739 name)) {
3740 library = os::dll_load(buffer, ebuf, sizeof ebuf);
3741 }
3742 if (library == NULL) { // Try the local directory
3743 char ns[1] = {0};
3744 if (os::dll_build_name(buffer, sizeof(buffer), ns, name)) {
3745 library = os::dll_load(buffer, ebuf, sizeof ebuf);
3746 }
3747 if (library == NULL) {
3748 const char *sub_msg = " on the library path, with error: ";
3749 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1;
3750 char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread);
3751 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf);
3752 // If we can't find the agent, exit.
3753 vm_exit_during_initialization(buf, NULL);
3754 FREE_C_HEAP_ARRAY(char, buf, mtThread);
3755 }
3756 }
3757 }
3758 agent->set_os_lib(library);
3759 agent->set_valid();
3760 }
3762 // Find the OnLoad function.
3763 on_load_entry =
3764 CAST_TO_FN_PTR(OnLoadEntry_t, os::find_agent_function(agent,
3765 false,
3766 on_load_symbols,
3767 num_symbol_entries));
3768 return on_load_entry;
3769 }
3771 // Find the JVM_OnLoad entry point
3772 static OnLoadEntry_t lookup_jvm_on_load(AgentLibrary* agent) {
3773 const char *on_load_symbols[] = JVM_ONLOAD_SYMBOLS;
3774 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*));
3775 }
3777 // Find the Agent_OnLoad entry point
3778 static OnLoadEntry_t lookup_agent_on_load(AgentLibrary* agent) {
3779 const char *on_load_symbols[] = AGENT_ONLOAD_SYMBOLS;
3780 return lookup_on_load(agent, on_load_symbols, sizeof(on_load_symbols) / sizeof(char*));
3781 }
3783 // For backwards compatibility with -Xrun
3784 // Convert libraries with no JVM_OnLoad, but which have Agent_OnLoad to be
3785 // treated like -agentpath:
3786 // Must be called before agent libraries are created
3787 void Threads::convert_vm_init_libraries_to_agents() {
3788 AgentLibrary* agent;
3789 AgentLibrary* next;
3791 for (agent = Arguments::libraries(); agent != NULL; agent = next) {
3792 next = agent->next(); // cache the next agent now as this agent may get moved off this list
3793 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent);
3795 // If there is an JVM_OnLoad function it will get called later,
3796 // otherwise see if there is an Agent_OnLoad
3797 if (on_load_entry == NULL) {
3798 on_load_entry = lookup_agent_on_load(agent);
3799 if (on_load_entry != NULL) {
3800 // switch it to the agent list -- so that Agent_OnLoad will be called,
3801 // JVM_OnLoad won't be attempted and Agent_OnUnload will
3802 Arguments::convert_library_to_agent(agent);
3803 } else {
3804 vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name());
3805 }
3806 }
3807 }
3808 }
3810 // Create agents for -agentlib: -agentpath: and converted -Xrun
3811 // Invokes Agent_OnLoad
3812 // Called very early -- before JavaThreads exist
3813 void Threads::create_vm_init_agents() {
3814 extern struct JavaVM_ main_vm;
3815 AgentLibrary* agent;
3817 JvmtiExport::enter_onload_phase();
3819 for (agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
3820 OnLoadEntry_t on_load_entry = lookup_agent_on_load(agent);
3822 if (on_load_entry != NULL) {
3823 // Invoke the Agent_OnLoad function
3824 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL);
3825 if (err != JNI_OK) {
3826 vm_exit_during_initialization("agent library failed to init", agent->name());
3827 }
3828 } else {
3829 vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name());
3830 }
3831 }
3832 JvmtiExport::enter_primordial_phase();
3833 }
3835 extern "C" {
3836 typedef void (JNICALL *Agent_OnUnload_t)(JavaVM *);
3837 }
3839 void Threads::shutdown_vm_agents() {
3840 // Send any Agent_OnUnload notifications
3841 const char *on_unload_symbols[] = AGENT_ONUNLOAD_SYMBOLS;
3842 size_t num_symbol_entries = ARRAY_SIZE(on_unload_symbols);
3843 extern struct JavaVM_ main_vm;
3844 for (AgentLibrary* agent = Arguments::agents(); agent != NULL; agent = agent->next()) {
3846 // Find the Agent_OnUnload function.
3847 Agent_OnUnload_t unload_entry = CAST_TO_FN_PTR(Agent_OnUnload_t,
3848 os::find_agent_function(agent,
3849 false,
3850 on_unload_symbols,
3851 num_symbol_entries));
3853 // Invoke the Agent_OnUnload function
3854 if (unload_entry != NULL) {
3855 JavaThread* thread = JavaThread::current();
3856 ThreadToNativeFromVM ttn(thread);
3857 HandleMark hm(thread);
3858 (*unload_entry)(&main_vm);
3859 }
3860 }
3861 }
3863 // Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries
3864 // Invokes JVM_OnLoad
3865 void Threads::create_vm_init_libraries() {
3866 extern struct JavaVM_ main_vm;
3867 AgentLibrary* agent;
3869 for (agent = Arguments::libraries(); agent != NULL; agent = agent->next()) {
3870 OnLoadEntry_t on_load_entry = lookup_jvm_on_load(agent);
3872 if (on_load_entry != NULL) {
3873 // Invoke the JVM_OnLoad function
3874 JavaThread* thread = JavaThread::current();
3875 ThreadToNativeFromVM ttn(thread);
3876 HandleMark hm(thread);
3877 jint err = (*on_load_entry)(&main_vm, agent->options(), NULL);
3878 if (err != JNI_OK) {
3879 vm_exit_during_initialization("-Xrun library failed to init", agent->name());
3880 }
3881 } else {
3882 vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name());
3883 }
3884 }
3885 }
3887 // Last thread running calls java.lang.Shutdown.shutdown()
3888 void JavaThread::invoke_shutdown_hooks() {
3889 HandleMark hm(this);
3891 // We could get here with a pending exception, if so clear it now.
3892 if (this->has_pending_exception()) {
3893 this->clear_pending_exception();
3894 }
3896 EXCEPTION_MARK;
3897 Klass* k =
3898 SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(),
3899 THREAD);
3900 if (k != NULL) {
3901 // SystemDictionary::resolve_or_null will return null if there was
3902 // an exception. If we cannot load the Shutdown class, just don't
3903 // call Shutdown.shutdown() at all. This will mean the shutdown hooks
3904 // and finalizers (if runFinalizersOnExit is set) won't be run.
3905 // Note that if a shutdown hook was registered or runFinalizersOnExit
3906 // was called, the Shutdown class would have already been loaded
3907 // (Runtime.addShutdownHook and runFinalizersOnExit will load it).
3908 instanceKlassHandle shutdown_klass (THREAD, k);
3909 JavaValue result(T_VOID);
3910 JavaCalls::call_static(&result,
3911 shutdown_klass,
3912 vmSymbols::shutdown_method_name(),
3913 vmSymbols::void_method_signature(),
3914 THREAD);
3915 }
3916 CLEAR_PENDING_EXCEPTION;
3917 }
3919 // Threads::destroy_vm() is normally called from jni_DestroyJavaVM() when
3920 // the program falls off the end of main(). Another VM exit path is through
3921 // vm_exit() when the program calls System.exit() to return a value or when
3922 // there is a serious error in VM. The two shutdown paths are not exactly
3923 // the same, but they share Shutdown.shutdown() at Java level and before_exit()
3924 // and VM_Exit op at VM level.
3925 //
3926 // Shutdown sequence:
3927 // + Shutdown native memory tracking if it is on
3928 // + Wait until we are the last non-daemon thread to execute
3929 // <-- every thing is still working at this moment -->
3930 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level
3931 // shutdown hooks, run finalizers if finalization-on-exit
3932 // + Call before_exit(), prepare for VM exit
3933 // > run VM level shutdown hooks (they are registered through JVM_OnExit(),
3934 // currently the only user of this mechanism is File.deleteOnExit())
3935 // > stop flat profiler, StatSampler, watcher thread, CMS threads,
3936 // post thread end and vm death events to JVMTI,
3937 // stop signal thread
3938 // + Call JavaThread::exit(), it will:
3939 // > release JNI handle blocks, remove stack guard pages
3940 // > remove this thread from Threads list
3941 // <-- no more Java code from this thread after this point -->
3942 // + Stop VM thread, it will bring the remaining VM to a safepoint and stop
3943 // the compiler threads at safepoint
3944 // <-- do not use anything that could get blocked by Safepoint -->
3945 // + Disable tracing at JNI/JVM barriers
3946 // + Set _vm_exited flag for threads that are still running native code
3947 // + Delete this thread
3948 // + Call exit_globals()
3949 // > deletes tty
3950 // > deletes PerfMemory resources
3951 // + Return to caller
3953 bool Threads::destroy_vm() {
3954 JavaThread* thread = JavaThread::current();
3956 #ifdef ASSERT
3957 _vm_complete = false;
3958 #endif
3959 // Wait until we are the last non-daemon thread to execute
3960 { MutexLocker nu(Threads_lock);
3961 while (Threads::number_of_non_daemon_threads() > 1 )
3962 // This wait should make safepoint checks, wait without a timeout,
3963 // and wait as a suspend-equivalent condition.
3964 //
3965 // Note: If the FlatProfiler is running and this thread is waiting
3966 // for another non-daemon thread to finish, then the FlatProfiler
3967 // is waiting for the external suspend request on this thread to
3968 // complete. wait_for_ext_suspend_completion() will eventually
3969 // timeout, but that takes time. Making this wait a suspend-
3970 // equivalent condition solves that timeout problem.
3971 //
3972 Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0,
3973 Mutex::_as_suspend_equivalent_flag);
3974 }
3976 // Hang forever on exit if we are reporting an error.
3977 if (ShowMessageBoxOnError && is_error_reported()) {
3978 os::infinite_sleep();
3979 }
3980 os::wait_for_keypress_at_exit();
3982 if (JDK_Version::is_jdk12x_version()) {
3983 // We are the last thread running, so check if finalizers should be run.
3984 // For 1.3 or later this is done in thread->invoke_shutdown_hooks()
3985 HandleMark rm(thread);
3986 Universe::run_finalizers_on_exit();
3987 } else {
3988 // run Java level shutdown hooks
3989 thread->invoke_shutdown_hooks();
3990 }
3992 before_exit(thread);
3994 thread->exit(true);
3996 // Stop VM thread.
3997 {
3998 // 4945125 The vm thread comes to a safepoint during exit.
3999 // GC vm_operations can get caught at the safepoint, and the
4000 // heap is unparseable if they are caught. Grab the Heap_lock
4001 // to prevent this. The GC vm_operations will not be able to
4002 // queue until after the vm thread is dead.
4003 // After this point, we'll never emerge out of the safepoint before
4004 // the VM exits, so concurrent GC threads do not need to be explicitly
4005 // stopped; they remain inactive until the process exits.
4006 // Note: some concurrent G1 threads may be running during a safepoint,
4007 // but these will not be accessing the heap, just some G1-specific side
4008 // data structures that are not accessed by any other threads but them
4009 // after this point in a terminal safepoint.
4011 MutexLocker ml(Heap_lock);
4013 VMThread::wait_for_vm_thread_exit();
4014 assert(SafepointSynchronize::is_at_safepoint(), "VM thread should exit at Safepoint");
4015 VMThread::destroy();
4016 }
4018 // clean up ideal graph printers
4019 #if defined(COMPILER2) && !defined(PRODUCT)
4020 IdealGraphPrinter::clean_up();
4021 #endif
4023 // Now, all Java threads are gone except daemon threads. Daemon threads
4024 // running Java code or in VM are stopped by the Safepoint. However,
4025 // daemon threads executing native code are still running. But they
4026 // will be stopped at native=>Java/VM barriers. Note that we can't
4027 // simply kill or suspend them, as it is inherently deadlock-prone.
4029 #ifndef PRODUCT
4030 // disable function tracing at JNI/JVM barriers
4031 TraceJNICalls = false;
4032 TraceJVMCalls = false;
4033 TraceRuntimeCalls = false;
4034 #endif
4036 VM_Exit::set_vm_exited();
4038 notify_vm_shutdown();
4040 delete thread;
4042 // exit_globals() will delete tty
4043 exit_globals();
4045 return true;
4046 }
4049 jboolean Threads::is_supported_jni_version_including_1_1(jint version) {
4050 if (version == JNI_VERSION_1_1) return JNI_TRUE;
4051 return is_supported_jni_version(version);
4052 }
4055 jboolean Threads::is_supported_jni_version(jint version) {
4056 if (version == JNI_VERSION_1_2) return JNI_TRUE;
4057 if (version == JNI_VERSION_1_4) return JNI_TRUE;
4058 if (version == JNI_VERSION_1_6) return JNI_TRUE;
4059 if (version == JNI_VERSION_1_8) return JNI_TRUE;
4060 return JNI_FALSE;
4061 }
4064 void Threads::add(JavaThread* p, bool force_daemon) {
4065 // The threads lock must be owned at this point
4066 assert_locked_or_safepoint(Threads_lock);
4068 // See the comment for this method in thread.hpp for its purpose and
4069 // why it is called here.
4070 p->initialize_queues();
4071 p->set_next(_thread_list);
4072 _thread_list = p;
4073 _number_of_threads++;
4074 oop threadObj = p->threadObj();
4075 bool daemon = true;
4076 // Bootstrapping problem: threadObj can be null for initial
4077 // JavaThread (or for threads attached via JNI)
4078 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) {
4079 _number_of_non_daemon_threads++;
4080 daemon = false;
4081 }
4083 p->set_safepoint_visible(true);
4085 ThreadService::add_thread(p, daemon);
4087 // Possible GC point.
4088 Events::log(p, "Thread added: " INTPTR_FORMAT, p);
4089 }
4091 void Threads::remove(JavaThread* p) {
4092 // Extra scope needed for Thread_lock, so we can check
4093 // that we do not remove thread without safepoint code notice
4094 { MutexLocker ml(Threads_lock);
4096 assert(includes(p), "p must be present");
4098 JavaThread* current = _thread_list;
4099 JavaThread* prev = NULL;
4101 while (current != p) {
4102 prev = current;
4103 current = current->next();
4104 }
4106 if (prev) {
4107 prev->set_next(current->next());
4108 } else {
4109 _thread_list = p->next();
4110 }
4111 _number_of_threads--;
4112 oop threadObj = p->threadObj();
4113 bool daemon = true;
4114 if (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj)) {
4115 _number_of_non_daemon_threads--;
4116 daemon = false;
4118 // Only one thread left, do a notify on the Threads_lock so a thread waiting
4119 // on destroy_vm will wake up.
4120 if (number_of_non_daemon_threads() == 1)
4121 Threads_lock->notify_all();
4122 }
4123 ThreadService::remove_thread(p, daemon);
4125 // Make sure that safepoint code disregard this thread. This is needed since
4126 // the thread might mess around with locks after this point. This can cause it
4127 // to do callbacks into the safepoint code. However, the safepoint code is not aware
4128 // of this thread since it is removed from the queue.
4129 p->set_terminated_value();
4131 // Now, this thread is not visible to safepoint
4132 p->set_safepoint_visible(false);
4133 // once the thread becomes safepoint invisible, we can not use its per-thread
4134 // recorder. And Threads::do_threads() no longer walks this thread, so we have
4135 // to release its per-thread recorder here.
4136 MemTracker::thread_exiting(p);
4137 } // unlock Threads_lock
4139 // Since Events::log uses a lock, we grab it outside the Threads_lock
4140 Events::log(p, "Thread exited: " INTPTR_FORMAT, p);
4141 }
4143 // Threads_lock must be held when this is called (or must be called during a safepoint)
4144 bool Threads::includes(JavaThread* p) {
4145 assert(Threads_lock->is_locked(), "sanity check");
4146 ALL_JAVA_THREADS(q) {
4147 if (q == p ) {
4148 return true;
4149 }
4150 }
4151 return false;
4152 }
4154 // Operations on the Threads list for GC. These are not explicitly locked,
4155 // but the garbage collector must provide a safe context for them to run.
4156 // In particular, these things should never be called when the Threads_lock
4157 // is held by some other thread. (Note: the Safepoint abstraction also
4158 // uses the Threads_lock to gurantee this property. It also makes sure that
4159 // all threads gets blocked when exiting or starting).
4161 void Threads::oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
4162 ALL_JAVA_THREADS(p) {
4163 p->oops_do(f, cld_f, cf);
4164 }
4165 VMThread::vm_thread()->oops_do(f, cld_f, cf);
4166 }
4168 void Threads::possibly_parallel_oops_do(OopClosure* f, CLDToOopClosure* cld_f, CodeBlobClosure* cf) {
4169 // Introduce a mechanism allowing parallel threads to claim threads as
4170 // root groups. Overhead should be small enough to use all the time,
4171 // even in sequential code.
4172 SharedHeap* sh = SharedHeap::heap();
4173 // Cannot yet substitute active_workers for n_par_threads
4174 // because of G1CollectedHeap::verify() use of
4175 // SharedHeap::process_strong_roots(). n_par_threads == 0 will
4176 // turn off parallelism in process_strong_roots while active_workers
4177 // is being used for parallelism elsewhere.
4178 bool is_par = sh->n_par_threads() > 0;
4179 assert(!is_par ||
4180 (SharedHeap::heap()->n_par_threads() ==
4181 SharedHeap::heap()->workers()->active_workers()), "Mismatch");
4182 int cp = SharedHeap::heap()->strong_roots_parity();
4183 ALL_JAVA_THREADS(p) {
4184 if (p->claim_oops_do(is_par, cp)) {
4185 p->oops_do(f, cld_f, cf);
4186 }
4187 }
4188 VMThread* vmt = VMThread::vm_thread();
4189 if (vmt->claim_oops_do(is_par, cp)) {
4190 vmt->oops_do(f, cld_f, cf);
4191 }
4192 }
4194 #if INCLUDE_ALL_GCS
4195 // Used by ParallelScavenge
4196 void Threads::create_thread_roots_tasks(GCTaskQueue* q) {
4197 ALL_JAVA_THREADS(p) {
4198 q->enqueue(new ThreadRootsTask(p));
4199 }
4200 q->enqueue(new ThreadRootsTask(VMThread::vm_thread()));
4201 }
4203 // Used by Parallel Old
4204 void Threads::create_thread_roots_marking_tasks(GCTaskQueue* q) {
4205 ALL_JAVA_THREADS(p) {
4206 q->enqueue(new ThreadRootsMarkingTask(p));
4207 }
4208 q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread()));
4209 }
4210 #endif // INCLUDE_ALL_GCS
4212 void Threads::nmethods_do(CodeBlobClosure* cf) {
4213 ALL_JAVA_THREADS(p) {
4214 p->nmethods_do(cf);
4215 }
4216 VMThread::vm_thread()->nmethods_do(cf);
4217 }
4219 void Threads::metadata_do(void f(Metadata*)) {
4220 ALL_JAVA_THREADS(p) {
4221 p->metadata_do(f);
4222 }
4223 }
4225 void Threads::gc_epilogue() {
4226 ALL_JAVA_THREADS(p) {
4227 p->gc_epilogue();
4228 }
4229 }
4231 void Threads::gc_prologue() {
4232 ALL_JAVA_THREADS(p) {
4233 p->gc_prologue();
4234 }
4235 }
4237 void Threads::deoptimized_wrt_marked_nmethods() {
4238 ALL_JAVA_THREADS(p) {
4239 p->deoptimized_wrt_marked_nmethods();
4240 }
4241 }
4244 // Get count Java threads that are waiting to enter the specified monitor.
4245 GrowableArray<JavaThread*>* Threads::get_pending_threads(int count,
4246 address monitor, bool doLock) {
4247 assert(doLock || SafepointSynchronize::is_at_safepoint(),
4248 "must grab Threads_lock or be at safepoint");
4249 GrowableArray<JavaThread*>* result = new GrowableArray<JavaThread*>(count);
4251 int i = 0;
4252 {
4253 MutexLockerEx ml(doLock ? Threads_lock : NULL);
4254 ALL_JAVA_THREADS(p) {
4255 if (p->is_Compiler_thread()) continue;
4257 address pending = (address)p->current_pending_monitor();
4258 if (pending == monitor) { // found a match
4259 if (i < count) result->append(p); // save the first count matches
4260 i++;
4261 }
4262 }
4263 }
4264 return result;
4265 }
4268 JavaThread *Threads::owning_thread_from_monitor_owner(address owner, bool doLock) {
4269 assert(doLock ||
4270 Threads_lock->owned_by_self() ||
4271 SafepointSynchronize::is_at_safepoint(),
4272 "must grab Threads_lock or be at safepoint");
4274 // NULL owner means not locked so we can skip the search
4275 if (owner == NULL) return NULL;
4277 {
4278 MutexLockerEx ml(doLock ? Threads_lock : NULL);
4279 ALL_JAVA_THREADS(p) {
4280 // first, see if owner is the address of a Java thread
4281 if (owner == (address)p) return p;
4282 }
4283 }
4284 // Cannot assert on lack of success here since this function may be
4285 // used by code that is trying to report useful problem information
4286 // like deadlock detection.
4287 if (UseHeavyMonitors) return NULL;
4289 //
4290 // If we didn't find a matching Java thread and we didn't force use of
4291 // heavyweight monitors, then the owner is the stack address of the
4292 // Lock Word in the owning Java thread's stack.
4293 //
4294 JavaThread* the_owner = NULL;
4295 {
4296 MutexLockerEx ml(doLock ? Threads_lock : NULL);
4297 ALL_JAVA_THREADS(q) {
4298 if (q->is_lock_owned(owner)) {
4299 the_owner = q;
4300 break;
4301 }
4302 }
4303 }
4304 // cannot assert on lack of success here; see above comment
4305 return the_owner;
4306 }
4308 // Threads::print_on() is called at safepoint by VM_PrintThreads operation.
4309 void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) {
4310 char buf[32];
4311 st->print_cr(os::local_time_string(buf, sizeof(buf)));
4313 st->print_cr("Full thread dump %s (%s %s):",
4314 Abstract_VM_Version::vm_name(),
4315 Abstract_VM_Version::vm_release(),
4316 Abstract_VM_Version::vm_info_string()
4317 );
4318 st->cr();
4320 #if INCLUDE_ALL_GCS
4321 // Dump concurrent locks
4322 ConcurrentLocksDump concurrent_locks;
4323 if (print_concurrent_locks) {
4324 concurrent_locks.dump_at_safepoint();
4325 }
4326 #endif // INCLUDE_ALL_GCS
4328 ALL_JAVA_THREADS(p) {
4329 ResourceMark rm;
4330 p->print_on(st);
4331 if (print_stacks) {
4332 if (internal_format) {
4333 p->trace_stack();
4334 } else {
4335 p->print_stack_on(st);
4336 }
4337 }
4338 st->cr();
4339 #if INCLUDE_ALL_GCS
4340 if (print_concurrent_locks) {
4341 concurrent_locks.print_locks_on(p, st);
4342 }
4343 #endif // INCLUDE_ALL_GCS
4344 }
4346 VMThread::vm_thread()->print_on(st);
4347 st->cr();
4348 Universe::heap()->print_gc_threads_on(st);
4349 WatcherThread* wt = WatcherThread::watcher_thread();
4350 if (wt != NULL) {
4351 wt->print_on(st);
4352 st->cr();
4353 }
4354 CompileBroker::print_compiler_threads_on(st);
4355 st->flush();
4356 }
4358 // Threads::print_on_error() is called by fatal error handler. It's possible
4359 // that VM is not at safepoint and/or current thread is inside signal handler.
4360 // Don't print stack trace, as the stack may not be walkable. Don't allocate
4361 // memory (even in resource area), it might deadlock the error handler.
4362 void Threads::print_on_error(outputStream* st, Thread* current, char* buf, int buflen) {
4363 bool found_current = false;
4364 st->print_cr("Java Threads: ( => current thread )");
4365 ALL_JAVA_THREADS(thread) {
4366 bool is_current = (current == thread);
4367 found_current = found_current || is_current;
4369 st->print("%s", is_current ? "=>" : " ");
4371 st->print(PTR_FORMAT, thread);
4372 st->print(" ");
4373 thread->print_on_error(st, buf, buflen);
4374 st->cr();
4375 }
4376 st->cr();
4378 st->print_cr("Other Threads:");
4379 if (VMThread::vm_thread()) {
4380 bool is_current = (current == VMThread::vm_thread());
4381 found_current = found_current || is_current;
4382 st->print("%s", current == VMThread::vm_thread() ? "=>" : " ");
4384 st->print(PTR_FORMAT, VMThread::vm_thread());
4385 st->print(" ");
4386 VMThread::vm_thread()->print_on_error(st, buf, buflen);
4387 st->cr();
4388 }
4389 WatcherThread* wt = WatcherThread::watcher_thread();
4390 if (wt != NULL) {
4391 bool is_current = (current == wt);
4392 found_current = found_current || is_current;
4393 st->print("%s", is_current ? "=>" : " ");
4395 st->print(PTR_FORMAT, wt);
4396 st->print(" ");
4397 wt->print_on_error(st, buf, buflen);
4398 st->cr();
4399 }
4400 if (!found_current) {
4401 st->cr();
4402 st->print("=>" PTR_FORMAT " (exited) ", current);
4403 current->print_on_error(st, buf, buflen);
4404 st->cr();
4405 }
4406 }
4408 // Internal SpinLock and Mutex
4409 // Based on ParkEvent
4411 // Ad-hoc mutual exclusion primitives: SpinLock and Mux
4412 //
4413 // We employ SpinLocks _only for low-contention, fixed-length
4414 // short-duration critical sections where we're concerned
4415 // about native mutex_t or HotSpot Mutex:: latency.
4416 // The mux construct provides a spin-then-block mutual exclusion
4417 // mechanism.
4418 //
4419 // Testing has shown that contention on the ListLock guarding gFreeList
4420 // is common. If we implement ListLock as a simple SpinLock it's common
4421 // for the JVM to devolve to yielding with little progress. This is true
4422 // despite the fact that the critical sections protected by ListLock are
4423 // extremely short.
4424 //
4425 // TODO-FIXME: ListLock should be of type SpinLock.
4426 // We should make this a 1st-class type, integrated into the lock
4427 // hierarchy as leaf-locks. Critically, the SpinLock structure
4428 // should have sufficient padding to avoid false-sharing and excessive
4429 // cache-coherency traffic.
4432 typedef volatile int SpinLockT ;
4434 void Thread::SpinAcquire (volatile int * adr, const char * LockName) {
4435 if (Atomic::cmpxchg (1, adr, 0) == 0) {
4436 return ; // normal fast-path return
4437 }
4439 // Slow-path : We've encountered contention -- Spin/Yield/Block strategy.
4440 TEVENT (SpinAcquire - ctx) ;
4441 int ctr = 0 ;
4442 int Yields = 0 ;
4443 for (;;) {
4444 while (*adr != 0) {
4445 ++ctr ;
4446 if ((ctr & 0xFFF) == 0 || !os::is_MP()) {
4447 if (Yields > 5) {
4448 // Consider using a simple NakedSleep() instead.
4449 // Then SpinAcquire could be called by non-JVM threads
4450 Thread::current()->_ParkEvent->park(1) ;
4451 } else {
4452 os::NakedYield() ;
4453 ++Yields ;
4454 }
4455 } else {
4456 SpinPause() ;
4457 }
4458 }
4459 if (Atomic::cmpxchg (1, adr, 0) == 0) return ;
4460 }
4461 }
4463 void Thread::SpinRelease (volatile int * adr) {
4464 assert (*adr != 0, "invariant") ;
4465 OrderAccess::fence() ; // guarantee at least release consistency.
4466 // Roach-motel semantics.
4467 // It's safe if subsequent LDs and STs float "up" into the critical section,
4468 // but prior LDs and STs within the critical section can't be allowed
4469 // to reorder or float past the ST that releases the lock.
4470 *adr = 0 ;
4471 }
4473 // muxAcquire and muxRelease:
4474 //
4475 // * muxAcquire and muxRelease support a single-word lock-word construct.
4476 // The LSB of the word is set IFF the lock is held.
4477 // The remainder of the word points to the head of a singly-linked list
4478 // of threads blocked on the lock.
4479 //
4480 // * The current implementation of muxAcquire-muxRelease uses its own
4481 // dedicated Thread._MuxEvent instance. If we're interested in
4482 // minimizing the peak number of extant ParkEvent instances then
4483 // we could eliminate _MuxEvent and "borrow" _ParkEvent as long
4484 // as certain invariants were satisfied. Specifically, care would need
4485 // to be taken with regards to consuming unpark() "permits".
4486 // A safe rule of thumb is that a thread would never call muxAcquire()
4487 // if it's enqueued (cxq, EntryList, WaitList, etc) and will subsequently
4488 // park(). Otherwise the _ParkEvent park() operation in muxAcquire() could
4489 // consume an unpark() permit intended for monitorenter, for instance.
4490 // One way around this would be to widen the restricted-range semaphore
4491 // implemented in park(). Another alternative would be to provide
4492 // multiple instances of the PlatformEvent() for each thread. One
4493 // instance would be dedicated to muxAcquire-muxRelease, for instance.
4494 //
4495 // * Usage:
4496 // -- Only as leaf locks
4497 // -- for short-term locking only as muxAcquire does not perform
4498 // thread state transitions.
4499 //
4500 // Alternatives:
4501 // * We could implement muxAcquire and muxRelease with MCS or CLH locks
4502 // but with parking or spin-then-park instead of pure spinning.
4503 // * Use Taura-Oyama-Yonenzawa locks.
4504 // * It's possible to construct a 1-0 lock if we encode the lockword as
4505 // (List,LockByte). Acquire will CAS the full lockword while Release
4506 // will STB 0 into the LockByte. The 1-0 scheme admits stranding, so
4507 // acquiring threads use timers (ParkTimed) to detect and recover from
4508 // the stranding window. Thread/Node structures must be aligned on 256-byte
4509 // boundaries by using placement-new.
4510 // * Augment MCS with advisory back-link fields maintained with CAS().
4511 // Pictorially: LockWord -> T1 <-> T2 <-> T3 <-> ... <-> Tn <-> Owner.
4512 // The validity of the backlinks must be ratified before we trust the value.
4513 // If the backlinks are invalid the exiting thread must back-track through the
4514 // the forward links, which are always trustworthy.
4515 // * Add a successor indication. The LockWord is currently encoded as
4516 // (List, LOCKBIT:1). We could also add a SUCCBIT or an explicit _succ variable
4517 // to provide the usual futile-wakeup optimization.
4518 // See RTStt for details.
4519 // * Consider schedctl.sc_nopreempt to cover the critical section.
4520 //
4523 typedef volatile intptr_t MutexT ; // Mux Lock-word
4524 enum MuxBits { LOCKBIT = 1 } ;
4526 void Thread::muxAcquire (volatile intptr_t * Lock, const char * LockName) {
4527 intptr_t w = Atomic::cmpxchg_ptr (LOCKBIT, Lock, 0) ;
4528 if (w == 0) return ;
4529 if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
4530 return ;
4531 }
4533 TEVENT (muxAcquire - Contention) ;
4534 ParkEvent * const Self = Thread::current()->_MuxEvent ;
4535 assert ((intptr_t(Self) & LOCKBIT) == 0, "invariant") ;
4536 for (;;) {
4537 int its = (os::is_MP() ? 100 : 0) + 1 ;
4539 // Optional spin phase: spin-then-park strategy
4540 while (--its >= 0) {
4541 w = *Lock ;
4542 if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
4543 return ;
4544 }
4545 }
4547 Self->reset() ;
4548 Self->OnList = intptr_t(Lock) ;
4549 // The following fence() isn't _strictly necessary as the subsequent
4550 // CAS() both serializes execution and ratifies the fetched *Lock value.
4551 OrderAccess::fence();
4552 for (;;) {
4553 w = *Lock ;
4554 if ((w & LOCKBIT) == 0) {
4555 if (Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
4556 Self->OnList = 0 ; // hygiene - allows stronger asserts
4557 return ;
4558 }
4559 continue ; // Interference -- *Lock changed -- Just retry
4560 }
4561 assert (w & LOCKBIT, "invariant") ;
4562 Self->ListNext = (ParkEvent *) (w & ~LOCKBIT );
4563 if (Atomic::cmpxchg_ptr (intptr_t(Self)|LOCKBIT, Lock, w) == w) break ;
4564 }
4566 while (Self->OnList != 0) {
4567 Self->park() ;
4568 }
4569 }
4570 }
4572 void Thread::muxAcquireW (volatile intptr_t * Lock, ParkEvent * ev) {
4573 intptr_t w = Atomic::cmpxchg_ptr (LOCKBIT, Lock, 0) ;
4574 if (w == 0) return ;
4575 if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
4576 return ;
4577 }
4579 TEVENT (muxAcquire - Contention) ;
4580 ParkEvent * ReleaseAfter = NULL ;
4581 if (ev == NULL) {
4582 ev = ReleaseAfter = ParkEvent::Allocate (NULL) ;
4583 }
4584 assert ((intptr_t(ev) & LOCKBIT) == 0, "invariant") ;
4585 for (;;) {
4586 guarantee (ev->OnList == 0, "invariant") ;
4587 int its = (os::is_MP() ? 100 : 0) + 1 ;
4589 // Optional spin phase: spin-then-park strategy
4590 while (--its >= 0) {
4591 w = *Lock ;
4592 if ((w & LOCKBIT) == 0 && Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
4593 if (ReleaseAfter != NULL) {
4594 ParkEvent::Release (ReleaseAfter) ;
4595 }
4596 return ;
4597 }
4598 }
4600 ev->reset() ;
4601 ev->OnList = intptr_t(Lock) ;
4602 // The following fence() isn't _strictly necessary as the subsequent
4603 // CAS() both serializes execution and ratifies the fetched *Lock value.
4604 OrderAccess::fence();
4605 for (;;) {
4606 w = *Lock ;
4607 if ((w & LOCKBIT) == 0) {
4608 if (Atomic::cmpxchg_ptr (w|LOCKBIT, Lock, w) == w) {
4609 ev->OnList = 0 ;
4610 // We call ::Release while holding the outer lock, thus
4611 // artificially lengthening the critical section.
4612 // Consider deferring the ::Release() until the subsequent unlock(),
4613 // after we've dropped the outer lock.
4614 if (ReleaseAfter != NULL) {
4615 ParkEvent::Release (ReleaseAfter) ;
4616 }
4617 return ;
4618 }
4619 continue ; // Interference -- *Lock changed -- Just retry
4620 }
4621 assert (w & LOCKBIT, "invariant") ;
4622 ev->ListNext = (ParkEvent *) (w & ~LOCKBIT );
4623 if (Atomic::cmpxchg_ptr (intptr_t(ev)|LOCKBIT, Lock, w) == w) break ;
4624 }
4626 while (ev->OnList != 0) {
4627 ev->park() ;
4628 }
4629 }
4630 }
4632 // Release() must extract a successor from the list and then wake that thread.
4633 // It can "pop" the front of the list or use a detach-modify-reattach (DMR) scheme
4634 // similar to that used by ParkEvent::Allocate() and ::Release(). DMR-based
4635 // Release() would :
4636 // (A) CAS() or swap() null to *Lock, releasing the lock and detaching the list.
4637 // (B) Extract a successor from the private list "in-hand"
4638 // (C) attempt to CAS() the residual back into *Lock over null.
4639 // If there were any newly arrived threads and the CAS() would fail.
4640 // In that case Release() would detach the RATs, re-merge the list in-hand
4641 // with the RATs and repeat as needed. Alternately, Release() might
4642 // detach and extract a successor, but then pass the residual list to the wakee.
4643 // The wakee would be responsible for reattaching and remerging before it
4644 // competed for the lock.
4645 //
4646 // Both "pop" and DMR are immune from ABA corruption -- there can be
4647 // multiple concurrent pushers, but only one popper or detacher.
4648 // This implementation pops from the head of the list. This is unfair,
4649 // but tends to provide excellent throughput as hot threads remain hot.
4650 // (We wake recently run threads first).
4652 void Thread::muxRelease (volatile intptr_t * Lock) {
4653 for (;;) {
4654 const intptr_t w = Atomic::cmpxchg_ptr (0, Lock, LOCKBIT) ;
4655 assert (w & LOCKBIT, "invariant") ;
4656 if (w == LOCKBIT) return ;
4657 ParkEvent * List = (ParkEvent *) (w & ~LOCKBIT) ;
4658 assert (List != NULL, "invariant") ;
4659 assert (List->OnList == intptr_t(Lock), "invariant") ;
4660 ParkEvent * nxt = List->ListNext ;
4662 // The following CAS() releases the lock and pops the head element.
4663 if (Atomic::cmpxchg_ptr (intptr_t(nxt), Lock, w) != w) {
4664 continue ;
4665 }
4666 List->OnList = 0 ;
4667 OrderAccess::fence() ;
4668 List->unpark () ;
4669 return ;
4670 }
4671 }
4674 void Threads::verify() {
4675 ALL_JAVA_THREADS(p) {
4676 p->verify();
4677 }
4678 VMThread* thread = VMThread::vm_thread();
4679 if (thread != NULL) thread->verify();
4680 }