354 lines
12 KiB
Java
354 lines
12 KiB
Java
/*
|
|
* Copyright (c) 2001, 2011, 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. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
/*
|
|
* This source code is provided to illustrate the usage of a given feature
|
|
* or technique and has been deliberately simplified. Additional steps
|
|
* required for a production-quality application, such as security checks,
|
|
* input validation and proper error handling, might not be present in
|
|
* this sample code.
|
|
*/
|
|
|
|
|
|
package com.sun.tools.example.trace;
|
|
|
|
import com.sun.jdi.*;
|
|
import com.sun.jdi.request.*;
|
|
import com.sun.jdi.event.*;
|
|
|
|
import java.util.*;
|
|
import java.io.PrintWriter;
|
|
|
|
/**
|
|
* This class processes incoming JDI events and displays them
|
|
*
|
|
* @author Robert Field
|
|
*/
|
|
public class EventThread extends Thread {
|
|
|
|
private final VirtualMachine vm; // Running VM
|
|
private final String[] excludes; // Packages to exclude
|
|
private final PrintWriter writer; // Where output goes
|
|
|
|
static String nextBaseIndent = ""; // Starting indent for next thread
|
|
|
|
private boolean connected = true; // Connected to VM
|
|
private boolean vmDied = true; // VMDeath occurred
|
|
|
|
// Maps ThreadReference to ThreadTrace instances
|
|
private Map<ThreadReference, ThreadTrace> traceMap =
|
|
new HashMap<>();
|
|
|
|
EventThread(VirtualMachine vm, String[] excludes, PrintWriter writer) {
|
|
super("event-handler");
|
|
this.vm = vm;
|
|
this.excludes = excludes;
|
|
this.writer = writer;
|
|
}
|
|
|
|
/**
|
|
* Run the event handling thread.
|
|
* As long as we are connected, get event sets off
|
|
* the queue and dispatch the events within them.
|
|
*/
|
|
@Override
|
|
public void run() {
|
|
EventQueue queue = vm.eventQueue();
|
|
while (connected) {
|
|
try {
|
|
EventSet eventSet = queue.remove();
|
|
EventIterator it = eventSet.eventIterator();
|
|
while (it.hasNext()) {
|
|
handleEvent(it.nextEvent());
|
|
}
|
|
eventSet.resume();
|
|
} catch (InterruptedException exc) {
|
|
// Ignore
|
|
} catch (VMDisconnectedException discExc) {
|
|
handleDisconnectedException();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create the desired event requests, and enable
|
|
* them so that we will get events.
|
|
* @param excludes Class patterns for which we don't want events
|
|
* @param watchFields Do we want to watch assignments to fields
|
|
*/
|
|
void setEventRequests(boolean watchFields) {
|
|
EventRequestManager mgr = vm.eventRequestManager();
|
|
|
|
// want all exceptions
|
|
ExceptionRequest excReq = mgr.createExceptionRequest(null,
|
|
true, true);
|
|
// suspend so we can step
|
|
excReq.setSuspendPolicy(EventRequest.SUSPEND_ALL);
|
|
excReq.enable();
|
|
|
|
MethodEntryRequest menr = mgr.createMethodEntryRequest();
|
|
for (int i=0; i<excludes.length; ++i) {
|
|
menr.addClassExclusionFilter(excludes[i]);
|
|
}
|
|
menr.setSuspendPolicy(EventRequest.SUSPEND_NONE);
|
|
menr.enable();
|
|
|
|
MethodExitRequest mexr = mgr.createMethodExitRequest();
|
|
for (int i=0; i<excludes.length; ++i) {
|
|
mexr.addClassExclusionFilter(excludes[i]);
|
|
}
|
|
mexr.setSuspendPolicy(EventRequest.SUSPEND_NONE);
|
|
mexr.enable();
|
|
|
|
ThreadDeathRequest tdr = mgr.createThreadDeathRequest();
|
|
// Make sure we sync on thread death
|
|
tdr.setSuspendPolicy(EventRequest.SUSPEND_ALL);
|
|
tdr.enable();
|
|
|
|
if (watchFields) {
|
|
ClassPrepareRequest cpr = mgr.createClassPrepareRequest();
|
|
for (int i=0; i<excludes.length; ++i) {
|
|
cpr.addClassExclusionFilter(excludes[i]);
|
|
}
|
|
cpr.setSuspendPolicy(EventRequest.SUSPEND_ALL);
|
|
cpr.enable();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This class keeps context on events in one thread.
|
|
* In this implementation, context is the indentation prefix.
|
|
*/
|
|
class ThreadTrace {
|
|
final ThreadReference thread;
|
|
final String baseIndent;
|
|
static final String threadDelta = " ";
|
|
StringBuffer indent;
|
|
|
|
ThreadTrace(ThreadReference thread) {
|
|
this.thread = thread;
|
|
this.baseIndent = nextBaseIndent;
|
|
indent = new StringBuffer(baseIndent);
|
|
nextBaseIndent += threadDelta;
|
|
println("====== " + thread.name() + " ======");
|
|
}
|
|
|
|
private void println(String str) {
|
|
writer.print(indent);
|
|
writer.println(str);
|
|
}
|
|
|
|
void methodEntryEvent(MethodEntryEvent event) {
|
|
println(event.method().name() + " -- "
|
|
+ event.method().declaringType().name());
|
|
indent.append("| ");
|
|
}
|
|
|
|
void methodExitEvent(MethodExitEvent event) {
|
|
indent.setLength(indent.length()-2);
|
|
}
|
|
|
|
void fieldWatchEvent(ModificationWatchpointEvent event) {
|
|
Field field = event.field();
|
|
Value value = event.valueToBe();
|
|
println(" " + field.name() + " = " + value);
|
|
}
|
|
|
|
void exceptionEvent(ExceptionEvent event) {
|
|
println("Exception: " + event.exception() +
|
|
" catch: " + event.catchLocation());
|
|
|
|
// Step to the catch
|
|
EventRequestManager mgr = vm.eventRequestManager();
|
|
StepRequest req = mgr.createStepRequest(thread,
|
|
StepRequest.STEP_MIN,
|
|
StepRequest.STEP_INTO);
|
|
req.addCountFilter(1); // next step only
|
|
req.setSuspendPolicy(EventRequest.SUSPEND_ALL);
|
|
req.enable();
|
|
}
|
|
|
|
// Step to exception catch
|
|
void stepEvent(StepEvent event) {
|
|
// Adjust call depth
|
|
int cnt = 0;
|
|
indent = new StringBuffer(baseIndent);
|
|
try {
|
|
cnt = thread.frameCount();
|
|
} catch (IncompatibleThreadStateException exc) {
|
|
}
|
|
while (cnt-- > 0) {
|
|
indent.append("| ");
|
|
}
|
|
|
|
EventRequestManager mgr = vm.eventRequestManager();
|
|
mgr.deleteEventRequest(event.request());
|
|
}
|
|
|
|
void threadDeathEvent(ThreadDeathEvent event) {
|
|
indent = new StringBuffer(baseIndent);
|
|
println("====== " + thread.name() + " end ======");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the ThreadTrace instance for the specified thread,
|
|
* creating one if needed.
|
|
*/
|
|
ThreadTrace threadTrace(ThreadReference thread) {
|
|
ThreadTrace trace = traceMap.get(thread);
|
|
if (trace == null) {
|
|
trace = new ThreadTrace(thread);
|
|
traceMap.put(thread, trace);
|
|
}
|
|
return trace;
|
|
}
|
|
|
|
/**
|
|
* Dispatch incoming events
|
|
*/
|
|
private void handleEvent(Event event) {
|
|
if (event instanceof ExceptionEvent) {
|
|
exceptionEvent((ExceptionEvent)event);
|
|
} else if (event instanceof ModificationWatchpointEvent) {
|
|
fieldWatchEvent((ModificationWatchpointEvent)event);
|
|
} else if (event instanceof MethodEntryEvent) {
|
|
methodEntryEvent((MethodEntryEvent)event);
|
|
} else if (event instanceof MethodExitEvent) {
|
|
methodExitEvent((MethodExitEvent)event);
|
|
} else if (event instanceof StepEvent) {
|
|
stepEvent((StepEvent)event);
|
|
} else if (event instanceof ThreadDeathEvent) {
|
|
threadDeathEvent((ThreadDeathEvent)event);
|
|
} else if (event instanceof ClassPrepareEvent) {
|
|
classPrepareEvent((ClassPrepareEvent)event);
|
|
} else if (event instanceof VMStartEvent) {
|
|
vmStartEvent((VMStartEvent)event);
|
|
} else if (event instanceof VMDeathEvent) {
|
|
vmDeathEvent((VMDeathEvent)event);
|
|
} else if (event instanceof VMDisconnectEvent) {
|
|
vmDisconnectEvent((VMDisconnectEvent)event);
|
|
} else {
|
|
throw new Error("Unexpected event type");
|
|
}
|
|
}
|
|
|
|
/***
|
|
* A VMDisconnectedException has happened while dealing with
|
|
* another event. We need to flush the event queue, dealing only
|
|
* with exit events (VMDeath, VMDisconnect) so that we terminate
|
|
* correctly.
|
|
*/
|
|
synchronized void handleDisconnectedException() {
|
|
EventQueue queue = vm.eventQueue();
|
|
while (connected) {
|
|
try {
|
|
EventSet eventSet = queue.remove();
|
|
EventIterator iter = eventSet.eventIterator();
|
|
while (iter.hasNext()) {
|
|
Event event = iter.nextEvent();
|
|
if (event instanceof VMDeathEvent) {
|
|
vmDeathEvent((VMDeathEvent)event);
|
|
} else if (event instanceof VMDisconnectEvent) {
|
|
vmDisconnectEvent((VMDisconnectEvent)event);
|
|
}
|
|
}
|
|
eventSet.resume(); // Resume the VM
|
|
} catch (InterruptedException exc) {
|
|
// ignore
|
|
}
|
|
}
|
|
}
|
|
|
|
private void vmStartEvent(VMStartEvent event) {
|
|
writer.println("-- VM Started --");
|
|
}
|
|
|
|
// Forward event for thread specific processing
|
|
private void methodEntryEvent(MethodEntryEvent event) {
|
|
threadTrace(event.thread()).methodEntryEvent(event);
|
|
}
|
|
|
|
// Forward event for thread specific processing
|
|
private void methodExitEvent(MethodExitEvent event) {
|
|
threadTrace(event.thread()).methodExitEvent(event);
|
|
}
|
|
|
|
// Forward event for thread specific processing
|
|
private void stepEvent(StepEvent event) {
|
|
threadTrace(event.thread()).stepEvent(event);
|
|
}
|
|
|
|
// Forward event for thread specific processing
|
|
private void fieldWatchEvent(ModificationWatchpointEvent event) {
|
|
threadTrace(event.thread()).fieldWatchEvent(event);
|
|
}
|
|
|
|
void threadDeathEvent(ThreadDeathEvent event) {
|
|
ThreadTrace trace = traceMap.get(event.thread());
|
|
if (trace != null) { // only want threads we care about
|
|
trace.threadDeathEvent(event); // Forward event
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A new class has been loaded.
|
|
* Set watchpoints on each of its fields
|
|
*/
|
|
private void classPrepareEvent(ClassPrepareEvent event) {
|
|
EventRequestManager mgr = vm.eventRequestManager();
|
|
List<Field> fields = event.referenceType().visibleFields();
|
|
for (Field field : fields) {
|
|
ModificationWatchpointRequest req =
|
|
mgr.createModificationWatchpointRequest(field);
|
|
for (int i=0; i<excludes.length; ++i) {
|
|
req.addClassExclusionFilter(excludes[i]);
|
|
}
|
|
req.setSuspendPolicy(EventRequest.SUSPEND_NONE);
|
|
req.enable();
|
|
}
|
|
}
|
|
|
|
private void exceptionEvent(ExceptionEvent event) {
|
|
ThreadTrace trace = traceMap.get(event.thread());
|
|
if (trace != null) { // only want threads we care about
|
|
trace.exceptionEvent(event); // Forward event
|
|
}
|
|
}
|
|
|
|
public void vmDeathEvent(VMDeathEvent event) {
|
|
vmDied = true;
|
|
writer.println("-- The application exited --");
|
|
}
|
|
|
|
public void vmDisconnectEvent(VMDisconnectEvent event) {
|
|
connected = false;
|
|
if (!vmDied) {
|
|
writer.println("-- The application has been disconnected --");
|
|
}
|
|
}
|
|
}
|