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