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 }

   221 

   222 void VM_PrintThreads::doit_epilogue() {

   223   if (_print_concurrent_locks) {

   224     // Release Heap_lock

   225     Heap_lock->unlock();

   226   }

   227 }

   228 

   229 void VM_PrintJNI::doit() {

   230   JNIHandles::print_on(_out);

   231 }

   232 

   233 VM_FindDeadlocks::~VM_FindDeadlocks() {

   234   if (_deadlocks != NULL) {

   235     DeadlockCycle* cycle = _deadlocks;

   236     while (cycle != NULL) {

   237       DeadlockCycle* d = cycle;

   238       cycle = cycle->next();

   239       delete d;

   240     }

   241   }

   242 }

   243 

   244 bool VM_FindDeadlocks::doit_prologue() {

   245   if (_concurrent_locks) {

   246     // Make sure AbstractOwnableSynchronizer is loaded

   247     JavaThread* jt = JavaThread::current();

   248     java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(jt);

   249     if (jt->has_pending_exception()) {

   250       return false;

   251     }

   252   }

   253 

   254   return true;

   255 }

   256 

   257 void VM_FindDeadlocks::doit() {

   258   _deadlocks = ThreadService::find_deadlocks_at_safepoint(_concurrent_locks);

   259   if (_out != NULL) {

   260     int num_deadlocks = 0;

   261     for (DeadlockCycle* cycle = _deadlocks; cycle != NULL; cycle = cycle->next()) {

   262       num_deadlocks++;

   263       cycle->print_on(_out);

   264     }

   265 

   266     if (num_deadlocks == 1) {

   267       _out->print_cr("\nFound 1 deadlock.\n");

   268       _out->flush();

   269     } else if (num_deadlocks > 1) {

   270       _out->print_cr("\nFound %d deadlocks.\n", num_deadlocks);

   271       _out->flush();

   272     }

   273   }

   274 }

   275 

   276 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,

   277                              int max_depth,

   278                              bool with_locked_monitors,

   279                              bool with_locked_synchronizers) {

   280   _result = result;

   281   _num_threads = 0; // 0 indicates all threads

   282   _threads = NULL;

   283   _result = result;

   284   _max_depth = max_depth;

   285   _with_locked_monitors = with_locked_monitors;

   286   _with_locked_synchronizers = with_locked_synchronizers;

   287 }

   288 

   289 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,

   290                              GrowableArray<instanceHandle>* threads,

   291                              int num_threads,

   292                              int max_depth,

   293                              bool with_locked_monitors,

   294                              bool with_locked_synchronizers) {

   295   _result = result;

   296   _num_threads = num_threads;

   297   _threads = threads;

   298   _result = result;

   299   _max_depth = max_depth;

   300   _with_locked_monitors = with_locked_monitors;

   301   _with_locked_synchronizers = with_locked_synchronizers;

   302 }

   303 

   304 bool VM_ThreadDump::doit_prologue() {

   305   // Make sure AbstractOwnableSynchronizer is loaded

   306   JavaThread* jt = JavaThread::current();

   307   java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(jt);

   308   if (jt->has_pending_exception()) {

   309     return false;

   310   }

   311 

   312   if (_with_locked_synchronizers) {

   313     // Acquire Heap_lock to dump concurrent locks

   314     Heap_lock->lock();

   315   }

   316 

   317   return true;

   318 }

   319 

   320 void VM_ThreadDump::doit_epilogue() {

   321   if (_with_locked_synchronizers) {

   322     // Release Heap_lock

   323     Heap_lock->unlock();

   324   }

   325 }

   326 

   327 void VM_ThreadDump::doit() {

   328   ResourceMark rm;

   329 

   330   ConcurrentLocksDump concurrent_locks(true);

   331   if (_with_locked_synchronizers) {

   332     concurrent_locks.dump_at_safepoint();

   333   }

   334 

   335   if (_num_threads == 0) {

   336     // Snapshot all live threads

   337     for (JavaThread* jt = Threads::first(); jt != NULL; jt = jt->next()) {

   338       if (jt->is_exiting() ||

   339           jt->is_hidden_from_external_view())  {

   340         // skip terminating threads and hidden threads

   341         continue;

   342       }

   343       ThreadConcurrentLocks* tcl = NULL;

   344       if (_with_locked_synchronizers) {

   345         tcl = concurrent_locks.thread_concurrent_locks(jt);

   346       }

   347       ThreadSnapshot* ts = snapshot_thread(jt, tcl);

   348       _result->add_thread_snapshot(ts);

   349     }

   350   } else {

   351     // Snapshot threads in the given _threads array

   352     // A dummy snapshot is created if a thread doesn't exist

   353     for (int i = 0; i < _num_threads; i++) {

   354       instanceHandle th = _threads->at(i);

   355       if (th() == NULL) {

   356         // skip if the thread doesn't exist

   357         // Add a dummy snapshot

   358         _result->add_thread_snapshot(new ThreadSnapshot());

   359         continue;

   360       }

   361 

   362       // Dump thread stack only if the thread is alive and not exiting

   363       // and not VM internal thread.

   364       JavaThread* jt = java_lang_Thread::thread(th());

   365       if (jt == NULL || /* thread not alive */

   366           jt->is_exiting() ||

   367           jt->is_hidden_from_external_view())  {

   368         // add a NULL snapshot if skipped

   369         _result->add_thread_snapshot(new ThreadSnapshot());

   370         continue;

   371       }

   372       ThreadConcurrentLocks* tcl = NULL;

   373       if (_with_locked_synchronizers) {

   374         tcl = concurrent_locks.thread_concurrent_locks(jt);

   375       }

   376       ThreadSnapshot* ts = snapshot_thread(jt, tcl);

   377       _result->add_thread_snapshot(ts);

   378     }

   379   }

   380 }

   381 

   382 ThreadSnapshot* VM_ThreadDump::snapshot_thread(JavaThread* java_thread, ThreadConcurrentLocks* tcl) {

   383   ThreadSnapshot* snapshot = new ThreadSnapshot(java_thread);

   384   snapshot->dump_stack_at_safepoint(_max_depth, _with_locked_monitors);

   385   snapshot->set_concurrent_locks(tcl);

   386   return snapshot;

   387 }

   388 

   389 volatile bool VM_Exit::_vm_exited = false;

   390 Thread * VM_Exit::_shutdown_thread = NULL;

   391 

   392 int VM_Exit::set_vm_exited() {

   393 

   394   Thread * thr_cur = Thread::current();

   395 

   396   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already");

   397 

   398   int num_active = 0;

   399 

   400   _shutdown_thread = thr_cur;

   401   _vm_exited = true;                                // global flag

   402   for(JavaThread *thr = Threads::first(); thr != NULL; thr = thr->next())

   403     if (thr!=thr_cur && thr->thread_state() == _thread_in_native) {

   404       ++num_active;

   405       thr->set_terminated(JavaThread::_vm_exited);  // per-thread flag

   406     }

   407 

   408   return num_active;

   409 }

   410 

   411 int VM_Exit::wait_for_threads_in_native_to_block() {

   412   // VM exits at safepoint. This function must be called at the final safepoint

   413   // to wait for threads in _thread_in_native state to be quiescent.

   414   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint already");

   415 

   416   Thread * thr_cur = Thread::current();

   417   Monitor timer(Mutex::leaf, "VM_Exit timer", true,

   418                 Monitor::_safepoint_check_never);

   419 

   420   // Compiler threads need longer wait because they can access VM data directly

   421   // while in native. If they are active and some structures being used are

   422   // deleted by the shutdown sequence, they will crash. On the other hand, user

   423   // threads must go through native=>Java/VM transitions first to access VM

   424   // data, and they will be stopped during state transition. In theory, we

   425   // don't have to wait for user threads to be quiescent, but it's always

   426   // better to terminate VM when current thread is the only active thread, so

   427   // wait for user threads too. Numbers are in 10 milliseconds.

   428   int max_wait_user_thread = 30;                  // at least 300 milliseconds

   429   int max_wait_compiler_thread = 1000;            // at least 10 seconds

   430 

   431   int max_wait = max_wait_compiler_thread;

   432 

   433   int attempts = 0;

   434   while (true) {

   435     int num_active = 0;

   436     int num_active_compiler_thread = 0;

   437 

   438     for(JavaThread *thr = Threads::first(); thr != NULL; thr = thr->next()) {

   439       if (thr!=thr_cur && thr->thread_state() == _thread_in_native) {

   440         num_active++;

   441         if (thr->is_Compiler_thread()) {

   442           num_active_compiler_thread++;

   443         }

   444       }

   445     }

   446 

   447     if (num_active == 0) {

   448        return 0;

   449     } else if (attempts > max_wait) {

   450        return num_active;

   451     } else if (num_active_compiler_thread == 0 && attempts > max_wait_user_thread) {

   452        return num_active;

   453     }

   454 

   455     attempts++;

   456 

   457     MutexLockerEx ml(&timer, Mutex::_no_safepoint_check_flag);

   458     timer.wait(Mutex::_no_safepoint_check_flag, 10);

   459   }

   460 }

   461 

   462 void VM_Exit::doit() {

   463   CompileBroker::set_should_block();

   464 

   465   // Wait for a short period for threads in native to block. Any thread

   466   // still executing native code after the wait will be stopped at

   467   // native==>Java/VM barriers.

   468   // Among 16276 JCK tests, 94% of them come here without any threads still

   469   // running in native; the other 6% are quiescent within 250ms (Ultra 80).

   470   wait_for_threads_in_native_to_block();

   471 

   472   set_vm_exited();

   473 

   474   // cleanup globals resources before exiting. exit_globals() currently

   475   // cleans up outputStream resources and PerfMemory resources.

   476   exit_globals();

   477 

   478   // Check for exit hook

   479   exit_hook_t exit_hook = Arguments::exit_hook();

   480   if (exit_hook != NULL) {

   481     // exit hook should exit.

   482     exit_hook(_exit_code);

   483     // ... but if it didn't, we must do it here

   484     vm_direct_exit(_exit_code);

   485   } else {

   486     vm_direct_exit(_exit_code);

   487   }

   488 }

   489 

   490 

   491 void VM_Exit::wait_if_vm_exited() {

   492   if (_vm_exited &&

   493       Thread::current_or_null() != _shutdown_thread) {

   494     // _vm_exited is set at safepoint, and the Threads_lock is never released

   495     // we will block here until the process dies

   496     Threads_lock->lock_without_safepoint_check();

   497     ShouldNotReachHere();

   498   }

   499 }

   500 

   501 void VM_PrintCompileQueue::doit() {

   502   CompileBroker::print_compile_queues(_out);

   503 }

   504 

   505 #if INCLUDE_SERVICES

   506 void VM_PrintClassHierarchy::doit() {

   507   KlassHierarchy::print_class_hierarchy(_out, _print_interfaces, _print_subclasses, _classname);

   508 }

   509 #endif