void BiasedLocking::preserve_marks() { if (!UseBiasedLocking) return; assert(SafepointSynchronize::is_at_safepoint(), "must only be called while at safepoint"); assert(_preserved_oop_stack == NULL, "double initialization"); assert(_preserved_mark_stack == NULL, "double initialization"); // In order to reduce the number of mark words preserved during GC // due to the presence of biased locking, we reinitialize most mark // words to the class's prototype during GC -- even those which have // a currently valid bias owner. One important situation where we // must not clobber a bias is when a biased object is currently // locked. To handle this case we iterate over the currently-locked // monitors in a prepass and, if they are biased, preserve their // mark words here. This should be a relatively small set of objects // especially compared to the number of objects in the heap. _preserved_mark_stack = new (ResourceObj::C_HEAP) GrowableArray<markOop>(10, true); _preserved_oop_stack = new (ResourceObj::C_HEAP) GrowableArray<Handle>(10, true); ResourceMark rm; Thread* cur = Thread::current(); for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) { if (thread->has_last_Java_frame()) { RegisterMap rm(thread); for (javaVFrame* vf = thread->last_java_vframe(&rm); vf != NULL; vf = vf->java_sender()) { GrowableArray<MonitorInfo*> *monitors = vf->monitors(); if (monitors != NULL) { int len = monitors->length(); // Walk monitors youngest to oldest for (int i = len - 1; i >= 0; i--) { MonitorInfo* mon_info = monitors->at(i); oop owner = mon_info->owner(); if (owner != NULL) { markOop mark = owner->mark(); if (mark->has_bias_pattern()) { _preserved_oop_stack->push(Handle(cur, owner)); _preserved_mark_stack->push(mark); } } } } } } } }
void ZeroStack::handle_overflow(TRAPS) { JavaThread *thread = (JavaThread *) THREAD; // Set up the frame anchor if it isn't already bool has_last_Java_frame = thread->has_last_Java_frame(); if (!has_last_Java_frame) { intptr_t *sp = thread->zero_stack()->sp(); ZeroFrame *frame = thread->top_zero_frame(); while (frame) { if (frame->is_shark_frame()) break; if (frame->is_interpreter_frame()) { interpreterState istate = frame->as_interpreter_frame()->interpreter_state(); if (istate->self_link() == istate) break; } sp = ((intptr_t *) frame) + 1; frame = frame->next(); } if (frame == NULL) fatal("unrecoverable stack overflow"); thread->set_last_Java_frame(frame, sp); } // Throw the exception switch (thread->thread_state()) { case _thread_in_Java: InterpreterRuntime::throw_StackOverflowError(thread); break; case _thread_in_vm: Exceptions::throw_stack_overflow_exception(thread, __FILE__, __LINE__); break; default: ShouldNotReachHere(); } // Reset the frame anchor if necessary if (!has_last_Java_frame) thread->reset_last_Java_frame(); }
void doit() { ResourceMark rmark; // _thread != Thread::current() RegisterMap rm(_thread, false); // There can be a race condition between a VM_Operation reaching a safepoint // and the target thread exiting from Java execution. // We must recheck the last Java frame still exists. if (!_thread->is_exiting() && _thread->has_last_Java_frame()) { javaVFrame* vf = _thread->last_java_vframe(&rm); assert(vf != NULL, "must have last java frame"); Method* method = vf->method(); _method_id = method->jmethod_id(); _bci = vf->bci(); } else { // Clear current location as the target thread has no Java frames anymore. _method_id = (jmethodID)NULL; _bci = 0; } }
// For Forte Analyzer AsyncGetCallTrace profiling support - thread is // currently interrupted by SIGPROF bool JavaThread::pd_get_top_frame_for_signal_handler(frame* fr_addr, void* ucontext, bool isInJava) { assert(Thread::current() == this, "caller must be current thread"); assert(this->is_Java_thread(), "must be JavaThread"); JavaThread* jt = (JavaThread *)this; // If we have a last_Java_frame, then we should use it even if // isInJava == true. It should be more reliable than ucontext info. if (jt->has_last_Java_frame()) { *fr_addr = jt->pd_last_frame(); return true; } // At this point, we don't have a last_Java_frame, so // we try to glean some information out of the ucontext // if we were running Java code when SIGPROF came in. if (isInJava) { ucontext_t* uc = (ucontext_t*) ucontext; intptr_t* ret_fp; intptr_t* ret_sp; ExtendedPC addr = os::Solaris::fetch_frame_from_ucontext(this, uc, &ret_sp, &ret_fp); if (addr.contained_pc() == NULL || ret_sp == NULL || ret_fp == NULL) { // ucontext wasn't useful return false; } frame ret_frame(ret_sp, ret_fp, addr.pc()); if (!ret_frame.safe_for_sender(jt)) { // nothing else to try if the frame isn't good return false; } *fr_addr = ret_frame; return true; } // nothing else to try return false; }
extern "C" void ps() { // print stack if (Thread::current() == NULL) return; Command c("ps"); // Prints the stack of the current Java thread JavaThread* p = JavaThread::active(); tty->print(" for thread: "); p->print(); tty->cr(); if (p->has_last_Java_frame()) { // If the last_Java_fp is set we are in C land and // can call the standard stack_trace function. #ifdef PRODUCT p->print_stack(); } else { tty->print_cr("Cannot find the last Java frame, printing stack disabled."); #else // !PRODUCT p->trace_stack(); } else {
extern "C" void ps() { // print stack Command c("ps"); // Prints the stack of the current Java thread JavaThread* p = JavaThread::active(); tty->print(" for thread: "); p->print(); tty->cr(); if (p->has_last_Java_frame()) { // If the last_Java_fp is set we are in C land and // can call the standard stack_trace function. p->trace_stack(); } else { frame f = os::current_frame(); RegisterMap reg_map(p); f = f.sender(®_map); tty->print("(guessing starting frame id=%#p based on current fp)\n", f.id()); p->trace_stack_from(vframe::new_vframe(&f, ®_map, p)); pd_ps(f); } }
// true when the thread was suspended with a pointer to the last Java frame. bool has_last_frame() { return _thread->has_last_Java_frame(); }
// For Forte Analyzer AsyncGetCallTrace profiling support - thread is // currently interrupted by SIGPROF bool JavaThread::pd_get_top_frame_for_signal_handler(frame* fr_addr, void* ucontext, bool isInJava) { assert(Thread::current() == this, "caller must be current thread"); assert(this->is_Java_thread(), "must be JavaThread"); JavaThread* jt = (JavaThread *)this; if (!isInJava) { // make_walkable flushes register windows and grabs last_Java_pc // which can not be done if the ucontext sp matches last_Java_sp // stack walking utilities assume last_Java_pc set if marked flushed jt->frame_anchor()->make_walkable(jt); } // If we have a walkable last_Java_frame, then we should use it // even if isInJava == true. It should be more reliable than // ucontext info. if (jt->has_last_Java_frame() && jt->frame_anchor()->walkable()) { *fr_addr = jt->pd_last_frame(); return true; } ucontext_t* uc = (ucontext_t*) ucontext; // At this point, we don't have a walkable last_Java_frame, so // we try to glean some information out of the ucontext. intptr_t* ret_sp; ExtendedPC addr = os::fetch_frame_from_context(uc, &ret_sp, NULL /* ret_fp only used on X86 */); if (addr.pc() == NULL || ret_sp == NULL) { // ucontext wasn't useful return false; } #if INCLUDE_CDS if (UseSharedSpaces && MetaspaceShared::is_in_shared_region(addr.pc(), MetaspaceShared::md)) { // In the middle of a trampoline call. Bail out for safety. // This happens rarely so shouldn't affect profiling. return false; } #endif // we were running Java code when SIGPROF came in if (isInJava) { // If we have a last_Java_sp, then the SIGPROF signal caught us // right when we were transitioning from _thread_in_Java to a new // JavaThreadState. We use last_Java_sp instead of the sp from // the ucontext since it should be more reliable. if (jt->has_last_Java_frame()) { ret_sp = jt->last_Java_sp(); } // Implied else: we don't have a last_Java_sp so we use what we // got from the ucontext. frame ret_frame(ret_sp, frame::unpatchable, addr.pc()); if (!ret_frame.safe_for_sender(jt)) { // nothing else to try if the frame isn't good return false; } *fr_addr = ret_frame; return true; } // At this point, we know we weren't running Java code. We might // have a last_Java_sp, but we don't have a walkable frame. // However, we might still be able to construct something useful // if the thread was running native code. if (jt->has_last_Java_frame()) { assert(!jt->frame_anchor()->walkable(), "case covered above"); if (jt->thread_state() == _thread_in_native) { frame ret_frame(jt->last_Java_sp(), frame::unpatchable, addr.pc()); if (!ret_frame.safe_for_sender(jt)) { // nothing else to try if the frame isn't good return false; } *fr_addr = ret_frame; return true; } } // nothing else to try return false; }
void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) { // This is if'd out because we no longer use thread suspension. // However if someone wanted to backport this to a 5.0 jvm then this // code would be important. #if 0 if (SafepointSynchronize::is_synchronizing()) { // The safepoint mechanism is trying to synchronize all the threads. // Since this can involve thread suspension, it is not safe for us // to be here. We can reduce the deadlock risk window by quickly // returning to the SIGPROF handler. However, it is still possible // for VMThread to catch us here or in the SIGPROF handler. If we // are suspended while holding a resource and another thread blocks // on that resource in the SIGPROF handler, then we will have a // three-thread deadlock (VMThread, this thread, the other thread). trace->num_frames = ticks_safepoint; // -10 return; } #endif JavaThread* thread; if (trace->env_id == NULL || (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL || thread->is_exiting()) { // bad env_id, thread has exited or thread is exiting trace->num_frames = ticks_thread_exit; // -8 return; } if (thread->in_deopt_handler()) { // thread is in the deoptimization handler so return no frames trace->num_frames = ticks_deopt; // -9 return; } assert(JavaThread::current() == thread, "AsyncGetCallTrace must be called by the current interrupted thread"); if (!JvmtiExport::should_post_class_load()) { trace->num_frames = ticks_no_class_load; // -1 return; } if (Universe::heap()->is_gc_active()) { trace->num_frames = ticks_GC_active; // -2 return; } switch (thread->thread_state()) { case _thread_new: case _thread_uninitialized: case _thread_new_trans: // We found the thread on the threads list above, but it is too // young to be useful so return that there are no Java frames. trace->num_frames = 0; break; case _thread_in_native: case _thread_in_native_trans: case _thread_blocked: case _thread_blocked_trans: case _thread_in_vm: case _thread_in_vm_trans: { frame fr; // param isInJava == false - indicate we aren't in Java code if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) { trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame } else { if (!thread->has_last_Java_frame()) { trace->num_frames = 0; // No Java frames } else { trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default forte_fill_call_trace_given_top(thread, trace, depth, fr); // This assert would seem to be valid but it is not. // It would be valid if we weren't possibly racing a gc // thread. A gc thread can make a valid interpreted frame // look invalid. It's a small window but it does happen. // The assert is left here commented out as a reminder. // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable"); } } } break; case _thread_in_Java: case _thread_in_Java_trans: { frame fr; // param isInJava == true - indicate we are in Java code if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) { trace->num_frames = ticks_unknown_Java; // -5 unknown frame } else { trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default forte_fill_call_trace_given_top(thread, trace, depth, fr); } } break; default: // Unknown thread state trace->num_frames = ticks_unknown_state; // -7 break; } }
bool JavaThread::pd_get_top_frame(frame* fr_addr, void* ucontext, bool isInJava, bool makeWalkable) { assert(this->is_Java_thread(), "must be JavaThread"); JavaThread* jt = (JavaThread *)this; if (!isInJava && makeWalkable) { // make_walkable flushes register windows and grabs last_Java_pc // which can not be done if the ucontext sp matches last_Java_sp // stack walking utilities assume last_Java_pc set if marked flushed jt->frame_anchor()->make_walkable(jt); } // If we have a walkable last_Java_frame, then we should use it // even if isInJava == true. It should be more reliable than // ucontext info. if (jt->has_last_Java_frame() && jt->frame_anchor()->walkable()) { *fr_addr = jt->pd_last_frame(); return true; } ucontext_t* uc = (ucontext_t*) ucontext; // At this point, we don't have a walkable last_Java_frame, so // we try to glean some information out of the ucontext. intptr_t* ret_sp; ExtendedPC addr = os::Solaris::fetch_frame_from_ucontext(this, uc, &ret_sp, NULL /* ret_fp only used on Solaris X86 */); if (addr.pc() == NULL || ret_sp == NULL) { // ucontext wasn't useful return false; } #if INCLUDE_CDS if (UseSharedSpaces && MetaspaceShared::is_in_shared_region(addr.pc(), MetaspaceShared::md)) { // In the middle of a trampoline call. Bail out for safety. // This happens rarely so shouldn't affect profiling. return false; } #endif frame ret_frame(ret_sp, frame::unpatchable, addr.pc()); // we were running Java code when SIGPROF came in if (isInJava) { // If the frame we got is safe then it is most certainly valid if (ret_frame.safe_for_sender(jt)) { *fr_addr = ret_frame; return true; } // If it isn't safe then we can try several things to try and get // a good starting point. // // On sparc the frames are almost certainly walkable in the sense // of sp/fp linkages. However because of recycling of windows if // a piece of code does multiple save's where the initial save creates // a real frame with a return pc and the succeeding save's are used to // simply get free registers and have no real pc then the pc linkage on these // "inner" temporary frames will be bogus. // Since there is in general only a nesting level like // this one deep in general we'll try and unwind such an "inner" frame // here ourselves and see if it makes sense frame unwind_frame(ret_frame.fp(), frame::unpatchable, addr.pc()); if (unwind_frame.safe_for_sender(jt)) { *fr_addr = unwind_frame; return true; } // Well that didn't work. Most likely we're toast on this tick // The previous code would try this. I think it is dubious in light // of changes to safe_for_sender and the unwind trick above but // if it gets us a safe frame who wants to argue. // If we have a last_Java_sp, then the SIGPROF signal caught us // right when we were transitioning from _thread_in_Java to a new // JavaThreadState. We use last_Java_sp instead of the sp from // the ucontext since it should be more reliable. if (jt->has_last_Java_frame()) { ret_sp = jt->last_Java_sp(); frame ret_frame2(ret_sp, frame::unpatchable, addr.pc()); if (ret_frame2.safe_for_sender(jt)) { *fr_addr = ret_frame2; return true; } } // This is the best we can do. We will only be able to decode the top frame *fr_addr = ret_frame; return true; } // At this point, we know we weren't running Java code. We might // have a last_Java_sp, but we don't have a walkable frame. // However, we might still be able to construct something useful // if the thread was running native code. if (jt->has_last_Java_frame()) { assert(!jt->frame_anchor()->walkable(), "case covered above"); frame ret_frame(jt->last_Java_sp(), frame::unpatchable, addr.pc()); *fr_addr = ret_frame; return true; } // nothing else to try but what we found initially *fr_addr = ret_frame; return true; }
JNIEXPORT void AsyncGetCallTrace(ASGCT_CallTrace *trace, jint depth, void* ucontext) { JavaThread* thread; if (trace->env_id == NULL || (thread = JavaThread::thread_from_jni_environment(trace->env_id)) == NULL || thread->is_exiting()) { // bad env_id, thread has exited or thread is exiting trace->num_frames = ticks_thread_exit; // -8 return; } if (thread->in_deopt_handler()) { // thread is in the deoptimization handler so return no frames trace->num_frames = ticks_deopt; // -9 return; } assert(JavaThread::current() == thread, "AsyncGetCallTrace must be called by the current interrupted thread"); if (!JvmtiExport::should_post_class_load()) { trace->num_frames = ticks_no_class_load; // -1 return; } if (Universe::heap()->is_gc_active()) { trace->num_frames = ticks_GC_active; // -2 return; } switch (thread->thread_state()) { case _thread_new: case _thread_uninitialized: case _thread_new_trans: // We found the thread on the threads list above, but it is too // young to be useful so return that there are no Java frames. trace->num_frames = 0; break; case _thread_in_native: case _thread_in_native_trans: case _thread_blocked: case _thread_blocked_trans: case _thread_in_vm: case _thread_in_vm_trans: { frame fr; // param isInJava == false - indicate we aren't in Java code if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, false)) { trace->num_frames = ticks_unknown_not_Java; // -3 unknown frame } else { if (!thread->has_last_Java_frame()) { trace->num_frames = 0; // No Java frames } else { trace->num_frames = ticks_not_walkable_not_Java; // -4 non walkable frame by default forte_fill_call_trace_given_top(thread, trace, depth, fr); // This assert would seem to be valid but it is not. // It would be valid if we weren't possibly racing a gc // thread. A gc thread can make a valid interpreted frame // look invalid. It's a small window but it does happen. // The assert is left here commented out as a reminder. // assert(trace->num_frames != ticks_not_walkable_not_Java, "should always be walkable"); } } } break; case _thread_in_Java: case _thread_in_Java_trans: { frame fr; // param isInJava == true - indicate we are in Java code if (!thread->pd_get_top_frame_for_signal_handler(&fr, ucontext, true)) { trace->num_frames = ticks_unknown_Java; // -5 unknown frame } else { trace->num_frames = ticks_not_walkable_Java; // -6, non walkable frame by default forte_fill_call_trace_given_top(thread, trace, depth, fr); } } break; default: // Unknown thread state trace->num_frames = ticks_unknown_state; // -7 break; } }