| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * @author Valentin Al. Sitnick |
| * |
| */ |
| |
| #include "utils.h" |
| |
| typedef struct |
| { |
| jvmtiError code; |
| const char* text; |
| |
| } jvmti_error_text; |
| |
| static jvmti_error_text jvmti_errors[] = |
| { |
| {JVMTI_ERROR_NONE, "JVMTI_ERROR_NONE"}, |
| {JVMTI_ERROR_NULL_POINTER, "JVMTI_ERROR_NULL_POINTER"}, |
| {JVMTI_ERROR_OUT_OF_MEMORY, "JVMTI_ERROR_OUT_OF_MEMORY"}, |
| {JVMTI_ERROR_ACCESS_DENIED, "JVMTI_ERROR_ACCESS_DENIED"}, |
| {JVMTI_ERROR_UNATTACHED_THREAD, "JVMTI_ERROR_UNATTACHED_THREAD"}, |
| {JVMTI_ERROR_INVALID_ENVIRONMENT, "JVMTI_ERROR_INVALID_ENVIRONMENT"}, |
| {JVMTI_ERROR_WRONG_PHASE, "JVMTI_ERROR_WRONG_PHASE"}, |
| {JVMTI_ERROR_INTERNAL, "JVMTI_ERROR_INTERNAL"}, |
| {JVMTI_ERROR_NOT_AVAILABLE, "JVMTI_ERROR_NOT_AVAILABLE"}, |
| {JVMTI_ERROR_MUST_POSSESS_CAPABILITY, "JVMTI_ERROR_MUST_POSSESS_CAPABILITY"}, |
| }; |
| |
| const char* get_jvmti_eror_text(jvmtiError code) |
| { |
| for (unsigned int i = 0; i < sizeof(jvmti_errors) / sizeof(jvmti_errors[0]); i++) |
| { |
| if (jvmti_errors[i].code == code) |
| return jvmti_errors[i].text; |
| } |
| |
| return "Unknown jvmti error"; |
| } |
| |
| /* *********************************************************************** */ |
| |
| /* |
| * Function for outputting names of current states of thread as a string. |
| */ |
| void thread_state_output_as_string(long state) |
| { |
| bool pipe = false; |
| if (state & JVMTI_THREAD_STATE_ALIVE ) |
| { |
| fprintf(stderr, " _ALIVE "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_TERMINATED ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _TERMINATED "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_RUNNABLE ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _RUNNABLE "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_BLOCKED_ON_MONITOR_ENTER ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _BLOCKED_ON_MONITOR_ENTER "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_WAITING ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _WAITING "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_WAITING_INDEFINITELY ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _WAITING_INDEFINITELY "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_WAITING_WITH_TIMEOUT ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _WAITING_WITH_TIMEOUT "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_SLEEPING ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _SLEEPING "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_IN_OBJECT_WAIT ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _IN_OBJECT_WAIT "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_PARKED ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _PARKED "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_SUSPENDED ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _SUSPENDED "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_INTERRUPTED ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _INTERRUPTED "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_IN_NATIVE ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _IN_NATIVE "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_VENDOR_1 ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _VENDOR_1 "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_VENDOR_2 ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _VENDOR_2 "); |
| pipe = true; |
| } |
| |
| if (state & JVMTI_THREAD_STATE_VENDOR_3 ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _VENDOR_3 "); |
| pipe = true; |
| } |
| return; |
| } |
| |
| /* |
| * Function for outputting names of current statuses of class as a string. |
| */ |
| void class_status_output_as_string(long status) |
| { |
| bool pipe = false; |
| if ( status & JVMTI_CLASS_STATUS_VERIFIED ) |
| { |
| fprintf(stderr, " _VERIFIED "); |
| pipe = true; |
| } |
| |
| if ( status & JVMTI_CLASS_STATUS_PREPARED ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _PREPARED "); |
| pipe = true; |
| } |
| |
| if ( status & JVMTI_CLASS_STATUS_INITIALIZED ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _INITIALIZED "); |
| pipe = true; |
| } |
| |
| if ( status & JVMTI_CLASS_STATUS_ERROR ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _ERROR "); |
| pipe = true; |
| } |
| |
| if ( status & JVMTI_CLASS_STATUS_ARRAY ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _ARRAY "); |
| pipe = true; |
| } |
| |
| if ( status & JVMTI_CLASS_STATUS_PRIMITIVE ) |
| { |
| if (pipe) fprintf(stderr, "|"); |
| fprintf(stderr, " _PRIMITIVE "); |
| pipe = true; |
| } |
| |
| return; |
| } |
| |
| /* |
| * Function for comparing of 2 capabilities structure and output result |
| * of this operation. |
| */ |
| int cmp_caps_and_output_results(jvmtiCapabilities c1, |
| jvmtiCapabilities c2, const char* name1, const char* name2) |
| { |
| int diff = 0; |
| |
| if (c1.can_tag_objects |
| != c2.can_tag_objects) |
| { |
| fprintf(stderr, "\t\tDIFF: can_tag_objects %d in %s and %d in %s\n", |
| c1.can_tag_objects, name1, c2.can_tag_objects, name2); |
| diff++; |
| } |
| if (c1.can_generate_field_modification_events |
| != c2.can_generate_field_modification_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_field_modification_events %d in %s and %d in %s\n", |
| c1.can_generate_field_modification_events, name1, c2.can_generate_field_modification_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_field_access_events |
| != c2.can_generate_field_access_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_field_access_events %d in %s and %d in %s\n", |
| c1.can_generate_field_access_events, name1, c2.can_generate_field_access_events, name2); |
| diff++; |
| } |
| if (c1.can_get_bytecodes |
| != c2.can_get_bytecodes) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_bytecodes %d in %s and %d in %s\n", |
| c1.can_get_bytecodes, name1, c2.can_get_bytecodes, name2); |
| diff++; |
| } |
| if (c1.can_get_synthetic_attribute |
| != c2.can_get_synthetic_attribute) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_synthetic_attribute in %d in %s and %d in %s\n", |
| c1.can_get_synthetic_attribute, name1, c2.can_get_synthetic_attribute, name2); |
| diff++; |
| } |
| if (c1.can_get_owned_monitor_info |
| != c2.can_get_owned_monitor_info) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_owned_monitor_info in %d in %s and %d in %s\n", |
| c1.can_get_owned_monitor_info, name1, c2.can_get_owned_monitor_info, name2); |
| diff++; |
| } |
| if (c1.can_get_current_contended_monitor |
| != c2.can_get_current_contended_monitor) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_current_contended_monitor %d in %s and %d in %s\n", |
| c1.can_get_current_contended_monitor, name1, c2.can_get_current_contended_monitor, name2); |
| diff++; |
| } |
| if (c1.can_get_monitor_info |
| != c2.can_get_monitor_info) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_monitor_info %d in %s and %d in %s\n", |
| c1.can_get_monitor_info, name1, c2.can_get_monitor_info, name2); |
| diff++; |
| } |
| if (c1.can_pop_frame |
| != c2.can_pop_frame) |
| { |
| fprintf(stderr, "\t\tDIFF: can_pop_frame %d in %s and %d in %s\n", |
| c1.can_pop_frame, name1, c2.can_pop_frame, name2); |
| diff++; |
| } |
| if (c1.can_redefine_classes |
| != c2.can_redefine_classes) |
| { |
| fprintf(stderr, "\t\tDIFF: can_redefine_classes %d in %s and %d in %s\n", |
| c1.can_redefine_classes, name1, c2.can_redefine_classes, name2); |
| diff++; |
| } |
| if (c1.can_signal_thread |
| != c2.can_signal_thread) |
| { |
| fprintf(stderr, "\t\tDIFF: can_signal_thread %d in %s and %d in %s\n", |
| c1.can_signal_thread, name1, c2.can_signal_thread, name2); |
| diff++; |
| } |
| if (c1.can_get_source_file_name |
| != c2.can_get_source_file_name) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_source_file_name %d in %s and %d in %s\n", |
| c1.can_get_source_file_name, name1, c2.can_get_source_file_name, name2); |
| diff++; |
| } |
| if (c1.can_get_line_numbers |
| != c2.can_get_line_numbers) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_line_numbers %d in %s and %d in %s\n", |
| c1.can_get_line_numbers, name1, c2.can_get_line_numbers, name2); |
| diff++; |
| } |
| if (c1.can_get_source_debug_extension |
| != c2.can_get_source_debug_extension) |
| { |
| fprintf(stderr, "\t\tDIFF: can_get_source_debug_extension %d in %s and %d in %s\n", |
| c1.can_get_source_debug_extension, name1, c2.can_get_source_debug_extension, name2); |
| diff++; |
| } |
| if (c1.can_access_local_variables |
| != c2.can_access_local_variables) |
| { |
| fprintf(stderr, "\t\tDIFF: can_access_local_variables %d in %s and %d in %s\n", |
| c1.can_access_local_variables, name1, c2.can_access_local_variables, name2); |
| diff++; |
| } |
| if (c1.can_maintain_original_method_order |
| != c2.can_maintain_original_method_order) |
| { |
| fprintf(stderr, "\t\tDIFF: can_maintain_original_method_order %d in %s and %d in %s\n", |
| c1.can_maintain_original_method_order, name1, c2.can_maintain_original_method_order, name2); |
| diff++; |
| } |
| if (c1.can_generate_single_step_events |
| != c2.can_generate_single_step_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_single_step_events %d in %s and %d in %s\n", |
| c1.can_generate_single_step_events, name1, c2.can_generate_single_step_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_exception_events |
| != c2.can_generate_exception_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_exception_events %d in %s and %d in %s\n", |
| c1.can_generate_exception_events, name1, c2.can_generate_exception_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_frame_pop_events |
| != c2.can_generate_frame_pop_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_frame_pop_events %d in %s and %d in %s\n", |
| c1.can_generate_frame_pop_events, name1, c2.can_generate_frame_pop_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_breakpoint_events |
| != c2.can_generate_breakpoint_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_breakpoint_events %d in %s and %d in %s\n", |
| c1.can_generate_breakpoint_events, name1, c2.can_generate_breakpoint_events, name2); |
| diff++; |
| } |
| if (c1.can_suspend |
| != c2.can_suspend) |
| { |
| fprintf(stderr, "\t\tDIFF: can_suspend %d in %s and %d in %s\n", |
| c1.can_suspend, name1, c2.can_suspend, name2); |
| diff++; |
| } |
| if (c1.can_redefine_any_class |
| != c2.can_redefine_any_class) |
| { |
| fprintf(stderr, "\t\tDIFF: can_redefine_any_class %d in %s and %d in %s\n", |
| c1.can_redefine_any_class, name1, c2.can_redefine_any_class, name2); |
| diff++; |
| } |
| if (c1.can_get_current_thread_cpu_time |
| != c2.can_get_current_thread_cpu_time) |
| { |
| fprintf(stderr, "\t\tDIFF: can_tag_objects %d in %s and %d in %s\n", |
| c1.can_tag_objects, name1, c2.can_tag_objects, name2); |
| diff++; |
| } |
| if (c1.can_get_thread_cpu_time |
| != c2.can_get_thread_cpu_time) |
| { |
| fprintf(stderr, "\t\tDIFF: can_tag_objects %d in %s and %d in %s\n", |
| c1.can_tag_objects, name1, c2.can_tag_objects, name2); |
| diff++; |
| } |
| if (c1.can_generate_method_entry_events |
| != c2.can_generate_method_entry_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_method_entry_events %d in %s and %d in %s\n", |
| c1.can_generate_method_entry_events, name1, c2.can_generate_method_entry_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_method_exit_events |
| != c2.can_generate_method_exit_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_method_exit_events %d in %s and %d in %s\n", |
| c1.can_generate_method_exit_events, name1, c2.can_generate_method_exit_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_all_class_hook_events |
| != c2.can_generate_all_class_hook_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_all_class_hook_events %d in %s and %d in %s\n", |
| c1.can_generate_all_class_hook_events, name1, c2.can_generate_all_class_hook_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_compiled_method_load_events |
| != c2.can_generate_compiled_method_load_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_compiled_method_load_events %d in %s and %d in %s\n", |
| c1.can_generate_compiled_method_load_events, name1, c2.can_generate_compiled_method_load_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_monitor_events |
| != c2.can_generate_monitor_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_monitor_events %d in %s and %d in %s\n", |
| c1.can_generate_monitor_events, name1, c2.can_generate_monitor_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_vm_object_alloc_events |
| != c2.can_generate_vm_object_alloc_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_vm_object_alloc_events %d in %s and %d in %s\n", |
| c1.can_generate_vm_object_alloc_events, name1, c2.can_generate_vm_object_alloc_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_native_method_bind_events |
| != c2.can_generate_native_method_bind_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_native_method_bind_events %d in %s and %d in %s\n", |
| c1.can_generate_native_method_bind_events, name1, c2.can_generate_native_method_bind_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_garbage_collection_events |
| != c2.can_generate_garbage_collection_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_garbage_collection_events %d in %s and %d in %s\n", |
| c1.can_generate_garbage_collection_events, name1, c2.can_generate_garbage_collection_events, name2); |
| diff++; |
| } |
| if (c1.can_generate_object_free_events |
| != c2.can_generate_object_free_events) |
| { |
| fprintf(stderr, "\t\tDIFF: can_generate_object_free_events %d in %s and %d in %s\n", |
| c1.can_generate_object_free_events, name1, c2.can_generate_object_free_events, name2); |
| diff++; |
| } |
| |
| if (0 != diff) |
| { |
| fprintf(stderr, "\t\tDIFF: capabilities %s and %s has %d differences\n", name1, name2, diff); |
| } |
| else |
| { |
| fprintf(stderr, "\t\tDIFF: capabilities %s and %s are identical\n", name1, name2); |
| } |
| |
| return diff; |
| } |
| |
| void print_capabilities(jvmtiCapabilities c, const char* name) |
| { |
| fprintf(stderr, "\t\t%s.can_tag_objects = %d\n", |
| name, c.can_tag_objects); |
| fprintf(stderr, "\t\t%s.can_generate_field_modification_events = %d\n", |
| name, c.can_generate_field_modification_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_field_access_events = %d\n", |
| name, c.can_generate_field_access_events); |
| |
| fprintf(stderr, "\t\t%s.can_get_bytecodes = %d\n", |
| name, c.can_get_bytecodes); |
| |
| fprintf(stderr, "\t\t%s.can_get_synthetic_attribute = %d\n", |
| name, c.can_get_synthetic_attribute); |
| |
| fprintf(stderr, "\t\t%s.can_get_owned_monitor_info = %d\n", |
| name, c.can_get_owned_monitor_info); |
| |
| fprintf(stderr, "\t\t%s.can_get_current_contended_monitor = %d\n", |
| name, c.can_get_current_contended_monitor); |
| |
| fprintf(stderr, "\t\t%s.can_get_monitor_info = %d\n", |
| name, c.can_get_monitor_info); |
| |
| fprintf(stderr, "\t\t%s.can_pop_frame = %d\n", |
| name, c.can_pop_frame); |
| |
| fprintf(stderr, "\t\t%s.can_redefine_classes = %d\n", |
| name, c.can_redefine_classes); |
| |
| fprintf(stderr, "\t\t%s.can_signal_thread = %d\n", |
| name, c.can_signal_thread); |
| |
| fprintf(stderr, "\t\t%s.can_get_source_file_name = %d\n", |
| name, c.can_get_source_file_name); |
| |
| fprintf(stderr, "\t\t%s.can_get_line_numbers = %d\n", |
| name, c.can_get_line_numbers); |
| |
| fprintf(stderr, "\t\t%s.can_get_source_debug_extension = %d\n", |
| name, c.can_get_source_debug_extension); |
| |
| fprintf(stderr, "\t\t%s.can_access_local_variables = %d\n", |
| name, c.can_access_local_variables); |
| |
| fprintf(stderr, "\t\t%s.can_maintain_original_method_order = %d\n", |
| name, c.can_maintain_original_method_order); |
| |
| fprintf(stderr, "\t\t%s.can_generate_single_step_events = %d\n", |
| name, c.can_generate_single_step_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_exception_events = %d\n", |
| name, c.can_generate_exception_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_frame_pop_events = %d\n", |
| name, c.can_generate_frame_pop_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_breakpoint_events = %d\n", |
| name, c.can_generate_breakpoint_events); |
| |
| fprintf(stderr, "\t\t%s.can_suspend = %d\n", |
| name, c.can_suspend); |
| |
| fprintf(stderr, "\t\t%s.can_redefine_any_class = %d\n", |
| name, c.can_redefine_any_class); |
| |
| fprintf(stderr, "\t\t%s.can_tag_objects = %d\n", |
| name, c.can_tag_objects); |
| |
| fprintf(stderr, "\t\t%s.can_tag_objects = %d\n", |
| name, c.can_tag_objects); |
| |
| fprintf(stderr, "\t\t%s.can_generate_method_entry_events = %d\n", |
| name, c.can_generate_method_entry_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_method_exit_events = %d\n", |
| name, c.can_generate_method_exit_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_all_class_hook_events = %d\n", |
| name, c.can_generate_all_class_hook_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_compiled_method_load_events = %d\n", |
| name, c.can_generate_compiled_method_load_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_monitor_events = %d\n", |
| name, c.can_generate_monitor_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_vm_object_alloc_events = %d\n", |
| name, c.can_generate_vm_object_alloc_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_native_method_bind_events = %d\n", |
| name, c.can_generate_native_method_bind_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_garbage_collection_events = %d\n", |
| name, c.can_generate_garbage_collection_events); |
| |
| fprintf(stderr, "\t\t%s.can_generate_object_free_events = %d\n", |
| name, c.can_generate_object_free_events); |
| } |
| |
| |
| /* |
| * Function for making ZERO capabilities |
| */ |
| void make_caps_zero(jvmtiCapabilities* c1) |
| { |
| memset(c1, 0, sizeof(jvmtiCapabilities)); |
| |
| return; |
| } |
| |
| /* |
| * Function for making SET capabilities |
| */ |
| void make_caps_set_all(jvmtiCapabilities* c1) |
| { |
| memset(c1, 0xff, sizeof(jvmtiCapabilities)); |
| |
| return; |
| } |
| |
| /* |
| * Check Phase |
| * 1. special phase parameter is |
| * 0 - any phases (no check) |
| * 1 - ONLOAD only |
| * 2 - ONLOAD & LIVE |
| * 3 - START & LIVE |
| * 4 - LIVE only |
| */ |
| |
| bool check_phase_debug(jvmtiEnv* jvmti_env, int phase_param, bool is_debug) |
| { |
| jvmtiPhase phase; |
| jvmtiError result = jvmti_env->GetPhase(&phase); |
| |
| if (is_debug) |
| { |
| fprintf(stderr, "\tnative: GetPhase result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: current phase is %d (must be 4 (LIVE-phase)) \n", phase); |
| } |
| |
| if (result != JVMTI_ERROR_NONE) return false; |
| |
| if (phase_param) |
| { |
| if (((phase_param == 1) && (phase == JVMTI_PHASE_ONLOAD)) || |
| ((phase_param == 2) && (phase == JVMTI_PHASE_ONLOAD) && (phase == JVMTI_PHASE_LIVE)) || |
| ((phase_param == 3) && (phase == JVMTI_PHASE_START) && (phase == JVMTI_PHASE_LIVE)) || |
| ((phase_param == 4) && (phase == JVMTI_PHASE_LIVE))) return true; |
| else |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool check_phase_and_method_debug(jvmtiEnv* jvmti_env, jmethodID method, int phase_param, |
| const char* exp_name, bool is_debug) |
| { |
| char* name; |
| char* signature; |
| char* generic; |
| |
| if (!check_phase_debug(jvmti_env, phase_param, is_debug)) |
| return false; |
| |
| jvmtiError result = jvmti_env->GetMethodName(method, &name, &signature, &generic); |
| |
| if (is_debug) |
| { |
| fprintf(stderr, "\tnative: GetMethodName result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: method name is %s \n", name); |
| fprintf(stderr, "\tnative: signature name is %s \n", signature); |
| fprintf(stderr, "\tnative: generic name is %s \n", generic); |
| fflush(stderr); |
| } |
| |
| if (result != JVMTI_ERROR_NONE) return false; |
| |
| if (strcmp(name, exp_name)) |
| return false; |
| else |
| return true; |
| } |
| |
| bool check_phase_and_thread_debug(jvmtiEnv* jvmti_env, jthread thread, int phase_param, |
| const char* exp_name, bool is_debug) |
| { |
| jvmtiThreadInfo tinfo; |
| |
| if (!check_phase_debug(jvmti_env, phase_param, is_debug)) |
| return false; |
| |
| jvmtiError result = jvmti_env->GetThreadInfo(thread, &tinfo); |
| if (is_debug) |
| { |
| fprintf(stderr, "\tnative: GetThreadInfo result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: current thread name is %s (must be zero) \n", tinfo.name); |
| } |
| |
| if (strcmp(tinfo.name, exp_name) || (result != JVMTI_ERROR_NONE)) |
| return false; |
| else |
| return true; |
| } |
| /* |
| jthread create_not_alive_thread(JNIEnv* jni_env, jvmtiEnv* jvmti_env) |
| { |
| jclass clazz; |
| jmethodID mid; |
| jthread thread; |
| |
| fprintf(stderr, "\tnative: JNI: funcs start\n"); |
| |
| clazz = jni_env->FindClass("java/lang/Thread"); |
| if (!clazz) return NULL; |
| fprintf(stderr, "\tnative: JNI: FindClass - Ok\n"); |
| |
| mid = jni_env->GetMethodID(clazz, "<init>", "()V"); |
| if (!mid) return NULL; |
| fprintf(stderr, "\tnative: JNI: GetMethodID - Ok\n"); |
| |
| thread = jni_env->NewObject(clazz, mid, "native_agent_thread"); |
| if (!thread) return NULL; |
| fprintf(stderr, "\tnative: JNI: NewObject - Ok\n"); |
| |
| return thread; |
| } |
| */ |
| bool is_needed_field_found(jvmtiEnv* jvmti_env, const char* filename, const char* fieldname, |
| jclass* myclass, jfieldID* myfield, bool is_debug) |
| { |
| |
| jint class_count; |
| jclass* classes; |
| jclass my_class = NULL; |
| char* source_name; |
| jint field_count; |
| jfieldID* fields; |
| jfieldID my_field = NULL; |
| |
| jvmtiError result = jvmti_env->GetLoadedClasses(&class_count, &classes); |
| fprintf(stderr, "\tnative: GetLoadedClasses result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: class_count is %d \n", class_count); |
| fprintf(stderr, "\tnative: classes is %p \n", classes); |
| fflush(stderr); |
| |
| if ( result != JVMTI_ERROR_NONE ) return false; |
| |
| for (int i = 0; i < class_count; i++) |
| { |
| result = jvmti_env->GetSourceFileName(classes[i], &source_name); |
| if (is_debug) |
| { |
| fprintf(stderr, "\tnative: GetSourceFileName result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: source_name is %s \n", source_name); |
| fprintf(stderr, "\tnative: classes is %p \n", classes); |
| fflush(stderr); |
| } |
| |
| if (result != JVMTI_ERROR_NONE) continue; |
| |
| if (!strcmp(source_name, filename)) |
| { |
| fprintf(stderr, "\tnative: GetSourceFileName result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: source_name is %s \n", source_name); |
| fprintf(stderr, "\tnative: classes is %p \n", classes); |
| fflush(stderr); |
| |
| my_class = classes[i]; |
| break; |
| } |
| } |
| |
| result = jvmti_env->GetClassFields(my_class, &field_count, &fields); |
| fprintf(stderr, "\tnative: GetClassFields result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: fields_ptr is %p \n", fields); |
| fprintf(stderr, "\tnative: field_count_ptr is %d \n", field_count); |
| fprintf(stderr, "\tnative: my_class is %p \n", my_class); |
| fflush(stderr); |
| |
| if ( result != JVMTI_ERROR_NONE ) return false; |
| |
| for (int j = 0; j < field_count; j++) |
| { |
| char* name; |
| char* signature; |
| char* generic; |
| |
| result = jvmti_env->GetFieldName(my_class, fields[j], &name, &signature, &generic); |
| if (is_debug) |
| { |
| fprintf(stderr, "\tnative: GetFieldName result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: classes is %p \n", my_class); |
| fprintf(stderr, "\tnative: fields_ptr[%d] is %p \n", j, fields[j]); |
| fprintf(stderr, "\tnative: field name is %s \n", name); |
| fprintf(stderr, "\tnative: field signature is %s \n", signature); |
| fprintf(stderr, "\tnative: field generic is %s \n", generic); |
| fflush(stderr); |
| } |
| if ( result != JVMTI_ERROR_NONE ) continue; |
| |
| if (!strcmp(name, fieldname)) |
| { |
| fprintf(stderr, "\tnative: GetFieldName result = %d (must be zero) \n", result); |
| fprintf(stderr, "\tnative: classes is %p \n", my_class); |
| fprintf(stderr, "\tnative: fields_ptr[%d] is %p \n", j, fields[j]); |
| fprintf(stderr, "\tnative: field name is %s \n", name); |
| fprintf(stderr, "\tnative: field signature is %s \n", signature); |
| fprintf(stderr, "\tnative: field generic is %s \n", generic); |
| fflush(stderr); |
| |
| my_field = fields[j]; |
| break; |
| } |
| } |
| |
| if (!my_class || !my_field) return false; |
| |
| *myclass = my_class; |
| *myfield = my_field; |
| |
| return true; |
| } |
| |
| jint func_for_Agent_OnLoad_JVMTI(JavaVM *vm, char *options, void *reserved, Callbacks* callbacks, |
| jvmtiEvent* events, jint size, const char* test_case_name, bool is_debug, jvmtiEnv** jvmti) |
| { |
| jvmtiEnv* jvmti_env; |
| jvmtiError result; |
| jvmtiCapabilities pc; |
| jvmtiEventCallbacks cb = {NULL}; |
| |
| //warning fix |
| int w_fix = sizeof(options); |
| w_fix += sizeof(reserved); |
| w_fix += sizeof (is_debug); |
| // |
| |
| /* Getting of jvmti environment */ |
| if (vm->GetEnv((void**)&jvmti_env, JVMTI_VERSION_1_0) != JNI_OK) |
| { |
| fprintf(stderr, "Failure of initialization of JVMTI environment"); |
| return JNI_ERR; |
| } |
| |
| *jvmti = jvmti_env; |
| |
| result = jvmti_env->GetPotentialCapabilities(&pc); |
| if (result != JVMTI_ERROR_NONE) |
| { |
| fprintf(stderr, "\n\tERROR during the getting of potential capabilities"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: GetPotentialCapabilities error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| bool mentry = false, mexit = false, fpopnot = false; |
| |
| for (jint mee_ind = 0; mee_ind < size; mee_ind++) |
| { |
| if (events[mee_ind] == JVMTI_EVENT_METHOD_ENTRY) |
| mentry = true; |
| if (events[mee_ind] == JVMTI_EVENT_METHOD_EXIT) |
| mexit = true; |
| if (events[mee_ind] == JVMTI_EVENT_FRAME_POP) |
| fpopnot = true; |
| } |
| |
| if (!mentry) |
| pc.can_generate_method_entry_events = 0; |
| if (!mexit) |
| pc.can_generate_method_exit_events = 0; |
| if (!fpopnot) |
| pc.can_generate_frame_pop_events = 0; |
| |
| result = jvmti_env->AddCapabilities(&pc); |
| if (result != JVMTI_ERROR_NONE) |
| { |
| fprintf(stderr, "\n\tERROR during the adding of all possible capabilities"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: AddCapabilities error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| memset(&cb, 0, sizeof(cb)); |
| |
| cb.SingleStep = callbacks->cbSingleStep; |
| cb.Breakpoint = callbacks->cbBreakpoint; |
| cb.FieldAccess = callbacks->cbFieldAccess; |
| cb.FieldModification = callbacks->cbFieldModification; |
| cb.FramePop = callbacks->cbFramePop; |
| cb.MethodEntry = callbacks->cbMethodEntry; |
| cb.MethodExit = callbacks->cbMethodExit; |
| cb.NativeMethodBind = callbacks->cbNativeMethodBind; |
| cb.Exception = callbacks->cbException; |
| cb.ExceptionCatch = callbacks->cbExceptionCatch; |
| cb.ThreadStart = callbacks->cbThreadStart; |
| cb.ThreadEnd = callbacks->cbThreadEnd; |
| cb.ClassLoad = callbacks->cbClassLoad; |
| cb.ClassPrepare = callbacks->cbClassPrepare; |
| cb.ClassFileLoadHook = callbacks->cbClassFileLoadHook; |
| cb.VMStart = callbacks->cbVMStart; |
| cb.VMInit = callbacks->cbVMInit; |
| cb.VMDeath = callbacks->cbVMDeath; |
| cb.CompiledMethodLoad = callbacks->cbCompiledMethodLoad; |
| cb.CompiledMethodUnload = callbacks->cbCompiledMethodUnload; |
| cb.DynamicCodeGenerated = callbacks->cbDynamicCodeGenerated; |
| cb.DataDumpRequest = callbacks->cbDataDumpRequest; |
| cb.MonitorContendedEnter = callbacks->cbMonitorContendedEnter; |
| cb.MonitorContendedEntered = callbacks->cbMonitorContendedEntered; |
| cb.MonitorWait = callbacks->cbMonitorWait; |
| cb.MonitorWaited = callbacks->cbMonitorWaited; |
| cb.VMObjectAlloc = callbacks->cbVMObjectAlloc; |
| cb.ObjectFree = callbacks->cbObjectFree; |
| cb.GarbageCollectionStart = callbacks->cbGarbageCollectionStart; |
| cb.GarbageCollectionFinish = callbacks->cbGarbageCollectionFinish; |
| |
| for (int j = 0; j < size; j++) |
| { |
| result = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, events[j], NULL); |
| |
| if (result == JVMTI_ERROR_NONE) continue; |
| |
| fprintf(stderr, "\n\tERROR during the adding of SetEventNotificationMode"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: SetEventNotificationMode error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| result = jvmti_env->SetEventCallbacks(&cb, sizeof(cb)); |
| |
| if (result != JVMTI_ERROR_NONE) |
| { |
| fprintf(stderr, "\n\tERROR during the adding of SetEventCallbacks"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: SetEventCallbacks error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| fprintf(stderr, "\n----------------------------------------------------"); |
| fprintf(stderr, "\ntest"); |
| fprintf(stderr, " %s ", test_case_name); |
| fprintf(stderr, "is started\n{\n"); |
| fflush(stderr); |
| |
| return JNI_OK; |
| } |
| |
| /* |
| * Universal agent function; |
| */ |
| jint func_for_Agent_OnLoad(JavaVM *vm, char *options, void *reserved, Callbacks* callbacks, |
| jvmtiEvent* events, jint size, const char* test_case_name, bool is_debug) |
| { |
| jvmtiEnv* jvmti_env; |
| jvmtiError result; |
| jvmtiCapabilities pc; |
| jvmtiEventCallbacks cb = {NULL}; |
| |
| //warning fix |
| int w_fix = sizeof(options); |
| w_fix += sizeof(reserved); |
| w_fix += sizeof (is_debug); |
| // |
| |
| /* Getting of jvmti environment */ |
| if (vm->GetEnv((void**)&jvmti_env, JVMTI_VERSION_1_0) != JNI_OK) |
| { |
| fprintf(stderr, "Failure of initialization of JVMTI environment"); |
| return JNI_ERR; |
| } |
| |
| result = jvmti_env->GetPotentialCapabilities(&pc); |
| if (result != JVMTI_ERROR_NONE) |
| { |
| fprintf(stderr, "\n\tERROR during the getting of potential capabilities"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: GetPotentialCapabilities error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| bool mentry = false, mexit = false, fpopnot = false; |
| |
| for (jint mee_ind = 0; mee_ind < size; mee_ind++) |
| { |
| if (events[mee_ind] == JVMTI_EVENT_METHOD_ENTRY) |
| mentry = true; |
| if (events[mee_ind] == JVMTI_EVENT_METHOD_EXIT) |
| mexit = true; |
| if (events[mee_ind] == JVMTI_EVENT_FRAME_POP) |
| fpopnot = true; |
| } |
| |
| if (!mentry) |
| pc.can_generate_method_entry_events = 0; |
| if (!mexit) |
| pc.can_generate_method_exit_events = 0; |
| if (!fpopnot) |
| pc.can_generate_frame_pop_events = 0; |
| |
| result = jvmti_env->AddCapabilities(&pc); |
| if (result != JVMTI_ERROR_NONE) |
| { |
| fprintf(stderr, "\n\tERROR during the adding of all possible capabilities"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: AddCapabilities error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| memset(&cb, 0, sizeof(cb)); |
| |
| cb.SingleStep = callbacks->cbSingleStep; |
| cb.Breakpoint = callbacks->cbBreakpoint; |
| cb.FieldAccess = callbacks->cbFieldAccess; |
| cb.FieldModification = callbacks->cbFieldModification; |
| cb.FramePop = callbacks->cbFramePop; |
| cb.MethodEntry = callbacks->cbMethodEntry; |
| cb.MethodExit = callbacks->cbMethodExit; |
| cb.NativeMethodBind = callbacks->cbNativeMethodBind; |
| cb.Exception = callbacks->cbException; |
| cb.ExceptionCatch = callbacks->cbExceptionCatch; |
| cb.ThreadStart = callbacks->cbThreadStart; |
| cb.ThreadEnd = callbacks->cbThreadEnd; |
| cb.ClassLoad = callbacks->cbClassLoad; |
| cb.ClassPrepare = callbacks->cbClassPrepare; |
| cb.ClassFileLoadHook = callbacks->cbClassFileLoadHook; |
| cb.VMStart = callbacks->cbVMStart; |
| cb.VMInit = callbacks->cbVMInit; |
| cb.VMDeath = callbacks->cbVMDeath; |
| cb.CompiledMethodLoad = callbacks->cbCompiledMethodLoad; |
| cb.CompiledMethodUnload = callbacks->cbCompiledMethodUnload; |
| cb.DynamicCodeGenerated = callbacks->cbDynamicCodeGenerated; |
| cb.DataDumpRequest = callbacks->cbDataDumpRequest; |
| cb.MonitorContendedEnter = callbacks->cbMonitorContendedEnter; |
| cb.MonitorContendedEntered = callbacks->cbMonitorContendedEntered; |
| cb.MonitorWait = callbacks->cbMonitorWait; |
| cb.MonitorWaited = callbacks->cbMonitorWaited; |
| cb.VMObjectAlloc = callbacks->cbVMObjectAlloc; |
| cb.ObjectFree = callbacks->cbObjectFree; |
| cb.GarbageCollectionStart = callbacks->cbGarbageCollectionStart; |
| cb.GarbageCollectionFinish = callbacks->cbGarbageCollectionFinish; |
| |
| for (int j = 0; j < size; j++) |
| { |
| result = jvmti_env->SetEventNotificationMode(JVMTI_ENABLE, events[j], NULL); |
| |
| if (result == JVMTI_ERROR_NONE) continue; |
| |
| fprintf(stderr, "\n\tERROR during the adding of SetEventNotificationMode"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: SetEventNotificationMode error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| result = jvmti_env->SetEventCallbacks(&cb, sizeof(cb)); |
| |
| if (result != JVMTI_ERROR_NONE) |
| { |
| fprintf(stderr, "\n\tERROR during the adding of SetEventCallbacks"); |
| fprintf(stderr, "\n\tERROR: test interupted"); |
| fprintf(stderr, "\n\tnative: SetEventCallbacks error_code is %d", |
| result); |
| return JNI_ERR; |
| } |
| |
| fprintf(stderr, "\n----------------------------------------------------"); |
| fprintf(stderr, "\ntest"); |
| fprintf(stderr, " %s ", test_case_name); |
| fprintf(stderr, "is started\n{\n"); |
| fflush(stderr); |
| |
| return JNI_OK; |
| } |
| |
| /* |
| * Universal VMDeath callback function; |
| */ |
| void func_for_callback_VMDeath(JNIEnv* jni_env, jvmtiEnv* jvmti_env, |
| const char* test_case_name, bool test, bool util) |
| { |
| |
| //warning fix |
| int w_fix = 1; |
| w_fix += sizeof(jni_env); |
| w_fix += sizeof(jvmti_env); |
| // |
| |
| fprintf(stderr, "\n\tTest of function "); |
| fprintf(stderr, "%s ", test_case_name); |
| fprintf(stderr, " : "); |
| fflush(stderr); |
| |
| if (test && util) |
| fprintf(stderr, " passed \n"); |
| else |
| fprintf(stderr, " failed \n"); |
| |
| fprintf(stderr, "\n} /* test "); |
| fprintf(stderr, "%s ", test_case_name); |
| fprintf(stderr, "is finished */ \n\n"); |
| fflush(stderr); |
| |
| return; |
| } |
| |
| /* *********************************************************************** */ |
| |
| |
