3070 }
3071 HOTSPOT_THREAD_SLEEP_END(0);
3072 JVM_END
3073
3074 JVM_ENTRY(jobject, JVM_CurrentCarrierThread(JNIEnv* env, jclass threadClass))
3075 oop jthread = thread->threadObj();
3076 assert(jthread != nullptr, "no current carrier thread!");
3077 return JNIHandles::make_local(THREAD, jthread);
3078 JVM_END
3079
3080 JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass))
3081 oop theThread = thread->vthread();
3082 assert(theThread != (oop)nullptr, "no current thread!");
3083 return JNIHandles::make_local(THREAD, theThread);
3084 JVM_END
3085
3086 JVM_ENTRY(void, JVM_SetCurrentThread(JNIEnv* env, jobject thisThread,
3087 jobject theThread))
3088 oop threadObj = JNIHandles::resolve(theThread);
3089 thread->set_vthread(threadObj);
3090 JFR_ONLY(Jfr::on_set_current_thread(thread, threadObj);)
3091 JVM_END
3092
3093 JVM_ENTRY(jlong, JVM_GetNextThreadIdOffset(JNIEnv* env, jclass threadClass))
3094 return ThreadIdentifier::unsafe_offset();
3095 JVM_END
3096
3097 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
3098 ThreadsListHandle tlh(thread);
3099 JavaThread* receiver = nullptr;
3100 bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, nullptr);
3101 if (is_alive) {
3102 // jthread refers to a live JavaThread.
3103 receiver->interrupt();
3104 }
3105 JVM_END
3106
3107 // Return true iff the current thread has locked the object passed in
3108
3109 JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj))
3956 assert(!thread->is_in_VTMS_transition(), "sanity check");
3957 assert(thread->is_in_tmp_VTMS_transition() != (bool)hide, "sanity check");
3958 thread->toggle_is_in_tmp_VTMS_transition();
3959 #endif
3960 JVM_END
3961
3962 // Notification from VirtualThread about disabling JVMTI Suspend in a sync critical section.
3963 // Needed to avoid deadlocks with JVMTI suspend mechanism.
3964 JVM_ENTRY(void, JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jboolean enter))
3965 #if INCLUDE_JVMTI
3966 if (!DoJVMTIVirtualThreadTransitions) {
3967 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check");
3968 return;
3969 }
3970 assert(thread->is_disable_suspend() != (bool)enter,
3971 "nested or unbalanced monitor enter/exit is not allowed");
3972 thread->toggle_is_disable_suspend();
3973 #endif
3974 JVM_END
3975
3976 /*
3977 * Return the current class's class file version. The low order 16 bits of the
3978 * returned jint contain the class's major version. The high order 16 bits
3979 * contain the class's minor version.
3980 */
3981 JVM_ENTRY(jint, JVM_GetClassFileVersion(JNIEnv* env, jclass current))
3982 oop mirror = JNIHandles::resolve_non_null(current);
3983 if (java_lang_Class::is_primitive(mirror)) {
3984 // return latest major version and minor version of 0.
3985 return JVM_CLASSFILE_MAJOR_VERSION;
3986 }
3987 assert(!java_lang_Class::as_Klass(mirror)->is_array_klass(), "unexpected array class");
3988
3989 Klass* c = java_lang_Class::as_Klass(mirror);
3990 assert(c->is_instance_klass(), "must be");
3991 InstanceKlass* ik = InstanceKlass::cast(c);
3992 return (ik->minor_version() << 16) | ik->major_version();
3993 JVM_END
3994
3995 /*
|
3070 }
3071 HOTSPOT_THREAD_SLEEP_END(0);
3072 JVM_END
3073
3074 JVM_ENTRY(jobject, JVM_CurrentCarrierThread(JNIEnv* env, jclass threadClass))
3075 oop jthread = thread->threadObj();
3076 assert(jthread != nullptr, "no current carrier thread!");
3077 return JNIHandles::make_local(THREAD, jthread);
3078 JVM_END
3079
3080 JVM_ENTRY(jobject, JVM_CurrentThread(JNIEnv* env, jclass threadClass))
3081 oop theThread = thread->vthread();
3082 assert(theThread != (oop)nullptr, "no current thread!");
3083 return JNIHandles::make_local(THREAD, theThread);
3084 JVM_END
3085
3086 JVM_ENTRY(void, JVM_SetCurrentThread(JNIEnv* env, jobject thisThread,
3087 jobject theThread))
3088 oop threadObj = JNIHandles::resolve(theThread);
3089 thread->set_vthread(threadObj);
3090
3091 // Set lock id of new current Thread
3092 thread->set_lock_id(java_lang_Thread::thread_id(threadObj));
3093
3094 JFR_ONLY(Jfr::on_set_current_thread(thread, threadObj);)
3095 JVM_END
3096
3097 JVM_ENTRY(jlong, JVM_GetNextThreadIdOffset(JNIEnv* env, jclass threadClass))
3098 return ThreadIdentifier::unsafe_offset();
3099 JVM_END
3100
3101 JVM_ENTRY(void, JVM_Interrupt(JNIEnv* env, jobject jthread))
3102 ThreadsListHandle tlh(thread);
3103 JavaThread* receiver = nullptr;
3104 bool is_alive = tlh.cv_internal_thread_to_JavaThread(jthread, &receiver, nullptr);
3105 if (is_alive) {
3106 // jthread refers to a live JavaThread.
3107 receiver->interrupt();
3108 }
3109 JVM_END
3110
3111 // Return true iff the current thread has locked the object passed in
3112
3113 JVM_ENTRY(jboolean, JVM_HoldsLock(JNIEnv* env, jclass threadClass, jobject obj))
3960 assert(!thread->is_in_VTMS_transition(), "sanity check");
3961 assert(thread->is_in_tmp_VTMS_transition() != (bool)hide, "sanity check");
3962 thread->toggle_is_in_tmp_VTMS_transition();
3963 #endif
3964 JVM_END
3965
3966 // Notification from VirtualThread about disabling JVMTI Suspend in a sync critical section.
3967 // Needed to avoid deadlocks with JVMTI suspend mechanism.
3968 JVM_ENTRY(void, JVM_VirtualThreadDisableSuspend(JNIEnv* env, jclass clazz, jboolean enter))
3969 #if INCLUDE_JVMTI
3970 if (!DoJVMTIVirtualThreadTransitions) {
3971 assert(!JvmtiExport::can_support_virtual_threads(), "sanity check");
3972 return;
3973 }
3974 assert(thread->is_disable_suspend() != (bool)enter,
3975 "nested or unbalanced monitor enter/exit is not allowed");
3976 thread->toggle_is_disable_suspend();
3977 #endif
3978 JVM_END
3979
3980 JVM_ENTRY_NO_ENV(void, JVM_VirtualThreadPinnedEvent(jint reasonCode, jstring reasonString))
3981 #if INCLUDE_JFR
3982 EventVirtualThreadPinned e;
3983 if (e.should_commit()) {
3984 ResourceMark rm(THREAD);
3985 // ignore reason code for now
3986 const char *reason = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(reasonString));
3987 e.set_pinnedReason(reason);
3988 e.set_carrierThread(JFR_JVM_THREAD_ID(THREAD));
3989 e.commit();
3990 }
3991 #endif
3992 JVM_END
3993
3994 JVM_ENTRY_NO_ENV(void, JVM_SetLockId(JNIEnv* env, jclass clazz, jlong tid))
3995 thread->set_lock_id(tid);
3996 JVM_END
3997
3998 JVM_ENTRY(jobject, JVM_TakeVirtualThreadListToUnblock(JNIEnv* env, jclass ignored))
3999 ParkEvent* parkEvent = ObjectMonitor::vthread_unparker_ParkEvent();
4000 assert(parkEvent != nullptr, "not initialized");
4001
4002 OopHandle& list_head = ObjectMonitor::vthread_cxq_head();
4003 oop vthread_head = nullptr;
4004 while (true) {
4005 if (list_head.peek() != nullptr) {
4006 for (;;) {
4007 oop head = list_head.resolve();
4008 if (list_head.cmpxchg(head, nullptr) == head) {
4009 return JNIHandles::make_local(THREAD, head);
4010 }
4011 }
4012 }
4013 ThreadBlockInVM tbivm(THREAD);
4014 parkEvent->park();
4015 }
4016 JVM_END
4017 /*
4018 * Return the current class's class file version. The low order 16 bits of the
4019 * returned jint contain the class's major version. The high order 16 bits
4020 * contain the class's minor version.
4021 */
4022 JVM_ENTRY(jint, JVM_GetClassFileVersion(JNIEnv* env, jclass current))
4023 oop mirror = JNIHandles::resolve_non_null(current);
4024 if (java_lang_Class::is_primitive(mirror)) {
4025 // return latest major version and minor version of 0.
4026 return JVM_CLASSFILE_MAJOR_VERSION;
4027 }
4028 assert(!java_lang_Class::as_Klass(mirror)->is_array_klass(), "unexpected array class");
4029
4030 Klass* c = java_lang_Class::as_Klass(mirror);
4031 assert(c->is_instance_klass(), "must be");
4032 InstanceKlass* ik = InstanceKlass::cast(c);
4033 return (ik->minor_version() << 16) | ik->major_version();
4034 JVM_END
4035
4036 /*
|