/*
|
* Copyright (c) 1998, 2007, 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.
|
*/
|
/*
|
* eventHandler
|
*
|
* This module handles events as they come in directly from JVMTI
|
* and also maps them to JDI events. JDI events are those requested
|
* at the JDI or JDWP level and seen on those levels. Mapping is
|
* one-to-many, a JVMTI event may map to several JDI events, or
|
* to none. Part of that mapping process is filteration, which
|
* eventFilter sub-module handles. A JDI EventRequest corresponds
|
* to a HandlerNode and a JDI filter to the hidden HandlerNode data
|
* used by eventFilter. For example, if at the JDI level the user
|
* executed:
|
*
|
* EventRequestManager erm = vm.eventRequestManager();
|
* BreakpointRequest bp = erm.createBreakpointRequest();
|
* bp.enable();
|
* ClassPrepareRequest req = erm.createClassPrepareRequest();
|
* req.enable();
|
* req = erm.createClassPrepareRequest();
|
* req.addClassFilter("Foo*");
|
* req.enable();
|
*
|
* Three handlers would be created, the first with a LocationOnly
|
* filter and the last with a ClassMatch filter.
|
* When a JVMTI class prepare event for "Foobar"
|
* comes in, the second handler will create one JDI event, the
|
* third handler will compare the class signature, and since
|
* it matchs create a second event. There may also be internal
|
* events as there are in this case, one created by the front-end
|
* and one by the back-end.
|
*
|
* Each event kind has a handler chain, which is a doublely linked
|
* list of handlers for that kind of event.
|
*/
|
#include "util.h"
|
#include "eventHandler.h"
|
#include "eventHandlerRestricted.h"
|
#include "eventFilter.h"
|
#include "eventFilterRestricted.h"
|
#include "standardHandlers.h"
|
#include "threadControl.h"
|
#include "eventHelper.h"
|
#include "classTrack.h"
|
#include "commonRef.h"
|
#include "debugLoop.h"
|
|
static HandlerID requestIdCounter;
|
static jbyte currentSessionID;
|
|
/* Counter of active callbacks and flag for vm_death */
|
static int active_callbacks = 0;
|
static jboolean vm_death_callback_active = JNI_FALSE;
|
static jrawMonitorID callbackLock;
|
static jrawMonitorID callbackBlock;
|
|
/* Macros to surround callback code (non-VM_DEATH callbacks).
|
* Note that this just keeps a count of the non-VM_DEATH callbacks that
|
* are currently active, it does not prevent these callbacks from
|
* operating in parallel. It's the VM_DEATH callback that will wait
|
* for all these callbacks to finish up, so that it can report the
|
* VM_DEATH in a clean state.
|
* If the VM_DEATH callback is active in the BEGIN macro then this
|
* callback just blocks until released by the VM_DEATH callback.
|
* If the VM_DEATH callback is active in the END macro, then this
|
* callback will notify the VM_DEATH callback if it's the last one,
|
* and then block until released by the VM_DEATH callback.
|
* Why block? These threads are often the threads of the Java program,
|
* not blocking might mean that a return would continue execution of
|
* some java thread in the middle of VM_DEATH, this seems troubled.
|
*
|
* WARNING: No not 'return' or 'goto' out of the BEGIN_CALLBACK/END_CALLBACK
|
* block, this will mess up the count.
|
*/
|
|
#define BEGIN_CALLBACK() \
|
{ /* BEGIN OF CALLBACK */ \
|
jboolean bypass = JNI_TRUE; \
|
debugMonitorEnter(callbackLock); { \
|
if (vm_death_callback_active) { \
|
/* allow VM_DEATH callback to finish */ \
|
debugMonitorExit(callbackLock); \
|
/* Now block because VM is about to die */ \
|
debugMonitorEnter(callbackBlock); \
|
debugMonitorExit(callbackBlock); \
|
} else { \
|
active_callbacks++; \
|
bypass = JNI_FALSE; \
|
debugMonitorExit(callbackLock); \
|
} \
|
} \
|
if ( !bypass ) { \
|
/* BODY OF CALLBACK CODE */
|
|
#define END_CALLBACK() /* Part of bypass if body */ \
|
debugMonitorEnter(callbackLock); { \
|
active_callbacks--; \
|
if (active_callbacks < 0) { \
|
EXIT_ERROR(0, "Problems tracking active callbacks"); \
|
} \
|
if (vm_death_callback_active) { \
|
if (active_callbacks == 0) { \
|
debugMonitorNotifyAll(callbackLock); \
|
} \
|
/* allow VM_DEATH callback to finish */ \
|
debugMonitorExit(callbackLock); \
|
/* Now block because VM is about to die */ \
|
debugMonitorEnter(callbackBlock); \
|
debugMonitorExit(callbackBlock); \
|
} else { \
|
debugMonitorExit(callbackLock); \
|
} \
|
} \
|
} \
|
} /* END OF CALLBACK */
|
|
/*
|
* We are starting with a very simple locking scheme
|
* for event handling. All readers and writers of data in
|
* the handlers[] chain must own this lock for the duration
|
* of its use. If contention becomes a problem, we can:
|
*
|
* 1) create a lock per event type.
|
* 2) move to a readers/writers approach where multiple threads
|
* can access the chains simultaneously while reading (the
|
* normal activity of an event callback).
|
*/
|
static jrawMonitorID handlerLock;
|
|
typedef struct HandlerChain_ {
|
HandlerNode *first;
|
/* add lock here */
|
} HandlerChain;
|
|
/*
|
* This array maps event kinds to handler chains.
|
* Protected by handlerLock.
|
*/
|
|
static HandlerChain __handlers[EI_max-EI_min+1];
|
|
/* Given a HandlerNode, these access our private data.
|
*/
|
#define PRIVATE_DATA(node) \
|
(&(((EventHandlerRestricted_HandlerNode*)(void*)(node))->private_ehpd))
|
|
#define NEXT(node) (PRIVATE_DATA(node)->private_next)
|
#define PREV(node) (PRIVATE_DATA(node)->private_prev)
|
#define CHAIN(node) (PRIVATE_DATA(node)->private_chain)
|
#define HANDLER_FUNCTION(node) (PRIVATE_DATA(node)->private_handlerFunction)
|
|
static jclass getObjectClass(jobject object);
|
static jvmtiError freeHandler(HandlerNode *node);
|
|
static jvmtiError freeHandlerChain(HandlerChain *chain);
|
|
static HandlerChain *
|
getHandlerChain(EventIndex i)
|
{
|
if ( i < EI_min || i > EI_max ) {
|
EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,"bad index for handler");
|
}
|
return &(__handlers[i-EI_min]);
|
}
|
|
static void
|
insert(HandlerChain *chain, HandlerNode *node)
|
{
|
HandlerNode *oldHead = chain->first;
|
NEXT(node) = oldHead;
|
PREV(node) = NULL;
|
CHAIN(node) = chain;
|
if (oldHead != NULL) {
|
PREV(oldHead) = node;
|
}
|
chain->first = node;
|
}
|
|
static HandlerNode *
|
findInChain(HandlerChain *chain, HandlerID handlerID)
|
{
|
HandlerNode *node = chain->first;
|
while (node != NULL) {
|
if (node->handlerID == handlerID) {
|
return node;
|
}
|
node = NEXT(node);
|
}
|
return NULL;
|
}
|
|
static HandlerNode *
|
find(EventIndex ei, HandlerID handlerID)
|
{
|
return findInChain(getHandlerChain(ei), handlerID);
|
}
|
|
/**
|
* Deinsert. Safe for non-inserted nodes.
|
*/
|
static void
|
deinsert(HandlerNode *node)
|
{
|
HandlerChain *chain = CHAIN(node);
|
|
if (chain == NULL) {
|
return;
|
}
|
if (chain->first == node) {
|
chain->first = NEXT(node);
|
}
|
if (NEXT(node) != NULL) {
|
PREV(NEXT(node)) = PREV(node);
|
}
|
if (PREV(node) != NULL) {
|
NEXT(PREV(node)) = NEXT(node);
|
}
|
CHAIN(node) = NULL;
|
}
|
|
jboolean
|
eventHandlerRestricted_iterator(EventIndex ei,
|
IteratorFunction func, void *arg)
|
{
|
HandlerChain *chain;
|
HandlerNode *node;
|
JNIEnv *env;
|
|
chain = getHandlerChain(ei);
|
node = chain->first;
|
env = getEnv();
|
|
if ( func == NULL ) {
|
EXIT_ERROR(AGENT_ERROR_INTERNAL,"iterator function NULL");
|
}
|
|
while (node != NULL) {
|
if (((func)(env, node, arg))) {
|
return JNI_TRUE;
|
}
|
node = NEXT(node);
|
}
|
return JNI_FALSE;
|
}
|
|
/* BREAKPOINT, METHOD_ENTRY and SINGLE_STEP events are covered by
|
* the co-location of events policy. Of these three co-located
|
* events, METHOD_ENTRY is always reported first and BREAKPOINT
|
* is always reported last. Here are the possible combinations and
|
* their order:
|
*
|
* (p1) METHOD_ENTRY, BREAKPOINT (existing)
|
* (p2) METHOD_ENTRY, BREAKPOINT (new)
|
* (p1) METHOD_ENTRY, SINGLE_STEP
|
* (p1) METHOD_ENTRY, SINGLE_STEP, BREAKPOINT (existing)
|
* (p1/p2) METHOD_ENTRY, SINGLE_STEP, BREAKPOINT (new)
|
* (p1) SINGLE_STEP, BREAKPOINT (existing)
|
* (p2) SINGLE_STEP, BREAKPOINT (new)
|
*
|
* BREAKPOINT (existing) indicates a BREAKPOINT that is set before
|
* the other co-located event is posted. BREAKPOINT (new) indicates
|
* a BREAKPOINT that is set after the other co-located event is
|
* posted and before the thread has resumed execution.
|
*
|
* Co-location of events policy used to be implemented via
|
* temporary BREAKPOINTs along with deferring the reporting of
|
* non-BREAKPOINT co-located events, but the temporary BREAKPOINTs
|
* caused performance problems on VMs where setting or clearing
|
* BREAKPOINTs is expensive, e.g., HotSpot.
|
*
|
* The policy is now implemented in two phases. Phase 1: when a
|
* METHOD_ENTRY or SINGLE_STEP event is received, if there is an
|
* existing co-located BREAKPOINT, then the current event is
|
* deferred. When the BREAKPOINT event is processed, the event
|
* bag will contain the deferred METHOD_ENTRY and/or SINGLE_STEP
|
* events along with the BREAKPOINT event. For a METHOD_ENTRY
|
* event where there is not an existing co-located BREAKPOINT,
|
* if SINGLE_STEP events are also enabled for the thread, then
|
* the METHOD_ENTRY event is deferred. When the SINGLE_STEP event
|
* is processed, the event bag will also contain the deferred
|
* METHOD_ENTRY event. This covers each of the combinations
|
* marked with 'p1' above.
|
*
|
* Phase 2: if there is no existing co-located BREAKPOINT, then the
|
* location information for the METHOD_ENTRY or SINGLE_STEP event
|
* is recorded in the ThreadNode. If the next event for the thread
|
* is a co-located BREAKPOINT, then the first BREAKPOINT event will
|
* be skipped since it cannot be delivered in the same event set.
|
* This covers each of the combinations marked with 'p2' above.
|
*
|
* For the combination marked p1/p2, part of the case is handled
|
* during phase 1 and the rest is handled during phase 2.
|
*
|
* The recording of information in the ThreadNode is handled in
|
* this routine. The special handling of the next event for the
|
* thread is handled in skipEventReport().
|
*/
|
|
static jboolean
|
deferEventReport(JNIEnv *env, jthread thread,
|
EventIndex ei, jclass clazz, jmethodID method, jlocation location)
|
{
|
jboolean deferring = JNI_FALSE;
|
|
switch (ei) {
|
case EI_METHOD_ENTRY:
|
if (!isMethodNative(method)) {
|
jvmtiError error;
|
jlocation start;
|
jlocation end;
|
error = methodLocation(method, &start, &end);
|
if (error == JVMTI_ERROR_NONE) {
|
deferring = isBreakpointSet(clazz, method, start) ||
|
threadControl_getInstructionStepMode(thread)
|
== JVMTI_ENABLE;
|
if (!deferring) {
|
threadControl_saveCLEInfo(env, thread, ei,
|
clazz, method, start);
|
}
|
}
|
}
|
break;
|
case EI_SINGLE_STEP:
|
deferring = isBreakpointSet(clazz, method, location);
|
if (!deferring) {
|
threadControl_saveCLEInfo(env, thread, ei,
|
clazz, method, location);
|
}
|
break;
|
default:
|
break;
|
}
|
/* TO DO: Once JVMTI supports a way to know if we're
|
* at the end of a method, we should check here for
|
* break and step events which precede a method exit
|
* event.
|
*/
|
return deferring;
|
}
|
|
/* Handle phase 2 of the co-located events policy. See detailed
|
* comments in deferEventReport() above.
|
*/
|
static jboolean
|
skipEventReport(JNIEnv *env, jthread thread, EventIndex ei,
|
jclass clazz, jmethodID method, jlocation location)
|
{
|
jboolean skipping = JNI_FALSE;
|
|
if (ei == EI_BREAKPOINT) {
|
if (threadControl_cmpCLEInfo(env, thread, clazz, method, location)) {
|
LOG_MISC(("Co-located breakpoint event found: "
|
"%s,thread=%p,clazz=%p,method=%p,location=%d",
|
eventText(ei), thread, clazz, method, location));
|
skipping = JNI_TRUE;
|
}
|
}
|
|
threadControl_clearCLEInfo(env, thread);
|
|
return skipping;
|
}
|
|
static void
|
reportEvents(JNIEnv *env, jbyte sessionID, jthread thread, EventIndex ei,
|
jclass clazz, jmethodID method, jlocation location,
|
struct bag *eventBag)
|
{
|
jbyte suspendPolicy;
|
jboolean invoking;
|
|
if (bagSize(eventBag) < 1) {
|
return;
|
}
|
|
/*
|
* Never report events before initialization completes
|
*/
|
if (!debugInit_isInitComplete()) {
|
return;
|
}
|
|
/*
|
* Check to see if we should skip reporting this event due to
|
* co-location of events policy.
|
*/
|
if (thread != NULL &&
|
skipEventReport(env, thread, ei, clazz, method, location)) {
|
LOG_MISC(("event report being skipped: "
|
"ei=%s,thread=%p,clazz=%p,method=%p,location=%d",
|
eventText(ei), thread, clazz, method, location));
|
bagDeleteAll(eventBag);
|
return;
|
}
|
|
/* We delay the reporting of some events so that they can be
|
* properly grouped into event sets with upcoming events. If
|
* the reporting is to be deferred, the event commands remain
|
* in the event bag until a subsequent event occurs. Event is
|
* NULL for synthetic events (e.g. unload).
|
*/
|
if (thread == NULL
|
|| !deferEventReport(env, thread, ei,
|
clazz, method, location)) {
|
struct bag *completedBag = bagDup(eventBag);
|
bagDeleteAll(eventBag);
|
if (completedBag == NULL) {
|
/*
|
* TO DO: Report, but don't terminate?
|
*/
|
return;
|
} else {
|
suspendPolicy = eventHelper_reportEvents(sessionID, completedBag);
|
if (thread != NULL && suspendPolicy != JDWP_SUSPEND_POLICY(NONE)) {
|
do {
|
/* The events have been reported and this
|
* thread is about to continue, but it may
|
* have been started up up just to perform a
|
* requested method invocation. If so, we do
|
* the invoke now and then stop again waiting
|
* for another continue. By then another
|
* invoke request can be in place, so there is
|
* a loop around this code.
|
*/
|
invoking = invoker_doInvoke(thread);
|
if (invoking) {
|
eventHelper_reportInvokeDone(sessionID, thread);
|
}
|
} while (invoking);
|
}
|
bagDestroyBag(completedBag);
|
}
|
}
|
}
|
|
/* A bagEnumerateFunction. Create a synthetic class unload event
|
* for every class no longer present. Analogous to event_callback
|
* combined with a handler in a unload specific (no event
|
* structure) kind of way.
|
*/
|
static jboolean
|
synthesizeUnloadEvent(void *signatureVoid, void *envVoid)
|
{
|
JNIEnv *env = (JNIEnv *)envVoid;
|
char *signature = *(char **)signatureVoid;
|
char *classname;
|
HandlerNode *node;
|
jbyte eventSessionID = currentSessionID;
|
struct bag *eventBag = eventHelper_createEventBag();
|
|
if (eventBag == NULL) {
|
/* TO DO: Report, but don't die
|
*/
|
JDI_ASSERT(eventBag != NULL);
|
}
|
|
/* Signature needs to last, so convert extra copy to
|
* classname
|
*/
|
classname = jvmtiAllocate((int)strlen(signature)+1);
|
(void)strcpy(classname, signature);
|
convertSignatureToClassname(classname);
|
|
debugMonitorEnter(handlerLock);
|
|
node = getHandlerChain(EI_GC_FINISH)->first;
|
while (node != NULL) {
|
/* save next so handlers can remove themselves */
|
HandlerNode *next = NEXT(node);
|
jboolean shouldDelete;
|
|
if (eventFilterRestricted_passesUnloadFilter(env, classname,
|
node,
|
&shouldDelete)) {
|
/* There may be multiple handlers, the signature will
|
* be freed when the event helper thread has written
|
* it. So each event needs a separate allocation.
|
*/
|
char *durableSignature = jvmtiAllocate((int)strlen(signature)+1);
|
(void)strcpy(durableSignature, signature);
|
|
eventHelper_recordClassUnload(node->handlerID,
|
durableSignature,
|
eventBag);
|
}
|
if (shouldDelete) {
|
/* We can safely free the node now that we are done
|
* using it.
|
*/
|
(void)freeHandler(node);
|
}
|
node = next;
|
}
|
|
debugMonitorExit(handlerLock);
|
|
if (eventBag != NULL) {
|
reportEvents(env, eventSessionID, (jthread)NULL, 0,
|
(jclass)NULL, (jmethodID)NULL, 0, eventBag);
|
|
/*
|
* bag was created locally, destroy it here.
|
*/
|
bagDestroyBag(eventBag);
|
}
|
|
jvmtiDeallocate(signature);
|
jvmtiDeallocate(classname);
|
|
return JNI_TRUE;
|
}
|
|
/* Garbage Collection Happened */
|
static unsigned int garbageCollected = 0;
|
|
/* The JVMTI generic event callback. Each event is passed to a sequence of
|
* handlers in a chain until the chain ends or one handler
|
* consumes the event.
|
*/
|
static void
|
event_callback(JNIEnv *env, EventInfo *evinfo)
|
{
|
struct bag *eventBag;
|
jbyte eventSessionID = currentSessionID; /* session could change */
|
jthrowable currentException;
|
jthread thread;
|
|
LOG_MISC(("event_callback(): ei=%s", eventText(evinfo->ei)));
|
log_debugee_location("event_callback()", evinfo->thread, evinfo->method, evinfo->location);
|
|
/* We want to preserve any current exception that might get
|
* wiped out during event handling (e.g. JNI calls). We have
|
* to rely on space for the local reference on the current
|
* frame because doing a PushLocalFrame here might itself
|
* generate an exception.
|
*/
|
currentException = JNI_FUNC_PTR(env,ExceptionOccurred)(env);
|
JNI_FUNC_PTR(env,ExceptionClear)(env);
|
|
/* See if a garbage collection finish event happened earlier.
|
*
|
* Note: The "if" is an optimization to avoid entering the lock on every
|
* event; garbageCollected may be zapped before we enter
|
* the lock but then this just becomes one big no-op.
|
*/
|
if ( garbageCollected > 0 ) {
|
struct bag *unloadedSignatures = NULL;
|
|
/* We want to compact the hash table of all
|
* objects sent to the front end by removing objects that have
|
* been collected.
|
*/
|
commonRef_compact();
|
|
/* We also need to simulate the class unload events. */
|
|
debugMonitorEnter(handlerLock);
|
|
/* Clear garbage collection counter */
|
garbageCollected = 0;
|
|
/* Analyze which class unloads occurred */
|
unloadedSignatures = classTrack_processUnloads(env);
|
|
debugMonitorExit(handlerLock);
|
|
/* Generate the synthetic class unload events and/or just cleanup. */
|
if ( unloadedSignatures != NULL ) {
|
(void)bagEnumerateOver(unloadedSignatures, synthesizeUnloadEvent,
|
(void *)env);
|
bagDestroyBag(unloadedSignatures);
|
}
|
}
|
|
thread = evinfo->thread;
|
if (thread != NULL) {
|
/*
|
* Record the fact that we're entering an event
|
* handler so that thread operations (status, interrupt,
|
* stop) can be done correctly and so that thread
|
* resources can be allocated. This must be done before
|
* grabbing any locks.
|
*/
|
eventBag = threadControl_onEventHandlerEntry(eventSessionID,
|
evinfo->ei, thread, currentException);
|
if ( eventBag == NULL ) {
|
jboolean invoking;
|
do {
|
/* The event has been 'handled' and this
|
* thread is about to continue, but it may
|
* have been started up just to perform a
|
* requested method invocation. If so, we do
|
* the invoke now and then stop again waiting
|
* for another continue. By then another
|
* invoke request can be in place, so there is
|
* a loop around this code.
|
*/
|
invoking = invoker_doInvoke(thread);
|
if (invoking) {
|
eventHelper_reportInvokeDone(eventSessionID, thread);
|
}
|
} while (invoking);
|
return; /* Do nothing, event was consumed */
|
}
|
} else {
|
eventBag = eventHelper_createEventBag();
|
if (eventBag == NULL) {
|
/*
|
* TO DO: Report, but don't die
|
*/
|
eventBag = NULL; /* to shut up lint */
|
}
|
}
|
|
debugMonitorEnter(handlerLock);
|
{
|
HandlerNode *node;
|
char *classname;
|
|
/* We must keep track of all classes prepared to know what's unloaded */
|
if (evinfo->ei == EI_CLASS_PREPARE) {
|
classTrack_addPreparedClass(env, evinfo->clazz);
|
}
|
|
node = getHandlerChain(evinfo->ei)->first;
|
classname = getClassname(evinfo->clazz);
|
|
while (node != NULL) {
|
/* save next so handlers can remove themselves */
|
HandlerNode *next = NEXT(node);
|
jboolean shouldDelete;
|
|
if (eventFilterRestricted_passesFilter(env, classname,
|
evinfo, node,
|
&shouldDelete)) {
|
HandlerFunction func;
|
|
func = HANDLER_FUNCTION(node);
|
if ( func == NULL ) {
|
EXIT_ERROR(AGENT_ERROR_INTERNAL,"handler function NULL");
|
}
|
(*func)(env, evinfo, node, eventBag);
|
}
|
if (shouldDelete) {
|
/* We can safely free the node now that we are done
|
* using it.
|
*/
|
(void)freeHandler(node);
|
}
|
node = next;
|
}
|
jvmtiDeallocate(classname);
|
}
|
debugMonitorExit(handlerLock);
|
|
if (eventBag != NULL) {
|
reportEvents(env, eventSessionID, thread, evinfo->ei,
|
evinfo->clazz, evinfo->method, evinfo->location, eventBag);
|
}
|
|
/* we are continuing after VMDeathEvent - now we are dead */
|
if (evinfo->ei == EI_VM_DEATH) {
|
gdata->vmDead = JNI_TRUE;
|
}
|
|
/*
|
* If the bag was created locally, destroy it here.
|
*/
|
if (thread == NULL) {
|
bagDestroyBag(eventBag);
|
}
|
|
/* Always restore any exception that was set beforehand. If
|
* there is a pending async exception, StopThread will be
|
* called from threadControl_onEventHandlerExit immediately
|
* below. Depending on VM implementation and state, the async
|
* exception might immediately overwrite the currentException,
|
* or it might be delayed until later. */
|
if (currentException != NULL) {
|
JNI_FUNC_PTR(env,Throw)(env, currentException);
|
} else {
|
JNI_FUNC_PTR(env,ExceptionClear)(env);
|
}
|
|
/*
|
* Release thread resources and perform any delayed operations.
|
*/
|
if (thread != NULL) {
|
threadControl_onEventHandlerExit(evinfo->ei, thread, eventBag);
|
}
|
}
|
|
/* Returns a local ref to the declaring class for an object. */
|
static jclass
|
getObjectClass(jobject object)
|
{
|
jclass clazz;
|
JNIEnv *env = getEnv();
|
|
clazz = JNI_FUNC_PTR(env,GetObjectClass)(env, object);
|
|
return clazz;
|
}
|
|
/* Returns a local ref to the declaring class for a method, or NULL. */
|
jclass
|
getMethodClass(jvmtiEnv *jvmti_env, jmethodID method)
|
{
|
jclass clazz = NULL;
|
jvmtiError error;
|
|
if ( method == NULL ) {
|
return NULL;
|
}
|
error = methodClass(method, &clazz);
|
if ( error != JVMTI_ERROR_NONE ) {
|
EXIT_ERROR(error,"Can't get jclass for a methodID, invalid?");
|
return NULL;
|
}
|
return clazz;
|
}
|
|
/* ANDROID-CHANGED: Android keeps track of object unloads by watching this event instead of looking
|
* through jweaks since there are a limited number of those. This does not cause any corresponding
|
* jdwp event and is merely passed on to the commonRef system.
|
*/
|
static void JNICALL
|
cbObjectFree(jvmtiEnv* jvmti_env, jlong tag)
|
{
|
commonRef_handleFreedObject(tag);
|
}
|
|
/* Event callback for JVMTI_EVENT_SINGLE_STEP */
|
static void JNICALL
|
cbSingleStep(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method, jlocation location)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbSingleStep: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_SINGLE_STEP;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.location = location;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbSingleStep"));
|
}
|
|
/* Event callback for JVMTI_EVENT_BREAKPOINT */
|
static void JNICALL
|
cbBreakpoint(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method, jlocation location)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbBreakpoint: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_BREAKPOINT;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.location = location;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbBreakpoint"));
|
}
|
|
/* Event callback for JVMTI_EVENT_FRAME_POP */
|
static void JNICALL
|
cbFramePop(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method,
|
jboolean wasPoppedByException)
|
{
|
EventInfo info;
|
|
/* JDWP does not return these events when popped due to an exception. */
|
if ( wasPoppedByException ) {
|
return;
|
}
|
|
LOG_CB(("cbFramePop: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_FRAME_POP;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbFramePop"));
|
}
|
|
/* Event callback for JVMTI_EVENT_EXCEPTION */
|
static void JNICALL
|
cbException(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method,
|
jlocation location, jobject exception,
|
jmethodID catch_method, jlocation catch_location)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbException: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_EXCEPTION;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.location = location;
|
info.object = exception;
|
info.u.exception.catch_clazz = getMethodClass(jvmti_env, catch_method);
|
info.u.exception.catch_method = catch_method;
|
info.u.exception.catch_location = catch_location;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbException"));
|
}
|
|
/* Event callback for JVMTI_EVENT_THREAD_START */
|
static void JNICALL
|
cbThreadStart(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbThreadStart: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_THREAD_START;
|
info.thread = thread;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbThreadStart"));
|
}
|
|
/* Event callback for JVMTI_EVENT_THREAD_END */
|
static void JNICALL
|
cbThreadEnd(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbThreadEnd: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_THREAD_END;
|
info.thread = thread;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbThreadEnd"));
|
}
|
|
/* Event callback for JVMTI_EVENT_CLASS_PREPARE */
|
static void JNICALL
|
cbClassPrepare(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jclass klass)
|
{
|
/* ANDROID-CHANGED: b/111394423 Android sends ClassPrepare events for arrays too. We don't
|
* really care about these though and they can cause deadlocks since they may be sent on jit
|
* threads so just ignore them.
|
*/
|
if (isArrayClass(klass)) {
|
return;
|
}
|
EventInfo info;
|
|
LOG_CB(("cbClassPrepare: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_CLASS_PREPARE;
|
info.thread = thread;
|
info.clazz = klass;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbClassPrepare"));
|
}
|
|
/* Event callback for JVMTI_EVENT_GARBAGE_COLLECTION_FINISH */
|
static void JNICALL
|
cbGarbageCollectionFinish(jvmtiEnv *jvmti_env)
|
{
|
LOG_CB(("cbGarbageCollectionFinish"));
|
++garbageCollected;
|
LOG_MISC(("END cbGarbageCollectionFinish"));
|
}
|
|
/* Event callback for JVMTI_EVENT_CLASS_LOAD */
|
static void JNICALL
|
cbClassLoad(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jclass klass)
|
{
|
/* ANDROID-CHANGED: b/111394423 Android sends ClassLoad events for arrays too. We don't really
|
* care about these though and they can cause deadlocks since they may be sent on jit threads so
|
* just ignore them.
|
*/
|
if (isArrayClass(klass)) {
|
return;
|
}
|
EventInfo info;
|
|
LOG_CB(("cbClassLoad: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_CLASS_LOAD;
|
info.thread = thread;
|
info.clazz = klass;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbClassLoad"));
|
}
|
|
/* Event callback for JVMTI_EVENT_FIELD_ACCESS */
|
static void JNICALL
|
cbFieldAccess(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method,
|
jlocation location, jclass field_klass,
|
jobject object, jfieldID field)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbFieldAccess: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_FIELD_ACCESS;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.location = location;
|
info.u.field_access.field_clazz = field_klass;
|
info.object = object;
|
info.u.field_access.field = field;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbFieldAccess"));
|
}
|
|
/* Event callback for JVMTI_EVENT_FIELD_MODIFICATION */
|
static void JNICALL
|
cbFieldModification(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method,
|
jlocation location, jclass field_klass, jobject object, jfieldID field,
|
char signature_type, jvalue new_value)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbFieldModification: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_FIELD_MODIFICATION;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.location = location;
|
info.u.field_modification.field = field;
|
info.u.field_modification.field_clazz = field_klass;
|
info.object = object;
|
info.u.field_modification.signature_type= signature_type;
|
info.u.field_modification.new_value = new_value;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbFieldModification"));
|
}
|
|
/* Event callback for JVMTI_EVENT_EXCEPTION_CATCH */
|
static void JNICALL
|
cbExceptionCatch(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread,
|
jmethodID method, jlocation location, jobject exception)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbExceptionCatch: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_EXCEPTION_CATCH;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.location = location;
|
info.object = exception;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbExceptionCatch"));
|
}
|
|
/* Event callback for JVMTI_EVENT_METHOD_ENTRY */
|
static void JNICALL
|
cbMethodEntry(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbMethodEntry: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_METHOD_ENTRY;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbMethodEntry"));
|
}
|
|
/* Event callback for JVMTI_EVENT_METHOD_EXIT */
|
static void JNICALL
|
cbMethodExit(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jmethodID method,
|
jboolean wasPoppedByException, jvalue return_value)
|
{
|
EventInfo info;
|
|
/* JDWP does not return these events when popped due to an exception. */
|
if ( wasPoppedByException ) {
|
return;
|
}
|
|
LOG_CB(("cbMethodExit: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_METHOD_EXIT;
|
info.thread = thread;
|
info.clazz = getMethodClass(jvmti_env, method);
|
info.method = method;
|
info.u.method_exit.return_value = return_value;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbMethodExit"));
|
}
|
|
/* Event callback for JVMTI_EVENT_MONITOR_CONTENDED_ENTER */
|
static void JNICALL
|
cbMonitorContendedEnter(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jobject object)
|
{
|
EventInfo info;
|
jvmtiError error;
|
jmethodID method;
|
jlocation location;
|
|
LOG_CB(("cbMonitorContendedEnter: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_MONITOR_CONTENDED_ENTER;
|
info.thread = thread;
|
info.object = object;
|
/* get current location of contended monitor enter */
|
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameLocation)
|
(gdata->jvmti, thread, 0, &method, &location);
|
if (error == JVMTI_ERROR_NONE) {
|
info.location = location;
|
info.method = method;
|
info.clazz = getMethodClass(jvmti_env, method);
|
} else {
|
info.location = -1;
|
}
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbMonitorContendedEnter"));
|
}
|
|
/* Event callback for JVMTI_EVENT_MONITOR_CONTENDED_ENTERED */
|
static void JNICALL
|
cbMonitorContendedEntered(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jobject object)
|
{
|
EventInfo info;
|
jvmtiError error;
|
jmethodID method;
|
jlocation location;
|
|
LOG_CB(("cbMonitorContendedEntered: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_MONITOR_CONTENDED_ENTERED;
|
info.thread = thread;
|
info.object = object;
|
/* get current location of contended monitor enter */
|
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameLocation)
|
(gdata->jvmti, thread, 0, &method, &location);
|
if (error == JVMTI_ERROR_NONE) {
|
info.location = location;
|
info.method = method;
|
info.clazz = getMethodClass(jvmti_env, method);
|
} else {
|
info.location = -1;
|
}
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbMonitorContendedEntered"));
|
}
|
|
/* Event callback for JVMTI_EVENT_MONITOR_WAIT */
|
static void JNICALL
|
cbMonitorWait(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jobject object,
|
jlong timeout)
|
{
|
EventInfo info;
|
jvmtiError error;
|
jmethodID method;
|
jlocation location;
|
|
LOG_CB(("cbMonitorWait: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_MONITOR_WAIT;
|
info.thread = thread;
|
info.object = object;
|
/* The info.clazz is used for both class filtering and for location info.
|
* For monitor wait event the class filtering is done for class of monitor
|
* object. So here info.clazz is set to class of monitor object here and it
|
* is reset to class of method before writing location info.
|
* See writeMonitorEvent in eventHelper.c
|
*/
|
info.clazz = getObjectClass(object);
|
info.u.monitor.timeout = timeout;
|
|
/* get location of monitor wait() method. */
|
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameLocation)
|
(gdata->jvmti, thread, 0, &method, &location);
|
if (error == JVMTI_ERROR_NONE) {
|
info.location = location;
|
info.method = method;
|
} else {
|
info.location = -1;
|
}
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbMonitorWait"));
|
}
|
|
/* Event callback for JVMTI_EVENT_MONITOR_WAIT */
|
static void JNICALL
|
cbMonitorWaited(jvmtiEnv *jvmti_env, JNIEnv *env,
|
jthread thread, jobject object,
|
jboolean timed_out)
|
{
|
EventInfo info;
|
jvmtiError error;
|
jmethodID method;
|
jlocation location;
|
|
LOG_CB(("cbMonitorWaited: thread=%p", thread));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_MONITOR_WAITED;
|
info.thread = thread;
|
info.object = object;
|
/* The info.clazz is used for both class filtering and for location info.
|
* For monitor waited event the class filtering is done for class of monitor
|
* object. So here info.clazz is set to class of monitor object here and it
|
* is reset to class of method before writing location info.
|
* See writeMonitorEvent in eventHelper.c
|
*/
|
info.clazz = getObjectClass(object);
|
info.u.monitor.timed_out = timed_out;
|
|
/* get location of monitor wait() method */
|
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameLocation)
|
(gdata->jvmti, thread, 0, &method, &location);
|
if (error == JVMTI_ERROR_NONE) {
|
info.location = location;
|
info.method = method;
|
} else {
|
info.location = -1;
|
}
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbMonitorWaited"));
|
}
|
|
/* Event callback for JVMTI_EVENT_VM_INIT */
|
static void JNICALL
|
cbVMInit(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thread)
|
{
|
EventInfo info;
|
|
LOG_CB(("cbVMInit"));
|
|
BEGIN_CALLBACK() {
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_VM_INIT;
|
info.thread = thread;
|
event_callback(env, &info);
|
} END_CALLBACK();
|
|
LOG_MISC(("END cbVMInit"));
|
}
|
|
/* Event callback for JVMTI_EVENT_VM_DEATH */
|
static void JNICALL
|
cbVMDeath(jvmtiEnv *jvmti_env, JNIEnv *env)
|
{
|
jvmtiError error;
|
EventInfo info;
|
LOG_CB(("cbVMDeath"));
|
|
/* Clear out ALL callbacks at this time, we don't want any more. */
|
/* This should prevent any new BEGIN_CALLBACK() calls. */
|
(void)memset(&(gdata->callbacks),0,sizeof(gdata->callbacks));
|
error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks)
|
(gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks));
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't clear event callbacks on vm death");
|
}
|
|
/* Now that no new callbacks will be made, we need to wait for the ones
|
* that are still active to complete.
|
* The BEGIN_CALLBACK/END_CALLBACK macros implement the VM_DEATH
|
* callback protocol. Once the callback table is cleared (above),
|
* we can have callback threads in different stages:
|
* 1) after callback function entry and before BEGIN_CALLBACK
|
* macro; we catch these threads with callbackBlock in the
|
* BEGIN_CALLBACK macro
|
* 2) after BEGIN_CALLBACK macro and before END_CALLBACK macro; we
|
* catch these threads with callbackBlock in the END_CALLBACK
|
* macro
|
* 3) after END_CALLBACK macro; these threads have made it past
|
* callbackBlock and callbackLock and don't count as active
|
*
|
* Since some of the callback threads could be blocked or suspended
|
* we will resume all threads suspended by the debugger for a short
|
* time to flush out all callbacks. Note that the callback threads
|
* will block from returning to the VM in both macros. Some threads
|
* not associated with callbacks, but suspended by the debugger may
|
* continue on, but not for long.
|
* Once the last callback finishes, it will notify this thread and
|
* we fall out of the loop below and actually process the VM_DEATH
|
* event.
|
*/
|
debugMonitorEnter(callbackBlock); {
|
debugMonitorEnter(callbackLock); {
|
vm_death_callback_active = JNI_TRUE;
|
(void)threadControl_resumeAll();
|
while (active_callbacks > 0) {
|
/* wait for active CALLBACKs to check in (and block) */
|
debugMonitorWait(callbackLock);
|
}
|
} debugMonitorExit(callbackLock);
|
|
/* Only now should we actually process the VM death event */
|
(void)memset(&info,0,sizeof(info));
|
info.ei = EI_VM_DEATH;
|
event_callback(env, &info);
|
|
/* Here we unblock all the callbacks and let them return to the
|
* VM. It's not clear this is necessary, but leaving threads
|
* blocked doesn't seem like a good idea. They don't have much
|
* life left anyway.
|
*/
|
} debugMonitorExit(callbackBlock);
|
|
/*
|
* The VM will die soon after the completion of this callback - we
|
* may need to do a final synchronization with the command loop to
|
* avoid the VM terminating with replying to the final (resume)
|
* command.
|
*/
|
debugLoop_sync();
|
|
LOG_MISC(("END cbVMDeath"));
|
}
|
|
/**
|
* Delete this handler (do not delete permanent handlers):
|
* Deinsert handler from active list,
|
* make it inactive, and free it's memory
|
* Assumes handlerLock held.
|
*/
|
static jvmtiError
|
freeHandler(HandlerNode *node) {
|
jvmtiError error = JVMTI_ERROR_NONE;
|
|
/* deinsert the handler node before disableEvents() to make
|
* sure the event will be disabled when no other event
|
* handlers are installed.
|
*/
|
if (node != NULL && (!node->permanent)) {
|
deinsert(node);
|
error = eventFilterRestricted_deinstall(node);
|
jvmtiDeallocate(node);
|
}
|
|
return error;
|
}
|
|
/**
|
* Delete all the handlers on this chain (do not delete permanent handlers).
|
* Assumes handlerLock held.
|
*/
|
static jvmtiError
|
freeHandlerChain(HandlerChain *chain)
|
{
|
HandlerNode *node;
|
jvmtiError error;
|
|
error = JVMTI_ERROR_NONE;
|
node = chain->first;
|
while ( node != NULL ) {
|
HandlerNode *next;
|
jvmtiError singleError;
|
|
next = NEXT(node);
|
singleError = freeHandler(node);
|
if ( singleError != JVMTI_ERROR_NONE ) {
|
error = singleError;
|
}
|
node = next;
|
}
|
return error;
|
}
|
|
/**
|
* Deinsert and free all memory. Safe for non-inserted nodes.
|
*/
|
jvmtiError
|
eventHandler_free(HandlerNode *node)
|
{
|
jvmtiError error;
|
|
debugMonitorEnter(handlerLock);
|
|
error = freeHandler(node);
|
|
debugMonitorExit(handlerLock);
|
|
return error;
|
}
|
|
/**
|
* Free all handlers of this kind created by the JDWP client,
|
* that is, doesn't free handlers internally created by back-end.
|
*/
|
jvmtiError
|
eventHandler_freeAll(EventIndex ei)
|
{
|
jvmtiError error = JVMTI_ERROR_NONE;
|
HandlerNode *node;
|
|
debugMonitorEnter(handlerLock);
|
node = getHandlerChain(ei)->first;
|
while (node != NULL) {
|
HandlerNode *next = NEXT(node); /* allows node removal */
|
if (node->handlerID != 0) { /* don't free internal handlers */
|
error = freeHandler(node);
|
if (error != JVMTI_ERROR_NONE) {
|
break;
|
}
|
}
|
node = next;
|
}
|
debugMonitorExit(handlerLock);
|
return error;
|
}
|
|
/***
|
* Delete all breakpoints on "clazz".
|
*/
|
void
|
eventHandler_freeClassBreakpoints(jclass clazz)
|
{
|
HandlerNode *node;
|
JNIEnv *env = getEnv();
|
|
debugMonitorEnter(handlerLock);
|
node = getHandlerChain(EI_BREAKPOINT)->first;
|
while (node != NULL) {
|
HandlerNode *next = NEXT(node); /* allows node removal */
|
if (eventFilterRestricted_isBreakpointInClass(env, clazz,
|
node)) {
|
(void)freeHandler(node);
|
}
|
node = next;
|
}
|
debugMonitorExit(handlerLock);
|
}
|
|
jvmtiError
|
eventHandler_freeByID(EventIndex ei, HandlerID handlerID)
|
{
|
jvmtiError error;
|
HandlerNode *node;
|
|
debugMonitorEnter(handlerLock);
|
node = find(ei, handlerID);
|
if (node != NULL) {
|
error = freeHandler(node);
|
} else {
|
/* already freed */
|
error = JVMTI_ERROR_NONE;
|
}
|
debugMonitorExit(handlerLock);
|
return error;
|
}
|
|
void
|
eventHandler_initialize(jbyte sessionID)
|
{
|
jvmtiError error;
|
jint i;
|
|
requestIdCounter = 1;
|
currentSessionID = sessionID;
|
|
/* This is for BEGIN_CALLBACK/END_CALLBACK handling, make sure this
|
* is done while none of these callbacks are active.
|
*/
|
active_callbacks = 0;
|
vm_death_callback_active = JNI_FALSE;
|
callbackLock = debugMonitorCreate("JDWP Callback Lock");
|
callbackBlock = debugMonitorCreate("JDWP Callback Block");
|
|
handlerLock = debugMonitorCreate("JDWP Event Handler Lock");
|
|
for (i = EI_min; i <= EI_max; ++i) {
|
getHandlerChain(i)->first = NULL;
|
}
|
|
/*
|
* Permanently enabled some events.
|
*/
|
error = threadControl_setEventMode(JVMTI_ENABLE,
|
EI_VM_INIT, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable vm init events");
|
}
|
error = threadControl_setEventMode(JVMTI_ENABLE,
|
EI_VM_DEATH, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable vm death events");
|
}
|
error = threadControl_setEventMode(JVMTI_ENABLE,
|
EI_THREAD_START, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable thread start events");
|
}
|
error = threadControl_setEventMode(JVMTI_ENABLE,
|
EI_THREAD_END, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable thread end events");
|
}
|
error = threadControl_setEventMode(JVMTI_ENABLE,
|
EI_CLASS_PREPARE, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable class prepare events");
|
}
|
error = threadControl_setEventMode(JVMTI_ENABLE,
|
EI_GC_FINISH, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable garbage collection finish events");
|
}
|
/* ANDROID-CHANGED: Permanently enable object free for common-ref tracking */
|
error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode)
|
(gdata->jvmti, JVMTI_ENABLE, JVMTI_EVENT_OBJECT_FREE, NULL);
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't enable object free events");
|
}
|
|
(void)memset(&(gdata->callbacks),0,sizeof(gdata->callbacks));
|
/* ANDROID-CHANGED: Event callback for common-ref tracking */
|
gdata->callbacks.ObjectFree = &cbObjectFree;
|
/* Event callback for JVMTI_EVENT_SINGLE_STEP */
|
gdata->callbacks.SingleStep = &cbSingleStep;
|
/* Event callback for JVMTI_EVENT_BREAKPOINT */
|
gdata->callbacks.Breakpoint = &cbBreakpoint;
|
/* Event callback for JVMTI_EVENT_FRAME_POP */
|
gdata->callbacks.FramePop = &cbFramePop;
|
/* Event callback for JVMTI_EVENT_EXCEPTION */
|
gdata->callbacks.Exception = &cbException;
|
/* Event callback for JVMTI_EVENT_THREAD_START */
|
gdata->callbacks.ThreadStart = &cbThreadStart;
|
/* Event callback for JVMTI_EVENT_THREAD_END */
|
gdata->callbacks.ThreadEnd = &cbThreadEnd;
|
/* Event callback for JVMTI_EVENT_CLASS_PREPARE */
|
gdata->callbacks.ClassPrepare = &cbClassPrepare;
|
/* Event callback for JVMTI_EVENT_CLASS_LOAD */
|
gdata->callbacks.ClassLoad = &cbClassLoad;
|
/* Event callback for JVMTI_EVENT_FIELD_ACCESS */
|
gdata->callbacks.FieldAccess = &cbFieldAccess;
|
/* Event callback for JVMTI_EVENT_FIELD_MODIFICATION */
|
gdata->callbacks.FieldModification = &cbFieldModification;
|
/* Event callback for JVMTI_EVENT_EXCEPTION_CATCH */
|
gdata->callbacks.ExceptionCatch = &cbExceptionCatch;
|
/* Event callback for JVMTI_EVENT_METHOD_ENTRY */
|
gdata->callbacks.MethodEntry = &cbMethodEntry;
|
/* Event callback for JVMTI_EVENT_METHOD_EXIT */
|
gdata->callbacks.MethodExit = &cbMethodExit;
|
/* Event callback for JVMTI_EVENT_MONITOR_CONTENDED_ENTER */
|
gdata->callbacks.MonitorContendedEnter = &cbMonitorContendedEnter;
|
/* Event callback for JVMTI_EVENT_MONITOR_CONTENDED_ENTERED */
|
gdata->callbacks.MonitorContendedEntered = &cbMonitorContendedEntered;
|
/* Event callback for JVMTI_EVENT_MONITOR_WAIT */
|
gdata->callbacks.MonitorWait = &cbMonitorWait;
|
/* Event callback for JVMTI_EVENT_MONITOR_WAITED */
|
gdata->callbacks.MonitorWaited = &cbMonitorWaited;
|
/* Event callback for JVMTI_EVENT_VM_INIT */
|
gdata->callbacks.VMInit = &cbVMInit;
|
/* Event callback for JVMTI_EVENT_VM_DEATH */
|
gdata->callbacks.VMDeath = &cbVMDeath;
|
/* Event callback for JVMTI_EVENT_GARBAGE_COLLECTION_FINISH */
|
gdata->callbacks.GarbageCollectionFinish = &cbGarbageCollectionFinish;
|
|
error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventCallbacks)
|
(gdata->jvmti, &(gdata->callbacks), sizeof(gdata->callbacks));
|
if (error != JVMTI_ERROR_NONE) {
|
EXIT_ERROR(error,"Can't set event callbacks");
|
}
|
|
/* Notify other modules that the event callbacks are in place */
|
threadControl_onHook();
|
|
/* Get the event helper thread initialized */
|
eventHelper_initialize(sessionID);
|
}
|
|
void
|
eventHandler_reset(jbyte sessionID)
|
{
|
int i;
|
|
debugMonitorEnter(handlerLock);
|
|
/* We must do this first so that if any invokes complete,
|
* there will be no attempt to send them to the front
|
* end. Waiting for threadControl_reset leaves a window where
|
* the invoke completions can sneak through.
|
*/
|
threadControl_detachInvokes();
|
|
/* Reset the event helper thread, purging all queued and
|
* in-process commands.
|
*/
|
eventHelper_reset(sessionID);
|
|
/* delete all handlers */
|
for (i = EI_min; i <= EI_max; i++) {
|
(void)freeHandlerChain(getHandlerChain(i));
|
}
|
|
requestIdCounter = 1;
|
currentSessionID = sessionID;
|
|
debugMonitorExit(handlerLock);
|
}
|
|
void
|
eventHandler_lock(void)
|
{
|
debugMonitorEnter(handlerLock);
|
}
|
|
void
|
eventHandler_unlock(void)
|
{
|
debugMonitorExit(handlerLock);
|
}
|
|
/***** handler creation *****/
|
|
HandlerNode *
|
eventHandler_alloc(jint filterCount, EventIndex ei, jbyte suspendPolicy)
|
{
|
HandlerNode *node = eventFilterRestricted_alloc(filterCount);
|
|
if (node != NULL) {
|
node->ei = ei;
|
node->suspendPolicy = suspendPolicy;
|
node->permanent = JNI_FALSE;
|
}
|
|
return node;
|
}
|
|
|
HandlerID
|
eventHandler_allocHandlerID(void)
|
{
|
jint handlerID;
|
debugMonitorEnter(handlerLock);
|
handlerID = ++requestIdCounter;
|
debugMonitorExit(handlerLock);
|
return handlerID;
|
}
|
|
|
static jvmtiError
|
installHandler(HandlerNode *node,
|
HandlerFunction func,
|
jboolean external)
|
{
|
jvmtiError error;
|
|
if ( func == NULL ) {
|
return AGENT_ERROR_INVALID_EVENT_TYPE;
|
}
|
|
debugMonitorEnter(handlerLock);
|
|
HANDLER_FUNCTION(node) = func;
|
|
node->handlerID = external? ++requestIdCounter : 0;
|
error = eventFilterRestricted_install(node);
|
if (error == JVMTI_ERROR_NONE) {
|
insert(getHandlerChain(node->ei), node);
|
}
|
|
debugMonitorExit(handlerLock);
|
|
return error;
|
}
|
|
static HandlerNode *
|
createInternal(EventIndex ei, HandlerFunction func,
|
jthread thread, jclass clazz, jmethodID method,
|
jlocation location, jboolean permanent)
|
{
|
jint index = 0;
|
jvmtiError error = JVMTI_ERROR_NONE;
|
HandlerNode *node;
|
|
/*
|
* Start with necessary allocations
|
*/
|
node = eventHandler_alloc(
|
((thread == NULL)? 0 : 1) + ((clazz == NULL)? 0 : 1),
|
ei, JDWP_SUSPEND_POLICY(NONE));
|
if (node == NULL) {
|
return NULL;
|
}
|
|
node->permanent = permanent;
|
|
if (thread != NULL) {
|
error = eventFilter_setThreadOnlyFilter(node, index++, thread);
|
}
|
|
if ((error == JVMTI_ERROR_NONE) && (clazz != NULL)) {
|
error = eventFilter_setLocationOnlyFilter(node, index++, clazz,
|
method, location);
|
}
|
/*
|
* Create the new handler node
|
*/
|
error = installHandler(node, func, JNI_FALSE);
|
|
if (error != JVMTI_ERROR_NONE) {
|
(void)eventHandler_free(node);
|
node = NULL;
|
}
|
return node;
|
}
|
|
HandlerNode *
|
eventHandler_createPermanentInternal(EventIndex ei, HandlerFunction func)
|
{
|
return createInternal(ei, func, NULL,
|
NULL, NULL, (jlocation)NULL, JNI_TRUE);
|
}
|
|
HandlerNode *
|
eventHandler_createInternalThreadOnly(EventIndex ei,
|
HandlerFunction func,
|
jthread thread)
|
{
|
return createInternal(ei, func, thread,
|
NULL, NULL, (jlocation)NULL, JNI_FALSE);
|
}
|
|
HandlerNode *
|
eventHandler_createInternalBreakpoint(HandlerFunction func,
|
jthread thread,
|
jclass clazz,
|
jmethodID method,
|
jlocation location)
|
{
|
return createInternal(EI_BREAKPOINT, func, thread,
|
clazz, method, location, JNI_FALSE);
|
}
|
|
jvmtiError
|
eventHandler_installExternal(HandlerNode *node)
|
{
|
return installHandler(node,
|
standardHandlers_defaultHandler(node->ei),
|
JNI_TRUE);
|
}
|
