inspectorJ -- JavaTM Profiler

sf project site browse source checkout source

src/inspectorj/agent/inspectorjagent.cpp

Go to the documentation of this file.

/***************************************************************************
 *   inspectorJ - java profiler                                            *
 *   Copyright (C) 2007 by James May
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
        
#include "inspectorj/agent/inspectorjagent.h"


using namespace inspectorj::agent;
using inspectorj::client::SessionProfile;
using inspectorj::toolset::ProfileToolSet;

/* ------------------------------------------------------------------- */
/* Some constant maximum sizes */

#define MAX_TOKEN_LENGTH    256              
#define MAX_THREAD_NAME_LENGTH  512         
#define MAX_METHOD_NAME_LENGTH  1024        
#define INSPECTORJ_class        Mtrace      
#define INSPECTORJ_entry        method_entry    
#define INSPECTORJ_exit         method_exit     
#define INSPECTORJ_native_entry _method_entry   
#define INSPECTORJ_native_exit  _method_exit    
#define INSPECTORJ_engaged      engaged         

/* C macros to create strings from tokens */
#define _STRING(s) #s
#define STRING(s) _STRING(s)

/* ------------------------------------------------------------------- */

typedef struct MethodInfo {
    const char *name;          
    const char *signature;     
    int         calls;         
    int         returns;       
} MethodInfo;

typedef struct ClassInfo {
    const char *name;          
    int         mcount;        
    MethodInfo *methods;       
    int         calls;         
} ClassInfo;


typedef struct {
    /* JVMTI Environment */
    JavaVM        *vm;
    JNIEnv        *env;
    jvmtiEnv      *jvmti;
    jboolean       vm_is_dead;
    jboolean       vm_is_started;
    /* Data access Lock */
    jrawMonitorID  lock;
    /* Options */
    SessionProfile *profile;
    QList<QRegExp> *regexFilterList;

    /* ClassInfo Table */
    ClassInfo      *classes;
    jint            ccount;
    
    /* Agent Server */
    AgentServer    *server;
    AgentPacketHandler *cmdHandler;
    boost::thread *serverThread;
} AgentGlobalContext;

static AgentGlobalContext *context;



static void
deallocate(jvmtiEnv *jvmti, void *ptr)
{
    jvmtiError error;

    error = jvmti->Deallocate(static_cast<unsigned char *>(ptr));
    check_jvmti_error(jvmti, error, "Cannot deallocate memory");
}

static void *
allocate(jvmtiEnv *jvmti, jint len)
{
    jvmtiError error;
    void      *ptr;

    error = jvmti->Allocate(len, (unsigned char **)&ptr);
    check_jvmti_error(jvmti, error, "Cannot allocate memory");
    return ptr;
}

static void
enter_critical_section(jvmtiEnv *jvmti)
{
    jvmtiError error;

    error = jvmti->RawMonitorEnter(context->lock);
    check_jvmti_error(jvmti, error, "Cannot enter with raw monitor");
}

static void
exit_critical_section(jvmtiEnv *jvmti)
{
    jvmtiError error;

    error = jvmti->RawMonitorExit(context->lock);
    check_jvmti_error(jvmti, error, "Cannot exit with raw monitor");
}

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(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);
    }
}

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;
}

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;
}

static void
mnum_callbacks(unsigned cnum, const char **names, const char**sigs, int mcount)
{
    ClassInfo  *cp;
    int         mnum;

    if ( cnum >= (unsigned)context->ccount ) {
    AgentLogger::fatal("=> Class number out of range");
    }
    if ( mcount == 0 ) {
    return;
    }

    cp           = context->classes + (int)cnum;
    cp->calls    = 0;
    cp->mcount   = mcount;
    cp->methods  = (MethodInfo*)calloc(mcount, sizeof(MethodInfo));
    if ( cp->methods == NULL ) {
    AgentLogger::fatal("=> Out of malloc memory");
    }

    for ( mnum = 0 ; mnum < mcount ; mnum++ ) {
        MethodInfo *mp;

    mp            = cp->methods + mnum;
        mp->name      = (const char *)strdup(names[mnum]);
    if ( mp->name == NULL ) {
        AgentLogger::fatal("=> Out of malloc memory");
    }
        mp->signature = (const char *)strdup(sigs[mnum]);
    if ( mp->signature == NULL ) {
        AgentLogger::fatal("=> Out of malloc memory");
    }
    }
}

static void
INSPECTORJ_native_entry(JNIEnv *env, jclass klass, jobject thread, jint cnum, jint mnum)
{
    enter_critical_section(context->jvmti); {

    if ( !context->vm_is_dead ) {
            ClassInfo  *cp;
            MethodInfo *mp;

        if ( cnum >= context->ccount ) {
        AgentLogger::fatal("=> Class number out of range");
        }
            cp = context->classes + cnum;
        if ( mnum >= cp->mcount ) {
        AgentLogger::fatal("=> Method number out of range");
        }
        mp = cp->methods + mnum;
            if ( interested((char*)cp->name, (char*)mp->name,
                context->regexFilterList)  ) {
        mp->calls++;
        cp->calls++;
        }
    }
    } exit_critical_section(context->jvmti);
}

static void
INSPECTORJ_native_exit(JNIEnv *env, jclass klass, jobject thread, jint cnum, jint mnum)
{
    enter_critical_section(context->jvmti); {
    /* It's possible we get here right after VmDeath event, be careful */
    if ( !context->vm_is_dead ) {
            ClassInfo  *cp;
            MethodInfo *mp;

        if ( cnum >= context->ccount ) {
        AgentLogger::fatal("=> Class number out of range");
        }
            cp = context->classes + cnum;
        if ( mnum >= cp->mcount ) {
        AgentLogger::fatal("=> Method number out of range");
        }
        mp = cp->methods + mnum;
            if ( interested((char*)cp->name, (char*)mp->name,
                        context->regexFilterList)  ) {
        mp->returns++;
        }
    }
    } exit_critical_section(context->jvmti);
}

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(INSPECTORJ_native_entry), "(Ljava/lang/Object;II)V",
        (void*)&INSPECTORJ_native_entry},
        {STRING(INSPECTORJ_native_exit),  "(Ljava/lang/Object;II)V",
        (void*)&INSPECTORJ_native_exit}
        };

    /* The VM has started. */
    AgentLogger::debug("VMStart");

    /* Register Natives for class whose methods we use */
    klass = env->FindClass(STRING(INSPECTORJ_class));
    if ( klass == NULL ) {
        AgentLogger::fatal("=> JNI: Cannot find %s with FindClass",
            STRING(INSPECTORJ_class));
    }
    rc = env->RegisterNatives(klass, registry, 2);
    if ( rc != 0 ) {
        AgentLogger::fatal("=> JNI: Cannot register native methods for %s",
            STRING(INSPECTORJ_class));
    }

    /* Engage calls. */
    field = env->GetStaticFieldID(klass, STRING(INSPECTORJ_engaged), "I");
    if ( field == NULL ) {
        AgentLogger::fatal("=> JNI: Cannot get field from %s",
            STRING(INSPECTORJ_class));
    }
    env->SetStaticIntField(klass, field, 1);

        /* Indicate VM has started */
        context->vm_is_started = JNI_TRUE;

    } exit_critical_section(jvmti);
}


void startServer()
{
    AgentLogger::print("*****************************\n");
    AgentLogger::print("  inspectorj server starting\n");
    AgentLogger::print("  listening on port %s\n",
            context->profile->getConnection().port.toLocal8Bit().data());
    AgentLogger::print("*****************************\n");    
    context->server->start();
}

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));
    AgentLogger::debug("VMInit %s", 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_ENABLE,
                  events[i], (jthread)NULL);
        check_jvmti_error(jvmti, error, "Cannot set event notification");
    }
    
    } exit_critical_section(jvmti);
    
    context->env = env;
    
    /* Create the agent server and store in global data */
    AgentPacketHandler *cmdHandler = new AgentPacketHandler(context->vm, context->env, context->jvmti);    
    AgentServer *server = new AgentServer(
            context->profile->getConnection().port.toInt(),
            cmdHandler);
    
    context->server = server;
    context->cmdHandler = cmdHandler;    
    // Start the agent server
    context->serverThread = &boost::thread(startServer);
}

static void JNICALL
cbVMDeath(jvmtiEnv *jvmti, JNIEnv *env)
{
    enter_critical_section(jvmti); {
        jclass   klass;
    jfieldID field;

    /* The VM has died. */
    AgentLogger::info("VMDeath");

    /* Disengage calls in INSPECTORJ_class. */
    klass = env->FindClass(STRING(INSPECTORJ_class));
    if ( klass == NULL ) {
        AgentLogger::fatal("=> JNI: Cannot find %s with FindClass",
            STRING(INSPECTORJ_class));
    }
    field = env->GetStaticFieldID(klass, STRING(INSPECTORJ_engaged), "I");
    if ( field == NULL ) {
        AgentLogger::fatal("=> JNI: Cannot get field from %s",
            STRING(INSPECTORJ_class));
    }
    env->SetStaticIntField(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.
     */
    context->vm_is_dead = JNI_TRUE;

    /* Dump out stats */
    AgentLogger::info("Begin Class Stats");
    if ( context->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(context->classes, context->ccount, sizeof(ClassInfo),
            &class_compar);

        /* Dump out context->max_count most called classes */
        for ( cnum=context->ccount-1 ;
          cnum >= 0 && cnum >= context->ccount - 4;
          cnum-- ) {
        ClassInfo *cp;
            int        mnum;

        cp = context->classes + cnum;
        AgentLogger::info("Class %s %d calls", 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;
            AgentLogger::info("\tMethod %s %s %d calls %d returns",
            mp->name, mp->signature, mp->calls, mp->returns);
        }
        }
    }
    AgentLogger::info("End Class Stats");
    (void)fflush(stdout);

    } exit_critical_section(jvmti);

}

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 ( !context->vm_is_dead ) {
        char  tname[MAX_THREAD_NAME_LENGTH];

        get_thread_name(jvmti, thread, tname, sizeof(tname));
        AgentLogger::info("ThreadStart %s", tname);
    }
    } exit_critical_section(jvmti);
}

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 ( !context->vm_is_dead ) {
        char  tname[MAX_THREAD_NAME_LENGTH];

        get_thread_name(jvmti, thread, tname, sizeof(tname));
        AgentLogger::info("ThreadEnd %s", tname);
    }
    } exit_critical_section(jvmti);
}

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 ( !context->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 ) {
            AgentLogger::fatal("=> No classname inside classfile");
        }
        } else {
        classname = strdup(name);
        if ( classname == NULL ) {
            AgentLogger::fatal("=> Out of malloc memory");
        }
        }

        *new_class_data_len = 0;
            *new_class_data     = NULL;

            /* The tracker class itself? */
            if ( interested((char*)classname, "", context->regexFilterList)
          &&  strcmp(classname, STRING(INSPECTORJ_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 = context->ccount++;

        /* Save away class information */
        if ( context->classes == NULL ) {
            context->classes = (ClassInfo*)malloc(
                context->ccount*sizeof(ClassInfo));
                } else {
            context->classes = (ClassInfo*)
                realloc((void*)context->classes,
                context->ccount*sizeof(ClassInfo));
        }
        if ( context->classes == NULL ) {
            AgentLogger::fatal("=> Out of malloc memory");
        }
        cp           = context->classes + cnum;
        cp->name     = (const char *)strdup(classname);
        if ( cp->name == NULL ) {
            AgentLogger::fatal("=> Out of malloc memory");
        }
        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 ( !context->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(INSPECTORJ_class), "L" STRING(INSPECTORJ_class) ";",
                    STRING(INSPECTORJ_entry), "(II)V",
                    STRING(INSPECTORJ_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);
}

static void parseOptions(char *options)
{
    char token[MAX_TOKEN_LENGTH];
    char *next;

    /* Parse options and set flags in context */
    if ( options == NULL ) {
        options = "help";
    }
    
    /* Get the first token from the options string. */
    next = getToken(options, ",=", token, sizeof(token));

    /* While not at the end of the options string, process this option. */
    while ( next != NULL ) {
    if ( strcmp(token,"help")==0 ) {
        AgentLogger::println("");
        AgentLogger::println("====================");
        AgentLogger::println("inspectorJ JVM Agent");
        AgentLogger::println("====================");
        AgentLogger::println("");
        AgentLogger::println(" java -agent:ij_agent=profile=<path_to_profile>[,=options,...]");
        AgentLogger::println("");
        AgentLogger::println("\t port=xxxx\txxxx is the port number used by the agent server");
        AgentLogger::println("");        
        AgentLogger::println(" The options are comma separated:");
        AgentLogger::println("\t help\t\tPrint help information");
        AgentLogger::println("\t loglevel=n\tlogging [0 = error, 1 = warn, (2) = info]");
        AgentLogger::println("");
        exit(0);
    } else if ( strcmp(token,"loglevel")==0 ) {
            char number[MAX_TOKEN_LENGTH];

        /* Get the numeric option */
        next = getToken(next, ",=", number, (int)sizeof(number));
        /* Check for token scan error */
        if ( next==NULL ) {
            AgentLogger::error("=> loglevel=n option error");
            next = "1";
        }
        /* Save numeric value */        
        AgentLogger::loglevel = atoi(number);         
    } else if ( strcmp(token,"profile")==0 ) {
            char fileName[MAX_TOKEN_LENGTH];

        /* Get the numeric option */
        next = getToken(next, ",=", fileName, (int)sizeof(fileName));
        
        /* Check for token scan error */
        if ( next==NULL ) {
        AgentLogger::fatal("=> profile option error");
        }
        /* Save session profile */
        context->profile = new SessionProfile(); 
        if (!ProfileToolSet::loadProfile(*(context->profile), fileName)) {
            AgentLogger::fatal("=> Could not load profile: %s", fileName);
        }
        context->regexFilterList = new QList<QRegExp>();

        // create class filter regular expressions
        if (context->profile) {
            QStringList filters = context->profile->getClassFilters();
            QStringListIterator filterIter(filters);
            while(filterIter.hasNext()) {
                QRegExp regexp;
                createAgentClassFilter(regexp, filterIter.next());
                *(context->regexFilterList) << regexp;
            }
        }
    } else if ( token[0]!=0 ) {
        /* We got a non-empty token and we don't know what it is. */
        AgentLogger::fatal("=> Unknown option: %s", token);
    }
    /* Get the next token (returns NULL if there are no more) */
        next = getToken(next, ",=", token, sizeof(token));
    }        
}

JNIEXPORT jint JNICALL
Agent_OnLoad(JavaVM *vm, char *options, void *reserved)
{
    static AgentGlobalContext ctx;
    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*)&ctx, 0, sizeof(ctx));
    context = &ctx;

    /* First thing we need to do is get the jvmtiEnv* or JVMTI environment */
    res = vm->GetEnv((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.
     */
    AgentLogger::fatal("=> Unable to access JVMTI Version 1 (0x%x),"
                " is your J2SE a 1.5 or newer version?"
                " JNIEnv's GetEnv() returned %d",
               JVMTI_VERSION_1, res);
    }
    
    context->vm = vm;

    /* Here we save the jvmtiEnv* for Agent_OnUnload(). */
    context->jvmti = jvmti;

    /* Parse any options supplied on the command line */
    parseOptions(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;
    capabilities.can_get_source_file_name = 1;
    capabilities.can_access_local_variables = 1;
    capabilities.can_get_line_numbers = 1;
    error = jvmti->AddCapabilities(&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(&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_ENABLE,
              JVMTI_EVENT_VM_START, (jthread)NULL);
    check_jvmti_error(jvmti, error, "Cannot set event notification");
    error = jvmti->SetEventNotificationMode(JVMTI_ENABLE,
              JVMTI_EVENT_VM_INIT, (jthread)NULL);
    check_jvmti_error(jvmti, error, "Cannot set event notification");
    error = jvmti->SetEventNotificationMode(JVMTI_ENABLE,
              JVMTI_EVENT_VM_DEATH, (jthread)NULL);
    check_jvmti_error(jvmti, error, "Cannot set event notification");
    error = jvmti->SetEventNotificationMode(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("inspectorj agent", &(context->lock));
    check_jvmti_error(jvmti, error, "Cannot create raw monitor");    
    
    /* We return JNI_OK to signify success */
    return JNI_OK;
}

JNIEXPORT void JNICALL
Agent_OnUnload(JavaVM *vm)
{
    /* Make sure all malloc/calloc/strdup space is freed */

    // stop and delete the server instance
    if ( context->server != NULL ) {
        AgentLogger::print("**********************************\n");
        AgentLogger::print("  shutting down inspectorj server\n");                   
            
        // stop the server
        context->server->stop();
        
        // wait for server to stop...
        while(context->server->isStarted()) { }       
        AgentLogger::print("  unloading inspectorj agent\n"); 
    
        delete context->server;
        context->server = NULL;
    }
    
    // delete the AgentPacketHandler instance
    if ( context->cmdHandler != NULL ) {
        delete context->cmdHandler;
        context->cmdHandler = NULL;
    }

    // delete the regexFilterList
    if ( context->regexFilterList != NULL ) {
        delete context->regexFilterList;
        context->regexFilterList = NULL;
    }
          
    // delete the SessionProfile
    if ( context->profile != NULL ) {
        delete context->profile;
        context->profile = NULL;
    }

    if ( context->classes != NULL ) {
        int cnum;      

        for ( cnum = 0 ; cnum < context->ccount ; cnum++ ) {
            ClassInfo *cp;    
            cp = context->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*)context->classes);
        context->classes = NULL;
    }
    AgentLogger::print("**********************************\n");
}

---