/*

 * 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.

 */

#include <stdio.h>

#include <string.h>

#include "jni_tools.h"

#include "agent_common.h"

#include "jvmti_tools.h"

extern "C" {

/* The test adds all capabilities suitable for profiling at OnLoad phase:

 *

 *   can_tag_objects

 *   can_get_owned_monitor_info

 *   can_get_current_contended_monitor

 *   can_get_monitor_info

 *   can_maintain_original_method_order

 *   can_get_current_thread_cpu_time

 *   can_get_thread_cpu_time

 *   can_generate_all_class_hook_events

 *   can_generate_compiled_method_load_events

 *   can_generate_monitor_events

 *   can_generate_vm_object_alloc_events

 *   can_generate_native_method_bind_events

 *   can_generate_garbage_collection_events

 *   can_generate_object_free_events

 *

 * and sets calbacks and enables events correspondent to capabilities above.

 * Then checks that GetCapabilities returns correct list of possessed

 * capabilities in Live phase, and checks that correspondent possessed

 * functions works and requested events are generated.

 */

/* ========================================================================== */

/* scaffold objects */

static jlong timeout = 0;

/* test objects */

static jthread thread = NULL;

static jclass klass = NULL;

/* event counts */

static int ClassFileLoadHookEventsCount = 0;

static int CompiledMethodLoadEventsCount = 0;

static int CompiledMethodUnloadEventsCount = 0;

static int MonitorContendedEnterEventsCount = 0;

static int MonitorContendedEnteredEventsCount = 0;

static int MonitorWaitEventsCount = 0;

static int MonitorWaitedEventsCount = 0;

static int VMObjectAllocEventsCount = 0;

static int NativeMethodBindEventsCount = 0;

static int GarbageCollectionStartEventsCount = 0;

static int GarbageCollectionFinishEventsCount = 0;

static int ObjectFreeEventsCount = 0;

/* ========================================================================== */

/** callback functions **/

static 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) {

    ClassFileLoadHookEventsCount++;

    NSK_DISPLAY1("ClassFileLoadHook event: %s\n", name);

}

static 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) {

    char *name = NULL;

    char *signature = NULL;

    CompiledMethodLoadEventsCount++;

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY3("CompiledMethodLoad event: %s%s (0x%p)\n",

        name, signature, code_addr);

    if (name != NULL)

    if (signature != NULL)

}

static void JNICALL

CompiledMethodUnload(jvmtiEnv *jvmti_env, jmethodID method,

        const void* code_addr) {

    char *name = NULL;

    char *sig = NULL;

    jvmtiError err;

    CompiledMethodUnloadEventsCount++;

    NSK_DISPLAY0("CompiledMethodUnload event received\n");

    // Check for the case that the class has been unloaded

    err = jvmti_env->GetMethodName(method, &name, &sig, NULL);

    if (err == JVMTI_ERROR_NONE) {

        NSK_DISPLAY3("for: \tmethod: name=\"%s\" signature=\"%s\"\n\tnative address=0x%p\n",

          name, sig, code_addr);

    }

}

static void JNICALL

MonitorContendedEnter(jvmtiEnv *jvmti_env, JNIEnv* jni_env,

        jthread thread, jobject object) {

    jvmtiThreadInfo info;

    MonitorContendedEnterEventsCount++;

    /* get thread information */

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY2("MonitorContendedEnter event: thread=\"%s\", object=0x%p\n",

        info.name, object);

}

static void JNICALL

MonitorContendedEntered(jvmtiEnv *jvmti_env, JNIEnv* jni_env,

        jthread thread, jobject object) {

    jvmtiThreadInfo info;

    MonitorContendedEnteredEventsCount++;

    /* get thread information */

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY2("MonitorContendedEntered event: thread=\"%s\", object=0x%p\n",

        info.name, object);

}

static void JNICALL

MonitorWait(jvmtiEnv *jvmti_env, JNIEnv* jni_env,

        jthread thread, jobject object, jlong timeout) {

    jvmtiThreadInfo info;

    MonitorWaitEventsCount++;

    /* get thread information */

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY2("MonitorWait event: thread=\"%s\", object=0x%p\n",

        info.name, object);

}

static void JNICALL

MonitorWaited(jvmtiEnv *jvmti_env, JNIEnv* jni_env,

        jthread thread, jobject object, jboolean timed_out) {

    jvmtiThreadInfo info;

    MonitorWaitedEventsCount++;

    /* get thread information */

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY2("MonitorWaited event: thread=\"%s\", object=0x%p\n",

        info.name, object);

}

static void JNICALL

VMObjectAlloc(jvmtiEnv *jvmti_env, JNIEnv* jni_env,

              jthread thread, jobject object,

              jclass object_klass, jlong size) {

    char *signature;

    VMObjectAllocEventsCount++;

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY2("VMObjectAlloc: \"%s\", size=%d\n", signature, size);

    if (signature != NULL)

}

static void JNICALL

NativeMethodBind(jvmtiEnv* jvmti_env, JNIEnv *jni_env,

        jthread thread, jmethodID method, void* func, void** func_ptr) {

    jvmtiPhase phase;

    char *name = NULL;

    char *signature = NULL;

    NativeMethodBindEventsCount++;

        nsk_jvmti_setFailStatus();

        return;

    }

    if (phase != JVMTI_PHASE_START && phase != JVMTI_PHASE_LIVE)

        return;

        nsk_jvmti_setFailStatus();

        return;

    }

    NSK_DISPLAY2("NativeMethodBind event: %s%s\n", name, signature);

    if (name != NULL)

    if (signature != NULL)

}

static void JNICALL

GarbageCollectionStart(jvmtiEnv *jvmti_env) {

    GarbageCollectionStartEventsCount++;

    NSK_DISPLAY0("GarbageCollectionStart\n");

}

static void JNICALL

GarbageCollectionFinish(jvmtiEnv *jvmti_env) {

    GarbageCollectionFinishEventsCount++;

    NSK_DISPLAY0("GarbageCollectionFinish\n");

}

static void JNICALL

ObjectFree(jvmtiEnv *jvmti_env, jlong tag) {

    char buffer[32];

    ObjectFreeEventsCount++;

    NSK_DISPLAY1("ObjectFree event: tag=%s\n", jlong_to_string(tag, buffer));

}

/* ========================================================================== */

static int prepare(jvmtiEnv* jvmti, JNIEnv* jni) {

    const char* THREAD_NAME = "Debuggee Thread";

    jvmtiThreadInfo info;

    jthread *threads = NULL;

    jint threads_count = 0;

    int i;

    NSK_DISPLAY0("Prepare: find tested thread\n");

    /* get all live threads */

        return NSK_FALSE;

    if (!NSK_VERIFY(threads_count > 0 && threads != NULL))

        return NSK_FALSE;

    /* find tested thread */

    for (i = 0; i < threads_count; i++) {

        if (!NSK_VERIFY(threads[i] != NULL))

            return NSK_FALSE;

        /* get thread information */

            return NSK_FALSE;

        NSK_DISPLAY3("    thread #%d (%s): %p\n", i, info.name, threads[i]);

        /* find by name */

        if (info.name != NULL && (strcmp(info.name, THREAD_NAME) == 0)) {

            thread = threads[i];

        }

    }

        return NSK_FALSE;

    /* deallocate threads list */

        return NSK_FALSE;

    /* get tested thread class */

        return NSK_FALSE;

    return NSK_TRUE;

}

/* ========================================================================== */

/* Check GetCapabilities function

 */

static int checkGetCapabilities(jvmtiEnv* jvmti) {

    jvmtiCapabilities caps;

    memset(&caps, 0, sizeof(caps));

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_tag_objects))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_get_owned_monitor_info))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_get_current_contended_monitor))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_get_monitor_info))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_maintain_original_method_order))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_get_current_thread_cpu_time))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_get_thread_cpu_time))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_all_class_hook_events))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_compiled_method_load_events))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_monitor_events))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_vm_object_alloc_events))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_native_method_bind_events))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_garbage_collection_events))

        return NSK_FALSE;

    if (!NSK_VERIFY(caps.can_generate_object_free_events))

        return NSK_FALSE;

    return NSK_TRUE;

}

/* ========================================================================== */

/* Check "can_get_owned_monitor_info" function

 */

static int checkGetOwnedMonitorInfo(jvmtiEnv* jvmti) {

    jint count;

    jobject *monitors = NULL;

    NSK_DISPLAY0("Checking positive: GetOwnedMonitorInfo\n");

        return NSK_FALSE;

    return NSK_TRUE;

}

/* Check "can_get_current_contended_monitor" function

 */

static int checkGetCurrentContendedMonitor(jvmtiEnv* jvmti) {

    jobject monitor = NULL;

    NSK_DISPLAY0("Checking positive: GetCurrentContendedMonitor\n");

        return NSK_FALSE;

    return NSK_TRUE;

}

/* Check "can_tag_objects" functions

 */

static jvmtiIterationControl JNICALL

HeapObject(jlong class_tag, jlong size, jlong *tag_ptr, void *user_data) {

    return JVMTI_ITERATION_CONTINUE;

}

static jvmtiIterationControl JNICALL

HeapRoot(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,

        jlong *tag_ptr, void *user_data) {

    return JVMTI_ITERATION_CONTINUE;

}

static jvmtiIterationControl JNICALL

StackReference(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,

        jlong *tag_ptr, jlong thread_tag, jint depth, jmethodID method,

        jint slot, void *user_data) {

    return JVMTI_ITERATION_CONTINUE;

}

static jvmtiIterationControl JNICALL

ObjectReference(jvmtiObjectReferenceKind reference_kind, jlong class_tag,

        jlong size, jlong *tag_ptr, jlong referrer_tag,

        jint referrer_index, void *user_data) {

    return JVMTI_ITERATION_CONTINUE;

}

static jvmtiIterationControl JNICALL

ThreadObjectReference(jvmtiObjectReferenceKind reference_kind, jlong class_tag,

        jlong size, jlong *tag_ptr, jlong referrer_tag,

        jint referrer_index, void *user_data) {

    static jlong ThreadObjectReferenceTagCount;

    *tag_ptr = ++ThreadObjectReferenceTagCount;

    return JVMTI_ITERATION_CONTINUE;

}

static int checkHeapFunctions(jvmtiEnv* jvmti) {

    const jlong TAG_VALUE = (123456789L);

    jlong tag;

    jint count;

    jobject *res_objects = NULL;

    jlong *res_tags = NULL;

    jint dummy_user_data = 0;

    NSK_DISPLAY0("Checking positive: SetTag\n");

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: GetTag\n");

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: GetObjectsWithTags\n");

    tag = TAG_VALUE;

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: IterateOverHeap\n");

    if (!NSK_JVMTI_VERIFY(

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: IterateOverInstancesOfClass\n");

    if (!NSK_JVMTI_VERIFY(

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: IterateOverObjectsReachableFromObject\n");

    if (!NSK_JVMTI_VERIFY(

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: IterateOverReachableObjects\n");

    if (!NSK_JVMTI_VERIFY(

        return NSK_FALSE;

    return NSK_TRUE;

}

/* Check "can_get_monitor_info" function

 */

static int checkGetObjectMonitorUsage(jvmtiEnv* jvmti) {

    jvmtiMonitorUsage monitor_info;

    NSK_DISPLAY0("Checking positive: GetObjectMonitorUsage\n");

        return NSK_FALSE;

    return NSK_TRUE;

}

/* Check "can_get_current_thread_cpu_time" function

 */

static int checkGetCurrentThreadCpuTime(jvmtiEnv* jvmti) {

    jvmtiTimerInfo info;

    jlong nanos;

    NSK_DISPLAY0("Checking positive: GetCurrentThreadCpuTimerInfo\n");

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: GetCurrentThreadCpuTime\n");

        return NSK_FALSE;

    return NSK_TRUE;

}

/* Check "can_get_thread_cpu_time" function

 */

static int checkGetThreadCpuTime(jvmtiEnv* jvmti) {

    jvmtiTimerInfo info;

    jlong nanos;

    NSK_DISPLAY0("Checking positive: GetThreadCpuTimerInfo\n");

        return NSK_FALSE;

    NSK_DISPLAY0("Checking positive: checkGetThreadCpuTime\n");

        return NSK_FALSE;

    return NSK_TRUE;

}

/* ========================================================================== */

/* Check generated events

 */

static int checkGeneratedEvents() {