| /* |
| * Copyright (c) 2001, 2013, 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. |
| */ |
| /* |
| * eventFilter |
| * |
| * This module handles event filteration and the enabling/disabling |
| * of the corresponding events. Used for filters on JDI EventRequests |
| * and also internal requests. Our data is in a private hidden section |
| * of the HandlerNode's data. See comment for enclosing |
| * module eventHandler. |
| */ |
| |
| #include "util.h" |
| #include "eventFilter.h" |
| #include "eventFilterRestricted.h" |
| #include "eventHandlerRestricted.h" |
| #include "stepControl.h" |
| #include "threadControl.h" |
| #include "SDE.h" |
| #include "jvmti.h" |
| |
| typedef struct ClassFilter { |
| jclass clazz; |
| } ClassFilter; |
| |
| typedef struct LocationFilter { |
| jclass clazz; |
| jmethodID method; |
| jlocation location; |
| } LocationFilter; |
| |
| typedef struct ThreadFilter { |
| jthread thread; |
| } ThreadFilter; |
| |
| typedef struct CountFilter { |
| jint count; |
| } CountFilter; |
| |
| typedef struct ConditionalFilter { |
| jint exprID; |
| } ConditionalFilter; |
| |
| typedef struct FieldFilter { |
| jclass clazz; |
| jfieldID field; |
| } FieldFilter; |
| |
| typedef struct ExceptionFilter { |
| jclass exception; |
| jboolean caught; |
| jboolean uncaught; |
| } ExceptionFilter; |
| |
| typedef struct InstanceFilter { |
| jobject instance; |
| } InstanceFilter; |
| |
| typedef struct StepFilter { |
| jint size; |
| jint depth; |
| jthread thread; |
| } StepFilter; |
| |
| typedef struct MatchFilter { |
| char *classPattern; |
| } MatchFilter; |
| |
| typedef struct SourceNameFilter { |
| char *sourceNamePattern; |
| } SourceNameFilter; |
| |
| typedef struct Filter_ { |
| jbyte modifier; |
| union { |
| struct ClassFilter ClassOnly; |
| struct LocationFilter LocationOnly; |
| struct ThreadFilter ThreadOnly; |
| struct CountFilter Count; |
| struct ConditionalFilter Conditional; |
| struct FieldFilter FieldOnly; |
| struct ExceptionFilter ExceptionOnly; |
| struct InstanceFilter InstanceOnly; |
| struct StepFilter Step; |
| struct MatchFilter ClassMatch; |
| struct MatchFilter ClassExclude; |
| struct SourceNameFilter SourceNameOnly; |
| } u; |
| } Filter; |
| |
| /* The filters array is allocated to the specified filterCount. |
| * Theoretically, some compiler could do range checking on this |
| * array - so, we define it to have a ludicrously large size so |
| * that this range checking won't get upset. |
| * |
| * The actual allocated number of bytes is computed using the |
| * offset of "filters" and so is not effected by this number. |
| */ |
| #define MAX_FILTERS 10000 |
| |
| typedef struct EventFilters_ { |
| jint filterCount; |
| Filter filters[MAX_FILTERS]; |
| } EventFilters; |
| |
| typedef struct EventFilterPrivate_HandlerNode_ { |
| EventHandlerRestricted_HandlerNode not_for_us; |
| EventFilters ef; |
| } EventFilterPrivate_HandlerNode; |
| |
| /** |
| * The following macros extract filter info (EventFilters) from private |
| * data at the end of a HandlerNode |
| */ |
| #define EVENT_FILTERS(node) (&(((EventFilterPrivate_HandlerNode*)(void*)node)->ef)) |
| #define FILTER_COUNT(node) (EVENT_FILTERS(node)->filterCount) |
| #define FILTERS_ARRAY(node) (EVENT_FILTERS(node)->filters) |
| #define FILTER(node,index) ((FILTERS_ARRAY(node))[index]) |
| #define NODE_EI(node) (node->ei) |
| |
| /***** filter set-up / destruction *****/ |
| |
| /** |
| * Allocate a HandlerNode. |
| * We do it because eventHandler doesn't know how big to make it. |
| */ |
| HandlerNode * |
| eventFilterRestricted_alloc(jint filterCount) |
| { |
| /*LINTED*/ |
| size_t size = offsetof(EventFilterPrivate_HandlerNode, ef) + |
| offsetof(EventFilters, filters) + |
| (filterCount * (int)sizeof(Filter)); |
| HandlerNode *node = jvmtiAllocate((jint)size); |
| |
| if (node != NULL) { |
| int i; |
| Filter *filter; |
| |
| (void)memset(node, 0, size); |
| |
| FILTER_COUNT(node) = filterCount; |
| |
| /* Initialize all modifiers |
| */ |
| for (i = 0, filter = FILTERS_ARRAY(node); |
| i < filterCount; |
| i++, filter++) { |
| filter->modifier = JDWP_REQUEST_NONE; |
| } |
| } |
| |
| return node; |
| } |
| |
| /** |
| * Free up global refs held by the filter. |
| * free things up at the JNI level if needed. |
| */ |
| static jvmtiError |
| clearFilters(HandlerNode *node) |
| { |
| JNIEnv *env = getEnv(); |
| jint i; |
| jvmtiError error = JVMTI_ERROR_NONE; |
| Filter *filter = FILTERS_ARRAY(node); |
| |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(ThreadOnly): |
| if ( filter->u.ThreadOnly.thread != NULL ) { |
| tossGlobalRef(env, &(filter->u.ThreadOnly.thread)); |
| } |
| break; |
| case JDWP_REQUEST_MODIFIER(LocationOnly): |
| tossGlobalRef(env, &(filter->u.LocationOnly.clazz)); |
| break; |
| case JDWP_REQUEST_MODIFIER(FieldOnly): |
| tossGlobalRef(env, &(filter->u.FieldOnly.clazz)); |
| break; |
| case JDWP_REQUEST_MODIFIER(ExceptionOnly): |
| if ( filter->u.ExceptionOnly.exception != NULL ) { |
| tossGlobalRef(env, &(filter->u.ExceptionOnly.exception)); |
| } |
| break; |
| case JDWP_REQUEST_MODIFIER(InstanceOnly): |
| if ( filter->u.InstanceOnly.instance != NULL ) { |
| tossGlobalRef(env, &(filter->u.InstanceOnly.instance)); |
| } |
| break; |
| case JDWP_REQUEST_MODIFIER(ClassOnly): |
| tossGlobalRef(env, &(filter->u.ClassOnly.clazz)); |
| break; |
| case JDWP_REQUEST_MODIFIER(ClassMatch): |
| jvmtiDeallocate(filter->u.ClassMatch.classPattern); |
| break; |
| case JDWP_REQUEST_MODIFIER(ClassExclude): |
| jvmtiDeallocate(filter->u.ClassExclude.classPattern); |
| break; |
| case JDWP_REQUEST_MODIFIER(Step): { |
| jthread thread = filter->u.Step.thread; |
| error = stepControl_endStep(thread); |
| if (error == JVMTI_ERROR_NONE) { |
| tossGlobalRef(env, &(filter->u.Step.thread)); |
| } |
| break; |
| } |
| } |
| } |
| if (error == JVMTI_ERROR_NONE) { |
| FILTER_COUNT(node) = 0; /* blast so we don't clear again */ |
| } |
| |
| return error; |
| } |
| |
| |
| /***** filtering *****/ |
| |
| /* |
| * Match a string against a wildcard |
| * string pattern. |
| */ |
| static jboolean |
| patternStringMatch(char *classname, const char *pattern) |
| { |
| int pattLen; |
| int compLen; |
| char *start; |
| int offset; |
| |
| if ( pattern==NULL || classname==NULL ) { |
| return JNI_FALSE; |
| } |
| pattLen = (int)strlen(pattern); |
| |
| if ((pattern[0] != '*') && (pattern[pattLen-1] != '*')) { |
| /* An exact match is required when there is no *: bug 4331522 */ |
| return strcmp(pattern, classname) == 0; |
| } else { |
| compLen = pattLen - 1; |
| offset = (int)strlen(classname) - compLen; |
| if (offset < 0) { |
| return JNI_FALSE; |
| } else { |
| if (pattern[0] == '*') { |
| pattern++; |
| start = classname + offset; |
| } else { |
| start = classname; |
| } |
| return strncmp(pattern, start, compLen) == 0; |
| } |
| } |
| } |
| |
| static jboolean isVersionGte12x() { |
| jint version; |
| jvmtiError err = |
| JVMTI_FUNC_PTR(gdata->jvmti,GetVersionNumber)(gdata->jvmti, &version); |
| |
| if (err == JVMTI_ERROR_NONE) { |
| jint major, minor; |
| |
| major = (version & JVMTI_VERSION_MASK_MAJOR) |
| >> JVMTI_VERSION_SHIFT_MAJOR; |
| minor = (version & JVMTI_VERSION_MASK_MINOR) |
| >> JVMTI_VERSION_SHIFT_MINOR; |
| return (major > 1 || major == 1 && minor >= 2); |
| } else { |
| return JNI_FALSE; |
| } |
| } |
| |
| /* Return the object instance in which the event occurred */ |
| /* Return NULL if static or if an error occurs */ |
| static jobject |
| eventInstance(EventInfo *evinfo) |
| { |
| jobject object = NULL; |
| jthread thread ; |
| jmethodID method ; |
| jint modifiers = 0; |
| jvmtiError error; |
| |
| static jboolean got_version = JNI_FALSE; |
| static jboolean is_version_gte_12x = JNI_FALSE; |
| |
| if (!got_version) { |
| is_version_gte_12x = isVersionGte12x(); |
| got_version = JNI_TRUE; |
| } |
| |
| switch (evinfo->ei) { |
| case EI_SINGLE_STEP: |
| case EI_BREAKPOINT: |
| case EI_FRAME_POP: |
| case EI_METHOD_ENTRY: |
| case EI_METHOD_EXIT: |
| case EI_EXCEPTION: |
| case EI_EXCEPTION_CATCH: |
| case EI_MONITOR_CONTENDED_ENTER: |
| case EI_MONITOR_CONTENDED_ENTERED: |
| case EI_MONITOR_WAIT: |
| case EI_MONITOR_WAITED: |
| thread = evinfo->thread; |
| method = evinfo->method; |
| break; |
| case EI_FIELD_ACCESS: |
| case EI_FIELD_MODIFICATION: |
| object = evinfo->object; |
| return object; |
| default: |
| return object; /* NULL */ |
| } |
| |
| error = methodModifiers(method, &modifiers); |
| |
| /* fail if error or static (0x8) */ |
| if (error == JVMTI_ERROR_NONE && thread!=NULL && (modifiers & 0x8) == 0) { |
| FrameNumber fnum = 0; |
| if (is_version_gte_12x) { |
| /* Use new 1.2.x function, GetLocalInstance */ |
| error = JVMTI_FUNC_PTR(gdata->jvmti,GetLocalInstance) |
| (gdata->jvmti, thread, fnum, &object); |
| } else { |
| /* get slot zero object "this" */ |
| error = JVMTI_FUNC_PTR(gdata->jvmti,GetLocalObject) |
| (gdata->jvmti, thread, fnum, 0, &object); |
| } |
| if (error != JVMTI_ERROR_NONE) { |
| object = NULL; |
| } |
| } |
| |
| return object; |
| } |
| |
| /* |
| * Determine if this event is interesting to this handler. |
| * Do so by checking each of the handler's filters. |
| * Return false if any of the filters fail, |
| * true if the handler wants this event. |
| * Anyone modifying this function should check |
| * eventFilterRestricted_passesUnloadFilter and |
| * eventFilter_predictFiltering as well. |
| * |
| * If shouldDelete is returned true, a count filter has expired |
| * and the corresponding node should be deleted. |
| */ |
| jboolean |
| eventFilterRestricted_passesFilter(JNIEnv *env, |
| char *classname, |
| EventInfo *evinfo, |
| HandlerNode *node, |
| jboolean *shouldDelete) |
| { |
| jthread thread; |
| jclass clazz; |
| jmethodID method; |
| Filter *filter = FILTERS_ARRAY(node); |
| int i; |
| |
| *shouldDelete = JNI_FALSE; |
| thread = evinfo->thread; |
| clazz = evinfo->clazz; |
| method = evinfo->method; |
| |
| /* |
| * Suppress most events if they happen in debug threads |
| */ |
| if ((evinfo->ei != EI_CLASS_PREPARE) && |
| (evinfo->ei != EI_GC_FINISH) && |
| (evinfo->ei != EI_CLASS_LOAD) && |
| threadControl_isDebugThread(thread)) { |
| return JNI_FALSE; |
| } |
| |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(ThreadOnly): |
| if (!isSameObject(env, thread, filter->u.ThreadOnly.thread)) { |
| return JNI_FALSE; |
| } |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(ClassOnly): |
| /* Class filters catch events in the specified |
| * class and any subclass/subinterface. |
| */ |
| if (!JNI_FUNC_PTR(env,IsAssignableFrom)(env, clazz, |
| filter->u.ClassOnly.clazz)) { |
| return JNI_FALSE; |
| } |
| break; |
| |
| /* This is kinda cheating assumming the event |
| * fields will be in the same locations, but it is |
| * true now. |
| */ |
| case JDWP_REQUEST_MODIFIER(LocationOnly): |
| if (evinfo->method != |
| filter->u.LocationOnly.method || |
| evinfo->location != |
| filter->u.LocationOnly.location || |
| !isSameObject(env, clazz, filter->u.LocationOnly.clazz)) { |
| return JNI_FALSE; |
| } |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(FieldOnly): |
| /* Field watchpoints can be triggered from the |
| * declared class or any subclass/subinterface. |
| */ |
| if ((evinfo->u.field_access.field != |
| filter->u.FieldOnly.field) || |
| !isSameObject(env, evinfo->u.field_access.field_clazz, |
| filter->u.FieldOnly.clazz)) { |
| return JNI_FALSE; |
| } |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(ExceptionOnly): |
| /* do we want caught/uncaught exceptions */ |
| if (!((evinfo->u.exception.catch_clazz == NULL)? |
| filter->u.ExceptionOnly.uncaught : |
| filter->u.ExceptionOnly.caught)) { |
| return JNI_FALSE; |
| } |
| |
| /* do we care about exception class */ |
| if (filter->u.ExceptionOnly.exception != NULL) { |
| jclass exception = evinfo->object; |
| |
| /* do we want this exception class */ |
| if (!JNI_FUNC_PTR(env,IsInstanceOf)(env, exception, |
| filter->u.ExceptionOnly.exception)) { |
| return JNI_FALSE; |
| } |
| } |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(InstanceOnly): { |
| jobject eventInst = eventInstance(evinfo); |
| jobject filterInst = filter->u.InstanceOnly.instance; |
| /* if no error and doesn't match, don't pass |
| * filter |
| */ |
| if (eventInst != NULL && |
| !isSameObject(env, eventInst, filterInst)) { |
| return JNI_FALSE; |
| } |
| break; |
| } |
| case JDWP_REQUEST_MODIFIER(Count): { |
| JDI_ASSERT(filter->u.Count.count > 0); |
| if (--filter->u.Count.count > 0) { |
| return JNI_FALSE; |
| } |
| *shouldDelete = JNI_TRUE; |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(Conditional): |
| /*** |
| if (... filter->u.Conditional.exprID ...) { |
| return JNI_FALSE; |
| } |
| ***/ |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(ClassMatch): { |
| if (!patternStringMatch(classname, |
| filter->u.ClassMatch.classPattern)) { |
| return JNI_FALSE; |
| } |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(ClassExclude): { |
| if (patternStringMatch(classname, |
| filter->u.ClassExclude.classPattern)) { |
| return JNI_FALSE; |
| } |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(Step): |
| if (!isSameObject(env, thread, filter->u.Step.thread)) { |
| return JNI_FALSE; |
| } |
| if (!stepControl_handleStep(env, thread, clazz, method)) { |
| return JNI_FALSE; |
| } |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(SourceNameMatch): { |
| char* desiredNamePattern = filter->u.SourceNameOnly.sourceNamePattern; |
| if (!searchAllSourceNames(env, clazz, |
| desiredNamePattern) == 1) { |
| /* The name isn't in the SDE; try the sourceName in the ref |
| * type |
| */ |
| char *sourceName = 0; |
| jvmtiError error = JVMTI_FUNC_PTR(gdata->jvmti,GetSourceFileName) |
| (gdata->jvmti, clazz, &sourceName); |
| if (error == JVMTI_ERROR_NONE && |
| sourceName != 0 && |
| patternStringMatch(sourceName, desiredNamePattern)) { |
| // got a hit - report the event |
| jvmtiDeallocate(sourceName); |
| break; |
| } |
| // We have no match, we have no source file name, |
| // or we got a JVM TI error. Don't report the event. |
| jvmtiDeallocate(sourceName); |
| return JNI_FALSE; |
| } |
| break; |
| } |
| |
| default: |
| EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"Invalid filter modifier"); |
| return JNI_FALSE; |
| } |
| } |
| return JNI_TRUE; |
| } |
| |
| /* Determine if this event is interesting to this handler. Do so |
| * by checking each of the handler's filters. Return false if any |
| * of the filters fail, true if the handler wants this event. |
| * Special version of filter for unloads since they don't have an |
| * event structure or a jclass. |
| * |
| * If shouldDelete is returned true, a count filter has expired |
| * and the corresponding node should be deleted. |
| */ |
| jboolean |
| eventFilterRestricted_passesUnloadFilter(JNIEnv *env, |
| char *classname, |
| HandlerNode *node, |
| jboolean *shouldDelete) |
| { |
| Filter *filter = FILTERS_ARRAY(node); |
| int i; |
| |
| *shouldDelete = JNI_FALSE; |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| |
| case JDWP_REQUEST_MODIFIER(Count): { |
| JDI_ASSERT(filter->u.Count.count > 0); |
| if (--filter->u.Count.count > 0) { |
| return JNI_FALSE; |
| } |
| *shouldDelete = JNI_TRUE; |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(ClassMatch): { |
| if (!patternStringMatch(classname, |
| filter->u.ClassMatch.classPattern)) { |
| return JNI_FALSE; |
| } |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(ClassExclude): { |
| if (patternStringMatch(classname, |
| filter->u.ClassExclude.classPattern)) { |
| return JNI_FALSE; |
| } |
| break; |
| } |
| |
| default: |
| EXIT_ERROR(AGENT_ERROR_ILLEGAL_ARGUMENT,"Invalid filter modifier"); |
| return JNI_FALSE; |
| } |
| } |
| return JNI_TRUE; |
| } |
| |
| /** |
| * This function returns true only if it is certain that |
| * all events for the given node in the given stack frame will |
| * be filtered. It is used to optimize stepping. (If this |
| * function returns true the stepping algorithm does not |
| * have to step through every instruction in this stack frame; |
| * instead, it can use more efficient method entry/exit |
| * events. |
| */ |
| jboolean |
| eventFilter_predictFiltering(HandlerNode *node, jclass clazz, char *classname) |
| { |
| JNIEnv *env; |
| jboolean willBeFiltered; |
| Filter *filter; |
| jboolean done; |
| int count; |
| int i; |
| |
| willBeFiltered = JNI_FALSE; |
| env = NULL; |
| filter = FILTERS_ARRAY(node); |
| count = FILTER_COUNT(node); |
| done = JNI_FALSE; |
| |
| for (i = 0; (i < count) && (!done); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(ClassOnly): |
| if ( env==NULL ) { |
| env = getEnv(); |
| } |
| if (!JNI_FUNC_PTR(env,IsAssignableFrom)(env, clazz, |
| filter->u.ClassOnly.clazz)) { |
| willBeFiltered = JNI_TRUE; |
| done = JNI_TRUE; |
| } |
| break; |
| |
| case JDWP_REQUEST_MODIFIER(Count): { |
| /* |
| * If preceding filters have determined that events will |
| * be filtered out, that is fine and we won't get here. |
| * However, the count must be decremented - even if |
| * subsequent filters will filter these events. We |
| * thus must end now unable to predict |
| */ |
| done = JNI_TRUE; |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(ClassMatch): { |
| if (!patternStringMatch(classname, |
| filter->u.ClassMatch.classPattern)) { |
| willBeFiltered = JNI_TRUE; |
| done = JNI_TRUE; |
| } |
| break; |
| } |
| |
| case JDWP_REQUEST_MODIFIER(ClassExclude): { |
| if (patternStringMatch(classname, |
| filter->u.ClassExclude.classPattern)) { |
| willBeFiltered = JNI_TRUE; |
| done = JNI_TRUE; |
| } |
| break; |
| } |
| } |
| } |
| |
| return willBeFiltered; |
| } |
| |
| /** |
| * Determine if the given breakpoint node is in the specified class. |
| */ |
| jboolean |
| eventFilterRestricted_isBreakpointInClass(JNIEnv *env, jclass clazz, |
| HandlerNode *node) |
| { |
| Filter *filter = FILTERS_ARRAY(node); |
| int i; |
| |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(LocationOnly): |
| return isSameObject(env, clazz, filter->u.LocationOnly.clazz); |
| } |
| } |
| return JNI_TRUE; /* should never come here */ |
| } |
| |
| /***** filter set-up *****/ |
| |
| jvmtiError |
| eventFilter_setConditionalFilter(HandlerNode *node, jint index, |
| jint exprID) |
| { |
| ConditionalFilter *filter = &FILTER(node, index).u.Conditional; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(Conditional); |
| filter->exprID = exprID; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setCountFilter(HandlerNode *node, jint index, |
| jint count) |
| { |
| CountFilter *filter = &FILTER(node, index).u.Count; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if (count <= 0) { |
| return JDWP_ERROR(INVALID_COUNT); |
| } else { |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(Count); |
| filter->count = count; |
| return JVMTI_ERROR_NONE; |
| } |
| } |
| |
| jvmtiError |
| eventFilter_setThreadOnlyFilter(HandlerNode *node, jint index, |
| jthread thread) |
| { |
| JNIEnv *env = getEnv(); |
| ThreadFilter *filter = &FILTER(node, index).u.ThreadOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if (NODE_EI(node) == EI_GC_FINISH) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| /* Create a thread ref that will live beyond */ |
| /* the end of this call */ |
| saveGlobalRef(env, thread, &(filter->thread)); |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(ThreadOnly); |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setLocationOnlyFilter(HandlerNode *node, jint index, |
| jclass clazz, jmethodID method, |
| jlocation location) |
| { |
| JNIEnv *env = getEnv(); |
| LocationFilter *filter = &FILTER(node, index).u.LocationOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if ((NODE_EI(node) != EI_BREAKPOINT) && |
| (NODE_EI(node) != EI_FIELD_ACCESS) && |
| (NODE_EI(node) != EI_FIELD_MODIFICATION) && |
| (NODE_EI(node) != EI_SINGLE_STEP) && |
| (NODE_EI(node) != EI_EXCEPTION)) { |
| |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| /* Create a class ref that will live beyond */ |
| /* the end of this call */ |
| saveGlobalRef(env, clazz, &(filter->clazz)); |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(LocationOnly); |
| filter->method = method; |
| filter->location = location; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setFieldOnlyFilter(HandlerNode *node, jint index, |
| jclass clazz, jfieldID field) |
| { |
| JNIEnv *env = getEnv(); |
| FieldFilter *filter = &FILTER(node, index).u.FieldOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if ((NODE_EI(node) != EI_FIELD_ACCESS) && |
| (NODE_EI(node) != EI_FIELD_MODIFICATION)) { |
| |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| /* Create a class ref that will live beyond */ |
| /* the end of this call */ |
| saveGlobalRef(env, clazz, &(filter->clazz)); |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(FieldOnly); |
| filter->field = field; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setClassOnlyFilter(HandlerNode *node, jint index, |
| jclass clazz) |
| { |
| JNIEnv *env = getEnv(); |
| ClassFilter *filter = &FILTER(node, index).u.ClassOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if ( |
| (NODE_EI(node) == EI_GC_FINISH) || |
| (NODE_EI(node) == EI_THREAD_START) || |
| (NODE_EI(node) == EI_THREAD_END)) { |
| |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| /* Create a class ref that will live beyond */ |
| /* the end of this call */ |
| saveGlobalRef(env, clazz, &(filter->clazz)); |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(ClassOnly); |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setExceptionOnlyFilter(HandlerNode *node, jint index, |
| jclass exceptionClass, |
| jboolean caught, |
| jboolean uncaught) |
| { |
| JNIEnv *env = getEnv(); |
| ExceptionFilter *filter = &FILTER(node, index).u.ExceptionOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if (NODE_EI(node) != EI_EXCEPTION) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| filter->exception = NULL; |
| if (exceptionClass != NULL) { |
| /* Create a class ref that will live beyond */ |
| /* the end of this call */ |
| saveGlobalRef(env, exceptionClass, &(filter->exception)); |
| } |
| FILTER(node, index).modifier = |
| JDWP_REQUEST_MODIFIER(ExceptionOnly); |
| filter->caught = caught; |
| filter->uncaught = uncaught; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setInstanceOnlyFilter(HandlerNode *node, jint index, |
| jobject instance) |
| { |
| JNIEnv *env = getEnv(); |
| InstanceFilter *filter = &FILTER(node, index).u.InstanceOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| filter->instance = NULL; |
| if (instance != NULL) { |
| /* Create an object ref that will live beyond |
| * the end of this call |
| */ |
| saveGlobalRef(env, instance, &(filter->instance)); |
| } |
| FILTER(node, index).modifier = |
| JDWP_REQUEST_MODIFIER(InstanceOnly); |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setClassMatchFilter(HandlerNode *node, jint index, |
| char *classPattern) |
| { |
| MatchFilter *filter = &FILTER(node, index).u.ClassMatch; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if ( |
| (NODE_EI(node) == EI_THREAD_START) || |
| (NODE_EI(node) == EI_THREAD_END)) { |
| |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| FILTER(node, index).modifier = |
| JDWP_REQUEST_MODIFIER(ClassMatch); |
| filter->classPattern = classPattern; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setClassExcludeFilter(HandlerNode *node, jint index, |
| char *classPattern) |
| { |
| MatchFilter *filter = &FILTER(node, index).u.ClassExclude; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if ( |
| (NODE_EI(node) == EI_THREAD_START) || |
| (NODE_EI(node) == EI_THREAD_END)) { |
| |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| FILTER(node, index).modifier = |
| JDWP_REQUEST_MODIFIER(ClassExclude); |
| filter->classPattern = classPattern; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| jvmtiError |
| eventFilter_setStepFilter(HandlerNode *node, jint index, |
| jthread thread, jint size, jint depth) |
| { |
| jvmtiError error; |
| JNIEnv *env = getEnv(); |
| StepFilter *filter = &FILTER(node, index).u.Step; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if (NODE_EI(node) != EI_SINGLE_STEP) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| /* Create a thread ref that will live beyond */ |
| /* the end of this call */ |
| saveGlobalRef(env, thread, &(filter->thread)); |
| error = stepControl_beginStep(env, filter->thread, size, depth, node); |
| if (error != JVMTI_ERROR_NONE) { |
| tossGlobalRef(env, &(filter->thread)); |
| return error; |
| } |
| FILTER(node, index).modifier = JDWP_REQUEST_MODIFIER(Step); |
| filter->depth = depth; |
| filter->size = size; |
| return JVMTI_ERROR_NONE; |
| } |
| |
| |
| jvmtiError |
| eventFilter_setSourceNameMatchFilter(HandlerNode *node, |
| jint index, |
| char *sourceNamePattern) { |
| SourceNameFilter *filter = &FILTER(node, index).u.SourceNameOnly; |
| if (index >= FILTER_COUNT(node)) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| if (NODE_EI(node) != EI_CLASS_PREPARE) { |
| return AGENT_ERROR_ILLEGAL_ARGUMENT; |
| } |
| |
| FILTER(node, index).modifier = |
| JDWP_REQUEST_MODIFIER(SourceNameMatch); |
| filter->sourceNamePattern = sourceNamePattern; |
| return JVMTI_ERROR_NONE; |
| |
| } |
| |
| /***** JVMTI event enabling / disabling *****/ |
| |
| /** |
| * Return the Filter that is of the specified type (modifier). |
| * Return NULL if not found. |
| */ |
| static Filter * |
| findFilter(HandlerNode *node, jint modifier) |
| { |
| int i; |
| Filter *filter; |
| for (i = 0, filter = FILTERS_ARRAY(node); |
| i <FILTER_COUNT(node); |
| i++, filter++) { |
| if (filter->modifier == modifier) { |
| return filter; |
| } |
| } |
| return NULL; |
| } |
| |
| /** |
| * Determine if the specified breakpoint node is in the |
| * same location as the LocationFilter passed in arg. |
| * |
| * This is a match function called by a |
| * eventHandlerRestricted_iterator invokation. |
| */ |
| static jboolean |
| matchBreakpoint(JNIEnv *env, HandlerNode *node, void *arg) |
| { |
| LocationFilter *goal = (LocationFilter *)arg; |
| Filter *filter = FILTERS_ARRAY(node); |
| int i; |
| |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(LocationOnly): { |
| LocationFilter *trial = &(filter->u.LocationOnly); |
| if (trial->method == goal->method && |
| trial->location == goal->location && |
| isSameObject(env, trial->clazz, goal->clazz)) { |
| return JNI_TRUE; |
| } |
| } |
| } |
| } |
| return JNI_FALSE; |
| } |
| |
| /** |
| * Set a breakpoint if this is the first one at this location. |
| */ |
| static jvmtiError |
| setBreakpoint(HandlerNode *node) |
| { |
| jvmtiError error = JVMTI_ERROR_NONE; |
| Filter *filter; |
| |
| filter = findFilter(node, JDWP_REQUEST_MODIFIER(LocationOnly)); |
| if (filter == NULL) { |
| /* bp event with no location filter */ |
| error = AGENT_ERROR_INTERNAL; |
| } else { |
| LocationFilter *lf = &(filter->u.LocationOnly); |
| |
| /* if this is the first handler for this |
| * location, set bp at JVMTI level |
| */ |
| if (!eventHandlerRestricted_iterator( |
| EI_BREAKPOINT, matchBreakpoint, lf)) { |
| LOG_LOC(("SetBreakpoint at location: method=%p,location=%d", |
| lf->method, (int)lf->location)); |
| error = JVMTI_FUNC_PTR(gdata->jvmti,SetBreakpoint) |
| (gdata->jvmti, lf->method, lf->location); |
| } |
| } |
| return error; |
| } |
| |
| /** |
| * Clear a breakpoint if this is the last one at this location. |
| */ |
| static jvmtiError |
| clearBreakpoint(HandlerNode *node) |
| { |
| jvmtiError error = JVMTI_ERROR_NONE; |
| Filter *filter; |
| |
| filter = findFilter(node, JDWP_REQUEST_MODIFIER(LocationOnly)); |
| if (filter == NULL) { |
| /* bp event with no location filter */ |
| error = AGENT_ERROR_INTERNAL; |
| } else { |
| LocationFilter *lf = &(filter->u.LocationOnly); |
| |
| /* if this is the last handler for this |
| * location, clear bp at JVMTI level |
| */ |
| if (!eventHandlerRestricted_iterator( |
| EI_BREAKPOINT, matchBreakpoint, lf)) { |
| LOG_LOC(("ClearBreakpoint at location: method=%p,location=%d", |
| lf->method, (int)lf->location)); |
| error = JVMTI_FUNC_PTR(gdata->jvmti,ClearBreakpoint) |
| (gdata->jvmti, lf->method, lf->location); |
| } |
| } |
| return error; |
| } |
| |
| /** |
| * Return true if a breakpoint is set at the specified location. |
| */ |
| jboolean |
| isBreakpointSet(jclass clazz, jmethodID method, jlocation location) |
| { |
| LocationFilter lf; |
| |
| lf.clazz = clazz; |
| lf.method = method; |
| lf.location = location; |
| |
| return eventHandlerRestricted_iterator(EI_BREAKPOINT, |
| matchBreakpoint, &lf); |
| } |
| |
| /** |
| * Determine if the specified watchpoint node has the |
| * same field as the FieldFilter passed in arg. |
| * |
| * This is a match function called by a |
| * eventHandlerRestricted_iterator invokation. |
| */ |
| static jboolean |
| matchWatchpoint(JNIEnv *env, HandlerNode *node, void *arg) |
| { |
| FieldFilter *goal = (FieldFilter *)arg; |
| Filter *filter = FILTERS_ARRAY(node); |
| int i; |
| |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(FieldOnly): { |
| FieldFilter *trial = &(filter->u.FieldOnly); |
| if (trial->field == goal->field && |
| isSameObject(env, trial->clazz, goal->clazz)) { |
| return JNI_TRUE; |
| } |
| } |
| } |
| } |
| return JNI_FALSE; |
| } |
| |
| /** |
| * Set a watchpoint if this is the first one on this field. |
| */ |
| static jvmtiError |
| setWatchpoint(HandlerNode *node) |
| { |
| jvmtiError error = JVMTI_ERROR_NONE; |
| Filter *filter; |
| |
| filter = findFilter(node, JDWP_REQUEST_MODIFIER(FieldOnly)); |
| if (filter == NULL) { |
| /* event with no field filter */ |
| error = AGENT_ERROR_INTERNAL; |
| } else { |
| FieldFilter *ff = &(filter->u.FieldOnly); |
| |
| /* if this is the first handler for this |
| * field, set wp at JVMTI level |
| */ |
| if (!eventHandlerRestricted_iterator( |
| NODE_EI(node), matchWatchpoint, ff)) { |
| error = (NODE_EI(node) == EI_FIELD_ACCESS) ? |
| JVMTI_FUNC_PTR(gdata->jvmti,SetFieldAccessWatch) |
| (gdata->jvmti, ff->clazz, ff->field) : |
| JVMTI_FUNC_PTR(gdata->jvmti,SetFieldModificationWatch) |
| (gdata->jvmti, ff->clazz, ff->field); |
| } |
| } |
| return error; |
| } |
| |
| /** |
| * Clear a watchpoint if this is the last one on this field. |
| */ |
| static jvmtiError |
| clearWatchpoint(HandlerNode *node) |
| { |
| jvmtiError error = JVMTI_ERROR_NONE; |
| Filter *filter; |
| |
| filter = findFilter(node, JDWP_REQUEST_MODIFIER(FieldOnly)); |
| if (filter == NULL) { |
| /* event with no field filter */ |
| error = AGENT_ERROR_INTERNAL; |
| } else { |
| FieldFilter *ff = &(filter->u.FieldOnly); |
| |
| /* if this is the last handler for this |
| * field, clear wp at JVMTI level |
| */ |
| if (!eventHandlerRestricted_iterator( |
| NODE_EI(node), matchWatchpoint, ff)) { |
| error = (NODE_EI(node) == EI_FIELD_ACCESS) ? |
| JVMTI_FUNC_PTR(gdata->jvmti,ClearFieldAccessWatch) |
| (gdata->jvmti, ff->clazz, ff->field) : |
| JVMTI_FUNC_PTR(gdata->jvmti,ClearFieldModificationWatch) |
| (gdata->jvmti, ff->clazz, ff->field); |
| } |
| } |
| return error; |
| } |
| |
| /** |
| * Determine the thread this node is filtered on. |
| * NULL if not thread filtered. |
| */ |
| static jthread |
| requestThread(HandlerNode *node) |
| { |
| int i; |
| Filter *filter = FILTERS_ARRAY(node); |
| |
| for (i = 0; i < FILTER_COUNT(node); ++i, ++filter) { |
| switch (filter->modifier) { |
| case JDWP_REQUEST_MODIFIER(ThreadOnly): |
| return filter->u.ThreadOnly.thread; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| /** |
| * Determine if the specified node has a |
| * thread filter with the thread passed in arg. |
| * |
| * This is a match function called by a |
| * eventHandlerRestricted_iterator invokation. |
| */ |
| static jboolean |
| matchThread(JNIEnv *env, HandlerNode *node, void *arg) |
| { |
| jthread goalThread = (jthread)arg; |
| jthread reqThread = requestThread(node); |
| |
| /* If the event's thread and the passed thread are the same |
| * (or both are NULL), we have a match. |
| */ |
| return isSameObject(env, reqThread, goalThread); |
| } |
| |
| /** |
| * Do any enabling of events (including setting breakpoints etc) |
| * needed to get the events requested by this handler node. |
| */ |
| static jvmtiError |
| enableEvents(HandlerNode *node) |
| { |
| jvmtiError error = JVMTI_ERROR_NONE; |
| |
| switch (NODE_EI(node)) { |
| /* The stepping code directly enables/disables stepping as |
| * necessary |
| */ |
| case EI_SINGLE_STEP: |
| /* Internal thread event handlers are always present |
| * (hardwired in the event hook), so we don't change the |
| * notification mode here. |
| */ |
| case EI_THREAD_START: |
| case EI_THREAD_END: |
| case EI_VM_INIT: |
| case EI_VM_DEATH: |
| case EI_CLASS_PREPARE: |
| case EI_GC_FINISH: |
| return error; |
| |
| case EI_FIELD_ACCESS: |
| case EI_FIELD_MODIFICATION: |
| error = setWatchpoint(node); |
| break; |
| |
| case EI_BREAKPOINT: |
| error = setBreakpoint(node); |
| break; |
| |
| default: |
| break; |
| } |
| |
| /* Don't globally enable if the above failed */ |
| if (error == JVMTI_ERROR_NONE) { |
| jthread thread = requestThread(node); |
| |
| /* If this is the first request of it's kind on this |
| * thread (or all threads (thread == NULL)) then enable |
| * these events on this thread. |
| */ |
| if (!eventHandlerRestricted_iterator( |
| NODE_EI(node), matchThread, thread)) { |
| error = threadControl_setEventMode(JVMTI_ENABLE, |
| NODE_EI(node), thread); |
| } |
| } |
| return error; |
| } |
| |
| /** |
| * Do any disabling of events (including clearing breakpoints etc) |
| * needed to no longer get the events requested by this handler node. |
| */ |
| static jvmtiError |
| disableEvents(HandlerNode *node) |
| { |
| jvmtiError error = JVMTI_ERROR_NONE; |
| jvmtiError error2 = JVMTI_ERROR_NONE; |
| jthread thread; |
| |
| |
| switch (NODE_EI(node)) { |
| /* The stepping code directly enables/disables stepping as |
| * necessary |
| */ |
| case EI_SINGLE_STEP: |
| /* Internal thread event handlers are always present |
| * (hardwired in the event hook), so we don't change the |
| * notification mode here. |
| */ |
| case EI_THREAD_START: |
| case EI_THREAD_END: |
| case EI_VM_INIT: |
| case EI_VM_DEATH: |
| case EI_CLASS_PREPARE: |
| case EI_GC_FINISH: |
| return error; |
| |
| case EI_FIELD_ACCESS: |
| case EI_FIELD_MODIFICATION: |
| error = clearWatchpoint(node); |
| break; |
| |
| case EI_BREAKPOINT: |
| error = clearBreakpoint(node); |
| break; |
| |
| default: |
| break; |
| } |
| |
| thread = requestThread(node); |
| |
| /* If this is the last request of it's kind on this thread |
| * (or all threads (thread == NULL)) then disable these |
| * events on this thread. |
| * |
| * Disable even if the above caused an error |
| */ |
| if (!eventHandlerRestricted_iterator(NODE_EI(node), matchThread, thread)) { |
| error2 = threadControl_setEventMode(JVMTI_DISABLE, |
| NODE_EI(node), thread); |
| } |
| return error != JVMTI_ERROR_NONE? error : error2; |
| } |
| |
| |
| /***** filter (and event) installation and deinstallation *****/ |
| |
| /** |
| * Make the set of event filters that correspond with this |
| * node active (including enabling the corresponding events). |
| */ |
| jvmtiError |
| eventFilterRestricted_install(HandlerNode *node) |
| { |
| return enableEvents(node); |
| } |
| |
| /** |
| * Make the set of event filters that correspond with this |
| * node inactive (including disabling the corresponding events |
| * and freeing resources). |
| */ |
| jvmtiError |
| eventFilterRestricted_deinstall(HandlerNode *node) |
| { |
| jvmtiError error1, error2; |
| |
| error1 = disableEvents(node); |
| error2 = clearFilters(node); |
| |
| return error1 != JVMTI_ERROR_NONE? error1 : error2; |
| } |
