1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 # include "incls/_precompiled.incl"

    26 # include "incls/_vm_operations.cpp.incl"

    27 

    28 #define VM_OP_NAME_INITIALIZE(name) #name,

    29 

    30 const char* VM_Operation::_names[VM_Operation::VMOp_Terminating] = \

    31   { VM_OPS_DO(VM_OP_NAME_INITIALIZE) };

    32 

    33 void VM_Operation::set_calling_thread(Thread* thread, ThreadPriority priority) {

    34   _calling_thread = thread;

    35   assert(MinPriority <= priority && priority <= MaxPriority, "sanity check");

    36   _priority = priority;

    37 }

    38 

    39 

    40 void VM_Operation::evaluate() {

    41   ResourceMark rm;

    42   if (TraceVMOperation) {

    43     tty->print("[");

    44     NOT_PRODUCT(print();)

    45   }

    46   doit();

    47   if (TraceVMOperation) {

    48     tty->print_cr("]");

    49   }

    50 }

    51 

    52 // Called by fatal error handler.

    53 void VM_Operation::print_on_error(outputStream* st) const {

    54   st->print("VM_Operation (" PTR_FORMAT "): ", this);

    55   st->print("%s", name());

    56 

    57   const char* mode;

    58   switch(evaluation_mode()) {

    59     case _safepoint      : mode = "safepoint";       break;

    60     case _no_safepoint   : mode = "no safepoint";    break;

    61     case _concurrent     : mode = "concurrent";      break;

    62     case _async_safepoint: mode = "async safepoint"; break;

    63     default              : mode = "unknown";         break;

    64   }

    65   st->print(", mode: %s", mode);

    66 

    67   if (calling_thread()) {

    68     st->print(", requested by thread " PTR_FORMAT, calling_thread());

    69   }

    70 }

    71 

    72 void VM_ThreadStop::doit() {

    73   assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");

    74   JavaThread* target = java_lang_Thread::thread(target_thread());

    75   // Note that this now allows multiple ThreadDeath exceptions to be

    76   // thrown at a thread.

    77   if (target != NULL) {

    78     // the thread has run and is not already in the process of exiting

    79     target->send_thread_stop(throwable());

    80   }

    81 }

    82 

    83 void VM_Deoptimize::doit() {

    84   // We do not want any GCs to happen while we are in the middle of this VM operation

    85   ResourceMark rm;

    86   DeoptimizationMarker dm;

    87 

    88   // Deoptimize all activations depending on marked nmethods

    89   Deoptimization::deoptimize_dependents();

    90 

    91   // Make the dependent methods zombies

    92   CodeCache::make_marked_nmethods_zombies();

    93 }

    94 

    95 

    96 VM_DeoptimizeFrame::VM_DeoptimizeFrame(JavaThread* thread, intptr_t* id) {

    97   _thread = thread;

    98   _id     = id;

    99 }

   100 

   101 

   102 void VM_DeoptimizeFrame::doit() {

   103   Deoptimization::deoptimize_frame(_thread, _id);

   104 }

   105 

   106 

   107 #ifndef PRODUCT

   108 

   109 void VM_DeoptimizeAll::doit() {

   110   DeoptimizationMarker dm;

   111   // deoptimize all java threads in the system

   112   if (DeoptimizeALot) {

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

   114       if (thread->has_last_Java_frame()) {

   115         thread->deoptimize();

   116       }

   117     }

   118   } else if (DeoptimizeRandom) {

   119 

   120     // Deoptimize some selected threads and frames

   121     int tnum = os::random() & 0x3;

   122     int fnum =  os::random() & 0x3;

   123     int tcount = 0;

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

   125       if (thread->has_last_Java_frame()) {

   126         if (tcount++ == tnum)  {

   127         tcount = 0;

   128           int fcount = 0;

   129           // Deoptimize some selected frames.

   130           // Biased llocking wants a updated register map

   131           for(StackFrameStream fst(thread, UseBiasedLocking); !fst.is_done(); fst.next()) {

   132             if (fst.current()->can_be_deoptimized()) {

   133               if (fcount++ == fnum) {

   134                 fcount = 0;

   135                 Deoptimization::deoptimize(thread, *fst.current(), fst.register_map());

   136               }

   137             }

   138           }

   139         }

   140       }

   141     }

   142   }

   143 }

   144 

   145 

   146 void VM_ZombieAll::doit() {

   147   JavaThread *thread = (JavaThread *)calling_thread();

   148   assert(thread->is_Java_thread(), "must be a Java thread");

   149   thread->make_zombies();

   150 }

   151 

   152 #endif // !PRODUCT

   153 

   154 void VM_Verify::doit() {

   155   Universe::verify();

   156 }

   157 

   158 bool VM_PrintThreads::doit_prologue() {

   159   assert(Thread::current()->is_Java_thread(), "just checking");

   160 

   161   // Make sure AbstractOwnableSynchronizer is loaded

   162   if (JDK_Version::is_gte_jdk16x_version()) {

   163     java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current());

   164   }

   165 

   166   // Get Heap_lock if concurrent locks will be dumped

   167   if (_print_concurrent_locks) {

   168     Heap_lock->lock();

   169   }

   170   return true;

   171 }

   172 

   173 void VM_PrintThreads::doit() {

   174   Threads::print_on(_out, true, false, _print_concurrent_locks);

   175 }

   176 

   177 void VM_PrintThreads::doit_epilogue() {

   178   if (_print_concurrent_locks) {

   179     // Release Heap_lock

   180     Heap_lock->unlock();

   181   }

   182 }

   183 

   184 void VM_PrintJNI::doit() {

   185   JNIHandles::print_on(_out);

   186 }

   187 

   188 VM_FindDeadlocks::~VM_FindDeadlocks() {

   189   if (_deadlocks != NULL) {

   190     DeadlockCycle* cycle = _deadlocks;

   191     while (cycle != NULL) {

   192       DeadlockCycle* d = cycle;

   193       cycle = cycle->next();

   194       delete d;

   195     }

   196   }

   197 }

   198 

   199 bool VM_FindDeadlocks::doit_prologue() {

   200   assert(Thread::current()->is_Java_thread(), "just checking");

   201 

   202   // Load AbstractOwnableSynchronizer class

   203   if (_concurrent_locks && JDK_Version::is_gte_jdk16x_version()) {

   204     java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current());

   205   }

   206 

   207   return true;

   208 }

   209 

   210 void VM_FindDeadlocks::doit() {

   211   _deadlocks = ThreadService::find_deadlocks_at_safepoint(_concurrent_locks);

   212   if (_out != NULL) {

   213     int num_deadlocks = 0;

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

   215       num_deadlocks++;

   216       cycle->print_on(_out);

   217     }

   218 

   219     if (num_deadlocks == 1) {

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

   221       _out->flush();

   222     } else if (num_deadlocks > 1) {

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

   224       _out->flush();

   225     }

   226   }

   227 }

   228 

   229 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,

   230                              int max_depth,

   231                              bool with_locked_monitors,

   232                              bool with_locked_synchronizers) {

   233   _result = result;

   234   _num_threads = 0; // 0 indicates all threads

   235   _threads = NULL;

   236   _result = result;

   237   _max_depth = max_depth;

   238   _with_locked_monitors = with_locked_monitors;

   239   _with_locked_synchronizers = with_locked_synchronizers;

   240 }

   241 

   242 VM_ThreadDump::VM_ThreadDump(ThreadDumpResult* result,

   243                              GrowableArray<instanceHandle>* threads,

   244                              int num_threads,

   245                              int max_depth,

   246                              bool with_locked_monitors,

   247                              bool with_locked_synchronizers) {

   248   _result = result;

   249   _num_threads = num_threads;

   250   _threads = threads;

   251   _result = result;

   252   _max_depth = max_depth;

   253   _with_locked_monitors = with_locked_monitors;

   254   _with_locked_synchronizers = with_locked_synchronizers;

   255 }

   256 

   257 bool VM_ThreadDump::doit_prologue() {

   258   assert(Thread::current()->is_Java_thread(), "just checking");

   259 

   260   // Load AbstractOwnableSynchronizer class before taking thread snapshots

   261   if (JDK_Version::is_gte_jdk16x_version()) {

   262     java_util_concurrent_locks_AbstractOwnableSynchronizer::initialize(JavaThread::current());

   263   }

   264 

   265   if (_with_locked_synchronizers) {

   266     // Acquire Heap_lock to dump concurrent locks

   267     Heap_lock->lock();

   268   }

   269 

   270   return true;

   271 }

   272 

   273 void VM_ThreadDump::doit_epilogue() {

   274   if (_with_locked_synchronizers) {

   275     // Release Heap_lock

   276     Heap_lock->unlock();

   277   }

   278 }

   279 

   280 void VM_ThreadDump::doit() {

   281   ResourceMark rm;

   282 

   283   ConcurrentLocksDump concurrent_locks(true);

   284   if (_with_locked_synchronizers) {

   285     concurrent_locks.dump_at_safepoint();

   286   }

   287 

   288   if (_num_threads == 0) {

   289     // Snapshot all live threads

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

   291       if (jt->is_exiting() ||

   292           jt->is_hidden_from_external_view())  {

   293         // skip terminating threads and hidden threads

   294         continue;

   295       }

   296       ThreadConcurrentLocks* tcl = NULL;

   297       if (_with_locked_synchronizers) {

   298         tcl = concurrent_locks.thread_concurrent_locks(jt);

   299       }

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

   301       _result->add_thread_snapshot(ts);

   302     }

   303   } else {

   304     // Snapshot threads in the given _threads array

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

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

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

   308       if (th() == NULL) {

   309         // skip if the thread doesn't exist

   310         // Add a dummy snapshot

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

   312         continue;

   313       }

   314 

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

   316       // and not VM internal thread.

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

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

   319           jt->is_exiting() ||

   320           jt->is_hidden_from_external_view())  {

   321         // add a NULL snapshot if skipped

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

   323         continue;

   324       }

   325       ThreadConcurrentLocks* tcl = NULL;

   326       if (_with_locked_synchronizers) {

   327         tcl = concurrent_locks.thread_concurrent_locks(jt);

   328       }

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

   330       _result->add_thread_snapshot(ts);

   331     }

   332   }

   333 }

   334 

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

   336   ThreadSnapshot* snapshot = new ThreadSnapshot(java_thread);

   337   snapshot->dump_stack_at_safepoint(_max_depth, _with_locked_monitors);

   338   snapshot->set_concurrent_locks(tcl);

   339   return snapshot;

   340 }

   341 

   342 volatile bool VM_Exit::_vm_exited = false;

   343 Thread * VM_Exit::_shutdown_thread = NULL;

   344 

   345 int VM_Exit::set_vm_exited() {

   346   Thread * thr_cur = ThreadLocalStorage::get_thread_slow();

   347 

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

   349 

   350   int num_active = 0;

   351 

   352   _shutdown_thread = thr_cur;

   353   _vm_exited = true;                                // global flag

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

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

   356       ++num_active;

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

   358     }

   359 

   360   return num_active;

   361 }

   362 

   363 int VM_Exit::wait_for_threads_in_native_to_block() {

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

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

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

   367 

   368   Thread * thr_cur = ThreadLocalStorage::get_thread_slow();

   369   Monitor timer(Mutex::leaf, "VM_Exit timer", true);

   370 

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

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

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

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

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

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

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

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

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

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

   381 

   382   int max_wait = max_wait_compiler_thread;

   383 

   384   int attempts = 0;

   385   while (true) {

   386     int num_active = 0;

   387     int num_active_compiler_thread = 0;

   388 

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

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

   391         num_active++;

   392         if (thr->is_Compiler_thread()) {

   393           num_active_compiler_thread++;

   394         }

   395       }

   396     }

   397 

   398     if (num_active == 0) {

   399        return 0;

   400     } else if (attempts > max_wait) {

   401        return num_active;

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

   403        return num_active;

   404     }

   405 

   406     attempts++;

   407 

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

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

   410   }

   411 }

   412 

   413 void VM_Exit::doit() {

   414   CompileBroker::set_should_block();

   415 

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

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

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

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

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

   421   wait_for_threads_in_native_to_block();

   422 

   423   set_vm_exited();

   424 

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

   426   // cleans up outputStream resources and PerfMemory resources.

   427   exit_globals();

   428 

   429   // Check for exit hook

   430   exit_hook_t exit_hook = Arguments::exit_hook();

   431   if (exit_hook != NULL) {

   432     // exit hook should exit.

   433     exit_hook(_exit_code);

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

   435     vm_direct_exit(_exit_code);

   436   } else {

   437     vm_direct_exit(_exit_code);

   438   }

   439 }

   440 

   441 

   442 void VM_Exit::wait_if_vm_exited() {

   443   if (_vm_exited &&

   444       ThreadLocalStorage::get_thread_slow() != _shutdown_thread) {

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

   446     // we will block here until the process dies

   447     Threads_lock->lock_without_safepoint_check();

   448     ShouldNotReachHere();

   449   }

   450 }