Merge pull request #9 from roberttoyonaga/bp-GR-73283

zakkak · web-flow · commit ccbeb75d1f2d · 2026-02-19T12:39:58.000+02:00
Backport [GR-73283] Fix JCMD Thread.dump_to_file
diff --git a/substratevm/mx.substratevm/mx_substratevm.py b/substratevm/mx.substratevm/mx_substratevm.py
@@ -672,6 +672,7 @@ def _native_junit(native_image, unittest_args, build_args=None, run_args=None, b
         build_args.append("-D" + key + "=" + value)
 
     build_args.append('--add-exports=java.base/jdk.internal.misc=ALL-UNNAMED')
+    build_args.append('--add-exports=java.base/jdk.internal.vm=ALL-UNNAMED')
     run_args = run_args or ['--verbose']
     junit_native_dir = join(svmbuild_dir(), platform_name(), 'junit')
     mx_util.ensure_dir_exists(junit_native_dir)
diff --git a/substratevm/mx.substratevm/suite.py b/substratevm/mx.substratevm/suite.py
@@ -1131,6 +1131,7 @@
             "requiresConcealed" : {
                 "java.base" : [
                     "jdk.internal.misc",
+                    "jdk.internal.vm",
                     "sun.security.jca",
                 ],
             },
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/dcmd/Target_jdk_internal_vm_ThreadSnapshot.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/dcmd/Target_jdk_internal_vm_ThreadSnapshot.java
@@ -0,0 +1,149 @@
+/*
+ * Copyright (c) 2026, 2026, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2026, 2026, IBM Inc. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package com.oracle.svm.core.dcmd;
+
+import java.lang.Thread.State;
+import java.util.concurrent.locks.LockSupport;
+
+import com.oracle.svm.core.SubstrateUtil;
+import com.oracle.svm.core.annotate.Alias;
+import com.oracle.svm.core.annotate.Delete;
+import com.oracle.svm.core.annotate.Inject;
+import com.oracle.svm.core.annotate.Substitute;
+import com.oracle.svm.core.annotate.TargetClass;
+import com.oracle.svm.core.heap.VMOperationInfos;
+import com.oracle.svm.core.monitor.JavaMonitor;
+import com.oracle.svm.core.monitor.JavaMonitorQueuedSynchronizer;
+import com.oracle.svm.core.thread.JavaThreads;
+import com.oracle.svm.core.thread.JavaVMOperation;
+import com.oracle.svm.core.thread.Target_java_lang_VirtualThread;
+import com.oracle.svm.core.thread.VMOperation;
+import com.oracle.svm.core.util.BasedOnJDKFile;
+
+@TargetClass(className = "jdk.internal.vm.ThreadSnapshot")
+final class Target_jdk_internal_vm_ThreadSnapshot {
+    @Alias //
+    String name;
+    /** Replaces {@link #threadStatus}, to avoid unnecessary conversions. */
+    @Inject //
+    State state;
+    @Delete //
+    private int threadStatus;
+    @Alias //
+    Thread carrierThread;
+    @Alias //
+    StackTraceElement[] stackTrace;
+    @Alias //
+    int blockerTypeOrdinal;
+    @Alias //
+    Object blockerObject;
+
+    @Alias //
+    Target_jdk_internal_vm_ThreadSnapshot() {
+    }
+
+    @Substitute
+    @BasedOnJDKFile("https://github.com/openjdk/jdk/blob/jdk-25+26/src/java.base/share/native/libjava/ThreadSnapshot.c#L32-L36")
+    @BasedOnJDKFile("https://github.com/openjdk/jdk/blob/jdk-25+36/src/hotspot/share/prims/jvm.cpp#L2964-L2971")
+    private static Target_jdk_internal_vm_ThreadSnapshot create(Thread thread) {
+        return ThreadSnapshotUtil.create(thread);
+    }
+
+    @Substitute
+    State threadState() {
+        return state;
+    }
+}
+
+@TargetClass(className = "jdk.internal.vm.ThreadSnapshot", innerClass = "BlockerLockType")
+final class Target_jdk_internal_vm_ThreadSnapshot_BlockerLockType {
+    // Checkstyle: stop
+    @Alias //
+    static Target_jdk_internal_vm_ThreadSnapshot_BlockerLockType PARK_BLOCKER;
+    // Checkstyle: resume
+}
+
+final class ThreadSnapshotUtil {
+    /**
+     * At the moment, this method only computes the most relevant data, i.e., the blocker
+     * information is incomplete and owned monitors are not supported. It is also slow because it
+     * often needs a VM operation.
+     */
+    @BasedOnJDKFile("https://github.com/openjdk/jdk/blob/jdk-25+36/src/hotspot/share/services/threadService.cpp#L1437-L1554")
+    public static Target_jdk_internal_vm_ThreadSnapshot create(Thread thread) {
+        if (thread == Thread.currentThread()) {
+            /* No VM operation needed. */
+            return createSnapshot(thread);
+        }
+
+        /*
+         * Enqueue a VM operation to get a consistent state. Could use a thread-local handshake in
+         * the future (see GR-60270).
+         */
+        CreateThreadSnapshotOperation op = new CreateThreadSnapshotOperation(thread);
+        op.enqueue();
+        return op.result;
+    }
+
+    private static Target_jdk_internal_vm_ThreadSnapshot createSnapshot(Thread thread) {
+        assert thread == Thread.currentThread() || VMOperation.isInProgressAtSafepoint();
+
+        Target_jdk_internal_vm_ThreadSnapshot snapshot = new Target_jdk_internal_vm_ThreadSnapshot();
+        snapshot.stackTrace = thread.getStackTrace();
+        snapshot.name = thread.getName();
+        snapshot.state = thread.getState();
+
+        if (JavaThreads.isVirtual(thread)) {
+            Target_java_lang_VirtualThread vthread = SubstrateUtil.cast(thread, Target_java_lang_VirtualThread.class);
+            snapshot.carrierThread = JavaThreads.getVirtualThreadCarrier(vthread);
+        }
+
+        /* Setting the blocker info in cases other than PARK_BLOCKER is non-trivial. */
+        Object blocker = LockSupport.getBlocker(thread);
+        if (blocker != null && !(blocker instanceof JavaMonitor) && !(blocker instanceof JavaMonitorQueuedSynchronizer.JavaMonitorConditionObject)) {
+            snapshot.blockerTypeOrdinal = SubstrateUtil.cast(Target_jdk_internal_vm_ThreadSnapshot_BlockerLockType.PARK_BLOCKER, Enum.class).ordinal();
+            snapshot.blockerObject = blocker;
+        }
+
+        return snapshot;
+    }
+
+    private static class CreateThreadSnapshotOperation extends JavaVMOperation {
+        private final Thread thread;
+        Target_jdk_internal_vm_ThreadSnapshot result;
+
+        CreateThreadSnapshotOperation(Thread thread) {
+            super(VMOperationInfos.get(CreateThreadSnapshotOperation.class, "Create ThreadSnapshot", SystemEffect.SAFEPOINT));
+            this.thread = thread;
+        }
+
+        @Override
+        protected void operate() {
+            result = createSnapshot(thread);
+        }
+    }
+}
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/monitor/JavaMonitorQueuedSynchronizer.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/monitor/JavaMonitorQueuedSynchronizer.java
@@ -60,7 +60,7 @@
  * </ul>
  */
 @BasedOnJDKClass(AbstractQueuedLongSynchronizer.class)
-abstract class JavaMonitorQueuedSynchronizer {
+public abstract class JavaMonitorQueuedSynchronizer {
     // Node status bits, also used as argument and return values
     static final int WAITING = 1; // must be 1
     static final int CANCELLED = 0x80000000; // must be negative
diff --git a/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/JavaThreads.java b/substratevm/src/com.oracle.svm.core/src/com/oracle/svm/core/thread/JavaThreads.java
@@ -214,6 +214,15 @@ public static boolean isCurrentThreadVirtualAndPinned() {
         return carrier != null && carrier.vthread != null && Target_jdk_internal_vm_Continuation.isPinned(carrier.cont.getScope());
     }
 
+    /**
+     * Returns the carrier thread. Note that this method may only be called for the current thread
+     * or during a VM operation. Otherwise, the result could be stale.
+     */
+    public static Thread getVirtualThreadCarrier(Target_java_lang_VirtualThread thread) {
+        assert SubstrateUtil.cast(thread, Thread.class) == Thread.currentThread() || VMOperation.isInProgressAtSafepoint() : "otherwise, this information could change at any time";
+        return thread.carrierThread;
+    }
+
     @SuppressFBWarnings(value = "BC", justification = "Cast for @TargetClass")
     static Target_java_lang_ThreadGroup toTarget(ThreadGroup threadGroup) {
         return Target_java_lang_ThreadGroup.class.cast(threadGroup);
diff --git a/substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/jcmd/JCmdTest.java b/substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/jcmd/JCmdTest.java
@@ -1,6 +1,7 @@
 /*
- * Copyright (c) 2024, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, 2026, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2024, 2024, Red Hat Inc. All rights reserved.
+ * Copyright (c) 2026, 2026, IBM Inc. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -39,7 +40,9 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.LockSupport;
 
 import org.graalvm.nativeimage.Platform;
 import org.junit.BeforeClass;
@@ -49,7 +52,7 @@
 
 public class JCmdTest {
     @BeforeClass
-    public static void checkForJFR() {
+    public static void checkForJcmd() {
         assumeTrue("skipping JCmd tests", VMInspectionOptions.hasJCmdSupport());
     }
 
@@ -76,8 +79,7 @@ public void testBadSocketFile() throws IOException, InterruptedException {
         checkJCmdConnection();
 
         /* Delete the socket file. */
-        String tempDir = System.getProperty("java.io.tmpdir");
-        Path attachFile = Paths.get(tempDir, ".java_pid" + ProcessHandle.current().pid());
+        Path attachFile = getTempFilePath(".java_pid", "");
         boolean deletedSocketFile = Files.deleteIfExists(attachFile);
         assertTrue(deletedSocketFile);
 
@@ -128,6 +130,91 @@ public void testJfr() throws IOException, InterruptedException {
         assertOutputContainsLines(jcmd, "Stopped recording \"JCmdTest\".");
     }
 
+    @Test
+    public void testThreadPrint() throws IOException, InterruptedException {
+        Process jcmd = runJCmd("Thread.print");
+        assertOutputContainsStrings(jcmd, "Threads dumped.");
+    }
+
+    @Test
+    public void testThreadDumpToTextFile() throws IOException, InterruptedException {
+        BlockerHelper blocker = new BlockerHelper();
+        CountDownLatch parked = new CountDownLatch(1);
+
+        Thread parkedThread = new Thread(() -> {
+            parked.countDown();
+            LockSupport.park(blocker);
+        }, "test-park-blocker-thread");
+
+        parkedThread.start();
+
+        /* Wait until parkedThread is parked. */
+        parked.await();
+        while (!parkedThread.getState().equals(Thread.State.WAITING)) {
+            Thread.sleep(10);
+        }
+
+        Path textFile = getTempFilePath("test_thread_dump", ".txt");
+        Process jcmd = runJCmd("Thread.dump_to_file", textFile.toString());
+        assertOutputContainsStrings(jcmd, "Created");
+        assertTrue(Files.size(textFile) > 0);
+        checkThreadDump(textFile);
+        assertTrue(Files.deleteIfExists(textFile));
+
+        /* Unpark the thread and wait until it terminates. */
+        LockSupport.unpark(parkedThread);
+        parkedThread.join();
+    }
+
+    private static void checkThreadDump(Path textFile) throws IOException {
+        String dump = Files.readString(textFile);
+        assertTrue("Dump should contain the blocked thread's name", dump.contains("test-park-blocker-thread"));
+        assertTrue("Dump should contain the thread's state", dump.contains("WAITING"));
+        assertTrue("Dump should contain text 'parking to wait for'", dump.contains("parking to wait for"));
+        assertTrue("Dump should report the blocker object", dump.contains(BlockerHelper.class.getSimpleName()));
+        assertTrue("Dump should report the process ID", dump.contains(String.valueOf(ProcessHandle.current().pid())));
+        assertTrue("Dump should report at least some stacktrace lines", dump.contains("    at "));
+    }
+
+    @Test
+    public void testThreadDumpToJsonFile() throws IOException, InterruptedException {
+        Path jsonFile = getTempFilePath("test_thread_dump", ".json");
+        Process jcmd = runJCmd("Thread.dump_to_file", "-format=json", jsonFile.toString());
+        assertOutputContainsStrings(jcmd, "Created");
+        assertTrue(Files.size(jsonFile) > 0);
+        assertTrue(Files.deleteIfExists(jsonFile));
+    }
+
+    @Test
+    public void testVM() throws IOException, InterruptedException {
+        Process jcmd = runJCmd("VM.command_line");
+        assertOutputContainsStrings(jcmd, "VM Arguments:", "java_command:");
+
+        jcmd = runJCmd("VM.native_memory");
+        assertOutputContainsStrings(jcmd, "Native memory tracking");
+
+        jcmd = runJCmd("VM.system_properties");
+        assertOutputContainsStrings(jcmd, ":");
+
+        jcmd = runJCmd("VM.uptime");
+        assertOutputContainsStrings(jcmd, ":");
+
+        jcmd = runJCmd("VM.version");
+        assertOutputContainsStrings(jcmd, "GraalVM");
+    }
+
+    @Test
+    public void testGC() throws IOException, InterruptedException {
+        Path dumpFile = getTempFilePath("heap_dump", ".hprof");
+        Process jcmd = runJCmd("GC.heap_dump", dumpFile.toString());
+        assertOutputContainsStrings(jcmd, "Dumped to:");
+        assertTrue(Files.size(dumpFile) > 0);
+        assertTrue(Files.deleteIfExists(dumpFile));
+
+        jcmd = runJCmd("GC.run");
+        assertOutputContainsStrings(jcmd, "Command executed successfully");
+    }
+
     private static void checkJCmdConnection() throws IOException, InterruptedException {
         Process jcmd = runJCmd("help");
         assertOutputContainsLines(jcmd, "help");
@@ -175,4 +262,12 @@ private static String[] getOutput(Process process) throws InterruptedException {
         }
         return lines;
     }
+
+    private static Path getTempFilePath(String prefix, String suffix) {
+        String tempDir = System.getProperty("java.io.tmpdir");
+        return Paths.get(tempDir, prefix + ProcessHandle.current().pid() + suffix);
+    }
+
+    private static final class BlockerHelper {
+    }
 }
