Refactor: JVM implementation separation and JVMThread abstraction (#435)

Author: zhengyu123

ddprof-lib/src/main/cpp/ctimer_linux.cpp

@@ -1,6 +1,6 @@
 /*
  * Copyright 2023 Andrei Pangin
- * Copyright 2025, Datadog, Inc.
+ * Copyright 2025, 2026, Datadog, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,7 +23,6 @@
 #include "libraries.h"
 #include "profiler.h"
 #include "threadState.inline.h"
-#include "vmStructs.h"
 #include <assert.h>
 #include <stdlib.h>
 #include <sys/syscall.h>

ddprof-lib/src/main/cpp/flightRecorder.cpp

@@ -26,7 +26,7 @@
 #include "threadFilter.h"
 #include "threadState.h"
 #include "tsc.h"
-#include "vmStructs.h"
+#include "hotspot/vmStructs.h"
 #include <arpa/inet.h>
 #include <cxxabi.h>
 #include <errno.h>

ddprof-lib/src/main/cpp/vmStructs.cpp …f-lib/src/main/cpp/hotspot/vmStructs.cppddprof-lib/src/main/cpp/vmStructs.cpp renamed to ddprof-lib/src/main/cpp/hotspot/vmStructs.cpp ddprof-lib/src/main/cpp/vmStructs.cpp renamed to ddprof-lib/src/main/cpp/hotspot/vmStructs.cpp

@@ -1,20 +1,21 @@
 /*
  * Copyright The async-profiler authors
+ * Copyright 2025, 2026 Datadog, Inc
  * SPDX-License-Identifier: Apache-2.0
  */
 
 #include <pthread.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdarg.h>
-#include "vmStructs.h"
+#include "hotspot/vmStructs.inline.h"
 #include "vmEntry.h"
-#include "j9Ext.h"
 #include "jniHelper.h"
 #include "jvmHeap.h"
+#include "jvmThread.h"
 #include "safeAccess.h"
 #include "spinLock.h"
-#include "common.h"
+#include "threadState.h"
 
 CodeCache* VMStructs::_libjvm = nullptr;
 bool VMStructs::_has_class_names = false;
@@ -79,11 +80,8 @@ DECLARE_LONG_CONSTANTS_DO(INIT_LONG_CONSTANT, INIT_LONG_CONSTANT)
 #undef INIT_INT_CONSTANT
 #undef INIT_LONG_CONSTANT
 
-
-jfieldID VMStructs::_eetop;
-jfieldID VMStructs::_tid;
+jfieldID VMStructs::_eetop = NULL;
 jfieldID VMStructs::_klass = NULL;
-int VMStructs::_tls_index = -1;
 intptr_t VMStructs::_env_offset = -1;
 void* VMStructs::_java_thread_vtbl[6];
 
@@ -122,7 +120,6 @@ void VMStructs::init(CodeCache* libjvm) {
 void VMStructs::ready() {
     resolveOffsets();
     patchSafeFetch();
-    initThreadBridge();
 }
 
 bool matchAny(const char* target_name, std::initializer_list<const char*> names) {
@@ -482,51 +479,6 @@ void VMStructs::patchSafeFetch() {
     }
 }
 
-void VMStructs::initTLS(void* vm_thread) {
-    for (int i = 0; i < 1024; i++) {
-        if (pthread_getspecific((pthread_key_t)i) == vm_thread) {
-            _tls_index = i;
-            break;
-        }
-    }
-}
-
-void VMStructs::initThreadBridge() {
-    jthread thread;
-    if (VM::jvmti()->GetCurrentThread(&thread) != 0) {
-        return;
-    }
-
-    JNIEnv* env = VM::jni();
-    jclass thread_class = env->FindClass("java/lang/Thread");
-    if (thread_class == NULL || (_tid = env->GetFieldID(thread_class, "tid", "J")) == NULL) {
-        env->ExceptionClear();
-        return;
-    }
-
-    if (VM::isOpenJ9()) {
-        void* j9thread = J9Ext::j9thread_self();
-        if (j9thread != NULL) {
-            initTLS(j9thread);
-        }
-    } else {
-        // Get eetop field - a bridge from Java Thread to VMThread
-        if ((_eetop = env->GetFieldID(thread_class, "eetop", "J")) == NULL) {
-            // No such field - probably not a HotSpot JVM
-            env->ExceptionClear();
-            return;
-        }
-
-        VMThread* vm_thread = VMThread::fromJavaThread(env, thread);
-        if (vm_thread != NULL) {
-            _has_native_thread_id = _thread_osthread_offset >= 0 && _osthread_id_offset >= 0;
-            initTLS(vm_thread);
-            _env_offset = (intptr_t)env - (intptr_t)vm_thread;
-            memcpy(_java_thread_vtbl, vm_thread->vtable(), sizeof(_java_thread_vtbl));
-        }
-    }
-}
-
 // ===== Datadog-specific VMStructs extensions =====
 
 void VMStructs::initUnsafeFunctions() {
@@ -654,16 +606,89 @@ void VMStructs::checkNativeBinding(jvmtiEnv *jvmti, JNIEnv *jni,
     jvmti->Deallocate((unsigned char *)method_name);
 }
 
-VMThread* VMThread::current() {
-    return _tls_index >= 0 ? (VMThread*)pthread_getspecific((pthread_key_t)_tls_index) : NULL;
-}
+void* VMThread::initialize(jthread thread) {
+    JNIEnv* env = VM::jni();
+    jclass thread_class = env->FindClass("java/lang/Thread");
+    if (thread_class == NULL) {
+        env->ExceptionClear();
+        return nullptr;
+    }
 
-int VMThread::nativeThreadId(JNIEnv* jni, jthread thread) {
-    if (_has_native_thread_id) {
-        VMThread* vm_thread = fromJavaThread(jni, thread);
-        return vm_thread != NULL ? vm_thread->osThreadId() : -1;
+    // Get eetop field - a bridge from Java Thread to VMThread
+    if ((_eetop = env->GetFieldID(thread_class, "eetop", "J")) == NULL) {
+        // No such field - probably not a HotSpot JVM
+        env->ExceptionClear();
+        return nullptr;
     }
-    return VM::isOpenJ9() ? J9Ext::GetOSThreadID(thread) : -1;
+
+    void* vm_thread = fromJavaThread(env, thread);
+    assert(vm_thread != nullptr);
+    _has_native_thread_id = _thread_osthread_offset >= 0 && _osthread_id_offset >= 0;
+    _env_offset = (intptr_t)env - (intptr_t)vm_thread;
+    memcpy(_java_thread_vtbl, VMThread::cast(vm_thread)->vtable(), sizeof(_java_thread_vtbl));
+    return vm_thread;
+}
+
+static ExecutionMode convertJvmExecutionState(int state) {
+  switch (state) {
+  case 4:
+  case 5:
+    return ExecutionMode::NATIVE;
+  case 6:
+  case 7:
+    return ExecutionMode::JVM;
+  case 8:
+  case 9:
+    return ExecutionMode::JAVA;
+  case 10:
+  case 11:
+    return ExecutionMode::SAFEPOINT;
+  default:
+    return ExecutionMode::UNKNOWN;
+  }
+}
+
+ExecutionMode VMThread::getExecutionMode() {
+  assert(VM::isHotspot());
+  
+  VMThread* vm_thread = VMThread::current();
+  // Not a JVM thread - native thread, e.g. thread launched by JNI code
+  if (vm_thread == nullptr) {
+    return ExecutionMode::NATIVE;
+  }
+
+  ProfiledThread *prof_thread = ProfiledThread::currentSignalSafe();
+  bool is_java_thread = prof_thread != nullptr && prof_thread->isJavaThread();
+
+  // A Java thread that JVM tells us via jvmti `ThreadStart()` callback.
+  if (is_java_thread) {
+    int raw_thread_state = vm_thread->state();
+
+    // Java threads: [4, 12) = [_thread_in_native, _thread_max_state)
+    // JVM internal threads: 0 or outside this range
+    is_java_thread = raw_thread_state >= 4 && raw_thread_state < 12;
+
+    return is_java_thread ? convertJvmExecutionState(raw_thread_state)
+                        : ExecutionMode::JVM;
+  } else {
+    // It is a JVM internal thread, may or may not be a Java thread, 
+    // e.g. Compiler thread or GC thread, etc
+    return ExecutionMode::JVM;
+  }
+}
+
+OSThreadState VMThread::getOSThreadState() {
+  VMThread* vm_thread = VMThread::current();
+  if (vm_thread == nullptr) {
+    return OSThreadState::UNKNOWN;
+  }
+  int raw_thread_state = vm_thread->state();
+  bool is_java_thread = raw_thread_state >= 4 && raw_thread_state < 12;
+  OSThreadState state = OSThreadState::UNKNOWN;
+  if (is_java_thread) {
+    state = vm_thread->osThreadState();
+  }
+  return state;
 }
 
 int VMThread::osThreadId() {

ddprof-lib/src/main/cpp/vmStructs.h …rof-lib/src/main/cpp/hotspot/vmStructs.hddprof-lib/src/main/cpp/vmStructs.h renamed to ddprof-lib/src/main/cpp/hotspot/vmStructs.h ddprof-lib/src/main/cpp/vmStructs.h renamed to ddprof-lib/src/main/cpp/hotspot/vmStructs.h

@@ -1,18 +1,20 @@
 /*
  * Copyright The async-profiler authors
- * Copyright 2026 Datadog, Inc
+ * Copyright 2025, 2026 Datadog, Inc
  * SPDX-License-Identifier: Apache-2.0
  */
 
-#ifndef _VMSTRUCTS_H
-#define _VMSTRUCTS_H
+#ifndef _HOTSPOT_VMSTRUCTS_H
+#define _HOTSPOT_VMSTRUCTS_H
 
 #include <initializer_list>
+#include <jni.h>
 #include <jvmti.h>
 #include <stdint.h>
 #include <type_traits>
 #include "codeCache.h"
 #include "counters.h"
+#include "jvmThread.h"
 #include "safeAccess.h"
 #include "thread.h"
 #include "threadState.h"
@@ -31,10 +33,6 @@ class VMNMethod;
 // sending SIGABRT which is uncatchable by crash protection.
 // When crash protection is active the assert is redundant — any bad read will
 // be caught by the SIGSEGV handler and recovered via longjmp — so we skip it.
-//
-// Defined at the bottom of this file after VMThread is declared so that the
-// VMThread fallback path (isExceptionActive) is accessible without forward-
-// declaring the full class.
 inline bool crashProtectionActive();
 
 template <typename T>
@@ -352,9 +350,7 @@ class VMStructs {
 
 
     static jfieldID _eetop;
-    static jfieldID _tid;
     static jfieldID _klass;
-    static int _tls_index;
     static intptr_t _env_offset;
     static void* _java_thread_vtbl[6];
 
@@ -444,10 +440,6 @@ class VMStructs {
         return _has_native_thread_id;
     }
 
-    static bool hasJavaThreadId() {
-        return _tid != NULL;
-    }
-
     static bool isInterpretedFrameValidFunc(const void* pc) {
         return pc >= _interpreted_frame_valid_start && pc < _interpreted_frame_valid_end;
     }
@@ -696,32 +688,24 @@ enum JVMJavaThreadState {
 };
 
 DECLARE(VMThread)
+  friend class JVMThread;
   public:
-    static VMThread* current();
-
-    static int key() {
-        return _tls_index;
-    }
+    static void* initialize(jthread thread);
 
-    static VMThread* fromJavaThread(JNIEnv* env, jthread thread) {
-        return VMThread::cast_raw((const void*)env->GetLongField(thread, _eetop));
-    }
-
-    static jlong javaThreadId(JNIEnv* env, jthread thread) {
-        return env->GetLongField(thread, _tid);
-    }
-
-    static int nativeThreadId(JNIEnv* jni, jthread thread);
+    static inline VMThread* current();
+    static inline VMThread* fromJavaThread(JNIEnv* env, jthread thread);
+    static ExecutionMode getExecutionMode();
+    static OSThreadState getOSThreadState();
 
     int osThreadId();
-
     JNIEnv* jni();
 
     const void** vtable() {
         assert(SafeAccess::isReadable(this));
         return *(const void***)this;
     }
 
+
     // This thread is considered a JavaThread if at least 2 of the selected 3 vtable entries
     // match those of a known JavaThread (which is either application thread or AttachListener).
     // Indexes were carefully chosen to work on OpenJDK 8 to 25, both product an debug builds.
@@ -795,7 +779,7 @@ DECLARE(VMThread)
     // Safe because 'this' is the current live thread (we are in its signal handler).
     static bool isExceptionActive() {
         if (_thread_exception_offset < 0) return false;
-        VMThread* vt = current();
+        void* vt = JVMThread::current();
         if (vt == nullptr) return false;
         return *(const void* const*)((const char*)vt + _thread_exception_offset) != nullptr;
     }
@@ -807,6 +791,8 @@ DECLARE(VMThread)
     }
 
     inline VMMethod* compiledMethod();
+private:
+    static inline int nativeThreadId(JNIEnv* jni, jthread thread);
 DECLARE_END
 
 DECLARE(VMConstMethod)
@@ -1146,7 +1132,7 @@ inline bool crashProtectionActive() {
     // is equally redundant — any bad read will be caught by the SIGSEGV handler.
     // Uses VMThread::isExceptionActive() which reads the field directly without
     // going through at() to avoid recursive assertion.
-    return VMThread::key() >= 0 && VMThread::isExceptionActive();
+    return JVMThread::key() != pthread_key_t(-1) && VMThread::isExceptionActive();
 }
 
-#endif // _VMSTRUCTS_H
+#endif // _HOTSPOT_VMSTRUCTS_H