8012005: LogManager needs test to ensure stack trace is not being done to find bundle
Reviewed-by: mchung
/*
* Copyright (c) 2004, 2011, 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. (*.<init>;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
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
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;
}
}