1 /*
2 * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/symbolTable.hpp"
27 #include "classfile/vmSymbols.hpp"
28 #include "code/codeCache.hpp"
29 #include "compiler/compileBroker.hpp"
30 #include "compiler/compilerOracle.hpp"
31 #include "gc_implementation/shared/isGCActiveMark.hpp"
32 #include "memory/heapInspection.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "oops/symbol.hpp"
35 #include "runtime/arguments.hpp"
36 #include "runtime/deoptimization.hpp"
37 #include "runtime/interfaceSupport.hpp"
38 #include "runtime/sweeper.hpp"
39 #include "runtime/thread.inline.hpp"
40 #include "runtime/vm_operations.hpp"
41 #include "services/threadService.hpp"
42 #include "trace/tracing.hpp"
43
44 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
45
46 #define VM_OP_NAME_INITIALIZE(name) #name,
47
48 const char* VM_Operation::_names[VM_Operation::VMOp_Terminating] = \
49 { VM_OPS_DO(VM_OP_NAME_INITIALIZE) };
50
51 void VM_Operation::set_calling_thread(Thread* thread, ThreadPriority priority) {
52 _calling_thread = thread;
53 assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");
54 _priority = priority;
55 }
56
57
58 void VM_Operation::evaluate() {
59 ResourceMark rm;
60 if (TraceVMOperation) {
61 tty->print("[");
62 NOT_PRODUCT(print();)
63 }
64 doit();
65 if (TraceVMOperation) {
66 tty->print_cr("]");
67 }
68 }
69
70 const char* VM_Operation::mode_to_string(Mode mode) {
71 switch(mode) {
72 case _safepoint : return "safepoint";
73 case _no_safepoint : return "no safepoint";
74 case _concurrent : return "concurrent";
75 case _async_safepoint: return "async safepoint";
76 default : return "unknown";
77 }
78 }
79 // Called by fatal error handler.
80 void VM_Operation::print_on_error(outputStream* st) const {
81 st->print("VM_Operation (" PTR_FORMAT "): ", this);
82 st->print("%s", name());
83
84 const char* mode = mode_to_string(evaluation_mode());
85 st->print(", mode: %s", mode);
86
87 if (calling_thread()) {
88 st->print(", requested by thread " PTR_FORMAT, calling_thread());
89 }
90 }
91
92 void VM_ThreadStop::doit() {
93 assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
94 JavaThread* target = java_lang_Thread::thread(target_thread());
95 // Note that this now allows multiple ThreadDeath exceptions to be
96 // thrown at a thread.
97 if (target != NULL) {
98 // the thread has run and is not already in the process of exiting
99 target->send_thread_stop(throwable());
100 }
101 }
102
103 void VM_Deoptimize::doit() {
104 // We do not want any GCs to happen while we are in the middle of this VM operation
105 ResourceMark rm;
106 DeoptimizationMarker dm;
107
108 // Deoptimize all activations depending on marked nmethods
109 Deoptimization::deoptimize_dependents();
110
111 // Make the dependent methods zombies
112 CodeCache::make_marked_nmethods_zombies();
113 }
114
115 void VM_MarkActiveNMethods::doit() {
116 NMethodSweeper::mark_active_nmethods();
117 }
118
119 VM_DeoptimizeFrame::VM_DeoptimizeFrame(JavaThread* thread, intptr_t* id) {
120 _thread = thread;
121 _id = id;
122 }
123
124
125 void VM_DeoptimizeFrame::doit() {
126 Deoptimization::deoptimize_frame_internal(_thread, _id);
127 }
128
129
130 #ifndef PRODUCT
131
132 void VM_DeoptimizeAll::doit() {
133 DeoptimizationMarker dm;
134 // deoptimize all java threads in the system
135 if (DeoptimizeALot) {
136 for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
137 if (thread->has_last_Java_frame()) {
138 thread->deoptimize();
139 }
140 }
141 } else if (DeoptimizeRandom) {
142
143 // Deoptimize some selected threads and frames
144 int tnum = os::random() & 0x3;
145 int fnum = os::random() & 0x3;
146 int tcount = 0;
147 for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
148 if (thread->has_last_Java_frame()) {
149 if (tcount++ == tnum) {
150 tcount = 0;
151 int fcount = 0;
152 // Deoptimize some selected frames.
153 // Biased llocking wants a updated register map
154 for(StackFrameStream fst(thread, UseBiasedLocking); !fst.is_done(); fst.next()) {
155 if (fst.current()->can_be_deoptimized()) {
156 if (fcount++ == fnum) {
157 fcount = 0;
158 Deoptimization::deoptimize(thread, *fst.current(), fst.register_map());
159 }
160 }
161 }
162 }
163 }
164 }
165 }
166 }
167
168
169 void VM_ZombieAll::doit() {
170 JavaThread *thread = (JavaThread *)calling_thread();
171 assert(thread->is_Java_thread(), "must be a Java thread");
172 thread->make_zombies();
173 }
174
175 #endif // !PRODUCT
176
177 void VM_UnlinkSymbols::doit() {
178 JavaThread *thread = (JavaThread *)calling_thread();
179 assert(thread->is_Java_thread(), "must be a Java thread");
180 SymbolTable::unlink();
181 }
182
183 void VM_Verify::doit() {
184 Universe::heap()->prepare_for_verify();
185 Universe::verify(_silent);
186 }
187
188 bool VM_PrintThreads::doit_prologue() {
189 assert(Thread::current()->is_Java_thread(), "just checking");
190
191 // Make sure AbstractOwnableSynchronizer is loaded
192 java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current());
193
194 // Get Heap_lock if concurrent locks will be dumped
195 if (_print_concurrent_locks) {
196 Heap_lock->lock();
197 }
198 return true;
199 }
200
201 void VM_PrintThreads::doit() {
202 Threads::print_on(_out, true, false, _print_concurrent_locks);
203 }
204
205 void VM_PrintThreads::doit_epilogue() {
206 if (_print_concurrent_locks) {
207 // Release Heap_lock
208 Heap_lock->unlock();
209 }
210 }
211
212 void VM_PrintJNI::doit() {
213 JNIHandles::print_on(_out);
214 }
215
216 VM_FindDeadlocks::~VM_FindDeadlocks() {
217 if (_deadlocks != NULL) {
218 DeadlockCycle* cycle = _deadlocks;
219 while (cycle != NULL) {
220 DeadlockCycle* d = cycle;
221 cycle = cycle->next();
222 delete d;
223 }
224 }
225 }
226
227 bool VM_FindDeadlocks::doit_prologue() {
228 assert(Thread::current()->is_Java_thread(), "just checking");
229
230 // Load AbstractOwnableSynchronizer class
231 if (_concurrent_locks) {
232 java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current());
233 }
234
235 return true;
236 }
237
238 void VM_FindDeadlocks::doit() {
239 _deadlocks = ThreadService::find_deadlocks_at_safepoint(_concurrent_locks);
240 if (_out != NULL) {
241 int num_deadlocks = 0;
242 for (DeadlockCycle* cycle = _deadlocks; cycle != NULL; cycle = cycle->next()) {
243 num_deadlocks++;
244 cycle->print_on(_out);
245 }
246
247 if (num_deadlocks == 1) {
248 _out->print_cr("\nFound 1 deadlock.\n");
249 _out->flush();
250 } else if (num_deadlocks > 1) {
251 _out->print_cr("\nFound %d deadlocks.\n", num_deadlocks);
252 _out->flush();
253 }
254 }
255 }
256
257 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,
258 int max_depth,
259 bool with_locked_monitors,
260 bool with_locked_synchronizers) {
261 _result = result;
262 _num_threads = 0; // 0 indicates all threads
263 _threads = NULL;
264 _result = result;
265 _max_depth = max_depth;
266 _with_locked_monitors = with_locked_monitors;
267 _with_locked_synchronizers = with_locked_synchronizers;
268 }
269
270 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,
271 GrowableArray<instanceHandle>* threads,
272 int num_threads,
273 int max_depth,
274 bool with_locked_monitors,
275 bool with_locked_synchronizers) {
276 _result = result;
277 _num_threads = num_threads;
278 _threads = threads;
279 _result = result;
280 _max_depth = max_depth;
281 _with_locked_monitors = with_locked_monitors;
282 _with_locked_synchronizers = with_locked_synchronizers;
283 }
284
285 bool VM_ThreadDump::doit_prologue() {
286 assert(Thread::current()->is_Java_thread(), "just checking");
287
288 // Load AbstractOwnableSynchronizer class before taking thread snapshots
289 java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current());
290
291 if (_with_locked_synchronizers) {
292 // Acquire Heap_lock to dump concurrent locks
293 Heap_lock->lock();
294 }
295
296 return true;
297 }
298
299 void VM_ThreadDump::doit_epilogue() {
300 if (_with_locked_synchronizers) {
301 // Release Heap_lock
302 Heap_lock->unlock();
303 }
304 }
305
306 void VM_ThreadDump::doit() {
307 ResourceMark rm;
308
309 ConcurrentLocksDump concurrent_locks(true);
310 if (_with_locked_synchronizers) {
311 concurrent_locks.dump_at_safepoint();
312 }
313
314 if (_num_threads == 0) {
315 // Snapshot all live threads
316 for (JavaThread* jt = Threads::first(); jt != NULL; jt = jt->next()) {
317 if (jt->is_exiting() ||
318 jt->is_hidden_from_external_view()) {
319 // skip terminating threads and hidden threads
320 continue;
321 }
322 ThreadConcurrentLocks* tcl = NULL;
323 if (_with_locked_synchronizers) {
324 tcl = concurrent_locks.thread_concurrent_locks(jt);
325 }
326 ThreadSnapshot* ts = snapshot_thread(jt, tcl);
327 _result->add_thread_snapshot(ts);
328 }
329 } else {
330 // Snapshot threads in the given _threads array
331 // A dummy snapshot is created if a thread doesn't exist
332 for (int i = 0; i < _num_threads; i++) {
333 instanceHandle th = _threads->at(i);
334 if (th() == NULL) {
335 // skip if the thread doesn't exist
336 // Add a dummy snapshot
337 _result->add_thread_snapshot(new ThreadSnapshot());
338 continue;
339 }
340
341 // Dump thread stack only if the thread is alive and not exiting
342 // and not VM internal thread.
343 JavaThread* jt = java_lang_Thread::thread(th());
344 if (jt == NULL || /* thread not alive */
345 jt->is_exiting() ||
346 jt->is_hidden_from_external_view()) {
347 // add a NULL snapshot if skipped
348 _result->add_thread_snapshot(new ThreadSnapshot());
349 continue;
350 }
351 ThreadConcurrentLocks* tcl = NULL;
352 if (_with_locked_synchronizers) {
353 tcl = concurrent_locks.thread_concurrent_locks(jt);
354 }
355 ThreadSnapshot* ts = snapshot_thread(jt, tcl);
356 _result->add_thread_snapshot(ts);
357 }
358 }
359 }
360
361 ThreadSnapshot* VM_ThreadDump::snapshot_thread(JavaThread* java_thread, ThreadConcurrentLocks* tcl) {
362 ThreadSnapshot* snapshot = new ThreadSnapshot(java_thread);
363 snapshot->dump_stack_at_safepoint(_max_depth, _with_locked_monitors);
364 snapshot->set_concurrent_locks(tcl);
365 return snapshot;
366 }
367
368 volatile bool VM_Exit::_vm_exited = false;
369 Thread * VM_Exit::_shutdown_thread = NULL;
370
371 int VM_Exit::set_vm_exited() {
372 Thread * thr_cur = ThreadLocalStorage::get_thread_slow();
373
374 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already");
375
376 int num_active = 0;
377
378 _shutdown_thread = thr_cur;
379 _vm_exited = true; // global flag
380 for(JavaThread *thr = Threads::first(); thr != NULL; thr = thr->next())
381 if (thr!=thr_cur && thr->thread_state() == _thread_in_native) {
382 ++num_active;
383 thr->set_terminated(JavaThread::_vm_exited); // per-thread flag
384 }
385
386 return num_active;
387 }
388
389 int VM_Exit::wait_for_threads_in_native_to_block() {
390 // VM exits at safepoint. This function must be called at the final safepoint
391 // to wait for threads in _thread_in_native state to be quiescent.
392 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already");
393
394 Thread * thr_cur = ThreadLocalStorage::get_thread_slow();
395 Monitor timer(Mutex::leaf, "VM_Exit timer", true,
396 Monitor::_safepoint_check_never);
397
398 // Compiler threads need longer wait because they can access VM data directly
399 // while in native. If they are active and some structures being used are
400 // deleted by the shutdown sequence, they will crash. On the other hand, user
401 // threads must go through native=>Java/VM transitions first to access VM
402 // data, and they will be stopped during state transition. In theory, we
403 // don't have to wait for user threads to be quiescent, but it's always
404 // better to terminate VM when current thread is the only active thread, so
405 // wait for user threads too. Numbers are in 10 milliseconds.
406 int max_wait_user_thread = 30; // at least 300 milliseconds
407 int max_wait_compiler_thread = 1000; // at least 10 seconds
408
409 int max_wait = max_wait_compiler_thread;
410
411 int attempts = 0;
412 while (true) {
413 int num_active = 0;
414 int num_active_compiler_thread = 0;
415
416 for(JavaThread *thr = Threads::first(); thr != NULL; thr = thr->next()) {
417 if (thr!=thr_cur && thr->thread_state() == _thread_in_native) {
418 num_active++;
419 if (thr->is_Compiler_thread()) {
420 num_active_compiler_thread++;
421 }
422 }
423 }
424
425 if (num_active == 0) {
426 return 0;
427 } else if (attempts > max_wait) {
428 return num_active;
429 } else if (num_active_compiler_thread == 0 && attempts > max_wait_user_thread) {
430 return num_active;
431 }
432
433 attempts++;
434
435 MutexLockerEx ml(&timer, Mutex::_no_safepoint_check_flag);
436 timer.wait(Mutex::_no_safepoint_check_flag, 10);
437 }
438 }
439
440 void VM_Exit::doit() {
441 CompileBroker::set_should_block();
442
443 // Wait for a short period for threads in native to block. Any thread
444 // still executing native code after the wait will be stopped at
445 // native==>Java/VM barriers.
446 // Among 16276 JCK tests, 94% of them come here without any threads still
447 // running in native; the other 6% are quiescent within 250ms (Ultra 80).
448 wait_for_threads_in_native_to_block();
449
450 set_vm_exited();
451
452 // cleanup globals resources before exiting. exit_globals() currently
453 // cleans up outputStream resources and PerfMemory resources.
454 exit_globals();
455
456 // Check for exit hook
457 exit_hook_t exit_hook = Arguments::exit_hook();
458 if (exit_hook != NULL) {
459 // exit hook should exit.
460 exit_hook(_exit_code);
461 // ... but if it didn't, we must do it here
462 vm_direct_exit(_exit_code);
463 } else {
464 vm_direct_exit(_exit_code);
465 }
466 }
467
468
469 void VM_Exit::wait_if_vm_exited() {
470 if (_vm_exited &&
471 ThreadLocalStorage::get_thread_slow() != _shutdown_thread) {
472 // _vm_exited is set at safepoint, and the Threads_lock is never released
473 // we will block here until the process dies
474 Threads_lock->lock_without_safepoint_check();
475 ShouldNotReachHere();
476 }
477 }
478
479 void VM_PrintCompileQueue::doit() {
480 CompileBroker::print_compile_queues(_out);
481 }
482
483 void VM_PrintCodeList::doit() {
484 CodeCache::print_codelist(_out);
485 }
486
487 void VM_PrintCodeCache::doit() {
488 CodeCache::print_layout(_out);
489 }
490
491 #if INCLUDE_SERVICES
492 void VM_PrintClassHierachry::doit() {
493 KlassHierarchy::print_class_hierarchy(_out, _print_interfaces, _print_subclasses, _classname);
494 }
495 #endif