thread.cpp revision 1614
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * This code is free software; you can redistribute it and/or modify it
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * under the terms of the GNU General Public License version 2 only, as
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * published by the Free Software Foundation.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * This code is distributed in the hope that it will be useful, but WITHOUT
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * version 2 for more details (a copy is included in the LICENSE file that
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * accompanied this code).
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * You should have received a copy of the GNU General Public License version
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * 2 along with this work; if not, write to the Free Software Foundation,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * or visit www.oracle.com if you need additional information or have any
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn * questions.
d5af1880773b35da2da505be54be517b746e7410ludovicp# include "incls/_precompiled.incl"
d5af1880773b35da2da505be54be517b746e7410ludovicp# include "incls/_thread.cpp.incl"
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Only bother with this argument setup if dtrace is available
d5af1880773b35da2da505be54be517b746e7410ludovicpHS_DTRACE_PROBE_DECL5(hotspot, thread__start, char*, intptr_t,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnHS_DTRACE_PROBE_DECL5(hotspot, thread__stop, char*, intptr_t,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn const char* name = (javathread)->get_thread_name(); \
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn java_lang_Thread::thread_id((javathread)->threadObj()), \
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn java_lang_Thread::is_daemon((javathread)->threadObj())); \
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn#else // ndef DTRACE_ENABLED
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma#endif // ndef DTRACE_ENABLED
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Class hierarchy
d5af1880773b35da2da505be54be517b746e7410ludovicp// - VMThread
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// - WatcherThread
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// - ConcurrentMarkSweepThread
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// - JavaThread
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// - CompilerThread
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// ======= Thread ========
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// Support for forcing alignment of thread objects for biased locking
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift const int alignment = markOopDesc::biased_lock_alignment;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn size_t aligned_size = size + (alignment - sizeof(intptr_t));
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn void* real_malloc_addr = CHeapObj::operator new(aligned_size);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn assert(((uintptr_t) aligned_addr + (uintptr_t) size) <=
e89b8e1cf5e7165e6453cd4fe8e57359f6ee2d01hajma ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size),
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift "JavaThread alignment code overflowed allocated storage");
d5af1880773b35da2da505be54be517b746e7410ludovicp tty->print_cr("Aligned thread " INTPTR_FORMAT " to " INTPTR_FORMAT,
d5af1880773b35da2da505be54be517b746e7410ludovicp ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnvoid Thread::operator delete(void* p) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn void* real_malloc_addr = ((Thread*) p)->_real_malloc_address;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn CHeapObj::operator delete(p);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// JavaThread
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // allocated data structures
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // This initial value ==> never claimed.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // the handle mark links itself to last_handle_mark
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // plain initialization
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift CHECK_UNHANDLED_OOPS_ONLY(_gc_locked_out_count = 0;)
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift _SR_lock = new Monitor(Mutex::suspend_resume, "SR_lock", true);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // thread-specific hashCode stream generator state - Marsaglia shift-xor form
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn _hashStateZ = 0x8767 ; // (int)(3579807591LL & 0xffff) ;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Many of the following fields are effectively final - immutable
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Note that nascent threads can't use the Native Monitor-Mutex
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // construct until the _MutexEvent is initialized ...
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // CONSIDER: instead of using a fixed set of purpose-dedicated ParkEvents
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // we might instead use a stack of ParkEvents that we could provision on-demand.
d550ed97bd4eb1658565af49c77579295d60c46ahajma // The stack would act as a cache to avoid calls to ParkEvent::Allocate()
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // and ::Release()
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn#endif // CHECK_UNHANDLED_OOPS
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn assert((((uintptr_t) this) & (markOopDesc::biased_lock_alignment - 1)) == 0, "forced alignment of thread object failed");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn this == (void*) align_size_up((intptr_t) _real_malloc_address, markOopDesc::biased_lock_alignment),
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn "bug in forced alignment of thread objects");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn#endif /* ASSERT */
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swiftvoid Thread::initialize_thread_local_storage() {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // Note: Make sure this method only calls
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // non-blocking operations. Otherwise, it might not work
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // with the thread-startup/safepoint interaction.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // During Java thread startup, safepoint code should allow this
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // method to complete because it may need to allocate memory to
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // store information for the new thread.
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // initialize structure dependent on thread local storage
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // set up any platform-specific state.
6df86604699d401d24863654538c078d3750963ashankar_mbn // Reclaim the objectmonitors from the omFreeList of the moribund thread.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // deallocate data structures
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // since the handle marks are using the handle area, we have to deallocated the root
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // handle mark before deallocating the thread's handle area,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn assert(last_handle_mark() != NULL, "check we have an element");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn assert(last_handle_mark() == NULL, "check we have reached the end");
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // It's possible we can encounter a null _ParkEvent, etc., in stillborn threads.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // We NULL out the fields for good hygiene.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn ParkEvent::Release (_ParkEvent) ; _ParkEvent = NULL ;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn ParkEvent::Release (_SleepEvent) ; _SleepEvent = NULL ;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn ParkEvent::Release (_MutexEvent) ; _MutexEvent = NULL ;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn ParkEvent::Release (_MuxEvent) ; _MuxEvent = NULL ;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // osthread() can be NULL, if creation of thread failed.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn if (osthread() != NULL) os::free_thread(osthread());
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // clear thread local storage if the Thread is deleting itself
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // In the case where we're not the current thread, invalidate all the
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // caches in case some code tries to get the current thread or the
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // thread that was destroyed, and gets stale information.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn CHECK_UNHANDLED_OOPS_ONLY(if (CheckUnhandledOops) delete unhandled_oops();)
6df86604699d401d24863654538c078d3750963ashankar_mbn// NOTE: dummy function for assertion purpose.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Private method to check for dangling thread pointer
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnvoid check_for_dangling_thread_pointer(Thread *thread) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn assert(!thread->is_Java_thread() || Thread::current() == thread || Threads_lock->owned_by_self(),
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn "possibility of dangling Thread pointer");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Tracing method for basic thread operations
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnvoid Thread::trace(const char* msg, const Thread* const thread) {
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // The Threads_lock must be held to get information about
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // this thread but may not be in some situations when
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // tracing thread events.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn tty->print_cr("Thread::%s " INTPTR_FORMAT " [%lx] %s (prio: %d)", msg, thread, thread->osthread()->thread_id(), name, prio);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swiftThreadPriority Thread::get_priority(const Thread* const thread) {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // Can return an error!
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift assert(MinPriority <= priority && priority <= MaxPriority, "non-Java priority found");
6df86604699d401d24863654538c078d3750963ashankar_mbnvoid Thread::set_priority(Thread* thread, ThreadPriority priority) {
6df86604699d401d24863654538c078d3750963ashankar_mbn debug_only(check_for_dangling_thread_pointer(thread);)
6df86604699d401d24863654538c078d3750963ashankar_mbn // Can return an error!
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Start is different from resume in that its safety is guaranteed by context or
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // being called from a Java method synchronized on the Thread object.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Initialize the thread state to RUNNABLE before starting this thread.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Can not set it after the thread started because we do not know the
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // exact thread state at that time. It could be in MONITOR_WAIT or
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // in SLEEPING or some other state.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift java_lang_Thread::set_thread_status(((JavaThread*)thread)->threadObj(),
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Enqueue a VM_Operation to do the job for us - sometime later
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnvoid Thread::send_async_exception(oop java_thread, oop java_throwable) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn VM_ThreadStop* vm_stop = new VM_ThreadStop(java_thread, java_throwable);
e89b8e1cf5e7165e6453cd4fe8e57359f6ee2d01hajma// Check if an external suspend request has completed (or has been
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// cancelled). Returns true if the thread is externally suspended and
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// false otherwise.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// The bits parameter returns information about the code path through
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// the routine. Useful for debugging:
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// set in is_ext_suspend_completed():
d5af1880773b35da2da505be54be517b746e7410ludovicp// 0x00000001 - routine was entered
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// 0x00000010 - routine return false at end
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00000100 - thread exited (return false)
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// 0x00000200 - suspend request cancelled (return false)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00000400 - thread suspended (return true)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00001000 - thread is in a suspend equivalent state (return true)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00002000 - thread is native and walkable (return true)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00004000 - thread is native_trans and walkable (needed retry)
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// set in wait_for_ext_suspend_completion():
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// 0x00010000 - routine was entered
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00020000 - suspend request cancelled before loop (return false)
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// 0x00040000 - thread suspended before loop (return true)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00080000 - suspend request cancelled in loop (return false)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00100000 - thread suspended in loop (return true)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00200000 - suspend not completed during retry loop (return false)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Helper class for tracing suspend wait debug bits.
6df86604699d401d24863654538c078d3750963ashankar_mbn// 0x00000100 indicates that the target thread exited before it could
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// self-suspend which is not a wait failure. 0x00000200, 0x00020000 and
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// 0x00080000 each indicate a cancelled suspend request so they don't
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// count as wait failures either.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn#define DEBUG_FALSE_BITS (0x00000010 | 0x00200000)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn TraceSuspendDebugBits(JavaThread *_jt, bool _is_wait, bool _called_by_wait,
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // By default, don't trace bits for is_ext_suspend_completed() calls.
e89b8e1cf5e7165e6453cd4fe8e57359f6ee2d01hajma // That trace is very chatty.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // If tracing for is_ext_suspend_completed() is enabled, then only
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // trace calls to it from wait_for_ext_suspend_completion()
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma if (AssertOnSuspendWaitFailure || TraceSuspendWaitFailures) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn if (bits != NULL && (*bits & DEBUG_FALSE_BITS) != 0) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn MutexLocker ml(Threads_lock); // needed for get_thread_name()
d5af1880773b35da2da505be54be517b746e7410ludovicp "Failed wait_for_ext_suspend_completion(thread=%s, debug_bits=%x)",
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn guarantee(!AssertOnSuspendWaitFailure, "external suspend wait failed");
6df86604699d401d24863654538c078d3750963ashankar_mbnbool JavaThread::is_ext_suspend_completed(bool called_by_wait, int delay, uint32_t *bits) {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift TraceSuspendDebugBits tsdb(this, false /* !is_wait */, called_by_wait, bits);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift bool did_trans_retry = false; // only do thread_in_native_trans retry once
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Thread is in the process of exiting. This is always checked
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // first to reduce the risk of dereferencing a freed JavaThread.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Suspend request is cancelled. This is always checked before
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // is_ext_suspended() to reduce the risk of a rogue resume
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // confusing the thread that made the suspend request.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // thread is suspended
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Now that we no longer do hard suspends of threads running
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // native code, the target thread can be changing thread state
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // while we are in this routine:
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // _thread_in_native -> _thread_in_native_trans -> _thread_blocked
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // We save a copy of the thread state as observed at this moment
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // and make our decision about suspend completeness based on the
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // copy. This closes the race where the thread state is seen as
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // _thread_in_native_trans in the if-thread_blocked check, but is
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // seen as _thread_blocked in if-thread_in_native_trans check.
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma if (save_state == _thread_blocked && is_suspend_equivalent()) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // If the thread's state is _thread_blocked and this blocking
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // condition is known to be equivalent to a suspend, then we can
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // consider the thread to be externally suspended. This means that
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // the code that sets _thread_blocked has been modified to do
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // self-suspension if the blocking condition releases. We also
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // used to check for CONDVAR_WAIT here, but that is now covered by
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // the _thread_blocked with self-suspension check.
6df86604699d401d24863654538c078d3750963ashankar_mbn // Return true since we wouldn't be here unless there was still an
6df86604699d401d24863654538c078d3750963ashankar_mbn // external suspend request.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn } else if (save_state == _thread_in_native && frame_anchor()->walkable()) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Threads running native code will self-suspend on native==>VM/Java
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // transitions. If its stack is walkable (should always be the case
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // unless this function is called before the actual java_suspend()
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // call), then the wait is done.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn } else if (!called_by_wait && !did_trans_retry &&
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // The thread is transitioning from thread_in_native to another
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // thread state. check_safepoint_and_suspend_for_native_trans()
6df86604699d401d24863654538c078d3750963ashankar_mbn // will force the thread to self-suspend. If it hasn't gotten
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // there yet we may have caught the thread in-between the native
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // code check above and the self-suspend. Lucky us. If we were
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // called by wait_for_ext_suspend_completion(), then it
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // will be doing the retries so we don't have to.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Since we use the saved thread state in the if-statement above,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // there is a chance that the thread has already transitioned to
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // _thread_blocked by the time we get here. In that case, we will
d550ed97bd4eb1658565af49c77579295d60c46ahajma // make a single unnecessary pass through the logic below. This
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // doesn't hurt anything since we still do the trans retry.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Once the thread leaves thread_in_native_trans for another
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // thread state, we break out of this retry loop. We shouldn't
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // need this flag to prevent us from getting back here, but
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // sometimes paranoia is good.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // We wait for the thread to transition to a more usable state.
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // We used to do an "os::yield_all(i)" call here with the intention
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // that yielding would increase on each retry. However, the parameter
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // is ignored on Linux which means the yield didn't scale up. Waiting
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // on the SR_lock below provides a much more predictable scale up for
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // the delay. It also provides a simple/direct point to check for any
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // safepoint requests from the VMThread
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // temporarily drops SR_lock while doing wait with safepoint check
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // (if we're a JavaThread - the WatcherThread can also call this)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // and increase delay with each retry
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // check the actual thread state instead of what we saved above
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn if (thread_state() != _thread_in_native_trans) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // the thread has transitioned to another thread state so
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // try all the checks (except this one) one more time.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift } // end retry loop
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// Wait for an external suspend request to complete (or be cancelled).
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// Returns true if the thread is externally suspended and false otherwise.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swiftbool JavaThread::wait_for_ext_suspend_completion(int retries, int delay,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn TraceSuspendDebugBits tsdb(this, true /* is_wait */,
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // local flag copies to minimize SR_lock hold time
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // set a marker so is_ext_suspend_completed() knows we are the caller
d550ed97bd4eb1658565af49c77579295d60c46ahajma // We use reset_bits to reinitialize the bits value at the top of
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // each retry loop. This allows the caller to make use of any
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // unused bits for their own marking purposes.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift MutexLockerEx ml(SR_lock(), Mutex::_no_safepoint_check_flag);
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // must release SR_lock to allow suspension to complete
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // A cancelled suspend request is the only false return from
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // is_ext_suspend_completed() that keeps us from entering the
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // retry loop.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return true;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn *bits = reset_bits; // reinit to only track last retry
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // We used to do an "os::yield_all(i)" call here with the intention
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // that yielding would increase on each retry. However, the parameter
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // is ignored on Linux which means the yield didn't scale up. Waiting
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // on the SR_lock below provides a much more predictable scale up for
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // the delay. It also provides a simple/direct point to check for any
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // safepoint requests from the VMThread
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // wait with safepoint check (if we're a JavaThread - the WatcherThread
d5af1880773b35da2da505be54be517b746e7410ludovicp // can also call this) and increase delay with each retry
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn SR_lock()->wait(!Thread::current()->is_Java_thread(), i * delay);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn is_suspended = is_ext_suspend_completed(true /* called_by_wait */,
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // It is possible for the external suspend request to be cancelled
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // (by a resume) before the actual suspend operation is completed.
d5af1880773b35da2da505be54be517b746e7410ludovicp // Refresh our local copy to see if we still need to wait.
d5af1880773b35da2da505be54be517b746e7410ludovicp // A cancelled suspend request is the only false return from
d5af1880773b35da2da505be54be517b746e7410ludovicp // is_ext_suspend_completed() that keeps us from staying in the
d5af1880773b35da2da505be54be517b746e7410ludovicp // retry loop.
d5af1880773b35da2da505be54be517b746e7410ludovicp return false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return true;
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift } // end retry loop
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // thread did not suspend after all our retries
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma return false;
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swiftvoid JavaThread::record_jump(address target, address instr, const char* file, int line) {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // This should not need to be atomic as the only way for simultaneous
f30ee734ac0ee8b792c77ab3bc42494fcddb1508hajma // updates is via interrupts. Even then this should be rare or non-existant
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // and we don't care that much anyway.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn _jmp_ring_index = (index + 1 ) & (jump_ring_buffer_size - 1);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift _jmp_ring[index]._instruction = (intptr_t) instr;
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift#endif /* PRODUCT */
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// Called by flat profiler
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// Callers have already called wait_for_ext_suspend_completion
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// The assertion for that is currently too complex to put here:
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnbool JavaThread::profile_last_Java_frame(frame* _fr) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn bool gotframe = false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // self suspension saves needed state.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn if (has_last_Java_frame() && _anchor.walkable()) {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift debug_only(check_for_dangling_thread_pointer(thread);)
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swiftbool Thread::is_interrupted(Thread* thread, bool clear_interrupted) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn debug_only(check_for_dangling_thread_pointer(thread);)
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // Note: If clear_interrupted==false, this simply fetches and
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma // returns the value of the field osthread()->interrupted().
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// GC Support
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnbool Thread::claim_oops_do_par_case(int strong_roots_parity) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn jint res = Atomic::cmpxchg(strong_roots_parity, &_oops_do_parity, thread_parity);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn guarantee(res == strong_roots_parity, "Or else what?");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn "Should only fail when parallel.");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn "Should only fail when parallel.");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
074f2520bc04a7a93b4123bc58fb40055c9174d2hajmavoid Thread::oops_do(OopClosure* f, CodeBlobClosure* cf) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Do oop for ThreadShadow
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // no nmethods in a generic thread...
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // get_priority assumes osthread initialized
3e8ebc69e18e02f0935b37e8f5837aab18557f50ludovicp st->print("prio=%d tid=" INTPTR_FORMAT " ", get_priority(this), this);
6df86604699d401d24863654538c078d3750963ashankar_mbn debug_only(if (WizardMode) print_owned_locks_on(st);)
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Thread::print_on_error() is called by fatal error handler. Don't use
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma// any lock or allocate memory.
074f2520bc04a7a93b4123bc58fb40055c9174d2hajmavoid Thread::print_on_error(outputStream* st, char* buf, int buflen) const {
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma else if (is_Compiler_thread()) st->print("CompilerThread");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn else if (is_Java_thread()) st->print("JavaThread");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn else if (is_GC_task_thread()) st->print("GCTaskThread");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn else if (is_Watcher_thread()) st->print("WatcherThread");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn else if (is_ConcurrentGC_thread()) st->print("ConcurrentGCThread");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn st->print(" [stack: " PTR_FORMAT "," PTR_FORMAT "]",
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnvoid Thread::print_owned_locks_on(outputStream* st) const {
074f2520bc04a7a93b4123bc58fb40055c9174d2hajmastatic int ref_use_count = 0;
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// The flag: potential_vm_operation notifies if this particular safepoint state could potential
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// invoke the vm-thread (i.e., and oop allocation). In that case, we also have to make sure that
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// no threads which allow_vm_block's are held
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swiftvoid Thread::check_for_valid_safepoint_state(bool potential_vm_operation) {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // Check if current thread is allowed to block at a safepoint
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift fatal("Possible safepoint reached by thread that does not allow it");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn if (is_Java_thread() && ((JavaThread*)this)->thread_state() != _thread_in_vm) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Make sure we do not hold any locks that the VM thread also uses.
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // This could potentially lead to deadlocks
d5af1880773b35da2da505be54be517b746e7410ludovicp for(Monitor *cur = _owned_locks; cur; cur = cur->next()) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Threads_lock is special, since the safepoint synchronization will not start before this is
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // acquired. Hence, a JavaThread cannot be holding it at a safepoint. So is VMOperationRequest_lock,
d550ed97bd4eb1658565af49c77579295d60c46ahajma // since it is used to transfer control between JavaThreads and the VMThread
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // Do not *exclude* any locks unless you are absolutly sure it is correct. Ask someone else first!
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift cur != Compile_lock && // Temporary: should not be necessary when we get spearate compilation
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift warning("Thread holding lock at safepoint that vm can block on: %s", cur->name());
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn // We could enter a safepoint here and thus have a gc
e0796af4a59f1d5667632857f3e59d4f4a778e4eludo assert(Thread::current() == this, "is_in_stack can only be called from current thread");
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn if (stack_base() >= adr && adr >= end) return true;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn return false;
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// We had to move these methods here, because vm threads get into ObjectSynchronizer::enter
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// However, there is a note in JavaThread::is_lock_owned() about the VM threads not being
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// used for compilation in the future. If that change is made, the need for these methods
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// should be revisited, and they should be removed if possible.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift return (_stack_base >= adr && adr >= (_stack_base - _stack_size));
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift // NOTE: this must be called inside the main thread.
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift return os::create_main_thread((JavaThread*)this);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnstatic void initialize_class(symbolHandle class_name, TRAPS) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn klassOop klass = SystemDictionary::resolve_or_fail(class_name, true, CHECK);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift// Creates the initial ThreadGroup
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbnstatic Handle create_initial_thread_group(TRAPS) {
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_ThreadGroup(), true, CHECK_NH);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift Universe::set_system_thread_group(system_instance());
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift Handle string = java_lang_String::create_from_str("main", CHECK_NH);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift vmSymbolHandles::threadgroup_string_void_signature(),
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn// Creates the initial Thread
e0796af4a59f1d5667632857f3e59d4f4a778e4eludostatic oop create_initial_thread(Handle thread_group, JavaThread* thread, TRAPS) {
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK_NULL);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn java_lang_Thread::set_thread(thread_oop(), thread);
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift java_lang_Thread::set_priority(thread_oop(), NormPriority);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn vmSymbolHandles::threadgroup_string_void_signature(),
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
9def8137e705ec92bc3a2881a8457795c860fdb1shankar_mbn JavaCalls::call_static(&result, klass, vmSymbolHandles::initializeSystemClass_name(),
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift vmSymbolHandles::void_method_signature(), CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicpstatic void set_jkernel_boot_classloader_hook(TRAPS) {
074f2520bc04a7a93b4123bc58fb40055c9174d2hajma klassOop k = SystemDictionary::sun_jkernel_DownloadManager_klass();
b3d0736ce9ff54f95fc06741c7279172f961363fshankar_mbn // sun.jkernel.DownloadManager may not present in the JDK; just return
62ecec3a82a8b838ee76c1f6610902d8fd7015cbmatthew_swift JavaCalls::call_static(&result, klass, vmSymbolHandles::setBootClassLoaderHook_name(),
3e8ebc69e18e02f0935b37e8f5837aab18557f50ludovicp#endif // KERNEL
d5af1880773b35da2da505be54be517b746e7410ludovicp // the vm info string
d5af1880773b35da2da505be54be517b746e7410ludovicp const char *vm_info = VM_Version::vm_info_string();
d5af1880773b35da2da505be54be517b746e7410ludovicp // java.lang.System class
d5af1880773b35da2da505be54be517b746e7410ludovicp klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_System(), true, CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicp // setProperty arguments
d5af1880773b35da2da505be54be517b746e7410ludovicp Handle key_str = java_lang_String::create_from_str("java.vm.info", CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicp Handle value_str = java_lang_String::create_from_str(vm_info, CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicp // return value
d5af1880773b35da2da505be54be517b746e7410ludovicp // public static String setProperty(String key, String value);
d5af1880773b35da2da505be54be517b746e7410ludovicpvoid JavaThread::allocate_threadObj(Handle thread_group, char* thread_name, bool daemon, TRAPS) {
d5af1880773b35da2da505be54be517b746e7410ludovicp assert(thread_group.not_null(), "thread group should be specified");
d5af1880773b35da2da505be54be517b746e7410ludovicp assert(threadObj() == NULL, "should only create Java thread object once");
d5af1880773b35da2da505be54be517b746e7410ludovicp klassOop k = SystemDictionary::resolve_or_fail(vmSymbolHandles::java_lang_Thread(), true, CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicp instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicp java_lang_Thread::set_priority(thread_oop(), NormPriority);
d5af1880773b35da2da505be54be517b746e7410ludovicp Handle name = java_lang_String::create_from_str(thread_name, CHECK);
d5af1880773b35da2da505be54be517b746e7410ludovicp // Thread gets assigned specified name and null target
THREAD);
THREAD);
if (daemon) {
if (HAS_PENDING_EXCEPTION) {
THREAD);
_watcher_thread = this;
if (!DisableStartThread) {
this->record_stack_base_and_size();
this->initialize_thread_local_storage();
while(!_should_terminate) {
if (time_to_wait <= 0)
if (is_error_reported()) {
_should_terminate = true;
_should_terminate = false;
new WatcherThread();
_should_terminate = true;
_suspend_equivalent = false;
_in_deopt_handler = 0;
_doing_unsafe_access = false;
_exception_pc = 0;
_interp_only_mode = 0;
_is_compiling = false;
_blocked_on_compilation = false;
_jni_active_critical = 0;
_do_not_unlock_if_synchronized = false;
#ifndef PRODUCT
_jmp_ring_index = 0;
#ifndef SERIALGC
Thread()
#ifndef SERIALGC
initialize();
if (register_stack_overflow()) {
guarantee(cur_sp > stack_yellow_zone_base(), "not enough space to reguard - increase StackShadowPages");
Thread()
#ifndef SERIALGC
if (TraceThreadEvents) {
initialize();
_is_attaching = false;
if (TraceThreadEvents) {
delete old_info;
delete old_array;
delete dlv;
delete deferred;
this->initialize_tlab();
this->record_base_of_stack_pointer();
this->record_stack_base_and_size();
this->initialize_thread_local_storage();
this->create_stack_guard_pages();
this->cache_global_variables();
this->entry_point()(this, this);
this->exit(false);
if (!InitializeJavaLangSystem) return;
this->clear_pending_exception();
THREAD);
THREAD);
// Call Thread.exit(). We try 3 times in case we got another Thread.stop during
// the execution of the method. If that is not enough, then we don't really care. Thread.stop
THREAD);
if (!is_external_suspend()) {
ensure_join(this);
if (UseTLAB) {
#ifndef SERIALGC
if (UseG1GC) {
// Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
#ifndef SERIALGC
if (UseTLAB) {
#ifndef SERIALGC
if (UseG1GC) {
return ret;
if (is_at_poll_safepoint()) {
if (TraceExceptions) {
if (!has_pending_exception() || !pending_exception()->is_a(SystemDictionary::ThreadDeath_klass())) {
if (TraceExceptions) {
if (has_last_Java_frame() ) {
tty->print_cr(" of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
if (check_unsafe_error &&
switch (thread_state()) {
case _thread_in_vm:
THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
case _thread_in_native:
THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in an unsafe memory access operation");
case _thread_in_Java:
THROW_MSG(vmSymbols::java_lang_InternalError(), "a fault occurred in a recent unsafe memory access operation in compiled Java code");
// constructor/destructor pair because they assert on that type of
if (check_asyncs) {
if (is_Compiler_thread()) return;
if (_pending_async_exception == NULL || !_pending_async_exception->is_a(SystemDictionary::ThreadDeath_klass())) {
if (has_last_Java_frame()) {
if (TraceExceptions) {
tty->print_cr("Pending Async. exception installed of type: %s", instanceKlass::cast(_pending_async_exception->klass())->external_name());
NOT_PRODUCT(Exceptions::debug_check_abort(instanceKlass::cast(_pending_async_exception->klass())->external_name()));
if (!is_external_suspend()) {
int ret = 0;
if (is_exiting()) {
return ret;
if (this->is_suspend_equivalent()) {
this->clear_suspend_equivalent();
while (is_external_suspend()) {
ret++;
this->set_ext_suspended();
while (is_ext_suspended()) {
return ret;
#ifdef ASSERT
assert(!curJT->has_last_Java_frame() || curJT->frame_anchor()->walkable(), "Unwalkable stack in native->vm transition");
if (UseMembar) {
if (is_ext_suspended()) {
if (!has_last_Java_frame()) return;
#ifndef PRODUCT
if (only_at) {
if (!found) {
trace_frames();
trace_stack();
trace_frames();
if (!has_last_Java_frame()) return;
if (_cur_thr) {
if (has_last_Java_frame()) {
if (has_last_Java_frame()) {
switch (_thread_state) {
#ifndef PRODUCT
#ifndef PRODUCT
if (osthread()) {
#ifdef ASSERT
return get_thread_name_string();
const char* name_str;
return name_str;
return str;
return NULL;
return str;
return NULL;
return priority;
return NULL;
if (!has_last_Java_frame()) return;
int count = 0;
if (f->is_java_frame()) {
if (JavaMonitorsInStackTrace) {
count++;
return _popframe_preserved_args;
#ifndef PRODUCT
if (f->is_java_frame()) {
f->print();
if (!has_last_Java_frame()) return;
return NULL;
return NULL;
#ifndef PRODUCT
void os_stream();
ALL_JAVA_THREADS(p) {
extern void JDK_Version_init();
ostream_init();
if (PauseAtStartup) {
_number_of_threads = 0;
delete main_thread;
return JNI_ENOMEM;
// crash Linux VM, see notes in os_linux.cpp.
delete main_thread;
return status;
if (VerifyBeforeGC &&
if (DumpSharedSpaces) {
if (InitializeJavaLangString) {
if (AggressiveOpts) {
#ifdef ASSERT
klassOop tmp_k = SystemDictionary::find(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_util_HashMap(), Handle(), Handle(), CHECK_0);
if (UseStringCache) {
// Forcibly initialize java/lang/StringValue and mutate the private
klassOop k_o = SystemDictionary::resolve_or_null(vmSymbolHandles::java_lang_StringValue(), Handle(), Handle(), CHECK_0);
if (InitializeJavaLangSystem) {
if (EnableInvokeDynamic) {
// property"java.compiler" and read & write property "java.vm.info".
// option "-Djava.security.manager", the above properties are not
// Future Fix : the best fix is to grant everyone permissions to read "java.compiler" and
if (HAS_PENDING_EXCEPTION) {
#ifdef KERNEL
#ifndef SERIALGC
if (UseConcMarkSweepGC) {
if (HAS_PENDING_EXCEPTION) {
if (!DisableAttachMechanism) {
if (HAS_PENDING_EXCEPTION) {
return JNI_OK;
// num_symbol_entries must be passed-in since only the caller knows the number of symbols in the array.
static OnLoadEntry_t lookup_on_load(AgentLibrary* agent, const char *on_load_symbols[], size_t num_symbol_entries) {
#ifdef KERNEL
on_load_entry = CAST_TO_FN_PTR(OnLoadEntry_t, hpi::dll_lookup(library, on_load_symbols[symbol_index]));
return on_load_entry;
vm_exit_during_initialization("Could not find JVM_OnLoad or Agent_OnLoad function in the library", agent->name());
vm_exit_during_initialization("Could not find Agent_OnLoad function in the agent library", agent->name());
// Called for after the VM is initialized for -Xrun libraries which have not been converted to agent libraries
vm_exit_during_initialization("Could not find JVM_OnLoad function in -Xrun library", agent->name());
// Last thread running calls java.lang.Shutdown.shutdown()
if (this->has_pending_exception()) {
this->clear_pending_exception();
klassOop k =
THREAD);
if (k != NULL) {
// call Shutdown.shutdown() at all. This will mean the shutdown hooks
THREAD);
// the same, but they share Shutdown.shutdown() at Java level and before_exit()
// + Call java.lang.Shutdown.shutdown(), which will invoke Java level
#ifndef PRODUCT
TraceHPI = false;
TraceJNICalls = false;
TraceJVMCalls = false;
TraceRuntimeCalls = false;
delete thread;
exit_globals();
return JNI_FALSE;
_thread_list = p;
bool daemon = true;
daemon = false;
while (current != p) {
if (prev) {
bool daemon = true;
daemon = false;
p->set_terminated_value();
ALL_JAVA_THREADS(q) {
ALL_JAVA_THREADS(p) {
ALL_JAVA_THREADS(p) {
#ifndef SERIALGC
ALL_JAVA_THREADS(p) {
ALL_JAVA_THREADS(p) {
ALL_JAVA_THREADS(p) {
ALL_JAVA_THREADS(p) {
p->gc_epilogue();
ALL_JAVA_THREADS(p) {
p->gc_prologue();
ALL_JAVA_THREADS(p) {
ALL_JAVA_THREADS(p) {
if (p->is_Compiler_thread()) continue;
return result;
ALL_JAVA_THREADS(p) {
ALL_JAVA_THREADS(q) {
the_owner = q;
return the_owner;
void Threads::print_on(outputStream* st, bool print_stacks, bool internal_format, bool print_concurrent_locks) {
#ifndef SERIALGC
if (print_concurrent_locks) {
ALL_JAVA_THREADS(p) {
if (print_stacks) {
if (internal_format) {
p->trace_stack();
#ifndef SERIALGC
if (print_concurrent_locks) {
bool found_current = false;
if (!found_current) {
return ev ;
void ParkEvent::operator delete (void * a) {
Parker * p ;
p = FreeList ;
if (p == NULL) break ;
if (p != NULL) {
p = new Parker() ;
if (p == NULL) return ;
ALL_JAVA_THREADS(p) {
p->verify();