jdk-sandbox: comparison hotspot/src/share/vm/runtime/thread.cpp

equal deleted inserted replaced

-:d10b1eca0b45
+:3bf4544bec14
 // Creates the initial ThreadGroup
 static Handle create_initial_thread_group(TRAPS) {
 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_ThreadGroup(), true, CHECK_NH);
-instanceKlassHandle klass (THREAD, k);
+InstanceKlass* ik = InstanceKlass::cast(k);
-Handle system_instance = klass->allocate_instance_handle(CHECK_NH);
+Handle system_instance = ik->allocate_instance_handle(CHECK_NH);
 {
 JavaValue result(T_VOID);
 JavaCalls::call_special(&result,
 system_instance,
-klass,
+ik,
 vmSymbols::object_initializer_name(),
 vmSymbols::void_method_signature(),
 CHECK_NH);
 }
 Universe::set_system_thread_group(system_instance());
-Handle main_instance = klass->allocate_instance_handle(CHECK_NH);
+Handle main_instance = ik->allocate_instance_handle(CHECK_NH);
 {
 JavaValue result(T_VOID);
 Handle string = java_lang_String::create_from_str("main", CHECK_NH);
 JavaCalls::call_special(&result,
 main_instance,
-klass,
+ik,
 vmSymbols::object_initializer_name(),
 vmSymbols::threadgroup_string_void_signature(),
 system_instance,
 string,
 CHECK_NH);
 // Creates the initial Thread
 static oop create_initial_thread(Handle thread_group, JavaThread* thread,
 TRAPS) {
 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL);
-instanceKlassHandle klass (THREAD, k);
+InstanceKlass* ik = InstanceKlass::cast(k);
-instanceHandle thread_oop = klass->allocate_instance_handle(CHECK_NULL);
+instanceHandle thread_oop = ik->allocate_instance_handle(CHECK_NULL);
 java_lang_Thread::set_thread(thread_oop(), thread);
 java_lang_Thread::set_priority(thread_oop(), NormPriority);
 thread->set_threadObj(thread_oop());
 Handle string = java_lang_String::create_from_str("main", CHECK_NULL);
 JavaValue result(T_VOID);
 JavaCalls::call_special(&result, thread_oop,
-klass,
+ik,
 vmSymbols::object_initializer_name(),
 vmSymbols::threadgroup_string_void_signature(),
 thread_group,
 string,
 CHECK_NULL);
 }
 // General purpose hook into Java code, run once when the VM is initialized.
 // The Java library method itself may be changed independently from the VM.
 static void call_postVMInitHook(TRAPS) {
-Klass* k = SystemDictionary::resolve_or_null(vmSymbols::jdk_internal_vm_PostVMInitHook(), THREAD);
+Klass* klass = SystemDictionary::resolve_or_null(vmSymbols::jdk_internal_vm_PostVMInitHook(), THREAD);
-instanceKlassHandle klass (THREAD, k);
+if (klass != NULL) {
-if (klass.not_null()) {
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::run_method_name(),
 vmSymbols::void_method_signature(),
 CHECK);
 }
 // the vm info string
 ResourceMark rm(THREAD);
 const char *vm_info = VM_Version::vm_info_string();
 // java.lang.System class
-Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
+Klass* klass =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-instanceKlassHandle klass (THREAD, k);
 // setProperty arguments
 Handle key_str    = java_lang_String::create_from_str("java.vm.info", CHECK);
 Handle value_str  = java_lang_String::create_from_str(vm_info, CHECK);
 bool daemon, TRAPS) {
 assert(thread_group.not_null(), "thread group should be specified");
 assert(threadObj() == NULL, "should only create Java thread object once");
 Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
-instanceKlassHandle klass (THREAD, k);
+InstanceKlass* ik = InstanceKlass::cast(k);
-instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
+instanceHandle thread_oop = ik->allocate_instance_handle(CHECK);
 java_lang_Thread::set_thread(thread_oop(), this);
 java_lang_Thread::set_priority(thread_oop(), NormPriority);
 set_threadObj(thread_oop());
 if (thread_name != NULL) {
 Handle name = java_lang_String::create_from_str(thread_name, CHECK);
 // Thread gets assigned specified name and null target
 JavaCalls::call_special(&result,
 thread_oop,
-klass,
+ik,
 vmSymbols::object_initializer_name(),
 vmSymbols::threadgroup_string_void_signature(),
 thread_group, // Argument 1
 name,         // Argument 2
 THREAD);
 } else {
 // Thread gets assigned name "Thread-nnn" and null target
 // (java.lang.Thread doesn't have a constructor taking only a ThreadGroup argument)
 JavaCalls::call_special(&result,
 thread_oop,
-klass,
+ik,
 vmSymbols::object_initializer_name(),
 vmSymbols::threadgroup_runnable_void_signature(),
 thread_group, // Argument 1
 Handle(),     // Argument 2
 THREAD);
 if (HAS_PENDING_EXCEPTION) {
 return;
 }
-KlassHandle group(THREAD, SystemDictionary::ThreadGroup_klass());
+Klass* group =  SystemDictionary::ThreadGroup_klass();
 Handle threadObj(THREAD, this->threadObj());
 JavaCalls::call_special(&result,
 thread_group,
 group,
 int time_waited = sleep();
 if (is_error_reported()) {
 // A fatal error has happened, the error handler(VMError::report_and_die)
 // should abort JVM after creating an error log file. However in some
-// rare cases, the error handler itself might deadlock. Here we try to
+// rare cases, the error handler itself might deadlock. Here periodically
-// kill JVM if the fatal error handler fails to abort in 2 minutes.
+// check for error reporting timeouts, and if it happens, just proceed to
-//
+// abort the VM.
 // This code is in WatcherThread because WatcherThread wakes up
 // periodically so the fatal error handler doesn't need to do anything;
 // also because the WatcherThread is less likely to crash than other
 // threads.
 for (;;) {
-if (!ShowMessageBoxOnError
+// Note: we use naked sleep in this loop because we want to avoid using
-&& (OnError == NULL || OnError[0] == '\0')
+// any kind of VM infrastructure which may be broken at this point.
-&& Arguments::abort_hook() == NULL) {
+if (VMError::check_timeout()) {
-os::sleep(this, (jlong)ErrorLogTimeout * 1000, false); // in seconds
+// We hit error reporting timeout. Error reporting was interrupted and
+// will be wrapping things up now (closing files etc). Give it some more
+// time, then quit the VM.
+os::naked_short_sleep(200);
+// Print a message to stderr.
 fdStream err(defaultStream::output_fd());
 err.print_raw_cr("# [ timer expired, abort... ]");
 // skip atexit/vm_exit/vm_abort hooks
 os::die();
 }
-// Wake up 5 seconds later, the fatal handler may reset OnError or
+// Wait a second, then recheck for timeout.
-// ShowMessageBoxOnError when it is ready to abort.
+os::naked_short_sleep(999);
-os::sleep(this, 5 * 1000, false);
 }
 }
 if (_should_terminate) {
 // check for termination before posting the next tick
 }
 if (!destroy_vm) {
 if (uncaught_exception.not_null()) {
 EXCEPTION_MARK;
 // Call method Thread.dispatchUncaughtException().
-KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
+Klass* thread_klass = SystemDictionary::Thread_klass();
 JavaValue result(T_VOID);
 JavaCalls::call_virtual(&result,
 threadObj, thread_klass,
 vmSymbols::dispatchUncaughtException_name(),
 vmSymbols::throwable_void_signature(),
 if (!is_Compiler_thread()) {
 int count = 3;
 while (java_lang_Thread::threadGroup(threadObj()) != NULL && (count-- > 0)) {
 EXCEPTION_MARK;
 JavaValue result(T_VOID);
-KlassHandle thread_klass(THREAD, SystemDictionary::Thread_klass());
+Klass* thread_klass = SystemDictionary::Thread_klass();
 JavaCalls::call_virtual(&result,
 threadObj, thread_klass,
 vmSymbols::exit_method_name(),
 vmSymbols::void_method_signature(),
 THREAD);
 //
 //     System.initPhase1 initializes the system properties, the static
 //     fields in, out, and err. Set up java signal handlers, OS-specific
 //     system settings, and thread group of the main thread.
 static void call_initPhase1(TRAPS) {
-Klass* k =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
+Klass* klass =  SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-instanceKlassHandle klass (THREAD, k);
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::initPhase1_name(),
 vmSymbols::void_method_signature(), CHECK);
 }
 //
 //     After phase 2, The VM will begin search classes from -Xbootclasspath/a.
 static void call_initPhase2(TRAPS) {
 TraceTime timer("Phase2 initialization", TRACETIME_LOG(Info, modules, startuptime));
-Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
+Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-instanceKlassHandle klass (THREAD, k);
 JavaValue result(T_INT);
 JavaCallArguments args;
 args.push_int(DisplayVMOutputToStderr);
 args.push_int(log_is_enabled(Debug, init)); // print stack trace if exception thrown
 //     This will instantiate and set the security manager, set the system class
 //     loader as well as the thread context class loader.  The security manager
 //     and system class loader may be a custom class loaded from -Xbootclasspath/a,
 //     other modules or the application's classpath.
 static void call_initPhase3(TRAPS) {
-Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
+Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_System(), true, CHECK);
-instanceKlassHandle klass (THREAD, k);
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result, klass, vmSymbols::initPhase3_name(),
 vmSymbols::void_method_signature(), CHECK);
 }
 #if INCLUDE_MANAGEMENT
 Management::record_vm_init_completed();
 #endif // INCLUDE_MANAGEMENT
 // Signal Dispatcher needs to be started before VMInit event is posted
-os::signal_init();
+os::signal_init(CHECK_JNI_ERR);
 // Start Attach Listener if +StartAttachListener or it can't be started lazily
 if (!DisableAttachMechanism) {
 AttachListener::vm_start();
 if (StartAttachListener || AttachListener::init_at_startup()) {
 if (this->has_pending_exception()) {
 this->clear_pending_exception();
 }
 EXCEPTION_MARK;
-Klass* k =
+Klass* shutdown_klass =
 SystemDictionary::resolve_or_null(vmSymbols::java_lang_Shutdown(),
 THREAD);
-if (k != NULL) {
+if (shutdown_klass != NULL) {
 // SystemDictionary::resolve_or_null will return null if there was
 // an exception.  If we cannot load the Shutdown class, just don't
 // call Shutdown.shutdown() at all.  This will mean the shutdown hooks
 // and finalizers (if runFinalizersOnExit is set) won't be run.
 // Note that if a shutdown hook was registered or runFinalizersOnExit
 // was called, the Shutdown class would have already been loaded
 // (Runtime.addShutdownHook and runFinalizersOnExit will load it).
-instanceKlassHandle shutdown_klass (THREAD, k);
 JavaValue result(T_VOID);
 JavaCalls::call_static(&result,
 shutdown_klass,
 vmSymbols::shutdown_method_name(),
 vmSymbols::void_method_signature(),

changeset 46369	3bf4544bec14
parent 44326	6c59cca7ff07
parent 46329	53ccc37bda19
child 46388	d7a164ad6b7f