/* * Copyright (c) 2006, 2015, 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 * @bug 6293795 * @summary Backend hangs when invokeMethod is called from a JDI eventHandler * * @author jjh * * @modules jdk.jdi * @run build TestScaffold VMConnection TargetListener TargetAdapter * @run compile -g InvokeHangTest.java * @run driver InvokeHangTest */ import com.sun.jdi.*; import com.sun.jdi.event.*; import com.sun.jdi.request.*; import java.util.*; /* * This debuggee basically runs two threads each of * which loop, hitting a bkpt in each iteration. * */ class InvokeHangTarg extends Thread { static boolean one = false; static String name1 = "Thread 1"; static String name2 = "Thread 2"; static int count = 100; public static void main(String[] args) { System.out.println("Howdy!"); InvokeHangTarg t1 = new InvokeHangTarg(name1); InvokeHangTarg t2 = new InvokeHangTarg(name2); t1.start(); t2.start(); } // This is called from the debugger via invokeMethod public double invokeee() { System.out.println("Debuggee: invokeee in thread "+Thread.currentThread().toString()); yield(); return longMethod(2); } public double longMethod(int n) { double a = 0; double s = 0; for (int i = 0; i < n; i++) { a += i; for (int j = -1000*i; j < 1000*i; j++) { a = a*(1 + i/(j + 0.5)); s += Math.sin(a); } } System.out.println("Debuggee: invokeee finished"); return s; } public InvokeHangTarg(String name) { super(name); } public void run() { if (getName().equals(name1)) { run1(); } else { run2(); } } public void bkpt1(int i) { System.out.println("Debuggee: " + Thread.currentThread() +" is running:" + i); try { Thread.currentThread().sleep(2); } catch (InterruptedException iex) {} //yield(); } public void run1() { int i = 0; while (i < count) { i++; bkpt1(i); } } public void bkpt2(int i) { System.out.println("Debuggee: " + Thread.currentThread() +" is running:" + i); try { Thread.currentThread().sleep(2); } catch (InterruptedException iex) {} //yield(); } public void run2() { int i = 0; while (i < count) { i++; bkpt2(i); } } } /********** test program **********/ public class InvokeHangTest extends TestScaffold { ReferenceType targetClass; ThreadReference mainThread; BreakpointRequest request1; BreakpointRequest request2; static volatile int bkpts = 0; Thread timerThread; static int waitTime = 20000; InvokeHangTest (String args[]) { super(args); } public static void main(String[] args) throws Exception { new InvokeHangTest(args).startTests(); } void doInvoke(ThreadReference thread, ObjectReference ref, String methodName) { List methods = ref.referenceType().methodsByName(methodName); Method method = (Method) methods.get(0); try { System.err.println(" Debugger: Invoking in thread" + thread); ref.invokeMethod(thread, method, new ArrayList(), ref.INVOKE_NONVIRTUAL); System.err.println(" Debugger: Invoke done"); } catch (Exception ex) { ex.printStackTrace(); failure("failure: Exception"); } } // BreakpointEvent handler public void breakpointReached(BreakpointEvent event) { if (bkpts == 0) { /* * This thread will watch for n secs to go by with no * calls to this method. */ timerThread.start(); } synchronized("abc") { /* * Note that this will most likely never get to * the number of times the two bkpt lines in the debuggee * are hit because bkpts are lost while they are disabled. */ bkpts++; } /* * The bug occurs when the requests are disabled * and then an invoke is done in the event handler. In some cases * the other thread has hit a bkpt and the back-end is waiting * to send it. When the back-end resumes the debuggee to do the * invokeMethod, this 2nd bkpt is released, the debuggee is suspended, including * the thread on which the invoke was done (because it is a SUSPEND_ALL bkpt), * the bkpt is sent to the front-end, but the client event handler is sitting * here waiting for the invoke to finish, so it doesn't get the 2nd bkpt and * do the resume for it. Thus, the debuggee is suspended waiting for a resume * that never comes. */ request1.disable(); request2.disable(); ThreadReference thread = event.thread(); try { StackFrame sf = thread.frame(0); System.err.println(" Debugger: Breakpoint hit at "+sf.location()); doInvoke(thread, sf.thisObject(), "invokeee"); } catch (IncompatibleThreadStateException itsex) { itsex.printStackTrace(); failure("failure: Exception"); } request1.enable(); request2.enable(); } /********** test core **********/ protected void runTests() throws Exception { /* * Get to the top of main() * to determine targetClass and mainThread */ BreakpointEvent bpe = startToMain("InvokeHangTarg"); targetClass = bpe.location().declaringType(); mainThread = bpe.thread(); EventRequestManager erm = vm().eventRequestManager(); final Thread mainThread = Thread.currentThread(); /* * Set event requests */ Location loc1 = findMethod(targetClass, "bkpt1", "(I)V").location(); Location loc2 = findMethod(targetClass, "bkpt2", "(I)V").location(); request1 = erm.createBreakpointRequest(loc1); request2 = erm.createBreakpointRequest(loc2); request1.enable(); request2.enable(); /* * This thread will be started when we get the first bkpt. * (Which we always expect to get). * It awakens every n seconds and checks to see if we * got any breakpoint events while it was asleep. If not, then * we assume the debuggee is hung and fail the test. */ timerThread = new Thread("test timer") { public void run() { int myBkpts = bkpts; while (true) { try { Thread.sleep(waitTime); System.out.println("bkpts = " + bkpts); if (myBkpts == bkpts) { // no bkpt for 'waitTime' msecs failure("failure: Debuggee appears to be hung"); vmDisconnected = true; // This awakens the main thread which is // waiting for a VMDisconnect. mainThread.interrupt(); break; } myBkpts = bkpts; } catch (InterruptedException ee) { // If the test completes, this occurs. println("timer Interrupted"); break; } } } }; /* * resume the target, listening for events */ listenUntilVMDisconnect(); timerThread.interrupt(); /* * deal with results of test * if anything has called failure("foo") testFailed will be true */ if (!testFailed) { println("InvokeHangTest: passed; bkpts = " + bkpts); } else { throw new Exception("InvokeHangTest: failed; bkpts = " + bkpts); } } }