/*
* Copyright (c) 1998, 2017, 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.
*/
#include "util.h"
#include "outStream.h"
#include "eventHandler.h"
#include "threadControl.h"
#include "invoker.h"
/*
* Event helper thread command commandKinds
*/
#define COMMAND_REPORT_EVENT_COMPOSITE 1
#define COMMAND_REPORT_INVOKE_DONE 2
#define COMMAND_REPORT_VM_INIT 3
#define COMMAND_SUSPEND_THREAD 4
/*
* Event helper thread command singleKinds
*/
#define COMMAND_SINGLE_EVENT 11
#define COMMAND_SINGLE_UNLOAD 12
#define COMMAND_SINGLE_FRAME_EVENT 13
typedef struct EventCommandSingle {
jbyte suspendPolicy; /* NOTE: Must be the first field */
jint id;
EventInfo info;
} EventCommandSingle;
typedef struct UnloadCommandSingle {
char *classSignature;
jint id;
} UnloadCommandSingle;
typedef struct FrameEventCommandSingle {
jbyte suspendPolicy; /* NOTE: Must be the first field */
jint id;
EventIndex ei;
jthread thread;
jclass clazz;
jmethodID method;
jlocation location;
char typeKey; /* Not used for method entry events */
/* If typeKey is 0, then no return value is needed */
jvalue returnValue; /* Not used for method entry events */
} FrameEventCommandSingle;
typedef struct CommandSingle {
jint singleKind;
union {
EventCommandSingle eventCommand;
UnloadCommandSingle unloadCommand;
FrameEventCommandSingle frameEventCommand;
} u;
} CommandSingle;
typedef struct ReportInvokeDoneCommand {
jthread thread;
} ReportInvokeDoneCommand;
typedef struct ReportVMInitCommand {
jbyte suspendPolicy; /* NOTE: Must be the first field */
jthread thread;
} ReportVMInitCommand;
typedef struct SuspendThreadCommand {
jthread thread;
} SuspendThreadCommand;
typedef struct ReportEventCompositeCommand {
jbyte suspendPolicy; /* NOTE: Must be the first field */
jint eventCount;
CommandSingle singleCommand[1]; /* variable length */
} ReportEventCompositeCommand;
typedef struct HelperCommand {
jint commandKind;
jboolean done;
jboolean waiting;
jbyte sessionID;
struct HelperCommand *next;
union {
/* NOTE: Each of the structs below must have the same first field */
ReportEventCompositeCommand reportEventComposite;
ReportInvokeDoneCommand reportInvokeDone;
ReportVMInitCommand reportVMInit;
SuspendThreadCommand suspendThread;
} u;
/* composite array expand out, put nothing after */
} HelperCommand;
typedef struct {
HelperCommand *head;
HelperCommand *tail;
} CommandQueue;
static CommandQueue commandQueue;
static jrawMonitorID commandQueueLock;
static jrawMonitorID commandCompleteLock;
static jrawMonitorID blockCommandLoopLock;
static jint maxQueueSize = 50 * 1024; /* TO DO: Make this configurable */
static jboolean holdEvents;
static jint currentQueueSize = 0;
static jint currentSessionID;
static void saveEventInfoRefs(JNIEnv *env, EventInfo *evinfo);
static void tossEventInfoRefs(JNIEnv *env, EventInfo *evinfo);
static jint
commandSize(HelperCommand *command)
{
jint size = sizeof(HelperCommand);
if (command->commandKind == COMMAND_REPORT_EVENT_COMPOSITE) {
/*
* One event is accounted for in the Helper Command. If there are
* more, add to size here.
*/
/*LINTED*/
size += ((int)sizeof(CommandSingle) *
(command->u.reportEventComposite.eventCount - 1));
}
return size;
}
static void
freeCommand(HelperCommand *command)
{
if ( command == NULL )
return;
jvmtiDeallocate(command);
}
static void
enqueueCommand(HelperCommand *command,
jboolean wait, jboolean reportingVMDeath)
{
static jboolean vmDeathReported = JNI_FALSE;
CommandQueue *queue = &commandQueue;
jint size = commandSize(command);
command->done = JNI_FALSE;
command->waiting = wait;
command->next = NULL;
debugMonitorEnter(commandQueueLock);
while (size + currentQueueSize > maxQueueSize) {
debugMonitorWait(commandQueueLock);
}
log_debugee_location("enqueueCommand(): HelperCommand being processed", NULL, NULL, 0);
if (vmDeathReported) {
/* send no more events after VMDeath and don't wait */
wait = JNI_FALSE;
} else {
currentQueueSize += size;
if (queue->head == NULL) {
queue->head = command;
} else {
queue->tail->next = command;
}
queue->tail = command;
if (reportingVMDeath) {
vmDeathReported = JNI_TRUE;
}
}
debugMonitorNotifyAll(commandQueueLock);
debugMonitorExit(commandQueueLock);
if (wait) {
debugMonitorEnter(commandCompleteLock);
while (!command->done) {
log_debugee_location("enqueueCommand(): HelperCommand wait", NULL, NULL, 0);
debugMonitorWait(commandCompleteLock);
}
freeCommand(command);
debugMonitorExit(commandCompleteLock);
}
}
static void
completeCommand(HelperCommand *command)
{
if (command->waiting) {
debugMonitorEnter(commandCompleteLock);
command->done = JNI_TRUE;
log_debugee_location("completeCommand(): HelperCommand done waiting", NULL, NULL, 0);
debugMonitorNotifyAll(commandCompleteLock);
debugMonitorExit(commandCompleteLock);
} else {
freeCommand(command);
}
}
static HelperCommand *
dequeueCommand(void)
{
HelperCommand *command = NULL;
CommandQueue *queue = &commandQueue;
jint size;
debugMonitorEnter(commandQueueLock);
while (command == NULL) {
while (holdEvents || (queue->head == NULL)) {
debugMonitorWait(commandQueueLock);
}
JDI_ASSERT(queue->head);
command = queue->head;
queue->head = command->next;
if (queue->tail == command) {
queue->tail = NULL;
}
log_debugee_location("dequeueCommand(): command being dequeued", NULL, NULL, 0);
size = commandSize(command);
/*
* Immediately close out any commands enqueued from
* a dead VM or a previously attached debugger.
*/
if (gdata->vmDead || command->sessionID != currentSessionID) {
log_debugee_location("dequeueCommand(): command session removal", NULL, NULL, 0);
completeCommand(command);
command = NULL;
}
/*
* There's room in the queue for more.
*/
currentQueueSize -= size;
debugMonitorNotifyAll(commandQueueLock);
}
debugMonitorExit(commandQueueLock);
return command;
}
void eventHelper_holdEvents(void)
{
debugMonitorEnter(commandQueueLock);
holdEvents = JNI_TRUE;
debugMonitorNotifyAll(commandQueueLock);
debugMonitorExit(commandQueueLock);
}
void eventHelper_releaseEvents(void)
{
debugMonitorEnter(commandQueueLock);
holdEvents = JNI_FALSE;
debugMonitorNotifyAll(commandQueueLock);
debugMonitorExit(commandQueueLock);
}
static void
writeSingleStepEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
(void)outStream_writeObjectRef(env, out, evinfo->thread);
writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);
}
static void
writeBreakpointEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
(void)outStream_writeObjectRef(env, out, evinfo->thread);
writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);
}
static void
writeFieldAccessEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
jbyte fieldClassTag;
fieldClassTag = referenceTypeTag(evinfo->u.field_access.field_clazz);
(void)outStream_writeObjectRef(env, out, evinfo->thread);
writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);
(void)outStream_writeByte(out, fieldClassTag);
(void)outStream_writeObjectRef(env, out, evinfo->u.field_access.field_clazz);
(void)outStream_writeFieldID(out, evinfo->u.field_access.field);
(void)outStream_writeObjectTag(env, out, evinfo->object);
(void)outStream_writeObjectRef(env, out, evinfo->object);
}
static void
writeFieldModificationEvent(JNIEnv *env, PacketOutputStream *out,
EventInfo *evinfo)
{
jbyte fieldClassTag;
fieldClassTag = referenceTypeTag(evinfo->u.field_modification.field_clazz);
(void)outStream_writeObjectRef(env, out, evinfo->thread);
writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);
(void)outStream_writeByte(out, fieldClassTag);
(void)outStream_writeObjectRef(env, out, evinfo->u.field_modification.field_clazz);
(void)outStream_writeFieldID(out, evinfo->u.field_modification.field);
(void)outStream_writeObjectTag(env, out, evinfo->object);
(void)outStream_writeObjectRef(env, out, evinfo->object);
(void)outStream_writeValue(env, out, (jbyte)evinfo->u.field_modification.signature_type,
evinfo->u.field_modification.new_value);
}
static void
writeExceptionEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
(void)outStream_writeObjectRef(env, out, evinfo->thread);
writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);
(void)outStream_writeObjectTag(env, out, evinfo->object);
(void)outStream_writeObjectRef(env, out, evinfo->object);
writeCodeLocation(out, evinfo->u.exception.catch_clazz,
evinfo->u.exception.catch_method, evinfo->u.exception.catch_location);
}
static void
writeThreadEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
(void)outStream_writeObjectRef(env, out, evinfo->thread);
}
static void
writeMonitorEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
jclass klass;
(void)outStream_writeObjectRef(env, out, evinfo->thread);
(void)outStream_writeObjectTag(env, out, evinfo->object);
(void)outStream_writeObjectRef(env, out, evinfo->object);
if (evinfo->ei == EI_MONITOR_WAIT || evinfo->ei == EI_MONITOR_WAITED) {
/* clazz of evinfo was set to class of monitor object for monitor wait event class filtering.
* So get the method class to write location info.
* See cbMonitorWait() and cbMonitorWaited() function in eventHandler.c.
*/
klass=getMethodClass(gdata->jvmti, evinfo->method);
writeCodeLocation(out, klass, evinfo->method, evinfo->location);
if (evinfo->ei == EI_MONITOR_WAIT) {
(void)outStream_writeLong(out, evinfo->u.monitor.timeout);
} else if (evinfo->ei == EI_MONITOR_WAITED) {
(void)outStream_writeBoolean(out, evinfo->u.monitor.timed_out);
}
/* This runs in a command loop and this thread may not return to java.
* So we need to delete the local ref created by jvmti GetMethodDeclaringClass.
*/
JNI_FUNC_PTR(env,DeleteLocalRef)(env, klass);
} else {
writeCodeLocation(out, evinfo->clazz, evinfo->method, evinfo->location);
}
}
static void
writeClassEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
jbyte classTag;
jint status;
char *signature = NULL;
jvmtiError error;
classTag = referenceTypeTag(evinfo->clazz);
error = classSignature(evinfo->clazz, &signature, NULL);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error,"signature");
}
status = classStatus(evinfo->clazz);
(void)outStream_writeObjectRef(env, out, evinfo->thread);
(void)outStream_writeByte(out, classTag);
(void)outStream_writeObjectRef(env, out, evinfo->clazz);
(void)outStream_writeString(out, signature);
(void)outStream_writeInt(out, map2jdwpClassStatus(status));
jvmtiDeallocate(signature);
}
static void
writeVMDeathEvent(JNIEnv *env, PacketOutputStream *out, EventInfo *evinfo)
{
}
static void
handleEventCommandSingle(JNIEnv *env, PacketOutputStream *out,
EventCommandSingle *command)
{
EventInfo *evinfo = &command->info;
(void)outStream_writeByte(out, eventIndex2jdwp(evinfo->ei));
(void)outStream_writeInt(out, command->id);
switch (evinfo->ei) {
case EI_SINGLE_STEP:
writeSingleStepEvent(env, out, evinfo);
break;
case EI_BREAKPOINT:
writeBreakpointEvent(env, out, evinfo);
break;
case EI_FIELD_ACCESS:
writeFieldAccessEvent(env, out, evinfo);
break;
case EI_FIELD_MODIFICATION:
writeFieldModificationEvent(env, out, evinfo);
break;
case EI_EXCEPTION:
writeExceptionEvent(env, out, evinfo);
break;
case EI_THREAD_START:
case EI_THREAD_END:
writeThreadEvent(env, out, evinfo);
break;
case EI_CLASS_LOAD:
case EI_CLASS_PREPARE:
writeClassEvent(env, out, evinfo);
break;
case EI_MONITOR_CONTENDED_ENTER:
case EI_MONITOR_CONTENDED_ENTERED:
case EI_MONITOR_WAIT:
case EI_MONITOR_WAITED:
writeMonitorEvent(env, out, evinfo);
break;
case EI_VM_DEATH:
writeVMDeathEvent(env, out, evinfo);
break;
default:
EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,"unknown event index");
break;
}
tossEventInfoRefs(env, evinfo);
}
static void
handleUnloadCommandSingle(JNIEnv* env, PacketOutputStream *out,
UnloadCommandSingle *command)
{
(void)outStream_writeByte(out, JDWP_EVENT(CLASS_UNLOAD));
(void)outStream_writeInt(out, command->id);
(void)outStream_writeString(out, command->classSignature);
jvmtiDeallocate(command->classSignature);
command->classSignature = NULL;
}
static void
handleFrameEventCommandSingle(JNIEnv* env, PacketOutputStream *out,
FrameEventCommandSingle *command)
{
if (command->typeKey) {
(void)outStream_writeByte(out, JDWP_EVENT(METHOD_EXIT_WITH_RETURN_VALUE));
} else {
(void)outStream_writeByte(out, eventIndex2jdwp(command->ei));
}
(void)outStream_writeInt(out, command->id);
(void)outStream_writeObjectRef(env, out, command->thread);
writeCodeLocation(out, command->clazz, command->method, command->location);
if (command->typeKey) {
(void)outStream_writeValue(env, out, command->typeKey, command->returnValue);
if (isObjectTag(command->typeKey) &&
command->returnValue.l != NULL) {
tossGlobalRef(env, &(command->returnValue.l));
}
}
tossGlobalRef(env, &(command->thread));
tossGlobalRef(env, &(command->clazz));
}
static void
suspendWithInvokeEnabled(jbyte policy, jthread thread)
{
invoker_enableInvokeRequests(thread);
if (policy == JDWP_SUSPEND_POLICY(ALL)) {
(void)threadControl_suspendAll();
} else {
(void)threadControl_suspendThread(thread, JNI_FALSE);
}
}
static void
handleReportEventCompositeCommand(JNIEnv *env,
ReportEventCompositeCommand *recc)
{
PacketOutputStream out;
jint count = recc->eventCount;
jint i;
if (recc->suspendPolicy != JDWP_SUSPEND_POLICY(NONE)) {
/* must determine thread to interrupt before writing */
/* since writing destroys it */
jthread thread = NULL;
for (i = 0; i < count; i++) {
CommandSingle *single = &(recc->singleCommand[i]);
switch (single->singleKind) {
case COMMAND_SINGLE_EVENT:
thread = single->u.eventCommand.info.thread;
break;
case COMMAND_SINGLE_FRAME_EVENT:
thread = single->u.frameEventCommand.thread;
break;
}
if (thread != NULL) {
break;
}
}
if (thread == NULL) {
(void)threadControl_suspendAll();
} else {
suspendWithInvokeEnabled(recc->suspendPolicy, thread);
}
}
outStream_initCommand(&out, uniqueID(), 0x0,
JDWP_COMMAND_SET(Event),
JDWP_COMMAND(Event, Composite));
(void)outStream_writeByte(&out, recc->suspendPolicy);
(void)outStream_writeInt(&out, count);
for (i = 0; i < count; i++) {
CommandSingle *single = &(recc->singleCommand[i]);
switch (single->singleKind) {
case COMMAND_SINGLE_EVENT:
handleEventCommandSingle(env, &out,
&single->u.eventCommand);
break;
case COMMAND_SINGLE_UNLOAD:
handleUnloadCommandSingle(env, &out,
&single->u.unloadCommand);
break;
case COMMAND_SINGLE_FRAME_EVENT:
handleFrameEventCommandSingle(env, &out,
&single->u.frameEventCommand);
break;
}
}
outStream_sendCommand(&out);
outStream_destroy(&out);
}
static void
handleReportInvokeDoneCommand(JNIEnv* env, ReportInvokeDoneCommand *command)
{
invoker_completeInvokeRequest(command->thread);
tossGlobalRef(env, &(command->thread));
}
static void
handleReportVMInitCommand(JNIEnv* env, ReportVMInitCommand *command)
{
PacketOutputStream out;
if (command->suspendPolicy == JDWP_SUSPEND_POLICY(ALL)) {
(void)threadControl_suspendAll();
} else if (command->suspendPolicy == JDWP_SUSPEND_POLICY(EVENT_THREAD)) {
(void)threadControl_suspendThread(command->thread, JNI_FALSE);
}
outStream_initCommand(&out, uniqueID(), 0x0,
JDWP_COMMAND_SET(Event),
JDWP_COMMAND(Event, Composite));
(void)outStream_writeByte(&out, command->suspendPolicy);
(void)outStream_writeInt(&out, 1); /* Always one component */
(void)outStream_writeByte(&out, JDWP_EVENT(VM_INIT));
(void)outStream_writeInt(&out, 0); /* Not in response to an event req. */
(void)outStream_writeObjectRef(env, &out, command->thread);
outStream_sendCommand(&out);
outStream_destroy(&out);
/* Why aren't we tossing this: tossGlobalRef(env, &(command->thread)); */
}
static void
handleSuspendThreadCommand(JNIEnv* env, SuspendThreadCommand *command)
{
/*
* For the moment, there's nothing that can be done with the
* return code, so we don't check it here.
*/
(void)threadControl_suspendThread(command->thread, JNI_TRUE);
tossGlobalRef(env, &(command->thread));
}
static void
handleCommand(JNIEnv *env, HelperCommand *command)
{
switch (command->commandKind) {
case COMMAND_REPORT_EVENT_COMPOSITE:
handleReportEventCompositeCommand(env,
&command->u.reportEventComposite);
break;
case COMMAND_REPORT_INVOKE_DONE:
handleReportInvokeDoneCommand(env, &command->u.reportInvokeDone);
break;
case COMMAND_REPORT_VM_INIT:
handleReportVMInitCommand(env, &command->u.reportVMInit);
break;
case COMMAND_SUSPEND_THREAD:
handleSuspendThreadCommand(env, &command->u.suspendThread);
break;
default:
EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,"Event Helper Command");
break;
}
}
/*
* There was an assumption that only one event with a suspend-all
* policy could be processed by commandLoop() at one time. It was
* assumed that native thread suspension from the first suspend-all
* event would prevent the second suspend-all event from making it
* into the command queue. For the Classic VM, this was a reasonable
* assumption. However, in HotSpot all thread suspension requires a
* VM operation and VM operations take time.
*
* The solution is to add a mechanism to prevent commandLoop() from
* processing more than one event with a suspend-all policy. This is
* accomplished by forcing commandLoop() to wait for either
* ThreadReferenceImpl.c: resume() or VirtualMachineImpl.c: resume()
* when an event with a suspend-all policy has been completed.
*/
static jboolean blockCommandLoop = JNI_FALSE;
/*
* We wait for either ThreadReferenceImpl.c: resume() or
* VirtualMachineImpl.c: resume() to be called.
*/
static void
doBlockCommandLoop(void) {
debugMonitorEnter(blockCommandLoopLock);
while (blockCommandLoop == JNI_TRUE) {
debugMonitorWait(blockCommandLoopLock);
}
debugMonitorExit(blockCommandLoopLock);
}
/*
* If the command that we are about to execute has a suspend-all
* policy, then prepare for either ThreadReferenceImpl.c: resume()
* or VirtualMachineImpl.c: resume() to be called.
*/
static jboolean
needBlockCommandLoop(HelperCommand *cmd) {
if (cmd->commandKind == COMMAND_REPORT_EVENT_COMPOSITE
&& cmd->u.reportEventComposite.suspendPolicy == JDWP_SUSPEND_POLICY(ALL)) {
debugMonitorEnter(blockCommandLoopLock);
blockCommandLoop = JNI_TRUE;
debugMonitorExit(blockCommandLoopLock);
return JNI_TRUE;
}
return JNI_FALSE;
}
/*
* Used by either ThreadReferenceImpl.c: resume() or
* VirtualMachineImpl.c: resume() to resume commandLoop().
*/
void
unblockCommandLoop(void) {
debugMonitorEnter(blockCommandLoopLock);
blockCommandLoop = JNI_FALSE;
debugMonitorNotifyAll(blockCommandLoopLock);
debugMonitorExit(blockCommandLoopLock);
}
/*
* The event helper thread. Dequeues commands and processes them.
*/
static void JNICALL
commandLoop(jvmtiEnv* jvmti_env, JNIEnv* jni_env, void* arg)
{
LOG_MISC(("Begin command loop thread"));
while (JNI_TRUE) {
HelperCommand *command = dequeueCommand();
if (command != NULL) {
/*
* Setup for a potential doBlockCommand() call before calling
* handleCommand() to prevent any races.
*/
jboolean doBlock = needBlockCommandLoop(command);
log_debugee_location("commandLoop(): command being handled", NULL, NULL, 0);
handleCommand(jni_env, command);
completeCommand(command);
/* if we just finished a suspend-all cmd, then we block here */
if (doBlock) {
doBlockCommandLoop();
}
}
}
/* This loop never ends, even as connections come and go with server=y */
}
void
eventHelper_initialize(jbyte sessionID)
{
jvmtiStartFunction func;
currentSessionID = sessionID;
holdEvents = JNI_FALSE;
commandQueue.head = NULL;
commandQueue.tail = NULL;
commandQueueLock = debugMonitorCreate("JDWP Event Helper Queue Monitor");
commandCompleteLock = debugMonitorCreate("JDWP Event Helper Completion Monitor");
blockCommandLoopLock = debugMonitorCreate("JDWP Event Block CommandLoop Monitor");
/* Start the event handler thread */
func = &commandLoop;
(void)spawnNewThread(func, NULL, "JDWP Event Helper Thread");
}
void
eventHelper_reset(jbyte newSessionID)
{
debugMonitorEnter(commandQueueLock);
currentSessionID = newSessionID;
holdEvents = JNI_FALSE;
debugMonitorNotifyAll(commandQueueLock);
debugMonitorExit(commandQueueLock);
}
/*
* Provide a means for threadControl to ensure that crucial locks are not
* held by suspended threads.
*/
void
eventHelper_lock(void)
{
debugMonitorEnter(commandQueueLock);
debugMonitorEnter(commandCompleteLock);
}
void
eventHelper_unlock(void)
{
debugMonitorExit(commandCompleteLock);
debugMonitorExit(commandQueueLock);
}
/* Change all references to global in the EventInfo struct */
static void
saveEventInfoRefs(JNIEnv *env, EventInfo *evinfo)
{
jthread *pthread;
jclass *pclazz;
jobject *pobject;
jthread thread;
jclass clazz;
jobject object;
char sig;
JNI_FUNC_PTR(env,ExceptionClear)(env);
if ( evinfo->thread != NULL ) {
pthread = &(evinfo->thread);
thread = *pthread;
*pthread = NULL;
saveGlobalRef(env, thread, pthread);
}
if ( evinfo->clazz != NULL ) {
pclazz = &(evinfo->clazz);
clazz = *pclazz;
*pclazz = NULL;
saveGlobalRef(env, clazz, pclazz);
}
if ( evinfo->object != NULL ) {
pobject = &(evinfo->object);
object = *pobject;
*pobject = NULL;
saveGlobalRef(env, object, pobject);
}
switch (evinfo->ei) {
case EI_FIELD_MODIFICATION:
if ( evinfo->u.field_modification.field_clazz != NULL ) {
pclazz = &(evinfo->u.field_modification.field_clazz);
clazz = *pclazz;
*pclazz = NULL;
saveGlobalRef(env, clazz, pclazz);
}
sig = evinfo->u.field_modification.signature_type;
if ((sig == JDWP_TAG(ARRAY)) || (sig == JDWP_TAG(OBJECT))) {
if ( evinfo->u.field_modification.new_value.l != NULL ) {
pobject = &(evinfo->u.field_modification.new_value.l);
object = *pobject;
*pobject = NULL;
saveGlobalRef(env, object, pobject);
}
}
break;
case EI_FIELD_ACCESS:
if ( evinfo->u.field_access.field_clazz != NULL ) {
pclazz = &(evinfo->u.field_access.field_clazz);
clazz = *pclazz;
*pclazz = NULL;
saveGlobalRef(env, clazz, pclazz);
}
break;
case EI_EXCEPTION:
if ( evinfo->u.exception.catch_clazz != NULL ) {
pclazz = &(evinfo->u.exception.catch_clazz);
clazz = *pclazz;
*pclazz = NULL;
saveGlobalRef(env, clazz, pclazz);
}
break;
default:
break;
}
if (JNI_FUNC_PTR(env,ExceptionOccurred)(env)) {
EXIT_ERROR(AGENT_ERROR_INVALID_EVENT_TYPE,"ExceptionOccurred");
}
}
static void
tossEventInfoRefs(JNIEnv *env, EventInfo *evinfo)
{
char sig;
if ( evinfo->thread != NULL ) {
tossGlobalRef(env, &(evinfo->thread));
}
if ( evinfo->clazz != NULL ) {
tossGlobalRef(env, &(evinfo->clazz));
}
if ( evinfo->object != NULL ) {
tossGlobalRef(env, &(evinfo->object));
}
switch (evinfo->ei) {
case EI_FIELD_MODIFICATION:
if ( evinfo->u.field_modification.field_clazz != NULL ) {
tossGlobalRef(env, &(evinfo->u.field_modification.field_clazz));
}
sig = evinfo->u.field_modification.signature_type;
if ((sig == JDWP_TAG(ARRAY)) || (sig == JDWP_TAG(OBJECT))) {
if ( evinfo->u.field_modification.new_value.l != NULL ) {
tossGlobalRef(env, &(evinfo->u.field_modification.new_value.l));
}
}
break;
case EI_FIELD_ACCESS:
if ( evinfo->u.field_access.field_clazz != NULL ) {
tossGlobalRef(env, &(evinfo->u.field_access.field_clazz));
}
break;
case EI_EXCEPTION:
if ( evinfo->u.exception.catch_clazz != NULL ) {
tossGlobalRef(env, &(evinfo->u.exception.catch_clazz));
}
break;
default:
break;
}
}
struct bag *
eventHelper_createEventBag(void)
{
return bagCreateBag(sizeof(CommandSingle), 5 /* events */ );
}
/* Return the combined suspend policy for the event set
*/
static jboolean
enumForCombinedSuspendPolicy(void *cv, void *arg)
{
CommandSingle *command = cv;
jbyte thisPolicy;
jbyte *policy = arg;
switch(command->singleKind) {
case COMMAND_SINGLE_EVENT:
thisPolicy = command->u.eventCommand.suspendPolicy;
break;
case COMMAND_SINGLE_FRAME_EVENT:
thisPolicy = command->u.frameEventCommand.suspendPolicy;
break;
default:
thisPolicy = JDWP_SUSPEND_POLICY(NONE);
}
/* Expand running policy value if this policy demands it */
if (*policy == JDWP_SUSPEND_POLICY(NONE)) {
*policy = thisPolicy;
} else if (*policy == JDWP_SUSPEND_POLICY(EVENT_THREAD)) {
*policy = (thisPolicy == JDWP_SUSPEND_POLICY(ALL))?
thisPolicy : *policy;
}
/* Short circuit if we reached maximal suspend policy */
if (*policy == JDWP_SUSPEND_POLICY(ALL)) {
return JNI_FALSE;
} else {
return JNI_TRUE;
}
}
/* Determine whether we are reporting VM death
*/
static jboolean
enumForVMDeath(void *cv, void *arg)
{
CommandSingle *command = cv;
jboolean *reportingVMDeath = arg;
if (command->singleKind == COMMAND_SINGLE_EVENT) {
if (command->u.eventCommand.info.ei == EI_VM_DEATH) {
*reportingVMDeath = JNI_TRUE;
return JNI_FALSE;
}
}
return JNI_TRUE;
}
struct singleTracker {
ReportEventCompositeCommand *recc;
int index;
};
static jboolean
enumForCopyingSingles(void *command, void *tv)
{
struct singleTracker *tracker = (struct singleTracker *)tv;
(void)memcpy(&tracker->recc->singleCommand[tracker->index++],
command,
sizeof(CommandSingle));
return JNI_TRUE;
}
jbyte
eventHelper_reportEvents(jbyte sessionID, struct bag *eventBag)
{
int size = bagSize(eventBag);
jbyte suspendPolicy = JDWP_SUSPEND_POLICY(NONE);
jboolean reportingVMDeath = JNI_FALSE;
jboolean wait;
int command_size;
HelperCommand *command;
ReportEventCompositeCommand *recc;
struct singleTracker tracker;
if (size == 0) {
return suspendPolicy;
}
(void)bagEnumerateOver(eventBag, enumForCombinedSuspendPolicy, &suspendPolicy);
(void)bagEnumerateOver(eventBag, enumForVMDeath, &reportingVMDeath);
/*LINTED*/
command_size = (int)(sizeof(HelperCommand) +
sizeof(CommandSingle)*(size-1));
command = jvmtiAllocate(command_size);
(void)memset(command, 0, command_size);
command->commandKind = COMMAND_REPORT_EVENT_COMPOSITE;
command->sessionID = sessionID;
recc = &command->u.reportEventComposite;
recc->suspendPolicy = suspendPolicy;
recc->eventCount = size;
tracker.recc = recc;
tracker.index = 0;
(void)bagEnumerateOver(eventBag, enumForCopyingSingles, &tracker);
/*
* We must wait if this thread (the event thread) is to be
* suspended or if the VM is about to die. (Waiting in the latter
* case ensures that we get the event out before the process dies.)
*/
wait = (jboolean)((suspendPolicy != JDWP_SUSPEND_POLICY(NONE)) ||
reportingVMDeath);
enqueueCommand(command, wait, reportingVMDeath);
return suspendPolicy;
}
void
eventHelper_recordEvent(EventInfo *evinfo, jint id, jbyte suspendPolicy,
struct bag *eventBag)
{
JNIEnv *env = getEnv();
CommandSingle *command = bagAdd(eventBag);
if (command == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"badAdd(eventBag)");
}
command->singleKind = COMMAND_SINGLE_EVENT;
command->u.eventCommand.suspendPolicy = suspendPolicy;
command->u.eventCommand.id = id;
/*
* Copy the event into the command so that it can be used
* asynchronously by the event helper thread.
*/
(void)memcpy(&command->u.eventCommand.info, evinfo, sizeof(*evinfo));
saveEventInfoRefs(env, &command->u.eventCommand.info);
}
void
eventHelper_recordClassUnload(jint id, char *signature, struct bag *eventBag)
{
CommandSingle *command = bagAdd(eventBag);
if (command == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"bagAdd(eventBag)");
}
command->singleKind = COMMAND_SINGLE_UNLOAD;
command->u.unloadCommand.id = id;
command->u.unloadCommand.classSignature = signature;
}
void
eventHelper_recordFrameEvent(jint id, jbyte suspendPolicy, EventIndex ei,
jthread thread, jclass clazz,
jmethodID method, jlocation location,
int needReturnValue,
jvalue returnValue,
struct bag *eventBag)
{
JNIEnv *env = getEnv();
FrameEventCommandSingle *frameCommand;
CommandSingle *command = bagAdd(eventBag);
jvmtiError err = JVMTI_ERROR_NONE;
if (command == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"bagAdd(eventBag)");
}
command->singleKind = COMMAND_SINGLE_FRAME_EVENT;
frameCommand = &command->u.frameEventCommand;
frameCommand->suspendPolicy = suspendPolicy;
frameCommand->id = id;
frameCommand->ei = ei;
saveGlobalRef(env, thread, &(frameCommand->thread));
saveGlobalRef(env, clazz, &(frameCommand->clazz));
frameCommand->method = method;
frameCommand->location = location;
if (needReturnValue) {
err = methodReturnType(method, &frameCommand->typeKey);
JDI_ASSERT(err == JVMTI_ERROR_NONE);
/*
* V or B C D F I J S Z L <classname> ; [ ComponentType
*/
if (isObjectTag(frameCommand->typeKey) &&
returnValue.l != NULL) {
saveGlobalRef(env, returnValue.l, &(frameCommand->returnValue.l));
} else {
frameCommand->returnValue = returnValue;
}
} else {
/* This is not a JDWP METHOD_EXIT_WITH_RETURN_VALUE request,
* so signal this by setting typeKey = 0 which is not
* a legal typekey.
*/
frameCommand->typeKey = 0;
}
}
void
eventHelper_reportInvokeDone(jbyte sessionID, jthread thread)
{
JNIEnv *env = getEnv();
HelperCommand *command = jvmtiAllocate(sizeof(*command));
if (command == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"HelperCommand");
}
(void)memset(command, 0, sizeof(*command));
command->commandKind = COMMAND_REPORT_INVOKE_DONE;
command->sessionID = sessionID;
saveGlobalRef(env, thread, &(command->u.reportInvokeDone.thread));
enqueueCommand(command, JNI_TRUE, JNI_FALSE);
}
/*
* This, currently, cannot go through the normal event handling code
* because the JVMTI event does not contain a thread.
*/
void
eventHelper_reportVMInit(JNIEnv *env, jbyte sessionID, jthread thread, jbyte suspendPolicy)
{
HelperCommand *command = jvmtiAllocate(sizeof(*command));
if (command == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"HelperCommmand");
}
(void)memset(command, 0, sizeof(*command));
command->commandKind = COMMAND_REPORT_VM_INIT;
command->sessionID = sessionID;
saveGlobalRef(env, thread, &(command->u.reportVMInit.thread));
command->u.reportVMInit.suspendPolicy = suspendPolicy;
enqueueCommand(command, JNI_TRUE, JNI_FALSE);
}
void
eventHelper_suspendThread(jbyte sessionID, jthread thread)
{
JNIEnv *env = getEnv();
HelperCommand *command = jvmtiAllocate(sizeof(*command));
if (command == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"HelperCommmand");
}
(void)memset(command, 0, sizeof(*command));
command->commandKind = COMMAND_SUSPEND_THREAD;
command->sessionID = sessionID;
saveGlobalRef(env, thread, &(command->u.suspendThread.thread));
enqueueCommand(command, JNI_TRUE, JNI_FALSE);
}