768 // This is for extra safety. Other bits are not expected nor needed.
769 state &= (JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_INTERRUPTED);
770
771 if (jt->is_carrier_thread_suspended()) {
772 state |= JVMTI_THREAD_STATE_SUSPENDED;
773 }
774 // It's okay for the JVMTI state to be reported as WAITING when waiting
775 // for something other than an Object.wait. So, we treat a thread carrying
776 // a virtual thread as waiting indefinitely which is not runnable.
777 // It is why the RUNNABLE bit is not needed and the WAITING bits are added.
778 state |= JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_INDEFINITELY;
779 } else {
780 state = get_thread_state_base(thread_oop, jt);
781 }
782 return state;
783 }
784
785 jint
786 JvmtiEnvBase::get_vthread_state(oop thread_oop, JavaThread* java_thread) {
787 jint state = 0;
788 bool ext_suspended = JvmtiVTSuspender::is_vthread_suspended(thread_oop);
789 jint interrupted = java_lang_Thread::interrupted(thread_oop);
790
791 if (java_thread != nullptr) {
792 // If virtual thread is blocked on a monitor enter the BLOCKED_ON_MONITOR_ENTER bit
793 // is set for carrier thread instead of virtual.
794 // Other state bits except filtered ones are expected to be the same.
795 oop ct_oop = java_lang_VirtualThread::carrier_thread(thread_oop);
796 jint filtered_bits = JVMTI_THREAD_STATE_SUSPENDED | JVMTI_THREAD_STATE_INTERRUPTED;
797
798 // This call can trigger a safepoint, so thread_oop must not be used after it.
799 state = get_thread_state_base(ct_oop, java_thread) & ~filtered_bits;
800 } else {
801 int vt_state = java_lang_VirtualThread::state(thread_oop);
802 state = (jint)java_lang_VirtualThread::map_state_to_thread_status(vt_state);
803 }
804 // Ensure the thread has not exited after retrieving suspended/interrupted values.
805 if ((state & JVMTI_THREAD_STATE_ALIVE) != 0) {
806 if (ext_suspended) {
807 state |= JVMTI_THREAD_STATE_SUSPENDED;
808 }
809 if (interrupted) {
810 state |= JVMTI_THREAD_STATE_INTERRUPTED;
811 }
812 }
813 return state;
814 }
815
816 jint
817 JvmtiEnvBase::get_thread_or_vthread_state(oop thread_oop, JavaThread* java_thread) {
818 jint state = 0;
819 if (java_lang_VirtualThread::is_instance(thread_oop)) {
997 jvf != nullptr; jvf = jvf->java_sender()) {
998 if (MaxJavaStackTraceDepth == 0 || depth++ < MaxJavaStackTraceDepth) { // check for stack too deep
999 // add locked objects for this frame into list
1000 err = get_locked_objects_in_frame(calling_thread, java_thread, jvf, owned_monitors_list, depth-1);
1001 if (err != JVMTI_ERROR_NONE) {
1002 return err;
1003 }
1004 }
1005 }
1006 }
1007
1008 // Get off stack monitors. (e.g. acquired via jni MonitorEnter).
1009 JvmtiMonitorClosure jmc(calling_thread, owned_monitors_list, this);
1010 ObjectSynchronizer::owned_monitors_iterate(&jmc, java_thread);
1011 err = jmc.error();
1012
1013 return err;
1014 }
1015
1016 jvmtiError
1017 JvmtiEnvBase::get_owned_monitors(JavaThread* calling_thread, JavaThread* java_thread, javaVFrame* jvf,
1018 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list) {
1019 jvmtiError err = JVMTI_ERROR_NONE;
1020 Thread *current_thread = Thread::current();
1021 assert(java_thread->is_handshake_safe_for(current_thread),
1022 "call by myself or at handshake");
1023
1024 int depth = 0;
1025 for ( ; jvf != nullptr; jvf = jvf->java_sender()) {
1026 if (MaxJavaStackTraceDepth == 0 || depth++ < MaxJavaStackTraceDepth) { // check for stack too deep
1027 // Add locked objects for this frame into list.
1028 err = get_locked_objects_in_frame(calling_thread, java_thread, jvf, owned_monitors_list, depth - 1);
1029 if (err != JVMTI_ERROR_NONE) {
1030 return err;
1031 }
1032 }
1033 }
1034
1035 // Get off stack monitors. (e.g. acquired via jni MonitorEnter).
1036 JvmtiMonitorClosure jmc(calling_thread, owned_monitors_list, this);
1037 ObjectSynchronizer::owned_monitors_iterate(&jmc, java_thread);
1038 err = jmc.error();
1039
1040 return err;
1041 }
1042
1043 // Save JNI local handles for any objects that this frame owns.
1044 jvmtiError
1045 JvmtiEnvBase::get_locked_objects_in_frame(JavaThread* calling_thread, JavaThread* java_thread,
1046 javaVFrame *jvf, GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list, jint stack_depth) {
1047 jvmtiError err = JVMTI_ERROR_NONE;
1048 Thread* current_thread = Thread::current();
1049 ResourceMark rm(current_thread);
1050 HandleMark hm(current_thread);
1051
1052 GrowableArray<MonitorInfo*>* mons = jvf->monitors();
1053 if (mons->is_empty()) {
1054 return err; // this javaVFrame holds no monitors
1055 }
1056
1057 oop wait_obj = nullptr;
1058 {
1059 // The ObjectMonitor* can't be async deflated since we are either
1060 // at a safepoint or the calling thread is operating on itself so
1061 // it cannot leave the underlying wait() call.
1062 // Save object of current wait() call (if any) for later comparison.
1063 ObjectMonitor *mon = java_thread->current_waiting_monitor();
1064 if (mon != nullptr) {
1065 wait_obj = mon->object();
1066 }
1067 }
1068 oop pending_obj = nullptr;
1069 {
1070 // The ObjectMonitor* can't be async deflated since we are either
1071 // at a safepoint or the calling thread is operating on itself so
1072 // it cannot leave the underlying enter() call.
1073 // Save object of current enter() call (if any) for later comparison.
1074 ObjectMonitor *mon = java_thread->current_pending_monitor();
1075 if (mon != nullptr) {
1076 pending_obj = mon->object();
1077 }
1078 }
1079
1080 for (int i = 0; i < mons->length(); i++) {
1081 MonitorInfo *mi = mons->at(i);
1082
1083 if (mi->owner_is_scalar_replaced()) continue;
1084
1085 oop obj = mi->owner();
1086 if (obj == nullptr) {
1087 // this monitor doesn't have an owning object so skip it
1088 continue;
1089 }
1090
1091 if (wait_obj == obj) {
1092 // the thread is waiting on this monitor so it isn't really owned
1093 continue;
1094 }
1095
1096 if (pending_obj == obj) {
1504 // or to re-enter monitor, in Object.wait()
1505
1506 // Get the actual set of threads trying to enter, or re-enter, the monitor.
1507 wantList = Threads::get_pending_threads(tlh.list(), nWant + nWait, (address)mon);
1508 nWant = wantList->length();
1509 } else {
1510 // this object has a lightweight monitor
1511 }
1512
1513 jint skipped = 0;
1514 if (mon != nullptr) {
1515 // Robustness: the actual waiting list can be smaller.
1516 // The nWait count we got from the mon->waiters() may include the re-entering
1517 // the monitor threads after being notified. Here we are correcting the actual
1518 // number of the waiting threads by excluding those re-entering the monitor.
1519 nWait = 0;
1520 for (ObjectWaiter* waiter = mon->first_waiter();
1521 waiter != nullptr && (nWait == 0 || waiter != mon->first_waiter());
1522 waiter = mon->next_waiter(waiter)) {
1523 JavaThread *w = mon->thread_of_waiter(waiter);
1524 oop thread_oop = get_vthread_or_thread_oop(w);
1525 if (thread_oop->is_a(vmClasses::BaseVirtualThread_klass())) {
1526 skipped++;
1527 }
1528 nWait++;
1529 }
1530 }
1531 ret.waiter_count = nWant;
1532 ret.notify_waiter_count = nWait - skipped;
1533
1534 // Allocate memory for heavyweight and lightweight monitor.
1535 jvmtiError err;
1536 err = allocate(ret.waiter_count * sizeof(jthread *), (unsigned char**)&ret.waiters);
1537 if (err != JVMTI_ERROR_NONE) {
1538 return err;
1539 }
1540 err = allocate(ret.notify_waiter_count * sizeof(jthread *),
1541 (unsigned char**)&ret.notify_waiters);
1542 if (err != JVMTI_ERROR_NONE) {
1543 deallocate((unsigned char*)ret.waiters);
1544 return err;
1545 }
1546
1554 }
1555 if (ret.notify_waiters != nullptr) {
1556 memset(ret.notify_waiters, 0, ret.notify_waiter_count * sizeof(jthread *));
1557 }
1558
1559 if (ret.waiter_count > 0) { // we have contending threads waiting to enter/re-enter the monitor
1560 // identify threads waiting to enter and re-enter the monitor
1561 // get_pending_threads returns only java thread so we do not need to
1562 // check for non java threads.
1563 for (int i = 0; i < nWant; i++) {
1564 JavaThread *pending_thread = wantList->at(i);
1565 Handle th(current_thread, get_vthread_or_thread_oop(pending_thread));
1566 ret.waiters[i] = (jthread)jni_reference(calling_thread, th);
1567 }
1568 }
1569 if (ret.notify_waiter_count > 0) { // we have threads waiting to be notified in Object.wait()
1570 ObjectWaiter *waiter = mon->first_waiter();
1571 jint skipped = 0;
1572 for (int i = 0; i < nWait; i++) {
1573 JavaThread *w = mon->thread_of_waiter(waiter);
1574 oop thread_oop = get_vthread_or_thread_oop(w);
1575 bool is_virtual = thread_oop->is_a(vmClasses::BaseVirtualThread_klass());
1576 assert(w != nullptr, "sanity check");
1577 if (is_virtual) {
1578 skipped++;
1579 } else {
1580 // If the thread was found on the ObjectWaiter list, then
1581 // it has not been notified.
1582 Handle th(current_thread, get_vthread_or_thread_oop(w));
1583 ret.notify_waiters[i - skipped] = (jthread)jni_reference(calling_thread, th);
1584 }
1585 waiter = mon->next_waiter(waiter);
1586 }
1587 }
1588 } else {
1589 // this object has a lightweight monitor and we have nothing more
1590 // to do here because the defaults are just fine.
1591 }
1592
1593 // we don't update return parameter unless everything worked
1594 *info_ptr = ret;
1595
1596 return JVMTI_ERROR_NONE;
1597 }
1598
1599 jvmtiError
1600 JvmtiEnvBase::check_thread_list(jint count, const jthread* list) {
1601 if (list == nullptr && count != 0) {
1602 return JVMTI_ERROR_NULL_POINTER;
2481 if (!_self && !JvmtiVTSuspender::is_vthread_suspended(target_h())) {
2482 _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
2483 return;
2484 }
2485 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2486 _result = ((JvmtiEnvBase*)_env)->set_frame_pop(_state, jvf, _depth);
2487 }
2488
2489 void
2490 GetOwnedMonitorInfoClosure::do_thread(Thread *target) {
2491 JavaThread *jt = JavaThread::cast(target);
2492 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2493 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2494 jt,
2495 _owned_monitors_list);
2496 }
2497 }
2498
2499 void
2500 GetOwnedMonitorInfoClosure::do_vthread(Handle target_h) {
2501 assert(_target_jt != nullptr, "sanity check");
2502 Thread* current = Thread::current();
2503 ResourceMark rm(current); // vframes are resource allocated
2504 HandleMark hm(current);
2505
2506 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2507
2508 if (!_target_jt->is_exiting() && _target_jt->threadObj() != nullptr) {
2509 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2510 _target_jt,
2511 jvf,
2512 _owned_monitors_list);
2513 }
2514 }
2515
2516 void
2517 GetCurrentContendedMonitorClosure::do_thread(Thread *target) {
2518 JavaThread *jt = JavaThread::cast(target);
2519 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2520 _result = ((JvmtiEnvBase *)_env)->get_current_contended_monitor(_calling_thread,
2521 jt,
2522 _owned_monitor_ptr,
2523 _is_virtual);
2524 }
2525 }
2526
2527 void
2528 GetCurrentContendedMonitorClosure::do_vthread(Handle target_h) {
2529 if (_target_jt == nullptr) {
2530 _result = JVMTI_ERROR_NONE; // target virtual thread is unmounted
2531 return;
2532 }
2533 // mounted virtual thread case
2534 do_thread(_target_jt);
2535 }
2536
2537 void
2538 GetStackTraceClosure::do_thread(Thread *target) {
2539 Thread* current = Thread::current();
2540 ResourceMark rm(current);
2541
2542 JavaThread *jt = JavaThread::cast(target);
2543 if (!jt->is_exiting() && jt->threadObj() != nullptr) {
2544 _result = ((JvmtiEnvBase *)_env)->get_stack_trace(jt,
2545 _start_depth, _max_count,
2546 _frame_buffer, _count_ptr);
2547 }
2548 }
2549
|
768 // This is for extra safety. Other bits are not expected nor needed.
769 state &= (JVMTI_THREAD_STATE_ALIVE | JVMTI_THREAD_STATE_INTERRUPTED);
770
771 if (jt->is_carrier_thread_suspended()) {
772 state |= JVMTI_THREAD_STATE_SUSPENDED;
773 }
774 // It's okay for the JVMTI state to be reported as WAITING when waiting
775 // for something other than an Object.wait. So, we treat a thread carrying
776 // a virtual thread as waiting indefinitely which is not runnable.
777 // It is why the RUNNABLE bit is not needed and the WAITING bits are added.
778 state |= JVMTI_THREAD_STATE_WAITING | JVMTI_THREAD_STATE_WAITING_INDEFINITELY;
779 } else {
780 state = get_thread_state_base(thread_oop, jt);
781 }
782 return state;
783 }
784
785 jint
786 JvmtiEnvBase::get_vthread_state(oop thread_oop, JavaThread* java_thread) {
787 jint state = 0;
788 bool is_mon_responsible = java_lang_VirtualThread::recheckInterval(thread_oop) > 0;
789 bool ext_suspended = JvmtiVTSuspender::is_vthread_suspended(thread_oop);
790 jint interrupted = java_lang_Thread::interrupted(thread_oop);
791
792 if (java_thread != nullptr) {
793 // If virtual thread is blocked on a monitor enter the BLOCKED_ON_MONITOR_ENTER bit
794 // is set for carrier thread instead of virtual.
795 // Other state bits except filtered ones are expected to be the same.
796 oop ct_oop = java_lang_VirtualThread::carrier_thread(thread_oop);
797 jint filtered_bits = JVMTI_THREAD_STATE_SUSPENDED | JVMTI_THREAD_STATE_INTERRUPTED;
798
799 // This call can trigger a safepoint, so thread_oop must not be used after it.
800 state = get_thread_state_base(ct_oop, java_thread) & ~filtered_bits;
801 } else if (is_mon_responsible) {
802 state = (jint) JavaThreadStatus::BLOCKED_ON_MONITOR_ENTER;
803 } else {
804 int vt_state = java_lang_VirtualThread::state(thread_oop);
805 state = (jint)java_lang_VirtualThread::map_state_to_thread_status(vt_state);
806 }
807 // Ensure the thread has not exited after retrieving suspended/interrupted values.
808 if ((state & JVMTI_THREAD_STATE_ALIVE) != 0) {
809 if (ext_suspended) {
810 state |= JVMTI_THREAD_STATE_SUSPENDED;
811 }
812 if (interrupted) {
813 state |= JVMTI_THREAD_STATE_INTERRUPTED;
814 }
815 }
816 return state;
817 }
818
819 jint
820 JvmtiEnvBase::get_thread_or_vthread_state(oop thread_oop, JavaThread* java_thread) {
821 jint state = 0;
822 if (java_lang_VirtualThread::is_instance(thread_oop)) {
1000 jvf != nullptr; jvf = jvf->java_sender()) {
1001 if (MaxJavaStackTraceDepth == 0 || depth++ < MaxJavaStackTraceDepth) { // check for stack too deep
1002 // add locked objects for this frame into list
1003 err = get_locked_objects_in_frame(calling_thread, java_thread, jvf, owned_monitors_list, depth-1);
1004 if (err != JVMTI_ERROR_NONE) {
1005 return err;
1006 }
1007 }
1008 }
1009 }
1010
1011 // Get off stack monitors. (e.g. acquired via jni MonitorEnter).
1012 JvmtiMonitorClosure jmc(calling_thread, owned_monitors_list, this);
1013 ObjectSynchronizer::owned_monitors_iterate(&jmc, java_thread);
1014 err = jmc.error();
1015
1016 return err;
1017 }
1018
1019 jvmtiError
1020 JvmtiEnvBase::get_owned_monitors(JavaThread* calling_thread, JavaThread* carrier, javaVFrame* jvf,
1021 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list, oop vthread) {
1022 jvmtiError err = JVMTI_ERROR_NONE;
1023 Thread *current_thread = Thread::current();
1024 assert(carrier == nullptr || carrier->is_handshake_safe_for(current_thread),
1025 "call by myself or at handshake");
1026
1027 int depth = 0;
1028 for ( ; jvf != nullptr; jvf = jvf->java_sender()) {
1029 if (MaxJavaStackTraceDepth == 0 || depth++ < MaxJavaStackTraceDepth) { // check for stack too deep
1030 // Add locked objects for this frame into list.
1031 err = get_locked_objects_in_frame(calling_thread, carrier, jvf, owned_monitors_list, depth - 1, vthread);
1032 if (err != JVMTI_ERROR_NONE) {
1033 return err;
1034 }
1035 }
1036 }
1037
1038 if (carrier == nullptr) {
1039 // vthread gets pinned if monitors are acquired via jni MonitorEnter
1040 // so nothing else to do for unmounted case.
1041 return err;
1042 }
1043
1044 // Get off stack monitors. (e.g. acquired via jni MonitorEnter).
1045 JvmtiMonitorClosure jmc(calling_thread, owned_monitors_list, this);
1046 ObjectSynchronizer::owned_monitors_iterate(&jmc, carrier);
1047 err = jmc.error();
1048
1049 return err;
1050 }
1051
1052 // Save JNI local handles for any objects that this frame owns.
1053 jvmtiError
1054 JvmtiEnvBase::get_locked_objects_in_frame(JavaThread* calling_thread, JavaThread* target,
1055 javaVFrame *jvf, GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list,
1056 jint stack_depth, oop vthread) {
1057 jvmtiError err = JVMTI_ERROR_NONE;
1058 Thread* current_thread = Thread::current();
1059 ResourceMark rm(current_thread);
1060 HandleMark hm(current_thread);
1061
1062 GrowableArray<MonitorInfo*>* mons = jvf->monitors();
1063 if (mons->is_empty()) {
1064 return err; // this javaVFrame holds no monitors
1065 }
1066
1067 oop wait_obj = nullptr;
1068 {
1069 // The ObjectMonitor* can't be async deflated since we are either
1070 // at a safepoint or the calling thread is operating on itself so
1071 // it cannot leave the underlying wait() call.
1072 // Save object of current wait() call (if any) for later comparison.
1073 if (target != nullptr) {
1074 ObjectMonitor *mon = target->current_waiting_monitor();
1075 if (mon != nullptr) wait_obj = mon->object();
1076 }
1077 }
1078 oop pending_obj = nullptr;
1079 {
1080 // The ObjectMonitor* can't be async deflated since we are either
1081 // at a safepoint or the calling thread is operating on itself so
1082 // it cannot leave the underlying enter() call.
1083 // Save object of current enter() call (if any) for later comparison.
1084 if (target != nullptr) {
1085 ObjectMonitor *mon = target->current_pending_monitor();
1086 if (mon != nullptr) pending_obj = mon->object();
1087 } else {
1088 assert(vthread != nullptr, "no vthread oop");
1089 oop oopCont = java_lang_VirtualThread::continuation(vthread);
1090 assert(oopCont != nullptr, "vthread with no continuation");
1091 stackChunkOop chunk = jdk_internal_vm_Continuation::tail(oopCont);
1092 assert(chunk != nullptr, "unmounted vthread should have a chunk");
1093 ObjectMonitor *mon = chunk->current_pending_monitor();
1094 if (mon != nullptr) pending_obj = mon->object();
1095 }
1096 }
1097
1098 for (int i = 0; i < mons->length(); i++) {
1099 MonitorInfo *mi = mons->at(i);
1100
1101 if (mi->owner_is_scalar_replaced()) continue;
1102
1103 oop obj = mi->owner();
1104 if (obj == nullptr) {
1105 // this monitor doesn't have an owning object so skip it
1106 continue;
1107 }
1108
1109 if (wait_obj == obj) {
1110 // the thread is waiting on this monitor so it isn't really owned
1111 continue;
1112 }
1113
1114 if (pending_obj == obj) {
1522 // or to re-enter monitor, in Object.wait()
1523
1524 // Get the actual set of threads trying to enter, or re-enter, the monitor.
1525 wantList = Threads::get_pending_threads(tlh.list(), nWant + nWait, (address)mon);
1526 nWant = wantList->length();
1527 } else {
1528 // this object has a lightweight monitor
1529 }
1530
1531 jint skipped = 0;
1532 if (mon != nullptr) {
1533 // Robustness: the actual waiting list can be smaller.
1534 // The nWait count we got from the mon->waiters() may include the re-entering
1535 // the monitor threads after being notified. Here we are correcting the actual
1536 // number of the waiting threads by excluding those re-entering the monitor.
1537 nWait = 0;
1538 for (ObjectWaiter* waiter = mon->first_waiter();
1539 waiter != nullptr && (nWait == 0 || waiter != mon->first_waiter());
1540 waiter = mon->next_waiter(waiter)) {
1541 JavaThread *w = mon->thread_of_waiter(waiter);
1542 if (w == nullptr) {
1543 skipped++;
1544 } else {
1545 oop thread_oop = get_vthread_or_thread_oop(w);
1546 if (thread_oop->is_a(vmClasses::BaseVirtualThread_klass())) {
1547 skipped++;
1548 }
1549 }
1550 nWait++;
1551 }
1552 }
1553 ret.waiter_count = nWant;
1554 ret.notify_waiter_count = nWait - skipped;
1555
1556 // Allocate memory for heavyweight and lightweight monitor.
1557 jvmtiError err;
1558 err = allocate(ret.waiter_count * sizeof(jthread *), (unsigned char**)&ret.waiters);
1559 if (err != JVMTI_ERROR_NONE) {
1560 return err;
1561 }
1562 err = allocate(ret.notify_waiter_count * sizeof(jthread *),
1563 (unsigned char**)&ret.notify_waiters);
1564 if (err != JVMTI_ERROR_NONE) {
1565 deallocate((unsigned char*)ret.waiters);
1566 return err;
1567 }
1568
1576 }
1577 if (ret.notify_waiters != nullptr) {
1578 memset(ret.notify_waiters, 0, ret.notify_waiter_count * sizeof(jthread *));
1579 }
1580
1581 if (ret.waiter_count > 0) { // we have contending threads waiting to enter/re-enter the monitor
1582 // identify threads waiting to enter and re-enter the monitor
1583 // get_pending_threads returns only java thread so we do not need to
1584 // check for non java threads.
1585 for (int i = 0; i < nWant; i++) {
1586 JavaThread *pending_thread = wantList->at(i);
1587 Handle th(current_thread, get_vthread_or_thread_oop(pending_thread));
1588 ret.waiters[i] = (jthread)jni_reference(calling_thread, th);
1589 }
1590 }
1591 if (ret.notify_waiter_count > 0) { // we have threads waiting to be notified in Object.wait()
1592 ObjectWaiter *waiter = mon->first_waiter();
1593 jint skipped = 0;
1594 for (int i = 0; i < nWait; i++) {
1595 JavaThread *w = mon->thread_of_waiter(waiter);
1596 bool is_virtual;
1597 if (w == nullptr) {
1598 is_virtual = true;
1599 } else {
1600 oop thread_oop = get_vthread_or_thread_oop(w);
1601 is_virtual = thread_oop->is_a(vmClasses::BaseVirtualThread_klass());
1602 }
1603 if (is_virtual) {
1604 skipped++;
1605 } else {
1606 // If the thread was found on the ObjectWaiter list, then
1607 // it has not been notified.
1608 Handle th(current_thread, w->threadObj());
1609 ret.notify_waiters[i - skipped] = (jthread)jni_reference(calling_thread, th);
1610 }
1611 waiter = mon->next_waiter(waiter);
1612 }
1613 }
1614 } else {
1615 // this object has a lightweight monitor and we have nothing more
1616 // to do here because the defaults are just fine.
1617 }
1618
1619 // we don't update return parameter unless everything worked
1620 *info_ptr = ret;
1621
1622 return JVMTI_ERROR_NONE;
1623 }
1624
1625 jvmtiError
1626 JvmtiEnvBase::check_thread_list(jint count, const jthread* list) {
1627 if (list == nullptr && count != 0) {
1628 return JVMTI_ERROR_NULL_POINTER;
2507 if (!_self && !JvmtiVTSuspender::is_vthread_suspended(target_h())) {
2508 _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
2509 return;
2510 }
2511 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2512 _result = ((JvmtiEnvBase*)_env)->set_frame_pop(_state, jvf, _depth);
2513 }
2514
2515 void
2516 GetOwnedMonitorInfoClosure::do_thread(Thread *target) {
2517 JavaThread *jt = JavaThread::cast(target);
2518 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2519 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2520 jt,
2521 _owned_monitors_list);
2522 }
2523 }
2524
2525 void
2526 GetOwnedMonitorInfoClosure::do_vthread(Handle target_h) {
2527 Thread* current = Thread::current();
2528 ResourceMark rm(current); // vframes are resource allocated
2529 HandleMark hm(current);
2530
2531 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2532
2533 if (_target_jt == nullptr || (!_target_jt->is_exiting() && _target_jt->threadObj() != nullptr)) {
2534 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2535 _target_jt,
2536 jvf,
2537 _owned_monitors_list,
2538 target_h());
2539 }
2540 }
2541
2542 void
2543 GetCurrentContendedMonitorClosure::do_thread(Thread *target) {
2544 JavaThread *jt = JavaThread::cast(target);
2545 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2546 _result = ((JvmtiEnvBase *)_env)->get_current_contended_monitor(_calling_thread,
2547 jt,
2548 _owned_monitor_ptr,
2549 _is_virtual);
2550 }
2551 }
2552
2553 void
2554 GetCurrentContendedMonitorClosure::do_vthread(Handle target_h) {
2555 if (_target_jt == nullptr) {
2556 oop cont = java_lang_VirtualThread::continuation(target_h());
2557 assert(cont != nullptr, "vthread with no continuation");
2558 stackChunkOop chunk = jdk_internal_vm_Continuation::tail(cont);
2559 assert(chunk != nullptr, "unmounted vthread should have a chunk");
2560 if (chunk->current_pending_monitor() != nullptr) {
2561 *_owned_monitor_ptr = JNIHandles::make_local(_calling_thread, chunk->current_pending_monitor()->object());
2562 }
2563 _result = JVMTI_ERROR_NONE; // target virtual thread is unmounted
2564 return;
2565 }
2566 // mounted virtual thread case
2567 do_thread(_target_jt);
2568 }
2569
2570 void
2571 GetStackTraceClosure::do_thread(Thread *target) {
2572 Thread* current = Thread::current();
2573 ResourceMark rm(current);
2574
2575 JavaThread *jt = JavaThread::cast(target);
2576 if (!jt->is_exiting() && jt->threadObj() != nullptr) {
2577 _result = ((JvmtiEnvBase *)_env)->get_stack_trace(jt,
2578 _start_depth, _max_count,
2579 _frame_buffer, _count_ptr);
2580 }
2581 }
2582
|