71 #include "runtime/vframe_hp.hpp" |
71 #include "runtime/vframe_hp.hpp" |
72 #include "runtime/vmThread.hpp" |
72 #include "runtime/vmThread.hpp" |
73 #include "runtime/vm_operations.hpp" |
73 #include "runtime/vm_operations.hpp" |
74 #include "services/attachListener.hpp" |
74 #include "services/attachListener.hpp" |
75 #include "services/management.hpp" |
75 #include "services/management.hpp" |
|
76 #include "services/memTracker.hpp" |
76 #include "services/threadService.hpp" |
77 #include "services/threadService.hpp" |
77 #include "trace/traceEventTypes.hpp" |
78 #include "trace/traceEventTypes.hpp" |
78 #include "utilities/defaultStream.hpp" |
79 #include "utilities/defaultStream.hpp" |
79 #include "utilities/dtrace.hpp" |
80 #include "utilities/dtrace.hpp" |
80 #include "utilities/events.hpp" |
81 #include "utilities/events.hpp" |
157 |
158 |
158 #define DTRACE_THREAD_PROBE(probe, javathread) |
159 #define DTRACE_THREAD_PROBE(probe, javathread) |
159 |
160 |
160 #endif // ndef DTRACE_ENABLED |
161 #endif // ndef DTRACE_ENABLED |
161 |
162 |
|
163 |
162 // Class hierarchy |
164 // Class hierarchy |
163 // - Thread |
165 // - Thread |
164 // - VMThread |
166 // - VMThread |
165 // - WatcherThread |
167 // - WatcherThread |
166 // - ConcurrentMarkSweepThread |
168 // - ConcurrentMarkSweepThread |
167 // - JavaThread |
169 // - JavaThread |
168 // - CompilerThread |
170 // - CompilerThread |
169 |
171 |
170 // ======= Thread ======== |
172 // ======= Thread ======== |
171 |
|
172 // Support for forcing alignment of thread objects for biased locking |
173 // Support for forcing alignment of thread objects for biased locking |
173 void* Thread::operator new(size_t size) { |
174 void* Thread::allocate(size_t size, bool throw_excpt, MEMFLAGS flags) { |
174 if (UseBiasedLocking) { |
175 if (UseBiasedLocking) { |
175 const int alignment = markOopDesc::biased_lock_alignment; |
176 const int alignment = markOopDesc::biased_lock_alignment; |
176 size_t aligned_size = size + (alignment - sizeof(intptr_t)); |
177 size_t aligned_size = size + (alignment - sizeof(intptr_t)); |
177 void* real_malloc_addr = CHeapObj::operator new(aligned_size); |
178 void* real_malloc_addr = throw_excpt? AllocateHeap(aligned_size, flags, CURRENT_PC) |
|
179 : os::malloc(aligned_size, flags, CURRENT_PC); |
178 void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment); |
180 void* aligned_addr = (void*) align_size_up((intptr_t) real_malloc_addr, alignment); |
179 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <= |
181 assert(((uintptr_t) aligned_addr + (uintptr_t) size) <= |
180 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), |
182 ((uintptr_t) real_malloc_addr + (uintptr_t) aligned_size), |
181 "JavaThread alignment code overflowed allocated storage"); |
183 "JavaThread alignment code overflowed allocated storage"); |
182 if (TraceBiasedLocking) { |
184 if (TraceBiasedLocking) { |
185 real_malloc_addr, aligned_addr); |
187 real_malloc_addr, aligned_addr); |
186 } |
188 } |
187 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; |
189 ((Thread*) aligned_addr)->_real_malloc_address = real_malloc_addr; |
188 return aligned_addr; |
190 return aligned_addr; |
189 } else { |
191 } else { |
190 return CHeapObj::operator new(size); |
192 return throw_excpt? AllocateHeap(size, flags, CURRENT_PC) |
|
193 : os::malloc(size, flags, CURRENT_PC); |
191 } |
194 } |
192 } |
195 } |
193 |
196 |
194 void Thread::operator delete(void* p) { |
197 void Thread::operator delete(void* p) { |
195 if (UseBiasedLocking) { |
198 if (UseBiasedLocking) { |
196 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address; |
199 void* real_malloc_addr = ((Thread*) p)->_real_malloc_address; |
197 CHeapObj::operator delete(real_malloc_addr); |
200 FreeHeap(real_malloc_addr, mtThread); |
198 } else { |
201 } else { |
199 CHeapObj::operator delete(p); |
202 FreeHeap(p, mtThread); |
200 } |
203 } |
201 } |
204 } |
202 |
205 |
203 |
206 |
204 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread, |
207 // Base class for all threads: VMThread, WatcherThread, ConcurrentMarkSweepThread, |
212 set_self_raw_id(0); |
215 set_self_raw_id(0); |
213 set_lgrp_id(-1); |
216 set_lgrp_id(-1); |
214 |
217 |
215 // allocated data structures |
218 // allocated data structures |
216 set_osthread(NULL); |
219 set_osthread(NULL); |
217 set_resource_area(new ResourceArea()); |
220 set_resource_area(new (mtThread)ResourceArea()); |
218 set_handle_area(new HandleArea(NULL)); |
221 set_handle_area(new (mtThread) HandleArea(NULL)); |
219 set_active_handles(NULL); |
222 set_active_handles(NULL); |
220 set_free_handle_block(NULL); |
223 set_free_handle_block(NULL); |
221 set_last_handle_mark(NULL); |
224 set_last_handle_mark(NULL); |
222 |
225 |
223 // This initial value ==> never claimed. |
226 // This initial value ==> never claimed. |
304 // initialize structure dependent on thread local storage |
307 // initialize structure dependent on thread local storage |
305 ThreadLocalStorage::set_thread(this); |
308 ThreadLocalStorage::set_thread(this); |
306 |
309 |
307 // set up any platform-specific state. |
310 // set up any platform-specific state. |
308 os::initialize_thread(); |
311 os::initialize_thread(); |
309 |
|
310 } |
312 } |
311 |
313 |
312 void Thread::record_stack_base_and_size() { |
314 void Thread::record_stack_base_and_size() { |
313 set_stack_base(os::current_stack_base()); |
315 set_stack_base(os::current_stack_base()); |
314 set_stack_size(os::current_stack_size()); |
316 set_stack_size(os::current_stack_size()); |
|
317 |
|
318 // record thread's native stack, stack grows downward |
|
319 address vm_base = _stack_base - _stack_size; |
|
320 MemTracker::record_virtual_memory_reserve(vm_base, _stack_size, |
|
321 CURRENT_PC, this); |
|
322 MemTracker::record_virtual_memory_type(vm_base, mtThreadStack); |
315 } |
323 } |
316 |
324 |
317 |
325 |
318 Thread::~Thread() { |
326 Thread::~Thread() { |
319 // Reclaim the objectmonitors from the omFreeList of the moribund thread. |
327 // Reclaim the objectmonitors from the omFreeList of the moribund thread. |
320 ObjectSynchronizer::omFlush (this) ; |
328 ObjectSynchronizer::omFlush (this) ; |
|
329 |
|
330 MemTracker::record_virtual_memory_release((_stack_base - _stack_size), |
|
331 _stack_size, this); |
321 |
332 |
322 // deallocate data structures |
333 // deallocate data structures |
323 delete resource_area(); |
334 delete resource_area(); |
324 // since the handle marks are using the handle area, we have to deallocated the root |
335 // since the handle marks are using the handle area, we have to deallocated the root |
325 // handle mark before deallocating the thread's handle area, |
336 // handle mark before deallocating the thread's handle area, |
1103 _processed_thread = NULL; |
1114 _processed_thread = NULL; |
1104 } |
1115 } |
1105 |
1116 |
1106 NamedThread::~NamedThread() { |
1117 NamedThread::~NamedThread() { |
1107 if (_name != NULL) { |
1118 if (_name != NULL) { |
1108 FREE_C_HEAP_ARRAY(char, _name); |
1119 FREE_C_HEAP_ARRAY(char, _name, mtThread); |
1109 _name = NULL; |
1120 _name = NULL; |
1110 } |
1121 } |
1111 } |
1122 } |
1112 |
1123 |
1113 void NamedThread::set_name(const char* format, ...) { |
1124 void NamedThread::set_name(const char* format, ...) { |
1114 guarantee(_name == NULL, "Only get to set name once."); |
1125 guarantee(_name == NULL, "Only get to set name once."); |
1115 _name = NEW_C_HEAP_ARRAY(char, max_name_len); |
1126 _name = NEW_C_HEAP_ARRAY(char, max_name_len, mtThread); |
1116 guarantee(_name != NULL, "alloc failure"); |
1127 guarantee(_name != NULL, "alloc failure"); |
1117 va_list ap; |
1128 va_list ap; |
1118 va_start(ap, format); |
1129 va_start(ap, format); |
1119 jio_vsnprintf(_name, max_name_len, format, ap); |
1130 jio_vsnprintf(_name, max_name_len, format, ap); |
1120 va_end(ap); |
1131 va_end(ap); |
1293 set_deopt_nmethod(NULL); |
1304 set_deopt_nmethod(NULL); |
1294 clear_must_deopt_id(); |
1305 clear_must_deopt_id(); |
1295 set_monitor_chunks(NULL); |
1306 set_monitor_chunks(NULL); |
1296 set_next(NULL); |
1307 set_next(NULL); |
1297 set_thread_state(_thread_new); |
1308 set_thread_state(_thread_new); |
|
1309 set_recorder(NULL); |
1298 _terminated = _not_terminated; |
1310 _terminated = _not_terminated; |
1299 _privileged_stack_top = NULL; |
1311 _privileged_stack_top = NULL; |
1300 _array_for_gc = NULL; |
1312 _array_for_gc = NULL; |
1301 _suspend_equivalent = false; |
1313 _suspend_equivalent = false; |
1302 _in_deopt_handler = 0; |
1314 _in_deopt_handler = 0; |
1368 _jni_attach_state = _attaching_via_jni; |
1380 _jni_attach_state = _attaching_via_jni; |
1369 } else { |
1381 } else { |
1370 _jni_attach_state = _not_attaching_via_jni; |
1382 _jni_attach_state = _not_attaching_via_jni; |
1371 } |
1383 } |
1372 assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor"); |
1384 assert(_deferred_card_mark.is_empty(), "Default MemRegion ctor"); |
|
1385 _safepoint_visible = false; |
1373 } |
1386 } |
1374 |
1387 |
1375 bool JavaThread::reguard_stack(address cur_sp) { |
1388 bool JavaThread::reguard_stack(address cur_sp) { |
1376 if (_stack_guard_state != stack_guard_yellow_disabled) { |
1389 if (_stack_guard_state != stack_guard_yellow_disabled) { |
1377 return true; // Stack already guarded or guard pages not needed. |
1390 return true; // Stack already guarded or guard pages not needed. |
1430 // %note runtime_23 |
1443 // %note runtime_23 |
1431 os::ThreadType thr_type = os::java_thread; |
1444 os::ThreadType thr_type = os::java_thread; |
1432 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : |
1445 thr_type = entry_point == &compiler_thread_entry ? os::compiler_thread : |
1433 os::java_thread; |
1446 os::java_thread; |
1434 os::create_thread(this, thr_type, stack_sz); |
1447 os::create_thread(this, thr_type, stack_sz); |
1435 |
1448 _safepoint_visible = false; |
1436 // The _osthread may be NULL here because we ran out of memory (too many threads active). |
1449 // The _osthread may be NULL here because we ran out of memory (too many threads active). |
1437 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller |
1450 // We need to throw and OutOfMemoryError - however we cannot do this here because the caller |
1438 // may hold a lock and all locks must be unlocked before throwing the exception (throwing |
1451 // may hold a lock and all locks must be unlocked before throwing the exception (throwing |
1439 // the exception consists of creating the exception object & initializing it, initialization |
1452 // the exception consists of creating the exception object & initializing it, initialization |
1440 // will leave the VM via a JavaCall and then all locks must be unlocked). |
1453 // will leave the VM via a JavaCall and then all locks must be unlocked). |
1447 |
1460 |
1448 JavaThread::~JavaThread() { |
1461 JavaThread::~JavaThread() { |
1449 if (TraceThreadEvents) { |
1462 if (TraceThreadEvents) { |
1450 tty->print_cr("terminate thread %p", this); |
1463 tty->print_cr("terminate thread %p", this); |
1451 } |
1464 } |
|
1465 |
|
1466 // Info NMT that this JavaThread is exiting, its memory |
|
1467 // recorder should be collected |
|
1468 assert(!is_safepoint_visible(), "wrong state"); |
|
1469 MemTracker::thread_exiting(this); |
1452 |
1470 |
1453 // JSR166 -- return the parker to the free list |
1471 // JSR166 -- return the parker to the free list |
1454 Parker::Release(_parker); |
1472 Parker::Release(_parker); |
1455 _parker = NULL ; |
1473 _parker = NULL ; |
1456 |
1474 |
2890 |
2908 |
2891 // JVMTI PopFrame support |
2909 // JVMTI PopFrame support |
2892 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { |
2910 void JavaThread::popframe_preserve_args(ByteSize size_in_bytes, void* start) { |
2893 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); |
2911 assert(_popframe_preserved_args == NULL, "should not wipe out old PopFrame preserved arguments"); |
2894 if (in_bytes(size_in_bytes) != 0) { |
2912 if (in_bytes(size_in_bytes) != 0) { |
2895 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes)); |
2913 _popframe_preserved_args = NEW_C_HEAP_ARRAY(char, in_bytes(size_in_bytes), mtThread); |
2896 _popframe_preserved_args_size = in_bytes(size_in_bytes); |
2914 _popframe_preserved_args_size = in_bytes(size_in_bytes); |
2897 Copy::conjoint_jbytes(start, _popframe_preserved_args, _popframe_preserved_args_size); |
2915 Copy::conjoint_jbytes(start, _popframe_preserved_args, _popframe_preserved_args_size); |
2898 } |
2916 } |
2899 } |
2917 } |
2900 |
2918 |
2912 return in_WordSize(sz / wordSize); |
2930 return in_WordSize(sz / wordSize); |
2913 } |
2931 } |
2914 |
2932 |
2915 void JavaThread::popframe_free_preserved_args() { |
2933 void JavaThread::popframe_free_preserved_args() { |
2916 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); |
2934 assert(_popframe_preserved_args != NULL, "should not free PopFrame preserved arguments twice"); |
2917 FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args); |
2935 FREE_C_HEAP_ARRAY(char, (char*) _popframe_preserved_args, mtThread); |
2918 _popframe_preserved_args = NULL; |
2936 _popframe_preserved_args = NULL; |
2919 _popframe_preserved_args_size = 0; |
2937 _popframe_preserved_args_size = 0; |
2920 } |
2938 } |
2921 |
2939 |
2922 #ifndef PRODUCT |
2940 #ifndef PRODUCT |
3161 |
3179 |
3162 // Initialize the os module after parsing the args |
3180 // Initialize the os module after parsing the args |
3163 jint os_init_2_result = os::init_2(); |
3181 jint os_init_2_result = os::init_2(); |
3164 if (os_init_2_result != JNI_OK) return os_init_2_result; |
3182 if (os_init_2_result != JNI_OK) return os_init_2_result; |
3165 |
3183 |
|
3184 // intialize TLS |
|
3185 ThreadLocalStorage::init(); |
|
3186 |
|
3187 // Bootstrap native memory tracking, so it can start recording memory |
|
3188 // activities before worker thread is started. This is the first phase |
|
3189 // of bootstrapping, VM is currently running in single-thread mode. |
|
3190 MemTracker::bootstrap_single_thread(); |
|
3191 |
3166 // Initialize output stream logging |
3192 // Initialize output stream logging |
3167 ostream_init_log(); |
3193 ostream_init_log(); |
3168 |
3194 |
3169 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad |
3195 // Convert -Xrun to -agentlib: if there is no JVM_OnLoad |
3170 // Must be before create_vm_init_agents() |
3196 // Must be before create_vm_init_agents() |
3179 |
3205 |
3180 // Initialize Threads state |
3206 // Initialize Threads state |
3181 _thread_list = NULL; |
3207 _thread_list = NULL; |
3182 _number_of_threads = 0; |
3208 _number_of_threads = 0; |
3183 _number_of_non_daemon_threads = 0; |
3209 _number_of_non_daemon_threads = 0; |
3184 |
|
3185 // Initialize TLS |
|
3186 ThreadLocalStorage::init(); |
|
3187 |
3210 |
3188 // Initialize global data structures and create system classes in heap |
3211 // Initialize global data structures and create system classes in heap |
3189 vm_init_globals(); |
3212 vm_init_globals(); |
3190 |
3213 |
3191 // Attach the main thread to this os thread |
3214 // Attach the main thread to this os thread |
3214 main_thread->create_stack_guard_pages(); |
3237 main_thread->create_stack_guard_pages(); |
3215 |
3238 |
3216 // Initialize Java-Level synchronization subsystem |
3239 // Initialize Java-Level synchronization subsystem |
3217 ObjectMonitor::Initialize() ; |
3240 ObjectMonitor::Initialize() ; |
3218 |
3241 |
|
3242 // Second phase of bootstrapping, VM is about entering multi-thread mode |
|
3243 MemTracker::bootstrap_multi_thread(); |
|
3244 |
3219 // Initialize global modules |
3245 // Initialize global modules |
3220 jint status = init_globals(); |
3246 jint status = init_globals(); |
3221 if (status != JNI_OK) { |
3247 if (status != JNI_OK) { |
3222 delete main_thread; |
3248 delete main_thread; |
3223 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again |
3249 *canTryAgain = false; // don't let caller call JNI_CreateJavaVM again |
3240 if (VerifyBeforeGC && |
3266 if (VerifyBeforeGC && |
3241 Universe::heap()->total_collections() >= VerifyGCStartAt) { |
3267 Universe::heap()->total_collections() >= VerifyGCStartAt) { |
3242 Universe::heap()->prepare_for_verify(); |
3268 Universe::heap()->prepare_for_verify(); |
3243 Universe::verify(); // make sure we're starting with a clean slate |
3269 Universe::verify(); // make sure we're starting with a clean slate |
3244 } |
3270 } |
|
3271 |
|
3272 // Fully start NMT |
|
3273 MemTracker::start(); |
3245 |
3274 |
3246 // Create the VMThread |
3275 // Create the VMThread |
3247 { TraceTime timer("Start VMThread", TraceStartupTime); |
3276 { TraceTime timer("Start VMThread", TraceStartupTime); |
3248 VMThread::create(); |
3277 VMThread::create(); |
3249 Thread* vmthread = VMThread::vm_thread(); |
3278 Thread* vmthread = VMThread::vm_thread(); |
3542 if (agent->is_absolute_path()) { |
3571 if (agent->is_absolute_path()) { |
3543 library = os::dll_load(name, ebuf, sizeof ebuf); |
3572 library = os::dll_load(name, ebuf, sizeof ebuf); |
3544 if (library == NULL) { |
3573 if (library == NULL) { |
3545 const char *sub_msg = " in absolute path, with error: "; |
3574 const char *sub_msg = " in absolute path, with error: "; |
3546 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; |
3575 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; |
3547 char *buf = NEW_C_HEAP_ARRAY(char, len); |
3576 char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread); |
3548 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); |
3577 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); |
3549 // If we can't find the agent, exit. |
3578 // If we can't find the agent, exit. |
3550 vm_exit_during_initialization(buf, NULL); |
3579 vm_exit_during_initialization(buf, NULL); |
3551 FREE_C_HEAP_ARRAY(char, buf); |
3580 FREE_C_HEAP_ARRAY(char, buf, mtThread); |
3552 } |
3581 } |
3553 } else { |
3582 } else { |
3554 // Try to load the agent from the standard dll directory |
3583 // Try to load the agent from the standard dll directory |
3555 os::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), name); |
3584 os::dll_build_name(buffer, sizeof(buffer), Arguments::get_dll_dir(), name); |
3556 library = os::dll_load(buffer, ebuf, sizeof ebuf); |
3585 library = os::dll_load(buffer, ebuf, sizeof ebuf); |
3560 char *props = Arguments::get_kernel_properties(); |
3589 char *props = Arguments::get_kernel_properties(); |
3561 char *home = Arguments::get_java_home(); |
3590 char *home = Arguments::get_java_home(); |
3562 const char *fmt = "%s/bin/java %s -Dkernel.background.download=false" |
3591 const char *fmt = "%s/bin/java %s -Dkernel.background.download=false" |
3563 " sun.jkernel.DownloadManager -download client_jvm"; |
3592 " sun.jkernel.DownloadManager -download client_jvm"; |
3564 size_t length = strlen(props) + strlen(home) + strlen(fmt) + 1; |
3593 size_t length = strlen(props) + strlen(home) + strlen(fmt) + 1; |
3565 char *cmd = NEW_C_HEAP_ARRAY(char, length); |
3594 char *cmd = NEW_C_HEAP_ARRAY(char, length, mtThread); |
3566 jio_snprintf(cmd, length, fmt, home, props); |
3595 jio_snprintf(cmd, length, fmt, home, props); |
3567 int status = os::fork_and_exec(cmd); |
3596 int status = os::fork_and_exec(cmd); |
3568 FreeHeap(props); |
3597 FreeHeap(props); |
3569 if (status == -1) { |
3598 if (status == -1) { |
3570 warning(cmd); |
3599 warning(cmd); |
3571 vm_exit_during_initialization("fork_and_exec failed: %s", |
3600 vm_exit_during_initialization("fork_and_exec failed: %s", |
3572 strerror(errno)); |
3601 strerror(errno)); |
3573 } |
3602 } |
3574 FREE_C_HEAP_ARRAY(char, cmd); |
3603 FREE_C_HEAP_ARRAY(char, cmd, mtThread); |
3575 // when this comes back the instrument.dll should be where it belongs. |
3604 // when this comes back the instrument.dll should be where it belongs. |
3576 library = os::dll_load(buffer, ebuf, sizeof ebuf); |
3605 library = os::dll_load(buffer, ebuf, sizeof ebuf); |
3577 } |
3606 } |
3578 #endif // KERNEL |
3607 #endif // KERNEL |
3579 if (library == NULL) { // Try the local directory |
3608 if (library == NULL) { // Try the local directory |
3581 os::dll_build_name(buffer, sizeof(buffer), ns, name); |
3610 os::dll_build_name(buffer, sizeof(buffer), ns, name); |
3582 library = os::dll_load(buffer, ebuf, sizeof ebuf); |
3611 library = os::dll_load(buffer, ebuf, sizeof ebuf); |
3583 if (library == NULL) { |
3612 if (library == NULL) { |
3584 const char *sub_msg = " on the library path, with error: "; |
3613 const char *sub_msg = " on the library path, with error: "; |
3585 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; |
3614 size_t len = strlen(msg) + strlen(name) + strlen(sub_msg) + strlen(ebuf) + 1; |
3586 char *buf = NEW_C_HEAP_ARRAY(char, len); |
3615 char *buf = NEW_C_HEAP_ARRAY(char, len, mtThread); |
3587 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); |
3616 jio_snprintf(buf, len, "%s%s%s%s", msg, name, sub_msg, ebuf); |
3588 // If we can't find the agent, exit. |
3617 // If we can't find the agent, exit. |
3589 vm_exit_during_initialization(buf, NULL); |
3618 vm_exit_during_initialization(buf, NULL); |
3590 FREE_C_HEAP_ARRAY(char, buf); |
3619 FREE_C_HEAP_ARRAY(char, buf, mtThread); |
3591 } |
3620 } |
3592 } |
3621 } |
3593 } |
3622 } |
3594 agent->set_os_lib(library); |
3623 agent->set_os_lib(library); |
3595 } |
3624 } |
3754 // there is a serious error in VM. The two shutdown paths are not exactly |
3783 // there is a serious error in VM. The two shutdown paths are not exactly |
3755 // the same, but they share Shutdown.shutdown() at Java level and before_exit() |
3784 // the same, but they share Shutdown.shutdown() at Java level and before_exit() |
3756 // and VM_Exit op at VM level. |
3785 // and VM_Exit op at VM level. |
3757 // |
3786 // |
3758 // Shutdown sequence: |
3787 // Shutdown sequence: |
|
3788 // + Shutdown native memory tracking if it is on |
3759 // + Wait until we are the last non-daemon thread to execute |
3789 // + Wait until we are the last non-daemon thread to execute |
3760 // <-- every thing is still working at this moment --> |
3790 // <-- every thing is still working at this moment --> |
3761 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level |
3791 // + Call java.lang.Shutdown.shutdown(), which will invoke Java level |
3762 // shutdown hooks, run finalizers if finalization-on-exit |
3792 // shutdown hooks, run finalizers if finalization-on-exit |
3763 // + Call before_exit(), prepare for VM exit |
3793 // + Call before_exit(), prepare for VM exit |
3799 // |
3829 // |
3800 Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0, |
3830 Threads_lock->wait(!Mutex::_no_safepoint_check_flag, 0, |
3801 Mutex::_as_suspend_equivalent_flag); |
3831 Mutex::_as_suspend_equivalent_flag); |
3802 } |
3832 } |
3803 |
3833 |
|
3834 // Shutdown NMT before exit. Otherwise, |
|
3835 // it will run into trouble when system destroys static variables. |
|
3836 MemTracker::shutdown(MemTracker::NMT_normal); |
|
3837 |
3804 // Hang forever on exit if we are reporting an error. |
3838 // Hang forever on exit if we are reporting an error. |
3805 if (ShowMessageBoxOnError && is_error_reported()) { |
3839 if (ShowMessageBoxOnError && is_error_reported()) { |
3806 os::infinite_sleep(); |
3840 os::infinite_sleep(); |
3807 } |
3841 } |
3808 os::wait_for_keypress_at_exit(); |
3842 os::wait_for_keypress_at_exit(); |
3905 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) { |
3939 if ((!force_daemon) && (threadObj == NULL || !java_lang_Thread::is_daemon(threadObj))) { |
3906 _number_of_non_daemon_threads++; |
3940 _number_of_non_daemon_threads++; |
3907 daemon = false; |
3941 daemon = false; |
3908 } |
3942 } |
3909 |
3943 |
|
3944 p->set_safepoint_visible(true); |
|
3945 |
3910 ThreadService::add_thread(p, daemon); |
3946 ThreadService::add_thread(p, daemon); |
3911 |
3947 |
3912 // Possible GC point. |
3948 // Possible GC point. |
3913 Events::log(p, "Thread added: " INTPTR_FORMAT, p); |
3949 Events::log(p, "Thread added: " INTPTR_FORMAT, p); |
3914 } |
3950 } |
3950 // Make sure that safepoint code disregard this thread. This is needed since |
3986 // Make sure that safepoint code disregard this thread. This is needed since |
3951 // the thread might mess around with locks after this point. This can cause it |
3987 // the thread might mess around with locks after this point. This can cause it |
3952 // to do callbacks into the safepoint code. However, the safepoint code is not aware |
3988 // to do callbacks into the safepoint code. However, the safepoint code is not aware |
3953 // of this thread since it is removed from the queue. |
3989 // of this thread since it is removed from the queue. |
3954 p->set_terminated_value(); |
3990 p->set_terminated_value(); |
|
3991 |
|
3992 // Now, this thread is not visible to safepoint |
|
3993 p->set_safepoint_visible(false); |
|
3994 |
3955 } // unlock Threads_lock |
3995 } // unlock Threads_lock |
3956 |
3996 |
3957 // Since Events::log uses a lock, we grab it outside the Threads_lock |
3997 // Since Events::log uses a lock, we grab it outside the Threads_lock |
3958 Events::log(p, "Thread exited: " INTPTR_FORMAT, p); |
3998 Events::log(p, "Thread exited: " INTPTR_FORMAT, p); |
3959 } |
3999 } |