JVM源码分析之栈溢出完全解读

size_t os::Linux::default_stack_size(os::ThreadType thr_type) {   // default stack size (compiler thread needs larger stack) #ifdef AMD64   size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M); #else   size_t s = (thr_type == os::compiler_thread ? 2 * M : 512 * K); #endif // AMD64   return s; }

switch (thr_type) {       case os::java_thread:         // Java threads use ThreadStackSize which default value can be         // changed with the flag -Xss         assert (JavaThread::stack_size_at_create() > 0, "this should be set");         stack_size = JavaThread::stack_size_at_create();         break;       case os::compiler_thread:         if (CompilerThreadStackSize > 0) {           stack_size = (size_t)(CompilerThreadStackSize * K);           break;         } // else fall through:           // use VMThreadStackSize if CompilerThreadStackSize is not defined       case os::vm_thread:       case os::pgc_thread:       case os::cgc_thread:       case os::watcher_thread:         if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);         break;       }

// Java thread: // //   Low memory addresses //    +------------------------+ //    |                        |/  JavaThread created by VM does not have glibc //    |    glibc guard page    | - guard, attached Java thread usually has //    |                        |/  1 page glibc guard. // P1 +------------------------+ Thread::stack_base() - Thread::stack_size() //    |                        |/ //    |  HotSpot Guard Pages   | - red and yellow pages //    |                        |/ //    +------------------------+ JavaThread::stack_yellow_zone_base() //    |                        |/ //    |      Normal Stack      | - //    |                        |/ // P2 +------------------------+ Thread::stack_base() // // Non-Java thread: // //   Low memory addresses //    +------------------------+ //    |                        |/ //    |  glibc guard page      | - usually 1 page //    |                        |/ // P1 +------------------------+ Thread::stack_base() - Thread::stack_size() //    |                        |/ //    |      Normal Stack      | - //    |                        |/ // P2 +------------------------+ Thread::stack_base() // // ** P1 (aka bottom) and size ( P2 = P1 - size) are the address and stack size returned from //    pthread_attr_getstack()

 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 (stub != NULL) {     // save all thread context in case we need to restore it     if (thread != NULL) thread->set_saved_exception_pc(pc);      uc->uc_mcontext.gregs[REG_PC] = (greg_t)stub;     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();