1 /*
   2  * Copyright (c) 2003, 2019, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   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 "jni_tools.h"
  27 #include "agent_common.h"
  28 #include "jvmti_tools.h"
  29 
  30 extern "C" {
  31 
  32 #define CAPABILITY can_access_local_variables
  33 #define CAPABILITY_STR "can_access_local_variables"
  34 
  35 /* The test checks capability can_access_local_variables
  36  * and correspondent function:
  37  *     GetLocalVariableTable
  38  *     GetLocalObject
  39  *     GetLocalInt
  40  *     GetLocalLong
  41  *     GetLocalFloat
  42  *     GetLocalDouble
  43  *     SetLocalObject
  44  *     SetLocalInt
  45  *     SetLocalLong
  46  *     SetLocalFloat
  47  *     SetLocalDouble
  48  *
  49  * Testcases:
  50  *   1. Check if GetPotentialCapabilities returns the capability
  51  *   2. Add the capability during Onload phase
  52  *   3. Check if GetCapabilities returns the capability
  53  *   4. Relinquish the capability during Onload phase
  54  *   5. Check if GetCapabilities does not return the capability
  55  *   6. Add back the capability and check with GetCapabilities
  56  *   7. Check that only correspondent function work and functions of
  57  *      other capabilities return JVMTI_ERROR_MUST_POSSESS_CAPABILITY
  58  *   8. Check if VM exits well with the capability has not been relinquished
  59  */
  60 
  61 /* ========================================================================== */
  62 
  63 /* scaffold objects */
  64 static JNIEnv* jni = NULL;
  65 static jvmtiEnv *jvmti = NULL;
  66 static jlong timeout = 0;
  67 
  68 /* test objects */
  69 static jthread thread = NULL;
  70 static jclass klass = NULL;
  71 static jmethodID method = NULL;
  72 static jfieldID field = NULL;
  73 
  74 /* ========================================================================== */
  75 
  76 static int prepare() {
  77     const char* THREAD_NAME = "Debuggee Thread";
  78     jvmtiThreadInfo info;
  79     jthread *threads = NULL;
  80     jint threads_count = 0;
  81     int i;
  82 
  83     NSK_DISPLAY0("Prepare: find tested thread\n");
  84 
  85     /* get all live threads */
  86     if (!NSK_JVMTI_VERIFY(jvmti->GetAllThreads(&threads_count, &threads)))
  87         return NSK_FALSE;
  88 
  89     if (!NSK_VERIFY(threads_count > 0 && threads != NULL))
  90         return NSK_FALSE;
  91 
  92     /* find tested thread */
  93     for (i = 0; i < threads_count; i++) {
  94         if (!NSK_VERIFY(threads[i] != NULL))
  95             return NSK_FALSE;
  96 
  97         /* get thread information */
  98         if (!NSK_JVMTI_VERIFY(jvmti->GetThreadInfo(threads[i], &info)))
  99             return NSK_FALSE;
 100 
 101         NSK_DISPLAY3("    thread #%d (%s): %p\n", i, info.name, threads[i]);
 102 
 103         /* find by name */
 104         if (info.name != NULL && (strcmp(info.name, THREAD_NAME) == 0)) {
 105             thread = threads[i];
 106         }
 107     }
 108 
 109     /* deallocate threads list */
 110     if (!NSK_JVMTI_VERIFY(jvmti->Deallocate((unsigned char*)threads)))
 111         return NSK_FALSE;
 112 
 113     /* get tested thread class */
 114     if (!NSK_JNI_VERIFY(jni, (klass = jni->GetObjectClass(thread)) != NULL))
 115         return NSK_FALSE;
 116 
 117     /* get tested thread method 'run' */
 118     if (!NSK_JNI_VERIFY(jni, (method = jni->GetMethodID(klass, "run", "()V")) != NULL))
 119         return NSK_FALSE;
 120 
 121     /* get tested thread field 'waitingMonitor' */
 122     if (!NSK_JNI_VERIFY(jni, (field =
 123             jni->GetFieldID(klass, "waitingMonitor", "Ljava/lang/Object;")) != NULL))
 124         return NSK_FALSE;
 125 
 126     return NSK_TRUE;
 127 }
 128 
 129 /* ========================================================================== */
 130 
 131 /* Check "can_suspend" functions
 132  */
 133 static int checkSuspend() {
 134     jvmtiError err;
 135 
 136     NSK_DISPLAY0("Checking negative: SuspendThread\n");
 137     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->SuspendThread(thread)))
 138         return NSK_FALSE;
 139 
 140     NSK_DISPLAY0("Checking negative: ResumeThread\n");
 141     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->ResumeThread(thread)))
 142         return NSK_FALSE;
 143 
 144     NSK_DISPLAY0("Checking negative: SuspendThreadList\n");
 145     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 146             jvmti->SuspendThreadList(1, &thread, &err)))
 147         return NSK_FALSE;
 148 
 149     NSK_DISPLAY0("Checking negative: ResumeThreadList\n");
 150     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 151             jvmti->ResumeThreadList(1, &thread, &err)))
 152         return NSK_FALSE;
 153 
 154     return NSK_TRUE;
 155 }
 156 
 157 /* Check "can_signal_thread" functions
 158  */
 159 static int checkSignalThread() {
 160     const char* THREAD_DEATH_CLASS_NAME = "java/lang/ThreadDeath";
 161     const char* THREAD_DEATH_CTOR_NAME = "<init>";
 162     const char* THREAD_DEATH_CTOR_SIGNATURE = "()V";
 163     jclass cls = NULL;
 164     jmethodID ctor = NULL;
 165     jobject exception = NULL;
 166 
 167     if (!NSK_JNI_VERIFY(jni, (cls = jni->FindClass(THREAD_DEATH_CLASS_NAME)) != NULL))
 168         return NSK_FALSE;
 169 
 170     if (!NSK_JNI_VERIFY(jni, (ctor =
 171             jni->GetMethodID(cls, THREAD_DEATH_CTOR_NAME, THREAD_DEATH_CTOR_SIGNATURE)) != NULL))
 172         return NSK_FALSE;
 173 
 174     if (!NSK_JNI_VERIFY(jni, (exception = jni->NewObject(cls, ctor)) != NULL))
 175         return NSK_FALSE;
 176 
 177     NSK_DISPLAY0("Checking negative: StopThread\n");
 178     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 179             jvmti->StopThread(thread, exception)))
 180         return NSK_FALSE;
 181 
 182     NSK_DISPLAY0("Checking negative: InterruptThread\n");
 183     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->InterruptThread(thread)))
 184         return NSK_FALSE;
 185 
 186     return NSK_TRUE;
 187 }
 188 
 189 /* Check "can_get_owned_monitor_info" function
 190  */
 191 static int checkGetOwnedMonitorInfo() {
 192     jint count;
 193     jobject *monitors = NULL;
 194 
 195     NSK_DISPLAY0("Checking negative: GetOwnedMonitorInfo\n");
 196     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 197             jvmti->GetOwnedMonitorInfo(thread, &count, &monitors)))
 198         return NSK_FALSE;
 199 
 200     return NSK_TRUE;
 201 }
 202 
 203 /* Check "can_get_current_contended_monitor" function
 204  */
 205 static int checkGetCurrentContendedMonitor() {
 206     jobject monitor = NULL;
 207 
 208     NSK_DISPLAY0("Checking negative: GetCurrentContendedMonitor\n");
 209     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 210             jvmti->GetCurrentContendedMonitor(thread, &monitor)))
 211         return NSK_FALSE;
 212 
 213     return NSK_TRUE;
 214 }
 215 
 216 /* Check "can_pop_frame" function
 217  */
 218 static int checkPopFrame() {
 219     NSK_DISPLAY0("Checking negative: PopFrame\n");
 220     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->PopFrame(thread)))
 221         return NSK_FALSE;
 222 
 223     return NSK_TRUE;
 224 }
 225 
 226 /* Check "can_tag_objects" functions
 227  */
 228 
 229 static jvmtiIterationControl JNICALL
 230 HeapObject(jlong class_tag, jlong size, jlong *tag_ptr, void *user_data) {
 231     return JVMTI_ITERATION_ABORT;
 232 }
 233 
 234 static jvmtiIterationControl JNICALL
 235 HeapRoot(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,
 236         jlong *tag_ptr, void *user_data) {
 237     return JVMTI_ITERATION_ABORT;
 238 }
 239 
 240 static jvmtiIterationControl JNICALL
 241 StackReference(jvmtiHeapRootKind root_kind, jlong class_tag, jlong size,
 242         jlong *tag_ptr, jlong thread_tag, jint depth, jmethodID method,
 243         jint slot, void *user_data) {
 244     return JVMTI_ITERATION_ABORT;
 245 }
 246 
 247 static jvmtiIterationControl JNICALL
 248 ObjectReference(jvmtiObjectReferenceKind reference_kind, jlong class_tag,
 249         jlong size, jlong *tag_ptr, jlong referrer_tag,
 250         jint referrer_index, void *user_data) {
 251     return JVMTI_ITERATION_ABORT;
 252 }
 253 
 254 static int checkHeapFunctions() {
 255     const jlong TAG_VALUE = (123456789L);
 256     jlong tag;
 257     jint count;
 258     jobject *res_objects = NULL;
 259     jlong *res_tags = NULL;
 260     jint dummy_user_data = 0;
 261 
 262     NSK_DISPLAY0("Checking negative: SetTag\n");
 263     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 264             jvmti->SetTag(thread, TAG_VALUE)))
 265         return NSK_FALSE;
 266 
 267     NSK_DISPLAY0("Checking negative: GetTag\n");
 268     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY, jvmti->GetTag(thread, &tag)))
 269         return NSK_FALSE;
 270 
 271     NSK_DISPLAY0("Checking negative: GetObjectsWithTags\n");
 272     tag = TAG_VALUE;
 273     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 274             jvmti->GetObjectsWithTags(1, &tag, &count, &res_objects, &res_tags)))
 275         return NSK_FALSE;
 276 
 277     NSK_DISPLAY0("Checking negative: IterateOverHeap\n");
 278     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 279             jvmti->IterateOverHeap(JVMTI_HEAP_OBJECT_TAGGED, HeapObject, &dummy_user_data)))
 280         return NSK_FALSE;
 281 
 282     NSK_DISPLAY0("Checking negative: IterateOverInstancesOfClass\n");
 283     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 284             jvmti->IterateOverInstancesOfClass(klass,
 285                                                JVMTI_HEAP_OBJECT_UNTAGGED,
 286                                                HeapObject,
 287                                                &dummy_user_data)))
 288         return NSK_FALSE;
 289 
 290     NSK_DISPLAY0("Checking negative: IterateOverObjectsReachableFromObject\n");
 291     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 292             jvmti->IterateOverObjectsReachableFromObject(thread,
 293                                                          ObjectReference,
 294                                                          &dummy_user_data)))
 295         return NSK_FALSE;
 296 
 297     NSK_DISPLAY0("Checking negative: IterateOverReachableObjects\n");
 298     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 299             jvmti->IterateOverReachableObjects(HeapRoot,
 300                                                StackReference,
 301                                                ObjectReference,
 302                                                &dummy_user_data)))
 303         return NSK_FALSE;
 304 
 305     return NSK_TRUE;
 306 }
 307 
 308 /* Check "can_access_local_variables" functions
 309  */
 310 static int checkLocalVariableFunctions() {
 311     jint count;
 312     jvmtiLocalVariableEntry *local_variable_table = NULL;
 313     jobject object_value;
 314     jint int_value;
 315     jlong long_value;
 316     jfloat float_value;
 317     jdouble double_value;
 318     int i;
 319 
 320 /* DEBUG -- while thread should be suspended
 321     jvmtiCapabilities caps;
 322 */
 323 
 324     NSK_DISPLAY0("Checking positive: GetLocalVariableTable\n");
 325     if (!NSK_JVMTI_VERIFY(jvmti->GetLocalVariableTable(method, &count, &local_variable_table)))
 326         return NSK_FALSE;
 327 
 328 /* DEBUG -- while thread should be suspended
 329     memset(&caps, 0, sizeof(caps));
 330     caps.can_suspend = 1;
 331     if (!NSK_JVMTI_VERIFY(jvmti->AddCapabilities(&caps)))
 332         return JNI_ERR;
 333     if (!NSK_JVMTI_VERIFY(jvmti->SuspendThread(thread)))
 334         return NSK_FALSE;
 335 */
 336 
 337     for (i = 0; i < count; i++) {
 338         if (strcmp(local_variable_table[i].name, "o") == 0) {
 339             NSK_DISPLAY0("Checking positive: GetLocalObject\n");
 340             if (!NSK_JVMTI_VERIFY(
 341                     jvmti->GetLocalObject(thread, 2, local_variable_table[i].slot, &object_value)))
 342                 return NSK_FALSE;
 343 
 344             NSK_DISPLAY0("Checking positive: SetLocalObject\n");
 345             if (!NSK_JVMTI_VERIFY(
 346                     jvmti->SetLocalObject(thread, 2, local_variable_table[i].slot, object_value)))
 347                 return NSK_FALSE;
 348         } else if (strcmp(local_variable_table[i].name, "i") == 0) {
 349             NSK_DISPLAY0("Checking positive: GetLocalInt\n");
 350             if (!NSK_JVMTI_VERIFY(
 351                     jvmti->GetLocalInt(thread, 2, local_variable_table[i].slot, &int_value)))
 352                 return NSK_FALSE;
 353 
 354             NSK_DISPLAY0("Checking positive: SetLocalInt\n");
 355             if (!NSK_JVMTI_VERIFY(
 356                     jvmti->SetLocalInt(thread, 2, local_variable_table[i].slot, int_value)))
 357                 return NSK_FALSE;
 358         } else if (strcmp(local_variable_table[i].name, "l") == 0) {
 359             NSK_DISPLAY0("Checking positive: GetLocalLong\n");
 360             if (!NSK_JVMTI_VERIFY(
 361                     jvmti->GetLocalLong(thread, 2, local_variable_table[i].slot, &long_value)))
 362                 return NSK_FALSE;
 363 
 364             NSK_DISPLAY0("Checking positive: SetLocalLong\n");
 365             if (!NSK_JVMTI_VERIFY(
 366                     jvmti->SetLocalLong(thread, 2, local_variable_table[i].slot, long_value)))
 367                 return NSK_FALSE;
 368         } else if (strcmp(local_variable_table[i].name, "f") == 0) {
 369             NSK_DISPLAY0("Checking positive: GetLocalFloat\n");
 370             if (!NSK_JVMTI_VERIFY(
 371                     jvmti->GetLocalFloat(thread, 2, local_variable_table[i].slot, &float_value)))
 372                 return NSK_FALSE;
 373 
 374             NSK_DISPLAY0("Checking positive: SetLocalFloat\n");
 375             if (!NSK_JVMTI_VERIFY(
 376                     jvmti->SetLocalFloat(thread, 2, local_variable_table[i].slot, float_value)))
 377                 return NSK_FALSE;
 378         } else if (strcmp(local_variable_table[i].name, "d") == 0) {
 379             NSK_DISPLAY0("Checking positive: GetLocalDouble\n");
 380             if (!NSK_JVMTI_VERIFY(
 381                     jvmti->GetLocalDouble(thread, 2, local_variable_table[i].slot, &double_value)))
 382                 return NSK_FALSE;
 383 
 384             NSK_DISPLAY0("Checking positive: SetLocalDouble\n");
 385             if (!NSK_JVMTI_VERIFY(
 386                     jvmti->SetLocalDouble(thread, 2, local_variable_table[i].slot, double_value)))
 387                 return NSK_FALSE;
 388         }
 389     }
 390 
 391 /* DEBUG -- while thread should be suspended
 392     if (!NSK_JVMTI_VERIFY(jvmti->ResumeThread(thread)))
 393         return NSK_FALSE;
 394     if (!NSK_JVMTI_VERIFY(jvmti->RelinquishCapabilities(&caps)))
 395         return JNI_ERR;
 396 */
 397 
 398     if (!NSK_JVMTI_VERIFY(jvmti->Deallocate((unsigned char*)local_variable_table)))
 399         return NSK_FALSE;
 400 
 401     return NSK_TRUE;
 402 }
 403 
 404 /* Check "can_get_source_info" functions
 405  */
 406 static int checkSourceInfoFunctions() {
 407     char *name;
 408     jint count;
 409     jvmtiLineNumberEntry *line_number_table = NULL;
 410 
 411     NSK_DISPLAY0("Checking negative: GetSourceFileName\n");
 412     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 413             jvmti->GetSourceFileName(klass, &name)))
 414         return NSK_FALSE;
 415 
 416     NSK_DISPLAY0("Checking negative: GetSourceDebugExtension\n");
 417     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 418             jvmti->GetSourceDebugExtension(klass, &name)))
 419         return NSK_FALSE;
 420 
 421     NSK_DISPLAY0("Checking negative: GetLineNumberTable\n");
 422     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 423             jvmti->GetLineNumberTable(method, &count, &line_number_table)))
 424         return NSK_FALSE;
 425 
 426     return NSK_TRUE;
 427 }
 428 
 429 /* Check "can_redefine_classes" functions
 430  */
 431 static int checkRedefineClasses() {
 432     jvmtiClassDefinition class_def;
 433 
 434     NSK_DISPLAY0("Checking negative: RedefineClasses\n");
 435     class_def.klass = klass;
 436     class_def.class_byte_count = 0;
 437     class_def.class_bytes = NULL;
 438     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 439             jvmti->RedefineClasses(1, &class_def)))
 440         return NSK_FALSE;
 441 
 442     return NSK_TRUE;
 443 }
 444 
 445 /* Check "can_get_monitor_info" function
 446  */
 447 static int checkGetObjectMonitorUsage() {
 448     jvmtiMonitorUsage monitor_info;
 449 
 450     NSK_DISPLAY0("Checking negative: GetObjectMonitorUsage\n");
 451     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 452             jvmti->GetObjectMonitorUsage(thread, &monitor_info)))
 453         return NSK_FALSE;
 454 
 455     return NSK_TRUE;
 456 }
 457 
 458 /* Check "can_get_synthetic_attribute" functions
 459  */
 460 static int checkIsSyntheticFunctions() {
 461     jboolean is_synthetic;
 462 
 463     NSK_DISPLAY0("Checking negative: IsFieldSynthetic\n");
 464     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 465             jvmti->IsFieldSynthetic(klass, field, &is_synthetic)))
 466         return NSK_FALSE;
 467 
 468     NSK_DISPLAY0("Checking negative: IsMethodSynthetic\n");
 469     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 470             jvmti->IsMethodSynthetic(method, &is_synthetic)))
 471         return NSK_FALSE;
 472 
 473     return NSK_TRUE;
 474 }
 475 
 476 /* Check "can_get_bytecodes" function
 477  */
 478 static int checkGetBytecodes() {
 479     jint count;
 480     unsigned char *bytecodes;
 481 
 482     NSK_DISPLAY0("Checking negative: GetBytecodes\n");
 483     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 484             jvmti->GetBytecodes(method, &count, &bytecodes)))
 485         return NSK_FALSE;
 486 
 487     return NSK_TRUE;
 488 }
 489 
 490 /* Check "can_get_current_thread_cpu_time" function
 491  */
 492 static int checkGetCurrentThreadCpuTime() {
 493     jvmtiTimerInfo info;
 494     jlong nanos;
 495 
 496     NSK_DISPLAY0("Checking negative: GetCurrentThreadCpuTimerInfo\n");
 497     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 498             jvmti->GetCurrentThreadCpuTimerInfo(&info)))
 499         return NSK_FALSE;
 500 
 501     NSK_DISPLAY0("Checking negative: GetCurrentThreadCpuTime\n");
 502     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 503             jvmti->GetCurrentThreadCpuTime(&nanos)))
 504         return NSK_FALSE;
 505 
 506     return NSK_TRUE;
 507 }
 508 
 509 /* Check "can_get_thread_cpu_time" function
 510  */
 511 static int checkGetThreadCpuTime() {
 512     jvmtiTimerInfo info;
 513     jlong nanos;
 514 
 515     NSK_DISPLAY0("Checking negative: GetThreadCpuTimerInfo\n");
 516     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 517             jvmti->GetThreadCpuTimerInfo(&info)))
 518         return NSK_FALSE;
 519 
 520     NSK_DISPLAY0("Checking negative: GetThreadCpuTime\n");
 521     if (!NSK_JVMTI_VERIFY_CODE(JVMTI_ERROR_MUST_POSSESS_CAPABILITY,
 522             jvmti->GetThreadCpuTime(thread, &nanos)))
 523         return NSK_FALSE;
 524 
 525     return NSK_TRUE;
 526 }
 527 
 528 /* ========================================================================== */
 529 
 530 /* agent algorithm */
 531 static void JNICALL
 532 agentProc(jvmtiEnv* jvmti, JNIEnv* agentJNI, void* arg) {
 533     jni = agentJNI;
 534 
 535     /* wait for initial sync */
 536     if (!nsk_jvmti_waitForSync(timeout))
 537         return;
 538 
 539     if (!prepare()) {
 540         nsk_jvmti_setFailStatus();
 541         return;
 542     }
 543 
 544     /* testcase #7: check that only correspondent function work */
 545     NSK_DISPLAY0("Testcase #7: check that only correspondent function work but not others\n");
 546     if (!checkSuspend())
 547         nsk_jvmti_setFailStatus();
 548     if (!checkSignalThread())
 549         nsk_jvmti_setFailStatus();
 550     if (!checkGetOwnedMonitorInfo())
 551         nsk_jvmti_setFailStatus();
 552     if (!checkGetCurrentContendedMonitor())
 553         nsk_jvmti_setFailStatus();
 554     if (!checkPopFrame())
 555         nsk_jvmti_setFailStatus();
 556     if (!checkHeapFunctions())
 557         nsk_jvmti_setFailStatus();
 558     if (!checkLocalVariableFunctions())
 559         nsk_jvmti_setFailStatus();
 560     if (!checkSourceInfoFunctions())
 561         nsk_jvmti_setFailStatus();
 562     if (!checkRedefineClasses())
 563         nsk_jvmti_setFailStatus();
 564     if (!checkGetObjectMonitorUsage())
 565         nsk_jvmti_setFailStatus();
 566     if (!checkIsSyntheticFunctions())
 567         nsk_jvmti_setFailStatus();
 568     if (!checkGetBytecodes())
 569         nsk_jvmti_setFailStatus();
 570     if (!checkGetCurrentThreadCpuTime())
 571         nsk_jvmti_setFailStatus();
 572     if (!checkGetThreadCpuTime())
 573         nsk_jvmti_setFailStatus();
 574 
 575     /* testcase #8: exits with the capability has not been relinquished */
 576     NSK_DISPLAY0("Testcase #8: check if VM exits well with the capability has not been relinquished\n");
 577 
 578     /* resume debugee after last sync */
 579     if (!nsk_jvmti_resumeSync())
 580         return;
 581 }
 582 
 583 /* ========================================================================== */
 584 
 585 /* agent library initialization */
 586 #ifdef STATIC_BUILD
 587 JNIEXPORT jint JNICALL Agent_OnLoad_cm01t011(JavaVM *jvm, char *options, void *reserved) {
 588     return Agent_Initialize(jvm, options, reserved);
 589 }
 590 JNIEXPORT jint JNICALL Agent_OnAttach_cm01t011(JavaVM *jvm, char *options, void *reserved) {
 591     return Agent_Initialize(jvm, options, reserved);
 592 }
 593 JNIEXPORT jint JNI_OnLoad_cm01t011(JavaVM *jvm, char *options, void *reserved) {
 594     return JNI_VERSION_1_8;
 595 }
 596 #endif
 597 jint Agent_Initialize(JavaVM *jvm, char *options, void *reserved) {
 598     jvmtiCapabilities caps;
 599 
 600     /* init framework and parse options */
 601     if (!NSK_VERIFY(nsk_jvmti_parseOptions(options)))
 602         return JNI_ERR;
 603 
 604     timeout = nsk_jvmti_getWaitTime() * 60000;
 605     NSK_DISPLAY1("Timeout: %d msc\n", (int)timeout);
 606 
 607     /* create JVMTI environment */
 608     if (!NSK_VERIFY((jvmti =
 609             nsk_jvmti_createJVMTIEnv(jvm, reserved)) != NULL))
 610         return JNI_ERR;
 611 
 612     /* register agent proc and arg */
 613     if (!NSK_VERIFY(nsk_jvmti_setAgentProc(agentProc, NULL)))
 614         return JNI_ERR;
 615 
 616     /* testcase #1: check GetPotentialCapabilities */
 617     NSK_DISPLAY0("Testcase #1: check if GetPotentialCapabilities returns the capability\n");
 618     if (!NSK_JVMTI_VERIFY(jvmti->GetPotentialCapabilities(&caps)))
 619         return JNI_ERR;
 620     if (!caps.CAPABILITY) {
 621         NSK_COMPLAIN1("GetPotentialCapabilities does not return \"%s\" capability\n",
 622             CAPABILITY_STR);
 623         return JNI_ERR;
 624     }
 625 
 626     /* testcase #2: add the capability during Onload phase */
 627     NSK_DISPLAY0("Testcase #2: add the capability during Onload phase\n");
 628     memset(&caps, 0, sizeof(caps));
 629     caps.CAPABILITY = 1;
 630     if (!NSK_JVMTI_VERIFY(jvmti->AddCapabilities(&caps)))
 631         return JNI_ERR;
 632 
 633     /* testcase #3: check if GetCapabilities returns the capability */
 634     NSK_DISPLAY0("Testcase #3: check if GetCapabilities returns the capability\n");
 635     memset(&caps, 0, sizeof(caps));
 636     if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&caps)))
 637         return JNI_ERR;
 638     if (!caps.CAPABILITY) {
 639         NSK_COMPLAIN1("GetCapabilities does not return \"%s\" capability\n",
 640             CAPABILITY_STR);
 641         return JNI_ERR;
 642     }
 643 
 644     /* testcase #4: relinquish the capability during Onload phase */
 645     NSK_DISPLAY0("Testcase #4: relinquish the capability during Onload phase\n");
 646     memset(&caps, 0, sizeof(caps));
 647     caps.CAPABILITY = 1;
 648     if (!NSK_JVMTI_VERIFY(jvmti->RelinquishCapabilities(&caps)))
 649         return JNI_ERR;
 650 
 651     /* testcase #5: check if GetCapabilities does not return the capability */
 652     NSK_DISPLAY0("Testcase #5: check if GetCapabilities does not return the capability\n");
 653     memset(&caps, 0, sizeof(caps));
 654     if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&caps)))
 655         return JNI_ERR;
 656     if (caps.CAPABILITY) {
 657         NSK_COMPLAIN1("GetCapabilities returns relinquished \"%s\" capability\n",
 658             CAPABILITY_STR);
 659         return JNI_ERR;
 660     }
 661 
 662     /* testcase #6: add back the capability and check with GetCapabilities */
 663     NSK_DISPLAY0("Testcase #6: add back the capability and check with GetCapabilities\n");
 664     memset(&caps, 0, sizeof(caps));
 665     caps.CAPABILITY = 1;
 666     if (!NSK_JVMTI_VERIFY(jvmti->AddCapabilities(&caps)))
 667         return JNI_ERR;
 668     memset(&caps, 0, sizeof(caps));
 669     if (!NSK_JVMTI_VERIFY(jvmti->GetCapabilities(&caps)))
 670         return JNI_ERR;
 671     if (!caps.CAPABILITY) {
 672         NSK_COMPLAIN1("GetCapabilities does not return \"%s\" capability\n",
 673             CAPABILITY_STR);
 674         return JNI_ERR;
 675     }
 676 
 677     return JNI_OK;
 678 }
 679 
 680 /* ========================================================================== */
 681 
 682 }