< prev index next >

test/hotspot/jtreg/vmTestbase/nsk/jvmti/scenarios/sampling/SP06/sp06t002/sp06t002.cpp

Print this page
rev 52100 : 8212082: Remove the NSK_CPP_STUB macros for remaining vmTestbase/jvmti/[sS]*
Summary:
Reviewed-by:


 126             return;
 127 
 128         NSK_DISPLAY0("Clean data\n");
 129         if (!clean()) {
 130             nsk_jvmti_setFailStatus();
 131             return;
 132         }
 133     }
 134 
 135     NSK_DISPLAY0("Let debuggee to finish\n");
 136     if (!nsk_jvmti_resumeSync())
 137         return;
 138 }
 139 
 140 /* ============================================================================= */
 141 
 142 /**
 143  * Generate missed events (COMPILED_METHOD_LOAD only).
 144  */
 145 static int generateEvents() {
 146     if (!NSK_JVMTI_VERIFY(
 147             NSK_CPP_STUB2(GenerateEvents, jvmti, JVMTI_EVENT_COMPILED_METHOD_LOAD))) {
 148         nsk_jvmti_setFailStatus();
 149         return NSK_FALSE;
 150     }
 151     return NSK_TRUE;
 152 }
 153 
 154 /**
 155  * Prepare data.
 156  *    - clean threads list
 157  *    - get all live threads
 158  *    - get threads name
 159  *    - find tested threads
 160  *    - make global refs
 161  *    - enable events
 162  */
 163 static int prepare() {
 164     jthread *allThreadsList = NULL;
 165     jint allThreadsCount = 0;
 166     int found = 0;
 167     int i;
 168 
 169     NSK_DISPLAY1("Find tested threads: %d\n", THREADS_COUNT);
 170 
 171     /* clean threads list */
 172     for (i = 0; i < THREADS_COUNT; i++) {
 173         threadsDesc[i].thread = (jthread)NULL;
 174         threadsDesc[i].method = (jmethodID)NULL;
 175         threadsDesc[i].location = NSK_JVMTI_INVALID_JLOCATION;
 176         threadsDesc[i].methodCompiled = NSK_FALSE;
 177     }
 178 
 179     /* get all live threads */
 180     if (!NSK_JVMTI_VERIFY(
 181             NSK_CPP_STUB3(GetAllThreads, jvmti, &allThreadsCount, &allThreadsList)))
 182         return NSK_FALSE;
 183 
 184     if (!NSK_VERIFY(allThreadsCount > 0 && allThreadsList != NULL))
 185         return NSK_FALSE;
 186 
 187     /* find tested threads */
 188     for (i = 0; i < allThreadsCount; i++) {
 189         jvmtiThreadInfo threadInfo;
 190 
 191         if (!NSK_VERIFY(allThreadsList[i] != NULL))
 192             return NSK_FALSE;
 193 
 194         if (!NSK_JVMTI_VERIFY(
 195                 NSK_CPP_STUB3(GetThreadInfo, jvmti, allThreadsList[i], &threadInfo)))
 196             return NSK_FALSE;
 197 
 198         if (threadInfo.name != NULL) {
 199             int j;
 200 
 201             for (j = 0; j < THREADS_COUNT; j++) {
 202                 if (strcmp(threadInfo.name, threadsDesc[j].threadName) == 0) {
 203                     threadsDesc[j].thread = allThreadsList[i];
 204                     NSK_DISPLAY3("    thread #%d (%s): 0x%p\n",
 205                                             j, threadInfo.name, (void*)threadsDesc[j].thread);
 206                 }
 207             }
 208         }
 209     }
 210 
 211     /* deallocate all threads list */
 212     if (!NSK_JVMTI_VERIFY(
 213             NSK_CPP_STUB2(Deallocate, jvmti, (unsigned char*)allThreadsList)))
 214         return NSK_FALSE;
 215 
 216     /* check if all tested threads found */
 217     found = 0;
 218     for (i = 0; i < THREADS_COUNT; i++) {
 219         if (threadsDesc[i].thread == NULL) {
 220             NSK_COMPLAIN2("Not found tested thread #%d (%s)\n", i, threadsDesc[i].threadName);
 221         } else {
 222             found++;
 223         }
 224     }
 225 
 226     if (found < THREADS_COUNT)
 227         return NSK_FALSE;
 228 
 229     /* get threads class and frame method */
 230     NSK_DISPLAY0("Find tested methods:\n");
 231     for (i = 0; i < THREADS_COUNT; i++) {
 232 
 233         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].cls =
 234                 NSK_CPP_STUB2(GetObjectClass, jni, threadsDesc[i].thread)) != NULL))
 235             return NSK_FALSE;
 236 
 237         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].method =
 238                 NSK_CPP_STUB4(GetMethodID, jni, threadsDesc[i].cls,
 239                             threadsDesc[i].methodName, threadsDesc[i].methodSig)) != NULL))
 240             return NSK_FALSE;
 241 
 242         NSK_DISPLAY4("    thread #%d (%s): 0x%p (%s)\n",
 243                                 i, threadsDesc[i].threadName,
 244                                 (void*)threadsDesc[i].method,
 245                                 threadsDesc[i].methodName);
 246     }
 247 
 248     /* make global refs */
 249     for (i = 0; i < THREADS_COUNT; i++) {
 250         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].thread = (jthread)
 251                 NSK_CPP_STUB2(NewGlobalRef, jni, threadsDesc[i].thread)) != NULL))
 252             return NSK_FALSE;
 253         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].cls = (jclass)
 254                 NSK_CPP_STUB2(NewGlobalRef, jni, threadsDesc[i].cls)) != NULL))
 255             return NSK_FALSE;
 256     }
 257 
 258     NSK_DISPLAY0("Enable tested events\n");
 259     if (!nsk_jvmti_enableEvents(JVMTI_ENABLE, EVENTS_COUNT, eventsList, NULL))
 260         return NSK_FALSE;
 261 
 262     return NSK_TRUE;
 263 }
 264 
 265 /**
 266  * Suspend or resume tested threads.
 267  */
 268 static int suspendThreadsIndividually(int suspend) {
 269     int i;
 270 
 271     for (i = 0; i < THREADS_COUNT; i++) {
 272         if (suspend) {
 273             NSK_DISPLAY2("    suspend thread #%d (%s)\n", i, threadsDesc[i].threadName);
 274             if (!NSK_JVMTI_VERIFY(
 275                     NSK_CPP_STUB2(SuspendThread, jvmti, threadsDesc[i].thread)))
 276                 nsk_jvmti_setFailStatus();
 277         } else {
 278             NSK_DISPLAY2("    resume thread #%d (%s)\n", i, threadsDesc[i].threadName);
 279             if (!NSK_JVMTI_VERIFY(
 280                     NSK_CPP_STUB2(ResumeThread, jvmti, threadsDesc[i].thread)))
 281                 nsk_jvmti_setFailStatus();
 282         }
 283     }
 284     return NSK_TRUE;
 285 }
 286 
 287 /**
 288  * Testcase: check tested threads.
 289  *    - call GetFrameCount() and getStackTrace()
 290  *    - for suspended thread compare number of stack frames returned
 291  *    - find stack frames with expected methodID
 292  *
 293  * Returns NSK_TRUE if test may continue; or NSK_FALSE for test break.
 294  */
 295 static int checkThreads(int suspended, const char* kind0) {
 296     char kind[256] = "";
 297     int i;
 298 
 299     /* check each thread */
 300     for (i = 0; i < THREADS_COUNT; i++) {
 301         jint frameCount = 0;
 302         jint frameStackSize = 0;
 303         jvmtiFrameInfo frameStack[MAX_STACK_SIZE];
 304         int found = 0;
 305         int j;
 306 
 307         /* make proper kind */
 308         strcpy(kind, threadsDesc[i].methodCompiled ? "compiled " : "not compiled ");
 309         strcat(kind, kind0);
 310         NSK_DISPLAY2("  thread #%d (%s):\n", i, threadsDesc[i].threadName);
 311 
 312         /* get frame count */
 313         if (!NSK_JVMTI_VERIFY(
 314                 NSK_CPP_STUB3(GetFrameCount, jvmti,
 315                                     threadsDesc[i].thread, &frameCount))) {
 316             nsk_jvmti_setFailStatus();
 317             return NSK_TRUE;
 318         }
 319 
 320         NSK_DISPLAY1("    frameCount:  %d\n", (int)frameCount);
 321 
 322         /* get stack trace */
 323         if (!NSK_JVMTI_VERIFY(
 324                 NSK_CPP_STUB6(GetStackTrace, jvmti, threadsDesc[i].thread,
 325                                     0, MAX_STACK_SIZE, frameStack, &frameStackSize))) {
 326             nsk_jvmti_setFailStatus();
 327             return NSK_TRUE;
 328         }
 329 
 330         NSK_DISPLAY1("    stack depth: %d\n", (int)frameStackSize);
 331 
 332         /*  Only check for suspended threads: running threads might have different
 333             frames between stack grabbing calls. */
 334         if (suspended && (frameStackSize != frameCount)) {
 335             NSK_COMPLAIN5("Different frames count for %s thread #%d (%s):\n"
 336                           "#   getStackTrace(): %d\n"
 337                           "#   getFrameCount(): %d\n",
 338                           kind, i, threadsDesc[i].threadName,
 339                           (int)frameStackSize, (int)frameCount);
 340             nsk_jvmti_setFailStatus();
 341         }
 342 
 343         /* find method on the stack */
 344         found = 0;
 345         for (j = 0; j < frameStackSize; j++) {


 370     }
 371 
 372     /* test may continue */
 373     return NSK_TRUE;
 374 }
 375 
 376 /**
 377  * Clean data.
 378  *   - disable events
 379  *   - dispose global references to tested threads
 380  */
 381 static int clean() {
 382     int i;
 383 
 384     NSK_DISPLAY0("Disable events\n");
 385     if (!nsk_jvmti_enableEvents(JVMTI_DISABLE, EVENTS_COUNT, eventsList, NULL))
 386         return NSK_FALSE;
 387 
 388     NSK_DISPLAY0("Dispose global references to threads\n");
 389     for (i = 0; i < THREADS_COUNT; i++) {
 390         NSK_TRACE(NSK_CPP_STUB2(DeleteGlobalRef, jni, threadsDesc[i].thread));
 391         NSK_TRACE(NSK_CPP_STUB2(DeleteGlobalRef, jni, threadsDesc[i].cls));
 392     }
 393 
 394     return NSK_TRUE;
 395 }
 396 
 397 /* ============================================================================= */
 398 
 399 /**
 400  * COMPILED_METHOD_LOAD callback.
 401  *   - turn on flag that method is compiled
 402  */
 403 JNIEXPORT void JNICALL
 404 callbackCompiledMethodLoad(jvmtiEnv* jvmti, jmethodID method,
 405                             jint code_size, const void* code_addr,
 406                             jint map_length, const jvmtiAddrLocationMap* map,
 407                             const void* compile_info) {
 408     int i;
 409 
 410     /* check if event is for tested method and turn flag on */
 411     for (i = 0; i < THREADS_COUNT; i++) {


 504 JNIEXPORT jint JNI_OnLoad_sp06t002(JavaVM *jvm, char *options, void *reserved) {
 505     return JNI_VERSION_1_8;
 506 }
 507 #endif
 508 jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
 509 
 510     if (!NSK_VERIFY(nsk_jvmti_parseOptions(options)))
 511         return JNI_ERR;
 512 
 513     timeout = nsk_jvmti_getWaitTime() * 60 * 1000;
 514 
 515     if (!NSK_VERIFY((jvmti =
 516             nsk_jvmti_createJVMTIEnv(jvm, reserved)) != NULL))
 517         return JNI_ERR;
 518 
 519     {
 520         jvmtiCapabilities caps;
 521         memset(&caps, 0, sizeof(caps));
 522         caps.can_suspend = 1;
 523         caps.can_generate_compiled_method_load_events = 1;
 524         if (!NSK_JVMTI_VERIFY(
 525                 NSK_CPP_STUB2(AddCapabilities, jvmti, &caps)))
 526             return JNI_ERR;
 527     }
 528 
 529     {
 530         jvmtiEventCallbacks eventCallbacks;
 531         memset(&eventCallbacks, 0, sizeof(eventCallbacks));
 532         eventCallbacks.CompiledMethodLoad = callbackCompiledMethodLoad;
 533         eventCallbacks.CompiledMethodUnload = callbackCompiledMethodUnload;
 534         if (!NSK_JVMTI_VERIFY(
 535                 NSK_CPP_STUB3(SetEventCallbacks, jvmti,
 536                                     &eventCallbacks, sizeof(eventCallbacks))))
 537             return JNI_ERR;
 538     }
 539 
 540     if (!NSK_VERIFY(nsk_jvmti_setAgentProc(agentProc, NULL)))
 541         return JNI_ERR;
 542 
 543     return JNI_OK;
 544 }
 545 
 546 /* ============================================================================= */
 547 
 548 }


 126             return;
 127 
 128         NSK_DISPLAY0("Clean data\n");
 129         if (!clean()) {
 130             nsk_jvmti_setFailStatus();
 131             return;
 132         }
 133     }
 134 
 135     NSK_DISPLAY0("Let debuggee to finish\n");
 136     if (!nsk_jvmti_resumeSync())
 137         return;
 138 }
 139 
 140 /* ============================================================================= */
 141 
 142 /**
 143  * Generate missed events (COMPILED_METHOD_LOAD only).
 144  */
 145 static int generateEvents() {
 146     if (!NSK_JVMTI_VERIFY(jvmti->GenerateEvents(JVMTI_EVENT_COMPILED_METHOD_LOAD))) {

 147         nsk_jvmti_setFailStatus();
 148         return NSK_FALSE;
 149     }
 150     return NSK_TRUE;
 151 }
 152 
 153 /**
 154  * Prepare data.
 155  *    - clean threads list
 156  *    - get all live threads
 157  *    - get threads name
 158  *    - find tested threads
 159  *    - make global refs
 160  *    - enable events
 161  */
 162 static int prepare() {
 163     jthread *allThreadsList = NULL;
 164     jint allThreadsCount = 0;
 165     int found = 0;
 166     int i;
 167 
 168     NSK_DISPLAY1("Find tested threads: %d\n", THREADS_COUNT);
 169 
 170     /* clean threads list */
 171     for (i = 0; i < THREADS_COUNT; i++) {
 172         threadsDesc[i].thread = (jthread)NULL;
 173         threadsDesc[i].method = (jmethodID)NULL;
 174         threadsDesc[i].location = NSK_JVMTI_INVALID_JLOCATION;
 175         threadsDesc[i].methodCompiled = NSK_FALSE;
 176     }
 177 
 178     /* get all live threads */
 179     if (!NSK_JVMTI_VERIFY(jvmti->GetAllThreads(&allThreadsCount, &allThreadsList)))

 180         return NSK_FALSE;
 181 
 182     if (!NSK_VERIFY(allThreadsCount > 0 && allThreadsList != NULL))
 183         return NSK_FALSE;
 184 
 185     /* find tested threads */
 186     for (i = 0; i < allThreadsCount; i++) {
 187         jvmtiThreadInfo threadInfo;
 188 
 189         if (!NSK_VERIFY(allThreadsList[i] != NULL))
 190             return NSK_FALSE;
 191 
 192         if (!NSK_JVMTI_VERIFY(jvmti->GetThreadInfo(allThreadsList[i], &threadInfo)))

 193             return NSK_FALSE;
 194 
 195         if (threadInfo.name != NULL) {
 196             int j;
 197 
 198             for (j = 0; j < THREADS_COUNT; j++) {
 199                 if (strcmp(threadInfo.name, threadsDesc[j].threadName) == 0) {
 200                     threadsDesc[j].thread = allThreadsList[i];
 201                     NSK_DISPLAY3("    thread #%d (%s): 0x%p\n",
 202                                             j, threadInfo.name, (void*)threadsDesc[j].thread);
 203                 }
 204             }
 205         }
 206     }
 207 
 208     /* deallocate all threads list */
 209     if (!NSK_JVMTI_VERIFY(jvmti->Deallocate((unsigned char*)allThreadsList)))

 210         return NSK_FALSE;
 211 
 212     /* check if all tested threads found */
 213     found = 0;
 214     for (i = 0; i < THREADS_COUNT; i++) {
 215         if (threadsDesc[i].thread == NULL) {
 216             NSK_COMPLAIN2("Not found tested thread #%d (%s)\n", i, threadsDesc[i].threadName);
 217         } else {
 218             found++;
 219         }
 220     }
 221 
 222     if (found < THREADS_COUNT)
 223         return NSK_FALSE;
 224 
 225     /* get threads class and frame method */
 226     NSK_DISPLAY0("Find tested methods:\n");
 227     for (i = 0; i < THREADS_COUNT; i++) {
 228 
 229         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].cls =
 230                 jni->GetObjectClass(threadsDesc[i].thread)) != NULL))
 231             return NSK_FALSE;
 232 
 233         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].method =
 234                 jni->GetMethodID(threadsDesc[i].cls, threadsDesc[i].methodName, threadsDesc[i].methodSig)) != NULL))

 235             return NSK_FALSE;
 236 
 237         NSK_DISPLAY4("    thread #%d (%s): 0x%p (%s)\n",
 238                                 i, threadsDesc[i].threadName,
 239                                 (void*)threadsDesc[i].method,
 240                                 threadsDesc[i].methodName);
 241     }
 242 
 243     /* make global refs */
 244     for (i = 0; i < THREADS_COUNT; i++) {
 245         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].thread = (jthread)
 246                 jni->NewGlobalRef(threadsDesc[i].thread)) != NULL))
 247             return NSK_FALSE;
 248         if (!NSK_JNI_VERIFY(jni, (threadsDesc[i].cls = (jclass)
 249                 jni->NewGlobalRef(threadsDesc[i].cls)) != NULL))
 250             return NSK_FALSE;
 251     }
 252 
 253     NSK_DISPLAY0("Enable tested events\n");
 254     if (!nsk_jvmti_enableEvents(JVMTI_ENABLE, EVENTS_COUNT, eventsList, NULL))
 255         return NSK_FALSE;
 256 
 257     return NSK_TRUE;
 258 }
 259 
 260 /**
 261  * Suspend or resume tested threads.
 262  */
 263 static int suspendThreadsIndividually(int suspend) {
 264     int i;
 265 
 266     for (i = 0; i < THREADS_COUNT; i++) {
 267         if (suspend) {
 268             NSK_DISPLAY2("    suspend thread #%d (%s)\n", i, threadsDesc[i].threadName);
 269             if (!NSK_JVMTI_VERIFY(jvmti->SuspendThread(threadsDesc[i].thread)))

 270                 nsk_jvmti_setFailStatus();
 271         } else {
 272             NSK_DISPLAY2("    resume thread #%d (%s)\n", i, threadsDesc[i].threadName);
 273             if (!NSK_JVMTI_VERIFY(jvmti->ResumeThread(threadsDesc[i].thread)))

 274                 nsk_jvmti_setFailStatus();
 275         }
 276     }
 277     return NSK_TRUE;
 278 }
 279 
 280 /**
 281  * Testcase: check tested threads.
 282  *    - call GetFrameCount() and getStackTrace()
 283  *    - for suspended thread compare number of stack frames returned
 284  *    - find stack frames with expected methodID
 285  *
 286  * Returns NSK_TRUE if test may continue; or NSK_FALSE for test break.
 287  */
 288 static int checkThreads(int suspended, const char* kind0) {
 289     char kind[256] = "";
 290     int i;
 291 
 292     /* check each thread */
 293     for (i = 0; i < THREADS_COUNT; i++) {
 294         jint frameCount = 0;
 295         jint frameStackSize = 0;
 296         jvmtiFrameInfo frameStack[MAX_STACK_SIZE];
 297         int found = 0;
 298         int j;
 299 
 300         /* make proper kind */
 301         strcpy(kind, threadsDesc[i].methodCompiled ? "compiled " : "not compiled ");
 302         strcat(kind, kind0);
 303         NSK_DISPLAY2("  thread #%d (%s):\n", i, threadsDesc[i].threadName);
 304 
 305         /* get frame count */
 306         if (!NSK_JVMTI_VERIFY(jvmti->GetFrameCount(threadsDesc[i].thread, &frameCount))) {


 307             nsk_jvmti_setFailStatus();
 308             return NSK_TRUE;
 309         }
 310 
 311         NSK_DISPLAY1("    frameCount:  %d\n", (int)frameCount);
 312 
 313         /* get stack trace */
 314         if (!NSK_JVMTI_VERIFY(
 315                 jvmti->GetStackTrace(threadsDesc[i].thread, 0, MAX_STACK_SIZE, frameStack, &frameStackSize))) {

 316             nsk_jvmti_setFailStatus();
 317             return NSK_TRUE;
 318         }
 319 
 320         NSK_DISPLAY1("    stack depth: %d\n", (int)frameStackSize);
 321 
 322         /*  Only check for suspended threads: running threads might have different
 323             frames between stack grabbing calls. */
 324         if (suspended && (frameStackSize != frameCount)) {
 325             NSK_COMPLAIN5("Different frames count for %s thread #%d (%s):\n"
 326                           "#   getStackTrace(): %d\n"
 327                           "#   getFrameCount(): %d\n",
 328                           kind, i, threadsDesc[i].threadName,
 329                           (int)frameStackSize, (int)frameCount);
 330             nsk_jvmti_setFailStatus();
 331         }
 332 
 333         /* find method on the stack */
 334         found = 0;
 335         for (j = 0; j < frameStackSize; j++) {


 360     }
 361 
 362     /* test may continue */
 363     return NSK_TRUE;
 364 }
 365 
 366 /**
 367  * Clean data.
 368  *   - disable events
 369  *   - dispose global references to tested threads
 370  */
 371 static int clean() {
 372     int i;
 373 
 374     NSK_DISPLAY0("Disable events\n");
 375     if (!nsk_jvmti_enableEvents(JVMTI_DISABLE, EVENTS_COUNT, eventsList, NULL))
 376         return NSK_FALSE;
 377 
 378     NSK_DISPLAY0("Dispose global references to threads\n");
 379     for (i = 0; i < THREADS_COUNT; i++) {
 380         NSK_TRACE(jni->DeleteGlobalRef(threadsDesc[i].thread));
 381         NSK_TRACE(jni->DeleteGlobalRef(threadsDesc[i].cls));
 382     }
 383 
 384     return NSK_TRUE;
 385 }
 386 
 387 /* ============================================================================= */
 388 
 389 /**
 390  * COMPILED_METHOD_LOAD callback.
 391  *   - turn on flag that method is compiled
 392  */
 393 JNIEXPORT void JNICALL
 394 callbackCompiledMethodLoad(jvmtiEnv* jvmti, jmethodID method,
 395                             jint code_size, const void* code_addr,
 396                             jint map_length, const jvmtiAddrLocationMap* map,
 397                             const void* compile_info) {
 398     int i;
 399 
 400     /* check if event is for tested method and turn flag on */
 401     for (i = 0; i < THREADS_COUNT; i++) {


 494 JNIEXPORT jint JNI_OnLoad_sp06t002(JavaVM *jvm, char *options, void *reserved) {
 495     return JNI_VERSION_1_8;
 496 }
 497 #endif
 498 jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
 499 
 500     if (!NSK_VERIFY(nsk_jvmti_parseOptions(options)))
 501         return JNI_ERR;
 502 
 503     timeout = nsk_jvmti_getWaitTime() * 60 * 1000;
 504 
 505     if (!NSK_VERIFY((jvmti =
 506             nsk_jvmti_createJVMTIEnv(jvm, reserved)) != NULL))
 507         return JNI_ERR;
 508 
 509     {
 510         jvmtiCapabilities caps;
 511         memset(&caps, 0, sizeof(caps));
 512         caps.can_suspend = 1;
 513         caps.can_generate_compiled_method_load_events = 1;
 514         if (!NSK_JVMTI_VERIFY(jvmti->AddCapabilities(&caps)))

 515             return JNI_ERR;
 516     }
 517 
 518     {
 519         jvmtiEventCallbacks eventCallbacks;
 520         memset(&eventCallbacks, 0, sizeof(eventCallbacks));
 521         eventCallbacks.CompiledMethodLoad = callbackCompiledMethodLoad;
 522         eventCallbacks.CompiledMethodUnload = callbackCompiledMethodUnload;
 523         if (!NSK_JVMTI_VERIFY(jvmti->SetEventCallbacks(&eventCallbacks, sizeof(eventCallbacks))))


 524             return JNI_ERR;
 525     }
 526 
 527     if (!NSK_VERIFY(nsk_jvmti_setAgentProc(agentProc, NULL)))
 528         return JNI_ERR;
 529 
 530     return JNI_OK;
 531 }
 532 
 533 /* ============================================================================= */
 534 
 535 }
< prev index next >