Guard JavaThread-specific VMThread accessors for non-JavaThread safety

Resolve CSTACK_DEFAULT dynamically: CSTACK_VM on HotSpot+Linux,
CSTACK_DWARF on non-HotSpot JVMs (J9, Zing).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: jbachorik

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

@@ -477,7 +477,7 @@ int Profiler::getJavaTraceAsync(void *ucontext, ASGCT_CallFrame *frames,
   // handler since JDK 9, so we do it only for threads already registered in
   // ThreadLocalStorage
   VMThread *vm_thread = VMThread::current();
-  if (vm_thread == NULL) {
+  if (vm_thread == NULL || !vm_thread->isThreadAccessible()) {
     Counters::increment(AGCT_NOT_REGISTERED_IN_TLS);
     return 0;
   }
@@ -1385,6 +1385,13 @@ Error Profiler::start(Arguments &args, bool reset) {
   _cpu_engine = selectCpuEngine(args);
   _wall_engine = selectWallEngine(args);
   _cstack = args._cstack;
+  if (_cstack == CSTACK_DEFAULT) {
+    if (VMStructs::hasStackStructs() && OS::isLinux()) {
+      _cstack = CSTACK_VM;
+    } else if (DWARF_SUPPORTED) {
+      _cstack = CSTACK_DWARF;
+    }
+  }
   if (_cstack == CSTACK_DWARF && !DWARF_SUPPORTED) {
     _cstack = CSTACK_NO;
     Log::warn("DWARF unwinding is not supported on this platform. Defaulting "

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

@@ -276,6 +276,9 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
 
     jmp_buf crash_protection_ctx;
     VMThread* vm_thread = VMThread::current();
+    if (vm_thread != NULL && !vm_thread->isThreadAccessible()) {
+        vm_thread = NULL;
+    }
     void* saved_exception = vm_thread != NULL ? vm_thread->exception() : NULL;
 
     // Should be preserved across setjmp/longjmp
@@ -547,7 +550,6 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
                         // already used the anchor; disable it
                         anchor = NULL;
                         if (sp < prev_sp || sp >= bottom || !aligned(sp)) {
-                            fillFrame(frames[depth++], BCI_ERROR, "break_no_anchor");
                             break;
                         }
                         // we restored from Java frame; clean the prev_native_pc
@@ -572,7 +574,6 @@ __attribute__((no_sanitize("address"))) int StackWalker::walkVM(void* ucontext,
                         }
                     }
                 }
-                fillFrame(frames[depth++], BCI_ERROR, "break_no_anchor");
                 break;
             }
             fillFrame(frames[depth++], frame_bci, (void*)method_name);
@@ -681,7 +682,7 @@ void StackWalker::checkFault(ProfiledThread* thrd) {
     }
 
     VMThread* vm_thread = VMThread::current();
-    if (vm_thread != NULL && sameStack(vm_thread->exception(), &vm_thread)) {
+    if (vm_thread != NULL && vm_thread->isThreadAccessible() && sameStack(vm_thread->exception(), &vm_thread)) {
         if (thrd) {
             // going to longjmp out of the signal handler, reset the crash handler depth counter
             thrd->resetCrashHandler();

ddprof-lib/src/main/cpp/thread.h

@@ -36,6 +36,7 @@ class ProfiledThread : public ThreadLocalData {
 
   // Misc flags
   static constexpr u32 FLAG_JAVA_THREAD = 0x01;
+  static constexpr u32 FLAG_JAVA_THREAD_KNOWN = 0x02;
 
   // Free slot recycling - lock-free stack of available buffer slots
   // Note: Using plain int with GCC atomic builtins instead of std::atomic
@@ -200,11 +201,19 @@ class ProfiledThread : public ThreadLocalData {
 
   // Flags
   inline void setJavaThread() {
-    _misc_flags |= FLAG_JAVA_THREAD;
+    _misc_flags |= (FLAG_JAVA_THREAD | FLAG_JAVA_THREAD_KNOWN);
   }
 
   inline bool isJavaThread() const {
-    return (_misc_flags & FLAG_JAVA_THREAD) == FLAG_JAVA_THREAD;
+    return (_misc_flags & FLAG_JAVA_THREAD) != 0;
+  }
+
+  inline bool isJavaThreadKnown() const {
+    return (_misc_flags & FLAG_JAVA_THREAD_KNOWN) != 0;
+  }
+
+  inline void cacheJavaThread(bool isJava) {
+    _misc_flags |= FLAG_JAVA_THREAD_KNOWN | (isJava ? FLAG_JAVA_THREAD : 0);
   }
 
 private:

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

@@ -1082,6 +1082,7 @@ OSThreadState VMThread::osThreadState() {
 }
 
 int VMThread::state() {
+    if (!cachedIsJavaThread()) return 0;
     int offset = VMStructs::thread_state_offset();
     if (offset >= 0) {
         int* state = (int*)at(offset);

ddprof-lib/src/main/cpp/vmStructs.h

@@ -13,6 +13,7 @@
 #include <type_traits>
 #include "codeCache.h"
 #include "safeAccess.h"
+#include "thread.h"
 #include "threadState.h"
 #include "vmEntry.h"
 
@@ -539,6 +540,21 @@ DECLARE(VMThread)
                (vtbl[5] == _java_thread_vtbl[5]) >= 2;
     }
 
+    // Cached version of isJavaThread(). On first call per thread, computes the
+    // vtable check and caches the result in ProfiledThread for O(1) subsequent
+    // lookups. This is needed because JVMTI ThreadStart only fires for application
+    // threads, not for JVM-internal JavaThread subclasses (CompilerThread, etc.).
+    bool cachedIsJavaThread() {
+        ProfiledThread* pt = ProfiledThread::currentSignalSafe();
+        if (pt != NULL) {
+            if (!pt->isJavaThreadKnown()) {
+                pt->cacheJavaThread(isJavaThread());
+            }
+            return pt->isJavaThread();
+        }
+        return isJavaThread();
+    }
+
     OSThreadState osThreadState();
 
     int state();
@@ -548,16 +564,34 @@ DECLARE(VMThread)
     }
 
     bool inDeopt() {
+        if (!cachedIsJavaThread()) return false;
         assert(_thread_vframe_offset >= 0);
         return SafeAccess::loadPtr((void**) at(_thread_vframe_offset), nullptr) != NULL;
     }
 
+    // Check if the thread object memory is readable up to the largest used
+    // offset. On some JVMs (e.g. GraalVM 25 aarch64), a wall-clock signal
+    // can hit a thread whose memory is only partially mapped — the vtable
+    // at offset 0 may be readable while fields deeper in the object are not.
+    // On non-HotSpot JVMs (J9, Zing) offsets stay at -1; skip the check.
+    bool isThreadAccessible() {
+        int max_offset = -1;
+        if (_thread_exception_offset > max_offset) max_offset = _thread_exception_offset;
+        if (_thread_state_offset > max_offset) max_offset = _thread_state_offset;
+        if (_thread_osthread_offset > max_offset) max_offset = _thread_osthread_offset;
+        if (_thread_anchor_offset > max_offset) max_offset = _thread_anchor_offset;
+        if (_thread_vframe_offset > max_offset) max_offset = _thread_vframe_offset;
+        if (max_offset < 0) return true;
+        return SafeAccess::isReadableRange(this, max_offset + sizeof(void*));
+    }
+
     void*& exception() {
         assert(_thread_exception_offset >= 0);
         return *(void**) at(_thread_exception_offset);
     }
 
     VMJavaFrameAnchor* anchor() {
+        if (!cachedIsJavaThread()) return NULL;
         assert(_thread_anchor_offset >= 0);
         return VMJavaFrameAnchor::cast(at(_thread_anchor_offset));
     }

ddprof-lib/src/main/cpp/vmStructs.inline.h

@@ -13,6 +13,7 @@ VMNMethod* VMMethod::code() {
 }
 
 VMMethod* VMThread::compiledMethod() {
+    if (!cachedIsJavaThread()) return NULL;
     assert(_comp_method_offset >= 0);
     assert(_comp_env_offset >= 0);
     assert(_comp_task_offset >= 0);

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

@@ -80,6 +80,9 @@ void WallClockASGCT::signalHandler(int signo, siginfo_t *siginfo, void *ucontext
 
   ExecutionEvent event;
   VMThread *vm_thread = VMThread::current();
+  if (vm_thread != NULL && !vm_thread->isThreadAccessible()) {
+      vm_thread = NULL;
+  }
   int raw_thread_state = vm_thread ? vm_thread->state() : 0;
   bool is_java_thread = raw_thread_state >= 4 && raw_thread_state < 12;
   bool is_initialized = is_java_thread;