1 /*
  2  * Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 
 24 /*
 25  * @test id=default
 26  * @summary Verifies JVMTI StopThread support for virtual threads.
 27  * @requires vm.continuations

 28  * @run main/othervm/native -agentlib:StopThreadTest StopThreadTest
 29  */
 30 
 31 /*
 32  * @test id=no-vmcontinuations
 33  * @summary Verifies JVMTI StopThread support for bound virtual threads.
 34  * @run main/othervm/native -agentlib:StopThreadTest -XX:+UnlockExperimentalVMOptions -XX:-VMContinuations StopThreadTest

 35  */
 36 
 37 /*
 38  * @test id=platform
 39  * @summary Verifies JVMTI StopThread support for platform threads.

 40  * @run main/othervm/native -agentlib:StopThreadTest StopThreadTest platform
 41  */
 42 

 43 import java.lang.AssertionError;
 44 
 45 /*
 46  *     The test exercises the JVMTI function: StopThread(jthread).
 47  *     The test creates a new virtual or platform thread.
 48  *     Its method run() invokes the following methods:
 49  *      - method A() that is blocked on a monitor
 50  *      - method B() that is stopped at a breakpoint
 51  *      - method C() that forces agent to send AssertionError exception to its own thread
 52  *     All cases are using JVMTI StopThread to send an AssertionError object.
 53  */
 54 public class StopThreadTest {
 55     private static final String agentLib = "StopThreadTest";

 56     static final int JVMTI_ERROR_NONE = 0;

 57     static final int THREAD_NOT_SUSPENDED = 13;
 58     static final int PASSED = 0;
 59     static final int FAILED = 2;
 60 
 61     static void log(String str) { System.out.println(str); }
 62 
 63     static native void prepareAgent(Class taskClass, Object exceptionObject);
 64     static native void suspendThread(Thread thread);
 65     static native void resumeThread(Thread thread);
 66     static native void ensureAtBreakpoint();
 67     static native void notifyAtBreakpoint();
 68     static native int  stopThread(Thread thread);
 69 
 70     static int status = PASSED;
 71     static boolean is_virtual = true;
 72 
 73     static void setFailed(String msg) {
 74         log("\nFAILED: " + msg);
 75         status = FAILED;
 76     }
 77 
 78     static void throwFailed(String msg) {
 79         log("\nFAILED: " + msg);
 80         throw new RuntimeException("StopThreadTest failed!");
 81     }
 82 
 83     public static void main(String args[]) {
 84         is_virtual = !(args.length > 0 && args[0].equals("platform"));
 85         run();
 86         if (status == FAILED) {
 87             throwFailed("StopThreadTest!");
 88         }
 89         log("\nStopThreadTest passed");
 90     }
 91 
 92     public static void run() {
 93         TestTask testTask = new TestTask();
 94         Thread testTaskThread = null;
 95         AssertionError excObject = new AssertionError();
 96         int retCode;
 97 
 98         prepareAgent(TestTask.class, excObject);
 99 
100         log("\nMain #A: method A() must be blocked on entering a synchronized statement");
101         synchronized (TestTask.lock) {
102             if (is_virtual) {
103                 testTaskThread = Thread.ofVirtual().name("TestTaskThread").start(testTask);
104             } else {
105                 testTaskThread = Thread.ofPlatform().name("TestTaskThread").start(testTask);
106             }
107             TestTask.ensureAtPointA();
108 
109             if (is_virtual) { // this check is for virtual target thread only
110                 log("\nMain #A.1: unsuspended");
111                 retCode = stopThread(testTaskThread);
112                 if (retCode != THREAD_NOT_SUSPENDED) {
113                     throwFailed("Main #A.1: expected THREAD_NOT_SUSPENDED instead of: " + retCode);
114                 } else {
115                     log("Main #A.1: got expected THREAD_NOT_SUSPENDED");
116                 }
117             }
118 
119             log("\nMain #A.2: suspended");
120             suspendThread(testTaskThread);
121             retCode = stopThread(testTaskThread);
122             if (retCode != JVMTI_ERROR_NONE) {
123                 throwFailed("Main #A.2: expected JVMTI_ERROR_NONE instead of: " + retCode);



124             } else {
125                 log("Main #A.2: got expected JVMTI_ERROR_NONE");
126             }
127             resumeThread(testTaskThread);
128         }
129         log("\nMain #B: method B() must be blocked in a breakpoint event handler");
130         {
131             ensureAtBreakpoint();
132 
133             if (is_virtual) { // this check is for virtual target thread only
134                 log("\nMain #B.1: unsuspended");
135                 retCode = stopThread(testTaskThread);
136                 if (retCode != THREAD_NOT_SUSPENDED) {
137                     throwFailed("Main #B.1: expected THREAD_NOT_SUSPENDED instead of: " + retCode);
138                 }
139             }
140 
141             log("\nMain #B.2: suspended");
142             suspendThread(testTaskThread);
143             retCode = stopThread(testTaskThread);
144             if (retCode != JVMTI_ERROR_NONE) {
145                 throwFailed("Main #B.2: expected JVMTI_ERROR_NONE");
146             }
147             resumeThread(testTaskThread);
148 
149             notifyAtBreakpoint();
150         }
151 
152         log("\nMain #C: method C() sends AssertionError object to its own thread");
153         {
154             // StopThread is called from the test task (own thread) and expected to succeed.
155             // No suspension of the test task thread is required or can be done in this case.
156             TestTask.ensureFinished();
157         }
158 
159         try {
160             testTaskThread.join();
161         } catch (InterruptedException ex) {
162             throwFailed("Unexpected " + ex);
163         }
164     }
165 
166 
167     static class TestTask implements Runnable {
168         static Object lock = new Object();
169         static void log(String str) { System.out.println(str); }
170 
171         static volatile boolean atPointA = false;
172         static volatile boolean finished = false;
173 
174         static void sleep(long millis) {
175             try {
176                 Thread.sleep(millis);
177             } catch (InterruptedException e) {
178                 throw new RuntimeException("Interruption in TestTask.sleep: \n\t" + e);
179             }
180         }
181 
182         static void ensureAtPointA() {
183             while (!atPointA) {

184                 sleep(1);
185             }
186         }
187 
188         // Ensure thread is finished.
189         static void ensureFinished() {
190             while (!finished) {
191                 sleep(1);
192             }
193         }
194 
195         public void run() {
196             log("TestTask.run: started");
197 
198             boolean seenExceptionFromA = false;
199             try {
200                 A();
201             } catch (AssertionError ex) {
202                 log("TestTask.run: caught expected AssertionError from method A()");
203                 seenExceptionFromA = true;
204             }
205             Thread.interrupted();
206             if (!seenExceptionFromA) {



207                 StopThreadTest.setFailed("TestTask.run: expected AssertionError from method A()");
208             }
209             sleep(1); // to cause yield
210 
211             boolean seenExceptionFromB = false;
212             try {
213               B();
214             } catch (AssertionError ex) {
215                 log("TestTask.run: caught expected AssertionError from method B()");
216                 seenExceptionFromB = true;
217             }
218             Thread.interrupted();
219             if (!seenExceptionFromB) {
220                 StopThreadTest.setFailed("TestTask.run: expected AssertionError from method B()");
221             }
222             sleep(1); // to cause yield
223 
224             boolean seenExceptionFromC = false;
225             try {
226                 C();
227             } catch (AssertionError ex) {
228                 log("TestTask.run: caught expected AssertionError from method C()");
229                 seenExceptionFromC = true;
230             }
231             Thread.interrupted();
232             if (!seenExceptionFromC) {
233                 StopThreadTest.setFailed("TestTask.run: expected AssertionError from method C()");
234             }
235             finished = true;
236         }
237 
238         // Method is blocked on entering a synchronized statement.
239         // StopThread is used to send an AssertionError object two times:
240         //  - when not suspended: THREAD_NOT_SUSPENDED is expected
241         //  - when suspended: JVMTI_ERROR_NONE is expected
242         static void A() {
243             log("TestTask.A: started");
244             atPointA = true;
245             synchronized (lock) {
246             }
247             log("TestTask.A: finished");
248         }
249 
250         // A breakpoint is set at start of this method.
251         // StopThread is used to send an AssertionError object two times:
252         //  - when not suspended: THREAD_NOT_SUSPENDED is expected
253         //  - when suspended: expected to succeed
254         static void B() {
255             log("TestTask.B: started");
256         }
257 
258         // This method uses StopThread to send an AssertionError object to
259         // its own thread. It is expected to succeed.
260         static void C() {
261             log("TestTask.C: started");
262             StopThreadTest.stopThread(Thread.currentThread());
263             log("TestTask.C: finished");
264         }
265     }
266 }
--- EOF ---