jvm中对线程栈最小值的限制

```c++
// Check minimum allowable stack size for thread creation and to initialize
// the java system classes, including StackOverflowError - depends on page
// size.  Add a page for compiler2 recursion in main thread.
// Add in 2*BytesPerWord times page size to account for VM stack during
// class initialization depending on 32 or 64 bit VM.
os::Linux::min_stack_allowed = MAX2(os::Linux::min_stack_allowed,
            (size_t)(StackYellowPages+StackRedPages+StackShadowPages) * Linux::page_size() +
                    (2*BytesPerWord COMPILER2_PRESENT(+1)) * Linux::vm_default_page_size());

size_t threadStackSizeInBytes = ThreadStackSize * K;
if (threadStackSizeInBytes != 0 &&
    threadStackSizeInBytes < os::Linux::min_stack_allowed) {
        tty->print_cr("\nThe stack size specified is too small, "
                    "Specify at least %dk",
                    os::Linux::min_stack_allowed/ K);
        return JNI_ERR;
}
```

os::Linux::min_stack_allowed = max(
    os::Linux::min_stack_allowed, 
    (2 + 1 + 20) * 4K + (2 * 8 + 1) * 8K
) = 228K

```c++
/* stack parameters */                                                    \
product_pd(intx, StackYellowPages,                                        \
        "Number of yellow zone (recoverable overflows) pages")            \
                                                                          \
product_pd(intx, StackRedPages,                                           \
        "Number of red zone (unrecoverable overflows) pages")             \
                                                                          \
product_pd(intx, StackShadowPages,                                        \
        "Number of shadow zone (for overflow checking) pages "            \
        "this should exceed the depth of the VM and native call stack") 
```

```c++
define_pd_global(intx, StackYellowPages, NOT_WINDOWS(2) WINDOWS_ONLY(3));
define_pd_global(intx, StackRedPages, 1);
#ifdef AMD64
// Very large C++ stack frames using solaris-amd64 optimized builds
// due to lack of optimization caused by C++ compiler bugs
define_pd_global(intx, StackShadowPages, NOT_WIN64(20) WIN64_ONLY(6) DEBUG_ONLY(+2));
#else
define_pd_global(intx, StackShadowPages, 4 DEBUG_ONLY(+5));
#endif // AMD64
```

```c++
// If the pagesize of the VM is greater than 8K determine the appropriate
// number of initial guard pages.  The user can change this with the
// command line arguments, if needed.
if (vm_page_size() > (int)Linux::vm_default_page_size()) {
    StackYellowPages = 1;
    StackRedPages = 1;
    StackShadowPages = round_to((StackShadowPages*Linux::vm_default_page_size()), vm_page_size()) / vm_page_size();
}
``` `Linux::page_size()`: 通过`sysconf(_SC_PAGESIZE)`获取到系统当前页面大小，查询操作系统实际数值后，该值为4K

```
Linux::set_page_size(sysconf(_SC_PAGESIZE));
```

```c++
const int os::Linux::_vm_default_page_size = (8 * K);
```

```c++
#ifdef _LP64
const int LogBytesPerWord    = 3;
#else
const int LogBytesPerWord    = 2;
#endif
const int LogBytesPerLong    = 3;

const int BytesPerShort      = 1 << LogBytesPerShort;
const int BytesPerInt        = 1 << LogBytesPerInt;
const int BytesPerWord       = 1 << LogBytesPerWord;
const int BytesPerLong       = 1 << LogBytesPerLong;
```

```c++
if (os::Linux::supports_variable_stack_size()) {
    // calculate stack size if it's not specified by caller
    if (stack_size == 0) {
    stack_size = os::Linux::default_stack_size(thr_type);

    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;
    }
}

// glibc guard page
pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));
```

```c++
size_t os::Linux::default_guard_size(os::ThreadType thr_type) {
    // Creating guard page is very expensive. Java thread has HotSpot
    // guard page, only enable glibc guard page for non-Java threads.
    return (thr_type == java_thread ? 0 : page_size());
}
```

```c++
// 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()
```

```c++
// 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.");
            }
        }
    }
}
```