1105 continue;
1106 }
1107
1108 // skip jni threads in the process of attaching
1109 if (!include_jni_attaching_threads && jt->is_attaching_via_jni()) {
1110 continue;
1111 }
1112
1113 // skip instances of BoundVirtualThread
1114 if (!include_bound_virtual_threads && jt->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) {
1115 continue;
1116 }
1117
1118 instanceHandle h(cur_thread, (instanceOop) jt->threadObj());
1119 _threads_array->append(h);
1120 }
1121 }
1122
1123
1124 // jdk.internal.vm.ThreadSnapshot support
1125 #if INCLUDE_JVMTI
1126
1127 class GetThreadSnapshotHandshakeClosure: public HandshakeClosure {
1128 private:
1129 static OopStorage* oop_storage() {
1130 assert(_thread_service_storage != nullptr, "sanity");
1131 return _thread_service_storage;
1132 }
1133
1134 public:
1135 struct OwnedLock {
1136 // should be synced with ordinals of jdk.internal.vm.ThreadSnapshot.OwnedLockType enum
1137 enum Type {
1138 NOTHING = -1,
1139 LOCKED = 0,
1140 ELIMINATED = 1,
1141 };
1142
1143 int _frame_depth;
1144 Type _type;
1145 // synchronization object (when type == LOCKED) or its klass (type == ELIMINATED)
1459
1460 JavaThread* java_thread = nullptr;
1461 oop thread_oop;
1462 bool has_javathread = tlh.cv_internal_thread_to_JavaThread(jthread, &java_thread, &thread_oop);
1463 assert((has_javathread && thread_oop != nullptr) || !has_javathread, "Missing Thread oop");
1464 bool is_virtual = java_lang_VirtualThread::is_instance(thread_oop); // Deals with null
1465
1466 if (!has_javathread && !is_virtual) {
1467 return nullptr; // thread terminated so not of interest
1468 }
1469
1470 // Handshake with target
1471 Handle thread_h(THREAD, thread_oop);
1472 GetThreadSnapshotHandshakeClosure cl(thread_h);
1473 if (java_lang_VirtualThread::is_instance(thread_oop)) {
1474 Handshake::execute(&cl, thread_oop);
1475 } else {
1476 Handshake::execute(&cl, &tlh, java_thread);
1477 }
1478
1479 // StackTrace
1480 InstanceKlass* ste_klass = vmClasses::StackTraceElement_klass();
1481 assert(ste_klass != nullptr, "must be loaded");
1482
1483 objArrayHandle trace = oopFactory::new_objArray_handle(ste_klass, cl._frame_count, CHECK_NULL);
1484
1485 for (int i = 0; i < cl._frame_count; i++) {
1486 methodHandle method(THREAD, cl._methods->at(i));
1487 oop element = java_lang_StackTraceElement::create(method, cl._bcis->at(i), CHECK_NULL);
1488 trace->obj_at_put(i, element);
1489 }
1490
1491 // Locks
1492 Symbol* lock_sym = vmSymbols::jdk_internal_vm_ThreadLock();
1493 Klass* lock_k = SystemDictionary::resolve_or_fail(lock_sym, true, CHECK_NULL);
1494 InstanceKlass* lock_klass = InstanceKlass::cast(lock_k);
1495
1496 objArrayHandle locks;
1497 if (cl._locks != nullptr && cl._locks->length() > 0) {
1498 locks = oopFactory::new_objArray_handle(lock_klass, cl._locks->length(), CHECK_NULL);
1517 // the method return the same trace array
1518
1519 Symbol* snapshot_klass_name = vmSymbols::jdk_internal_vm_ThreadSnapshot();
1520 Klass* snapshot_klass = SystemDictionary::resolve_or_fail(snapshot_klass_name, true, CHECK_NULL);
1521 if (snapshot_klass->should_be_initialized()) {
1522 snapshot_klass->initialize(CHECK_NULL);
1523 }
1524
1525 Handle snapshot = jdk_internal_vm_ThreadSnapshot::allocate(InstanceKlass::cast(snapshot_klass), CHECK_NULL);
1526 jdk_internal_vm_ThreadSnapshot::set_name(snapshot(), cl._thread_name.resolve());
1527 jdk_internal_vm_ThreadSnapshot::set_thread_status(snapshot(), (int)cl._thread_status);
1528 jdk_internal_vm_ThreadSnapshot::set_carrier_thread(snapshot(), cl._carrier_thread.resolve());
1529 jdk_internal_vm_ThreadSnapshot::set_stack_trace(snapshot(), trace());
1530 jdk_internal_vm_ThreadSnapshot::set_locks(snapshot(), locks());
1531 if (!cl._blocker.is_empty()) {
1532 jdk_internal_vm_ThreadSnapshot::set_blocker(snapshot(),
1533 cl._blocker._type, cl._blocker._obj.resolve(), cl._blocker._owner.resolve());
1534 }
1535 return snapshot();
1536 }
1537
1538 #endif // INCLUDE_JVMTI
|
1105 continue;
1106 }
1107
1108 // skip jni threads in the process of attaching
1109 if (!include_jni_attaching_threads && jt->is_attaching_via_jni()) {
1110 continue;
1111 }
1112
1113 // skip instances of BoundVirtualThread
1114 if (!include_bound_virtual_threads && jt->threadObj()->is_a(vmClasses::BoundVirtualThread_klass())) {
1115 continue;
1116 }
1117
1118 instanceHandle h(cur_thread, (instanceOop) jt->threadObj());
1119 _threads_array->append(h);
1120 }
1121 }
1122
1123
1124 // jdk.internal.vm.ThreadSnapshot support
1125
1126 class GetThreadSnapshotHandshakeClosure: public HandshakeClosure {
1127 private:
1128 static OopStorage* oop_storage() {
1129 assert(_thread_service_storage != nullptr, "sanity");
1130 return _thread_service_storage;
1131 }
1132
1133 public:
1134 struct OwnedLock {
1135 // should be synced with ordinals of jdk.internal.vm.ThreadSnapshot.OwnedLockType enum
1136 enum Type {
1137 NOTHING = -1,
1138 LOCKED = 0,
1139 ELIMINATED = 1,
1140 };
1141
1142 int _frame_depth;
1143 Type _type;
1144 // synchronization object (when type == LOCKED) or its klass (type == ELIMINATED)
1458
1459 JavaThread* java_thread = nullptr;
1460 oop thread_oop;
1461 bool has_javathread = tlh.cv_internal_thread_to_JavaThread(jthread, &java_thread, &thread_oop);
1462 assert((has_javathread && thread_oop != nullptr) || !has_javathread, "Missing Thread oop");
1463 bool is_virtual = java_lang_VirtualThread::is_instance(thread_oop); // Deals with null
1464
1465 if (!has_javathread && !is_virtual) {
1466 return nullptr; // thread terminated so not of interest
1467 }
1468
1469 // Handshake with target
1470 Handle thread_h(THREAD, thread_oop);
1471 GetThreadSnapshotHandshakeClosure cl(thread_h);
1472 if (java_lang_VirtualThread::is_instance(thread_oop)) {
1473 Handshake::execute(&cl, thread_oop);
1474 } else {
1475 Handshake::execute(&cl, &tlh, java_thread);
1476 }
1477
1478 // thread not alive
1479 if (cl._thread_status == JavaThreadStatus::NEW || cl._thread_status == JavaThreadStatus::TERMINATED) {
1480 return nullptr;
1481 }
1482
1483 // StackTrace
1484 InstanceKlass* ste_klass = vmClasses::StackTraceElement_klass();
1485 assert(ste_klass != nullptr, "must be loaded");
1486
1487 objArrayHandle trace = oopFactory::new_objArray_handle(ste_klass, cl._frame_count, CHECK_NULL);
1488
1489 for (int i = 0; i < cl._frame_count; i++) {
1490 methodHandle method(THREAD, cl._methods->at(i));
1491 oop element = java_lang_StackTraceElement::create(method, cl._bcis->at(i), CHECK_NULL);
1492 trace->obj_at_put(i, element);
1493 }
1494
1495 // Locks
1496 Symbol* lock_sym = vmSymbols::jdk_internal_vm_ThreadLock();
1497 Klass* lock_k = SystemDictionary::resolve_or_fail(lock_sym, true, CHECK_NULL);
1498 InstanceKlass* lock_klass = InstanceKlass::cast(lock_k);
1499
1500 objArrayHandle locks;
1501 if (cl._locks != nullptr && cl._locks->length() > 0) {
1502 locks = oopFactory::new_objArray_handle(lock_klass, cl._locks->length(), CHECK_NULL);
1521 // the method return the same trace array
1522
1523 Symbol* snapshot_klass_name = vmSymbols::jdk_internal_vm_ThreadSnapshot();
1524 Klass* snapshot_klass = SystemDictionary::resolve_or_fail(snapshot_klass_name, true, CHECK_NULL);
1525 if (snapshot_klass->should_be_initialized()) {
1526 snapshot_klass->initialize(CHECK_NULL);
1527 }
1528
1529 Handle snapshot = jdk_internal_vm_ThreadSnapshot::allocate(InstanceKlass::cast(snapshot_klass), CHECK_NULL);
1530 jdk_internal_vm_ThreadSnapshot::set_name(snapshot(), cl._thread_name.resolve());
1531 jdk_internal_vm_ThreadSnapshot::set_thread_status(snapshot(), (int)cl._thread_status);
1532 jdk_internal_vm_ThreadSnapshot::set_carrier_thread(snapshot(), cl._carrier_thread.resolve());
1533 jdk_internal_vm_ThreadSnapshot::set_stack_trace(snapshot(), trace());
1534 jdk_internal_vm_ThreadSnapshot::set_locks(snapshot(), locks());
1535 if (!cl._blocker.is_empty()) {
1536 jdk_internal_vm_ThreadSnapshot::set_blocker(snapshot(),
1537 cl._blocker._type, cl._blocker._obj.resolve(), cl._blocker._owner.resolve());
1538 }
1539 return snapshot();
1540 }
|