os::initialize_thread()
//Linux版(jdk7/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp) void os::initialize_thread() { // Nothing to do. }
ちなみにSolaris版はこんな感じ。
//Solaris版(jdk7/hotspot/src/os/solaris/vm/os_solaris.cpp) // First crack at OS-specific initialization, from inside the new thread. void os::initialize_thread() { int r = thr_main() ; guarantee (r == 0 || r == 1, "CR6501650 or CR6493689") ; if (r) { JavaThread* jt = (JavaThread *)Thread::current(); assert(jt != NULL,"Sanity check"); size_t stack_size; address base = jt->stack_base(); if (Arguments::created_by_java_launcher()) { // Use 2MB to allow for Solaris 7 64 bit mode. stack_size = JavaThread::stack_size_at_create() == 0 ? 2048*K : JavaThread::stack_size_at_create(); // There are rare cases when we may have already used more than // the basic stack size allotment before this method is invoked. // Attempt to allow for a normally sized java_stack. size_t current_stack_offset = (size_t)(base - (address)&stack_size); stack_size += ReservedSpace::page_align_size_down(current_stack_offset); } else { // 6269555: If we were not created by a Java launcher, i.e. if we are // running embedded in a native application, treat the primordial thread // as much like a native attached thread as possible. This means using // the current stack size from thr_stksegment(), unless it is too large // to reliably setup guard pages. A reasonable max size is 8MB. size_t current_size = current_stack_size(); // This should never happen, but just in case.... if (current_size == 0) current_size = 2 * K * K; stack_size = current_size > (8 * K * K) ? (8 * K * K) : current_size; } address bottom = (address)align_size_up((intptr_t)(base - stack_size), os::vm_page_size());; stack_size = (size_t)(base - bottom); assert(stack_size > 0, "Stack size calculation problem"); if (stack_size > jt->stack_size()) { NOT_PRODUCT( struct rlimit limits; getrlimit(RLIMIT_STACK, &limits); size_t size = adjust_stack_size(base, (size_t)limits.rlim_cur); assert(size >= jt->stack_size(), "Stack size problem in main thread"); ) tty->print_cr( "Stack size of %d Kb exceeds current limit of %d Kb.\n" "(Stack sizes are rounded up to a multiple of the system page size.)\n" "See limit(1) to increase the stack size limit.", stack_size / K, jt->stack_size() / K); vm_exit(1); } assert(jt->stack_size() >= stack_size, "Attempt to map more stack than was allocated"); jt->set_stack_size(stack_size); } // 5/22/01: Right now alternate signal stacks do not handle // throwing stack overflow exceptions, see bug 4463178 // Until a fix is found for this, T2 will NOT imply alternate signal // stacks. // If using T2 libthread threads, install an alternate signal stack. // Because alternate stacks associate with LWPs on Solaris, // see sigaltstack(2), if using UNBOUND threads, or if UseBoundThreads // we prefer to explicitly stack bang. // If not using T2 libthread, but using UseBoundThreads any threads // (primordial thread, jni_attachCurrentThread) we do not create, // probably are not bound, therefore they can not have an alternate // signal stack. Since our stack banging code is generated and // is shared across threads, all threads must be bound to allow // using alternate signal stacks. The alternative is to interpose // on _lwp_create to associate an alt sig stack with each LWP, // and this could be a problem when the JVM is embedded. // We would prefer to use alternate signal stacks with T2 // Since there is currently no accurate way to detect T2 // we do not. Assuming T2 when running T1 causes sig 11s or assertions // on installing alternate signal stacks // 05/09/03: removed alternate signal stack support for Solaris // The alternate signal stack mechanism is no longer needed to // handle stack overflow. This is now handled by allocating // guard pages (red zone) and stackbanging. // Initially the alternate signal stack mechanism was removed because // it did not work with T1 llibthread. Alternate // signal stacks MUST have all threads bound to lwps. Applications // can create their own threads and attach them without their being // bound under T1. This is frequently the case for the primordial thread. // If we were ever to reenable this mechanism we would need to // use the dynamic check for T2 libthread. os::Solaris::init_thread_fpu_state(); std::set_terminate(_handle_uncaught_cxx_exception); }