Learning JVMTI

Chapter 1: Introduction to JVMTI

1. 1.1 Real-World Use Cases
2. 1.2 Evolution: JVMPI, JVMDI → JVMTI
3. 1.3 JVMTI vs Other Tooling Interfaces
4. 1.4 Requirements and Environment Setup
5. 1.5 What You’ll Learn in This Book

Chapter 2: Anatomy of a JVMTI Agent

1. 2.1 What is a JVMTI Agent?
2. 2.2 Lifecycle Entry Points
3. 2.3 Minimum Viable Agent
4. 2.4 Compiling with CMake
5. 2.5 Running the Agent with Java
6. 2.6 Troubleshooting Tips
7. 2.7 Optional: Logging with stderr or a file
8. 2.8 What’s Next?

Chapter 3: Capabilities and Events in JVMTI

1. 3.1 Understanding JVMTI Capabilities
2. 3.2 Registering Event Callbacks
3. 3.3 Commonly Used Events
4. 3.4 Best Practices for Event Handling
5. 3.5 Example: Counting Method Entries
6. 3.6 Troubleshooting
7. 3.7 What’s Next?

Chapter 4: Inspecting Threads, Stacks, and Methods

1. 4.1 Enumerating All Threads
2. 4.2 Walking the Stack of a Thread
3. 4.3 Retrieving Method Details
4. 4.4 Inspecting Local Variables
5. 4.5 Example: Print Stack Trace for All Threads
6. 4.6 Best Practices
7. 4.7 What’s Next?

Chapter 5: Heap Inspection and Object Tagging

1. 5.1 Iterating Over Heap Objects
2. 5.2 Object Tagging
3. 5.3 Finding Instances of a Class
4. 5.4 Heap Summary and Statistics
5. 5.5 Monitoring Object Allocations (Optional)
6. 5.6 Example: Count Instances by Class
7. 5.7 Best Practices
8. 5.8 What’s Next?

Chapter 6: Class Transformation and Bytecode Instrumentation

1. 6.1 The Class File Load Hook
2. 6.2 Using ASM for Bytecode Instrumentation
3. 6.3 Retransformation
4. 6.4 Filtering Classes
5. 6.5 Safety Tips and Pitfalls
6. 6.6 Example: Insert Logging in All Methods
7. 6.7 What’s Next?

Chapter 7: Event Notification and Callback Handling

1. 7.1 How Event Notification Works
2. 7.2 Commonly Used Events
3. 7.3 Writing Event Handlers
4. 7.4 Conditional Event Registration
5. 7.5 Working with Threads in Callbacks
6. 7.6 Use Case Examples
7. 7.7 Event Chaining with Other Tools
8. 7.8 What’s Next?

Chapter 8: Interacting with the JVM Runtime

1. 8.1 Querying JVM Capabilities
2. 8.2 Working with System Properties
3. 8.3 Interacting with Threads
4. 8.4 Memory Information and GC Control
5. 8.5 Managing Native Memory
6. 8.6 Advanced: Environment Manipulation
7. 8.7 Best Practices
8. 8.8 What’s Next?

Chapter 9: Stack Traces and Heap Walking

1. 9.1 Capturing Stack Traces
2. 9.2 Object Tagging and Metadata
3. 9.3 Walking the Heap
4. 9.4 Heap Analysis Use Cases
5. 9.5 Safely Walking the Heap
6. 9.6 Integration Tip: Combining Stack + Heap
7. 9.7 Best Practices
8. 9.8 What’s Next?

Chapter 10: Handling Exceptions and Debugging

1. 10.1 Introduction to Exception Handling in the JVM
2. 10.2 Exception Callback Events
3. 10.3 Stack Trace Capture on Exceptions
4. 10.4 Instrumenting Try-Catch Blocks
5. 10.5 Exception Suppression or Transformation
6. 10.6 Integration Tips
7. 10.7 Architecture Summary
8. 10.8 Real-World Relevance
9. 10.9 Summary and Next Steps

Chapter 11: Building a Minimal Profiler

1. 11.1 Profiling Approaches: Sampling vs Instrumentation
2. 11.2 Method Entry/Exit and Stack Trace Sampling
3. 11.3 Aggregating and Presenting Performance Data
4. 11.4 Timers and Signal Handling
5. 11.5 Open-Source Profiler Architecture
6. 11.6 Summary and Next Steps

Chapter 12: Advanced Topics

1. 12.1 Retransforming Classes
2. 12.2 Bytecode Verification and Redefinition
3. 12.3 Agent Reentrancy and Performance Trade-offs
4. 12.4 Thread-Local Storage and Thread Safety
5. 12.5 Native Memory Management (Allocation Tracking)
6. 12.6 Architecture Summary
7. 12.7 Real-World Relevance
8. 12.8 Summary and Next Steps

Chapter 13: Deploying and Testing JVMTI Agents

1. 13.1 Agent Packaging and Versioning
2. 13.2 Debug vs Release Builds
3. 13.3 Logging and Error Handling
4. 13.4 Using Attach API on Remote JVMs
5. 13.5 Monitoring Agent Impact
6. 13.6 Architecture Summary
7. 13.7 Real-World Relevance
8. 13.8 Summary and Next Steps

Chapter 14: Security and Stability Considerations

1. 14.1 Crash Handling and Signal Safety
2. 14.2 Thread Safety and Reentrancy
3. 14.3 Sandbox and Permissions
4. 14.4 JVMTI and Containerization
5. 14.5 JVM Compatibility Across Vendors and Versions
6. 14.6 Architecture Summary
7. 14.7 Real-World Relevance
8. 14.8 Summary and Next Steps

Chapter 15: Case Study: Building a Real-World Agent

1. 15.1 Full Project Structure
2. 15.2 Design Decisions
3. 15.3 Integrating with Other Tools
4. 15.4 Performance and Memory Impact Tuning
5. 15.5 CI/CD for Native Agents
6. 15.6 Architecture Summary
7. 15.7 Real-World Relevance
8. 15.8 Summary and Next Steps

Appendix A: Full JVMTI Capabilities Table

Appendix B: JVMTI Error Codes Cheat Sheet

Appendix C: Reference to Open-Source Tools using JVMTI

1. Open-Source Tools
2. Commercial Tools (JVMTI-based)
3. How to Learn from These Tools

Appendix D: Setting Up Debugging for Crashes in Native Code

1. 1. Enable Core Dumps
2. 2. Build with Debug Symbols
3. 3. Use Native Debuggers
4. 4. Analyze JVM Crash Logs
5. 5. Attach Debugger to Running JVM
6. Tips
7. Example: GDB Session

Appendix E: Compatibility Matrix (JVM Versions and JVMTI Capabilities)

1. How to Check Capabilities at Runtime
2. Additional Resources

Appendix F: Java Native Interface (JNI)

1. JNI Types and Handles
2. Accessing Java Classes, Methods, and Fields
3. Working with Strings and Arrays
4. Exception Handling
5. Creating and Managing References
6. Registering Native Methods
7. Common JNI Function Signatures
8. Best Practices and Gotchas
9. Additional Resources