/*

 * Copyright (c) 2004, 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.

 */

/*

 *

 * JVMTI agent used for run every test from the testbase in a special

 * debug mode. This mode is intended to be part of serviceability

 * reliability testing.

 */

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <jvmti.h>

#include "nsk_tools.h"

#include "jni_tools.h"

#include "JVMTITools.h"

#include "jvmti_tools.h"

extern "C" {

static jvmtiEnv *jvmti = NULL; /* JVMTI env */

static jvmtiEventCallbacks callbacks;

static jrawMonitorID eventLock; /* raw monitor used for exclusive ownership of HotSwap function */

static volatile int debug_mode = 0; /* 0 - verbose mode off;

                                       1 - verbose mode on;

                                       2 - verbose mode on including all JVMTI events reporting,

                                           produces a huge number of messages */

/* stress level */

static volatile int stress_lev = 0; /* 0 - default mode: generation of all events except

                                                ExceptionCatch,

                                                MethodEntry/Exit, SingleStep;

                                       1 - generation of all events except

                                                MethodEntry/Exit,

                                                SingleStep;

                                       2 - generation of all events except

                                                SingleStep;

                                       3 - generation of all events, including

                                                ExceptionCatch,

                                                MethodEntry/Exit,

                                                SingleStep

                                     */

#define TRUE 1

#define FALSE 0

/**** the following is used for "postVM_DEATH" events watching ****/

static volatile int vm_death_occured = FALSE;

/************************************************/

/**** the following is used for HotSwap mode ****/

/* HotSwap modes:

 HOTSWAP_OFF                - default mode: HotSwap off;

 HOTSWAP_EVERY_METHOD_ENTRY - HotSwap tested class in every method entry event

                              of running test

 HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS - HotSwap tested class in every

                              method entry event of every class

 HOTSWAP_EVERY_SINGLE_STEP  - HotSwap tested class in every single step event

                              of running test

 HOTSWAP_EVERY_EXCEPTION    - HotSwap tested class in every exception event

                              of running test

 HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS - HotSwap tested class in every

                              exception event of every class

 */

#define HOTSWAP_OFF 0

#define HOTSWAP_EVERY_METHOD_ENTRY 2

#define HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS 20

#define HOTSWAP_EVERY_SINGLE_STEP 3

#define HOTSWAP_EVERY_EXCEPTION 4

#define HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS 40

static int hotswap = HOTSWAP_OFF;

typedef struct {   /* test class info */

    char *clazzsig;  /* class signature */

    jclass cls;      /* a class to be redefined */

    jint bCount;     /* number of bytes defining the class */

    jbyte *clsBytes; /* bytes defining the class */

    struct class_info *next;

} class_info;

static const char *shortTestName = NULL; /* name of the test without package prefix */

static jclass rasCls; /* reference to the auxiliary class RASagent used for HotSwap */

static class_info *clsInfo = NULL, *clsInfoFst = NULL;

static void lock(JNIEnv*);

static void unlock(JNIEnv*);

static jint allocClsInfo(JNIEnv*, char*, jclass);

static void deallocClsInfo(JNIEnv*);

static int findAndHotSwap(JNIEnv*, jclass);

static int doHotSwap(JNIEnv*, jclass, jint, jbyte*);

static void display(int, const char format[], ...);

static void clearJavaException(JNIEnv*);

static int enableEventsCaps();

static int addStressEvents();

static void getVerdict(JNIEnv*, const char *);

/************************************************/

/** callback functions **/

void JNICALL

Breakpoint(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thr, jmethodID method,

        jlocation loc) {

    display(1, "#### JVMTIagent: Breakpoint occurred ####\n");

    getVerdict(jni_env, "Breakpoint");

}

void JNICALL

ClassFileLoadHook(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jclass class_beeing_redefined,

        jobject loader, const char* name, jobject protection_domain,

        jint class_data_len, const unsigned char* class_data,

        jint *new_class_data_len, unsigned char** new_class_data) {

    display(1, "#### JVMTIagent: ClassFileLoadHook occurred ####\n");

    getVerdict(jni_env, "ClassFileLoadHook");

}

void JNICALL

ClassLoad(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread, jclass klass) {

    char *cls_sig;

    jint clsByteCount;

    display((hotswap != HOTSWAP_OFF)?0:1,

        "#### JVMTIagent: ClassLoad occurred ####\n");

    getVerdict(jni_env, "ClassLoad");

    if (hotswap != HOTSWAP_OFF) {

        /* enter into a raw monitor for exclusive work with redefined class */

        lock(jni_env);

        display(0, "#### JVMTIagent: ClassLoad: >>>>>>>> entered the raw monitor \"eventLock\" ####\n");

        if (!NSK_JVMTI_VERIFY(jvmti_env->GetClassSignature(klass, &cls_sig, /*&generic*/NULL)))

            jni_env->FatalError("JVMTIagent: failed to get class signature\n");

        else {

            if (shortTestName != NULL) {

                if (strstr((const char*) cls_sig, shortTestName) != NULL) {

                    display(0,

                            "#### JVMTIagent: found test class matched with \"%s\"\n"

                            "<JVMTIagent>\tsignature=%s\n",

                            shortTestName, cls_sig);

                    clsByteCount = allocClsInfo(jni_env, cls_sig, klass);

                    display(0, "#### JVMTIagent: %d bytes defining the class have been successfully loaded\n",

                            clsByteCount);

                }

            }

        }

        /* exit from the raw monitor */

        unlock(jni_env);

        display(0, "#### JVMTIagent: ClassLoad: <<<<<<<< exited from the raw monitor \"eventLock\" ####\n\n");

    }

}

void JNICALL

ClassPrepare(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jthread thr, jclass cls) {

    display(1, "#### JVMTIagent: ClassPrepare occurred ####\n");

    getVerdict(jni_env, "ClassPrepare");

}

void JNICALL

CompiledMethodLoad(jvmtiEnv *jvmti_env, jmethodID method, jint code_size,

        const void* code_addr,  jint map_length,

        const jvmtiAddrLocationMap* map, const void* compile_info) {

    display(1, "#### JVMTIagent: CompiledMethodLoad occurred ####\n");

    getVerdict(NULL, "CompiledMethodLoad");

}

void JNICALL

CompiledMethodUnload(jvmtiEnv *jvmti_env, jmethodID method,

        const void* code_addr) {

    display(1, "#### JVMTIagent: CompiledMethodUnload occurred ####\n");

    getVerdict(NULL, "CompiledMethodUnload");

}

void JNICALL

DataDumpRequest(jvmtiEnv *jvmti_env) {

    display(1, "#### JVMTIagent: DataDumpRequest occurred ####\n");

    getVerdict(NULL, "DataDumpRequest");

}

void JNICALL

DynamicCodeGenerated(jvmtiEnv *jvmti_env,

        const char* name,

        const void* address,

        jint length) {

    display(1, "#### JVMTIagent: DynamicCodeGenerated occurred ####\n");

    getVerdict(NULL, "DynamicCodeGenerated");

}

void JNICALL

Exception(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thr,

        jmethodID method, jlocation location, jobject exception,

        jmethodID catch_method, jlocation catch_location) {

    jclass decl_clazz;

    display((hotswap == HOTSWAP_EVERY_EXCEPTION ||

            hotswap == HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS)?0:1,

        "#### JVMTIagent: Exception occurred ####\n");

    getVerdict(jni_env, "Exception");

    if (hotswap == HOTSWAP_EVERY_EXCEPTION ||

            hotswap == HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS) {

        if (!NSK_JVMTI_VERIFY(jvmti_env->GetMethodDeclaringClass(method, &decl_clazz)))

            jni_env->FatalError("JVMTIagent: failed to get method declaring class\n");

        if (findAndHotSwap(jni_env, decl_clazz) != 0)

            jni_env->FatalError("JVMTIagent: failed to hotswap class\n");

    }

}

void JNICALL

FieldAccess(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jthread thr, jmethodID method,

        jlocation location, jclass field_klass, jobject obj, jfieldID field) {

    display(1, "#### JVMTIagent: FieldAccess occurred ####\n");

    getVerdict(jni_env, "FieldAccess");

}

void JNICALL

FieldModification(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jthread thr, jmethodID method, jlocation location,

        jclass field_klass, jobject obj,

        jfieldID field, char sig, jvalue new_value) {

    display(1, "#### JVMTIagent: FieldModification occurred ####\n");

    getVerdict(jni_env, "FieldModification");

}

void JNICALL

FramePop(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jthread thr, jmethodID method, jboolean wasPopedByException) {

    display(1, "#### JVMTIagent: FramePop occurred ####\n");

    getVerdict(jni_env, "FramePop");

}

void JNICALL

GarbageCollectionFinish(jvmtiEnv *jvmti_env) {

    display(1, "#### JVMTIagent: GarbageCollectionFinish occurred ####\n");

    getVerdict(NULL, "GarbageCollectionFinish");

}

void JNICALL

GarbageCollectionStart(jvmtiEnv *jvmti_env) {

    display(1, "#### JVMTIagent: GarbageCollectionStart occurred ####\n");

    getVerdict(NULL, "GarbageCollectionStart");

}

void JNICALL

MonitorContendedEnter(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thr,

        jobject obj) {

    display(1, "#### JVMTIagent: MonitorContendedEnter occurred ####\n");

    getVerdict(jni_env, "MonitorContendedEnter");

}

void JNICALL

MonitorContendedEntered(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thr,

        jobject obj) {

    display(1, "#### JVMTIagent: MonitorContendedEntered occurred ####\n");

    getVerdict(jni_env, "MonitorContendedEntered");

}

void JNICALL

MonitorWait(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thr, jobject obj,

        jlong tout) {

    display(1, "#### JVMTIagent: MonitorWait occurred ####\n");

    getVerdict(jni_env, "MonitorWait");

}

void JNICALL

MonitorWaited(jvmtiEnv *jvmti_env, JNIEnv* jni_env,

        jthread thr, jobject obj, jboolean timed_out) {

    display(1, "#### JVMTIagent: MonitorWaited occurred ####\n");

    getVerdict(jni_env, "MonitorWaited");

}

void JNICALL

NativeMethodBind(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread,

        jmethodID method, void *addr, void **new_addr) {

    display(1, "#### JVMTIagent: NativeMethodBind occurred ####\n");

    getVerdict(jni_env, "NativeMethodBind");

}

void JNICALL

ObjectFree(jvmtiEnv *jvmti_env, jlong tag) {

    display(1, "#### JVMTIagent: ObjectFree occurred ####\n");

    getVerdict(NULL, "ObjectFree");

}

void JNICALL

ThreadEnd(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread) {

    display(1, "#### JVMTIagent: ThreadEnd occurred ####\n");

    getVerdict(jni_env, "ThreadEnd");

}

void JNICALL

ThreadStart(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thread) {

    display(1, "#### JVMTIagent: ThreadStart occurred ####\n");

    getVerdict(jni_env, "ThreadStart");

}

void JNICALL

VMDeath(jvmtiEnv *jvmti_env, JNIEnv *jni_env) {

    vm_death_occured = TRUE;

    display(0, "#### JVMTIagent: VMDeath occurred ####\n");

    if (hotswap != HOTSWAP_OFF) {

        deallocClsInfo(jni_env);

        display(0, "#### JVMTIagent: allocated memory was successfully freed ####\n");

    }

}

void JNICALL

VMInit(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thr) {

    display(0, "#### JVMTIagent: VMInit occurred ####\n");

    getVerdict(jni_env, "VMInit");

}

void JNICALL

VMStart(jvmtiEnv *jvmti_env, JNIEnv* jni_env) {

    display(0, "#### JVMTIagent: VMStart occurred ####\n");

    getVerdict(jni_env, "VMStart");

}

JNIEXPORT void JNICALL

VMObjectAlloc(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread,

        jobject object, jclass object_klass, jlong size) {

    display(1, "#### JVMTIagent: VMObjectAlloc occurred ####\n");

    getVerdict(jni_env, "VMObjectAlloc");

}

void JNICALL

SingleStep(jvmtiEnv *jvmti_env, JNIEnv* jni_env, jthread thread,

        jmethodID method, jlocation location) {

    jclass decl_clazz;

    display((hotswap == HOTSWAP_EVERY_SINGLE_STEP)?0:1,

        "#### JVMTIagent: SingleStep occurred ####\n");

    getVerdict(jni_env, "SingleStep");

    if (hotswap == HOTSWAP_EVERY_SINGLE_STEP) {

        if (!NSK_JVMTI_VERIFY(jvmti_env->GetMethodDeclaringClass(method, &decl_clazz)))

            jni_env->FatalError("JVMTIagent: failed to get method declaring class\n");

        if (findAndHotSwap(jni_env, decl_clazz) != 0)

            jni_env->FatalError("JVMTIagent: failed to hotswap class\n");

    }

}

void JNICALL

MethodEntry(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jthread thr, jmethodID method) {

    jclass decl_clazz;

    display((hotswap == HOTSWAP_EVERY_METHOD_ENTRY ||

            hotswap == HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS)?0:1,

        "#### JVMTIagent: MethodEntry occurred ####\n");

    getVerdict(jni_env, "MethodEntry");

    if (hotswap == HOTSWAP_EVERY_METHOD_ENTRY ||

            hotswap == HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS) {

        if (!NSK_JVMTI_VERIFY(jvmti_env->GetMethodDeclaringClass(method, &decl_clazz)))

            jni_env->FatalError("JVMTIagent: failed to get method declaring class\n");

        if (findAndHotSwap(jni_env, decl_clazz) != 0)

            jni_env->FatalError("JVMTIagent: failed to hotswap class\n");

    }

}

void JNICALL

MethodExit(jvmtiEnv *jvmti_env, JNIEnv *jni_env,

        jthread thr, jmethodID method,

        jboolean was_poped_by_exc, jvalue return_value) {

    display(1, "#### JVMTIagent: MethodExit occurred ####\n");

    getVerdict(jni_env, "MethodExit");

}

void JNICALL

ExceptionCatch(jvmtiEnv *jvmti_env, JNIEnv *jni_env, jthread thr,

        jmethodID method, jlocation location, jobject exception) {

    jclass decl_clazz;

    display((hotswap == HOTSWAP_EVERY_EXCEPTION ||

            hotswap == HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS)?0:1,

        "#### JVMTIagent: ExceptionCatch occurred ####\n");

    getVerdict(jni_env, "ExceptionCatch");

    if (hotswap == HOTSWAP_EVERY_EXCEPTION ||

            hotswap == HOTSWAP_EVERY_EXCEPTION_FOR_EVERY_CLASS) {

        if (!NSK_JVMTI_VERIFY(jvmti_env->GetMethodDeclaringClass(method, &decl_clazz)))

            jni_env->FatalError("JVMTIagent: failed to get method declaring class\n");

        if (findAndHotSwap(jni_env, decl_clazz) != 0)

            jni_env->FatalError("JVMTIagent: failed to hotswap class\n");

    }

}

/************************/

static void lock(JNIEnv *jni_env) {

    if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(eventLock)))

        jni_env->FatalError("JVMTIagent: failed to enter a raw monitor\n");

}

static void unlock(JNIEnv *jni_env) {

    if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(eventLock)))

        jni_env->FatalError("JVMTIagent: failed to exit a raw monitor\n");

}

JNIEXPORT jint JNICALL

Java_nsk_share_RASagent_setHotSwapMode(JNIEnv *jni_env, jclass cls,

        jboolean vrb, jint level, jstring shortName) {

    jvmtiCapabilities capabil;

    jmethodID mid = NULL;

    if (jvmti == NULL) {

        printf("ERROR(%s,%d): JVMTIagent was not properly loaded: JVMTI env = NULL\n",

               __FILE__, __LINE__);

        return 1;

    }

    /* get supported JVMTI capabilities */

    if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&capabil)))

        jni_env->FatalError("JVMTIagent: failed to get capabilities\n");

    if (capabil.can_redefine_classes != 1) { /* ???????????? */

        printf("ERROR: JVMTIagent: Class File Redefinition (HotSwap) is not implemented in this VM\n");

        return 1;

    }

    if (vrb == JNI_TRUE && debug_mode == 0)

        debug_mode = 1;

    hotswap = level;

    switch (hotswap) {

        case HOTSWAP_OFF:

            display(0, "#### JVMTIagent: hotswap mode off ####\n");

            return 0;

        case HOTSWAP_EVERY_METHOD_ENTRY:

            stress_lev = 2;

            display(0,

                    "#### JVMTIagent: hotswapping class in every method entry event enabled ####\n"

                    "<JVMTIagent>\tHotSwap stress level: %d\n",

                    stress_lev);

            break;

        case HOTSWAP_EVERY_METHOD_ENTRY_FOR_EVERY_CLASS:

            stress_lev = 2;