test/hotspot/jtreg/vmTestbase/nsk/jvmti/scenarios/hotswap/HS201/hs201t003/hs201t003.cpp
8210481: Remove #ifdef cplusplus from vmTestbase
Summary: Remove all cplusplus ifdefs from vmTestbase
Reviewed-by: dholmes, iignatyev, cjplummer, sspitsyn
/*
* 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 <jvmti.h>
#include "agent_common.h"
#include "nsk_tools.h"
#include "native_thread.h"
#include "JVMTITools.h"
#include "jvmti_tools.h"
extern "C" {
#define PASSED 0
#define STATUS_FAILED 2
#define MAX_ATTEMPTS 15
static const char *expHSMethod = "entryMethod2";
static const char *expHSSignature = "()V";
#define EVENTS_COUNT 4
static jvmtiEvent eventsList[EVENTS_COUNT] = {
JVMTI_EVENT_EXCEPTION,
JVMTI_EVENT_METHOD_ENTRY,
JVMTI_EVENT_METHOD_EXIT,
JVMTI_EVENT_FRAME_POP
};
static jvmtiEnv *jvmti = NULL;
static jlong timeout = 0;
static jint bytesCount; /* number of bytes of a redefining class */
static jbyte *clsBytes; /* bytes defining a redefining class */
static jint redefMethBytesCount; /* number of bytes of a redefined method */
static unsigned char *redefMethBytes; /* bytes defining a redefined method */
JNIEXPORT void JNICALL Java_nsk_jvmti_scenarios_hotswap_HS201_hs201t003_storeClassBytes
(JNIEnv *jni_env, jclass cls, jbyteArray classBytes) {
jboolean isCopy;
bytesCount = NSK_CPP_STUB2(GetArrayLength, jni_env, classBytes);
clsBytes =
NSK_CPP_STUB3(GetByteArrayElements, jni_env, classBytes, &isCopy);
}
static int expectedMeth(jvmtiEnv *jvmti_env, const char *event,
jmethodID method, const char *expMeth, const char *expSig) {
char *name;
char *sig;
int methFound = 0;
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB5(GetMethodName,
jvmti_env, method, &name, &sig, NULL))) {
nsk_jvmti_setFailStatus();
return 0;
}
if ((strcmp(name, expMeth) == 0) &&
(strcmp(sig, expSig) == 0)) {
NSK_DISPLAY4("===== %s event received for the tested method:\n\
\tID=0x%p name=\"%s\" signature=\"%s\"\n",
event, (void*) method, name, sig);
methFound = 1;
}
else
methFound = 0;
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB2(Deallocate,
jvmti_env, (unsigned char*) name)))
nsk_jvmti_setFailStatus();
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB2(Deallocate,
jvmti_env, (unsigned char*) sig)))
nsk_jvmti_setFailStatus();
return methFound;
}
static void doHotSwap(jvmtiEnv *jvmti_env,
jmethodID tMethodID, const char *event) {
jclass decl_cls;
char *cls_sig;
jvmtiClassDefinition classDef;
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(GetMethodDeclaringClass,
jvmti_env, tMethodID, &decl_cls))) {
nsk_jvmti_setFailStatus();
return;
}
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB4(GetClassSignature,
jvmti_env, decl_cls, &cls_sig, NULL))) {
nsk_jvmti_setFailStatus();
return;
}
else
NSK_DISPLAY2("[%s] tested method class signature: \"%s\"\n\n",
event, cls_sig);
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB2(Deallocate,
jvmti_env, (unsigned char*) cls_sig)))
nsk_jvmti_setFailStatus();
/* fill the structure jvmtiClassDefinition */
classDef.klass = decl_cls;
classDef.class_byte_count = bytesCount;
classDef.class_bytes = (unsigned char*) clsBytes;
NSK_DISPLAY2("[%s] >>>>> Invoke RedefineClasses():\n\
\tnew class byte count=%d\n",
event, classDef.class_byte_count);
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(RedefineClasses,
jvmti, 1, &classDef))) {
nsk_jvmti_setFailStatus();
return;
}
NSK_DISPLAY1("[%s] <<<<< RedefineClasses() is successfully done\n",
event);
}
static void doChecks(jvmtiEnv *jvmti_env,
jmethodID tMethodID, jboolean expected, const char *event) {
jboolean isObsolete = JNI_FALSE;
char *name;
char *sig;
jint methBytesCount; /* number of bytes of a method */
unsigned char *methBytes; /* bytes defining a method */
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB5(GetMethodName,
jvmti_env, tMethodID, &name, &sig, NULL))) {
nsk_jvmti_setFailStatus();
return;
}
NSK_DISPLAY4("[%s] method ID=0x%p name=\"%s\" signature=\"%s\"\n",
event, (void*) tMethodID, name, sig);
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB4(GetBytecodes,
jvmti_env, tMethodID, &methBytesCount, &methBytes))) {
nsk_jvmti_setFailStatus();
return;
}
NSK_DISPLAY3("[%s] method bytes count=%d\n\
\tbytes count of the redefined method=%d\n",
event, methBytesCount, redefMethBytesCount);
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB2(Deallocate,
jvmti_env, (unsigned char*) methBytes)))
nsk_jvmti_setFailStatus();
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(IsMethodObsolete,
jvmti_env, tMethodID, &isObsolete))) {
nsk_jvmti_setFailStatus();
return;
}
if ((methBytesCount == redefMethBytesCount && isObsolete == JNI_TRUE) ||
(methBytesCount != redefMethBytesCount && isObsolete == JNI_FALSE)) {
NSK_DISPLAY3("[%s] CHECK PASSED: IsMethodObsolete = %d(%s) as expected\n",
event, (int)isObsolete,
(isObsolete==JNI_TRUE)?"TRUE":"FALSE");
}
else {
nsk_jvmti_setFailStatus();
NSK_COMPLAIN4("[%s] TEST FAILED: IsMethodObsolete = %d(%s), expected: %s\n",
event, (int)isObsolete,
(isObsolete == JNI_TRUE)?"TRUE":"FALSE",
(methBytesCount == redefMethBytesCount)?"TRUE":"FALSE");
}
}
/** callback functions **/
void JNICALL MethodEntry(jvmtiEnv *jvmti_env, JNIEnv *env,
jthread thr, jmethodID method) {
if (expectedMeth(jvmti_env, "MethodEntry",
method, expHSMethod, expHSSignature)==1) {
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB4(GetBytecodes,
jvmti_env, method, &redefMethBytesCount, &redefMethBytes)))
nsk_jvmti_setFailStatus();
else {
NSK_DISPLAY2("[MethodEntry] thread=0x%p method bytes count=%d\n",
thr, redefMethBytesCount);
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(NotifyFramePop,
jvmti_env, thr, 0)))
nsk_jvmti_setFailStatus();
}
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB4(SetEventNotificationMode,
jvmti_env, JVMTI_DISABLE, JVMTI_EVENT_METHOD_ENTRY, NULL)))
nsk_jvmti_setFailStatus();
}
}
void JNICALL
Exception(jvmtiEnv *jvmti_env, JNIEnv *env, jthread thr,
jmethodID method, jlocation location, jobject exception,
jmethodID catch_method, jlocation catch_location) {
if (expectedMeth(jvmti_env, "Exception",
method, expHSMethod, expHSSignature)==1) {
NSK_DISPLAY1("[Exception] thread=0x%p\n", thr);
doHotSwap(jvmti_env, method, "Exception");
doChecks(jvmti_env, method, JNI_TRUE, "Exception");
}
}
void JNICALL
MethodExit(jvmtiEnv *jvmti_env, JNIEnv *env,
jthread thr, jmethodID method,
jboolean was_poped_by_exc, jvalue return_value) {
if (expectedMeth(jvmti_env, "MethodExit",
method, expHSMethod, expHSSignature)==1) {
NSK_DISPLAY1("[MethodExit] thread=0x%p\n", thr);
doHotSwap(jvmti_env, method, "MethodExit");
doChecks(jvmti_env, method, JNI_TRUE, "MethodExit");
}
}
void JNICALL
FramePop(jvmtiEnv *jvmti_env, JNIEnv *env,
jthread thr, jmethodID method, jboolean wasPopedByException) {
if (expectedMeth(jvmti_env, "FramePop",
method, expHSMethod, expHSSignature)==1) {
NSK_DISPLAY1("[FramePop] thread=0x%p\n", thr);
doHotSwap(jvmti_env, method, "FramePop");
doChecks(jvmti_env, method, JNI_TRUE, "FramePop");
}
}
/************************/
/** agent's procedure **/
static void JNICALL
agentProc(jvmtiEnv* jvmti_env, JNIEnv* jni_env, void* arg) {
int tries = 0;
/* testing sync */
NSK_DISPLAY1("agentProc: waiting for the debuggee start for %d msecs...\n\n",
(int) timeout);
if (!nsk_jvmti_waitForSync(timeout))
return;
NSK_DISPLAY0("agentProc: resuming the debuggee ...\n\n");
if (!nsk_jvmti_resumeSync())
return;
/* testing sync */
NSK_DISPLAY1("agentProc: waiting for the debuggee finish for %d msecs...\n\n",
(int) timeout);
if (!nsk_jvmti_waitForSync(timeout))
return;
/* deallocating used memory */
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB2(Deallocate,
jvmti_env, (unsigned char*) redefMethBytes)))
nsk_jvmti_setFailStatus();
NSK_DISPLAY0("agentProc: final resuming of the debuggee ...\n\n");
if (!nsk_jvmti_resumeSync())
return;
NSK_DISPLAY0("agentProc: finished\n\n");
}
#ifdef STATIC_BUILD
JNIEXPORT jint JNICALL Agent_OnLoad_hs201t003(JavaVM *jvm, char *options, void *reserved) {
return Agent_Initialize(jvm, options, reserved);
}
JNIEXPORT jint JNICALL Agent_OnAttach_hs201t003(JavaVM *jvm, char *options, void *reserved) {
return Agent_Initialize(jvm, options, reserved);
}
JNIEXPORT jint JNI_OnLoad_hs201t003(JavaVM *jvm, char *options, void *reserved) {
return JNI_VERSION_1_8;
}
#endif
jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
jvmtiCapabilities caps;
jvmtiEventCallbacks callbacks;
/* init framework and parse options */
if (!NSK_VERIFY(nsk_jvmti_parseOptions(options)))
return JNI_ERR;
/* obtain WAITTIME parameter */
timeout = nsk_jvmti_getWaitTime() * 60000;
NSK_DISPLAY1("waittime=%d msecs\n", (int) timeout);
/* create JVMTI environment */
if (!NSK_VERIFY((jvmti =
nsk_jvmti_createJVMTIEnv(jvm, reserved)) != NULL))
return JNI_ERR;
/* add required capabilities */
memset(&caps, 0, sizeof(jvmtiCapabilities));
caps.can_get_bytecodes = 1;
caps.can_generate_exception_events = 1;
caps.can_generate_method_entry_events = 1;
caps.can_generate_method_exit_events = 1;
caps.can_generate_frame_pop_events = 1;
caps.can_redefine_classes = 1;
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB2(AddCapabilities,
jvmti, &caps)))
return JNI_ERR;
/* set event callback */
NSK_DISPLAY0("setting event callbacks ...\n");
(void) memset(&callbacks, 0, sizeof(callbacks));
callbacks.Exception = &Exception;
callbacks.MethodEntry = &MethodEntry;
callbacks.MethodExit = &MethodExit;
callbacks.FramePop = &FramePop;
if (!NSK_JVMTI_VERIFY(NSK_CPP_STUB3(SetEventCallbacks,
jvmti, &callbacks, sizeof(callbacks))))
return JNI_ERR;
NSK_DISPLAY0("setting event callbacks done\nenabling events ...\n");
if (!nsk_jvmti_enableEvents(JVMTI_ENABLE, EVENTS_COUNT,
eventsList, NULL))
return JNI_ERR;
NSK_DISPLAY0("enabling the events done\n\n");
/* register agent proc */
if (!NSK_VERIFY(nsk_jvmti_setAgentProc(agentProc, NULL)))
return JNI_ERR;
return JNI_OK;
}
}