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) {
2470 if (!_self && !JvmtiVTSuspender::is_vthread_suspended(target_h())) {
2471 _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
2472 return;
2473 }
2474 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2475 _result = ((JvmtiEnvBase*)_env)->set_frame_pop(_state, jvf, _depth);
2476 }
2477
2478 void
2479 GetOwnedMonitorInfoClosure::do_thread(Thread *target) {
2480 JavaThread *jt = JavaThread::cast(target);
2481 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2482 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2483 jt,
2484 _owned_monitors_list);
2485 }
2486 }
2487
2488 void
2489 GetOwnedMonitorInfoClosure::do_vthread(Handle target_h) {
2490 assert(_target_jt != nullptr, "sanity check");
2491 Thread* current = Thread::current();
2492 ResourceMark rm(current); // vframes are resource allocated
2493 HandleMark hm(current);
2494
2495 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2496
2497 if (!_target_jt->is_exiting() && _target_jt->threadObj() != nullptr) {
2498 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2499 _target_jt,
2500 jvf,
2501 _owned_monitors_list);
2502 }
2503 }
2504
2505 void
2506 GetCurrentContendedMonitorClosure::do_thread(Thread *target) {
2507 JavaThread *jt = JavaThread::cast(target);
2508 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2509 _result = ((JvmtiEnvBase *)_env)->get_current_contended_monitor(_calling_thread,
2510 jt,
2511 _owned_monitor_ptr,
2512 _is_virtual);
2513 }
2514 }
2515
2516 void
2517 GetCurrentContendedMonitorClosure::do_vthread(Handle target_h) {
2518 if (_target_jt == nullptr) {
2519 _result = JVMTI_ERROR_NONE; // target virtual thread is unmounted
2520 return;
2521 }
2522 // mounted virtual thread case
2523 do_thread(_target_jt);
2524 }
2525
2526 void
2527 GetStackTraceClosure::do_thread(Thread *target) {
2528 Thread* current = Thread::current();
2529 ResourceMark rm(current);
2530
2531 JavaThread *jt = JavaThread::cast(target);
2532 if (!jt->is_exiting() && jt->threadObj() != nullptr) {
2533 _result = ((JvmtiEnvBase *)_env)->get_stack_trace(jt,
2534 _start_depth, _max_count,
2535 _frame_buffer, _count_ptr);
2536 }
2537 }
2538
2612 }
2613
2614 void
2615 GetFrameLocationClosure::do_thread(Thread *target) {
2616 JavaThread *jt = JavaThread::cast(target);
2617 assert(target == jt, "just checking");
2618
2619 if (!jt->is_exiting() && jt->threadObj() != nullptr) {
2620 _result = ((JvmtiEnvBase*)_env)->get_frame_location(jt, _depth,
2621 _method_ptr, _location_ptr);
2622 }
2623 }
2624
2625 void
2626 GetFrameLocationClosure::do_vthread(Handle target_h) {
2627 _result = ((JvmtiEnvBase*)_env)->get_frame_location(target_h(), _depth,
2628 _method_ptr, _location_ptr);
2629 }
2630
2631 void
2632 VirtualThreadGetThreadClosure::do_thread(Thread *target) {
2633 assert(target->is_Java_thread(), "just checking");
2634 JavaThread *jt = JavaThread::cast(target);
2635 oop carrier_thread = java_lang_VirtualThread::carrier_thread(_vthread_h());
2636 *_carrier_thread_ptr = (jthread)JNIHandles::make_local(jt, carrier_thread);
2637 }
|
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->objectMonitor();
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) {
2488 if (!_self && !JvmtiVTSuspender::is_vthread_suspended(target_h())) {
2489 _result = JVMTI_ERROR_THREAD_NOT_SUSPENDED;
2490 return;
2491 }
2492 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2493 _result = ((JvmtiEnvBase*)_env)->set_frame_pop(_state, jvf, _depth);
2494 }
2495
2496 void
2497 GetOwnedMonitorInfoClosure::do_thread(Thread *target) {
2498 JavaThread *jt = JavaThread::cast(target);
2499 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2500 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2501 jt,
2502 _owned_monitors_list);
2503 }
2504 }
2505
2506 void
2507 GetOwnedMonitorInfoClosure::do_vthread(Handle target_h) {
2508 Thread* current = Thread::current();
2509 ResourceMark rm(current); // vframes are resource allocated
2510 HandleMark hm(current);
2511
2512 javaVFrame *jvf = JvmtiEnvBase::get_vthread_jvf(target_h());
2513
2514 if (_target_jt == nullptr || (!_target_jt->is_exiting() && _target_jt->threadObj() != nullptr)) {
2515 _result = ((JvmtiEnvBase *)_env)->get_owned_monitors(_calling_thread,
2516 _target_jt,
2517 jvf,
2518 _owned_monitors_list,
2519 target_h());
2520 }
2521 }
2522
2523 void
2524 GetCurrentContendedMonitorClosure::do_thread(Thread *target) {
2525 JavaThread *jt = JavaThread::cast(target);
2526 if (!jt->is_exiting() && (jt->threadObj() != nullptr)) {
2527 _result = ((JvmtiEnvBase *)_env)->get_current_contended_monitor(_calling_thread,
2528 jt,
2529 _owned_monitor_ptr,
2530 _is_virtual);
2531 }
2532 }
2533
2534 void
2535 GetCurrentContendedMonitorClosure::do_vthread(Handle target_h) {
2536 if (_target_jt == nullptr) {
2537 oop cont = java_lang_VirtualThread::continuation(target_h());
2538 assert(cont != nullptr, "vthread with no continuation");
2539 stackChunkOop chunk = jdk_internal_vm_Continuation::tail(cont);
2540 assert(chunk != nullptr, "unmounted vthread should have a chunk");
2541 if (chunk->objectMonitor() != nullptr) {
2542 *_owned_monitor_ptr = JNIHandles::make_local(_calling_thread, chunk->objectMonitor()->object());
2543 }
2544 _result = JVMTI_ERROR_NONE; // target virtual thread is unmounted
2545 return;
2546 }
2547 // mounted virtual thread case
2548 do_thread(_target_jt);
2549 }
2550
2551 void
2552 GetStackTraceClosure::do_thread(Thread *target) {
2553 Thread* current = Thread::current();
2554 ResourceMark rm(current);
2555
2556 JavaThread *jt = JavaThread::cast(target);
2557 if (!jt->is_exiting() && jt->threadObj() != nullptr) {
2558 _result = ((JvmtiEnvBase *)_env)->get_stack_trace(jt,
2559 _start_depth, _max_count,
2560 _frame_buffer, _count_ptr);
2561 }
2562 }
2563
2637 }
2638
2639 void
2640 GetFrameLocationClosure::do_thread(Thread *target) {
2641 JavaThread *jt = JavaThread::cast(target);
2642 assert(target == jt, "just checking");
2643
2644 if (!jt->is_exiting() && jt->threadObj() != nullptr) {
2645 _result = ((JvmtiEnvBase*)_env)->get_frame_location(jt, _depth,
2646 _method_ptr, _location_ptr);
2647 }
2648 }
2649
2650 void
2651 GetFrameLocationClosure::do_vthread(Handle target_h) {
2652 _result = ((JvmtiEnvBase*)_env)->get_frame_location(target_h(), _depth,
2653 _method_ptr, _location_ptr);
2654 }
2655
2656 void
2657
2658 VirtualThreadGetThreadClosure::do_thread(Thread *target) {
2659 assert(target->is_Java_thread(), "just checking");
2660 JavaThread *jt = JavaThread::cast(target);
2661 oop carrier_thread = java_lang_VirtualThread::carrier_thread(_vthread_h());
2662 *_carrier_thread_ptr = (jthread)JNIHandles::make_local(jt, carrier_thread);
2663 }
|