| /* |
| * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| #include <string.h> |
| #include "jvmti.h" |
| #include "agent_common.h" |
| #include "jni_tools.h" |
| #include "jvmti_tools.h" |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* ============================================================================= */ |
| |
| /* scaffold objects */ |
| static JNIEnv* jni = NULL; |
| static jvmtiEnv *jvmti = NULL; |
| static jlong timeout = 0; |
| |
| /* constant names */ |
| #define DEBUGEE_CLASS_NAME "nsk/jvmti/scenarios/events/EM05/em05t002" |
| #define THREAD_CLASS_NAME "nsk/jvmti/scenarios/events/EM05/em05t002Thread" |
| #define THREAD_FIELD_NAME "thread" |
| #define THREAD_FIELD_SIG "L"THREAD_CLASS_NAME";" |
| |
| /* constants */ |
| #define MAX_NAME_LENGTH 64 |
| #define EVENTS_COUNT 2 |
| #define METHODS_COUNT 2 |
| #define MOMENTS_COUNT 3 |
| |
| /* compilation moments */ |
| #define COMPILATION_MOMENT_BEFORE 0 |
| #define COMPILATION_MOMENT_RUNNING 1 |
| #define COMPILATION_MOMENT_AFTER 2 |
| |
| /* tested events */ |
| static jvmtiEvent eventsList[EVENTS_COUNT] = { |
| JVMTI_EVENT_COMPILED_METHOD_LOAD, |
| JVMTI_EVENT_COMPILED_METHOD_UNLOAD |
| }; |
| |
| /* method description structure */ |
| typedef struct { |
| char methodName[MAX_NAME_LENGTH]; |
| char methodSig[MAX_NAME_LENGTH]; |
| jmethodID method; |
| int compiled; |
| int loadEvents[MOMENTS_COUNT]; |
| int unloadEvents[MOMENTS_COUNT]; |
| } MethodDesc; |
| |
| /* descriptions of tested methods */ |
| static MethodDesc methodsDesc[METHODS_COUNT] = { |
| {"javaMethod", "(I)I", NULL, 0, {0}, {0}}, |
| {"nativeMethod", "(I)I", NULL, 0, {0}, {0}} |
| }; |
| |
| /* current compilation moment */ |
| static volatile int moment = COMPILATION_MOMENT_BEFORE; |
| |
| /* ============================================================================= */ |
| |
| /* testcase(s) */ |
| static int prepare(); |
| static int generateEvents(); |
| static int checkEvents(); |
| static int clean(); |
| |
| /* ============================================================================= */ |
| |
| /** Agent algorithm. */ |
| static void JNICALL |
| agentProc(jvmtiEnv* jvmti, JNIEnv* agentJNI, void* arg) { |
| jni = agentJNI; |
| |
| NSK_DISPLAY0("Wait for debuggee to become ready\n"); |
| if (!nsk_jvmti_waitForSync(timeout)) |
| return; |
| |
| { |
| NSK_DISPLAY0("Prepare data\n"); |
| if (!prepare()) { |
| nsk_jvmti_setFailStatus(); |
| return; |
| } |
| |
| NSK_DISPLAY0("Testcase #1: generate events before running thread\n"); |
| moment = COMPILATION_MOMENT_BEFORE; |
| NSK_DISPLAY0("Call GenerateEvents() before running methods\n"); |
| if (!generateEvents()) |
| return; |
| NSK_DISPLAY0("Check if events received\n"); |
| if (!checkEvents()) |
| return; |
| |
| NSK_DISPLAY0("Testcase #2: run methods to provoke compilation\n"); |
| moment = COMPILATION_MOMENT_RUNNING; |
| NSK_DISPLAY0("Provoke methods compilation\n"); |
| if (!nsk_jvmti_resumeSync()) |
| return; |
| NSK_DISPLAY0("Wait for thread to completed\n"); |
| if (!nsk_jvmti_waitForSync(timeout)) |
| return; |
| NSK_DISPLAY0("Check if events received\n"); |
| if (!checkEvents()) |
| return; |
| |
| NSK_DISPLAY0("Testcase #3: generate events before running thread\n"); |
| moment = COMPILATION_MOMENT_AFTER; |
| NSK_DISPLAY0("Call GenerateEvents() after running methods\n"); |
| if (!generateEvents()) |
| return; |
| NSK_DISPLAY0("Check if events received\n"); |
| if (!checkEvents()) |
| return; |
| |
| NSK_DISPLAY0("Clean data\n"); |
| if (!clean()) { |
| nsk_jvmti_setFailStatus(); |
| return; |
| } |
| } |
| |
| NSK_DISPLAY0("Let debuggee to finish\n"); |
| if (!nsk_jvmti_resumeSync()) |
| return; |
| } |
| |
| /* ============================================================================= */ |
| |
| /** |
| * Generate tested events (COMPILED_METHOD_LOAD only). |
| */ |
| static int generateEvents() { |
| if (!NSK_JVMTI_VERIFY( |
| NSK_CPP_STUB2(GenerateEvents, jvmti, JVMTI_EVENT_COMPILED_METHOD_LOAD))) { |
| nsk_jvmti_setFailStatus(); |
| return NSK_FALSE; |
| } |
| return NSK_TRUE; |
| } |
| |
| /** |
| * Prepare data. |
| * - find tested thread |
| * - get tested methodIDs |
| * - enable events |
| */ |
| static int prepare() { |
| jclass debugeeClass = NULL; |
| jclass threadClass = NULL; |
| jfieldID threadFieldID = NULL; |
| jthread thread = NULL; |
| int i; |
| |
| for (i = 0; i < METHODS_COUNT; i++) { |
| int j; |
| methodsDesc[i].method = (jmethodID)NULL; |
| methodsDesc[i].compiled = NSK_FALSE; |
| for (j = 0; j < MOMENTS_COUNT; j++) { |
| methodsDesc[i].loadEvents[j] = 0; |
| methodsDesc[i].unloadEvents[j] = 0; |
| } |
| } |
| |
| if (!NSK_JNI_VERIFY(jni, (debugeeClass = |
| NSK_CPP_STUB2(FindClass, jni, DEBUGEE_CLASS_NAME)) != NULL)) |
| return NSK_FALSE; |
| |
| if (!NSK_JNI_VERIFY(jni, (threadFieldID = |
| NSK_CPP_STUB4(GetStaticFieldID, jni, debugeeClass, |
| THREAD_FIELD_NAME, THREAD_FIELD_SIG)) != NULL)) |
| return NSK_FALSE; |
| |
| if (!NSK_JNI_VERIFY(jni, (thread = (jthread) |
| NSK_CPP_STUB3(GetStaticObjectField, jni, debugeeClass, threadFieldID)) != NULL)) |
| return NSK_FALSE; |
| |
| if (!NSK_JNI_VERIFY(jni, (threadClass = |
| NSK_CPP_STUB2(GetObjectClass, jni, thread)) != NULL)) |
| return NSK_FALSE; |
| |
| NSK_DISPLAY0("Find tested methods:\n"); |
| for (i = 0; i < METHODS_COUNT; i++) { |
| if (!NSK_JNI_VERIFY(jni, (methodsDesc[i].method = |
| NSK_CPP_STUB4(GetMethodID, jni, threadClass, |
| methodsDesc[i].methodName, methodsDesc[i].methodSig)) != NULL)) |
| return NSK_FALSE; |
| NSK_DISPLAY3(" method #%d (%s): 0x%p\n", |
| i, methodsDesc[i].methodName, (void*)methodsDesc[i].method); |
| } |
| |
| NSK_DISPLAY0("Enable events\n"); |
| if (!nsk_jvmti_enableEvents(JVMTI_ENABLE, EVENTS_COUNT, eventsList, NULL)) |
| return NSK_FALSE; |
| |
| return NSK_TRUE; |
| } |
| |
| /** |
| * Testcase: check tested events. |
| * - check if expected events received for each method |
| * |
| * Returns NSK_TRUE if test may continue; or NSK_FALSE for test break. |
| */ |
| static int checkEvents() { |
| int i; |
| |
| for (i = 0; i < METHODS_COUNT; i++) { |
| NSK_DISPLAY2(" method #%d (%s):\n", |
| i, methodsDesc[i].methodName); |
| NSK_DISPLAY2(" COMPILED_METHOD_LOAD: %d, COMPILED_METHOD_UNLOAD: %d\n", |
| methodsDesc[i].loadEvents[moment], |
| methodsDesc[i].unloadEvents[moment]); |
| |
| if (moment == COMPILATION_MOMENT_AFTER) { |
| int loadEventsTotal = methodsDesc[i].loadEvents[COMPILATION_MOMENT_BEFORE] |
| + methodsDesc[i].loadEvents[COMPILATION_MOMENT_RUNNING]; |
| int unloadEventsTotal = methodsDesc[i].unloadEvents[COMPILATION_MOMENT_BEFORE] |
| + methodsDesc[i].unloadEvents[COMPILATION_MOMENT_RUNNING]; |
| |
| /* complain if no COMPILED_METHOD_LOAD events finally generated for compiled events */ |
| if (methodsDesc[i].compiled) { |
| if (methodsDesc[i].loadEvents[COMPILATION_MOMENT_AFTER] > loadEventsTotal) { |
| NSK_COMPLAIN4("No COMPILED_METHOD_LOAD events finally generated for compiled method: %s\n" |
| "# total COMPILED_METHOD_LOAD: %d\n" |
| "# total COMPILED_METHOD_UNLOAD: %d\n" |
| "# final GenerateEvents(): %d\n", |
| methodsDesc[i].methodName, |
| loadEventsTotal, |
| unloadEventsTotal, |
| methodsDesc[i].loadEvents[COMPILATION_MOMENT_AFTER]); |
| nsk_jvmti_setFailStatus(); |
| } |
| } |
| |
| /* complain if too many COMPILED_METHOD_LOAD events finally generated */ |
| if (methodsDesc[i].loadEvents[COMPILATION_MOMENT_AFTER] > loadEventsTotal) { |
| NSK_COMPLAIN5("Too many COMPILED_METHOD_LOAD events finally generated for method: %s\n" |
| "# GenerateEvents() before execution: %d\n" |
| "# generated during execution: %d\n" |
| "# total: %d\n" |
| "# GenerateEvents() after execution: %d\n", |
| methodsDesc[i].methodName, |
| methodsDesc[i].loadEvents[COMPILATION_MOMENT_BEFORE], |
| methodsDesc[i].loadEvents[COMPILATION_MOMENT_RUNNING], |
| loadEventsTotal, |
| methodsDesc[i].loadEvents[COMPILATION_MOMENT_AFTER]); |
| nsk_jvmti_setFailStatus(); |
| } |
| |
| /* warn if too mamy COMPILED_METHOD_UNLOAD events received */ |
| if (unloadEventsTotal > loadEventsTotal) { |
| NSK_DISPLAY1("# WARNING: Too many COMPILED_METHOD_UNLOAD events for method: %s\n", |
| methodsDesc[i].methodName); |
| NSK_DISPLAY2("# COMPILED_METHOD_LOAD: %d, COMPILED_METHOD_UNLOAD: %d\n", |
| loadEventsTotal, unloadEventsTotal); |
| } |
| } |
| } |
| return NSK_TRUE; |
| } |
| |
| /** |
| * Clean data. |
| * - disable events |
| */ |
| static int clean() { |
| NSK_DISPLAY0("Disable events\n"); |
| if (!nsk_jvmti_enableEvents(JVMTI_DISABLE, EVENTS_COUNT, eventsList, NULL)) |
| return NSK_FALSE; |
| |
| return NSK_TRUE; |
| } |
| |
| /* ============================================================================= */ |
| |
| /** |
| * COMPILED_METHOD_LOAD callback. |
| * - turm on flag that method is compiled |
| */ |
| JNIEXPORT void JNICALL |
| callbackCompiledMethodLoad(jvmtiEnv* jvmti, jmethodID method, |
| jint code_size, const void* code_addr, |
| jint map_length, const jvmtiAddrLocationMap* map, |
| const void* compile_info) { |
| int i; |
| |
| /* check if event is for tested method and count it */ |
| for (i = 0; i < METHODS_COUNT; i++) { |
| if (methodsDesc[i].method == method) { |
| methodsDesc[i].loadEvents[moment]++; |
| methodsDesc[i].compiled = NSK_TRUE; |
| |
| NSK_DISPLAY3(" COMPILED_METHOD_LOAD for method #%d (%s): %d times\n", |
| i, methodsDesc[i].methodName, |
| methodsDesc[i].loadEvents[moment]); |
| NSK_DISPLAY1(" methodID: 0x%p\n", |
| (void*)methodsDesc[i].method); |
| NSK_DISPLAY1(" code_size: %d\n", |
| (int)code_size); |
| NSK_DISPLAY1(" map_length: %d\n", |
| (int)map_length); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * COMPILED_METHOD_UNLOAD callback. |
| * - turn off flag that method is compiled |
| */ |
| JNIEXPORT void JNICALL |
| callbackCompiledMethodUnload(jvmtiEnv* jvmti, jmethodID method, |
| const void* code_addr) { |
| int i; |
| |
| /* check if event is for tested method and count it */ |
| for (i = 0; i < METHODS_COUNT; i++) { |
| if (methodsDesc[i].method == method) { |
| methodsDesc[i].unloadEvents[moment]++; |
| methodsDesc[i].compiled = NSK_FALSE; |
| |
| NSK_DISPLAY3(" COMPILED_METHOD_UNLOAD for method #%d (%s): %d times\n", |
| i, methodsDesc[i].methodName, |
| methodsDesc[i].loadEvents[moment]); |
| NSK_DISPLAY1(" methodID: 0x%p\n", |
| (void*)methodsDesc[i].method); |
| break; |
| } |
| } |
| } |
| |
| /* ============================================================================= */ |
| |
| /** Native running method in tested thread. */ |
| JNIEXPORT jint JNICALL |
| Java_nsk_jvmti_scenarios_events_EM05_em05t002Thread_nativeMethod(JNIEnv* jni, |
| jobject obj, jint i) { |
| jint k = 0; |
| jint j; |
| |
| for (j = 0; j < i; j++) { |
| k += (i - j); |
| } |
| return k; |
| } |
| |
| /* ============================================================================= */ |
| |
| /** Agent library initialization. */ |
| #ifdef STATIC_BUILD |
| JNIEXPORT jint JNICALL Agent_OnLoad_em05t002(JavaVM *jvm, char *options, void *reserved) { |
| return Agent_Initialize(jvm, options, reserved); |
| } |
| JNIEXPORT jint JNICALL Agent_OnAttach_em05t002(JavaVM *jvm, char *options, void *reserved) { |
| return Agent_Initialize(jvm, options, reserved); |
| } |
| JNIEXPORT jint JNI_OnLoad_em05t002(JavaVM *jvm, char *options, void *reserved) { |
| return JNI_VERSION_1_8; |
| } |
| #endif |
| jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) { |
| |
| if (!NSK_VERIFY(nsk_jvmti_parseOptions(options))) |
| return JNI_ERR; |
| |
| timeout = nsk_jvmti_getWaitTime() * 60 * 1000; |
| |
| if (!NSK_VERIFY((jvmti = |
| nsk_jvmti_createJVMTIEnv(jvm, reserved)) != NULL)) |
| return JNI_ERR; |
| |
| { |
| jvmtiCapabilities caps; |
| memset(&caps, 0, sizeof(caps)); |
| caps.can_generate_compiled_method_load_events = 1; |
| if (!NSK_JVMTI_VERIFY( |
| NSK_CPP_STUB2(AddCapabilities, jvmti, &caps))) |
| return JNI_ERR; |
| } |
| |
| { |
| jvmtiEventCallbacks eventCallbacks; |
| memset(&eventCallbacks, 0, sizeof(eventCallbacks)); |
| eventCallbacks.CompiledMethodLoad = callbackCompiledMethodLoad; |
| eventCallbacks.CompiledMethodUnload = callbackCompiledMethodUnload; |
| if (!NSK_JVMTI_VERIFY( |
| NSK_CPP_STUB3(SetEventCallbacks, jvmti, |
| &eventCallbacks, sizeof(eventCallbacks)))) |
| return JNI_ERR; |
| } |
| |
| if (!NSK_VERIFY(nsk_jvmti_setAgentProc(agentProc, NULL))) |
| return JNI_ERR; |
| |
| return JNI_OK; |
| } |
| |
| /* ============================================================================= */ |
| |
| #ifdef __cplusplus |
| } |
| #endif |
