1 /*
   2  * Copyright (c) 2003, 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/systemDictionary.hpp"
  27 #include "memory/allocation.hpp"
  28 #include "memory/heapInspection.hpp"
  29 #include "memory/oopFactory.hpp"
  30 #include "oops/instanceKlass.hpp"
  31 #include "oops/oop.inline.hpp"
  32 #include "runtime/atomic.inline.hpp"
  33 #include "runtime/handles.inline.hpp"
  34 #include "runtime/init.hpp"
  35 #include "runtime/thread.hpp"
  36 #include "runtime/vframe.hpp"
  37 #include "runtime/thread.inline.hpp"
  38 #include "runtime/vmThread.hpp"
  39 #include "runtime/vm_operations.hpp"
  40 #include "services/threadService.hpp"
  41 
  42 // TODO: we need to define a naming convention for perf counters
  43 // to distinguish counters for:
  44 //   - standard JSR174 use
  45 //   - Hotspot extension (public and committed)
  46 //   - Hotspot extension (private/internal and uncommitted)
  47 
  48 // Default is disabled.
  49 bool ThreadService::_thread_monitoring_contention_enabled = false;
  50 bool ThreadService::_thread_cpu_time_enabled = false;
  51 bool ThreadService::_thread_allocated_memory_enabled = false;
  52 
  53 PerfCounter*  ThreadService::_total_threads_count = NULL;
  54 PerfVariable* ThreadService::_live_threads_count = NULL;
  55 PerfVariable* ThreadService::_peak_threads_count = NULL;
  56 PerfVariable* ThreadService::_daemon_threads_count = NULL;
  57 volatile int ThreadService::_exiting_threads_count = 0;
  58 volatile int ThreadService::_exiting_daemon_threads_count = 0;
  59 
  60 ThreadDumpResult* ThreadService::_threaddump_list = NULL;
  61 
  62 static const int INITIAL_ARRAY_SIZE = 10;
  63 
  64 void ThreadService::init() {
  65   EXCEPTION_MARK;
  66 
  67   // These counters are for java.lang.management API support.
  68   // They are created even if -XX:-UsePerfData is set and in
  69   // that case, they will be allocated on C heap.
  70 
  71   _total_threads_count =
  72                 PerfDataManager::create_counter(JAVA_THREADS, "started",
  73                                                 PerfData::U_Events, CHECK);
  74 
  75   _live_threads_count =
  76                 PerfDataManager::create_variable(JAVA_THREADS, "live",
  77                                                  PerfData::U_None, CHECK);
  78 
  79   _peak_threads_count =
  80                 PerfDataManager::create_variable(JAVA_THREADS, "livePeak",
  81                                                  PerfData::U_None, CHECK);
  82 
  83   _daemon_threads_count =
  84                 PerfDataManager::create_variable(JAVA_THREADS, "daemon",
  85                                                  PerfData::U_None, CHECK);
  86 
  87   if (os::is_thread_cpu_time_supported()) {
  88     _thread_cpu_time_enabled = true;
  89   }
  90 
  91   _thread_allocated_memory_enabled = true; // Always on, so enable it
  92 }
  93 
  94 void ThreadService::reset_peak_thread_count() {
  95   // Acquire the lock to update the peak thread count
  96   // to synchronize with thread addition and removal.
  97   MutexLockerEx mu(Threads_lock);
  98   _peak_threads_count->set_value(get_live_thread_count());
  99 }
 100 
 101 void ThreadService::add_thread(JavaThread* thread, bool daemon) {
 102   // Do not count VM internal or JVMTI agent threads
 103   if (thread->is_hidden_from_external_view() ||
 104       thread->is_jvmti_agent_thread()) {
 105     return;
 106   }
 107 
 108   _total_threads_count->inc();
 109   _live_threads_count->inc();
 110 
 111   if (_live_threads_count->get_value() > _peak_threads_count->get_value()) {
 112     _peak_threads_count->set_value(_live_threads_count->get_value());
 113   }
 114 
 115   if (daemon) {
 116     _daemon_threads_count->inc();
 117   }
 118 }
 119 
 120 void ThreadService::remove_thread(JavaThread* thread, bool daemon) {
 121   Atomic::dec((jint*) &_exiting_threads_count);
 122 
 123   if (thread->is_hidden_from_external_view() ||
 124       thread->is_jvmti_agent_thread()) {
 125     return;
 126   }
 127 
 128   _live_threads_count->set_value(_live_threads_count->get_value() - 1);
 129 
 130   if (daemon) {
 131     _daemon_threads_count->set_value(_daemon_threads_count->get_value() - 1);
 132     Atomic::dec((jint*) &_exiting_daemon_threads_count);
 133   }
 134 }
 135 
 136 void ThreadService::current_thread_exiting(JavaThread* jt) {
 137   assert(jt == JavaThread::current(), "Called by current thread");
 138   Atomic::inc((jint*) &_exiting_threads_count);
 139 
 140   oop threadObj = jt->threadObj();
 141   if (threadObj != NULL && java_lang_Thread::is_daemon(threadObj)) {
 142     Atomic::inc((jint*) &_exiting_daemon_threads_count);
 143   }
 144 }
 145 
 146 // FIXME: JVMTI should call this function
 147 Handle ThreadService::get_current_contended_monitor(JavaThread* thread) {
 148   assert(thread != NULL, "should be non-NULL");
 149   assert(Threads_lock->owned_by_self(), "must grab Threads_lock or be at safepoint");
 150 
 151   ObjectMonitor *wait_obj = thread->current_waiting_monitor();
 152 
 153   oop obj = NULL;
 154   if (wait_obj != NULL) {
 155     // thread is doing an Object.wait() call
 156     obj = (oop) wait_obj->object();
 157     assert(obj != NULL, "Object.wait() should have an object");
 158   } else {
 159     ObjectMonitor *enter_obj = thread->current_pending_monitor();
 160     if (enter_obj != NULL) {
 161       // thread is trying to enter() or raw_enter() an ObjectMonitor.
 162       obj = (oop) enter_obj->object();
 163     }
 164     // If obj == NULL, then ObjectMonitor is raw which doesn't count.
 165   }
 166 
 167   Handle h(obj);
 168   return h;
 169 }
 170 
 171 bool ThreadService::set_thread_monitoring_contention(bool flag) {
 172   MutexLocker m(Management_lock);
 173 
 174   bool prev = _thread_monitoring_contention_enabled;
 175   _thread_monitoring_contention_enabled = flag;
 176 
 177   return prev;
 178 }
 179 
 180 bool ThreadService::set_thread_cpu_time_enabled(bool flag) {
 181   MutexLocker m(Management_lock);
 182 
 183   bool prev = _thread_cpu_time_enabled;
 184   _thread_cpu_time_enabled = flag;
 185 
 186   return prev;
 187 }
 188 
 189 bool ThreadService::set_thread_allocated_memory_enabled(bool flag) {
 190   MutexLocker m(Management_lock);
 191 
 192   bool prev = _thread_allocated_memory_enabled;
 193   _thread_allocated_memory_enabled = flag;
 194 
 195   return prev;
 196 }
 197 
 198 // GC support
 199 void ThreadService::oops_do(OopClosure* f) {
 200   for (ThreadDumpResult* dump = _threaddump_list; dump != NULL; dump = dump->next()) {
 201     dump->oops_do(f);
 202   }
 203 }
 204 
 205 void ThreadService::metadata_do(void f(Metadata*)) {
 206   for (ThreadDumpResult* dump = _threaddump_list; dump != NULL; dump = dump->next()) {
 207     dump->metadata_do(f);
 208   }
 209 }
 210 
 211 void ThreadService::add_thread_dump(ThreadDumpResult* dump) {
 212   MutexLocker ml(Management_lock);
 213   if (_threaddump_list == NULL) {
 214     _threaddump_list = dump;
 215   } else {
 216     dump->set_next(_threaddump_list);
 217     _threaddump_list = dump;
 218   }
 219 }
 220 
 221 void ThreadService::remove_thread_dump(ThreadDumpResult* dump) {
 222   MutexLocker ml(Management_lock);
 223 
 224   ThreadDumpResult* prev = NULL;
 225   bool found = false;
 226   for (ThreadDumpResult* d = _threaddump_list; d != NULL; prev = d, d = d->next()) {
 227     if (d == dump) {
 228       if (prev == NULL) {
 229         _threaddump_list = dump->next();
 230       } else {
 231         prev->set_next(dump->next());
 232       }
 233       found = true;
 234       break;
 235     }
 236   }
 237   assert(found, "The threaddump result to be removed must exist.");
 238 }
 239 
 240 // Dump stack trace of threads specified in the given threads array.
 241 // Returns StackTraceElement[][] each element is the stack trace of a thread in
 242 // the corresponding entry in the given threads array
 243 Handle ThreadService::dump_stack_traces(GrowableArray<instanceHandle>* threads,
 244                                         int num_threads,
 245                                         TRAPS) {
 246   assert(num_threads > 0, "just checking");
 247 
 248   ThreadDumpResult dump_result;
 249   VM_ThreadDump op(&dump_result,
 250                    threads,
 251                    num_threads,
 252                    -1,    /* entire stack */
 253                    false, /* with locked monitors */
 254                    false  /* with locked synchronizers */);
 255   VMThread::execute(&op);
 256 
 257   // Allocate the resulting StackTraceElement[][] object
 258 
 259   ResourceMark rm(THREAD);
 260   Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_StackTraceElement_array(), true, CHECK_NH);
 261   ObjArrayKlass* ik = ObjArrayKlass::cast(k);
 262   objArrayOop r = oopFactory::new_objArray(ik, num_threads, CHECK_NH);
 263   objArrayHandle result_obj(THREAD, r);
 264 
 265   int num_snapshots = dump_result.num_snapshots();
 266   assert(num_snapshots == num_threads, "Must have num_threads thread snapshots");
 267   int i = 0;
 268   for (ThreadSnapshot* ts = dump_result.snapshots(); ts != NULL; i++, ts = ts->next()) {
 269     ThreadStackTrace* stacktrace = ts->get_stack_trace();
 270     if (stacktrace == NULL) {
 271       // No stack trace
 272       result_obj->obj_at_put(i, NULL);
 273     } else {
 274       // Construct an array of java/lang/StackTraceElement object
 275       Handle backtrace_h = stacktrace->allocate_fill_stack_trace_element_array(CHECK_NH);
 276       result_obj->obj_at_put(i, backtrace_h());
 277     }
 278   }
 279 
 280   return result_obj;
 281 }
 282 
 283 void ThreadService::reset_contention_count_stat(JavaThread* thread) {
 284   ThreadStatistics* stat = thread->get_thread_stat();
 285   if (stat != NULL) {
 286     stat->reset_count_stat();
 287   }
 288 }
 289 
 290 void ThreadService::reset_contention_time_stat(JavaThread* thread) {
 291   ThreadStatistics* stat = thread->get_thread_stat();
 292   if (stat != NULL) {
 293     stat->reset_time_stat();
 294   }
 295 }
 296 
 297 // Find deadlocks involving object monitors and concurrent locks if concurrent_locks is true
 298 DeadlockCycle* ThreadService::find_deadlocks_at_safepoint(bool concurrent_locks) {
 299   // This code was modified from the original Threads::find_deadlocks code.
 300   int globalDfn = 0, thisDfn;
 301   ObjectMonitor* waitingToLockMonitor = NULL;
 302   oop waitingToLockBlocker = NULL;
 303   bool blocked_on_monitor = false;
 304   JavaThread *currentThread, *previousThread;
 305   int num_deadlocks = 0;
 306 
 307   for (JavaThread* p = Threads::first(); p != NULL; p = p->next()) {
 308     // Initialize the depth-first-number
 309     p->set_depth_first_number(-1);
 310   }
 311 
 312   DeadlockCycle* deadlocks = NULL;
 313   DeadlockCycle* last = NULL;
 314   DeadlockCycle* cycle = new DeadlockCycle();
 315   for (JavaThread* jt = Threads::first(); jt != NULL; jt = jt->next()) {
 316     if (jt->depth_first_number() >= 0) {
 317       // this thread was already visited
 318       continue;
 319     }
 320 
 321     thisDfn = globalDfn;
 322     jt->set_depth_first_number(globalDfn++);
 323     previousThread = jt;
 324     currentThread = jt;
 325 
 326     cycle->reset();
 327 
 328     // When there is a deadlock, all the monitors involved in the dependency
 329     // cycle must be contended and heavyweight. So we only care about the
 330     // heavyweight monitor a thread is waiting to lock.
 331     waitingToLockMonitor = (ObjectMonitor*)jt->current_pending_monitor();
 332     if (concurrent_locks) {
 333       waitingToLockBlocker = jt->current_park_blocker();
 334     }
 335     while (waitingToLockMonitor != NULL || waitingToLockBlocker != NULL) {
 336       cycle->add_thread(currentThread);
 337       if (waitingToLockMonitor != NULL) {
 338         address currentOwner = (address)waitingToLockMonitor->owner();
 339         if (currentOwner != NULL) {
 340           currentThread = Threads::owning_thread_from_monitor_owner(
 341                             currentOwner,
 342                             false /* no locking needed */);
 343           if (currentThread == NULL) {
 344             // This function is called at a safepoint so the JavaThread
 345             // that owns waitingToLockMonitor should be findable, but
 346             // if it is not findable, then the previous currentThread is
 347             // blocked permanently. We record this as a deadlock.
 348             num_deadlocks++;
 349 
 350             cycle->set_deadlock(true);
 351 
 352             // add this cycle to the deadlocks list
 353             if (deadlocks == NULL) {
 354               deadlocks = cycle;
 355             } else {
 356               last->set_next(cycle);
 357             }
 358             last = cycle;
 359             cycle = new DeadlockCycle();
 360             break;
 361           }
 362         }
 363       } else {
 364         if (concurrent_locks) {
 365           if (waitingToLockBlocker->is_a(SystemDictionary::abstract_ownable_synchronizer_klass())) {
 366             oop threadObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker);
 367             currentThread = threadObj != NULL ? java_lang_Thread::thread(threadObj) : NULL;
 368           } else {
 369             currentThread = NULL;
 370           }
 371         }
 372       }
 373 
 374       if (currentThread == NULL) {
 375         // No dependency on another thread
 376         break;
 377       }
 378       if (currentThread->depth_first_number() < 0) {
 379         // First visit to this thread
 380         currentThread->set_depth_first_number(globalDfn++);
 381       } else if (currentThread->depth_first_number() < thisDfn) {
 382         // Thread already visited, and not on a (new) cycle
 383         break;
 384       } else if (currentThread == previousThread) {
 385         // Self-loop, ignore
 386         break;
 387       } else {
 388         // We have a (new) cycle
 389         num_deadlocks++;
 390 
 391         cycle->set_deadlock(true);
 392 
 393         // add this cycle to the deadlocks list
 394         if (deadlocks == NULL) {
 395           deadlocks = cycle;
 396         } else {
 397           last->set_next(cycle);
 398         }
 399         last = cycle;
 400         cycle = new DeadlockCycle();
 401         break;
 402       }
 403       previousThread = currentThread;
 404       waitingToLockMonitor = (ObjectMonitor*)currentThread->current_pending_monitor();
 405       if (concurrent_locks) {
 406         waitingToLockBlocker = currentThread->current_park_blocker();
 407       }
 408     }
 409 
 410   }
 411   delete cycle;
 412   return deadlocks;
 413 }
 414 
 415 ThreadDumpResult::ThreadDumpResult() : _num_threads(0), _num_snapshots(0), _snapshots(NULL), _next(NULL), _last(NULL) {
 416 
 417   // Create a new ThreadDumpResult object and append to the list.
 418   // If GC happens before this function returns, Method*
 419   // in the stack trace will be visited.
 420   ThreadService::add_thread_dump(this);
 421 }
 422 
 423 ThreadDumpResult::ThreadDumpResult(int num_threads) : _num_threads(num_threads), _num_snapshots(0), _snapshots(NULL), _next(NULL), _last(NULL) {
 424   // Create a new ThreadDumpResult object and append to the list.
 425   // If GC happens before this function returns, oops
 426   // will be visited.
 427   ThreadService::add_thread_dump(this);
 428 }
 429 
 430 ThreadDumpResult::~ThreadDumpResult() {
 431   ThreadService::remove_thread_dump(this);
 432 
 433   // free all the ThreadSnapshot objects created during
 434   // the VM_ThreadDump operation
 435   ThreadSnapshot* ts = _snapshots;
 436   while (ts != NULL) {
 437     ThreadSnapshot* p = ts;
 438     ts = ts->next();
 439     delete p;
 440   }
 441 }
 442 
 443 
 444 void ThreadDumpResult::add_thread_snapshot(ThreadSnapshot* ts) {
 445   assert(_num_threads == 0 || _num_snapshots < _num_threads,
 446          "_num_snapshots must be less than _num_threads");
 447   _num_snapshots++;
 448   if (_snapshots == NULL) {
 449     _snapshots = ts;
 450   } else {
 451     _last->set_next(ts);
 452   }
 453   _last = ts;
 454 }
 455 
 456 void ThreadDumpResult::oops_do(OopClosure* f) {
 457   for (ThreadSnapshot* ts = _snapshots; ts != NULL; ts = ts->next()) {
 458     ts->oops_do(f);
 459   }
 460 }
 461 
 462 void ThreadDumpResult::metadata_do(void f(Metadata*)) {
 463   for (ThreadSnapshot* ts = _snapshots; ts != NULL; ts = ts->next()) {
 464     ts->metadata_do(f);
 465   }
 466 }
 467 
 468 StackFrameInfo::StackFrameInfo(javaVFrame* jvf, bool with_lock_info) {
 469   _method = jvf->method();
 470   _bci = jvf->bci();
 471   _class_holder = _method->method_holder()->klass_holder();
 472   _locked_monitors = NULL;
 473   if (with_lock_info) {
 474     ResourceMark rm;
 475     GrowableArray<MonitorInfo*>* list = jvf->locked_monitors();
 476     int length = list->length();
 477     if (length > 0) {
 478       _locked_monitors = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<oop>(length, true);
 479       for (int i = 0; i < length; i++) {
 480         MonitorInfo* monitor = list->at(i);
 481         assert(monitor->owner(), "This monitor must have an owning object");
 482         _locked_monitors->append(monitor->owner());
 483       }
 484     }
 485   }
 486 }
 487 
 488 void StackFrameInfo::oops_do(OopClosure* f) {
 489   if (_locked_monitors != NULL) {
 490     int length = _locked_monitors->length();
 491     for (int i = 0; i < length; i++) {
 492       f->do_oop((oop*) _locked_monitors->adr_at(i));
 493     }
 494   }
 495   f->do_oop(&_class_holder);
 496 }
 497 
 498 void StackFrameInfo::metadata_do(void f(Metadata*)) {
 499   f(_method);
 500 }
 501 
 502 void StackFrameInfo::print_on(outputStream* st) const {
 503   ResourceMark rm;
 504   java_lang_Throwable::print_stack_element(st, method(), bci());
 505   int len = (_locked_monitors != NULL ? _locked_monitors->length() : 0);
 506   for (int i = 0; i < len; i++) {
 507     oop o = _locked_monitors->at(i);
 508     st->print_cr("\t- locked <" INTPTR_FORMAT "> (a %s)", p2i(o), o->klass()->external_name());
 509   }
 510 
 511 }
 512 
 513 // Iterate through monitor cache to find JNI locked monitors
 514 class InflatedMonitorsClosure: public MonitorClosure {
 515 private:
 516   ThreadStackTrace* _stack_trace;
 517   Thread* _thread;
 518 public:
 519   InflatedMonitorsClosure(Thread* t, ThreadStackTrace* st) {
 520     _thread = t;
 521     _stack_trace = st;
 522   }
 523   void do_monitor(ObjectMonitor* mid) {
 524     if (mid->owner() == _thread) {
 525       oop object = (oop) mid->object();
 526       if (!_stack_trace->is_owned_monitor_on_stack(object)) {
 527         _stack_trace->add_jni_locked_monitor(object);
 528       }
 529     }
 530   }
 531 };
 532 
 533 ThreadStackTrace::ThreadStackTrace(JavaThread* t, bool with_locked_monitors) {
 534   _thread = t;
 535   _frames = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<StackFrameInfo*>(INITIAL_ARRAY_SIZE, true);
 536   _depth = 0;
 537   _with_locked_monitors = with_locked_monitors;
 538   if (_with_locked_monitors) {
 539     _jni_locked_monitors = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<oop>(INITIAL_ARRAY_SIZE, true);
 540   } else {
 541     _jni_locked_monitors = NULL;
 542   }
 543 }
 544 
 545 ThreadStackTrace::~ThreadStackTrace() {
 546   for (int i = 0; i < _frames->length(); i++) {
 547     delete _frames->at(i);
 548   }
 549   delete _frames;
 550   if (_jni_locked_monitors != NULL) {
 551     delete _jni_locked_monitors;
 552   }
 553 }
 554 
 555 void ThreadStackTrace::dump_stack_at_safepoint(int maxDepth) {
 556   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
 557 
 558   if (_thread->has_last_Java_frame()) {
 559     RegisterMap reg_map(_thread);
 560     vframe* start_vf = _thread->last_java_vframe(&reg_map);
 561     int count = 0;
 562     for (vframe* f = start_vf; f; f = f->sender() ) {
 563       if (f->is_java_frame()) {
 564         javaVFrame* jvf = javaVFrame::cast(f);
 565         add_stack_frame(jvf);
 566         count++;
 567       } else {
 568         // Ignore non-Java frames
 569       }
 570       if (maxDepth > 0 && count == maxDepth) {
 571         // Skip frames if more than maxDepth
 572         break;
 573       }
 574     }
 575   }
 576 
 577   if (_with_locked_monitors) {
 578     // Iterate inflated monitors and find monitors locked by this thread
 579     // not found in the stack
 580     InflatedMonitorsClosure imc(_thread, this);
 581     ObjectSynchronizer::monitors_iterate(&imc);
 582   }
 583 }
 584 
 585 
 586 bool ThreadStackTrace::is_owned_monitor_on_stack(oop object) {
 587   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
 588 
 589   bool found = false;
 590   int num_frames = get_stack_depth();
 591   for (int depth = 0; depth < num_frames; depth++) {
 592     StackFrameInfo* frame = stack_frame_at(depth);
 593     int len = frame->num_locked_monitors();
 594     GrowableArray<oop>* locked_monitors = frame->locked_monitors();
 595     for (int j = 0; j < len; j++) {
 596       oop monitor = locked_monitors->at(j);
 597       assert(monitor != NULL, "must be a Java object");
 598       if (monitor == object) {
 599         found = true;
 600         break;
 601       }
 602     }
 603   }
 604   return found;
 605 }
 606 
 607 Handle ThreadStackTrace::allocate_fill_stack_trace_element_array(TRAPS) {
 608   Klass* k = SystemDictionary::StackTraceElement_klass();
 609   assert(k != NULL, "must be loaded in 1.4+");
 610   instanceKlassHandle ik(THREAD, k);
 611 
 612   // Allocate an array of java/lang/StackTraceElement object
 613   objArrayOop ste = oopFactory::new_objArray(ik(), _depth, CHECK_NH);
 614   objArrayHandle backtrace(THREAD, ste);
 615   for (int j = 0; j < _depth; j++) {
 616     StackFrameInfo* frame = _frames->at(j);
 617     methodHandle mh(THREAD, frame->method());
 618     oop element = java_lang_StackTraceElement::create(mh, frame->bci(), CHECK_NH);
 619     backtrace->obj_at_put(j, element);
 620   }
 621   return backtrace;
 622 }
 623 
 624 void ThreadStackTrace::add_stack_frame(javaVFrame* jvf) {
 625   StackFrameInfo* frame = new StackFrameInfo(jvf, _with_locked_monitors);
 626   _frames->append(frame);
 627   _depth++;
 628 }
 629 
 630 void ThreadStackTrace::oops_do(OopClosure* f) {
 631   int length = _frames->length();
 632   for (int i = 0; i < length; i++) {
 633     _frames->at(i)->oops_do(f);
 634   }
 635 
 636   length = (_jni_locked_monitors != NULL ? _jni_locked_monitors->length() : 0);
 637   for (int j = 0; j < length; j++) {
 638     f->do_oop((oop*) _jni_locked_monitors->adr_at(j));
 639   }
 640 }
 641 
 642 void ThreadStackTrace::metadata_do(void f(Metadata*)) {
 643   int length = _frames->length();
 644   for (int i = 0; i < length; i++) {
 645     _frames->at(i)->metadata_do(f);
 646   }
 647 }
 648 
 649 
 650 ConcurrentLocksDump::~ConcurrentLocksDump() {
 651   if (_retain_map_on_free) {
 652     return;
 653   }
 654 
 655   for (ThreadConcurrentLocks* t = _map; t != NULL;)  {
 656     ThreadConcurrentLocks* tcl = t;
 657     t = t->next();
 658     delete tcl;
 659   }
 660 }
 661 
 662 void ConcurrentLocksDump::dump_at_safepoint() {
 663   // dump all locked concurrent locks
 664   assert(SafepointSynchronize::is_at_safepoint(), "all threads are stopped");
 665 
 666   ResourceMark rm;
 667 
 668   GrowableArray<oop>* aos_objects = new GrowableArray<oop>(INITIAL_ARRAY_SIZE);
 669 
 670   // Find all instances of AbstractOwnableSynchronizer
 671   HeapInspection::find_instances_at_safepoint(SystemDictionary::abstract_ownable_synchronizer_klass(),
 672                                                 aos_objects);
 673   // Build a map of thread to its owned AQS locks
 674   build_map(aos_objects);
 675 }
 676 
 677 
 678 // build a map of JavaThread to all its owned AbstractOwnableSynchronizer
 679 void ConcurrentLocksDump::build_map(GrowableArray<oop>* aos_objects) {
 680   int length = aos_objects->length();
 681   for (int i = 0; i < length; i++) {
 682     oop o = aos_objects->at(i);
 683     oop owner_thread_obj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(o);
 684     if (owner_thread_obj != NULL) {
 685       JavaThread* thread = java_lang_Thread::thread(owner_thread_obj);
 686       assert(o->is_instance(), "Must be an instanceOop");
 687       add_lock(thread, (instanceOop) o);
 688     }
 689   }
 690 }
 691 
 692 void ConcurrentLocksDump::add_lock(JavaThread* thread, instanceOop o) {
 693   ThreadConcurrentLocks* tcl = thread_concurrent_locks(thread);
 694   if (tcl != NULL) {
 695     tcl->add_lock(o);
 696     return;
 697   }
 698 
 699   // First owned lock found for this thread
 700   tcl = new ThreadConcurrentLocks(thread);
 701   tcl->add_lock(o);
 702   if (_map == NULL) {
 703     _map = tcl;
 704   } else {
 705     _last->set_next(tcl);
 706   }
 707   _last = tcl;
 708 }
 709 
 710 ThreadConcurrentLocks* ConcurrentLocksDump::thread_concurrent_locks(JavaThread* thread) {
 711   for (ThreadConcurrentLocks* tcl = _map; tcl != NULL; tcl = tcl->next()) {
 712     if (tcl->java_thread() == thread) {
 713       return tcl;
 714     }
 715   }
 716   return NULL;
 717 }
 718 
 719 void ConcurrentLocksDump::print_locks_on(JavaThread* t, outputStream* st) {
 720   st->print_cr("   Locked ownable synchronizers:");
 721   ThreadConcurrentLocks* tcl = thread_concurrent_locks(t);
 722   GrowableArray<instanceOop>* locks = (tcl != NULL ? tcl->owned_locks() : NULL);
 723   if (locks == NULL || locks->is_empty()) {
 724     st->print_cr("\t- None");
 725     st->cr();
 726     return;
 727   }
 728 
 729   for (int i = 0; i < locks->length(); i++) {
 730     instanceOop obj = locks->at(i);
 731     st->print_cr("\t- <" INTPTR_FORMAT "> (a %s)", p2i(obj), obj->klass()->external_name());
 732   }
 733   st->cr();
 734 }
 735 
 736 ThreadConcurrentLocks::ThreadConcurrentLocks(JavaThread* thread) {
 737   _thread = thread;
 738   _owned_locks = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<instanceOop>(INITIAL_ARRAY_SIZE, true);
 739   _next = NULL;
 740 }
 741 
 742 ThreadConcurrentLocks::~ThreadConcurrentLocks() {
 743   delete _owned_locks;
 744 }
 745 
 746 void ThreadConcurrentLocks::add_lock(instanceOop o) {
 747   _owned_locks->append(o);
 748 }
 749 
 750 void ThreadConcurrentLocks::oops_do(OopClosure* f) {
 751   int length = _owned_locks->length();
 752   for (int i = 0; i < length; i++) {
 753     f->do_oop((oop*) _owned_locks->adr_at(i));
 754   }
 755 }
 756 
 757 ThreadStatistics::ThreadStatistics() {
 758   _contended_enter_count = 0;
 759   _monitor_wait_count = 0;
 760   _sleep_count = 0;
 761   _count_pending_reset = false;
 762   _timer_pending_reset = false;
 763   memset((void*) _perf_recursion_counts, 0, sizeof(_perf_recursion_counts));
 764 }
 765 
 766 ThreadSnapshot::ThreadSnapshot(JavaThread* thread) {
 767   _thread = thread;
 768   _threadObj = thread->threadObj();
 769   _stack_trace = NULL;
 770   _concurrent_locks = NULL;
 771   _next = NULL;
 772 
 773   ThreadStatistics* stat = thread->get_thread_stat();
 774   _contended_enter_ticks = stat->contended_enter_ticks();
 775   _contended_enter_count = stat->contended_enter_count();
 776   _monitor_wait_ticks = stat->monitor_wait_ticks();
 777   _monitor_wait_count = stat->monitor_wait_count();
 778   _sleep_ticks = stat->sleep_ticks();
 779   _sleep_count = stat->sleep_count();
 780 
 781   _blocker_object = NULL;
 782   _blocker_object_owner = NULL;
 783 
 784   _thread_status = java_lang_Thread::get_thread_status(_threadObj);
 785   _is_ext_suspended = thread->is_being_ext_suspended();
 786   _is_in_native = (thread->thread_state() == _thread_in_native);
 787 
 788   if (_thread_status == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER ||
 789       _thread_status == java_lang_Thread::IN_OBJECT_WAIT ||
 790       _thread_status == java_lang_Thread::IN_OBJECT_WAIT_TIMED) {
 791 
 792     Handle obj = ThreadService::get_current_contended_monitor(thread);
 793     if (obj() == NULL) {
 794       // monitor no longer exists; thread is not blocked
 795       _thread_status = java_lang_Thread::RUNNABLE;
 796     } else {
 797       _blocker_object = obj();
 798       JavaThread* owner = ObjectSynchronizer::get_lock_owner(obj, false);
 799       if ((owner == NULL && _thread_status == java_lang_Thread::BLOCKED_ON_MONITOR_ENTER)
 800           || (owner != NULL && owner->is_attaching_via_jni())) {
 801         // ownership information of the monitor is not available
 802         // (may no longer be owned or releasing to some other thread)
 803         // make this thread in RUNNABLE state.
 804         // And when the owner thread is in attaching state, the java thread
 805         // is not completely initialized. For example thread name and id
 806         // and may not be set, so hide the attaching thread.
 807         _thread_status = java_lang_Thread::RUNNABLE;
 808         _blocker_object = NULL;
 809       } else if (owner != NULL) {
 810         _blocker_object_owner = owner->threadObj();
 811       }
 812     }
 813   }
 814 
 815   // Support for JSR-166 locks
 816   if (JDK_Version::current().supports_thread_park_blocker() &&
 817         (_thread_status == java_lang_Thread::PARKED ||
 818          _thread_status == java_lang_Thread::PARKED_TIMED)) {
 819 
 820     _blocker_object = thread->current_park_blocker();
 821     if (_blocker_object != NULL && _blocker_object->is_a(SystemDictionary::abstract_ownable_synchronizer_klass())) {
 822       _blocker_object_owner = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(_blocker_object);
 823     }
 824   }
 825 }
 826 
 827 ThreadSnapshot::~ThreadSnapshot() {
 828   delete _stack_trace;
 829   delete _concurrent_locks;
 830 }
 831 
 832 void ThreadSnapshot::dump_stack_at_safepoint(int max_depth, bool with_locked_monitors) {
 833   _stack_trace = new ThreadStackTrace(_thread, with_locked_monitors);
 834   _stack_trace->dump_stack_at_safepoint(max_depth);
 835 }
 836 
 837 
 838 void ThreadSnapshot::oops_do(OopClosure* f) {
 839   f->do_oop(&_threadObj);
 840   f->do_oop(&_blocker_object);
 841   f->do_oop(&_blocker_object_owner);
 842   if (_stack_trace != NULL) {
 843     _stack_trace->oops_do(f);
 844   }
 845   if (_concurrent_locks != NULL) {
 846     _concurrent_locks->oops_do(f);
 847   }
 848 }
 849 
 850 void ThreadSnapshot::metadata_do(void f(Metadata*)) {
 851   if (_stack_trace != NULL) {
 852     _stack_trace->metadata_do(f);
 853   }
 854 }
 855 
 856 
 857 DeadlockCycle::DeadlockCycle() {
 858   _is_deadlock = false;
 859   _threads = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JavaThread*>(INITIAL_ARRAY_SIZE, true);
 860   _next = NULL;
 861 }
 862 
 863 DeadlockCycle::~DeadlockCycle() {
 864   delete _threads;
 865 }
 866 
 867 void DeadlockCycle::print_on(outputStream* st) const {
 868   st->cr();
 869   st->print_cr("Found one Java-level deadlock:");
 870   st->print("=============================");
 871 
 872   JavaThread* currentThread;
 873   ObjectMonitor* waitingToLockMonitor;
 874   oop waitingToLockBlocker;
 875   int len = _threads->length();
 876   for (int i = 0; i < len; i++) {
 877     currentThread = _threads->at(i);
 878     waitingToLockMonitor = (ObjectMonitor*)currentThread->current_pending_monitor();
 879     waitingToLockBlocker = currentThread->current_park_blocker();
 880     st->cr();
 881     st->print_cr("\"%s\":", currentThread->get_thread_name());
 882     const char* owner_desc = ",\n  which is held by";
 883     if (waitingToLockMonitor != NULL) {
 884       st->print("  waiting to lock monitor " INTPTR_FORMAT, p2i(waitingToLockMonitor));
 885       oop obj = (oop)waitingToLockMonitor->object();
 886       if (obj != NULL) {
 887         st->print(" (object " INTPTR_FORMAT ", a %s)", p2i(obj),
 888                    obj->klass()->external_name());
 889 
 890         if (!currentThread->current_pending_monitor_is_from_java()) {
 891           owner_desc = "\n  in JNI, which is held by";
 892         }
 893       } else {
 894         // No Java object associated - a JVMTI raw monitor
 895         owner_desc = " (JVMTI raw monitor),\n  which is held by";
 896       }
 897       currentThread = Threads::owning_thread_from_monitor_owner(
 898                         (address)waitingToLockMonitor->owner(),
 899                         false /* no locking needed */);
 900       if (currentThread == NULL) {
 901         // The deadlock was detected at a safepoint so the JavaThread
 902         // that owns waitingToLockMonitor should be findable, but
 903         // if it is not findable, then the previous currentThread is
 904         // blocked permanently.
 905         st->print("%s UNKNOWN_owner_addr=" PTR_FORMAT, owner_desc,
 906                   p2i(waitingToLockMonitor->owner()));
 907         continue;
 908       }
 909     } else {
 910       st->print("  waiting for ownable synchronizer " INTPTR_FORMAT ", (a %s)",
 911                 p2i(waitingToLockBlocker),
 912                 waitingToLockBlocker->klass()->external_name());
 913       assert(waitingToLockBlocker->is_a(SystemDictionary::abstract_ownable_synchronizer_klass()),
 914              "Must be an AbstractOwnableSynchronizer");
 915       oop ownerObj = java_util_concurrent_locks_AbstractOwnableSynchronizer::get_owner_threadObj(waitingToLockBlocker);
 916       currentThread = java_lang_Thread::thread(ownerObj);
 917     }
 918     st->print("%s \"%s\"", owner_desc, currentThread->get_thread_name());
 919   }
 920 
 921   st->cr();
 922   st->cr();
 923 
 924   // Print stack traces
 925   bool oldJavaMonitorsInStackTrace = JavaMonitorsInStackTrace;
 926   JavaMonitorsInStackTrace = true;
 927   st->print_cr("Java stack information for the threads listed above:");
 928   st->print_cr("===================================================");
 929   for (int j = 0; j < len; j++) {
 930     currentThread = _threads->at(j);
 931     st->print_cr("\"%s\":", currentThread->get_thread_name());
 932     currentThread->print_stack_on(st);
 933   }
 934   JavaMonitorsInStackTrace = oldJavaMonitorsInStackTrace;
 935 }
 936 
 937 ThreadsListEnumerator::ThreadsListEnumerator(Thread* cur_thread,
 938                                              bool include_jvmti_agent_threads,
 939                                              bool include_jni_attaching_threads) {
 940   assert(cur_thread == Thread::current(), "Check current thread");
 941 
 942   int init_size = ThreadService::get_live_thread_count();
 943   _threads_array = new GrowableArray<instanceHandle>(init_size);
 944 
 945   MutexLockerEx ml(Threads_lock);
 946 
 947   for (JavaThread* jt = Threads::first(); jt != NULL; jt = jt->next()) {
 948     // skips JavaThreads in the process of exiting
 949     // and also skips VM internal JavaThreads
 950     // Threads in _thread_new or _thread_new_trans state are included.
 951     // i.e. threads have been started but not yet running.
 952     if (jt->threadObj() == NULL   ||
 953         jt->is_exiting() ||
 954         !java_lang_Thread::is_alive(jt->threadObj())   ||
 955         jt->is_hidden_from_external_view()) {
 956       continue;
 957     }
 958 
 959     // skip agent threads
 960     if (!include_jvmti_agent_threads && jt->is_jvmti_agent_thread()) {
 961       continue;
 962     }
 963 
 964     // skip jni threads in the process of attaching
 965     if (!include_jni_attaching_threads && jt->is_attaching_via_jni()) {
 966       continue;
 967     }
 968 
 969     instanceHandle h(cur_thread, (instanceOop) jt->threadObj());
 970     _threads_array->append(h);
 971   }
 972 }