1use std::os::raw::{c_void, c_char, c_uchar};
2use std::panic;
3use log::error;
4
5use crate::{sys::*, event::*, builder::*, *};
6
7static mut EVENT_CALL_TABLE: EventHandlers = empty_event_handlers!();
8
9macro_rules! global_event {
10 () => {{
11 unsafe {
12 EVENT_CALL_TABLE
13 }
14 }};
15}
16
17macro_rules! define_event {
18 ($event_name:ident, $event_field:ident, $event_type:ty) => {
19 pub fn $event_name(event: $event_type) { unsafe { EVENT_CALL_TABLE.$event_field = event } }
20 };
21}
22
23pub struct EventAdjuster();
24
25impl EventAdjuster {
26 fn global() -> EventHandlers {
27 return global_event!();
28 }
29
30 define_event!(on_breakpoint, breakpoint, EventBreakpointFn);
31 define_event!(on_class_file_load_hook, class_file_load_hook, EventClassFileLoadHookFn);
32 define_event!(on_class_load, class_load, EventClassLoadFn);
33 define_event!(on_class_prepare, class_prepare, EventClassPrepareFn);
34 define_event!(on_compiled_method_load, compiled_method_load, CompiledMethodLoadFn);
35 define_event!(on_compiled_method_unload, compiled_method_unload, CompiledMethodUnloadFn);
36 define_event!(on_data_dump_request, data_dump_request, DataDumpRequestFn);
37 define_event!(on_dynamic_code_generated, dynamic_code_generated, DynamicCodeGeneratedFn);
38 define_event!(on_exception, exception, ExceptionFn);
39 define_event!(on_exception_catch, exception_catch, ExceptionCatchFn);
40 define_event!(on_field_access, field_access, FieldAccessFn);
41 define_event!(on_field_modification, field_modification, FieldModificationFn);
42 define_event!(on_frame_pop, frame_pop, FramePopFn);
43 define_event!(on_garbage_collection_finish, garbage_collection_finish, GarbageCollectionFinishFn);
44 define_event!(on_garbage_collection_start, garbage_collection_start, GarbageCollectionStartFn);
45 define_event!(on_method_entry, method_entry, MethodEntryFn);
46 define_event!(on_method_exit, method_exit, MethodExitFn);
47 define_event!(on_monitor_contended_enter, monitor_contended_enter, MonitorContendedEnterFn);
48 define_event!(on_monitor_contended_entered, monitor_contended_entered, MonitorContendedEnteredFn);
49 define_event!(on_monitor_wait, monitor_wait, MonitorWaitFn);
50 define_event!(on_monitor_waited, monitor_waited, MonitorWaitedFn);
51 define_event!(on_native_method_bind, native_method_bind, NativeMethodBindFn);
52 define_event!(on_object_free, object_free, ObjectFreeFn);
53 define_event!(on_resource_exhausted, resource_exhausted, ResourceExhaustedFn);
54 define_event!(on_single_step, single_step, SingleStepFn);
55 define_event!(on_thread_end, thread_end, ThreadEndFn);
56 define_event!(on_thread_start, thread_start, ThreadStartFn);
57 define_event!(on_vm_death, vm_death, VmDeathFn);
58 define_event!(on_vm_init, vm_init, VmInitFn);
59 define_event!(on_vm_object_alloc, vm_object_alloc, VmObjectAllocFn);
60 define_event!(on_vm_start, vm_start, VmStartFn);
61}
62
63#[no_mangle]
64pub extern "C" fn jvmti_event_breakpoint_handler(jvmti_env: *mut sys::jvmtiEnv,
65 jni_env: *mut sys::JNIEnv,
66 thread: jthread,
67 method: jmethodID,
68 location: jlocation) {
69 unsafe {
70 let jvmti = jvmti!(jvmti_env);
71 let jni = jni!(jni_env);
72 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
73 let event = BreakpointEvent {
74 jvmti: &jvmti_facade,
75 jni: &jni,
76 thread: thread.into(),
77 method: method.into(),
78 location,
79 };
80 event_call!("jvmti_event_breakpoint_handler", breakpoint, event)
81 }
82}
83
84#[no_mangle]
85pub extern "C" fn jvmti_event_class_file_load_hook_handler(jvmti_env: *mut sys::jvmtiEnv,
86 jni_env: *mut sys::JNIEnv,
87 class_being_redefined: jclass,
88 loader: jobject,
89 name: *const c_char,
90 protection_domain: jobject,
91 class_data_len: jint,
92 class_data: *const c_uchar,
93 new_class_data_len: *mut jint,
94 new_class_data: *mut jmemory) {
95 unsafe {
96 let jvmti = jvmti!(jvmti_env);
97 let jni = jni!(jni_env);
98 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
99 let event = ClassFileLoadHookEvent {
100 jvmti: &jvmti_facade,
101 jni: &jni,
102 class_being_redefined: class_being_redefined.into(),
103 loader: loader.into(),
104 name: stringify(name),
105 protection_domain: protection_domain.into(),
106 class_data_len,
107 class_data,
108 new_class_data_len,
109 new_class_data,
110 };
111 event_call!("jvmti_event_class_file_load_hook_handler", class_file_load_hook, event)
112 }
113}
114
115#[no_mangle]
116pub extern "C" fn jvmti_event_class_load_handler(jvmti_env: *mut sys::jvmtiEnv,
117 jni_env: *mut sys::JNIEnv,
118 thread: jthread,
119 klass: jclass) {
120 unsafe {
121 let jvmti = jvmti!(jvmti_env);
122 let jni = jni!(jni_env);
123 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
124 let event = ClassLoadEvent {
125 jvmti: &jvmti_facade,
126 jni: &jni,
127 thread: thread.into(),
128 klass: klass.into(),
129 };
130 event_call!("jvmti_event_class_load_handler", class_load, event)
131 }
132}
133
134#[no_mangle]
135pub extern "C" fn jvmti_event_class_prepare_handler(jvmti_env: *mut sys::jvmtiEnv,
136 jni_env: *mut sys::JNIEnv,
137 thread: jthread,
138 klass: jclass) {
139 unsafe {
140 let jvmti = jvmti!(jvmti_env);
141 let jni = jni!(jni_env);
142 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
143 let event = ClassPrepareEvent {
144 jvmti: &jvmti_facade,
145 jni: &jni,
146 thread: thread.into(),
147 klass: klass.into(),
148 };
149 event_call!("jvmti_event_class_prepare_handler", class_prepare, event)
150 }
151}
152
153#[no_mangle]
154pub extern "C" fn jvmti_event_compiled_method_load_handler(jvmti_env: *mut sys::jvmtiEnv,
155 method: jmethodID,
156 code_size: jint,
157 code_addr: *const c_void,
158 map_length: jint,
159 map: *const jvmtiAddrLocationMap,
160 compile_info: *const c_void) {
161 unsafe {
162 let jvmti = jvmti!(jvmti_env);
163 let builder: ObjectArrayBuilder<jvmtiAddrLocationMap> = ObjectArrayBuilder::new(map_length, map);
164 let compiled_method_load_records = parse_compiled_method_load_record(compile_info);
165 let event = CompiledMethodLoadEvent {
166 jvmti: &jvmti,
167 method: method.into(),
168 code_size,
169 code_addr,
170 addr_location_map: builder.build(),
171 compiled_records: &compiled_method_load_records,
172 };
173 event_call!("jvmti_event_compiled_method_load_handler", compiled_method_load, event)
174 }
175}
176
177#[no_mangle]
178pub extern "C" fn jvmti_event_compiled_method_unload_handler(jvmti_env: *mut sys::jvmtiEnv,
179 method: jmethodID,
180 code_addr: *const c_void) {
181 unsafe {
182 let jvmti = jvmti!(jvmti_env);
183 let event = CompiledMethodUnloadEvent {
184 jvmti: &jvmti,
185 method: method.into(),
186 code_addr,
187 };
188 event_call!("jvmti_event_compiled_method_unload_handler", compiled_method_unload, event)
189 }
190}
191
192#[no_mangle]
193pub extern "C" fn jvmti_event_data_dump_request_handler(jvmti_env: *mut sys::jvmtiEnv) {
194 unsafe {
195 let jvmti = jvmti!(jvmti_env);
196 let event = DataDumpRequestEvent {
197 jvmti: &jvmti,
198 };
199 event_call!("jvmti_event_data_dump_request_handler", data_dump_request, event)
200 }
201}
202
203#[no_mangle]
204pub extern "C" fn jvmti_event_dynamic_code_generated_handler(jvmti_env: *mut sys::jvmtiEnv,
205 name: *const c_char,
206 address: *const c_void,
207 length: jint) {
208 unsafe {
209 let jvmti = jvmti!(jvmti_env);
210 let event = DynamicCodeGeneratedEvent {
211 jvmti: &jvmti,
212 name: stringify(name),
213 address,
214 length,
215 };
216 event_call!("jvmti_event_dynamic_code_generated_handler", dynamic_code_generated, event)
217 }
218}
219
220#[no_mangle]
221pub extern "C" fn jvmti_event_exception_handler(jvmti_env: *mut sys::jvmtiEnv,
222 jni_env: *mut sys::JNIEnv,
223 thread: jthread,
224 method: jmethodID,
225 location: jlocation,
226 exception: jobject,
227 catch_method: jmethodID,
228 catch_location: jlocation) {
229 unsafe {
230 let jvmti = jvmti!(jvmti_env);
231 let jni = jni!(jni_env);
232 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
233 let event = ExceptionEvent {
234 jvmti: &jvmti_facade,
235 jni: &jni,
236 thread: thread.into(),
237 method: method.into(),
238 location,
239 exception: exception.into(),
240 catch_method: catch_method.into(),
241 catch_location: catch_location.into(),
242 };
243 event_call!("jvmti_event_exception_handler", exception, event)
244 }
245}
246
247#[no_mangle]
248pub extern "C" fn jvmti_event_exception_catch_handler(jvmti_env: *mut sys::jvmtiEnv,
249 jni_env: *mut sys::JNIEnv,
250 thread: jthread,
251 method: jmethodID,
252 location: jlocation,
253 exception: jobject) {
254 unsafe {
255 let jvmti = jvmti!(jvmti_env);
256 let jni = jni!(jni_env);
257 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
258 let event = ExceptionCatchEvent {
259 jvmti: &jvmti_facade,
260 jni: &jni,
261 thread: thread.into(),
262 method: method.into(),
263 location,
264 exception: exception.into(),
265 };
266 event_call!("jvmti_event_exception_catch_handler", exception_catch, event)
267 }
268}
269
270#[no_mangle]
271pub extern "C" fn jvmti_event_field_access_handler(jvmti_env: *mut sys::jvmtiEnv,
272 jni_env: *mut sys::JNIEnv,
273 thread: jthread,
274 method: jmethodID,
275 location: jlocation,
276 field_klass: jclass,
277 object: jobject,
278 field: jfieldID) {
279 unsafe {
280 let jvmti = jvmti!(jvmti_env);
281 let jni = jni!(jni_env);
282 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
283 let event = FieldAccessEvent {
284 jvmti: &jvmti_facade,
285 jni: &jni,
286 thread: thread.into(),
287 method: method.into(),
288 location,
289 field_klass: field_klass.into(),
290 object: object.into(),
291 field: field.into(),
292 };
293 event_call!("jvmti_event_field_access_handler", field_access, event)
294 }
295}
296
297#[no_mangle]
298pub extern "C" fn jvmti_event_field_modification_handler(jvmti_env: *mut sys::jvmtiEnv,
299 jni_env: *mut sys::JNIEnv,
300 thread: jthread,
301 method: jmethodID,
302 location: jlocation,
303 field_klass: jclass,
304 object: jobject,
305 field: jfieldID,
306 signature_type: c_char,
307 new_value: jvalue) {
308 unsafe {
309 let jvmti = jvmti!(jvmti_env);
310 let jni = jni!(jni_env);
311 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
312 let event = FieldModificationEvent {
313 jvmti: &jvmti_facade,
314 jni: &jni,
315 thread: thread.into(),
316 method: method.into(),
317 location,
318 field_klass: field_klass.into(),
319 object: object.into(),
320 field: field.into(),
321 signature_type,
322 new_value,
323 };
324 event_call!("jvmti_event_field_modification_handler", field_modification, event)
325 }
326}
327
328#[no_mangle]
329pub extern "C" fn jvmti_event_frame_pop_handler(jvmti_env: *mut sys::jvmtiEnv,
330 jni_env: *mut sys::JNIEnv,
331 thread: jthread,
332 method: jmethodID,
333 was_popped_by_exception: jboolean) {
334 unsafe {
335 let jvmti = jvmti!(jvmti_env);
336 let jni = jni!(jni_env);
337 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
338 let event = FramePopEvent {
339 jvmti: &jvmti_facade,
340 jni: &jni,
341 thread: thread.into(),
342 method: method.into(),
343 was_popped_by_exception: to_bool(was_popped_by_exception),
344 };
345 event_call!("jvmti_event_frame_pop_handler", frame_pop, event)
346 }
347}
348
349#[no_mangle]
350pub extern "C" fn jvmti_event_garbage_collection_finish_handler(jvmti_env: *mut sys::jvmtiEnv) {
351 unsafe {
352 let jvmti = jvmti!(jvmti_env);
353 let event = GarbageCollectionFinishEvent {
354 jvmti: &jvmti,
355 };
356 event_call!("jvmti_event_garbage_collection_finish_handler", garbage_collection_finish, event)
357 }
358}
359
360#[no_mangle]
361pub extern "C" fn jvmti_event_garbage_collection_start_handler(jvmti_env: *mut sys::jvmtiEnv) {
362 unsafe {
363 let jvmti = jvmti!(jvmti_env);
364 let event = GarbageCollectionStartEvent {
365 jvmti: &jvmti,
366 };
367 event_call!("jvmti_event_garbage_collection_start_handler", garbage_collection_start, event)
368 }
369}
370
371#[no_mangle]
372pub extern "C" fn jvmti_event_method_entry_handler(jvmti_env: *mut sys::jvmtiEnv,
373 jni_env: *mut sys::JNIEnv,
374 thread: jthread,
375 method: jmethodID) {
376 unsafe {
377 let jvmti = jvmti!(jvmti_env);
378 let jni = jni!(jni_env);
379 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
380 let event = MethodEntryEvent {
381 jvmti: &jvmti_facade,
382 jni: &jni,
383 thread: thread.into(),
384 method: method.into(),
385 };
386 event_call!("jvmti_event_method_entry_handler", method_entry, event)
387 }
388}
389
390#[no_mangle]
391pub extern "C" fn jvmti_event_method_exit_handler(jvmti_env: *mut sys::jvmtiEnv,
392 jni_env: *mut sys::JNIEnv,
393 thread: jthread,
394 method: jmethodID,
395 was_popped_by_exception: jboolean,
396 return_value: jvalue) {
397 unsafe {
398 let jvmti = jvmti!(jvmti_env);
399 let jni = jni!(jni_env);
400 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
401 let event = MethodExitEvent {
402 jvmti: &jvmti_facade,
403 jni: &jni,
404 thread: thread.into(),
405 method: method.into(),
406 was_popped_by_exception: to_bool(was_popped_by_exception),
407 return_value,
408 };
409 event_call!("jvmti_event_method_exit_handler", method_exit, event)
410 }
411}
412
413#[no_mangle]
414pub extern "C" fn jvmti_event_monitor_contended_enter_handler(jvmti_env: *mut sys::jvmtiEnv,
415 jni_env: *mut sys::JNIEnv,
416 thread: jthread,
417 object: jobject) {
418 unsafe {
419 let jvmti = jvmti!(jvmti_env);
420 let jni = jni!(jni_env);
421 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
422 let event = MonitorContendedEnterEvent {
423 jvmti: &jvmti_facade,
424 jni: &jni,
425 thread: thread.into(),
426 object: object.into(),
427 };
428 event_call!("jvmti_event_monitor_contended_enter_handler", monitor_contended_enter, event)
429 }
430}
431
432#[no_mangle]
433pub extern "C" fn jvmti_event_monitor_contended_entered_handler(jvmti_env: *mut sys::jvmtiEnv,
434 jni_env: *mut sys::JNIEnv,
435 thread: jthread,
436 object: jobject) {
437 unsafe {
438 let jvmti = jvmti!(jvmti_env);
439 let jni = jni!(jni_env);
440 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
441 let event = MonitorContendedEnteredEvent {
442 jvmti: &jvmti_facade,
443 jni: &jni,
444 thread: thread.into(),
445 object: object.into(),
446 };
447 event_call!("jvmti_event_monitor_contended_entered_handler", monitor_contended_entered, event)
448 }
449}
450
451#[no_mangle]
452pub extern "C" fn jvmti_event_monitor_wait_handler(jvmti_env: *mut sys::jvmtiEnv,
453 jni_env: *mut sys::JNIEnv,
454 thread: jthread,
455 object: jobject,
456 timeout: jlong) {
457 unsafe {
458 let jvmti = jvmti!(jvmti_env);
459 let jni = jni!(jni_env);
460 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
461 let event = MonitorWaitEvent {
462 jvmti: &jvmti_facade,
463 jni: &jni,
464 thread: thread.into(),
465 object: object.into(),
466 timeout,
467 };
468 event_call!("jvmti_event_monitor_wait_handler", monitor_wait, event)
469 }
470}
471
472#[no_mangle]
473pub extern "C" fn jvmti_event_monitor_waited_handler(jvmti_env: *mut sys::jvmtiEnv,
474 jni_env: *mut sys::JNIEnv,
475 thread: jthread,
476 object: jobject,
477 timed_out: jboolean) {
478 unsafe {
479 let jvmti = jvmti!(jvmti_env);
480 let jni = jni!(jni_env);
481 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
482 let event = MonitorWaitedEvent {
483 jvmti: &jvmti_facade,
484 jni: &jni,
485 thread: thread.into(),
486 object: object.into(),
487 timed_out: to_bool(timed_out),
488 };
489 event_call!("jvmti_event_monitor_waited_handler", monitor_waited, event)
490 }
491}
492
493#[no_mangle]
494pub extern "C" fn jvmti_event_native_method_bind_handler(jvmti_env: *mut sys::jvmtiEnv,
495 jni_env: *mut sys::JNIEnv,
496 thread: jthread,
497 method: jmethodID,
498 address: *mut c_void,
499 new_address_ptr: *mut *mut c_void) {
500 unsafe {
501 let jvmti = jvmti!(jvmti_env);
502 let jni = jni!(jni_env);
503 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
504 let event = NativeMethodBindEvent {
505 jvmti: &jvmti_facade,
506 jni: &jni,
507 thread: thread.into(),
508 method: method.into(),
509 address,
510 new_address_ptr,
511 };
512 event_call!("jvmti_event_native_method_bind_handler", native_method_bind, event)
513 }
514}
515
516#[no_mangle]
517pub extern "C" fn jvmti_event_object_free_handler(jvmti_env: *mut sys::jvmtiEnv, tag: jlong) {
518 unsafe {
519 let jvmti = jvmti!(jvmti_env);
520 let event = ObjectFreeEvent {
521 jvmti: &jvmti,
522 tag,
523 };
524 event_call!("jvmti_event_object_free_handler", object_free, event)
525 }
526}
527
528#[no_mangle]
529pub extern "C" fn jvmti_event_resource_exhausted_handler(jvmti_env: *mut sys::jvmtiEnv,
530 jni_env: *mut sys::JNIEnv,
531 flags: jint,
532 reserved: *const c_void,
533 description: *const c_char) {
534 unsafe {
535 let jvmti = jvmti!(jvmti_env);
536 let jni = jni!(jni_env);
537 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
538 let event = ResourceExhaustedEvent {
539 jvmti: &jvmti_facade,
540 jni: &jni,
541 flags,
542 reserved,
543 description: stringify(description),
544 };
545 event_call!("jvmti_event_resource_exhausted_handler", resource_exhausted, event)
546 }
547}
548
549#[no_mangle]
550pub extern "C" fn jvmti_event_single_step_handler(jvmti_env: *mut sys::jvmtiEnv,
551 jni_env: *mut sys::JNIEnv,
552 thread: jthread,
553 method: jmethodID,
554 location: jlocation) {
555 unsafe {
556 let jvmti = jvmti!(jvmti_env);
557 let jni = jni!(jni_env);
558 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
559 let event = SingleStepEvent {
560 jvmti: &jvmti_facade,
561 jni: &jni,
562 thread: thread.into(),
563 method: method.into(),
564 location,
565 };
566 event_call!("jvmti_event_single_step_handler", single_step, event)
567 }
568}
569
570#[no_mangle]
571pub extern "C" fn jvmti_event_thread_end_handler(jvmti_env: *mut sys::jvmtiEnv,
572 jni_env: *mut sys::JNIEnv,
573 thread: jthread) {
574 unsafe {
575 let jvmti = jvmti!(jvmti_env);
576 let jni = jni!(jni_env);
577 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
578 let event = ThreadEndEvent {
579 jvmti: &jvmti_facade,
580 jni: &jni,
581 thread: thread.into(),
582 };
583 event_call!("jvmti_event_thread_end_handler", thread_end, event)
584 }
585}
586
587#[no_mangle]
588pub extern "C" fn jvmti_event_thread_start_handler(jvmti_env: *mut sys::jvmtiEnv,
589 jni_env: *mut sys::JNIEnv,
590 thread: jthread) {
591 unsafe {
592 let jvmti = jvmti!(jvmti_env);
593 let jni = jni!(jni_env);
594 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
595 let event = ThreadStartEvent {
596 jvmti: &jvmti_facade,
597 jni: &jni,
598 thread: thread.into(),
599 };
600 event_call!("jvmti_event_thread_start_handler", thread_start, event)
601 }
602}
603
604#[no_mangle]
605pub extern "C" fn jvmti_event_vm_death_handler(jvmti_env: *mut sys::jvmtiEnv,
606 jni_env: *mut sys::JNIEnv) {
607 unsafe {
608 let jvmti = jvmti!(jvmti_env);
609 let jni = jni!(jni_env);
610 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
611 let event = VmDeathEvent {
612 jvmti: &jvmti_facade,
613 jni: &jni,
614 };
615 event_call!("jvmti_event_vm_death_handler", vm_death, event)
616 }
617}
618
619#[no_mangle]
620pub extern "C" fn jvmti_event_vm_init_handler(jvmti_env: *mut sys::jvmtiEnv,
621 jni_env: *mut sys::JNIEnv,
622 thread: jthread) {
623 unsafe {
624 let jvmti = jvmti!(jvmti_env);
625 let jni = jni!(jni_env);
626 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
627 let event = VmInitEvent {
628 jvmti: &jvmti_facade,
629 jni: &jni,
630 thread: thread.into(),
631 };
632 event_call!("jvmti_event_vm_init_handler", vm_init, event)
633 }
634}
635
636#[no_mangle]
637pub extern "C" fn jvmti_event_vm_object_alloc_handler(jvmti_env: *mut sys::jvmtiEnv,
638 jni_env: *mut sys::JNIEnv,
639 thread: jthread,
640 object: jobject,
641 object_klass: jclass,
642 size: jlong) {
643 unsafe {
644 let jvmti = jvmti!(jvmti_env);
645 let jni = jni!(jni_env);
646 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
647 let event = VmObjectAllocEvent {
648 jvmti: &jvmti_facade,
649 jni: &jni,
650 thread: thread.into(),
651 object: object.into(),
652 object_klass: object_klass.into(),
653 size,
654 };
655 event_call!("jvmti_event_vm_object_alloc_handler", vm_object_alloc, event)
656 }
657}
658
659#[no_mangle]
660pub extern "C" fn jvmti_event_vm_start_handler(jvmti_env: *mut sys::jvmtiEnv,
661 jni_env: *mut sys::JNIEnv) {
662 unsafe {
663 let jvmti = jvmti!(jvmti_env);
664 let jni = jni!(jni_env);
665 let jvmti_facade = JVMTIFacadeEnv::new(&jvmti, &jni);
666 let event = VmStartEvent {
667 jvmti: &jvmti_facade,
668 jni: &jni,
669 };
670 event_call!("jvmti_event_vm_start_handler", vm_start, event)
671 }
672}