feat(jfr): resolve unblocking span for synchronized via direct ObjectMonitor::_owner read

Author: kaahos

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

@@ -946,10 +946,11 @@ void JNICALL Profiler::MonitorContendedEnterCallback(jvmtiEnv *jvmti, JNIEnv *jn
   if (thrd == nullptr) return;
   Context& ctx = Contexts::get();
   if (ctx.spanId == 0) return;
-  thrd->_monitor_block.start_ticks  = TSC::ticks();
-  thrd->_monitor_block.span_id      = ctx.spanId;
-  thrd->_monitor_block.root_span_id = ctx.rootSpanId;
-  thrd->_monitor_block.obj_addr     = (uintptr_t)(void*)object;
+  thrd->_monitor_block.start_ticks        = TSC::ticks();
+  thrd->_monitor_block.span_id            = ctx.spanId;
+  thrd->_monitor_block.root_span_id       = ctx.rootSpanId;
+  thrd->_monitor_block.obj_addr           = (uintptr_t)(void*)object;
+  thrd->_monitor_block.unblocking_span_id = VMThread::monitorOwnerSpanId((const void*)object);
 }
 
 void JNICALL Profiler::MonitorContendedEnteredCallback(jvmtiEnv *jvmti, JNIEnv *jni,
@@ -963,7 +964,7 @@ void JNICALL Profiler::MonitorContendedEnteredCallback(jvmtiEnv *jvmti, JNIEnv *
   event._span_id            = thrd->_monitor_block.span_id;
   event._root_span_id       = thrd->_monitor_block.root_span_id;
   event._blocker            = thrd->_monitor_block.obj_addr;
-  event._unblocking_span_id = 0;
+  event._unblocking_span_id = thrd->_monitor_block.unblocking_span_id;
 
   thrd->_monitor_block.obj_addr = 0;
 

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

@@ -133,6 +133,15 @@ ProfiledThread *ProfiledThread::currentSignalSafe() {
   return __atomic_load_n(&_tls_key_initialized, __ATOMIC_ACQUIRE) ? (ProfiledThread *)pthread_getspecific(_tls_key) : nullptr;
 }
 
+ProfiledThread* ProfiledThread::findByTid(int tid) {
+  int size = __atomic_load_n(&_running_buffer_pos, __ATOMIC_ACQUIRE);
+  for (int i = 0; i < size; i++) {
+    ProfiledThread* t = _buffer[i];
+    if (t != nullptr && t->_tid == tid) return t;
+  }
+  return nullptr;
+}
+
 int ProfiledThread::popFreeSlot() {
   int current_top;
   int new_top;

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

@@ -62,6 +62,7 @@ class ProfiledThread : public ThreadLocalData {
     u64 span_id;
     u64 root_span_id;
     uintptr_t obj_addr;
+    u64 unblocking_span_id;
   };
 
   u64 _pc;
@@ -91,6 +92,7 @@ class ProfiledThread : public ThreadLocalData {
 
 public:
   static ProfiledThread *forTid(int tid) { return new ProfiledThread(-1, tid); }
+  static ProfiledThread* findByTid(int tid);
   static ProfiledThread *inBuffer(int buffer_pos) {
     return new ProfiledThread(buffer_pos, 0);
   }

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

@@ -9,6 +9,8 @@
 #include <stdarg.h>
 #include "vmStructs.h"
 #include "vmEntry.h"
+#include "context.h"
+#include "thread.h"
 #include "j9Ext.h"
 #include "jniHelper.h"
 #include "jvmHeap.h"
@@ -675,6 +677,38 @@ int VMThread::osThreadId() {
     return -1;
 }
 
+u64 VMThread::monitorOwnerSpanId(const void* object) {
+    if (_monitor_owner_offset == 0) return 0;
+
+    // Read the mark word from the object header.
+    uintptr_t mark = (uintptr_t)SafeAccess::load((void**)object, nullptr);
+
+    // At MonitorContendedEnter time the monitor must be inflated (MONITOR_BIT set
+    // in bits [1:0]). Guard defensively for any narrow races.
+    if ((mark & 0x3) != MONITOR_BIT) return 0;
+
+    // Extract ObjectMonitor* (pointer stored in bits 63:2, 4-byte aligned).
+    const char* monitor = (const char*)(mark & ~(uintptr_t)0x3);
+
+    // Read ObjectMonitor::_owner (JavaThread*).
+    const char* owner_thread = (const char*)SafeAccess::load(
+        (void**)(monitor + _monitor_owner_offset), nullptr);
+    if (owner_thread == nullptr) return 0;
+
+    // JavaThread* -> OS thread ID via existing VMThread infrastructure.
+    int owner_tid = VMThread::cast(owner_thread)->osThreadId();
+    if (owner_tid <= 0) return 0;
+
+    // OS thread ID -> ProfiledThread* -> span ID.
+    ProfiledThread* owner = ProfiledThread::findByTid(owner_tid);
+    if (owner == nullptr || !owner->isContextTlsInitialized()) return 0;
+
+    Context* ctx = owner->getContextTlsPtr();
+    if (ctx == nullptr) return 0;
+
+    return ctx->spanId; // volatile u64, safe to read cross-thread on x86/aarch64
+}
+
 JNIEnv* VMThread::jni() {
     if (_env_offset < 0) {
         return VM::jni();  // fallback for non-HotSpot JVM

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

@@ -196,6 +196,9 @@ typedef void* address;
         field(_osthread_id_offset, offset, MATCH_SYMBOLS("_thread_id"))                                             \
         field_with_version(_osthread_state_offset, offset, 10, MAX_VERSION, MATCH_SYMBOLS("_state"))                \
     type_end()                                                                                                      \
+    type_begin(VMObjectMonitor, MATCH_SYMBOLS("ObjectMonitor"))                                                     \
+        field(_monitor_owner_offset, offset, MATCH_SYMBOLS("_owner"))                                               \
+    type_end()                                                                                                      \
     type_begin(VMThreadShadow, MATCH_SYMBOLS("ThreadShadow"))                                                         \
         field(_thread_exception_offset, offset, MATCH_SYMBOLS("_exception_file"))                                   \
     type_end()                                                                                                      \
@@ -714,6 +717,11 @@ DECLARE(VMThread)
 
     int osThreadId();
 
+    // Returns the span ID of the JavaThread currently owning the given monitor
+    // object, reading ObjectMonitor::_owner directly without a safepoint.
+    // Returns 0 if the owner cannot be determined.
+    static u64 monitorOwnerSpanId(const void* object);
+
     JNIEnv* jni();
 
     const void** vtable() {