8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <jvmti.h>
27 #include "agent_common.h"
28
29 #include "nsk_tools.h"
30 #include "jni_tools.h"
31 #include "JVMTITools.h"
32 #include "jvmti_tools.h"
33
34 extern "C" {
35
36 #define OBJ_MAX_COUNT 100000
37
38 static JNIEnv *jni = NULL;
39 static jvmtiEnv *jvmti = NULL;
40 static jvmtiEventCallbacks callbacks;
41 static jvmtiCapabilities caps;
42
43 static jlong timeout = 0;
44
45 static const char* DEBUGEE_SIGNATURE = "Lnsk/jvmti/scenarios/allocation/AP04/ap04t003;";
46 static const char* ROOT_SIGNATURE = "[Lnsk/jvmti/scenarios/allocation/AP04/ap04t003;";
47
48 static jclass debugeeClass = NULL;
288 }
289
290 /* enter and notify endLock */
291 {
292 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(endLock))) {
293 nsk_jvmti_setFailStatus();
294 }
295 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorNotify(endLock))) {
296 nsk_jvmti_setFailStatus();
297 }
298 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(endLock))) {
299 nsk_jvmti_setFailStatus();
300 }
301 }
302
303 NSK_DISPLAY0("Agent thread: finished.\n");
304 }
305
306 /***********************************************************************/
307
308 static int startThread(JNIEnv* jni, jthread threadObj) {
309 int success = NSK_TRUE;
310
311 /* enter startLock */
312 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(startLock))) {
313 nsk_jvmti_setFailStatus();
314 }
315
316 /* start thread */
317 if (!NSK_JVMTI_VERIFY(
318 jvmti->RunAgentThread(threadObj, agent_start, NULL, JVMTI_THREAD_NORM_PRIORITY))) {
319 success = NSK_FALSE;
320 nsk_jvmti_setFailStatus();
321 } else {
322 /* wait on startLock */
323 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorWait(startLock, timeout))) {
324 nsk_jvmti_setFailStatus();
325 }
326 }
327
328 /* exit starLock */
329 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(startLock))) {
330 nsk_jvmti_setFailStatus();
331 }
332
333 return success;
334 }
335
336 /** Create thread object for new agent thread. */
337 static jthread newThreadObj(JNIEnv* jni) {
338 jclass thrClass;
339 jmethodID cid;
340 jthread result = NULL;
341
342 thrClass = jni->FindClass("java/lang/Thread");
343 if (!NSK_JNI_VERIFY(jni, thrClass != NULL)) {
344 nsk_jvmti_setFailStatus();
345 return result;
346 }
347
348 cid = jni->GetMethodID(thrClass, "<init>", "()V");
349 if (!NSK_JNI_VERIFY(jni, cid != NULL)) {
350 nsk_jvmti_setFailStatus();
351 return result;
352 }
353
354 result = jni->NewObject(thrClass, cid);
355 if (!NSK_JNI_VERIFY(jni, result != NULL)) {
356 nsk_jvmti_setFailStatus();
357 return result;
358 }
359
360 return result;
361 }
362
363 /***********************************************************************/
364
365 /** Clean counters and start new agent thread with agent_start() body. */
366 static int prepareToIteration (JNIEnv* jni) {
367 jthread threadObj = NULL;
368
369 setCounter(&iterationCount, 0);
370 setCounter(&objectCount, 0);
371
372 threadObj = newThreadObj(jni);
373 if (!NSK_VERIFY(threadObj != NULL)) {
374 nsk_jvmti_setFailStatus();
375 return NSK_FALSE;
376 }
377
378 /* enter endLock */
379 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(endLock))) {
380 nsk_jvmti_setFailStatus();
381 }
382
383 NSK_DISPLAY0("Starting new agent thread...\n");
384 return startThread(jni, threadObj);
385 }
386
387 /** Wait for new agent thread to complete. */
388 static void afterIteration (JNIEnv* jni) {
389
390 /* notify new agent thread (in case if not yet notified) */
391 notifyThread();
392
393 NSK_DISPLAY0("Wait for new agent thread to complete\n");
394
395 /* wait on endLock */
396 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorWait(endLock, timeout))) {
397 nsk_jvmti_setFailStatus();
398 }
399
400 /* exit endLock */
401 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(endLock))) {
402 nsk_jvmti_setFailStatus();
403 }
404 }
405
406 /***********************************************************************/
407
408 JNIEXPORT void JNICALL
416 }
417 }
418
419 JNIEXPORT void JNICALL
420 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverHeap(JNIEnv* jni,
421 jclass klass) {
422 int modified = 0;
423 int found = 0;
424
425 if (!prepareToIteration(jni))
426 return;
427
428 NSK_DISPLAY0("Calling IterateOverHeap...\n");
429 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverHeap(JVMTI_HEAP_OBJECT_TAGGED,
430 heapObjectCallback,
431 NULL /*user_data*/))) {
432 nsk_jvmti_setFailStatus();
433 }
434 NSK_DISPLAY0("IterateOverHeap finished.\n");
435
436 afterIteration(jni);
437
438 found = getCounter(&objectCount);
439 NSK_DISPLAY1("Found tagged objects: %d\n", found);
440
441 modified = OBJ_MAX_COUNT - found;
442 if (modified > 0) {
443 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
444 modified, OBJ_MAX_COUNT);
445 nsk_jvmti_setFailStatus();
446 }
447 }
448
449 JNIEXPORT void JNICALL
450 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverReachableObjects(JNIEnv* jni,
451 jclass klass) {
452 int modified = 0;
453 int found = 0;
454
455 if (!prepareToIteration(jni))
456 return;
457
458 NSK_DISPLAY0("Calling IterateOverReachableObjects...\n");
459 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverReachableObjects(heapRootCallback,
460 stackReferenceCallback,
461 objectReferenceCallback,
462 NULL /*user_data*/))) {
463 nsk_jvmti_setFailStatus();
464 }
465 NSK_DISPLAY0("IterateOverReachableObjects finished.\n");
466
467 afterIteration(jni);
468
469 found = getCounter(&objectCount);
470 NSK_DISPLAY1("Found tagged objects: %d\n", found);
471
472 modified = OBJ_MAX_COUNT - found;
473 if (modified > 0) {
474 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
475 modified, OBJ_MAX_COUNT);
476 nsk_jvmti_setFailStatus();
477 }
478 }
479
480 JNIEXPORT void JNICALL
481 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverInstancesOfClass(JNIEnv* jni,
482 jclass klass) {
483 int modified = 0;
484 int found = 0;
485
486 if (!prepareToIteration(jni))
487 return;
488
489 NSK_DISPLAY0("Calling IterateOverInstancesOfClass...\n");
490 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverInstancesOfClass(debugeeClass,
491 JVMTI_HEAP_OBJECT_TAGGED,
492 heapObjectCallback,
493 NULL /*user_data*/))) {
494 nsk_jvmti_setFailStatus();
495 }
496 NSK_DISPLAY0("IterateOverInstancesOfClass finished.\n");
497
498 afterIteration(jni);
499
500 found = getCounter(&objectCount);
501 NSK_DISPLAY1("Found tagged objects: %d\n", found);
502
503 modified = OBJ_MAX_COUNT - found;
504 if (modified > 0) {
505 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
506 modified, OBJ_MAX_COUNT);
507 nsk_jvmti_setFailStatus();
508 }
509 }
510
511 JNIEXPORT void JNICALL
512 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverObjectsReachableFromObject(JNIEnv* jni,
513 jclass klass) {
514 jobject root = NULL;
515 int modified = 0;
516 int found = 0;
517
518 root = jni->GetStaticObjectField(debugeeClass, rootFieldID);
519 if (!NSK_JNI_VERIFY(jni, root != NULL)) {
520 NSK_COMPLAIN0("GetStaticObjectField returned NULL for 'root' field value\n\n");
521 nsk_jvmti_setFailStatus();
522 return;
523 }
524
525 if (!prepareToIteration(jni))
526 return;
527
528 NSK_DISPLAY0("Calling IterateOverObjectsReachableFromObject...\n");
529 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverObjectsReachableFromObject(root,
530 objectReferenceCallback,
531 NULL /*user_data*/))) {
532 nsk_jvmti_setFailStatus();
533 }
534 NSK_DISPLAY0("IterateOverObjectsReachableFromObject finished.\n");
535
536 afterIteration(jni);
537
538 found = getCounter(&objectCount);
539 NSK_DISPLAY1("Found tagged objects: %d\n", found);
540
541 modified = OBJ_MAX_COUNT - found;
542 if (modified > 0) {
543 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
544 modified, OBJ_MAX_COUNT);
545 nsk_jvmti_setFailStatus();
546 }
547 }
548
549 static void JNICALL
550 agentProc(jvmtiEnv* jvmti, JNIEnv* jni, void* arg) {
551
552 NSK_DISPLAY0("Wait for debugee start\n\n");
553 if (!NSK_VERIFY(nsk_jvmti_waitForSync(timeout)))
554 return;
555
556 NSK_DISPLAY1("Find debugee class: %s\n", DEBUGEE_SIGNATURE);
557 debugeeClass = nsk_jvmti_classBySignature(DEBUGEE_SIGNATURE);
558 if (debugeeClass == NULL) {
559 nsk_jvmti_setFailStatus();
560 return;
561 }
562
563 debugeeClass = (jclass) jni->NewGlobalRef(debugeeClass);
564 if (!NSK_JNI_VERIFY(jni, debugeeClass != NULL))
565 return;
566
567 NSK_DISPLAY1("Find ID of 'root' field: %s\n", ROOT_SIGNATURE);
568 rootFieldID = jni->GetStaticFieldID(debugeeClass, "root", ROOT_SIGNATURE);
569 if (!NSK_JNI_VERIFY(jni, rootFieldID != NULL)) {
570 nsk_jvmti_setFailStatus();
571 return;
572 }
573
574 NSK_DISPLAY0("Let debugee to run test cases\n");
575 if (!NSK_VERIFY(nsk_jvmti_resumeSync()))
576 return;
577
578 NSK_DISPLAY0("Wait for completion of test cases\n\n");
579 if (!NSK_VERIFY(nsk_jvmti_waitForSync(timeout)))
580 return;
581
582 NSK_TRACE(jni->DeleteGlobalRef(debugeeClass));
583 NSK_TRACE(jvmti->DestroyRawMonitor(counterMonitor_ptr));
584 NSK_TRACE(jvmti->DestroyRawMonitor(startLock));
585 NSK_TRACE(jvmti->DestroyRawMonitor(runLock));
586 NSK_TRACE(jvmti->DestroyRawMonitor(endLock));
587
588 NSK_DISPLAY0("Let debugee to finish\n");
589 if (!NSK_VERIFY(nsk_jvmti_resumeSync()))
590 return;
591 }
592
593 #ifdef STATIC_BUILD
594 JNIEXPORT jint JNICALL Agent_OnLoad_ap04t003(JavaVM *jvm, char *options, void *reserved) {
595 return Agent_Initialize(jvm, options, reserved);
596 }
597 JNIEXPORT jint JNICALL Agent_OnAttach_ap04t003(JavaVM *jvm, char *options, void *reserved) {
598 return Agent_Initialize(jvm, options, reserved);
599 }
600 JNIEXPORT jint JNI_OnLoad_ap04t003(JavaVM *jvm, char *options, void *reserved) {
601 return JNI_VERSION_1_8;
602 }
|
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #include <stdio.h>
25 #include <string.h>
26 #include <jvmti.h>
27 #include "agent_common.h"
28 #include "ExceptionCheckingJniEnv.hpp"
29 #include "nsk_tools.h"
30 #include "jni_tools.h"
31 #include "JVMTITools.h"
32 #include "jvmti_tools.h"
33
34 extern "C" {
35
36 #define OBJ_MAX_COUNT 100000
37
38 static JNIEnv *jni = NULL;
39 static jvmtiEnv *jvmti = NULL;
40 static jvmtiEventCallbacks callbacks;
41 static jvmtiCapabilities caps;
42
43 static jlong timeout = 0;
44
45 static const char* DEBUGEE_SIGNATURE = "Lnsk/jvmti/scenarios/allocation/AP04/ap04t003;";
46 static const char* ROOT_SIGNATURE = "[Lnsk/jvmti/scenarios/allocation/AP04/ap04t003;";
47
48 static jclass debugeeClass = NULL;
288 }
289
290 /* enter and notify endLock */
291 {
292 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(endLock))) {
293 nsk_jvmti_setFailStatus();
294 }
295 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorNotify(endLock))) {
296 nsk_jvmti_setFailStatus();
297 }
298 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(endLock))) {
299 nsk_jvmti_setFailStatus();
300 }
301 }
302
303 NSK_DISPLAY0("Agent thread: finished.\n");
304 }
305
306 /***********************************************************************/
307
308 static int startThread(jthread threadObj) {
309 int success = NSK_TRUE;
310
311 /* enter startLock */
312 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(startLock))) {
313 nsk_jvmti_setFailStatus();
314 }
315
316 /* start thread */
317 if (!NSK_JVMTI_VERIFY(
318 jvmti->RunAgentThread(threadObj, agent_start, NULL, JVMTI_THREAD_NORM_PRIORITY))) {
319 success = NSK_FALSE;
320 nsk_jvmti_setFailStatus();
321 } else {
322 /* wait on startLock */
323 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorWait(startLock, timeout))) {
324 nsk_jvmti_setFailStatus();
325 }
326 }
327
328 /* exit starLock */
329 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(startLock))) {
330 nsk_jvmti_setFailStatus();
331 }
332
333 return success;
334 }
335
336 /** Create thread object for new agent thread. */
337 static jthread newThreadObj(JNIEnv* jni_env) {
338 ExceptionCheckingJniEnvPtr jni(jni_env);
339 jclass thrClass;
340 jmethodID cid;
341 jthread result = NULL;
342
343 thrClass = jni->FindClass("java/lang/Thread", TRACE_JNI_CALL);
344 cid = jni->GetMethodID(thrClass, "<init>", "()V", TRACE_JNI_CALL);
345 return jni->NewObject(thrClass, cid, TRACE_JNI_CALL);
346 }
347
348 /***********************************************************************/
349
350 /** Clean counters and start new agent thread with agent_start() body. */
351 static int prepareToIteration(JNIEnv* jni) {
352 jthread threadObj = NULL;
353
354 setCounter(&iterationCount, 0);
355 setCounter(&objectCount, 0);
356
357 threadObj = newThreadObj(jni);
358
359 /* enter endLock */
360 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorEnter(endLock))) {
361 nsk_jvmti_setFailStatus();
362 }
363
364 NSK_DISPLAY0("Starting new agent thread...\n");
365 return startThread(threadObj);
366 }
367
368 /** Wait for new agent thread to complete. */
369 static void afterIteration() {
370
371 /* notify new agent thread (in case if not yet notified) */
372 notifyThread();
373
374 NSK_DISPLAY0("Wait for new agent thread to complete\n");
375
376 /* wait on endLock */
377 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorWait(endLock, timeout))) {
378 nsk_jvmti_setFailStatus();
379 }
380
381 /* exit endLock */
382 if (!NSK_JVMTI_VERIFY(jvmti->RawMonitorExit(endLock))) {
383 nsk_jvmti_setFailStatus();
384 }
385 }
386
387 /***********************************************************************/
388
389 JNIEXPORT void JNICALL
397 }
398 }
399
400 JNIEXPORT void JNICALL
401 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverHeap(JNIEnv* jni,
402 jclass klass) {
403 int modified = 0;
404 int found = 0;
405
406 if (!prepareToIteration(jni))
407 return;
408
409 NSK_DISPLAY0("Calling IterateOverHeap...\n");
410 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverHeap(JVMTI_HEAP_OBJECT_TAGGED,
411 heapObjectCallback,
412 NULL /*user_data*/))) {
413 nsk_jvmti_setFailStatus();
414 }
415 NSK_DISPLAY0("IterateOverHeap finished.\n");
416
417 afterIteration();
418
419 found = getCounter(&objectCount);
420 NSK_DISPLAY1("Found tagged objects: %d\n", found);
421
422 modified = OBJ_MAX_COUNT - found;
423 if (modified > 0) {
424 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
425 modified, OBJ_MAX_COUNT);
426 nsk_jvmti_setFailStatus();
427 }
428 }
429
430 JNIEXPORT void JNICALL
431 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverReachableObjects(JNIEnv* jni,
432 jclass klass) {
433 int modified = 0;
434 int found = 0;
435
436 if (!prepareToIteration(jni))
437 return;
438
439 NSK_DISPLAY0("Calling IterateOverReachableObjects...\n");
440 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverReachableObjects(heapRootCallback,
441 stackReferenceCallback,
442 objectReferenceCallback,
443 NULL /*user_data*/))) {
444 nsk_jvmti_setFailStatus();
445 }
446 NSK_DISPLAY0("IterateOverReachableObjects finished.\n");
447
448 afterIteration();
449
450 found = getCounter(&objectCount);
451 NSK_DISPLAY1("Found tagged objects: %d\n", found);
452
453 modified = OBJ_MAX_COUNT - found;
454 if (modified > 0) {
455 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
456 modified, OBJ_MAX_COUNT);
457 nsk_jvmti_setFailStatus();
458 }
459 }
460
461 JNIEXPORT void JNICALL
462 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverInstancesOfClass(JNIEnv* jni,
463 jclass klass) {
464 int modified = 0;
465 int found = 0;
466
467 if (!prepareToIteration(jni))
468 return;
469
470 NSK_DISPLAY0("Calling IterateOverInstancesOfClass...\n");
471 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverInstancesOfClass(debugeeClass,
472 JVMTI_HEAP_OBJECT_TAGGED,
473 heapObjectCallback,
474 NULL /*user_data*/))) {
475 nsk_jvmti_setFailStatus();
476 }
477 NSK_DISPLAY0("IterateOverInstancesOfClass finished.\n");
478
479 afterIteration();
480
481 found = getCounter(&objectCount);
482 NSK_DISPLAY1("Found tagged objects: %d\n", found);
483
484 modified = OBJ_MAX_COUNT - found;
485 if (modified > 0) {
486 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
487 modified, OBJ_MAX_COUNT);
488 nsk_jvmti_setFailStatus();
489 }
490 }
491
492 JNIEXPORT void JNICALL
493 Java_nsk_jvmti_scenarios_allocation_AP04_ap04t003_runIterateOverObjectsReachableFromObject(JNIEnv* jni_env,
494 jclass klass) {
495 ExceptionCheckingJniEnvPtr jni(jni_env);
496 jobject root = NULL;
497 int modified = 0;
498 int found = 0;
499
500 root = jni->GetStaticObjectField(debugeeClass, rootFieldID, TRACE_JNI_CALL);
501
502 if (!prepareToIteration(jni_env))
503 return;
504
505 NSK_DISPLAY0("Calling IterateOverObjectsReachableFromObject...\n");
506 if (!NSK_JVMTI_VERIFY(jvmti->IterateOverObjectsReachableFromObject(root,
507 objectReferenceCallback,
508 NULL /*user_data*/))) {
509 nsk_jvmti_setFailStatus();
510 }
511 NSK_DISPLAY0("IterateOverObjectsReachableFromObject finished.\n");
512
513 afterIteration();
514
515 found = getCounter(&objectCount);
516 NSK_DISPLAY1("Found tagged objects: %d\n", found);
517
518 modified = OBJ_MAX_COUNT - found;
519 if (modified > 0) {
520 NSK_COMPLAIN2("Tags were modified by other thread during heap iteration: %d of %d\n",
521 modified, OBJ_MAX_COUNT);
522 nsk_jvmti_setFailStatus();
523 }
524 }
525
526 static void JNICALL
527 agentProc(jvmtiEnv* jvmti, JNIEnv* jni_env, void* arg) {
528 ExceptionCheckingJniEnvPtr jni(jni_env);
529 NSK_DISPLAY0("Wait for debugee start\n\n");
530 if (!NSK_VERIFY(nsk_jvmti_waitForSync(timeout)))
531 return;
532
533 NSK_DISPLAY1("Find debugee class: %s\n", DEBUGEE_SIGNATURE);
534 debugeeClass = nsk_jvmti_classBySignature(DEBUGEE_SIGNATURE);
535 if (debugeeClass == NULL) {
536 nsk_jvmti_setFailStatus();
537 return;
538 }
539
540 debugeeClass = (jclass) jni->NewGlobalRef(debugeeClass, TRACE_JNI_CALL);
541
542 NSK_DISPLAY1("Find ID of 'root' field: %s\n", ROOT_SIGNATURE);
543 rootFieldID = jni->GetStaticFieldID(debugeeClass, "root",
544 ROOT_SIGNATURE, TRACE_JNI_CALL);
545
546 NSK_DISPLAY0("Let debugee to run test cases\n");
547 if (!NSK_VERIFY(nsk_jvmti_resumeSync()))
548 return;
549
550 NSK_DISPLAY0("Wait for completion of test cases\n\n");
551 if (!NSK_VERIFY(nsk_jvmti_waitForSync(timeout)))
552 return;
553
554 jni->DeleteGlobalRef(debugeeClass, TRACE_JNI_CALL);
555 NSK_TRACE(jvmti->DestroyRawMonitor(counterMonitor_ptr));
556 NSK_TRACE(jvmti->DestroyRawMonitor(startLock));
557 NSK_TRACE(jvmti->DestroyRawMonitor(runLock));
558 NSK_TRACE(jvmti->DestroyRawMonitor(endLock));
559
560 NSK_DISPLAY0("Let debugee to finish\n");
561 if (!NSK_VERIFY(nsk_jvmti_resumeSync()))
562 return;
563 }
564
565 #ifdef STATIC_BUILD
566 JNIEXPORT jint JNICALL Agent_OnLoad_ap04t003(JavaVM *jvm, char *options, void *reserved) {
567 return Agent_Initialize(jvm, options, reserved);
568 }
569 JNIEXPORT jint JNICALL Agent_OnAttach_ap04t003(JavaVM *jvm, char *options, void *reserved) {
570 return Agent_Initialize(jvm, options, reserved);
571 }
572 JNIEXPORT jint JNI_OnLoad_ap04t003(JavaVM *jvm, char *options, void *reserved) {
573 return JNI_VERSION_1_8;
574 }
|