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 * @library /test/lib
29 * @run main/othervm/native -agentlib:StopThreadTest StopThreadTest
30 */
31
32 /*
33 * @test id=no-vmcontinuations
34 * @summary Verifies JVMTI StopThread support for bound virtual threads.
35 * @library /test/lib
36 * @run main/othervm/native -agentlib:StopThreadTest -XX:+UnlockExperimentalVMOptions -XX:-VMContinuations -DboundVThread=true StopThreadTest
37 */
38
39 /*
40 * @test id=platform
41 * @summary Verifies JVMTI StopThread support for platform threads.
42 * @library /test/lib
43 * @run main/othervm/native -agentlib:StopThreadTest StopThreadTest platform
44 */
45
46 import jdk.test.lib.Platform;
47 import java.lang.AssertionError;
48
49 /*
50 * The test exercises the JVMTI function: StopThread(jthread).
51 * The test creates a new virtual or platform thread.
52 * Its method run() invokes the following methods:
53 * - method A() that is blocked on a monitor
54 * - method B() that is stopped at a breakpoint
55 * - method C() that forces agent to send AssertionError exception to its own thread
56 * All cases are using JVMTI StopThread to send an AssertionError object.
57 */
58 public class StopThreadTest {
59 private static final String agentLib = "StopThreadTest";
60 static final boolean isBoundVThread = Boolean.getBoolean("boundVThread");
61 static final int JVMTI_ERROR_NONE = 0;
62 static final int JVMTI_ERROR_OPAQUE_FRAME = 32;
63 static final int THREAD_NOT_SUSPENDED = 13;
64 static final int PASSED = 0;
65 static final int FAILED = 2;
66
67 static void log(String str) { System.out.println(str); }
68
69 static native void prepareAgent(Class taskClass, Object exceptionObject);
70 static native void suspendThread(Thread thread);
71 static native void resumeThread(Thread thread);
72 static native void ensureAtBreakpoint();
73 static native void notifyAtBreakpoint();
74 static native int stopThread(Thread thread);
75
76 static int status = PASSED;
77 static boolean is_virtual = true;
78
79 static void setFailed(String msg) {
80 log("\nFAILED: " + msg);
81 status = FAILED;
82 }
83
84 static void throwFailed(String msg) {
85 log("\nFAILED: " + msg);
86 throw new RuntimeException("StopThreadTest failed!");
87 }
88
89 public static void main(String args[]) {
90 is_virtual = !(args.length > 0 && args[0].equals("platform"));
91 run();
92 if (status == FAILED) {
93 throwFailed("StopThreadTest!");
94 }
95 log("\nStopThreadTest passed");
96 }
97
98 public static void run() {
99 TestTask testTask = new TestTask();
100 Thread testTaskThread = null;
101 AssertionError excObject = new AssertionError();
102 int retCode;
103
104 prepareAgent(TestTask.class, excObject);
105
106 log("\nMain #A: method A() must be blocked on entering a synchronized statement");
107 synchronized (TestTask.lock) {
108 if (is_virtual) {
109 testTaskThread = Thread.ofVirtual().name("TestTaskThread").start(testTask);
110 } else {
111 testTaskThread = Thread.ofPlatform().name("TestTaskThread").start(testTask);
112 }
113 TestTask.ensureAtPointA(testTaskThread);
114
115 if (is_virtual) { // this check is for virtual target thread only
116 log("\nMain #A.1: unsuspended");
117 retCode = stopThread(testTaskThread);
118 if (retCode != THREAD_NOT_SUSPENDED) {
119 throwFailed("Main #A.1: expected THREAD_NOT_SUSPENDED instead of: " + retCode);
120 } else {
121 log("Main #A.1: got expected THREAD_NOT_SUSPENDED");
122 }
123 }
124
125 log("\nMain #A.2: suspended");
126 suspendThread(testTaskThread);
127 retCode = stopThread(testTaskThread);
128 int expectedRetCode = (is_virtual && !isBoundVThread && (Platform.isX64() || Platform.isAArch64())) ? JVMTI_ERROR_OPAQUE_FRAME : JVMTI_ERROR_NONE;
129 String expectedRetCodeName = (is_virtual && !isBoundVThread && (Platform.isX64() || Platform.isAArch64())) ?
130 "JVMTI_ERROR_OPAQUE_FRAME" : "JVMTI_ERROR_NONE";
131 if (retCode != expectedRetCode) {
132 throwFailed("Main #A.2: expected " + expectedRetCodeName + " instead of: " + retCode);
133 } else {
134 log("Main #A.2: got expected " + expectedRetCodeName);
135 }
136 resumeThread(testTaskThread);
137 }
138 log("\nMain #B: method B() must be blocked in a breakpoint event handler");
139 {
140 ensureAtBreakpoint();
141
142 if (is_virtual) { // this check is for virtual target thread only
143 log("\nMain #B.1: unsuspended");
144 retCode = stopThread(testTaskThread);
145 if (retCode != THREAD_NOT_SUSPENDED) {
146 throwFailed("Main #B.1: expected THREAD_NOT_SUSPENDED instead of: " + retCode);
147 }
148 }
149
150 log("\nMain #B.2: suspended");
151 suspendThread(testTaskThread);
152 retCode = stopThread(testTaskThread);
153 if (retCode != JVMTI_ERROR_NONE) {
154 throwFailed("Main #B.2: expected JVMTI_ERROR_NONE");
155 }
156 resumeThread(testTaskThread);
157
158 notifyAtBreakpoint();
159 }
160
161 log("\nMain #C: method C() sends AssertionError object to its own thread");
162 {
163 // StopThread is called from the test task (own thread) and expected to succeed.
164 // No suspension of the test task thread is required or can be done in this case.
165 TestTask.ensureFinished();
166 }
167
168 try {
169 testTaskThread.join();
170 } catch (InterruptedException ex) {
171 throwFailed("Unexpected " + ex);
172 }
173 }
174
175
176 static class TestTask implements Runnable {
177 static Object lock = new Object();
178 static void log(String str) { System.out.println(str); }
179
180 static volatile boolean atPointA = false;
181 static volatile boolean finished = false;
182
183 static void sleep(long millis) {
184 try {
185 Thread.sleep(millis);
186 } catch (InterruptedException e) {
187 throw new RuntimeException("Interruption in TestTask.sleep: \n\t" + e);
188 }
189 }
190
191 static void ensureAtPointA(Thread vt) {
192 // wait while the thread state is not the expected one
193 while (vt.getState() != Thread.State.BLOCKED) {
194 sleep(1);
195 }
196 }
197
198 // Ensure thread is finished.
199 static void ensureFinished() {
200 while (!finished) {
201 sleep(1);
202 }
203 }
204
205 public void run() {
206 log("TestTask.run: started");
207
208 boolean seenExceptionFromA = false;
209 try {
210 A();
211 } catch (AssertionError ex) {
212 log("TestTask.run: caught expected AssertionError from method A()");
213 seenExceptionFromA = true;
214 }
215 Thread.interrupted();
216 if (!seenExceptionFromA
217 && !(is_virtual
218 && !isBoundVThread
219 && (Platform.isX64() || (Platform.isAArch64())) )) {
220 StopThreadTest.setFailed("TestTask.run: expected AssertionError from method A()");
221 }
222 sleep(1); // to cause yield
223
224 boolean seenExceptionFromB = false;
225 try {
226 B();
227 } catch (AssertionError ex) {
228 log("TestTask.run: caught expected AssertionError from method B()");
229 seenExceptionFromB = true;
230 }
231 Thread.interrupted();
232 if (!seenExceptionFromB) {
233 StopThreadTest.setFailed("TestTask.run: expected AssertionError from method B()");
234 }
235 sleep(1); // to cause yield
236
237 boolean seenExceptionFromC = false;
238 try {
239 C();
240 } catch (AssertionError ex) {
241 log("TestTask.run: caught expected AssertionError from method C()");
242 seenExceptionFromC = true;
243 }
244 Thread.interrupted();
245 if (!seenExceptionFromC) {
246 StopThreadTest.setFailed("TestTask.run: expected AssertionError from method C()");
247 }
248 finished = true;
249 }
250
251 // Method is blocked on entering a synchronized statement.
252 // StopThread is used to send an AssertionError object two times:
253 // - when not suspended: THREAD_NOT_SUSPENDED is expected
254 // - when suspended: JVMTI_ERROR_NONE is expected
255 static void A() {
256 log("TestTask.A: started");
257 synchronized (lock) {
258 }
259 log("TestTask.A: finished");
260 }
261
262 // A breakpoint is set at start of this method.
263 // StopThread is used to send an AssertionError object two times:
264 // - when not suspended: THREAD_NOT_SUSPENDED is expected
265 // - when suspended: expected to succeed
266 static void B() {
267 log("TestTask.B: started");
268 }
269
270 // This method uses StopThread to send an AssertionError object to
271 // its own thread. It is expected to succeed.
272 static void C() {
273 log("TestTask.C: started");
274 StopThreadTest.stopThread(Thread.currentThread());
275 log("TestTask.C: finished");
276 }
277 }
278 }