/* * Copyright (c) 2004, 2015, Oracle and/or its affiliates. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * - Neither the name of Oracle nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This source code is provided to illustrate the usage of a given feature * or technique and has been deliberately simplified. Additional steps * required for a production-quality application, such as security checks, * input validation and proper error handling, might not be present in * this sample code. */ #include "stdlib.h" #include "mtrace.h" #include "java_crw_demo.h" /* ------------------------------------------------------------------- */ /* Some constant maximum sizes */ #define MAX_TOKEN_LENGTH 16 #define MAX_THREAD_NAME_LENGTH 512 #define MAX_METHOD_NAME_LENGTH 1024 /* Some constant names that tie to Java class/method names. * We assume the Java class whose static methods we will be calling * looks like: * * public class Mtrace { * private static int engaged; * private static native void _method_entry(Object thr, int cnum, int mnum); * public static void method_entry(int cnum, int mnum) * { * if ( engaged != 0 ) { * _method_entry(Thread.currentThread(), cnum, mnum); * } * } * private static native void _method_exit(Object thr, int cnum, int mnum); * public static void method_exit(int cnum, int mnum) * { * if ( engaged != 0 ) { * _method_exit(Thread.currentThread(), cnum, mnum); * } * } * } * * The engaged field allows us to inject all classes (even system classes) * and delay the actual calls to the native code until the VM has reached * a safe time to call native methods (Past the JVMTI VM_START event). * */ #define MTRACE_class Mtrace /* Name of class we are using */ #define MTRACE_entry method_entry /* Name of java entry method */ #define MTRACE_exit method_exit /* Name of java exit method */ #define MTRACE_native_entry _method_entry /* Name of java entry native */ #define MTRACE_native_exit _method_exit /* Name of java exit native */ #define MTRACE_engaged engaged /* Name of java static field */ /* C macros to create strings from tokens */ #define _STRING(s) #s #define STRING(s) _STRING(s) /* ------------------------------------------------------------------- */ /* Data structure to hold method and class information in agent */ typedef struct MethodInfo { const char *name; /* Method name */ const char *signature; /* Method signature */ int calls; /* Method call count */ int returns; /* Method return count */ } MethodInfo; typedef struct ClassInfo { const char *name; /* Class name */ int mcount; /* Method count */ MethodInfo *methods; /* Method information */ int calls; /* Method call count for this class */ } ClassInfo; /* Global agent data structure */ typedef struct { /* JVMTI Environment */ jvmtiEnv *jvmti; jboolean vm_is_dead; jboolean vm_is_started; /* Data access Lock */ jrawMonitorID lock; /* Options */ char *include; char *exclude; int max_count; /* ClassInfo Table */ ClassInfo *classes; jint ccount; } GlobalAgentData; static GlobalAgentData *gdata; /* Enter a critical section by doing a JVMTI Raw Monitor Enter */ static void enter_critical_section(jvmtiEnv *jvmti) { jvmtiError error; error = (*jvmti)->RawMonitorEnter(jvmti, gdata->lock); check_jvmti_error(jvmti, error, "Cannot enter with raw monitor"); } /* Exit a critical section by doing a JVMTI Raw Monitor Exit */ static void exit_critical_section(jvmtiEnv *jvmti) { jvmtiError error; error = (*jvmti)->RawMonitorExit(jvmti, gdata->lock); check_jvmti_error(jvmti, error, "Cannot exit with raw monitor"); } /* Get a name for a jthread */ static void get_thread_name(jvmtiEnv *jvmti, jthread thread, char *tname, int maxlen) { jvmtiThreadInfo info; jvmtiError error; /* Make sure the stack variables are garbage free */ (void)memset(&info,0, sizeof(info)); /* Assume the name is unknown for now */ (void)strcpy(tname, "Unknown"); /* Get the thread information, which includes the name */ error = (*jvmti)->GetThreadInfo(jvmti, thread, &info); check_jvmti_error(jvmti, error, "Cannot get thread info"); /* The thread might not have a name, be careful here. */ if ( info.name != NULL ) { int len; /* Copy the thread name into tname if it will fit */ len = (int)strlen(info.name); if ( len < maxlen ) { (void)strcpy(tname, info.name); } /* Every string allocated by JVMTI needs to be freed */ deallocate(jvmti, (void*)info.name); } } /* Qsort class compare routine */ static int class_compar(const void *e1, const void *e2) { ClassInfo *c1 = (ClassInfo*)e1; ClassInfo *c2 = (ClassInfo*)e2; if ( c1->calls > c2->calls ) return 1; if ( c1->calls < c2->calls ) return -1; return 0; } /* Qsort method compare routine */ static int method_compar(const void *e1, const void *e2) { MethodInfo *m1 = (MethodInfo*)e1; MethodInfo *m2 = (MethodInfo*)e2; if ( m1->calls > m2->calls ) return 1; if ( m1->calls < m2->calls ) return -1; return 0; } /* Callback from java_crw_demo() that gives us mnum mappings */ static void mnum_callbacks(unsigned cnum, const char **names, const char**sigs, int mcount) { ClassInfo *cp; int mnum; if ( cnum >= (unsigned)gdata->ccount ) { fatal_error("ERROR: Class number out of range\n"); } if ( mcount == 0 ) { return; } cp = gdata->classes + (int)cnum; cp->calls = 0; cp->mcount = mcount; cp->methods = (MethodInfo*)calloc(mcount, sizeof(MethodInfo)); if ( cp->methods == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } for ( mnum = 0 ; mnum < mcount ; mnum++ ) { MethodInfo *mp; mp = cp->methods + mnum; mp->name = (const char *)strdup(names[mnum]); if ( mp->name == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } mp->signature = (const char *)strdup(sigs[mnum]); if ( mp->signature == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } } } /* Java Native Method for entry */ static void MTRACE_native_entry(JNIEnv *env, jclass klass, jobject thread, jint cnum, jint mnum) { enter_critical_section(gdata->jvmti); { /* It's possible we get here right after VmDeath event, be careful */ if ( !gdata->vm_is_dead ) { ClassInfo *cp; MethodInfo *mp; if ( cnum >= gdata->ccount ) { fatal_error("ERROR: Class number out of range\n"); } cp = gdata->classes + cnum; if ( mnum >= cp->mcount ) { fatal_error("ERROR: Method number out of range\n"); } mp = cp->methods + mnum; if ( interested((char*)cp->name, (char*)mp->name, gdata->include, gdata->exclude) ) { mp->calls++; cp->calls++; } } } exit_critical_section(gdata->jvmti); } /* Java Native Method for exit */ static void MTRACE_native_exit(JNIEnv *env, jclass klass, jobject thread, jint cnum, jint mnum) { enter_critical_section(gdata->jvmti); { /* It's possible we get here right after VmDeath event, be careful */ if ( !gdata->vm_is_dead ) { ClassInfo *cp; MethodInfo *mp; if ( cnum >= gdata->ccount ) { fatal_error("ERROR: Class number out of range\n"); } cp = gdata->classes + cnum; if ( mnum >= cp->mcount ) { fatal_error("ERROR: Method number out of range\n"); } mp = cp->methods + mnum; if ( interested((char*)cp->name, (char*)mp->name, gdata->include, gdata->exclude) ) { mp->returns++; } } } exit_critical_section(gdata->jvmti); } /* Callback for JVMTI_EVENT_VM_START */ static void JNICALL cbVMStart(jvmtiEnv *jvmti, JNIEnv *env) { enter_critical_section(jvmti); { jclass klass; jfieldID field; int rc; /* Java Native Methods for class */ static JNINativeMethod registry[2] = { {STRING(MTRACE_native_entry), "(Ljava/lang/Object;II)V", (void*)&MTRACE_native_entry}, {STRING(MTRACE_native_exit), "(Ljava/lang/Object;II)V", (void*)&MTRACE_native_exit} }; /* The VM has started. */ stdout_message("VMStart\n"); /* Register Natives for class whose methods we use */ klass = (*env)->FindClass(env, STRING(MTRACE_class)); if ( klass == NULL ) { fatal_error("ERROR: JNI: Cannot find %s with FindClass\n", STRING(MTRACE_class)); } rc = (*env)->RegisterNatives(env, klass, registry, 2); if ( rc != 0 ) { fatal_error("ERROR: JNI: Cannot register native methods for %s\n", STRING(MTRACE_class)); } /* Engage calls. */ field = (*env)->GetStaticFieldID(env, klass, STRING(MTRACE_engaged), "I"); if ( field == NULL ) { fatal_error("ERROR: JNI: Cannot get field from %s\n", STRING(MTRACE_class)); } (*env)->SetStaticIntField(env, klass, field, 1); /* Indicate VM has started */ gdata->vm_is_started = JNI_TRUE; } exit_critical_section(jvmti); } /* Callback for JVMTI_EVENT_VM_INIT */ static void JNICALL cbVMInit(jvmtiEnv *jvmti, JNIEnv *env, jthread thread) { enter_critical_section(jvmti); { char tname[MAX_THREAD_NAME_LENGTH]; static jvmtiEvent events[] = { JVMTI_EVENT_THREAD_START, JVMTI_EVENT_THREAD_END }; int i; /* The VM has started. */ get_thread_name(jvmti, thread, tname, sizeof(tname)); stdout_message("VMInit %s\n", tname); /* The VM is now initialized, at this time we make our requests * for additional events. */ for( i=0; i < (int)(sizeof(events)/sizeof(jvmtiEvent)); i++) { jvmtiError error; /* Setup event notification modes */ error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, events[i], (jthread)NULL); check_jvmti_error(jvmti, error, "Cannot set event notification"); } } exit_critical_section(jvmti); } /* Callback for JVMTI_EVENT_VM_DEATH */ static void JNICALL cbVMDeath(jvmtiEnv *jvmti, JNIEnv *env) { enter_critical_section(jvmti); { jclass klass; jfieldID field; /* The VM has died. */ stdout_message("VMDeath\n"); /* Disengage calls in MTRACE_class. */ klass = (*env)->FindClass(env, STRING(MTRACE_class)); if ( klass == NULL ) { fatal_error("ERROR: JNI: Cannot find %s with FindClass\n", STRING(MTRACE_class)); } field = (*env)->GetStaticFieldID(env, klass, STRING(MTRACE_engaged), "I"); if ( field == NULL ) { fatal_error("ERROR: JNI: Cannot get field from %s\n", STRING(MTRACE_class)); } (*env)->SetStaticIntField(env, klass, field, 0); /* The critical section here is important to hold back the VM death * until all other callbacks have completed. */ /* Since this critical section could be holding up other threads * in other event callbacks, we need to indicate that the VM is * dead so that the other callbacks can short circuit their work. * We don't expect any further events after VmDeath but we do need * to be careful that existing threads might be in our own agent * callback code. */ gdata->vm_is_dead = JNI_TRUE; /* Dump out stats */ stdout_message("Begin Class Stats\n"); if ( gdata->ccount > 0 ) { int cnum; /* Sort table (in place) by number of method calls into class. */ /* Note: Do not use this table after this qsort! */ qsort(gdata->classes, gdata->ccount, sizeof(ClassInfo), &class_compar); /* Dump out gdata->max_count most called classes */ for ( cnum=gdata->ccount-1 ; cnum >= 0 && cnum >= gdata->ccount - gdata->max_count; cnum-- ) { ClassInfo *cp; int mnum; cp = gdata->classes + cnum; stdout_message("Class %s %d calls\n", cp->name, cp->calls); if ( cp->calls==0 ) continue; /* Sort method table (in place) by number of method calls. */ /* Note: Do not use this table after this qsort! */ qsort(cp->methods, cp->mcount, sizeof(MethodInfo), &method_compar); for ( mnum=cp->mcount-1 ; mnum >= 0 ; mnum-- ) { MethodInfo *mp; mp = cp->methods + mnum; if ( mp->calls==0 ) continue; stdout_message("\tMethod %s %s %d calls %d returns\n", mp->name, mp->signature, mp->calls, mp->returns); } } } stdout_message("End Class Stats\n"); (void)fflush(stdout); } exit_critical_section(jvmti); } /* Callback for JVMTI_EVENT_THREAD_START */ static void JNICALL cbThreadStart(jvmtiEnv *jvmti, JNIEnv *env, jthread thread) { enter_critical_section(jvmti); { /* It's possible we get here right after VmDeath event, be careful */ if ( !gdata->vm_is_dead ) { char tname[MAX_THREAD_NAME_LENGTH]; get_thread_name(jvmti, thread, tname, sizeof(tname)); stdout_message("ThreadStart %s\n", tname); } } exit_critical_section(jvmti); } /* Callback for JVMTI_EVENT_THREAD_END */ static void JNICALL cbThreadEnd(jvmtiEnv *jvmti, JNIEnv *env, jthread thread) { enter_critical_section(jvmti); { /* It's possible we get here right after VmDeath event, be careful */ if ( !gdata->vm_is_dead ) { char tname[MAX_THREAD_NAME_LENGTH]; get_thread_name(jvmti, thread, tname, sizeof(tname)); stdout_message("ThreadEnd %s\n", tname); } } exit_critical_section(jvmti); } /* Callback for JVMTI_EVENT_CLASS_FILE_LOAD_HOOK */ static void JNICALL cbClassFileLoadHook(jvmtiEnv *jvmti, JNIEnv* env, jclass class_being_redefined, jobject loader, const char* name, jobject protection_domain, jint class_data_len, const unsigned char* class_data, jint* new_class_data_len, unsigned char** new_class_data) { enter_critical_section(jvmti); { /* It's possible we get here right after VmDeath event, be careful */ if ( !gdata->vm_is_dead ) { const char *classname; /* Name could be NULL */ if ( name == NULL ) { classname = java_crw_demo_classname(class_data, class_data_len, NULL); if ( classname == NULL ) { fatal_error("ERROR: No classname inside classfile\n"); } } else { classname = strdup(name); if ( classname == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } } *new_class_data_len = 0; *new_class_data = NULL; /* The tracker class itself? */ if ( interested((char*)classname, "", gdata->include, gdata->exclude) && strcmp(classname, STRING(MTRACE_class)) != 0 ) { jint cnum; int system_class; unsigned char *new_image; long new_length; ClassInfo *cp; /* Get unique number for every class file image loaded */ cnum = gdata->ccount++; /* Save away class information */ if ( gdata->classes == NULL ) { gdata->classes = (ClassInfo*)malloc( gdata->ccount*sizeof(ClassInfo)); } else { gdata->classes = (ClassInfo*) realloc((void*)gdata->classes, gdata->ccount*sizeof(ClassInfo)); } if ( gdata->classes == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } cp = gdata->classes + cnum; cp->name = (const char *)strdup(classname); if ( cp->name == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } cp->calls = 0; cp->mcount = 0; cp->methods = NULL; /* Is it a system class? If the class load is before VmStart * then we will consider it a system class that should * be treated carefully. (See java_crw_demo) */ system_class = 0; if ( !gdata->vm_is_started ) { system_class = 1; } new_image = NULL; new_length = 0; /* Call the class file reader/write demo code */ java_crw_demo(cnum, classname, class_data, class_data_len, system_class, STRING(MTRACE_class), "L" STRING(MTRACE_class) ";", STRING(MTRACE_entry), "(II)V", STRING(MTRACE_exit), "(II)V", NULL, NULL, NULL, NULL, &new_image, &new_length, NULL, &mnum_callbacks); /* If we got back a new class image, return it back as "the" * new class image. This must be JVMTI Allocate space. */ if ( new_length > 0 ) { unsigned char *jvmti_space; jvmti_space = (unsigned char *)allocate(jvmti, (jint)new_length); (void)memcpy((void*)jvmti_space, (void*)new_image, (int)new_length); *new_class_data_len = (jint)new_length; *new_class_data = jvmti_space; /* VM will deallocate */ } /* Always free up the space we get from java_crw_demo() */ if ( new_image != NULL ) { (void)free((void*)new_image); /* Free malloc() space with free() */ } } (void)free((void*)classname); } } exit_critical_section(jvmti); } /* Parse the options for this mtrace agent */ static void parse_agent_options(char *options) { char token[MAX_TOKEN_LENGTH]; char *next; gdata->max_count = 10; /* Default max=n */ /* Parse options and set flags in gdata */ if ( options==NULL ) { return; } /* Get the first token from the options string. */ next = get_token(options, ",=", token, sizeof(token)); /* While not at the end of the options string, process this option. */ while ( next != NULL ) { if ( strcmp(token,"help")==0 ) { stdout_message("The mtrace JVMTI demo agent\n"); stdout_message("\n"); stdout_message(" java -agent:mtrace[=options] ...\n"); stdout_message("\n"); stdout_message("The options are comma separated:\n"); stdout_message("\t help\t\t\t Print help information\n"); stdout_message("\t max=n\t\t Only list top n classes\n"); stdout_message("\t include=item\t\t Only these classes/methods\n"); stdout_message("\t exclude=item\t\t Exclude these classes/methods\n"); stdout_message("\n"); stdout_message("item\t Qualified class and/or method names\n"); stdout_message("\t\t e.g. (*.;Foobar.method;sun.*)\n"); stdout_message("\n"); exit(0); } else if ( strcmp(token,"max")==0 ) { char number[MAX_TOKEN_LENGTH]; /* Get the numeric option */ next = get_token(next, ",=", number, (int)sizeof(number)); /* Check for token scan error */ if ( next==NULL ) { fatal_error("ERROR: max=n option error\n"); } /* Save numeric value */ gdata->max_count = atoi(number); } else if ( strcmp(token,"include")==0 ) { int used; int maxlen; maxlen = MAX_METHOD_NAME_LENGTH; if ( gdata->include == NULL ) { gdata->include = (char*)calloc(maxlen+1, 1); used = 0; } else { used = (int)strlen(gdata->include); gdata->include[used++] = ','; gdata->include[used] = 0; gdata->include = (char*) realloc((void*)gdata->include, used+maxlen+1); } if ( gdata->include == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } /* Add this item to the list */ next = get_token(next, ",=", gdata->include+used, maxlen); /* Check for token scan error */ if ( next==NULL ) { fatal_error("ERROR: include option error\n"); } } else if ( strcmp(token,"exclude")==0 ) { int used; int maxlen; maxlen = MAX_METHOD_NAME_LENGTH; if ( gdata->exclude == NULL ) { gdata->exclude = (char*)calloc(maxlen+1, 1); used = 0; } else { used = (int)strlen(gdata->exclude); gdata->exclude[used++] = ','; gdata->exclude[used] = 0; gdata->exclude = (char*) realloc((void*)gdata->exclude, used+maxlen+1); } if ( gdata->exclude == NULL ) { fatal_error("ERROR: Out of malloc memory\n"); } /* Add this item to the list */ next = get_token(next, ",=", gdata->exclude+used, maxlen); /* Check for token scan error */ if ( next==NULL ) { fatal_error("ERROR: exclude option error\n"); } } else if ( token[0]!=0 ) { /* We got a non-empty token and we don't know what it is. */ fatal_error("ERROR: Unknown option: %s\n", token); } /* Get the next token (returns NULL if there are no more) */ next = get_token(next, ",=", token, sizeof(token)); } } /* Agent_OnLoad: This is called immediately after the shared library is * loaded. This is the first code executed. */ JNIEXPORT jint JNICALL DEF_Agent_OnLoad(JavaVM *vm, char *options, void *reserved) { static GlobalAgentData data; jvmtiEnv *jvmti; jvmtiError error; jint res; jvmtiCapabilities capabilities; jvmtiEventCallbacks callbacks; /* Setup initial global agent data area * Use of static/extern data should be handled carefully here. * We need to make sure that we are able to cleanup after ourselves * so anything allocated in this library needs to be freed in * the Agent_OnUnload() function. */ (void)memset((void*)&data, 0, sizeof(data)); gdata = &data; /* First thing we need to do is get the jvmtiEnv* or JVMTI environment */ res = (*vm)->GetEnv(vm, (void **)&jvmti, JVMTI_VERSION_1); if (res != JNI_OK) { /* This means that the VM was unable to obtain this version of the * JVMTI interface, this is a fatal error. */ fatal_error("ERROR: Unable to access JVMTI Version 1 (0x%x)," " is your JDK a 5.0 or newer version?" " JNIEnv's GetEnv() returned %d\n", JVMTI_VERSION_1, res); } /* Here we save the jvmtiEnv* for Agent_OnUnload(). */ gdata->jvmti = jvmti; /* Parse any options supplied on java command line */ parse_agent_options(options); /* Immediately after getting the jvmtiEnv* we need to ask for the * capabilities this agent will need. In this case we need to make * sure that we can get all class load hooks. */ (void)memset(&capabilities,0, sizeof(capabilities)); capabilities.can_generate_all_class_hook_events = 1; error = (*jvmti)->AddCapabilities(jvmti, &capabilities); check_jvmti_error(jvmti, error, "Unable to get necessary JVMTI capabilities."); /* Next we need to provide the pointers to the callback functions to * to this jvmtiEnv* */ (void)memset(&callbacks,0, sizeof(callbacks)); /* JVMTI_EVENT_VM_START */ callbacks.VMStart = &cbVMStart; /* JVMTI_EVENT_VM_INIT */ callbacks.VMInit = &cbVMInit; /* JVMTI_EVENT_VM_DEATH */ callbacks.VMDeath = &cbVMDeath; /* JVMTI_EVENT_CLASS_FILE_LOAD_HOOK */ callbacks.ClassFileLoadHook = &cbClassFileLoadHook; /* JVMTI_EVENT_THREAD_START */ callbacks.ThreadStart = &cbThreadStart; /* JVMTI_EVENT_THREAD_END */ callbacks.ThreadEnd = &cbThreadEnd; error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks, (jint)sizeof(callbacks)); check_jvmti_error(jvmti, error, "Cannot set jvmti callbacks"); /* At first the only initial events we are interested in are VM * initialization, VM death, and Class File Loads. * Once the VM is initialized we will request more events. */ error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_START, (jthread)NULL); check_jvmti_error(jvmti, error, "Cannot set event notification"); error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, (jthread)NULL); check_jvmti_error(jvmti, error, "Cannot set event notification"); error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, (jthread)NULL); check_jvmti_error(jvmti, error, "Cannot set event notification"); error = (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_FILE_LOAD_HOOK, (jthread)NULL); check_jvmti_error(jvmti, error, "Cannot set event notification"); /* Here we create a raw monitor for our use in this agent to * protect critical sections of code. */ error = (*jvmti)->CreateRawMonitor(jvmti, "agent data", &(gdata->lock)); check_jvmti_error(jvmti, error, "Cannot create raw monitor"); /* Add demo jar file to boot classpath */ add_demo_jar_to_bootclasspath(jvmti, "mtrace"); /* We return JNI_OK to signify success */ return JNI_OK; } /* Agent_OnUnload: This is called immediately before the shared library is * unloaded. This is the last code executed. */ JNIEXPORT void JNICALL DEF_Agent_OnUnload(JavaVM *vm) { /* Make sure all malloc/calloc/strdup space is freed */ if ( gdata->include != NULL ) { (void)free((void*)gdata->include); gdata->include = NULL; } if ( gdata->exclude != NULL ) { (void)free((void*)gdata->exclude); gdata->exclude = NULL; } if ( gdata->classes != NULL ) { int cnum; for ( cnum = 0 ; cnum < gdata->ccount ; cnum++ ) { ClassInfo *cp; cp = gdata->classes + cnum; (void)free((void*)cp->name); if ( cp->mcount > 0 ) { int mnum; for ( mnum = 0 ; mnum < cp->mcount ; mnum++ ) { MethodInfo *mp; mp = cp->methods + mnum; (void)free((void*)mp->name); (void)free((void*)mp->signature); } (void)free((void*)cp->methods); } } (void)free((void*)gdata->classes); gdata->classes = NULL; } }