// 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; // last_Java_frame is always walkable and safe use it if we have it if (jt->has_last_Java_frame()) { *fr_addr = jt->pd_last_frame(); return true; } ucontext_t* uc = (ucontext_t*) ucontext; // We always want to use the initial frame we create from the ucontext as // it certainly signals where we currently are. However that frame may not // be safe for calling sender. In that case if we have a last_Java_frame // then the forte walker will switch to that frame as the virtual sender // for the frame we create here which is not sender safe. intptr_t* ret_fp; intptr_t* ret_sp; ExtendedPC addr = os::Solaris::fetch_frame_from_ucontext(this, uc, &ret_sp, &ret_fp); // Something would really have to be screwed up to get a NULL pc if (addr.pc() == NULL ) { assert(false, "NULL pc from signal handler!"); return false; } // If sp and fp are nonsense just leave them out if ((address)ret_sp >= jt->stack_base() || (address)ret_sp < jt->stack_base() - jt->stack_size() ) { ret_sp = NULL; ret_fp = NULL; } else { // sp is reasonable is fp reasonable? if ( (address)ret_fp >= jt->stack_base() || ret_fp < ret_sp) { ret_fp = NULL; } } frame ret_frame(ret_sp, ret_fp, addr.pc()); *fr_addr = ret_frame; return true; }
// Reduce the guard page by YellowZonePages to allow for the processing // of register stack overflow exceptions. void JavaThread::disable_register_stack_guard() { address reg_stk_limit; JavaThread* thread = (JavaThread *)Thread::current(); assert(thread != NULL,"Sanity check"); if ( !thread->is_Java_thread() ) return; // We assume that the register stack is the same size as the memory stack and that // it starts at the beginning stack address and grows higher. The memory stack // grows to lower addresses. reg_stk_limit = thread->stack_base() + thread->stack_size() - ((StackShadowPages + StackRedPages) * os::vm_page_size()); thread->set_register_stack_limit( reg_stk_limit ); }
// Check to see if the current BSP is within our current guard // page area. bool JavaThread::register_stack_overflow() { address reg_stk_limit; JavaThread* thread = (JavaThread *)Thread::current(); assert(thread != NULL,"Sanity check"); if ( !thread->is_Java_thread() ) return false; reg_stk_limit = thread->stack_base() + thread->stack_size() - ((StackShadowPages + StackYellowPages + StackRedPages) * os::vm_page_size()); if ( StubRoutines::ia64::get_backing_store_pointer() > reg_stk_limit ) return true; else return false; }
// OS specific thread initialization // // For Itanium, we calculate and store the limits of the // register and memory stacks. // void os::initialize_thread() { address mem_stk_limit; JavaThread* thread = (JavaThread *)Thread::current(); assert(thread != NULL,"Sanity check"); if ( !thread->is_Java_thread() ) return; // Initialize our register stack limit which is our guard JavaThread::enable_register_stack_guard(); // Initialize our memory stack limit mem_stk_limit = thread->stack_base() - thread->stack_size() + ((StackShadowPages + StackYellowPages + StackRedPages) * os::vm_page_size()); thread->set_memory_stack_limit( mem_stk_limit ); }
extern "C" JNIEXPORT int JVM_handle_linux_signal(int sig, siginfo_t* info, void* ucVoid, int abort_if_unrecognized) { ucontext_t* uc = (ucontext_t*) ucVoid; Thread* t = ThreadLocalStorage::get_thread_slow(); SignalHandlerMark shm(t); // Note: it's not uncommon that JNI code uses signal/sigset to // install then restore certain signal handler (e.g. to temporarily // block SIGPIPE, or have a SIGILL handler when detecting CPU // type). When that happens, JVM_handle_linux_signal() might be // invoked with junk info/ucVoid. To avoid unnecessary crash when // libjsig is not preloaded, try handle signals that do not require // siginfo/ucontext first. if (sig == SIGPIPE || sig == SIGXFSZ) { // allow chained handler to go first if (os::Linux::chained_handler(sig, info, ucVoid)) { return true; } else { if (PrintMiscellaneous && (WizardMode || Verbose)) { char buf[64]; warning("Ignoring %s - see bugs 4229104 or 646499219", os::exception_name(sig, buf, sizeof(buf))); } return true; } } JavaThread* thread = NULL; VMThread* vmthread = NULL; if (os::Linux::signal_handlers_are_installed) { if (t != NULL ){ if(t->is_Java_thread()) { thread = (JavaThread*)t; } else if(t->is_VM_thread()){ vmthread = (VMThread *)t; } } } if (info != NULL && thread != NULL) { // Handle ALL stack overflow variations here if (sig == SIGSEGV) { address addr = (address) info->si_addr; // check if fault address is within thread stack if (addr < thread->stack_base() && addr >= thread->stack_base() - thread->stack_size()) { // stack overflow if (thread->in_stack_yellow_zone(addr)) { thread->disable_stack_yellow_zone(); ShouldNotCallThis(); } else if (thread->in_stack_red_zone(addr)) { thread->disable_stack_red_zone(); ShouldNotCallThis(); } else { // Accessing stack address below sp may cause SEGV if // current thread has MAP_GROWSDOWN stack. This should // only happen when current thread was created by user // code with MAP_GROWSDOWN flag and then attached to VM. // See notes in os_linux.cpp. if (thread->osthread()->expanding_stack() == 0) { thread->osthread()->set_expanding_stack(); if (os::Linux::manually_expand_stack(thread, addr)) { thread->osthread()->clear_expanding_stack(); return true; } thread->osthread()->clear_expanding_stack(); } else { fatal("recursive segv. expanding stack."); } } } } /*if (thread->thread_state() == _thread_in_Java) { ShouldNotCallThis(); } else*/ if (thread->thread_state() == _thread_in_vm && sig == SIGBUS && thread->doing_unsafe_access()) { ShouldNotCallThis(); } // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC // kicks in and the heap gets shrunk before the field access. /*if (sig == SIGSEGV || sig == SIGBUS) { address addr = JNI_FastGetField::find_slowcase_pc(pc); if (addr != (address)-1) { stub = addr; } }*/ // Check to see if we caught the safepoint code in the process // of write protecting the memory serialization page. It write // enables the page immediately after protecting it so we can // just return to retry the write. if (sig == SIGSEGV && os::is_memory_serialize_page(thread, (address) info->si_addr)) { // Block current thread until permission is restored. os::block_on_serialize_page_trap(); return true; } } // signal-chaining if (os::Linux::chained_handler(sig, info, ucVoid)) { return true; } if (!abort_if_unrecognized) { // caller wants another chance, so give it to him return false; } #ifndef PRODUCT if (sig == SIGSEGV) { fatal("\n#" "\n# /--------------------\\" "\n# | segmentation fault |" "\n# \\---\\ /--------------/" "\n# /" "\n# [-] |\\_/| " "\n# (+)=C |o o|__ " "\n# | | =-*-=__\\ " "\n# OOO c_c_(___)"); } #endif // !PRODUCT const char *fmt = "caught unhandled signal %d"; char buf[64]; sprintf(buf, fmt, sig); fatal(buf); }
extern "C" JNIEXPORT int JVM_handle_linux_signal(int sig, siginfo_t* info, void* ucVoid, int abort_if_unrecognized) { ucontext_t* uc = (ucontext_t*) ucVoid; Thread* t = ThreadLocalStorage::get_thread_slow(); // Must do this before SignalHandlerMark, if crash protection installed we will longjmp away // (no destructors can be run) os::WatcherThreadCrashProtection::check_crash_protection(sig, t); SignalHandlerMark shm(t); // Note: it's not uncommon that JNI code uses signal/sigset to install // then restore certain signal handler (e.g. to temporarily block SIGPIPE, // or have a SIGILL handler when detecting CPU type). When that happens, // JVM_handle_linux_signal() might be invoked with junk info/ucVoid. To // avoid unnecessary crash when libjsig is not preloaded, try handle signals // that do not require siginfo/ucontext first. if (sig == SIGPIPE || sig == SIGXFSZ) { // allow chained handler to go first if (os::Linux::chained_handler(sig, info, ucVoid)) { return true; } else { if (PrintMiscellaneous && (WizardMode || Verbose)) { char buf[64]; warning("Ignoring %s - see bugs 4229104 or 646499219", os::exception_name(sig, buf, sizeof(buf))); } return true; } } JavaThread* thread = NULL; VMThread* vmthread = NULL; if (os::Linux::signal_handlers_are_installed) { if (t != NULL ){ if(t->is_Java_thread()) { thread = (JavaThread*)t; } else if(t->is_VM_thread()){ vmthread = (VMThread *)t; } } } /* NOTE: does not seem to work on linux. if (info == NULL || info->si_code <= 0 || info->si_code == SI_NOINFO) { // can't decode this kind of signal info = NULL; } else { assert(sig == info->si_signo, "bad siginfo"); } */ // decide if this trap can be handled by a stub address stub = NULL; address pc = NULL; //%note os_trap_1 if (info != NULL && uc != NULL && thread != NULL) { pc = (address) os::Linux::ucontext_get_pc(uc); #ifdef BUILTIN_SIM if (pc == (address) Fetch32PFI) { uc->uc_mcontext.gregs[REG_PC] = intptr_t(Fetch32Resume) ; return 1 ; } if (pc == (address) FetchNPFI) { uc->uc_mcontext.gregs[REG_PC] = intptr_t (FetchNResume) ; return 1 ; } #else if (StubRoutines::is_safefetch_fault(pc)) { uc->uc_mcontext.pc = intptr_t(StubRoutines::continuation_for_safefetch_fault(pc)); return 1; } #endif #ifndef AMD64 // Halt if SI_KERNEL before more crashes get misdiagnosed as Java bugs // This can happen in any running code (currently more frequently in // interpreter code but has been seen in compiled code) if (sig == SIGSEGV && info->si_addr == 0 && info->si_code == SI_KERNEL) { fatal("An irrecoverable SI_KERNEL SIGSEGV has occurred due " "to unstable signal handling in this distribution."); } #endif // AMD64 // Handle ALL stack overflow variations here if (sig == SIGSEGV) { address addr = (address) info->si_addr; // check if fault address is within thread stack if (addr < thread->stack_base() && addr >= thread->stack_base() - thread->stack_size()) { // stack overflow if (thread->in_stack_yellow_zone(addr)) { thread->disable_stack_yellow_zone(); if (thread->thread_state() == _thread_in_Java) { // Throw a stack overflow exception. Guard pages will be reenabled // while unwinding the stack. stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::STACK_OVERFLOW); } else { // Thread was in the vm or native code. Return and try to finish. return 1; } } else if (thread->in_stack_red_zone(addr)) { // Fatal red zone violation. Disable the guard pages and fall through // to handle_unexpected_exception way down below. thread->disable_stack_red_zone(); tty->print_raw_cr("An irrecoverable stack overflow has occurred."); // This is a likely cause, but hard to verify. Let's just print // it as a hint. tty->print_raw_cr("Please check if any of your loaded .so files has " "enabled executable stack (see man page execstack(8))"); } else { // Accessing stack address below sp may cause SEGV if current // thread has MAP_GROWSDOWN stack. This should only happen when // current thread was created by user code with MAP_GROWSDOWN flag // and then attached to VM. See notes in os_linux.cpp. if (thread->osthread()->expanding_stack() == 0) { thread->osthread()->set_expanding_stack(); if (os::Linux::manually_expand_stack(thread, addr)) { thread->osthread()->clear_expanding_stack(); return 1; } thread->osthread()->clear_expanding_stack(); } else { fatal("recursive segv. expanding stack."); } } } } if (thread->thread_state() == _thread_in_Java) { // Java thread running in Java code => find exception handler if any // a fault inside compiled code, the interpreter, or a stub // Handle signal from NativeJump::patch_verified_entry(). if ((sig == SIGILL || sig == SIGTRAP) && nativeInstruction_at(pc)->is_sigill_zombie_not_entrant()) { if (TraceTraps) { tty->print_cr("trap: zombie_not_entrant (%s)", (sig == SIGTRAP) ? "SIGTRAP" : "SIGILL"); } stub = SharedRuntime::get_handle_wrong_method_stub(); } else if (sig == SIGSEGV && os::is_poll_address((address)info->si_addr)) { stub = SharedRuntime::get_poll_stub(pc); } else if (sig == SIGBUS /* && info->si_code == BUS_OBJERR */) { // BugId 4454115: A read from a MappedByteBuffer can fault // here if the underlying file has been truncated. // Do not crash the VM in such a case. CodeBlob* cb = CodeCache::find_blob_unsafe(pc); nmethod* nm = (cb != NULL && cb->is_nmethod()) ? (nmethod*)cb : NULL; if (nm != NULL && nm->has_unsafe_access()) { stub = handle_unsafe_access(thread, pc); } } else if (sig == SIGFPE && (info->si_code == FPE_INTDIV || info->si_code == FPE_FLTDIV)) { stub = SharedRuntime:: continuation_for_implicit_exception(thread, pc, SharedRuntime:: IMPLICIT_DIVIDE_BY_ZERO); } else if (sig == SIGSEGV && !MacroAssembler::needs_explicit_null_check((intptr_t)info->si_addr)) { // Determination of interpreter/vtable stub/compiled code null exception stub = SharedRuntime::continuation_for_implicit_exception(thread, pc, SharedRuntime::IMPLICIT_NULL); } } else if (thread->thread_state() == _thread_in_vm && sig == SIGBUS && /* info->si_code == BUS_OBJERR && */ thread->doing_unsafe_access()) { stub = handle_unsafe_access(thread, pc); } // jni_fast_Get<Primitive>Field can trap at certain pc's if a GC kicks in // and the heap gets shrunk before the field access. if ((sig == SIGSEGV) || (sig == SIGBUS)) { address addr = JNI_FastGetField::find_slowcase_pc(pc); if (addr != (address)-1) { stub = addr; } } // Check to see if we caught the safepoint code in the // process of write protecting the memory serialization page. // It write enables the page immediately after protecting it // so we can just return to retry the write. if ((sig == SIGSEGV) && os::is_memory_serialize_page(thread, (address) info->si_addr)) { // Block current thread until the memory serialize page permission restored. os::block_on_serialize_page_trap(); return true; } } if (stub != NULL) { // save all thread context in case we need to restore it if (thread != NULL) thread->set_saved_exception_pc(pc); #ifdef BUILTIN_SIM uc->uc_mcontext.gregs[REG_PC] = (greg_t)stub; #else uc->uc_mcontext.pc = (__u64)stub; #endif return true; } // signal-chaining if (os::Linux::chained_handler(sig, info, ucVoid)) { return true; } if (!abort_if_unrecognized) { // caller wants another chance, so give it to him return false; } if (pc == NULL && uc != NULL) { pc = os::Linux::ucontext_get_pc(uc); } // unmask current signal sigset_t newset; sigemptyset(&newset); sigaddset(&newset, sig); sigprocmask(SIG_UNBLOCK, &newset, NULL); VMError err(t, sig, pc, info, ucVoid); err.report_and_die(); ShouldNotReachHere(); }
// The call stub is used to call Java from C static void call_stub( JavaCallWrapper *call_wrapper, intptr_t* result, BasicType result_type, methodOop method, address entry_point, intptr_t* parameters, int parameter_words, TRAPS) { JavaThread *thread = (JavaThread *) THREAD; ZeroStack *stack = thread->zero_stack(); // Make sure we have no pending exceptions assert(!HAS_PENDING_EXCEPTION, "call_stub called with pending exception"); // Set up the stack if necessary bool stack_needs_teardown = false; if (stack->needs_setup()) { size_t stack_used = thread->stack_base() - (address) &stack_used; size_t stack_free = thread->stack_size() - stack_used; size_t zero_stack_size = align_size_down(stack_free / 2, wordSize); stack->setup(alloca(zero_stack_size), zero_stack_size); stack_needs_teardown = true; } // Allocate and initialize our frame thread->push_zero_frame( EntryFrame::build(stack, parameters, parameter_words, call_wrapper)); // Make the call Interpreter::invoke_method(method, entry_point, THREAD); // Store result depending on type if (!HAS_PENDING_EXCEPTION) { switch (result_type) { case T_INT: *(jint *) result = *(jint *) stack->sp(); break; case T_LONG: *(jlong *) result = *(jlong *) stack->sp(); break; case T_FLOAT: *(jfloat *) result = *(jfloat *) stack->sp(); break; case T_DOUBLE: *(jdouble *) result = *(jdouble *) stack->sp(); break; case T_OBJECT: *(oop *) result = *(oop *) stack->sp(); break; default: ShouldNotReachHere(); } } // Unwind our frame thread->pop_zero_frame(); // Tear down the stack if necessary if (stack_needs_teardown) stack->teardown(); }