/*
* 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.
*/
#include "util.h"
#include "eventHandler.h"
#include "threadControl.h"
#include "commonRef.h"
#include "eventHelper.h"
#include "stepControl.h"
#include "invoker.h"
#include "bag.h"
#define HANDLING_EVENT(node) ((node)->current_ei != 0)
/*
* Collection of info for properly handling co-located events.
* If the ei field is non-zero, then one of the possible
* co-located events has been posted and the other fields describe
* the event's location.
*/
typedef struct CoLocatedEventInfo_ {
EventIndex ei;
jclass clazz;
jmethodID method;
jlocation location;
} CoLocatedEventInfo;
/**
* The main data structure in threadControl is the ThreadNode.
* This is a per-thread structure that is allocated on the
* first event that occurs in a thread. It is freed after the
* thread's thread end event has completed processing. The
* structure contains state information on its thread including
* suspend counts. It also acts as a repository for other
* per-thread state such as the current method invocation or
* current step.
*
* suspendCount is the number of outstanding suspends
* from the debugger. suspends from the app itself are
* not included in this count.
*/
typedef struct ThreadNode {
jthread thread;
unsigned int toBeResumed : 1;
unsigned int pendingInterrupt : 1;
unsigned int isDebugThread : 1;
unsigned int suspendOnStart : 1;
unsigned int isStarted : 1;
unsigned int popFrameEvent : 1;
unsigned int popFrameProceed : 1;
unsigned int popFrameThread : 1;
EventIndex current_ei;
jobject pendingStop;
jint suspendCount;
jint resumeFrameDepth; /* !=0 => This thread is in a call to Thread.resume() */
jvmtiEventMode instructionStepMode;
StepRequest currentStep;
InvokeRequest currentInvoke;
struct bag *eventBag;
CoLocatedEventInfo cleInfo;
struct ThreadNode *next;
struct ThreadNode *prev;
jlong frameGeneration;
struct ThreadList *list; /* Tells us what list this thread is in */
} ThreadNode;
static jint suspendAllCount;
typedef struct ThreadList {
ThreadNode *first;
} ThreadList;
/*
* popFrameEventLock is used to notify that the event has been received
*/
static jrawMonitorID popFrameEventLock = NULL;
/*
* popFrameProceedLock is used to assure that the event thread is
* re-suspended immediately after the event is acknowledged.
*/
static jrawMonitorID popFrameProceedLock = NULL;
static jrawMonitorID threadLock;
static jlocation resumeLocation;
static HandlerNode *breakpointHandlerNode;
static HandlerNode *framePopHandlerNode;
static HandlerNode *catchHandlerNode;
static jvmtiError threadControl_removeDebugThread(jthread thread);
/*
* Threads which have issued thread start events and not yet issued thread
* end events are maintained in the "runningThreads" list. All other threads known
* to this module are kept in the "otherThreads" list.
*/
static ThreadList runningThreads;
static ThreadList otherThreads;
#define MAX_DEBUG_THREADS 10
static int debugThreadCount;
static jthread debugThreads[MAX_DEBUG_THREADS];
typedef struct DeferredEventMode {
EventIndex ei;
jvmtiEventMode mode;
jthread thread;
struct DeferredEventMode *next;
} DeferredEventMode;
typedef struct {
DeferredEventMode *first;
DeferredEventMode *last;
} DeferredEventModeList;
static DeferredEventModeList deferredEventModes;
static jint
getStackDepth(jthread thread)
{
jint count = 0;
jvmtiError error;
error = JVMTI_FUNC_PTR(gdata->jvmti,GetFrameCount)
(gdata->jvmti, thread, &count);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "getting frame count");
}
return count;
}
/* Get the state of the thread direct from JVMTI */
static jvmtiError
threadState(jthread thread, jint *pstate)
{
*pstate = 0;
return JVMTI_FUNC_PTR(gdata->jvmti,GetThreadState)
(gdata->jvmti, thread, pstate);
}
/* Set TLS on a specific jthread to the ThreadNode* */
static void
setThreadLocalStorage(jthread thread, ThreadNode *node)
{
jvmtiError error;
error = JVMTI_FUNC_PTR(gdata->jvmti,SetThreadLocalStorage)
(gdata->jvmti, thread, (void*)node);
if ( error == JVMTI_ERROR_THREAD_NOT_ALIVE ) {
/* Just return, thread hasn't started yet */
return;
} else if ( error != JVMTI_ERROR_NONE ) {
/* The jthread object must be valid, so this must be a fatal error */
EXIT_ERROR(error, "cannot set thread local storage");
}
}
/* Get TLS on a specific jthread, which is the ThreadNode* */
static ThreadNode *
getThreadLocalStorage(jthread thread)
{
jvmtiError error;
ThreadNode *node;
node = NULL;
error = JVMTI_FUNC_PTR(gdata->jvmti,GetThreadLocalStorage)
(gdata->jvmti, thread, (void**)&node);
if ( error == JVMTI_ERROR_THREAD_NOT_ALIVE ) {
/* Just return NULL, thread hasn't started yet */
return NULL;
} else if ( error != JVMTI_ERROR_NONE ) {
/* The jthread object must be valid, so this must be a fatal error */
EXIT_ERROR(error, "cannot get thread local storage");
}
return node;
}
/* Search list for nodes that don't have TLS set and match this thread.
* It assumed that this logic is never dealing with terminated threads,
* since the ThreadEnd events always delete the ThreadNode while the
* jthread is still alive. So we can only look at the ThreadNode's that
* have never had their TLS set, making the search much faster.
* But keep in mind, this kind of search should rarely be needed.
*/
static ThreadNode *
nonTlsSearch(JNIEnv *env, ThreadList *list, jthread thread)
{
ThreadNode *node;
for (node = list->first; node != NULL; node = node->next) {
if (isSameObject(env, node->thread, thread)) {
break;
}
}
return node;
}
/*
* These functions maintain the linked list of currently running threads.
* All assume that the threadLock is held before calling.
* If list==NULL, search both lists.
*/
static ThreadNode *
findThread(ThreadList *list, jthread thread)
{
ThreadNode *node;
/* Get thread local storage for quick thread -> node access */
node = getThreadLocalStorage(thread);
/* In some rare cases we might get NULL, so we check the list manually for
* any threads that we could match.
*/
if ( node == NULL ) {
JNIEnv *env;
env = getEnv();
if ( list != NULL ) {
node = nonTlsSearch(env, list, thread);
} else {
node = nonTlsSearch(env, &runningThreads, thread);
if ( node == NULL ) {
node = nonTlsSearch(env, &otherThreads, thread);
}
}
if ( node != NULL ) {
/* Here we make another attempt to set TLS, it's ok if this fails */
setThreadLocalStorage(thread, (void*)node);
}
}
/* If a list is supplied, only return ones in this list */
if ( node != NULL && list != NULL && node->list != list ) {
return NULL;
}
return node;
}
/* Remove a ThreadNode from a ThreadList */
static void
removeNode(ThreadList *list, ThreadNode *node)
{
ThreadNode *prev;
ThreadNode *next;
prev = node->prev;
next = node->next;
if ( prev != NULL ) {
prev->next = next;
}
if ( next != NULL ) {
next->prev = prev;
}
if ( prev == NULL ) {
list->first = next;
}
node->next = NULL;
node->prev = NULL;
node->list = NULL;
}
/* Add a ThreadNode to a ThreadList */
static void
addNode(ThreadList *list, ThreadNode *node)
{
node->next = NULL;
node->prev = NULL;
node->list = NULL;
if ( list->first == NULL ) {
list->first = node;
} else {
list->first->prev = node;
node->next = list->first;
list->first = node;
}
node->list = list;
}
static ThreadNode *
insertThread(JNIEnv *env, ThreadList *list, jthread thread)
{
ThreadNode *node;
struct bag *eventBag;
node = findThread(list, thread);
if (node == NULL) {
node = jvmtiAllocate(sizeof(*node));
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table entry");
return NULL;
}
(void)memset(node, 0, sizeof(*node));
eventBag = eventHelper_createEventBag();
if (eventBag == NULL) {
jvmtiDeallocate(node);
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table entry");
return NULL;
}
/*
* Init all flags false, all refs NULL, all counts 0
*/
saveGlobalRef(env, thread, &(node->thread));
if (node->thread == NULL) {
jvmtiDeallocate(node);
bagDestroyBag(eventBag);
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table entry");
return NULL;
}
/*
* Remember if it is a debug thread
*/
if (threadControl_isDebugThread(node->thread)) {
node->isDebugThread = JNI_TRUE;
} else if (suspendAllCount > 0){
/*
* If there is a pending suspendAll, all new threads should
* be initialized as if they were suspended by the suspendAll,
* and the thread will need to be suspended when it starts.
*/
node->suspendCount = suspendAllCount;
node->suspendOnStart = JNI_TRUE;
}
node->current_ei = 0;
node->instructionStepMode = JVMTI_DISABLE;
node->eventBag = eventBag;
addNode(list, node);
/* Set thread local storage for quick thread -> node access.
* Some threads may not be in a state that allows setting of TLS,
* which is ok, see findThread, it deals with threads without TLS set.
*/
setThreadLocalStorage(node->thread, (void*)node);
}
return node;
}
static void
clearThread(JNIEnv *env, ThreadNode *node)
{
if (node->pendingStop != NULL) {
tossGlobalRef(env, &(node->pendingStop));
}
stepControl_clearRequest(node->thread, &node->currentStep);
if (node->isDebugThread) {
(void)threadControl_removeDebugThread(node->thread);
}
/* Clear out TLS on this thread (just a cleanup action) */
setThreadLocalStorage(node->thread, NULL);
tossGlobalRef(env, &(node->thread));
bagDestroyBag(node->eventBag);
jvmtiDeallocate(node);
}
static void
removeThread(JNIEnv *env, ThreadList *list, jthread thread)
{
ThreadNode *node;
node = findThread(list, thread);
if (node != NULL) {
removeNode(list, node);
clearThread(env, node);
}
}
static void
removeResumed(JNIEnv *env, ThreadList *list)
{
ThreadNode *node;
node = list->first;
while (node != NULL) {
ThreadNode *temp = node->next;
if (node->suspendCount == 0) {
removeThread(env, list, node->thread);
}
node = temp;
}
}
static void
moveNode(ThreadList *source, ThreadList *dest, ThreadNode *node)
{
removeNode(source, node);
JDI_ASSERT(findThread(dest, node->thread) == NULL);
addNode(dest, node);
}
typedef jvmtiError (*ThreadEnumerateFunction)(JNIEnv *, ThreadNode *, void *);
static jvmtiError
enumerateOverThreadList(JNIEnv *env, ThreadList *list,
ThreadEnumerateFunction function, void *arg)
{
ThreadNode *node;
jvmtiError error = JVMTI_ERROR_NONE;
for (node = list->first; node != NULL; node = node->next) {
error = (*function)(env, node, arg);
if ( error != JVMTI_ERROR_NONE ) {
break;
}
}
return error;
}
static void
insertEventMode(DeferredEventModeList *list, DeferredEventMode *eventMode)
{
if (list->last != NULL) {
list->last->next = eventMode;
} else {
list->first = eventMode;
}
list->last = eventMode;
}
static void
removeEventMode(DeferredEventModeList *list, DeferredEventMode *eventMode, DeferredEventMode *prev)
{
if (prev == NULL) {
list->first = eventMode->next;
} else {
prev->next = eventMode->next;
}
if (eventMode->next == NULL) {
list->last = prev;
}
}
static jvmtiError
addDeferredEventMode(JNIEnv *env, jvmtiEventMode mode, EventIndex ei, jthread thread)
{
DeferredEventMode *eventMode;
/*LINTED*/
eventMode = jvmtiAllocate((jint)sizeof(DeferredEventMode));
if (eventMode == NULL) {
return AGENT_ERROR_OUT_OF_MEMORY;
}
eventMode->thread = NULL;
saveGlobalRef(env, thread, &(eventMode->thread));
eventMode->mode = mode;
eventMode->ei = ei;
eventMode->next = NULL;
insertEventMode(&deferredEventModes, eventMode);
return JVMTI_ERROR_NONE;
}
static void
freeDeferredEventModes(JNIEnv *env)
{
DeferredEventMode *eventMode;
eventMode = deferredEventModes.first;
while (eventMode != NULL) {
DeferredEventMode *next;
next = eventMode->next;
tossGlobalRef(env, &(eventMode->thread));
jvmtiDeallocate(eventMode);
eventMode = next;
}
deferredEventModes.first = NULL;
deferredEventModes.last = NULL;
}
static jvmtiError
threadSetEventNotificationMode(ThreadNode *node,
jvmtiEventMode mode, EventIndex ei, jthread thread)
{
jvmtiError error;
/* record single step mode */
if (ei == EI_SINGLE_STEP) {
node->instructionStepMode = mode;
}
error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode)
(gdata->jvmti, mode, eventIndex2jvmti(ei), thread);
return error;
}
static void
processDeferredEventModes(JNIEnv *env, jthread thread, ThreadNode *node)
{
jvmtiError error;
DeferredEventMode *eventMode;
DeferredEventMode *prev;
prev = NULL;
eventMode = deferredEventModes.first;
while (eventMode != NULL) {
DeferredEventMode *next = eventMode->next;
if (isSameObject(env, thread, eventMode->thread)) {
error = threadSetEventNotificationMode(node,
eventMode->mode, eventMode->ei, eventMode->thread);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "cannot process deferred thread event notifications at thread start");
}
removeEventMode(&deferredEventModes, eventMode, prev);
tossGlobalRef(env, &(eventMode->thread));
jvmtiDeallocate(eventMode);
} else {
prev = eventMode;
}
eventMode = next;
}
}
static void
getLocks(void)
{
/*
* Anything which might be locked as part of the handling of
* a JVMTI event (which means: might be locked by an application
* thread) needs to be grabbed here. This allows thread control
* code to safely suspend and resume the application threads
* while ensuring they don't hold a critical lock.
*/
eventHandler_lock();
invoker_lock();
eventHelper_lock();
stepControl_lock();
commonRef_lock();
debugMonitorEnter(threadLock);
}
static void
releaseLocks(void)
{
debugMonitorExit(threadLock);
commonRef_unlock();
stepControl_unlock();
eventHelper_unlock();
invoker_unlock();
eventHandler_unlock();
}
void
threadControl_initialize(void)
{
jlocation unused;
jvmtiError error;
suspendAllCount = 0;
runningThreads.first = NULL;
otherThreads.first = NULL;
debugThreadCount = 0;
threadLock = debugMonitorCreate("JDWP Thread Lock");
if (gdata->threadClass==NULL) {
EXIT_ERROR(AGENT_ERROR_NULL_POINTER, "no java.lang.thread class");
}
if (gdata->threadResume==0) {
EXIT_ERROR(AGENT_ERROR_NULL_POINTER, "cannot resume thread");
}
/* Get the java.lang.Thread.resume() method beginning location */
error = methodLocation(gdata->threadResume, &resumeLocation, &unused);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "getting method location");
}
}
static jthread
getResumee(jthread resumingThread)
{
jthread resumee = NULL;
jvmtiError error;
jobject object;
FrameNumber fnum = 0;
// ANDROID-CHANGED: On ART 'this' is not always in register 0. We just use GetLocalInstance in
// all cases.
error = JVMTI_FUNC_PTR(gdata->jvmti,GetLocalInstance)
(gdata->jvmti, resumingThread, fnum, &object);
if (error == JVMTI_ERROR_NONE) {
resumee = object;
}
return resumee;
}
static jboolean
pendingAppResume(jboolean includeSuspended)
{
ThreadList *list;
ThreadNode *node;
list = &runningThreads;
node = list->first;
while (node != NULL) {
if (node->resumeFrameDepth > 0) {
if (includeSuspended) {
return JNI_TRUE;
} else {
jvmtiError error;
jint state;
error = threadState(node->thread, &state);
if (error != JVMTI_ERROR_NONE) {
EXIT_ERROR(error, "getting thread state");
}
if (!(state & JVMTI_THREAD_STATE_SUSPENDED)) {
return JNI_TRUE;
}
}
}
node = node->next;
}
return JNI_FALSE;
}
static void
notifyAppResumeComplete(void)
{
debugMonitorNotifyAll(threadLock);
if (!pendingAppResume(JNI_TRUE)) {
if (framePopHandlerNode != NULL) {
(void)eventHandler_free(framePopHandlerNode);
framePopHandlerNode = NULL;
}
if (catchHandlerNode != NULL) {
(void)eventHandler_free(catchHandlerNode);
catchHandlerNode = NULL;
}
}
}
static void
handleAppResumeCompletion(JNIEnv *env, EventInfo *evinfo,
HandlerNode *handlerNode,
struct bag *eventBag)
{
ThreadNode *node;
jthread thread;
thread = evinfo->thread;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
if (node->resumeFrameDepth > 0) {
jint compareDepth = getStackDepth(thread);
if (evinfo->ei == EI_FRAME_POP) {
compareDepth--;
}
if (compareDepth < node->resumeFrameDepth) {
node->resumeFrameDepth = 0;
notifyAppResumeComplete();
}
}
}
debugMonitorExit(threadLock);
}
static void
blockOnDebuggerSuspend(jthread thread)
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node != NULL) {
while (node && node->suspendCount > 0) {
debugMonitorWait(threadLock);
node = findThread(NULL, thread);
}
}
}
static void
trackAppResume(jthread thread)
{
jvmtiError error;
FrameNumber fnum;
ThreadNode *node;
fnum = 0;
node = findThread(&runningThreads, thread);
if (node != NULL) {
JDI_ASSERT(node->resumeFrameDepth == 0);
error = JVMTI_FUNC_PTR(gdata->jvmti,NotifyFramePop)
(gdata->jvmti, thread, fnum);
if (error == JVMTI_ERROR_NONE) {
jint frameDepth = getStackDepth(thread);
if ((frameDepth > 0) && (framePopHandlerNode == NULL)) {
framePopHandlerNode = eventHandler_createInternalThreadOnly(
EI_FRAME_POP,
handleAppResumeCompletion,
thread);
catchHandlerNode = eventHandler_createInternalThreadOnly(
EI_EXCEPTION_CATCH,
handleAppResumeCompletion,
thread);
if ((framePopHandlerNode == NULL) ||
(catchHandlerNode == NULL)) {
(void)eventHandler_free(framePopHandlerNode);
framePopHandlerNode = NULL;
(void)eventHandler_free(catchHandlerNode);
catchHandlerNode = NULL;
}
}
if ((framePopHandlerNode != NULL) &&
(catchHandlerNode != NULL) &&
(frameDepth > 0)) {
node->resumeFrameDepth = frameDepth;
}
}
}
}
static void
handleAppResumeBreakpoint(JNIEnv *env, EventInfo *evinfo,
HandlerNode *handlerNode,
struct bag *eventBag)
{
jthread resumer = evinfo->thread;
jthread resumee = getResumee(resumer);
debugMonitorEnter(threadLock);
if (resumee != NULL) {
/*
* Hold up any attempt to resume as long as the debugger
* has suspended the resumee.
*/
blockOnDebuggerSuspend(resumee);
}
if (resumer != NULL) {
/*
* Track the resuming thread by marking it as being within
* a resume and by setting up for notification on
* a frame pop or exception. We won't allow the debugger
* to suspend threads while any thread is within a
* call to resume. This (along with the block above)
* ensures that when the debugger
* suspends a thread it will remain suspended.
*/
trackAppResume(resumer);
}
debugMonitorExit(threadLock);
}
void
threadControl_onConnect(void)
{
breakpointHandlerNode = eventHandler_createInternalBreakpoint(
handleAppResumeBreakpoint, NULL,
gdata->threadClass, gdata->threadResume, resumeLocation);
}
void
threadControl_onDisconnect(void)
{
if (breakpointHandlerNode != NULL) {
(void)eventHandler_free(breakpointHandlerNode);
breakpointHandlerNode = NULL;
}
if (framePopHandlerNode != NULL) {
(void)eventHandler_free(framePopHandlerNode);
framePopHandlerNode = NULL;
}
if (catchHandlerNode != NULL) {
(void)eventHandler_free(catchHandlerNode);
catchHandlerNode = NULL;
}
}
void
threadControl_onHook(void)
{
/*
* As soon as the event hook is in place, we need to initialize
* the thread list with already-existing threads. The threadLock
* has been held since initialize, so we don't need to worry about
* insertions or deletions from the event handlers while we do this
*/
JNIEnv *env;
env = getEnv();
/*
* Prevent any event processing until OnHook has been called
*/
debugMonitorEnter(threadLock);
WITH_LOCAL_REFS(env, 1) {
jint threadCount;
jthread *threads;
threads = allThreads(&threadCount);
if (threads == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"thread table");
} else {
int i;
for (i = 0; i < threadCount; i++) {
ThreadNode *node;
jthread thread = threads[i];
node = insertThread(env, &runningThreads, thread);
/*
* This is a tiny bit risky. We have to assume that the
* pre-existing threads have been started because we
* can't rely on a thread start event for them. The chances
* of a problem related to this are pretty slim though, and
* there's really no choice because without setting this flag
* there is no way to enable stepping and other events on
* the threads that already exist (e.g. the finalizer thread).
*/
node->isStarted = JNI_TRUE;
}
}
} END_WITH_LOCAL_REFS(env)
debugMonitorExit(threadLock);
}
static jvmtiError
commonSuspendByNode(ThreadNode *node)
{
jvmtiError error;
LOG_MISC(("thread=%p suspended", node->thread));
error = JVMTI_FUNC_PTR(gdata->jvmti,SuspendThread)
(gdata->jvmti, node->thread);
/*
* Mark for resume only if suspend succeeded
*/
if (error == JVMTI_ERROR_NONE) {
node->toBeResumed = JNI_TRUE;
}
/*
* If the thread was suspended by another app thread,
* do nothing and report no error (we won't resume it later).
*/
if (error == JVMTI_ERROR_THREAD_SUSPENDED) {
error = JVMTI_ERROR_NONE;
}
return error;
}
/*
* Deferred suspends happen when the suspend is attempted on a thread
* that is not started. Bookkeeping (suspendCount,etc.)
* is handled by the original request, and once the thread actually
* starts, an actual suspend is attempted. This function does the
* deferred suspend without changing the bookkeeping that is already
* in place.
*/
static jint
deferredSuspendThreadByNode(ThreadNode *node)
{
jvmtiError error;
error = JVMTI_ERROR_NONE;
if (node->isDebugThread) {
/* Ignore requests for suspending debugger threads */
return JVMTI_ERROR_NONE;
}
/*
* Do the actual suspend only if a subsequent resume hasn't
* made it irrelevant.
*/
if (node->suspendCount > 0) {
error = commonSuspendByNode(node);
/*
* Attempt to clean up from any error by decrementing the
* suspend count. This compensates for the increment that
* happens when suspendOnStart is set to true.
*/
if (error != JVMTI_ERROR_NONE) {
node->suspendCount--;
}
}
node->suspendOnStart = JNI_FALSE;
debugMonitorNotifyAll(threadLock);
return error;
}
static jvmtiError
suspendThreadByNode(ThreadNode *node)
{
jvmtiError error = JVMTI_ERROR_NONE;
if (node->isDebugThread) {
/* Ignore requests for suspending debugger threads */
return JVMTI_ERROR_NONE;
}
/*
* Just increment the suspend count if we are waiting
* for a deferred suspend.
*/
if (node->suspendOnStart) {
node->suspendCount++;
return JVMTI_ERROR_NONE;
}
if (node->suspendCount == 0) {
error = commonSuspendByNode(node);
if (error == JVMTI_ERROR_THREAD_NOT_ALIVE) {
/*
* This error means that the thread is either a zombie or not yet
* started. In either case, we ignore the error. If the thread
* is a zombie, suspend/resume are no-ops. If the thread is not
* started, it will be suspended for real during the processing
* of its thread start event.
*/
node->suspendOnStart = JNI_TRUE;
error = JVMTI_ERROR_NONE;
}
}
if (error == JVMTI_ERROR_NONE) {
node->suspendCount++;
}
debugMonitorNotifyAll(threadLock);
return error;
}
static jvmtiError
resumeThreadByNode(ThreadNode *node)
{
jvmtiError error = JVMTI_ERROR_NONE;
if (node->isDebugThread) {
/* never suspended by debugger => don't ever try to resume */
return JVMTI_ERROR_NONE;
}
if (node->suspendCount > 0) {
node->suspendCount--;
debugMonitorNotifyAll(threadLock);
if ((node->suspendCount == 0) && node->toBeResumed &&
!node->suspendOnStart) {
LOG_MISC(("thread=%p resumed", node->thread));
error = JVMTI_FUNC_PTR(gdata->jvmti,ResumeThread)
(gdata->jvmti, node->thread);
node->frameGeneration++; /* Increment on each resume */
node->toBeResumed = JNI_FALSE;
if (error == JVMTI_ERROR_THREAD_NOT_ALIVE && !node->isStarted) {
/*
* We successfully "suspended" this thread, but
* we never received a THREAD_START event for it.
* Since the thread never ran, we can ignore our
* failure to resume the thread.
*/
error = JVMTI_ERROR_NONE;
}
}
}
return error;
}
/*
* Functions which respond to user requests to suspend/resume
* threads.
* Suspends and resumes add and subtract from a count respectively.
* The thread is only suspended when the count goes from 0 to 1 and
* resumed only when the count goes from 1 to 0.
*
* These functions suspend and resume application threads
* without changing the
* state of threads that were already suspended beforehand.
* They must not be called from an application thread because
* that thread may be suspended somewhere in the middle of things.
*/
static void
preSuspend(void)
{
getLocks(); /* Avoid debugger deadlocks */
/*
* Delay any suspend while a call to java.lang.Thread.resume is in
* progress (not including those in suspended threads). The wait is
* timed because the threads suspended through
* java.lang.Thread.suspend won't result in a notify even though
* it may change the result of pendingAppResume()
*/
while (pendingAppResume(JNI_FALSE)) {
/*
* This is ugly but we need to release the locks from getLocks
* or else the notify will never happen. The locks must be
* released and reacquired in the right order. else deadlocks
* can happen. It is possible that, during this dance, the
* notify will be missed, but since the wait needs to be timed
* anyway, it won't be a disaster. Note that this code will
* execute only on very rare occasions anyway.
*/
releaseLocks();
debugMonitorEnter(threadLock);
debugMonitorTimedWait(threadLock, 1000);
debugMonitorExit(threadLock);
getLocks();
}
}
static void
postSuspend(void)
{
releaseLocks();
}
/*
* This function must be called after preSuspend and before postSuspend.
*/
static jvmtiError
commonSuspend(JNIEnv *env, jthread thread, jboolean deferred)
{
ThreadNode *node;
/*
* If the thread is not between its start and end events, we should
* still suspend it. To keep track of things, add the thread
* to a separate list of threads so that we'll resume it later.
*/
node = findThread(&runningThreads, thread);
if (node == NULL) {
node = insertThread(env, &otherThreads, thread);
}
if ( deferred ) {
return deferredSuspendThreadByNode(node);
} else {
return suspendThreadByNode(node);
}
}
static jvmtiError
resumeCopyHelper(JNIEnv *env, ThreadNode *node, void *arg)
{
if (node->isDebugThread) {
/* never suspended by debugger => don't ever try to resume */
return JVMTI_ERROR_NONE;
}
if (node->suspendCount > 1) {
node->suspendCount--;
/* nested suspend so just undo one level */
return JVMTI_ERROR_NONE;
}
/*
* This thread was marked for suspension since its THREAD_START
* event came in during a suspendAll, but the helper hasn't
* completed the job yet. We decrement the count so the helper
* won't suspend this thread after we are done with the resumeAll.
* Another case to be handled here is when the debugger suspends
* the thread while the app has it suspended. In this case,
* the toBeResumed flag has been cleared indicating that
* the thread should not be resumed when the debugger does a resume.
* In this case, we also have to decrement the suspend count.
* If we don't then when the app resumes the thread and our Thread.resume
* bkpt handler is called, blockOnDebuggerSuspend will not resume
* the thread because suspendCount will be 1 meaning that the
* debugger has the thread suspended. See bug 6224859.
*/
if (node->suspendCount == 1 && (!node->toBeResumed || node->suspendOnStart)) {
node->suspendCount--;
return JVMTI_ERROR_NONE;
}
if (arg == NULL) {
/* nothing to hard resume so we're done */
return JVMTI_ERROR_NONE;
}
/*
* This is tricky. A suspendCount of 1 and toBeResumed means that
* JVM/DI SuspendThread() or JVM/DI SuspendThreadList() was called
* on this thread. The check for !suspendOnStart is paranoia that
* we inherited from resumeThreadByNode().
*/
if (node->suspendCount == 1 && node->toBeResumed && !node->suspendOnStart) {
jthread **listPtr = (jthread **)arg;
**listPtr = node->thread;
(*listPtr)++;
}
return JVMTI_ERROR_NONE;
}
static jvmtiError
resumeCountHelper(JNIEnv *env, ThreadNode *node, void *arg)
{
if (node->isDebugThread) {
/* never suspended by debugger => don't ever try to resume */
return JVMTI_ERROR_NONE;
}
/*
* This is tricky. A suspendCount of 1 and toBeResumed means that
* JVM/DI SuspendThread() or JVM/DI SuspendThreadList() was called
* on this thread. The check for !suspendOnStart is paranoia that
* we inherited from resumeThreadByNode().
*/
if (node->suspendCount == 1 && node->toBeResumed && !node->suspendOnStart) {
jint *counter = (jint *)arg;
(*counter)++;
}
return JVMTI_ERROR_NONE;
}
static void *
newArray(jint length, size_t nbytes)
{
void *ptr;
ptr = jvmtiAllocate(length*(jint)nbytes);
if ( ptr != NULL ) {
(void)memset(ptr, 0, length*nbytes);
}
return ptr;
}
static void
deleteArray(void *ptr)
{
jvmtiDeallocate(ptr);
}
/*
* This function must be called with the threadLock held.
*
* Two facts conspire to make this routine complicated:
*
* 1) the VM doesn't support nested external suspend
* 2) the original resumeAll code structure doesn't retrieve the
* entire thread list from JVMTI so we use the runningThreads
* list and two helpers to get the job done.
*
* Because we hold the threadLock, state seen by resumeCountHelper()
* is the same state seen in resumeCopyHelper(). resumeCountHelper()
* just counts up the number of threads to be hard resumed.
* resumeCopyHelper() does the accounting for nested suspends and
* special cases and, finally, populates the list of hard resume
* threads to be passed to ResumeThreadList().
*
* At first glance, you might think that the accounting could be done
* in resumeCountHelper(), but then resumeCopyHelper() would see
* "post-resume" state in the accounting values (suspendCount and
* toBeResumed) and would not be able to distinguish between a thread
* that needs a hard resume versus a thread that is already running.
*/
static jvmtiError
commonResumeList(JNIEnv *env)
{
jvmtiError error;
jint i;
jint reqCnt;
jthread *reqList;
jthread *reqPtr;
jvmtiError *results;
reqCnt = 0;
/* count number of threads to hard resume */
(void) enumerateOverThreadList(env, &runningThreads, resumeCountHelper,
&reqCnt);
if (reqCnt == 0) {
/* nothing to hard resume so do just the accounting part */
(void) enumerateOverThreadList(env, &runningThreads, resumeCopyHelper,
NULL);
return JVMTI_ERROR_NONE;
}
/*LINTED*/
reqList = newArray(reqCnt, sizeof(jthread));
if (reqList == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"resume request list");
}
/*LINTED*/
results = newArray(reqCnt, sizeof(jvmtiError));
if (results == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"resume list");
}
/* copy the jthread values for threads to hard resume */
reqPtr = reqList;
(void) enumerateOverThreadList(env, &runningThreads, resumeCopyHelper,
&reqPtr);
error = JVMTI_FUNC_PTR(gdata->jvmti,ResumeThreadList)
(gdata->jvmti, reqCnt, reqList, results);
for (i = 0; i < reqCnt; i++) {
ThreadNode *node;
node = findThread(&runningThreads, reqList[i]);
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD,"missing entry in running thread table");
}
LOG_MISC(("thread=%p resumed as part of list", node->thread));
/*
* resumeThreadByNode() assumes that JVM/DI ResumeThread()
* always works and does all the accounting updates. We do
* the same here. We also don't clear the error.
*/
node->suspendCount--;
node->toBeResumed = JNI_FALSE;
node->frameGeneration++; /* Increment on each resume */
}
deleteArray(results);
deleteArray(reqList);
debugMonitorNotifyAll(threadLock);
return error;
}
/*
* This function must be called after preSuspend and before postSuspend.
*/
static jvmtiError
commonSuspendList(JNIEnv *env, jint initCount, jthread *initList)
{
jvmtiError error;
jint i;
jint reqCnt;
jthread *reqList;
error = JVMTI_ERROR_NONE;
reqCnt = 0;
reqList = newArray(initCount, sizeof(jthread));
if (reqList == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"request list");
}
/*
* Go through the initial list and see if we have anything to suspend.
*/
for (i = 0; i < initCount; i++) {
ThreadNode *node;
/*
* If the thread is not between its start and end events, we should
* still suspend it. To keep track of things, add the thread
* to a separate list of threads so that we'll resume it later.
*/
node = findThread(&runningThreads, initList[i]);
if (node == NULL) {
node = insertThread(env, &otherThreads, initList[i]);
}
if (node->isDebugThread) {
/* Ignore requests for suspending debugger threads */
continue;
}
/*
* Just increment the suspend count if we are waiting
* for a deferred suspend or if this is a nested suspend.
*/
if (node->suspendOnStart || node->suspendCount > 0) {
node->suspendCount++;
continue;
}
if (node->suspendCount == 0) {
/* thread is not suspended yet so put it on the request list */
reqList[reqCnt++] = initList[i];
}
}
if (reqCnt > 0) {
jvmtiError *results = newArray(reqCnt, sizeof(jvmtiError));
if (results == NULL) {
EXIT_ERROR(AGENT_ERROR_OUT_OF_MEMORY,"suspend list results");
}
/*
* We have something to suspend so try to do it.
*/
error = JVMTI_FUNC_PTR(gdata->jvmti,SuspendThreadList)
(gdata->jvmti, reqCnt, reqList, results);
for (i = 0; i < reqCnt; i++) {
ThreadNode *node;
node = findThread(NULL, reqList[i]);
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_INVALID_THREAD,"missing entry in thread tables");
}
LOG_MISC(("thread=%p suspended as part of list", node->thread));
if (results[i] == JVMTI_ERROR_NONE) {
/* thread was suspended as requested */
node->toBeResumed = JNI_TRUE;
} else if (results[i] == JVMTI_ERROR_THREAD_SUSPENDED) {
/*
* If the thread was suspended by another app thread,
* do nothing and report no error (we won't resume it later).
*/
results[i] = JVMTI_ERROR_NONE;
} else if (results[i] == JVMTI_ERROR_THREAD_NOT_ALIVE) {
/*
* This error means that the suspend request failed
* because the thread is either a zombie or not yet
* started. In either case, we ignore the error. If the
* thread is a zombie, suspend/resume are no-ops. If the
* thread is not started, it will be suspended for real
* during the processing of its thread start event.
*/
node->suspendOnStart = JNI_TRUE;
results[i] = JVMTI_ERROR_NONE;
}
/* count real, app and deferred (suspendOnStart) suspensions */
if (results[i] == JVMTI_ERROR_NONE) {
node->suspendCount++;
}
}
deleteArray(results);
}
deleteArray(reqList);
debugMonitorNotifyAll(threadLock);
return error;
}
static jvmtiError
commonResume(jthread thread)
{
jvmtiError error;
ThreadNode *node;
/*
* The thread is normally between its start and end events, but if
* not, check the auxiliary list used by threadControl_suspendThread.
*/
node = findThread(NULL, thread);
/*
* If the node is in neither list, the debugger never suspended
* this thread, so do nothing.
*/
error = JVMTI_ERROR_NONE;
if (node != NULL) {
error = resumeThreadByNode(node);
}
return error;
}
jvmtiError
threadControl_suspendThread(jthread thread, jboolean deferred)
{
jvmtiError error;
JNIEnv *env;
env = getEnv();
log_debugee_location("threadControl_suspendThread()", thread, NULL, 0);
preSuspend();
error = commonSuspend(env, thread, deferred);
postSuspend();
return error;
}
jvmtiError
threadControl_resumeThread(jthread thread, jboolean do_unblock)
{
jvmtiError error;
JNIEnv *env;
env = getEnv();
log_debugee_location("threadControl_resumeThread()", thread, NULL, 0);
eventHandler_lock(); /* for proper lock order */
debugMonitorEnter(threadLock);
error = commonResume(thread);
removeResumed(env, &otherThreads);
debugMonitorExit(threadLock);
eventHandler_unlock();
if (do_unblock) {
/* let eventHelper.c: commandLoop() know we resumed one thread */
unblockCommandLoop();
}
return error;
}
jvmtiError
threadControl_suspendCount(jthread thread, jint *count)
{
jvmtiError error;
ThreadNode *node;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node == NULL) {
node = findThread(&otherThreads, thread);
}
error = JVMTI_ERROR_NONE;
if (node != NULL) {
*count = node->suspendCount;
} else {
/*
* If the node is in neither list, the debugger never suspended
* this thread, so the suspend count is 0.
*/
*count = 0;
}
debugMonitorExit(threadLock);
return error;
}
static jboolean
contains(JNIEnv *env, jthread *list, jint count, jthread item)
{
int i;
for (i = 0; i < count; i++) {
if (isSameObject(env, list[i], item)) {
return JNI_TRUE;
}
}
return JNI_FALSE;
}
typedef struct {
jthread *list;
jint count;
} SuspendAllArg;
static jvmtiError
suspendAllHelper(JNIEnv *env, ThreadNode *node, void *arg)
{
SuspendAllArg *saArg = (SuspendAllArg *)arg;
jvmtiError error = JVMTI_ERROR_NONE;
jthread *list = saArg->list;
jint count = saArg->count;
if (!contains(env, list, count, node->thread)) {
error = commonSuspend(env, node->thread, JNI_FALSE);
}
return error;
}
jvmtiError
threadControl_suspendAll(void)
{
jvmtiError error;
JNIEnv *env;
env = getEnv();
log_debugee_location("threadControl_suspendAll()", NULL, NULL, 0);
preSuspend();
/*
* Get a list of all threads and suspend them.
*/
WITH_LOCAL_REFS(env, 1) {
jthread *threads;
jint count;
threads = allThreads(&count);
if (threads == NULL) {
error = AGENT_ERROR_OUT_OF_MEMORY;
goto err;
}
if (canSuspendResumeThreadLists()) {
error = commonSuspendList(env, count, threads);
if (error != JVMTI_ERROR_NONE) {
goto err;
}
} else {
int i;
for (i = 0; i < count; i++) {
error = commonSuspend(env, threads[i], JNI_FALSE);
if (error != JVMTI_ERROR_NONE) {
goto err;
}
}
}
/*
* Update the suspend count of any threads not yet (or no longer)
* in the thread list above.
*/
{
SuspendAllArg arg;
arg.list = threads;
arg.count = count;
error = enumerateOverThreadList(env, &otherThreads,
suspendAllHelper, &arg);
}
if (error == JVMTI_ERROR_NONE) {
suspendAllCount++;
}
err: ;
} END_WITH_LOCAL_REFS(env)
postSuspend();
return error;
}
static jvmtiError
resumeHelper(JNIEnv *env, ThreadNode *node, void *ignored)
{
/*
* Since this helper is called with the threadLock held, we
* don't need to recheck to see if the node is still on one
* of the two thread lists.
*/
return resumeThreadByNode(node);
}
jvmtiError
threadControl_resumeAll(void)
{
jvmtiError error;
JNIEnv *env;
env = getEnv();
log_debugee_location("threadControl_resumeAll()", NULL, NULL, 0);
eventHandler_lock(); /* for proper lock order */
debugMonitorEnter(threadLock);
/*
* Resume only those threads that the debugger has suspended. All
* such threads must have a node in one of the thread lists, so there's
* no need to get the whole thread list from JVMTI (unlike
* suspendAll).
*/
if (canSuspendResumeThreadLists()) {
error = commonResumeList(env);
} else {
error = enumerateOverThreadList(env, &runningThreads,
resumeHelper, NULL);
}
if ((error == JVMTI_ERROR_NONE) && (otherThreads.first != NULL)) {
error = enumerateOverThreadList(env, &otherThreads,
resumeHelper, NULL);
removeResumed(env, &otherThreads);
}
if (suspendAllCount > 0) {
suspendAllCount--;
}
debugMonitorExit(threadLock);
eventHandler_unlock();
/* let eventHelper.c: commandLoop() know we are resuming */
unblockCommandLoop();
return error;
}
StepRequest *
threadControl_getStepRequest(jthread thread)
{
ThreadNode *node;
StepRequest *step;
step = NULL;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
step = &node->currentStep;
}
debugMonitorExit(threadLock);
return step;
}
InvokeRequest *
threadControl_getInvokeRequest(jthread thread)
{
ThreadNode *node;
InvokeRequest *request;
request = NULL;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
request = &node->currentInvoke;
}
debugMonitorExit(threadLock);
return request;
}
jvmtiError
threadControl_addDebugThread(jthread thread)
{
jvmtiError error;
debugMonitorEnter(threadLock);
if (debugThreadCount >= MAX_DEBUG_THREADS) {
error = AGENT_ERROR_OUT_OF_MEMORY;
} else {
JNIEnv *env;
env = getEnv();
debugThreads[debugThreadCount] = NULL;
saveGlobalRef(env, thread, &(debugThreads[debugThreadCount]));
if (debugThreads[debugThreadCount] == NULL) {
error = AGENT_ERROR_OUT_OF_MEMORY;
} else {
debugThreadCount++;
error = JVMTI_ERROR_NONE;
}
}
debugMonitorExit(threadLock);
return error;
}
static jvmtiError
threadControl_removeDebugThread(jthread thread)
{
jvmtiError error;
JNIEnv *env;
int i;
error = AGENT_ERROR_INVALID_THREAD;
env = getEnv();
debugMonitorEnter(threadLock);
for (i = 0; i< debugThreadCount; i++) {
if (isSameObject(env, thread, debugThreads[i])) {
int j;
tossGlobalRef(env, &(debugThreads[i]));
for (j = i+1; j < debugThreadCount; j++) {
debugThreads[j-1] = debugThreads[j];
}
debugThreadCount--;
error = JVMTI_ERROR_NONE;
break;
}
}
debugMonitorExit(threadLock);
return error;
}
jboolean
threadControl_isDebugThread(jthread thread)
{
int i;
jboolean rc;
JNIEnv *env;
rc = JNI_FALSE;
env = getEnv();
debugMonitorEnter(threadLock);
for (i = 0; i < debugThreadCount; i++) {
if (isSameObject(env, thread, debugThreads[i])) {
rc = JNI_TRUE;
break;
}
}
debugMonitorExit(threadLock);
return rc;
}
static void
initLocks(void)
{
if (popFrameEventLock == NULL) {
popFrameEventLock = debugMonitorCreate("JDWP PopFrame Event Lock");
popFrameProceedLock = debugMonitorCreate("JDWP PopFrame Proceed Lock");
}
}
static jboolean
getPopFrameThread(jthread thread)
{
jboolean popFrameThread;
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node == NULL) {
popFrameThread = JNI_FALSE;
} else {
popFrameThread = node->popFrameThread;
}
}
debugMonitorExit(threadLock);
return popFrameThread;
}
static void
setPopFrameThread(jthread thread, jboolean value)
{
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table");
} else {
node->popFrameThread = value;
}
}
debugMonitorExit(threadLock);
}
static jboolean
getPopFrameEvent(jthread thread)
{
jboolean popFrameEvent;
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node == NULL) {
popFrameEvent = JNI_FALSE;
EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table");
} else {
popFrameEvent = node->popFrameEvent;
}
}
debugMonitorExit(threadLock);
return popFrameEvent;
}
static void
setPopFrameEvent(jthread thread, jboolean value)
{
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table");
} else {
node->popFrameEvent = value;
node->frameGeneration++; /* Increment on each resume */
}
}
debugMonitorExit(threadLock);
}
static jboolean
getPopFrameProceed(jthread thread)
{
jboolean popFrameProceed;
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node == NULL) {
popFrameProceed = JNI_FALSE;
EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table");
} else {
popFrameProceed = node->popFrameProceed;
}
}
debugMonitorExit(threadLock);
return popFrameProceed;
}
static void
setPopFrameProceed(jthread thread, jboolean value)
{
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"entry in thread table");
} else {
node->popFrameProceed = value;
}
}
debugMonitorExit(threadLock);
}
/**
* Special event handler for events on the popped thread
* that occur during the pop operation.
*/
static void
popFrameCompleteEvent(jthread thread)
{
debugMonitorEnter(popFrameProceedLock);
{
/* notify that we got the event */
debugMonitorEnter(popFrameEventLock);
{
setPopFrameEvent(thread, JNI_TRUE);
debugMonitorNotify(popFrameEventLock);
}
debugMonitorExit(popFrameEventLock);
/* make sure we get suspended again */
setPopFrameProceed(thread, JNI_FALSE);
while (getPopFrameProceed(thread) == JNI_FALSE) {
debugMonitorWait(popFrameProceedLock);
}
}
debugMonitorExit(popFrameProceedLock);
}
/**
* Pop one frame off the stack of thread.
* popFrameEventLock is already held
*/
static jvmtiError
popOneFrame(jthread thread)
{
jvmtiError error;
error = JVMTI_FUNC_PTR(gdata->jvmti,PopFrame)(gdata->jvmti, thread);
if (error != JVMTI_ERROR_NONE) {
return error;
}
/* resume the popped thread so that the pop occurs and so we */
/* will get the event (step or method entry) after the pop */
LOG_MISC(("thread=%p resumed in popOneFrame", thread));
error = JVMTI_FUNC_PTR(gdata->jvmti,ResumeThread)(gdata->jvmti, thread);
if (error != JVMTI_ERROR_NONE) {
return error;
}
/* wait for the event to occur */
setPopFrameEvent(thread, JNI_FALSE);
while (getPopFrameEvent(thread) == JNI_FALSE) {
debugMonitorWait(popFrameEventLock);
}
/* make sure not to suspend until the popped thread is on the wait */
debugMonitorEnter(popFrameProceedLock);
{
/* return popped thread to suspended state */
LOG_MISC(("thread=%p suspended in popOneFrame", thread));
error = JVMTI_FUNC_PTR(gdata->jvmti,SuspendThread)(gdata->jvmti, thread);
/* notify popped thread so it can proceed when resumed */
setPopFrameProceed(thread, JNI_TRUE);
debugMonitorNotify(popFrameProceedLock);
}
debugMonitorExit(popFrameProceedLock);
return error;
}
/**
* pop frames of the stack of 'thread' until 'frame' is popped.
*/
jvmtiError
threadControl_popFrames(jthread thread, FrameNumber fnum)
{
jvmtiError error;
jvmtiEventMode prevStepMode;
jint framesPopped = 0;
jint popCount;
jboolean prevInvokeRequestMode;
log_debugee_location("threadControl_popFrames()", thread, NULL, 0);
initLocks();
/* compute the number of frames to pop */
popCount = fnum+1;
if (popCount < 1) {
return AGENT_ERROR_NO_MORE_FRAMES;
}
/* enable instruction level single step, but first note prev value */
prevStepMode = threadControl_getInstructionStepMode(thread);
/*
* Fix bug 6517249. The pop processing will disable invokes,
* so remember if invokes are enabled now and restore
* that state after we finish popping.
*/
prevInvokeRequestMode = invoker_isEnabled(thread);
error = threadControl_setEventMode(JVMTI_ENABLE,
EI_SINGLE_STEP, thread);
if (error != JVMTI_ERROR_NONE) {
return error;
}
/* Inform eventHandler logic we are in a popFrame for this thread */
debugMonitorEnter(popFrameEventLock);
{
setPopFrameThread(thread, JNI_TRUE);
/* pop frames using single step */
while (framesPopped++ < popCount) {
error = popOneFrame(thread);
if (error != JVMTI_ERROR_NONE) {
break;
}
}
setPopFrameThread(thread, JNI_FALSE);
}
debugMonitorExit(popFrameEventLock);
/* Reset StepRequest info (fromLine and stackDepth) after popframes
* only if stepping is enabled.
*/
if (prevStepMode == JVMTI_ENABLE) {
stepControl_resetRequest(thread);
}
if (prevInvokeRequestMode) {
invoker_enableInvokeRequests(thread);
}
/* restore state */
(void)threadControl_setEventMode(prevStepMode,
EI_SINGLE_STEP, thread);
return error;
}
/* Check to see if any events are being consumed by a popFrame(). */
static jboolean
checkForPopFrameEvents(JNIEnv *env, EventIndex ei, jthread thread)
{
if ( getPopFrameThread(thread) ) {
switch (ei) {
case EI_THREAD_START:
/* Excuse me? */
EXIT_ERROR(AGENT_ERROR_INTERNAL, "thread start during pop frame");
break;
case EI_THREAD_END:
/* Thread wants to end? let it. */
setPopFrameThread(thread, JNI_FALSE);
popFrameCompleteEvent(thread);
break;
case EI_SINGLE_STEP:
/* This is an event we requested to mark the */
/* completion of the pop frame */
popFrameCompleteEvent(thread);
return JNI_TRUE;
case EI_BREAKPOINT:
case EI_EXCEPTION:
case EI_FIELD_ACCESS:
case EI_FIELD_MODIFICATION:
case EI_METHOD_ENTRY:
case EI_METHOD_EXIT:
/* Tell event handler to assume event has been consumed. */
return JNI_TRUE;
default:
break;
}
}
/* Pretend we were never called */
return JNI_FALSE;
}
struct bag *
threadControl_onEventHandlerEntry(jbyte sessionID, EventIndex ei, jthread thread, jobject currentException)
{
ThreadNode *node;
JNIEnv *env;
struct bag *eventBag;
jthread threadToSuspend;
jboolean consumed;
env = getEnv();
threadToSuspend = NULL;
log_debugee_location("threadControl_onEventHandlerEntry()", thread, NULL, 0);
/* Events during pop commands may need to be ignored here. */
consumed = checkForPopFrameEvents(env, ei, thread);
if ( consumed ) {
/* Always restore any exception (see below). */
if (currentException != NULL) {
JNI_FUNC_PTR(env,Throw)(env, currentException);
} else {
JNI_FUNC_PTR(env,ExceptionClear)(env);
}
return NULL;
}
debugMonitorEnter(threadLock);
/*
* Check the list of unknown threads maintained by suspend
* and resume. If this thread is currently present in the
* list, it should be
* moved to the runningThreads list, since it is a
* well-known thread now.
*/
node = findThread(&otherThreads, thread);
if (node != NULL) {
moveNode(&otherThreads, &runningThreads, node);
} else {
/*
* Get a thread node for the reporting thread. For thread start
* events, or if this event precedes a thread start event,
* the thread node may need to be created.
*
* It is possible for certain events (notably method entry/exit)
* to precede thread start for some VM implementations.
*/
node = insertThread(env, &runningThreads, thread);
}
if (ei == EI_THREAD_START) {
node->isStarted = JNI_TRUE;
processDeferredEventModes(env, thread, node);
}
node->current_ei = ei;
eventBag = node->eventBag;
if (node->suspendOnStart) {
threadToSuspend = node->thread;
}
debugMonitorExit(threadLock);
if (threadToSuspend != NULL) {
/*
* An attempt was made to suspend this thread before it started.
* We must suspend it now, before it starts to run. This must
* be done with no locks held.
*/
eventHelper_suspendThread(sessionID, threadToSuspend);
}
return eventBag;
}
static void
doPendingTasks(JNIEnv *env, ThreadNode *node)
{
/*
* Take care of any pending interrupts/stops, and clear out
* info on pending interrupts/stops.
*/
if (node->pendingInterrupt) {
JVMTI_FUNC_PTR(gdata->jvmti,InterruptThread)
(gdata->jvmti, node->thread);
/*
* TO DO: Log error
*/
node->pendingInterrupt = JNI_FALSE;
}
if (node->pendingStop != NULL) {
JVMTI_FUNC_PTR(gdata->jvmti,StopThread)
(gdata->jvmti, node->thread, node->pendingStop);
/*
* TO DO: Log error
*/
tossGlobalRef(env, &(node->pendingStop));
}
}
void
threadControl_onEventHandlerExit(EventIndex ei, jthread thread,
struct bag *eventBag)
{
ThreadNode *node;
log_debugee_location("threadControl_onEventHandlerExit()", thread, NULL, 0);
if (ei == EI_THREAD_END) {
eventHandler_lock(); /* for proper lock order */
}
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node == NULL) {
EXIT_ERROR(AGENT_ERROR_NULL_POINTER,"thread list corrupted");
} else {
JNIEnv *env;
env = getEnv();
if (ei == EI_THREAD_END) {
jboolean inResume = (node->resumeFrameDepth > 0);
removeThread(env, &runningThreads, thread);
node = NULL; /* has been freed */
/*
* Clean up mechanism used to detect end of
* resume.
*/
if (inResume) {
notifyAppResumeComplete();
}
} else {
/* No point in doing this if the thread is about to die.*/
doPendingTasks(env, node);
node->eventBag = eventBag;
node->current_ei = 0;
}
}
debugMonitorExit(threadLock);
if (ei == EI_THREAD_END) {
eventHandler_unlock();
}
}
/* Returns JDWP flavored status and status flags. */
jvmtiError
threadControl_applicationThreadStatus(jthread thread,
jdwpThreadStatus *pstatus, jint *statusFlags)
{
ThreadNode *node;
jvmtiError error;
jint state;
log_debugee_location("threadControl_applicationThreadStatus()", thread, NULL, 0);
debugMonitorEnter(threadLock);
error = threadState(thread, &state);
*pstatus = map2jdwpThreadStatus(state);
*statusFlags = map2jdwpSuspendStatus(state);
if (error == JVMTI_ERROR_NONE) {
node = findThread(&runningThreads, thread);
if ((node != NULL) && HANDLING_EVENT(node)) {
/*
* While processing an event, an application thread is always
* considered to be running even if its handler happens to be
* cond waiting on an internal debugger monitor, etc.
*
* Leave suspend status untouched since it is not possible
* to distinguish debugger suspends from app suspends.
*/
*pstatus = JDWP_THREAD_STATUS(RUNNING);
}
}
debugMonitorExit(threadLock);
return error;
}
jvmtiError
threadControl_interrupt(jthread thread)
{
ThreadNode *node;
jvmtiError error;
error = JVMTI_ERROR_NONE;
log_debugee_location("threadControl_interrupt()", thread, NULL, 0);
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if ((node == NULL) || !HANDLING_EVENT(node)) {
error = JVMTI_FUNC_PTR(gdata->jvmti,InterruptThread)
(gdata->jvmti, thread);
} else {
/*
* Hold any interrupts until after the event is processed.
*/
node->pendingInterrupt = JNI_TRUE;
}
debugMonitorExit(threadLock);
return error;
}
void
threadControl_clearCLEInfo(JNIEnv *env, jthread thread)
{
ThreadNode *node;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
node->cleInfo.ei = 0;
if (node->cleInfo.clazz != NULL) {
tossGlobalRef(env, &(node->cleInfo.clazz));
}
}
debugMonitorExit(threadLock);
}
jboolean
threadControl_cmpCLEInfo(JNIEnv *env, jthread thread, jclass clazz,
jmethodID method, jlocation location)
{
ThreadNode *node;
jboolean result;
result = JNI_FALSE;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL && node->cleInfo.ei != 0 &&
node->cleInfo.method == method &&
node->cleInfo.location == location &&
(isSameObject(env, node->cleInfo.clazz, clazz))) {
result = JNI_TRUE; /* we have a match */
}
debugMonitorExit(threadLock);
return result;
}
void
threadControl_saveCLEInfo(JNIEnv *env, jthread thread, EventIndex ei,
jclass clazz, jmethodID method, jlocation location)
{
ThreadNode *node;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
node->cleInfo.ei = ei;
/* Create a class ref that will live beyond */
/* the end of this call */
saveGlobalRef(env, clazz, &(node->cleInfo.clazz));
/* if returned clazz is NULL, we just won't match */
node->cleInfo.method = method;
node->cleInfo.location = location;
}
debugMonitorExit(threadLock);
}
void
threadControl_setPendingInterrupt(jthread thread)
{
ThreadNode *node;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
node->pendingInterrupt = JNI_TRUE;
}
debugMonitorExit(threadLock);
}
jvmtiError
threadControl_stop(jthread thread, jobject throwable)
{
ThreadNode *node;
jvmtiError error;
error = JVMTI_ERROR_NONE;
log_debugee_location("threadControl_stop()", thread, NULL, 0);
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if ((node == NULL) || !HANDLING_EVENT(node)) {
error = JVMTI_FUNC_PTR(gdata->jvmti,StopThread)
(gdata->jvmti, thread, throwable);
} else {
JNIEnv *env;
/*
* Hold any stops until after the event is processed.
*/
env = getEnv();
saveGlobalRef(env, throwable, &(node->pendingStop));
}
debugMonitorExit(threadLock);
return error;
}
static jvmtiError
detachHelper(JNIEnv *env, ThreadNode *node, void *arg)
{
invoker_detach(&node->currentInvoke);
return JVMTI_ERROR_NONE;
}
void
threadControl_detachInvokes(void)
{
JNIEnv *env;
env = getEnv();
invoker_lock(); /* for proper lock order */
debugMonitorEnter(threadLock);
(void)enumerateOverThreadList(env, &runningThreads, detachHelper, NULL);
debugMonitorExit(threadLock);
invoker_unlock();
}
static jvmtiError
resetHelper(JNIEnv *env, ThreadNode *node, void *arg)
{
if (node->toBeResumed) {
LOG_MISC(("thread=%p resumed", node->thread));
(void)JVMTI_FUNC_PTR(gdata->jvmti,ResumeThread)(gdata->jvmti, node->thread);
node->frameGeneration++; /* Increment on each resume */
}
stepControl_clearRequest(node->thread, &node->currentStep);
node->toBeResumed = JNI_FALSE;
node->suspendCount = 0;
node->suspendOnStart = JNI_FALSE;
return JVMTI_ERROR_NONE;
}
void
threadControl_reset(void)
{
JNIEnv *env;
env = getEnv();
eventHandler_lock(); /* for proper lock order */
debugMonitorEnter(threadLock);
(void)enumerateOverThreadList(env, &runningThreads, resetHelper, NULL);
(void)enumerateOverThreadList(env, &otherThreads, resetHelper, NULL);
removeResumed(env, &otherThreads);
freeDeferredEventModes(env);
suspendAllCount = 0;
/* Everything should have been resumed */
JDI_ASSERT(otherThreads.first == NULL);
debugMonitorExit(threadLock);
eventHandler_unlock();
}
jvmtiEventMode
threadControl_getInstructionStepMode(jthread thread)
{
ThreadNode *node;
jvmtiEventMode mode;
mode = JVMTI_DISABLE;
debugMonitorEnter(threadLock);
node = findThread(&runningThreads, thread);
if (node != NULL) {
mode = node->instructionStepMode;
}
debugMonitorExit(threadLock);
return mode;
}
jvmtiError
threadControl_setEventMode(jvmtiEventMode mode, EventIndex ei, jthread thread)
{
jvmtiError error;
/* Global event */
if ( thread == NULL ) {
error = JVMTI_FUNC_PTR(gdata->jvmti,SetEventNotificationMode)
(gdata->jvmti, mode, eventIndex2jvmti(ei), thread);
} else {
/* Thread event */
ThreadNode *node;
debugMonitorEnter(threadLock);
{
node = findThread(&runningThreads, thread);
if ((node == NULL) || (!node->isStarted)) {
JNIEnv *env;
env = getEnv();
error = addDeferredEventMode(env, mode, ei, thread);
} else {
error = threadSetEventNotificationMode(node,
mode, ei, thread);
}
}
debugMonitorExit(threadLock);
}
return error;
}
/*
* Returns the current thread, if the thread has generated at least
* one event, and has not generated a thread end event.
*/
jthread threadControl_currentThread(void)
{
jthread thread;
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(&runningThreads, NULL);
thread = (node == NULL) ? NULL : node->thread;
}
debugMonitorExit(threadLock);
return thread;
}
jlong
threadControl_getFrameGeneration(jthread thread)
{
jlong frameGeneration = -1;
debugMonitorEnter(threadLock);
{
ThreadNode *node;
node = findThread(NULL, thread);
if (node != NULL) {
frameGeneration = node->frameGeneration;
}
}
debugMonitorExit(threadLock);
return frameGeneration;
}