rename JVMTI VirtualThreadScheduled/Terminated events to VirtualThreadStart/End

Author: sspitsyn

src/hotspot/share/prims/jvm.cpp

@@ -3907,8 +3907,14 @@ JVM_ENTRY(void, JVM_VirtualThreadMountEnd(JNIEnv* env, jobject vthread, jboolean
 
   if (first_mount) {
     // thread start
-    if (JvmtiExport::should_post_vthread_scheduled()) {
-      JvmtiExport::post_vthread_scheduled(vthread);
+    if (JvmtiExport::can_support_virtual_threads()) {
+      if (JvmtiExport::should_post_vthread_start()) {
+        JvmtiExport::post_vthread_start(vthread);
+      }
+    } else { // compatibility for vthread unaware agents: legacy thread_start
+      if (JvmtiExport::should_post_thread_life()) {
+        JvmtiExport::post_thread_start(thread);
+      }
     }
     oop ct_oop = thread->threadObj();
     jobject cthread = JNIHandles::make_local(thread, ct_oop);
@@ -3934,8 +3940,14 @@ JVM_ENTRY(void, JVM_VirtualThreadUnmountEnd(JNIEnv* env, jobject vthread))
 JVM_END
 
 JVM_ENTRY(void, JVM_VirtualThreadTerminated(JNIEnv* env, jobject vthread))
-  if (JvmtiExport::should_post_vthread_terminated()) {
-    JvmtiExport::post_vthread_terminated(vthread);
+  if (JvmtiExport::can_support_virtual_threads()) {
+    if (JvmtiExport::should_post_vthread_end()) {
+      JvmtiExport::post_vthread_end(vthread);
+    }
+  } else { // compatibility for vthread unaware agents: legacy thread_end
+    if (JvmtiExport::should_post_thread_life()) {
+      JvmtiExport::post_thread_end(thread);
+    }
   }
   oop ct_oop = thread->threadObj();
   jobject cthread = JNIHandles::make_local(thread, ct_oop);

src/hotspot/share/prims/jvmti.xml

@@ -10603,8 +10603,8 @@ myInit() {
           <functionlink id="GetLocalFloat"></functionlink>
           <functionlink id="GetLocalDouble"></functionlink>
           and the following events can be enabled:
-          <eventlink id="VirtualThreadScheduled"></eventlink>,
-          <eventlink id="VirtualThreadTerminated"></eventlink>,
+          <eventlink id="VirtualThreadStart"></eventlink>,
+          <eventlink id="VirtualThreadEnd"></eventlink>,
           <eventlink id="VirtualThreadMounted"></eventlink> and
           <eventlink id="VirtualThreadUnmounted"></eventlink>.
         </description>
@@ -12940,10 +12940,10 @@ myInit() {
     </parameters>
   </event>
 
- <event label="Virtual Thread Scheduled"
-         id="VirtualThreadScheduled" const="JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED" filtered="thread" num="87" phase="start" since="14">
+ <event label="Virtual Thread Start"
+         id="VirtualThreadStart" const="JVMTI_EVENT_VIRTUAL_THREAD_START" filtered="thread" num="87" phase="start" since="14">
     <description>
-      Virtual thread scheduled events are generated before its initial method executes.
+      Virtual thread started events are generated before its initial method executes.
       <p/>
       The event is sent on the <paramlink id="thread"></paramlink>.
     </description>
@@ -12963,16 +12963,16 @@ myInit() {
       <param id="virtual_thread">
         <jthread/>
           <description>
-            Virtual thread scheduled for execution.
+            Virtual thread started for execution.
           </description>
       </param>
     </parameters>
   </event>
 
-  <event label="Virtual Thread Terminated"
-         id="VirtualThreadTerminated" const="JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED" filtered="thread" num="88" phase="start" since="14">
+  <event label="Virtual Thread End"
+         id="VirtualThreadEnd" const="JVMTI_EVENT_VIRTUAL_THREAD_END" filtered="thread" num="88" phase="start" since="14">
     <description>
-      Virtual thread terminated events are generated after its initial method has finished execution.
+      Virtual thread end events are generated after its initial method has finished execution.
       <p/>
       The event is sent on the <paramlink id="thread"></paramlink>.
     </description>
@@ -12992,7 +12992,7 @@ myInit() {
       <param id="virtual_thread">
         <jthread/>
           <description>
-            Virtual thread being terminated.
+            Virtual thread being ended.
           </description>
       </param>
     </parameters>

src/hotspot/share/prims/jvmtiEventController.cpp

@@ -88,16 +88,16 @@ static const jlong  OBJECT_FREE_BIT = (((jlong)1) << (JVMTI_EVENT_OBJECT_FREE -
 static const jlong  RESOURCE_EXHAUSTED_BIT = (((jlong)1) << (JVMTI_EVENT_RESOURCE_EXHAUSTED - TOTAL_MIN_EVENT_TYPE_VAL));
 static const jlong  VM_OBJECT_ALLOC_BIT = (((jlong)1) << (JVMTI_EVENT_VM_OBJECT_ALLOC - TOTAL_MIN_EVENT_TYPE_VAL));
 static const jlong  SAMPLED_OBJECT_ALLOC_BIT = (((jlong)1) << (JVMTI_EVENT_SAMPLED_OBJECT_ALLOC - TOTAL_MIN_EVENT_TYPE_VAL));
-static const jlong  VTHREAD_SCHEDULED_BIT = (((jlong)1) << (JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED - TOTAL_MIN_EVENT_TYPE_VAL));
-static const jlong  VTHREAD_TERMINATED_BIT = (((jlong)1) << (JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED - TOTAL_MIN_EVENT_TYPE_VAL));
+static const jlong  VTHREAD_START_BIT = (((jlong)1) << (JVMTI_EVENT_VIRTUAL_THREAD_START - TOTAL_MIN_EVENT_TYPE_VAL));
+static const jlong  VTHREAD_END_BIT = (((jlong)1) << (JVMTI_EVENT_VIRTUAL_THREAD_END - TOTAL_MIN_EVENT_TYPE_VAL));
 static const jlong  VTHREAD_MOUNTED_BIT = (((jlong)1) << (JVMTI_EVENT_VIRTUAL_THREAD_MOUNTED - TOTAL_MIN_EVENT_TYPE_VAL));
 static const jlong  VTHREAD_UNMOUNTED_BIT = (((jlong)1) << (JVMTI_EVENT_VIRTUAL_THREAD_UNMOUNTED - TOTAL_MIN_EVENT_TYPE_VAL));
 
 // bits for extension events
 static const jlong  CLASS_UNLOAD_BIT = (((jlong)1) << (EXT_EVENT_CLASS_UNLOAD - TOTAL_MIN_EVENT_TYPE_VAL));
 
 
-static const jlong  VTHREAD_BITS = VTHREAD_SCHEDULED_BIT | VTHREAD_TERMINATED_BIT | VTHREAD_MOUNTED_BIT | VTHREAD_UNMOUNTED_BIT;
+static const jlong  VTHREAD_BITS = VTHREAD_START_BIT | VTHREAD_END_BIT | VTHREAD_MOUNTED_BIT | VTHREAD_UNMOUNTED_BIT;
 static const jlong  MONITOR_BITS = MONITOR_CONTENDED_ENTER_BIT | MONITOR_CONTENDED_ENTERED_BIT |
                           MONITOR_WAIT_BIT | MONITOR_WAITED_BIT;
 static const jlong  EXCEPTION_BITS = EXCEPTION_THROW_BIT | EXCEPTION_CATCH_BIT;
@@ -673,8 +673,8 @@ JvmtiEventControllerPrivate::recompute_enabled() {
     JvmtiExport::set_should_post_compiled_method_unload((any_env_thread_enabled & COMPILED_METHOD_UNLOAD_BIT) != 0);
     JvmtiExport::set_should_post_vm_object_alloc((any_env_thread_enabled & VM_OBJECT_ALLOC_BIT) != 0);
     JvmtiExport::set_should_post_sampled_object_alloc((any_env_thread_enabled & SAMPLED_OBJECT_ALLOC_BIT) != 0);
-    JvmtiExport::set_should_post_vthread_scheduled((any_env_thread_enabled & VTHREAD_SCHEDULED_BIT) != 0);
-    JvmtiExport::set_should_post_vthread_terminated((any_env_thread_enabled & VTHREAD_TERMINATED_BIT) != 0);
+    JvmtiExport::set_should_post_vthread_start((any_env_thread_enabled & VTHREAD_START_BIT) != 0);
+    JvmtiExport::set_should_post_vthread_end((any_env_thread_enabled & VTHREAD_END_BIT) != 0);
     JvmtiExport::set_should_post_vthread_mounted((any_env_thread_enabled & VTHREAD_MOUNTED_BIT) != 0);
     JvmtiExport::set_should_post_vthread_unmounted((any_env_thread_enabled & VTHREAD_UNMOUNTED_BIT) != 0);
 

src/hotspot/share/prims/jvmtiExport.cpp

@@ -1283,8 +1283,8 @@ bool              JvmtiExport::_should_post_resource_exhausted            = fals
 bool              JvmtiExport::_should_post_vm_object_alloc               = false;
 bool              JvmtiExport::_should_post_sampled_object_alloc          = false;
 bool              JvmtiExport::_should_post_on_exceptions                 = false;
-bool              JvmtiExport::_should_post_vthread_scheduled             = false;
-bool              JvmtiExport::_should_post_vthread_terminated            = false;
+bool              JvmtiExport::_should_post_vthread_start                 = false;
+bool              JvmtiExport::_should_post_vthread_end                   = false;
 bool              JvmtiExport::_should_post_vthread_mounted               = false;
 bool              JvmtiExport::_should_post_vthread_unmounted             = false;
 
@@ -1471,7 +1471,7 @@ void JvmtiExport::post_thread_start(JavaThread *thread) {
         EVT_TRACE(JVMTI_EVENT_THREAD_START, ("[%s] Evt Thread Start event sent",
                      JvmtiTrace::safe_get_thread_name(thread) ));
 
-        JvmtiThreadEventMark jem(thread);
+        JvmtiVirtualThreadEventMark jem(thread);
         JvmtiJavaThreadEventTransition jet(thread);
         jvmtiEventThreadStart callback = env->callbacks()->ThreadStart;
         if (callback != NULL) {
@@ -1509,7 +1509,7 @@ void JvmtiExport::post_thread_end(JavaThread *thread) {
         EVT_TRACE(JVMTI_EVENT_THREAD_END, ("[%s] Evt Thread End event sent",
                      JvmtiTrace::safe_get_thread_name(thread) ));
 
-        JvmtiThreadEventMark jem(thread);
+        JvmtiVirtualThreadEventMark jem(thread);
         JvmtiJavaThreadEventTransition jet(thread);
         jvmtiEventThreadEnd callback = env->callbacks()->ThreadEnd;
         if (callback != NULL) {
@@ -1521,32 +1521,32 @@ void JvmtiExport::post_thread_end(JavaThread *thread) {
 }
 
 
-void JvmtiExport::post_vthread_scheduled(jobject vthread) {
+void JvmtiExport::post_vthread_start(jobject vthread) {
   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
     return;
   }
-  EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, ("[%p] Trg Virtual Thread Scheduled event triggered", vthread));
+  EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_START, ("[%p] Trg Virtual Thread Start event triggered", vthread));
 
   JavaThread *cur_thread = JavaThread::current();
   JvmtiThreadState *state = cur_thread->jvmti_thread_state();
   if (state == NULL) {
     return;
   }
 
-  if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED)) {
+  if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_START)) {
     JvmtiEnvThreadStateIterator it(state);
 
     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
       JvmtiEnv *env = ets->get_env();
       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
         continue;
       }
-      if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED)) {
-        EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, ("[%p] Evt Virtual Thread Scheduled event sent", vthread));
+      if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_START)) {
+        EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_START, ("[%p] Evt Virtual Thread Start event sent", vthread));
 
         JvmtiVirtualThreadEventMark jem(cur_thread);
         JvmtiJavaThreadEventTransition jet(cur_thread);
-        jvmtiEventVirtualThreadScheduled callback = env->callbacks()->VirtualThreadScheduled;
+        jvmtiEventVirtualThreadStart callback = env->callbacks()->VirtualThreadStart;
         if (callback != NULL) {
           (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());
         }
@@ -1555,32 +1555,32 @@ void JvmtiExport::post_vthread_scheduled(jobject vthread) {
   }
 }
 
-void JvmtiExport::post_vthread_terminated(jobject vthread) {
+void JvmtiExport::post_vthread_end(jobject vthread) {
   if (JvmtiEnv::get_phase() < JVMTI_PHASE_PRIMORDIAL) {
     return;
   }
-  EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED, ("[%p] Trg Virtual Thread Terminated event triggered", vthread));
+  EVT_TRIG_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_END, ("[%p] Trg Virtual Thread End event triggered", vthread));
 
   JavaThread *cur_thread = JavaThread::current();
   JvmtiThreadState *state = cur_thread->jvmti_thread_state();
   if (state == NULL) {
     return;
   }
 
-  if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED)) {
+  if (state->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_END)) {
     JvmtiEnvThreadStateIterator it(state);
 
     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
       JvmtiEnv *env = ets->get_env();
       if (env->phase() == JVMTI_PHASE_PRIMORDIAL) {
         continue;
       }
-      if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED)) {
-        EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED, ("[%p] Evt Virtual Thread Terminated event sent", vthread));
+      if (ets->is_enabled(JVMTI_EVENT_VIRTUAL_THREAD_END)) {
+        EVT_TRACE(JVMTI_EVENT_VIRTUAL_THREAD_END, ("[%p] Evt Virtual Thread End event sent", vthread));
 
         JvmtiVirtualThreadEventMark jem(cur_thread);
         JvmtiJavaThreadEventTransition jet(cur_thread);
-        jvmtiEventVirtualThreadTerminated callback = env->callbacks()->VirtualThreadTerminated;
+        jvmtiEventVirtualThreadEnd callback = env->callbacks()->VirtualThreadEnd;
         if (callback != NULL) {
           (*callback)(env->jvmti_external(), jem.jni_env(), vthread);
         }

src/hotspot/share/prims/jvmtiExport.hpp

@@ -132,8 +132,8 @@ class JvmtiExport : public AllStatic {
   JVMTI_SUPPORT_FLAG(should_post_vm_object_alloc)
   JVMTI_SUPPORT_FLAG(should_post_sampled_object_alloc)
 
-  JVMTI_SUPPORT_FLAG(should_post_vthread_scheduled)
-  JVMTI_SUPPORT_FLAG(should_post_vthread_terminated)
+  JVMTI_SUPPORT_FLAG(should_post_vthread_start)
+  JVMTI_SUPPORT_FLAG(should_post_vthread_end)
   JVMTI_SUPPORT_FLAG(should_post_vthread_mounted)
   JVMTI_SUPPORT_FLAG(should_post_vthread_unmounted)
 
@@ -342,8 +342,8 @@ class JvmtiExport : public AllStatic {
   static void post_thread_start          (JavaThread *thread) NOT_JVMTI_RETURN;
   static void post_thread_end            (JavaThread *thread) NOT_JVMTI_RETURN;
 
-  static void post_vthread_scheduled     (jthread vthread) NOT_JVMTI_RETURN;
-  static void post_vthread_terminated    (jthread vthread) NOT_JVMTI_RETURN;
+  static void post_vthread_start         (jthread vthread) NOT_JVMTI_RETURN;
+  static void post_vthread_end           (jthread vthread) NOT_JVMTI_RETURN;
   static void post_vthread_mounted       (jthread vthread) NOT_JVMTI_RETURN;
   static void post_vthread_unmounted     (jthread vthread) NOT_JVMTI_RETURN;
 

src/jdk.jdwp.agent/share/native/libjdwp/error_messages.c

@@ -239,8 +239,8 @@ eventText(int i)
         CASE_RETURN_TEXT(EI_VM_INIT)
         CASE_RETURN_TEXT(EI_VM_DEATH)
         CASE_RETURN_TEXT(EI_GC_FINISH)
-        CASE_RETURN_TEXT(EI_VIRTUAL_THREAD_SCHEDULED)
-        CASE_RETURN_TEXT(EI_VIRTUAL_THREAD_TERMINATED)
+        CASE_RETURN_TEXT(EI_VIRTUAL_THREAD_START)
+        CASE_RETURN_TEXT(EI_VIRTUAL_THREAD_END)
         default: return "EVENT_unknown";
     }
 }

src/jdk.jdwp.agent/share/native/libjdwp/eventFilter.c

@@ -1289,8 +1289,8 @@ enableEvents(HandlerNode *node)
         case EI_VM_DEATH:
         case EI_CLASS_PREPARE:
         case EI_GC_FINISH:
-        case EI_VIRTUAL_THREAD_SCHEDULED:
-        case EI_VIRTUAL_THREAD_TERMINATED:
+        case EI_VIRTUAL_THREAD_START:
+        case EI_VIRTUAL_THREAD_END:
             return error;
 
         case EI_FIELD_ACCESS:
@@ -1350,8 +1350,8 @@ disableEvents(HandlerNode *node)
         case EI_VM_DEATH:
         case EI_CLASS_PREPARE:
         case EI_GC_FINISH:
-        case EI_VIRTUAL_THREAD_SCHEDULED:
-        case EI_VIRTUAL_THREAD_TERMINATED:
+        case EI_VIRTUAL_THREAD_START:
+        case EI_VIRTUAL_THREAD_END:
             return error;
 
         case EI_FIELD_ACCESS:

src/jdk.jdwp.agent/share/native/libjdwp/eventHandler.c

@@ -650,21 +650,21 @@ filterAndAddVThread(JNIEnv *env, EventInfo *evinfo, EventIndex ei, jbyte eventSe
         if (gdata->fakeVThreadStartEvent) {
             /* vthread fixme: this shouldn't be needed if ei == EI_THREAD_START. */
             /*
-             * When the VIRTUAL_THREAD_SCHEDULED event arrived for this vthread, we ignored it since we don't
+             * When the VIRTUAL_THREAD_START event arrived for this vthread, we ignored it since we don't
              * want to notify the debugger about vthreads until there is a non-vthread event that
              * arrives on it (like a breakpoint). Now that this has happened, we need to send
-             * a VIRTUAL_THREAD_SCHEDULED event (which will be converted into a THREAD_START event) so
+             * a VIRTUAL_THREAD_START event (which will be converted into a THREAD_START event) so
              * the debugger will know about the vthread. Otherwise it will be unhappy when it gets
              * an event for a vthread that it never got a THREAD_START event for.
              */
             EventInfo info;
             struct bag *eventBag = eventHelper_createEventBag();
 
             (void)memset(&info,0,sizeof(info));
-            info.ei         = EI_VIRTUAL_THREAD_SCHEDULED;
+            info.ei         = EI_VIRTUAL_THREAD_START;
             info.thread     = vthread;
 
-            /* Note: filterAndHandleEvent() expects EI_THREAD_START instead of EI_VIRTUAL_THREAD_SCHEDULED
+            /* Note: filterAndHandleEvent() expects EI_THREAD_START instead of EI_VIRTUAL_THREAD_START
              * in order for getHandlerChain(ei) to work properly. */
             filterAndHandleEvent(env, &info, EI_THREAD_START, eventBag, eventSessionID);
             JDI_ASSERT(bagSize(eventBag) == 0);
@@ -777,11 +777,11 @@ event_callback(JNIEnv *env, EventInfo *evinfo)
         }
     }
 
-    /* We want the vthread scheduled/terminated events to mimic thread start/end events */
-    if (ei == EI_VIRTUAL_THREAD_SCHEDULED) {
+    /* We want the vthread start/end events to mimic thread start/end events */
+    if (ei == EI_VIRTUAL_THREAD_START) {
         ei = EI_THREAD_START;
     }
-    if (ei == EI_VIRTUAL_THREAD_TERMINATED) {
+    if (ei == EI_VIRTUAL_THREAD_END) {
         ei = EI_THREAD_END;
     }
 
@@ -1420,15 +1420,14 @@ cbVMDeath(jvmtiEnv *jvmti_env, JNIEnv *env)
     LOG_MISC(("END cbVMDeath"));
 }
 
-/* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED */
+/* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_START */
 static void JNICALL
-cbVThreadScheduled(jvmtiEnv *jvmti_env, JNIEnv *env,
-                   jthread vthread)
+cbVThreadStart(jvmtiEnv *jvmti_env, JNIEnv *env, jthread vthread)
 {
     EventInfo info;
 
-    LOG_CB(("cbVThreadScheduled: vthread=%p", vthread));
-    /*tty_message("cbVThreadScheduled: vthread=%p", vthread);*/
+    LOG_CB(("cbVThreadStart: vthread=%p", vthread));
+    /*tty_message("cbVThreadStart: vthread=%p", vthread);*/
     JDI_ASSERT(gdata->vthreadsSupported);
 
     /*
@@ -1456,7 +1455,7 @@ cbVThreadScheduled(jvmtiEnv *jvmti_env, JNIEnv *env,
         }
     }
 
-    /* Ignore VIRTUAL_THREAD_SCHEDULED events unless we are notifying the debugger of all vthreads. */
+    /* Ignore VIRTUAL_THREAD_START events unless we are notifying the debugger of all vthreads. */
     if (!gdata->trackAllVThreads || !gdata->enumerateVThreads) {
         return;
     }
@@ -1468,19 +1467,18 @@ cbVThreadScheduled(jvmtiEnv *jvmti_env, JNIEnv *env,
         event_callback(env, &info);
     } END_CALLBACK();
 
-    LOG_MISC(("END cbVThreadScheduled"));
+    LOG_MISC(("END cbVThreadStart"));
 }
 
-/* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED */
+/* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_END */
 static void JNICALL
-cbVThreadTerminated(jvmtiEnv *jvmti_env, JNIEnv *env,
-                    jthread vthread)
+cbVThreadEnd(jvmtiEnv *jvmti_env, JNIEnv *env, jthread vthread)
 {
 
     EventInfo info;
 
-    LOG_CB(("cbVThreadTerminated: vthread=%p", vthread));
-    /*tty_message("cbVThreadTerminated: vthread=%p", vthread);*/
+    LOG_CB(("cbVThreadEnd: vthread=%p", vthread));
+    /*tty_message("cbVThreadEnd: vthread=%p", vthread);*/
     JDI_ASSERT(gdata->vthreadsSupported);
 
     BEGIN_CALLBACK() {
@@ -1490,7 +1488,7 @@ cbVThreadTerminated(jvmtiEnv *jvmti_env, JNIEnv *env,
         event_callback(env, &info);
     } END_CALLBACK();
 
-    LOG_MISC(("END cbVThreadTerminated"));
+    LOG_MISC(("END cbVThreadEnd"));
 }
 
 /**
@@ -1684,14 +1682,14 @@ eventHandler_initialize(jbyte sessionID)
     /* Only enable vthread events if vthread support is enabled. */
     if (gdata->vthreadsSupported) {
         error = threadControl_setEventMode(JVMTI_ENABLE,
-                                           EI_VIRTUAL_THREAD_SCHEDULED, NULL);
+                                           EI_VIRTUAL_THREAD_START, NULL);
         if (error != JVMTI_ERROR_NONE) {
-            EXIT_ERROR(error,"Can't enable vthread scheduled events");
+            EXIT_ERROR(error,"Can't enable vthread start events");
         }
         error = threadControl_setEventMode(JVMTI_ENABLE,
-                                           EI_VIRTUAL_THREAD_TERMINATED, NULL);
+                                           EI_VIRTUAL_THREAD_END, NULL);
         if (error != JVMTI_ERROR_NONE) {
-            EXIT_ERROR(error,"Can't enable vthread terminated events");
+            EXIT_ERROR(error,"Can't enable vthread end events");
         }
     }
 
@@ -1736,10 +1734,10 @@ eventHandler_initialize(jbyte sessionID)
     gdata->callbacks.VMDeath                    = &cbVMDeath;
     /* Event callback for JVMTI_EVENT_GARBAGE_COLLECTION_FINISH */
     gdata->callbacks.GarbageCollectionFinish    = &cbGarbageCollectionFinish;
-    /* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED */
-    gdata->callbacks.VirtualThreadScheduled     = &cbVThreadScheduled;
-    /* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED */
-    gdata->callbacks.VirtualThreadTerminated    = &cbVThreadTerminated;
+    /* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_START */
+    gdata->callbacks.VirtualThreadStart         = &cbVThreadStart;
+    /* Event callback for JVMTI_EVENT_VIRTUAL_THREAD_END */
+    gdata->callbacks.VirtualThreadEnd           = &cbVThreadEnd;
 
     error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks)
                 (gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks));

src/jdk.jdwp.agent/share/native/libjdwp/eventHelper.c

@@ -435,8 +435,8 @@ handleEventCommandSingle(JNIEnv *env, PacketOutputStream *out,
         case EI_THREAD_END:
             writeThreadEvent(env, out, evinfo);
             break;
-        case EI_VIRTUAL_THREAD_SCHEDULED:
-        case EI_VIRTUAL_THREAD_TERMINATED:
+        case EI_VIRTUAL_THREAD_START:
+        case EI_VIRTUAL_THREAD_END:
             /* Note that when we wrote the evinfo->ei byte above, it was mapped to an EI_THREAD_XXX event
              * by eventIndex2jdwp(), so we didn't actually write the VIRTUAL_THREAD ei byte.
              */

src/jdk.jdwp.agent/share/native/libjdwp/standardHandlers.c

@@ -151,8 +151,8 @@ standardHandlers_defaultHandler(EventIndex ei)
         case EI_MONITOR_CONTENDED_ENTERED:
         case EI_MONITOR_WAIT:
         case EI_MONITOR_WAITED:
-        case EI_VIRTUAL_THREAD_SCHEDULED:
-        case EI_VIRTUAL_THREAD_TERMINATED:
+        case EI_VIRTUAL_THREAD_START:
+        case EI_VIRTUAL_THREAD_END:
             return &genericHandler;
 
         case EI_CLASS_PREPARE:

src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c

@@ -69,7 +69,7 @@ typedef struct ThreadNode {
     unsigned int pendingInterrupt : 1; /* true if thread is interrupted while handling an event. */
     unsigned int isDebugThread : 1;    /* true if this is one of our debug agent threads. */
     unsigned int suspendOnStart : 1;   /* true for new threads if we are currently in a VM.suspend(). */
-    unsigned int isStarted : 1;        /* THREAD_START or VIRTUAL_THREAD_SCHEDULED event received. */
+    unsigned int isStarted : 1;        /* THREAD_START or VIRTUAL_THREAD_START event received. */
     unsigned int is_vthread : 1;
     unsigned int popFrameEvent : 1;
     unsigned int popFrameProceed : 1;

src/jdk.jdwp.agent/share/native/libjdwp/util.c

@@ -1958,8 +1958,8 @@ eventIndexInit(void)
     index2jvmti[EI_MONITOR_WAITED     -EI_min] = JVMTI_EVENT_MONITOR_WAITED;
     index2jvmti[EI_VM_INIT            -EI_min] = JVMTI_EVENT_VM_INIT;
     index2jvmti[EI_VM_DEATH           -EI_min] = JVMTI_EVENT_VM_DEATH;
-    index2jvmti[EI_VIRTUAL_THREAD_SCHEDULED    -EI_min] = JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED;
-    index2jvmti[EI_VIRTUAL_THREAD_TERMINATED   -EI_min] = JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED;
+    index2jvmti[EI_VIRTUAL_THREAD_START -EI_min] = JVMTI_EVENT_VIRTUAL_THREAD_START;
+    index2jvmti[EI_VIRTUAL_THREAD_END   -EI_min] = JVMTI_EVENT_VIRTUAL_THREAD_END;
 
     index2jdwp[EI_SINGLE_STEP         -EI_min] = JDWP_EVENT(SINGLE_STEP);
     index2jdwp[EI_BREAKPOINT          -EI_min] = JDWP_EVENT(BREAKPOINT);
@@ -1981,9 +1981,9 @@ eventIndexInit(void)
     index2jdwp[EI_MONITOR_WAITED      -EI_min] = JDWP_EVENT(MONITOR_WAITED);
     index2jdwp[EI_VM_INIT             -EI_min] = JDWP_EVENT(VM_INIT);
     index2jdwp[EI_VM_DEATH            -EI_min] = JDWP_EVENT(VM_DEATH);
-    /* Just map VIRTUAL_THREAD_SCHEDULED/TERMINATED to THREAD_START/END. */
-    index2jdwp[EI_VIRTUAL_THREAD_SCHEDULED     -EI_min] = JDWP_EVENT(THREAD_START);
-    index2jdwp[EI_VIRTUAL_THREAD_TERMINATED    -EI_min] = JDWP_EVENT(THREAD_END);
+    /* Just map VIRTUAL_THREAD_START/END to THREAD_START/END. */
+    index2jdwp[EI_VIRTUAL_THREAD_START -EI_min] = JDWP_EVENT(THREAD_START);
+    index2jdwp[EI_VIRTUAL_THREAD_END   -EI_min] = JDWP_EVENT(THREAD_END);
 }
 
 jdwpEvent
@@ -2050,10 +2050,10 @@ eventIndex2EventName(EventIndex ei)
             return "EI_VM_INIT";
         case EI_VM_DEATH:
             return "EI_VM_DEATH";
-        case EI_VIRTUAL_THREAD_SCHEDULED:
-            return "EI_VIRTUAL_THREAD_SCHEDULED";
-        case EI_VIRTUAL_THREAD_TERMINATED:
-            return "EI_VIRTUAL_THREAD_TERMINATED";
+        case EI_VIRTUAL_THREAD_START:
+            return "EI_VIRTUAL_THREAD_START";
+        case EI_VIRTUAL_THREAD_END:
+            return "EI_VIRTUAL_THREAD_END";
         default:
             JDI_ASSERT(JNI_FALSE);
             return "Bad EI";
@@ -2168,10 +2168,10 @@ jvmti2EventIndex(jvmtiEvent kind)
         case JVMTI_EVENT_VM_DEATH:
             return EI_VM_DEATH;
         /* vthread events */
-        case JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED:
-            return EI_VIRTUAL_THREAD_SCHEDULED;
-        case JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED:
-            return EI_VIRTUAL_THREAD_TERMINATED;
+        case JVMTI_EVENT_VIRTUAL_THREAD_START:
+            return EI_VIRTUAL_THREAD_START;
+        case JVMTI_EVENT_VIRTUAL_THREAD_END:
+            return EI_VIRTUAL_THREAD_END;
 
         default:
             EXIT_ERROR(AGENT_ERROR_INVALID_INDEX,"JVMTI to EventIndex mapping");

src/jdk.jdwp.agent/share/native/libjdwp/util.h

@@ -172,8 +172,8 @@ typedef enum {
         EI_MONITOR_WAITED       = 18,
         EI_VM_INIT              = 19,
         EI_VM_DEATH             = 20,
-        EI_VIRTUAL_THREAD_SCHEDULED  = 21,
-        EI_VIRTUAL_THREAD_TERMINATED = 22,
+        EI_VIRTUAL_THREAD_START = 21,
+        EI_VIRTUAL_THREAD_END   = 22,
 
         EI_max                  = 22
 } EventIndex;

test/hotspot/jtreg/serviceability/jvmti/stress/ThreadLocalStorage/SetGetThreadLocalStorageStressTest/libSetGetThreadLocalStorageStress.cpp

@@ -202,18 +202,18 @@ MethodEntry(jvmtiEnv *jvmti, JNIEnv* jni, jthread thread, jmethodID method) {
 */
 
 static void JNICALL
-VirtualThreadScheduled(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
+VirtualThreadStart(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
   RawMonitorLocker rml(jvmti, jni, monitor);
   if (is_vm_running) {
-    check_reset_tls(jvmti, jni, vthread, "VirtualThreadScheduled");
+    check_reset_tls(jvmti, jni, vthread, "VirtualThreadStart");
   }
 }
 
 static void JNICALL
-VirtualThreadTerminated(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
+VirtualThreadEnd(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
   RawMonitorLocker rml(jvmti, jni, monitor);
   if (is_vm_running) {
-    check_reset_tls(jvmti, jni, vthread, "VirtualThreadTerminated");
+    check_reset_tls(jvmti, jni, vthread, "VirtualThreadEnd");
   }
 }
 
@@ -261,9 +261,9 @@ jint Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
   callbacks.VMDeath = &VMDeath;
   callbacks.ThreadStart = &ThreadStart;
   callbacks.ThreadEnd = &ThreadEnd;
- // callbacks.MethodEntry = &MethodEntry;
-  callbacks.VirtualThreadScheduled = &VirtualThreadScheduled;
-  callbacks.VirtualThreadTerminated = &VirtualThreadTerminated;
+  // callbacks.MethodEntry = &MethodEntry;
+  callbacks.VirtualThreadStart = &VirtualThreadStart;
+  callbacks.VirtualThreadEnd = &VirtualThreadEnd;
 
   err = jvmti->SetEventCallbacks(&callbacks, sizeof(callbacks));
   if (err != JVMTI_ERROR_NONE) {
@@ -273,8 +273,8 @@ jint Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
   jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, NULL);
   jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_THREAD_START, NULL);
   jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_THREAD_END, NULL);
-  jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, NULL);
-  jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED, NULL);
+  jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_START, NULL);
+  jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_END, NULL);
 
   //jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_METHOD_ENTRY, NULL);
 

test/hotspot/jtreg/serviceability/jvmti/vthread/BreakpointInYieldTest/libBreakpointInYieldTest.cpp

@@ -115,13 +115,13 @@ ThreadStart(jvmtiEnv *jvmti, JNIEnv* jni, jthread thread) {
 }
 
 static void JNICALL
-VirtualThreadScheduled(jvmtiEnv *jvmti, JNIEnv* jni, jthread thread) {
+VirtualThreadStart(jvmtiEnv *jvmti, JNIEnv* jni, jthread thread) {
   char* tname = get_thread_name(jvmti, jni, thread);
   const char* virt = jni->IsVirtualThread(thread) ? "virtual" : "carrier";
 
   {
     RawMonitorLocker rml(jvmti, jni, event_mon);
-    printf("\nVirtualThreadScheduled: %s, thread: %s\n", virt, tname);
+    printf("\nVirtualThreadStart: %s, thread: %s\n", virt, tname);
     fflush(0);
   }
 
@@ -174,7 +174,7 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
   memset(&callbacks, 0, sizeof(callbacks));
   callbacks.Breakpoint  = &Breakpoint;
   callbacks.ThreadStart = &ThreadStart;
-  callbacks.VirtualThreadScheduled = &VirtualThreadScheduled;
+  callbacks.VirtualThreadStart     = &VirtualThreadStart;
   callbacks.VirtualThreadMounted   = &VirtualThreadMounted;
   callbacks.VirtualThreadUnmounted = &VirtualThreadUnmounted;
 
@@ -206,7 +206,7 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
     return JNI_ERR;
   }
 
-  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, NULL);
+  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_START, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
   }

test/hotspot/jtreg/serviceability/jvmti/vthread/DoContinueSingleStepTest/libDoContinueSingleStepTest.cpp

@@ -386,15 +386,15 @@ FramePop(jvmtiEnv *jvmti, JNIEnv* jni, jthread thread, jmethodID method,
 }
 
 static void JNICALL
-VirtualThreadScheduled(jvmtiEnv *jvmti, JNIEnv* jni, jthread vthread) {
+VirtualThreadStart(jvmtiEnv *jvmti, JNIEnv* jni, jthread vthread) {
   RawMonitorLocker rml(jvmti, jni, event_mon);
-  //processFiberEvent(jvmti, jni, vthread, "VirtualThreadScheduled");
+  //processFiberEvent(jvmti, jni, vthread, "VirtualThreadStart");
 }
 
 static void JNICALL
-VirtualThreadTerminated(jvmtiEnv *jvmti, JNIEnv* jni, jthread vthread) {
+VirtualThreadEnd(jvmtiEnv *jvmti, JNIEnv* jni, jthread vthread) {
   RawMonitorLocker rml(jvmti, jni, event_mon);
-  //processFiberEvent(jvmti, jni, vthread, "VirtualThreadTerminated");
+  //processFiberEvent(jvmti, jni, vthread, "VirtualThreadEnd");
 }
 
 static void JNICALL
@@ -425,9 +425,9 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
   callbacks.SingleStep  = &SingleStep;
   callbacks.FramePop    = &FramePop;
   callbacks.MethodEntry = &MethodEntry;
-  callbacks.MethodExit = &MethodExit;
-  callbacks.VirtualThreadScheduled  = &VirtualThreadScheduled;
-  callbacks.VirtualThreadTerminated = &VirtualThreadTerminated;
+  callbacks.MethodExit  = &MethodExit;
+  callbacks.VirtualThreadStart     = &VirtualThreadStart;
+  callbacks.VirtualThreadEnd       = &VirtualThreadEnd;
   callbacks.VirtualThreadMounted   = &VirtualThreadMounted;
   callbacks.VirtualThreadUnmounted = &VirtualThreadUnmounted;
 
@@ -454,12 +454,12 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
   }
 
-  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, NULL);
+  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_START, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
   }
 
-  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED, NULL);
+  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_END, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
   }

test/hotspot/jtreg/serviceability/jvmti/vthread/MethodExitTest/libMethodExitTest.cpp

@@ -398,15 +398,15 @@ ThreadStart(jvmtiEnv *jvmti, JNIEnv* jni, jthread cthread) {
 }
 
 static void JNICALL
-VirtualThreadScheduled(jvmtiEnv *jvmti, JNIEnv* jni, jthread vthread) {
+VirtualThreadStart(jvmtiEnv *jvmti, JNIEnv* jni, jthread vthread) {
   char* tname = get_thread_name(jvmti, jni, vthread);
   jvmtiError err;
   jboolean is_virtual = jni->IsVirtualThread(vthread);
   const char* virt = is_virtual == JNI_TRUE ? "virtual" : "carrier";
 
   RawMonitorLocker rml(jvmti, jni, event_mon);
 
-  printf("\nVirtualThreadScheduled: %s thread: %p, name: %s\n", virt, (void*)vthread, tname);
+  printf("\nVirtualThreadStart: %s thread: %p, name: %s\n", virt, (void*)vthread, tname);
 
   // Test SetThreadLocalStorage for virtual thread.
   err = jvmti->SetThreadLocalStorage(vthread, (void*)222);
@@ -495,7 +495,7 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
   callbacks.MethodEntry = &MethodEntry;
   callbacks.MethodExit  = &MethodExit;
   callbacks.ThreadStart = &ThreadStart;
-  callbacks.VirtualThreadScheduled = &VirtualThreadScheduled;
+  callbacks.VirtualThreadStart     = &VirtualThreadStart;
   callbacks.VirtualThreadMounted   = &VirtualThreadMounted;
   callbacks.VirtualThreadUnmounted = &VirtualThreadUnmounted;
 
@@ -526,7 +526,7 @@ Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
   }
 
-  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, NULL);
+  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_START, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
   }

test/hotspot/jtreg/serviceability/jvmti/vthread/SuspendResumeAll/libSuspendResumeAll.cpp

@@ -413,7 +413,7 @@ agent_proc(jvmtiEnv* jvmti, JNIEnv* jni, void* arg) {
 }
 
 static void JNICALL
-VirtualThreadScheduled(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
+VirtualThreadStart(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
   RawMonitorLocker agent_start_locker(jvmti, jni, agent_event_lock);
 
   tested_vthreads[vthread_no++] = jni->NewGlobalRef(vthread);
@@ -459,7 +459,7 @@ jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
   }
 
   memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.VirtualThreadScheduled = &VirtualThreadScheduled;
+  callbacks.VirtualThreadStart = &VirtualThreadStart;
 
   err = jvmti->SetEventCallbacks(&callbacks, sizeof(jvmtiEventCallbacks));
   if (err != JVMTI_ERROR_NONE) {
@@ -470,7 +470,7 @@ jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
   }
 
   err = jvmti->SetEventNotificationMode(JVMTI_ENABLE,
-                                        JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, NULL);
+                                        JVMTI_EVENT_VIRTUAL_THREAD_START, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("Agent init: error in JVMTI SetEventNotificationMode: %s (%d)\n",
            TranslateError(err), err);

test/hotspot/jtreg/serviceability/jvmti/vthread/VThreadTest/libVThreadTest.cpp

@@ -94,11 +94,11 @@ print_vthread_event_info(jvmtiEnv *jvmti, JNIEnv *jni, jthread thread, jthread v
 
   printf("\n#### %s event: thread: %s, vthread: %p\n", event_name, tname, vthread);
 
-  if (strcmp(event_name, "VirtualThreadScheduled") == 0) {
+  if (strcmp(event_name, "VirtualThreadStart") == 0) {
     inf->just_scheduled = JNI_TRUE;
   }
   else {
-    if (inf->tname == NULL && strcmp(event_name, "VirtualThreadTerminated") != 0) {
+    if (inf->tname == NULL && strcmp(event_name, "VirtualThreadEnd") != 0) {
       fatal(jni, "VThread event: worker thread not found!");
     }
     if (strcmp(event_name, "VirtualThreadUnmounted") == 0) {
@@ -480,8 +480,8 @@ processVThreadEvent(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread, const char *e
   jthread cthread = NULL;
   jvmtiError err;
 
-  if (strcmp(event_name, "VirtualThreadTerminated") != 0 &&
-      strcmp(event_name, "VirtualThreadScheduled")  != 0) {
+  if (strcmp(event_name, "VirtualThreadEnd") != 0 &&
+      strcmp(event_name, "VirtualThreadStart")  != 0) {
     if (vthread_events_cnt++ > MAX_EVENTS_TO_PROCESS) {
       return; // No need to test all events
     }
@@ -495,16 +495,16 @@ processVThreadEvent(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread, const char *e
 
   deallocate(jvmti, jni, (void*)tname);
 
-  if (strcmp(event_name, "VirtualThreadTerminated") == 0) {
+  if (strcmp(event_name, "VirtualThreadEnd") == 0) {
     return; // skip further testing as GetVirtualThread can return NULL
   }
 
   test_GetVirtualThread(jvmti, jni, cthread, vthread, event_name);
   test_GetCarrierThread(jvmti, jni, cthread, vthread, event_name);
 
-  if (strcmp(event_name, "VirtualThreadScheduled") == 0) {
+  if (strcmp(event_name, "VirtualThreadStart") == 0) {
     test_GetThreadInfo(jvmti, jni, vthread, event_name);
-    return; // skip testing of GetFrame* for VirtualThreadScheduled events
+    return; // skip testing of GetFrame* for VirtualThreadStart events
   }
   jint frame_count = test_GetFrameCount(jvmti, jni, vthread, event_name);
   test_GetFrameLocation(jvmti, jni, vthread, event_name, frame_count);
@@ -513,15 +513,15 @@ processVThreadEvent(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread, const char *e
 }
 
 static void JNICALL
-VirtualThreadScheduled(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
+VirtualThreadStart(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
   RawMonitorLocker rml(jvmti, jni, events_monitor);
-  processVThreadEvent(jvmti, jni, vthread, "VirtualThreadScheduled");
+  processVThreadEvent(jvmti, jni, vthread, "VirtualThreadStart");
 }
 
 static void JNICALL
-VirtualThreadTerminated(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
+VirtualThreadEnd(jvmtiEnv *jvmti, JNIEnv *jni, jthread vthread) {
   RawMonitorLocker rml(jvmti, jni, events_monitor);
-  processVThreadEvent(jvmti, jni, vthread, "VirtualThreadTerminated");
+  processVThreadEvent(jvmti, jni, vthread, "VirtualThreadEnd");
 }
 
 static void JNICALL
@@ -549,8 +549,8 @@ Agent_OnLoad(JavaVM *jvm, char *options,
   }
 
   memset(&callbacks, 0, sizeof(callbacks));
-  callbacks.VirtualThreadScheduled = &VirtualThreadScheduled;
-  callbacks.VirtualThreadTerminated = &VirtualThreadTerminated;
+  callbacks.VirtualThreadStart = &VirtualThreadStart;
+  callbacks.VirtualThreadEnd = &VirtualThreadEnd;
   callbacks.VirtualThreadMounted = &VirtualThreadMounted;
   callbacks.VirtualThreadUnmounted = &VirtualThreadUnmounted;
 
@@ -570,13 +570,13 @@ Agent_OnLoad(JavaVM *jvm, char *options,
     return JNI_ERR;
   }
 
-  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_SCHEDULED, NULL);
+  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_START, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
     return JNI_ERR;
   }
 
-  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_TERMINATED, NULL);
+  err = jvmti->SetEventNotificationMode(JVMTI_ENABLE, JVMTI_EVENT_VIRTUAL_THREAD_END, NULL);
   if (err != JVMTI_ERROR_NONE) {
     printf("error in JVMTI SetEventNotificationMode: %d\n", err);
     return JNI_ERR;