stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8287847: Fatal Error when suspending virtual thread after it has terminated

Browse Source 
Reviewed-by: alanb, sspitsyn
This commit is contained in:
Chris Plummer 2022-07-05 17:46:59 +00:00
parent f640fc5a1e
commit 29ea6429d2
4 changed files with 182 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/jdk.jdwp.agent/share/native/libjdwp/threadControl.c
View File

@ -412,6 +412,12 @@ insertThread(JNIEnv *env, ThreadList *list, jthread thread)
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "getting vthread state");
}
if ((vthread_state & JVMTI_THREAD_STATE_ALIVE) == 0) {
// Thread not alive so put on otherThreads list instead of runningVThreads.
// It might not have started yet or might have terminated. Either way,
// otherThreads is the place for it.
list = &otherThreads;
}
if (suspendAllCount > 0) {
// Assume the suspendAllCount, just like the regular thread case above.
node->suspendCount = suspendAllCount;
@ -419,7 +425,6 @@ insertThread(JNIEnv *env, ThreadList *list, jthread thread)
// If state == 0, then this is a new vthread that has not been started yet.
// Need to suspendOnStart in that case, just like the regular thread case above.
node->suspendOnStart = JNI_TRUE;
list = &otherThreads; // Put on otherThreads list instead of runningVThreads
}
}
if (vthread_state != 0) {

1
test/jdk/TEST.groups
View File

@ -494,6 +494,7 @@ jdk_jdi_sanity = \
com/sun/jdi/ResumeOneThreadTest.java \
com/sun/jdi/RunToExit.java \
com/sun/jdi/SourceNameFilterTest.java \
com/sun/jdi/SuspendAfterDeath.java \
com/sun/jdi/VarargsTest.java \
com/sun/jdi/Vars.java \
com/sun/jdi/redefineMethod/RedefineTest.java \

167
test/jdk/com/sun/jdi/SuspendAfterDeath.java Normal file
View File

@ -0,0 +1,167 @@
/*
* Copyright (c) 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
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* 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.
*/
/**
* @test id=platform_thread
* @bug 8287847
* @summary Test suspending a platform thread after it has terminated.
* @enablePreview
* @requires vm.continuations
* @run build TestScaffold VMConnection TargetListener TargetAdapter
* @run compile SuspendAfterDeath.java
* @run main/othervm SuspendAfterDeath
*/
/**
* @test id=virtual_thread
* @bug 8287847
* @summary Test suspending a virtual thread after it has terminated.
* @enablePreview
* @requires vm.continuations
* @run build TestScaffold VMConnection TargetListener TargetAdapter
* @run compile SuspendAfterDeath.java
* @run main/othervm SuspendAfterDeath Virtual
*/
import com.sun.jdi.*;
import com.sun.jdi.event.*;
import com.sun.jdi.request.*;
import java.util.*;
class SuspendAfterDeathTarg {
static final String THREAD_NAME = "duke";
// breakpoint here
static void done() {
}
public static void main(String[] args) throws Exception {
boolean useVirtualThread = ((args.length > 0) && args[0].equals("Virtual"));
Thread thread;
System.out.println("Starting debuggee " + (useVirtualThread ? "virtual" : "platform") + " thread.");
if (useVirtualThread) {
thread = Thread.ofVirtual().name(THREAD_NAME).start(() -> { });
} else {
thread = Thread.ofPlatform().name(THREAD_NAME).start(() -> { });
}
thread.join();
done();
}
}
public class SuspendAfterDeath extends TestScaffold {
private volatile ThreadReference targetThread;
private volatile boolean breakpointReached;
private static boolean useVirtualThread = false;
SuspendAfterDeath() {
super(new String[0]); // no args to pass along to debuggee
}
public static void main(String[] args) throws Exception {
if (args.length == 1) {
if ("Virtual".equals(args[0])) {
useVirtualThread = true; // see connect() below for how this is handled
} else {
throw new RuntimeException("SuspendAfterDeath: invalid argument: " + args[0]);
}
} else if (args.length != 0) {
throw new RuntimeException("SuspendAfterDeath: incorrect number of arguments: " + args.length);
}
new SuspendAfterDeath().startTests();
}
@Override
public void threadDied(ThreadDeathEvent event) {
ThreadReference eventThread = event.thread();
if (eventThread.name().equals(SuspendAfterDeathTarg.THREAD_NAME)) {
System.out.println("Target thread died, thread=" + eventThread +
", state=" + eventThread.status());
targetThread = eventThread;
if (targetThread.status() != ThreadReference.THREAD_STATUS_RUNNING) {
failure("FAILED: wrong state for thread: " + targetThread.status());
}
}
}
@Override
public void breakpointReached(BreakpointEvent event) {
ThreadReference eventThread = event.thread();
System.out.println("Breakpoint, thread=" + eventThread);
if (targetThread == null) {
failure("FAILED: got Breakpoint event before ThreadDeath event.");
} else {
System.out.println("Target thread status at breakpoint: thread=" + targetThread +
", state=" + targetThread.status());
if (targetThread.status() != ThreadReference.THREAD_STATUS_ZOMBIE) {
failure("FAILED: wrong state for thread: " + targetThread.status());
}
breakpointReached = true;
/* Suspend the thread. This is being done after the thread has exited. */
targetThread.suspend();
}
}
@Override
public void connect(String args[]) {
if (useVirtualThread) {
/* Append the "Virtual" argument to the arguments used for the debuggee. */
List<String> argList = new ArrayList(Arrays.asList(args));
argList.add("Virtual");
args = argList.toArray(args);
}
super.connect(args);
}
@Override
protected void runTests() throws Exception {
BreakpointEvent bpe = startToMain("SuspendAfterDeathTarg");
EventRequestManager erm = vm().eventRequestManager();
// listener for ThreadDeathEvent captures reference to the thread
ThreadDeathRequest request1 = erm.createThreadDeathRequest();
request1.enable();
// listener for BreakpointEvent attempts to suspend the thread
ReferenceType targetClass = bpe.location().declaringType();
Location loc = findMethod(targetClass, "done", "()V").location();
BreakpointRequest request2 = erm.createBreakpointRequest(loc);
request2.setSuspendPolicy(EventRequest.SUSPEND_EVENT_THREAD);
request2.enable();
listenUntilVMDisconnect();
if (targetThread == null) {
failure("FAILED: never got ThreadDeath event for target thread.");
}
if (!breakpointReached) {
failure("FAILED: never got Breakpoint event for target thread.");
}
if (!testFailed) {
println("SuspendAfterDeath: passed");
} else {
throw new Exception("SuspendAfterDeath: failed");
}
}
}

10
test/jdk/com/sun/jdi/TestScaffold.java
View File

@ -66,6 +66,7 @@ abstract public class TestScaffold extends TargetAdapter {
final String[] args;
protected boolean testFailed = false;
protected long startTime;
public static final String OLD_MAIN_THREAD_NAME = "old-m-a-i-n";
static private class ArgInfo {
String targetVMArgs = "";
@ -359,10 +360,10 @@ abstract public class TestScaffold extends TargetAdapter {
}
protected void startUp(String targetName) {
List argList = new ArrayList(Arrays.asList(args));
List<String> argList = new ArrayList(Arrays.asList(args));
argList.add(targetName);
println("run args: " + argList);
connect((String[]) argList.toArray(args));
connect(argList.toArray(args));
waitForVMStart();
}
@ -461,6 +462,9 @@ abstract public class TestScaffold extends TargetAdapter {
if ("Virtual".equals(mainWrapper)) {
argInfo.targetAppCommandLine = TestScaffold.class.getName() + " " + mainWrapper + " ";
argInfo.targetVMArgs += "--enable-preview ";
} else if ("true".equals(System.getProperty("test.enable.preview"))) {
// the test specified @enablePreview.
argInfo.targetVMArgs += "--enable-preview ";
}
for (int i = 0; i < args.length; i++) {
@ -969,6 +973,8 @@ abstract public class TestScaffold extends TargetAdapter {
tg.uncaughtThrowable = error;
}
});
Thread.currentThread().setName(OLD_MAIN_THREAD_NAME);
vthread.setName("main");
vthread.join();
} else if (wrapper.equals("Kernel")) {
MainThreadGroup tg = new MainThreadGroup();