JVMTI is a native programming interface that provides tools with both a way to inspect the state and control the execution of applications running in the JVM.

1. JVMTI Overview and Architecture

// jvmti_demo.h - Basic JVMTI header includes #include <jvmti.h> #include <jni.h> #include <stdio.h> #include <stdlib.h> #include <string.h> // JVMTI is a two-way interface: // 1. JVM → Agent (via events) // 2. Agent → JVM (via functions)

2. Basic JVMTI Agent Structure

// basic_agent.c - Basic JVMTI agent structure #include <jvmti.h> #include <jni.h> // Global jvmti environment static jvmtiEnv *jvmti = NULL; // Agent initialization JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) { printf("JVMTI Agent Loading...\n"); jint result = (*jvm)->GetEnv(jvm, (void **)&jvmti, JVMTI_VERSION_1_2); if (result != JNI_OK || jvmti == NULL) { printf("ERROR: Unable to access JVMTI!\n"); return JNI_ERR; } // Set capabilities jvmtiCapabilities capabilities; memset(&capabilities, 0, sizeof(capabilities)); // Request basic capabilities capabilities.can_generate_all_class_hook_events = 1; capabilities.can_get_bytecodes = 1; capabilities.can_get_synthetic_attribute = 1; capabilities.can_tag_objects = 1; jvmtiError error = (*jvmti)->AddCapabilities(jvmti, &capabilities); if (error != JVMTI_ERROR_NONE) { printf("ERROR: Unable to set capabilities!\n"); return JNI_ERR; } // Set callbacks jvmtiEventCallbacks callbacks; memset(&callbacks, 0, sizeof(callbacks)); callbacks.ClassLoad = &class_load_handler; callbacks.ClassPrepare = &class_prepare_handler; callbacks.VMInit = &vm_init_handler; callbacks.VMDeath = &vm_death_handler; error = (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(callbacks)); if (error != JVMTI_ERROR_NONE) { printf("ERROR: Unable to set callbacks!\n"); return JNI_ERR; } // Enable events (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_INIT, NULL); (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_DEATH, NULL); (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_LOAD, NULL); (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_CLASS_PREPARE, NULL); printf("JVMTI Agent Loaded Successfully\n"); return JNI_OK; } // Agent shutdown JNIEXPORT void JNICALL Agent_OnUnload(JavaVM *vm) { printf("JVMTI Agent Unloading...\n"); }

3. Event Handlers Implementation

// event_handlers.c - JVMTI event handlers #include <jvmti.h> #include <jni.h> // VM Initialization event void JNICALL vm_init_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread) { printf("VM Initialized\n"); // Now we can safely call JNI functions jclass thread_class = (*jni_env)->FindClass(jni_env, "java/lang/Thread"); if (thread_class != NULL) { printf("Found Thread class\n"); } } // VM Death event void JNICALL vm_death_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env) { printf("VM Shutting Down\n"); } // Class Load event void JNICALL class_load_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread, jclass klass) { char* class_name; jvmtiError error = (*jvmti_env)->GetClassSignature(jvmti_env, klass, &class_name, NULL); if (error == JVMTI_ERROR_NONE && class_name != NULL) { printf("Class Loaded: %s\n", class_name); (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)class_name); } } // Class Prepare event void JNICALL class_prepare_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread, jclass klass) { char* class_name; jvmtiError error = (*jvmti_env)->GetClassSignature(jvmti_env, klass, &class_name, NULL); if (error == JVMTI_ERROR_NONE && class_name != NULL) { printf("Class Prepared: %s\n", class_name); (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)class_name); } }

4. Method Instrumentation Agent

// method_agent.c - Method entry/exit instrumentation #include <jvmti.h> #include <jni.h> static jvmtiEnv *jvmti = NULL; // Method entry callback void JNICALL method_entry_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread, jmethodID method) { char* method_name = NULL; char* class_name = NULL; char* method_signature = NULL; jvmtiError error = (*jvmti_env)->GetMethodName(jvmti_env, method, &method_name, &method_signature, NULL); if (error == JVMTI_ERROR_NONE) { jclass declaring_class; error = (*jvmti_env)->GetMethodDeclaringClass(jvmti_env, method, &declaring_class); if (error == JVMTI_ERROR_NONE) { error = (*jvmti_env)->GetClassSignature(jvmti_env, declaring_class, &class_name, NULL); } if (error == JVMTI_ERROR_NONE && class_name != NULL && method_name != NULL) { printf("→ ENTER: %s.%s%s\n", class_name, method_name, method_signature); } if (method_name != NULL) { (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)method_name); } if (method_signature != NULL) { (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)method_signature); } if (class_name != NULL) { (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)class_name); } } } // Method exit callback void JNICALL method_exit_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread, jmethodID method, jboolean was_popped_by_exception, jvalue return_value) { char* method_name = NULL; char* class_name = NULL; jvmtiError error = (*jvmti_env)->GetMethodName(jvmti_env, method, &method_name, NULL, NULL); if (error == JVMTI_ERROR_NONE) { jclass declaring_class; error = (*jvmti_env)->GetMethodDeclaringClass(jvmti_env, method, &declaring_class); if (error == JVMTI_ERROR_NONE) { error = (*jvmti_env)->GetClassSignature(jvmti_env, declaring_class, &class_name, NULL); } if (error == JVMTI_ERROR_NONE && class_name != NULL && method_name != NULL) { printf("← EXIT: %s.%s\n", class_name, method_name); } if (method_name != NULL) { (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)method_name); } if (class_name != NULL) { (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)class_name); } } } JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) { jint result = (*jvm)->GetEnv(jvm, (void **)&jvmti, JVMTI_VERSION_1_2); if (result != JNI_OK) return JNI_ERR; // Set capabilities for method tracing jvmtiCapabilities capabilities; memset(&capabilities, 0, sizeof(capabilities)); capabilities.can_generate_method_entry_events = 1; capabilities.can_generate_method_exit_events = 1; capabilities.can_get_method_name = 1; (*jvmti)->AddCapabilities(jvmti, &capabilities); // Set callbacks jvmtiEventCallbacks callbacks; memset(&callbacks, 0, sizeof(callbacks)); callbacks.MethodEntry = &method_entry_handler; callbacks.MethodExit = &method_exit_handler; (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(callbacks)); // Enable method events (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_METHOD_ENTRY, NULL); (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_METHOD_EXIT, NULL); return JNI_OK; }

5. Java Test Application

// JVMTITestApplication.java - Test application for JVMTI agent public class JVMTITestApplication { public static void main(String[] args) { System.out.println("JVMTI Test Application Started"); // Create some objects and call methods to trigger JVMTI events JVMTITestApplication app = new JVMTITestApplication(); app.performOperations(); System.out.println("JVMTI Test Application Completed"); } public void performOperations() { // These method calls will be tracked by JVMTI agent calculateSum(10, 20); createObjects(); callStaticMethod(); } private int calculateSum(int a, int b) { System.out.println("Calculating sum: " + a + " + " + b); return a + b; } private void createObjects() { String text = "Hello JVMTI"; List<String> list = new ArrayList<>(); list.add(text); System.out.println("Created objects: " + list); } private static void callStaticMethod() { System.out.println("Static method called"); } // Exception generation for testing public void generateException() { try { throw new RuntimeException("Test exception for JVMTI"); } catch (Exception e) { System.out.println("Exception caught: " + e.getMessage()); } } }

6. Object Tagging and Heap Analysis

// heap_analysis_agent.c - Object tagging and heap analysis #include <jvmti.h> #include <jni.h> static jvmtiEnv *jvmti = NULL; static jlong object_counter = 0; // Object allocation callback void JNICALL object_alloc_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread, jobject object, jclass object_klass, jlong size) { // Tag the object with a unique ID jlong tag = ++object_counter; (*jvmti_env)->SetTag(jvmti_env, object, tag); char* class_name = NULL; jvmtiError error = (*jvmti_env)->GetClassSignature(jvmti_env, object_klass, &class_name, NULL); if (error == JVMTI_ERROR_NONE && class_name != NULL) { printf("Object Allocated: %s, Size: %ld, Tag: %ld\n", class_name, size, tag); (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)class_name); } } // Heap iteration callback jint JNICALL heap_iteration_callback(jlong class_tag, jlong size, jlong* tag_ptr, jint length, void* user_data) { if (*tag_ptr != 0) { printf("Heap Object - Tag: %ld, Size: %ld\n", *tag_ptr, size); } return JVMTI_VISIT_OBJECTS; } // Perform heap walk void perform_heap_walk() { printf("=== Heap Walk Starting ===\n"); jvmtiError error = (*jvmti)->IterateOverHeap(jvmti, JVMTI_HEAP_OBJECT_TAGGED, heap_iteration_callback, NULL); if (error != JVMTI_ERROR_NONE) { printf("Heap iteration failed: %d\n", error); } printf("=== Heap Walk Completed ===\n"); } JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) { jint result = (*jvm)->GetEnv(jvm, (void **)&jvmti, JVMTI_VERSION_1_2); if (result != JNI_OK) return JNI_ERR; // Set capabilities for heap analysis jvmtiCapabilities capabilities; memset(&capabilities, 0, sizeof(capabilities)); capabilities.can_tag_objects = 1; capabilities.can_generate_object_free_events = 1; capabilities.can_generate_vm_object_alloc_events = 1; (*jvmti)->AddCapabilities(jvmti, &capabilities); // Set callbacks jvmtiEventCallbacks callbacks; memset(&callbacks, 0, sizeof(callbacks)); callbacks.VMObjectAlloc = &object_alloc_handler; (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(callbacks)); // Enable events (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_VM_OBJECT_ALLOC, NULL); return JNI_OK; }

7. Thread Monitoring Agent

// thread_agent.c - Thread lifecycle monitoring #include <jvmti.h> #include <jni.h> static jvmtiEnv *jvmti = NULL; // Thread start callback void JNICALL thread_start_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread) { jvmtiThreadInfo thread_info; jvmtiError error = (*jvmti_env)->GetThreadInfo(jvmti_env, thread, &thread_info); if (error == JVMTI_ERROR_NONE && thread_info.name != NULL) { printf("Thread Started: %s\n", thread_info.name); // Clean up (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)thread_info.name); if (thread_info.thread_group != NULL) { (*jni_env)->DeleteLocalRef(jni_env, thread_info.thread_group); } if (thread_info.context_class_loader != NULL) { (*jni_env)->DeleteLocalRef(jni_env, thread_info.context_class_loader); } } } // Thread end callback void JNICALL thread_end_handler(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread) { jvmtiThreadInfo thread_info; jvmtiError error = (*jvmti_env)->GetThreadInfo(jvmti_env, thread, &thread_info); if (error == JVMTI_ERROR_NONE && thread_info.name != NULL) { printf("Thread Ended: %s\n", thread_info.name); // Clean up (*jvmti_env)->Deallocate(jvmti_env, (unsigned char*)thread_info.name); if (thread_info.thread_group != NULL) { (*jni_env)->DeleteLocalRef(jni_env, thread_info.thread_group); } if (thread_info.context_class_loader != NULL) { (*jni_env)->DeleteLocalRef(jni_env, thread_info.context_class_loader); } } } JNIEXPORT jint JNICALL Agent_OnLoad(JavaVM *jvm, char *options, void *reserved) { jint result = (*jvm)->GetEnv(jvm, (void **)&jvmti, JVMTI_VERSION_1_2); if (result != JNI_OK) return JNI_ERR; // Set capabilities for thread monitoring jvmtiCapabilities capabilities; memset(&capabilities, 0, sizeof(capabilities)); capabilities.can_generate_thread_events = 1; capabilities.can_get_thread_info = 1; (*jvmti)->AddCapabilities(jvmti, &capabilities); // Set callbacks jvmtiEventCallbacks callbacks; memset(&callbacks, 0, sizeof(callbacks)); callbacks.ThreadStart = &thread_start_handler; callbacks.ThreadEnd = &thread_end_handler; (*jvmti)->SetEventCallbacks(jvmti, &callbacks, sizeof(callbacks)); // Enable thread events (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_THREAD_START, NULL); (*jvmti)->SetEventNotificationMode(jvmti, JVMTI_ENABLE, JVMTI_EVENT_THREAD_END, NULL); return JNI_OK; }

8. Building and Running JVMTI Agents

# Makefile for building JVMTI agents JAVA_HOME=/usr/lib/jvm/java-11-openjdk CC=gcc CFLAGS=-I$(JAVA_HOME)/include -I$(JAVA_HOME)/include/linux -fPIC -shared all: basic_agent.so method_agent.so heap_agent.so thread_agent.so basic_agent.so: basic_agent.c $(CC) $(CFLAGS) -o $@ $< method_agent.so: method_agent.c $(CC) $(CFLAGS) -o $@ $< heap_agent.so: heap_analysis_agent.c $(CC) $(CFLAGS) -o $@ $< thread_agent.so: thread_agent.c $(CC) $(CFLAGS) -o $@ $< clean: rm -f *.so test: java -agentpath:./basic_agent.so JVMTITestApplication java -agentpath:./method_agent.so JVMTITestApplication

9. Advanced JVMTI Features

// advanced_agent.c - Advanced JVMTI features #include <jvmti.h> #include <jni.h> static jvmtiEnv *jvmti = NULL; // Get all loaded classes jclass* get_all_loaded_classes(jint* class_count) { jclass* classes = NULL; jvmtiError error = (*jvmti)->GetLoadedClasses(jvmti, class_count, &classes); if (error != JVMTI_ERROR_NONE) { printf("Failed to get loaded classes: %d\n", error); return NULL; } return classes; } // Get class methods void print_class_methods(jclass klass) { jint method_count = 0; jmethodID* methods = NULL; jvmtiError error = (*jvmti)->GetClassMethods(jvmti, klass, &method_count, &methods); if (error != JVMTI_ERROR_NONE) { return; } char* class_name = NULL; (*jvmti)->GetClassSignature(jvmti, klass, &class_name, NULL); printf("Class %s has %d methods:\n", class_name, method_count); for (int i = 0; i < method_count; i++) { char* method_name = NULL; char* method_signature = NULL; error = (*jvmti)->GetMethodName(jvmti, methods[i], &method_name, &method_signature, NULL); if (error == JVMTI_ERROR_NONE) { printf(" Method: %s%s\n", method_name, method_signature); if (method_name != NULL) { (*jvmti)->Deallocate(jvmti, (unsigned char*)method_name); } if (method_signature != NULL) { (*jvmti)->Deallocate(jvmti, (unsigned char*)method_signature); } } } if (class_name != NULL) { (*jvmti)->Deallocate(jvmti, (unsigned char*)class_name); } if (methods != NULL) { (*jvmti)->Deallocate(jvmti, (unsigned char*)methods); } } // Get object size jlong get_object_size(jobject object) { jlong size = 0; jvmtiError error = (*jvmti)->GetObjectSize(jvmti, object, &size); if (error != JVMTI_ERROR_NONE) { printf("Failed to get object size: %d\n", error); return -1; } return size; } // Force garbage collection void force_garbage_collection() { printf("Forcing garbage collection...\n"); jvmtiError error = (*jvmti)->ForceGarbageCollection(jvmti); if (error != JVMTI_ERROR_NONE) { printf("Failed to force GC: %d\n", error); } }

10. Java-side Agent Controller

// JVMTIAgentController.java - Java side controller for JVMTI agent public class JVMTIAgentController { // Native methods to interact with JVMTI agent public native void performHeapWalk(); public native void forceGarbageCollection(); public native long getObjectSize(Object obj); static { // Load the native library System.loadLibrary("advanced_agent"); } public static void main(String[] args) { JVMTIAgentController controller = new JVMTIAgentController(); // Demonstrate JVMTI features from Java side controller.demoJVMTIFeatures(); } public void demoJVMTIFeatures() { System.out.println("Starting JVMTI Agent Controller Demo"); // Create some objects List<String> stringList = new ArrayList<>(); for (int i = 0; i < 100; i++) { stringList.add("String " + i); } // Force GC via JVMTI forceGarbageCollection(); // Get object size via JVMTI long listSize = getObjectSize(stringList); System.out.println("ArrayList size via JVMTI: " + listSize + " bytes"); // Perform heap walk performHeapWalk(); System.out.println("JVMTI Agent Controller Demo Completed"); } }

Key JVMTI Concepts

1. Agents: Native libraries loaded by JVM
2. Environment: jvmtiEnv pointer for all operations
3. Capabilities: Features that must be explicitly requested
4. Events: Notifications from JVM to agent
5. Callbacks: Functions called when events occur
6. Memory Management: Manual allocation/deallocation for strings and arrays

Common Use Cases

• Profiling and performance monitoring
• Debugging tools
• Code coverage tools
• Memory leak detection
• Security analysis
• Hot-swapping tools

JVMTI provides powerful low-level access to JVM internals, making it essential for building advanced development and monitoring tools.