8289607: Change hotspot/jtreg tests to not use Thread.suspend/resume

Reviewed-by: sspitsyn, cjplummer

Author: lmesnik

src/hotspot/share/prims/jvmtiEnvBase.cpp

@@ -1666,7 +1666,7 @@ JvmtiEnvBase::resume_thread(oop thread_oop, JavaThread* java_thread, bool single
     assert(single_resume || is_virtual, "ResumeAllVirtualThreads should never resume non-virtual threads");
     if (java_thread->is_suspended()) {
       if (!JvmtiSuspendControl::resume(java_thread)) {
-        return JVMTI_ERROR_INTERNAL;
+        return JVMTI_ERROR_THREAD_NOT_SUSPENDED;
       }
     }
   }

test/hotspot/jtreg/TEST.quick-groups

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2018, 2022, Oracle and/or its affiliates. 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
@@ -103,8 +103,8 @@ vmTestbase_nsk_monitoring_quick = \
   vmTestbase/nsk/monitoring/ThreadInfo/getLockName/getlockname001/TestDescription.java \
   vmTestbase/nsk/monitoring/ThreadInfo/getLockOwnerName/getlockownername001/TestDescription.java \
   vmTestbase/nsk/monitoring/ThreadInfo/isInNative/isinnative001/TestDescription.java \
-  vmTestbase/nsk/monitoring/ThreadInfo/isSuspended/issuspended001/TestDescription.java \
-  vmTestbase/nsk/monitoring/ThreadInfo/isSuspended/issuspended002/TestDescription.java \
+  vmTestbase/nsk/monitoring/ThreadInfo/isSuspended/issuspended001.java \
+  vmTestbase/nsk/monitoring/ThreadInfo/isSuspended/issuspended002.java \
   vmTestbase/nsk/monitoring/ThreadMXBean/findMonitorDeadlockedThreads/find001/TestDescription.java \
   vmTestbase/nsk/monitoring/ThreadMXBean/findMonitorDeadlockedThreads/find002/TestDescription.java \
   vmTestbase/nsk/monitoring/ThreadMXBean/findMonitorDeadlockedThreads/find003/TestDescription.java \

test/hotspot/jtreg/runtime/handshake/HandshakeDirectTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2022, Oracle and/or its affiliates. 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
@@ -33,6 +33,8 @@
  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:GuaranteedSafepointInterval=10 -XX:+HandshakeALot -XX:+SafepointALot HandshakeDirectTest
  */
 
+import jvmti.JVMTIUtils;
+
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.Semaphore;
@@ -46,6 +48,26 @@ public class HandshakeDirectTest  implements Runnable {
     static Object[] locks = new Object[WORKING_THREADS];
     static AtomicInteger handshakeCount = new AtomicInteger(0);
 
+    static void suspendThread(Thread t) {
+        try {
+            JVMTIUtils.suspendThread(t);
+        } catch (JVMTIUtils.JvmtiException e) {
+            if (e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_NOT_ALIVE) {
+                throw e;
+            }
+        }
+    }
+
+    static void resumeThread(Thread t) {
+        try {
+            JVMTIUtils.resumeThread(t);
+        } catch (JVMTIUtils.JvmtiException e) {
+            if (e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_NOT_ALIVE) {
+                throw e;
+            }
+        }
+    }
+
     @Override
     public void run() {
         int me = Integer.parseInt(Thread.currentThread().getName());
@@ -91,12 +113,12 @@ public static void main(String... args) throws Exception {
             public void run() {
                 while (true) {
                     int i = ThreadLocalRandom.current().nextInt(0, WORKING_THREADS - 1);
-                    workingThreads[i].suspend();
+                    suspendThread(workingThreads[i]);
                     try {
                         Thread.sleep(1); // sleep for 1 ms
                     } catch(InterruptedException ie) {
                     }
-                    workingThreads[i].resume();
+                    resumeThread(workingThreads[i]);
                 }
             }
         };

test/hotspot/jtreg/runtime/handshake/HandshakeSuspendExitTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2019, 2022, Oracle and/or its affiliates. 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
@@ -30,27 +30,52 @@
  * @run main/othervm -XX:+UnlockDiagnosticVMOptions -XX:GuaranteedSafepointInterval=1 -XX:+HandshakeALot HandshakeSuspendExitTest
  */
 
+import jvmti.JVMTIUtils;
+
 public class HandshakeSuspendExitTest  implements Runnable {
 
     static Thread[] _suspend_threads = new Thread[16];
     static volatile boolean _exit_now = false;
     static java.util.concurrent.Semaphore _sem = new java.util.concurrent.Semaphore(0);
 
+    static void suspendThread(Thread t) {
+        try {
+            JVMTIUtils.suspendThread(t);
+        } catch (JVMTIUtils.JvmtiException e) {
+            if (e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_SUSPENDED
+                && e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_NOT_ALIVE) {
+                throw e;
+            }
+        }
+    }
+
+    static void resumeThread(Thread t) {
+        try {
+            JVMTIUtils.resumeThread(t);
+        } catch (JVMTIUtils.JvmtiException e) {
+            if (e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_NOT_SUSPENDED
+                && e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_NOT_ALIVE) {
+                throw e;
+            }
+        }
+    }
+
     @Override
     public void run() {
         _sem.release();
         while (!_exit_now) {
             // Leave last 2 threads running.
             for (int i = 0; i < _suspend_threads.length - 2; i++) {
                 if (Thread.currentThread() != _suspend_threads[i]) {
-                    _suspend_threads[i].suspend();
-                    _suspend_threads[i].resume();
+                    suspendThread(_suspend_threads[i]);
+                    resumeThread(_suspend_threads[i]);
                 }
             }
         }
         _sem.release();
     }
 
+
     public static void main(String... args) throws Exception {
         HandshakeSuspendExitTest test = new HandshakeSuspendExitTest();
         // Fire-up suspend threads.
@@ -74,10 +99,10 @@ public static void main(String... args) throws Exception {
 
         // Try to suspend them.
         for (Thread thr : exit_threads) {
-            thr.suspend();
+            suspendThread(thr);
         }
         for (Thread thr : exit_threads) {
-            thr.resume();
+            resumeThread(thr);
         }
 
         // Start exit and join.
@@ -88,7 +113,7 @@ public static void main(String... args) throws Exception {
             // each other at exactly the same time so they can see
             // _exit_now and check in via the semaphore.
             for (Thread thr : _suspend_threads) {
-                thr.resume();
+                resumeThread(thr);
             }
             while (_sem.tryAcquire()) {
                 --waiting;

test/hotspot/jtreg/runtime/handshake/SuspendBlocked.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2021, 2022, Oracle and/or its affiliates. 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
@@ -25,12 +25,14 @@
 /*
  * @test SuspendBlocked
  * @bug 8270085
- * @library /test/lib
+ * @library /test/lib /testlibrary
  * @build SuspendBlocked
  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
  * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI SuspendBlocked
  */
 
+import jvmti.JVMTIUtils;
+
 import jdk.test.lib.Asserts;
 import jdk.test.whitebox.WhiteBox;
 
@@ -41,10 +43,16 @@ public static void main(String... args) throws Exception {
         suspend_thread.start();
         WhiteBox wb = WhiteBox.getWhiteBox();
         for (int i = 0; i < 100; i++) {
-            suspend_thread.suspend();
-            wb.lockAndBlock(/* suspender= */ true);
-            suspend_thread.resume();
-            Thread.sleep(1);
+            try {
+                JVMTIUtils.suspendThread(suspend_thread);
+                wb.lockAndBlock(/* suspender= */ true);
+                JVMTIUtils.resumeThread(suspend_thread);
+                Thread.sleep(1);
+            } catch (JVMTIUtils.JvmtiException e) {
+                if (e.getCode() != JVMTIUtils.JVMTI_ERROR_THREAD_NOT_ALIVE) {
+                    throw e;
+                }
+            }
         }
         suspend_thread.join();
     }

test/hotspot/jtreg/runtime/jni/terminatedThread/TestTerminatedThread.java

@@ -29,12 +29,15 @@
  * @comment Calling pthread_getcpuclockid() with invalid pid leads to undefined
  * behavior in musl libc (see 8240187).
  * @requires !vm.musl
+ * @library /testlibrary
  * @summary Basic test of Thread and ThreadMXBean queries on a natively
  *          attached thread that has failed to detach before terminating.
  * @comment The native code only supports POSIX so no windows testing
  * @run main/othervm/native TestTerminatedThread
  */
 
+import jvmti.JVMTIUtils;
+
 public class TestTerminatedThread {
 
     static native Thread createTerminatedThread();
@@ -63,9 +66,9 @@ public static void main(String[] args) throws Throwable {
                            ",  in state: " + t.getState());
 
         System.out.println("Calling suspend ...");
-        t.suspend();
+        JVMTIUtils.suspendThread(t);
         System.out.println("Calling resume ...");
-        t.resume();
+        JVMTIUtils.resumeThread(t);
         System.out.println("Calling getStackTrace ...");
         StackTraceElement[] stack = t.getStackTrace();
         System.out.println(java.util.Arrays.toString(stack));

test/hotspot/jtreg/serviceability/jvmti/thread/GetThreadState/thrstat02/thrstat02.java

@@ -30,8 +30,8 @@
  * VM Testbase readme:
  * DESCRIPTION
  *     The test exercises JVMDI function GetThreadState.  Java program launches
- *     a thread and for various thread states calls Thread.suspend()/resume()
- *     methods or JVMDI functions SuspendThread/ResumeThread. Then native method
+ *     a thread and for various thread states calls
+ *     JVMTI functions SuspendThread/ResumeThread. Then native method
  *     checkStatus is invoked. This method calls GetThreadState and checks if
  *     the returned values are correct and JVMTI_THREAD_STATE_SUSPENDED bit
  *     is set (or clear after resume).
@@ -120,30 +120,13 @@ void meth() throws InterruptedException {
             checkStatus(STATUS_MONITOR, false);
             System.out.println("thrstat02.meth after checkStatus(STATUS_MONITOR,false)");
 
-            thr.suspend();
-            System.out.println("thrstat02.meth after thr.suspend()");
-            checkStatus(STATUS_MONITOR, true);
-            System.out.println("thrstat02.meth after checkStatus(STATUS_MONITOR,true)");
-
-            thr.resume();
-            System.out.println("thrstat02.meth after thr.resume()");
-            checkStatus(STATUS_MONITOR, false);
-            System.out.println("thrstat02.meth after checkStatus(STATUS_MONITOR,false)");
         }
 
         runningBarrier.await();
         checkStatus(STATUS_RUNNING, false);
-        thr.suspend();
-        checkStatus(STATUS_RUNNING, true);
-        thr.resume();
-        checkStatus(STATUS_RUNNING, false);
         thr.letItGo();
 
         synchronized (endingMonitor) {
-            checkStatus(STATUS_WAIT, false);
-            thr.suspend();
-            checkStatus(STATUS_WAIT, true);
-            thr.resume();
             checkStatus(STATUS_WAIT, false);
             endingMonitor.val++;
             endingMonitor.notifyAll();

test/hotspot/jtreg/testlibrary/jvmti/JVMTIUtils.java

@@ -25,6 +25,31 @@
 
 public class JVMTIUtils {
 
+    public static int JVMTI_ERROR_NONE = 0;
+
+    public static int JVMTI_ERROR_THREAD_NOT_SUSPENDED = 13;
+    public static int JVMTI_ERROR_THREAD_SUSPENDED = 14;
+    public static int JVMTI_ERROR_THREAD_NOT_ALIVE = 15;
+
+
+    public static class JvmtiException extends RuntimeException {
+
+        private int code;
+
+        public JvmtiException(int code) {
+            this.code = code;
+        }
+
+        public int getCode() {
+            return code;
+        }
+
+        @Override
+        public String getMessage(){
+            return "JVMTI ERROR: " + code;
+        }
+    }
+
     private static native int init();
 
     static {
@@ -39,4 +64,21 @@ public class JVMTIUtils {
     public static void stopThread(Thread t) {
         stopThread(t, new ThreadDeath());
     }
+
+    private static native int suspendThread0(Thread t);
+    private static native int resumeThread0(Thread t);
+
+    public static void suspendThread(Thread t) {
+        int err = suspendThread0(t);
+        if (err != JVMTI_ERROR_NONE) {
+            throw new JvmtiException(err);
+        }
+    }
+    public static void resumeThread(Thread t) {
+        int err = resumeThread0(t);
+        if (err != JVMTI_ERROR_NONE) {
+            throw new JvmtiException(err);
+        }
+    }
+
 }

test/hotspot/jtreg/testlibrary/jvmti/libJvmtiUtils.cpp

@@ -39,6 +39,7 @@ Java_jvmti_JVMTIUtils_init(JNIEnv *jni, jclass cls) {
   }
   jvmtiCapabilities caps;
   memset(&caps, 0, sizeof (caps));
+  caps.can_suspend = 1;
   caps.can_signal_thread = 1;
   jvmtiError err = jvmti->AddCapabilities(&caps);
   if (err != JVMTI_ERROR_NONE) {
@@ -52,10 +53,20 @@ JNIEXPORT void JNICALL
 Java_jvmti_JVMTIUtils_stopThread(JNIEnv *jni, jclass cls, jthread thread, jobject exception) {
   jvmtiError err =  jvmti->StopThread(thread, exception);
   if (err == JVMTI_ERROR_THREAD_NOT_ALIVE) {
-    LOG("JVMTI_ERROR_THREAD_NOT_ALIVE happened");
+    LOG("JVMTI_ERROR_THREAD_NOT_ALIVE happened\n");
     return;
   }
   check_jvmti_status(jni, err, "Error during StopThread()");
 }
 
+JNIEXPORT jint JNICALL
+Java_jvmti_JVMTIUtils_suspendThread0(JNIEnv *jni, jclass cls, jthread thread) {
+  return jvmti->SuspendThread(thread);
+}
+
+JNIEXPORT jint JNICALL
+Java_jvmti_JVMTIUtils_resumeThread0(JNIEnv *jni, jclass cls, jthread thread) {
+  return jvmti->ResumeThread(thread);
+}
+
 }