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