async-profiler#1174: Detect JVM in non-Java application and attach to it (async-profiler#1192)

Co-authored-by: Andrei Pangin <noreply@pangin.pro>

Author: Baraa-Hasheesh

Makefile

@@ -220,6 +220,7 @@ build-test-bins:
 	@mkdir -p $(TEST_BIN_DIR)
 	gcc -o $(TEST_BIN_DIR)/malloc_plt_dyn test/test/nativemem/malloc_plt_dyn.c
 	gcc -o $(TEST_BIN_DIR)/native_api -Isrc test/test/c/native_api.c -ldl
+	$(CXX) -o $(TEST_BIN_DIR)/non_java_app $(INCLUDES) $(CPP_TEST_INCLUDES) test/test/nonjava/non_java_app.cpp $(LIBS)
 
 test-cpp: build-test-cpp
 	echo "Running cpp tests..."

src/profiler.cpp

@@ -1077,6 +1077,11 @@ Error Profiler::start(Arguments& args, bool reset) {
         return Error("Profiler already started");
     }
 
+    // If profiler is started from a native app, try to detect a running JVM and attach to it
+    if (!VM::loaded()) {
+        VM::tryAttach();
+    }
+
     Error error = checkJvmCapabilities();
     if (error) {
         return error;

src/vmEntry.cpp

@@ -32,14 +32,15 @@ int VM::_hotspot_version = 0;
 bool VM::_openj9 = false;
 bool VM::_zing = false;
 
+GetCreatedJavaVMs VM::_getCreatedJavaVMs = NULL;
+
 jvmtiError (JNICALL *VM::_orig_RedefineClasses)(jvmtiEnv*, jint, const jvmtiClassDefinition*);
 jvmtiError (JNICALL *VM::_orig_RetransformClasses)(jvmtiEnv*, jint, const jclass* classes);
 
 AsyncGetCallTrace VM::_asyncGetCallTrace;
 JVM_MemoryFunc VM::_totalMemory;
 JVM_MemoryFunc VM::_freeMemory;
 
-
 static bool isVmRuntimeEntry(const char* blob_name) {
     return strcmp(blob_name, "_ZNK12MemAllocator8allocateEv") == 0
         || strncmp(blob_name, "_Z22post_allocation_notify", 26) == 0
@@ -106,6 +107,30 @@ static void* resolveMethodIdEnd() {
     return NULL;
 }
 
+// Workaround for JDK-8308341: since JNI_GetCreatedJavaVMs may return an uninitialized JVM,
+// we verify the readiness of the JVM by presence of "VM Thread" and "Service Thread".
+bool VM::hasJvmThreads() {
+    char thread_name[32];
+    int threads_found = 0;
+
+    ThreadList* list = OS::listThreads();
+    while (list->hasNext() && threads_found != 3) {
+        if (!OS::threadName(list->next(), thread_name, sizeof(thread_name))) {
+            continue;
+        }
+
+        // On macOS, Java thread names start with "Java: "
+        int thread_name_offset = strncmp(thread_name, "Java: ", 6) == 0 ? 6 : 0;
+
+        if (strcmp(thread_name + thread_name_offset, "VM Thread") == 0) {
+            threads_found |= 1;
+        } else if (strcmp(thread_name + thread_name_offset, "Service Thread") == 0) {
+            threads_found |= 2;
+        }
+    }
+
+    return threads_found == 3;
+}
 
 bool VM::init(JavaVM* vm, bool attach) {
     if (_jvmti != NULL) return true;
@@ -275,6 +300,38 @@ bool VM::init(JavaVM* vm, bool attach) {
     return true;
 }
 
+// Try to find a running JVM instance and attach to it
+void VM::tryAttach() {
+    if (_getCreatedJavaVMs == NULL) {
+        void* lib_handle = dlopen(OS::isLinux() ? "libjvm.so" : "libjvm.dylib", RTLD_LAZY | RTLD_NOLOAD);
+        if (lib_handle != NULL) {
+            _getCreatedJavaVMs = (GetCreatedJavaVMs)dlsym(lib_handle, "JNI_GetCreatedJavaVMs");
+            dlclose(lib_handle);
+        }
+        if (_getCreatedJavaVMs == NULL) {
+            return;
+        }
+    }
+
+    JavaVM* vm;
+    jsize nVMs;
+    if (_getCreatedJavaVMs(&vm, 1, &nVMs) != JNI_OK || nVMs != 1) {
+        return;
+    }
+
+    JNIEnv* env;
+    jint get_env_result = vm->GetEnv((void**)&env, JNI_VERSION_1_6);
+    if (get_env_result == JNI_OK) {
+        // Current thread already belongs to the running JVM
+        VM::init(vm, true);
+    } else if (get_env_result == JNI_EDETACHED) {
+        // There is a running JVM, but we need to check it is initialized
+        if (hasJvmThreads() && vm->AttachCurrentThreadAsDaemon((void**)&env, NULL) == JNI_OK) {
+            VM::init(vm, true);
+        }
+    }
+}
+
 // Run late initialization when JVM is ready
 void VM::ready() {
     Profiler::setupSignalHandlers();

src/vmEntry.h

@@ -85,6 +85,8 @@ typedef void (*AsyncGetCallTrace)(ASGCT_CallTrace*, jint, void*);
 
 typedef jlong (*JVM_MemoryFunc)();
 
+typedef jint (*GetCreatedJavaVMs)(JavaVM**, jsize, jsize*);
+
 typedef struct {
     void* unused1[86];
     jvmtiError (JNICALL *RedefineClasses)(jvmtiEnv*, jint, const jvmtiClassDefinition*);
@@ -102,13 +104,16 @@ class VM {
     static bool _openj9;
     static bool _zing;
 
+    static GetCreatedJavaVMs _getCreatedJavaVMs;
+
     static jvmtiError (JNICALL *_orig_RedefineClasses)(jvmtiEnv*, jint, const jvmtiClassDefinition*);
     static jvmtiError (JNICALL *_orig_RetransformClasses)(jvmtiEnv*, jint, const jclass* classes);
 
     static void ready();
     static void applyPatch(char* func, const char* patch, const char* end_patch);
     static void loadMethodIDs(jvmtiEnv* jvmti, JNIEnv* jni, jclass klass);
     static void loadAllMethodIDs(jvmtiEnv* jvmti, JNIEnv* jni);
+    static bool hasJvmThreads();
 
   public:
     static AsyncGetCallTrace _asyncGetCallTrace;
@@ -117,6 +122,8 @@ class VM {
 
     static bool init(JavaVM* vm, bool attach);
 
+    static void tryAttach();
+
     static bool loaded() {
         return _jvmti != NULL;
     }

test/one/profiler/test/TestProcess.java

@@ -33,6 +33,8 @@ public class TestProcess implements Closeable {
     public static final String LIBPROF = "%lib";
     public static final String TESTBIN = "%testbin";
 
+    private static final String JAVA_HOME = System.getProperty("java.home");
+
     private static final Pattern filePattern = Pattern.compile("(%[a-z]+)(\\.[a-z]+)?");
 
     private static final MethodHandle pid = getPidHandle();
@@ -86,6 +88,7 @@ public TestProcess(Test test, Os currentOs, String logDir) throws Exception {
                 pb.environment().put(keyValue[0], substituteFiles(keyValue[1]));
             }
         }
+        pb.environment().put("TEST_JAVA_HOME", JAVA_HOME);
 
         this.p = pb.start();
 

test/test/nonjava/JavaClass.java

@@ -0,0 +1,18 @@
+/*
+ * Copyright The async-profiler authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package test.nonjava;
+
+public class JavaClass {
+
+    public static double cpuHeavyTask() {
+        double sum = 0;
+        for (int i = 0; i < 100000; i++) {
+            sum += Math.sqrt(Math.random());
+            sum += Math.pow(Math.random(), Math.random());
+        }
+        return sum;
+    }
+}

test/test/nonjava/NonjavaTests.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright The async-profiler authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package test.nonjava;
+
+import one.profiler.test.Output;
+import one.profiler.test.Test;
+import one.profiler.test.TestProcess;
+
+public class NonjavaTests {
+
+    // jvm is loaded before the profiling session is started
+    @Test(sh = "%testbin/non_java_app 1 %s.html", output = true)
+    public void jvmFirst(TestProcess p) throws Exception {
+        p.waitForExit();
+        assert p.exitCode() == 0;
+
+        Output out = p.readFile("%s");
+        assert out.contains(".cpuHeavyTask");
+    }
+
+    // jvm is loaded after the profiling session is started
+    @Test(sh = "%testbin/non_java_app 2 %s.html", output = true)
+    public void profilerFirst(TestProcess p) throws Exception {
+        p.waitForExit();
+        assert p.exitCode() == 0;
+
+        Output out = p.readFile("%s");
+        assert !out.contains(".cpuHeavyTask");
+    }
+
+    // jvm is loaded between two profiling sessions
+    @Test(sh = "%testbin/non_java_app 3 %f.html %s.html", output = true)
+    public void jvmInBetween(TestProcess p) throws Exception {
+        p.waitForExit();
+        assert p.exitCode() == 0;
+
+        Output out = p.readFile("%f");
+        assert !out.contains(".cpuHeavyTask");
+
+        out = p.readFile("%s");
+        assert out.contains(".cpuHeavyTask");
+    }
+
+    // jvm is loaded before the profiling session is started on a different thread
+    @Test(sh = "%testbin/non_java_app 4 %s.html", output = true)
+    public void differentThread(TestProcess p) throws Exception {
+        p.waitForExit();
+        assert p.exitCode() == 0;
+
+        Output out = p.readFile("%s");
+        assert out.contains(".cpuHeavyTask");
+    }
+}