1 /*
2 * Copyright (c) 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 /*
25 * @test
26 * @bug 8010319
27 * @summary Class redefinition must preclude changes to nest attributes
28 * @comment This is a copy of test/jdk/java/lang/instrument/RedefineNestmateAttr/
29 * @comment modified for JDI
30 * @library /test/lib ..
31 * @modules java.compiler
32 * @run build TestScaffold VMConnection TargetListener TargetAdapter
33 * @compile NamedBuffer.java
34 * @compile Host/Host.java
35 * @run main/othervm TestNestmateAttr Host
36 * @compile HostA/Host.java
37 * @run main/othervm TestNestmateAttr HostA
38 * @compile HostAB/Host.java
39 * @run main/othervm TestNestmateAttr HostAB
40 * @compile HostABC/Host.java
41 * @run main/othervm TestNestmateAttr HostABC
42 */
43
44 /* Test Description
45
46 The basic test class is called Host and we have variants that have zero or more
47 nested classes named A, B, C etc. Each variant of Host is defined in source
48 code in its own directory i.e.
49
50 Host/Host.java defines zero nested classes
51 HostA/Host.java defines one nested class A
52 HostAB/Host.java defines two nested classes A and B (in that order)
53 etc.
54
55 Each Host class has the form:
56
57 public class Host {
58 public static String getID() { return "<directory name>/Host.java"; }
59
60 < zero or more empty nested classes>
61
62 public int m() {
63 return 1; // original class
64 }
65 }
66
67 Under each directory is a directory "redef" with a modified version of the Host
68 class that changes the ID to e.g. Host/redef/Host.java, and the method m()
69 returns 2. This allows us to check we have the redefined class loaded.
70
71 Using Host' to represent the redefined version we test redefinition
72 combinations as follows:
73
74 Host:
75 Host -> Host' - succeeds m() returns 2
76 Host -> HostA' - fails - added a nest member
77
78 HostA:
79 HostA -> HostA' - succeeds m() returns 2
80 HostA -> Host' - fails - removed a nest member
81 HostA -> HostAB' - fails - added a nest member
82 HostA -> HostB' - fails - replaced a nest member
83
84 HostAB:
85 HostAB -> HostAB' - succeeds m() returns 2
86 HostAB -> HostBA' - succeeds m() returns 2
87 HostAB -> HostA' - fails - removed a nest member
88 HostAB -> HostABC' - fails - added a nest member
89 HostAB -> HostAC' - fails - replaced a nest member
90
91 HostABC:
92 HostABC -> HostABC' - succeeds m() returns 2
93 HostABC -> HostACB' - succeeds m() returns 2
94 HostABC -> HostBAC' - succeeds m() returns 2
95 HostABC -> HostBCA' - succeeds m() returns 2
96 HostABC -> HostCAB' - succeeds m() returns 2
97 HostABC -> HostCBA' - succeeds m() returns 2
98 HostABC -> HostAB' - fails - removed a nest member
99 HostABC -> HostABCD' - fails - added a nest member
100 HostABC -> HostABD' - fails - replaced a nest member
101
102 More than three nested classes doesn't add to the code coverage so
103 we stop here.
104
105 Note that we always try to load the redefined version even when we expect it
106 to fail.
107
108 We can only directly load one class Host per classloader, so to run all the
109 groups we either need to use new classloaders, or we reinvoke the test
110 requesting a different primary directory. We chose the latter using
111 multiple @run tags. So we proceed as follows:
112
113 @compile Host/Host.java
114 @run TestNestmateAttr Host
115 @compile HostA/Host.java - replaces previous Host.class
116 @run TestNestmateAttr HostA
117 @compile HostAB/Host.java - replaces previous Host.class
118 @run TestNestmateAttr HostAB
119 etc.
120
121 Within the test we directly compile redefined versions of the classes,
122 using CompilerUtil, and then read the .class file directly as a byte[].
123
124 Finally we test redefinition of the NestHost attribute - which is
125 conceptually simple, but in fact very tricky to do. We do that
126 when testing HostA so we can reuse the Host$A class.
127
128 */
129
130 import com.sun.jdi.*;
131 import com.sun.jdi.event.*;
132 import com.sun.jdi.request.*;
133
134 import java.io.File;
135 import java.io.FileInputStream;
136 import java.util.ArrayList;
137 import java.util.Arrays;
138 import java.util.Collections;
139 import java.util.HashMap;
140 import java.util.List;
141 import java.util.Map;
142
143 import jdk.test.lib.ByteCodeLoader;
144 import jdk.test.lib.compiler.CompilerUtils;
145 import jdk.test.lib.compiler.InMemoryJavaCompiler;
146 import static jdk.test.lib.Asserts.assertTrue;
147
148 /* For JDI the test is split across two VMs and so split into
149 two main classes. This is the class we will run under the debugger.
150 Package access so we can define in the same source file for ease of
151 reference.
152 */
153 class Target {
154 // We have to load all of the variants of the classes that we will
155 // attempt to redefine. This requires some in-memory compilation
156 // and use of additional classloaders.
157 public static void main(String[] args) throws Throwable {
158 String origin = args[0];
159 System.out.println("Target: Testing original Host class from " + origin);
160
161 // Make sure the Host class loaded directly is an original version
162 // and from the expected location
163 Host h = new Host();
164 assertTrue(h.m() == 1);
165 assertTrue(Host.getID().startsWith(origin + "/"));
166
167 // The rest of this setup is only needed for the case
168 // when we perform the checkNestHostChanges() test.
169 if (origin.equals("HostA")) {
170 String name = "Host$A";
171
172 // Have to do this reflectively as there is no Host$A
173 // when compiling the "Host/" case.
174 Class<?> nestedA = Class.forName(name); // triggers initialization
175
176 // This is compiled as a top-level class: the $ in the name is not
177 // significant to the compiler.
178 String hostA = "public class " + name + " {}";
179 byte[] bytes = InMemoryJavaCompiler.compile(name, hostA);
180 // And we have to load this into a new classloader
181 Class<?> topLevelHostA = ByteCodeLoader.load(name, bytes);
182 // The loaded class has not been linked (as per ClassLoader.resolveClass)
183 // and so will be filtered out by VirtualMachine.allClasses(). There are
184 // a number of ways to force linking - this is the simplest.
185 Object o = topLevelHostA.newInstance();
186
187 // sanity check
188 assertTrue(nestedA.getClassLoader() != topLevelHostA.getClassLoader());
189
190 }
191
192 allowRedefine(); // debugger stops us here to attempt redefinitions
193
194 System.out.println("Target executed okay");
195 }
196
197 public static void allowRedefine() { }
198 }
199
200 public class TestNestmateAttr extends TestScaffold {
201
202 static final String SRC = System.getProperty("test.src");
203 static final String DEST = System.getProperty("test.classes");
204 static final boolean VERBOSE = Boolean.getBoolean("verbose");
205
206 static String origin;
207
208 // override this to correct a bug so arguments can be passed to
209 // the Target class
210 protected void startUp(String targetName) {
211 List<String> argList = new ArrayList<>(Arrays.asList(args));
212 argList.add(0, targetName); // pre-pend so it becomes the first "app" arg
213 println("run args: " + argList);
214 connect((String[]) argList.toArray(args));
215 waitForVMStart();
216 }
217
218 TestNestmateAttr (String[] args) {
219 super(args);
220 }
221
222 public static void main(String[] args) throws Throwable {
223 origin = args[0];
224 new TestNestmateAttr(args).startTests();
225 }
226
227 public void runTests() throws Exception {
228 // Get Target into debuggable state
229 BreakpointEvent bpe = startToMain("Target");
230 EventRequestManager erm = vm().eventRequestManager();
231 MethodEntryRequest mee = erm.createMethodEntryRequest();
232 mee.addClassFilter("Target");
233 mee.enable();
234
235 // Allow application to complete and shut down
236 listenUntilVMDisconnect();
237
238 if (getExceptionCaught()) {
239 throw new Exception("TestNestmateAttr: failed due to unexpected exception - check logs for details");
240 }
241 else if (!testFailed) {
242 println("TestNestmateAttr: passed");
243 } else {
244 throw new Exception("TestNestmateAttr: failure reported - check log for details");
245 }
246 }
247
248 // All the actual work is done from here once we see we've entered Target.allowRedefine()
249 public void methodEntered(MethodEntryEvent event) {
250 Method meth = event.location().method();
251
252 if (!meth.name().equals("allowRedefine")) {
253 return;
254 }
255
256 System.out.println("TestNestmateAttr: Testing original Host class from " + origin);
257
258 String[] badTransforms; // directories of bad classes
259 String[] goodTransforms; // directories of good classes
260
261 boolean testNestHostChanges = false;
262
263 switch (origin) {
264 case "Host":
265 badTransforms = new String[] {
266 "HostA" // add member
267 };
268 goodTransforms = new String[] {
269 origin
270 };
271 break;
272
273 case "HostA":
274 badTransforms = new String[] {
275 "Host", // remove member
276 "HostAB", // add member
277 "HostB" // change member
278 };
279 goodTransforms = new String[] {
280 origin
281 };
282 testNestHostChanges = true;
283 break;
284
285 case "HostAB":
286 badTransforms = new String[] {
287 "HostA", // remove member
288 "HostABC", // add member
289 "HostAC" // change member
290 };
291 goodTransforms = new String[] {
292 origin,
293 "HostBA" // reorder members
294 };
295 break;
296
297 case "HostABC":
298 badTransforms = new String[] {
299 "HostAB", // remove member
300 "HostABCD", // add member
301 "HostABD" // change member
302 };
303 goodTransforms = new String[] {
304 origin,
305 "HostACB", // reorder members
306 "HostBAC", // reorder members
307 "HostBCA", // reorder members
308 "HostCAB", // reorder members
309 "HostCBA" // reorder members
310 };
311 break;
312
313 default: throw new Error("Unknown test directory: " + origin);
314 }
315
316 // Need to locate the type we will be trying to redefine in Target
317 findReferenceTypes();
318
319 try {
320 // Compile and check bad transformations
321 checkBadTransforms(_Host, badTransforms);
322
323 // Compile and check good transformations
324 checkGoodTransforms(_Host, goodTransforms);
325
326 if (testNestHostChanges)
327 checkNestHostChanges();
328 }
329 catch (Throwable t) {
330 failure(t);
331 }
332 }
333
334 // override to give exception details
335 protected void failure(Throwable t) {
336 super.failure(t.getMessage());
337 t.printStackTrace(System.out);
338 }
339
340 // These are references to the types in Target
341 // that we will be trying to redefine.
342 ReferenceType _Host;
343 ReferenceType _Host_A_nested;
344 ReferenceType _Host_A_topLevel;
345
346 void findReferenceTypes() {
347 List<ReferenceType> classes = vm().allClasses();
348 ClassLoaderReference cl = null; // track the main loader
349 ReferenceType a1 = null;
350 ReferenceType a2 = null;
351 for (ReferenceType c : classes) {
352 String name = c.name();
353 if (name.equals("Host")) {
354 _Host = c;
355 cl = c.classLoader();
356 }
357 else if (name.equals("Host$A")) {
358 if (a1 == null) {
359 a1 = c;
360 } else if (a2 == null) {
361 a2 = c;
362 }
363 else {
364 assertTrue(false); // Too many Host$A classes found!
365 }
366 }
367 }
368 assertTrue(_Host != null);
369
370 // The rest of this setup is only needed for the case
371 // when we perform the checkNestHostChanges() test.
372 if (origin.equals("HostA")) {
373 assertTrue(a1 != null);
374 assertTrue(a2 != null);
375
376 if (a1.classLoader() == cl) {
377 _Host_A_nested = a1;
378 assertTrue(a2.classLoader() != cl);
379 _Host_A_topLevel = a2;
380 }
381 else if (a2.classLoader() == cl) {
382 _Host_A_nested = a2;
383 assertTrue(a1.classLoader() != cl);
384 _Host_A_topLevel = a1;
385 }
386 else {
387 assertTrue(false); // Wrong classLoaders found
388 }
389 }
390 }
391
392 void checkNestHostChanges() throws Throwable {
393 Map<ReferenceType, byte[]> map = new HashMap<>();
394
395 // case 1: remove NestHost attribute
396 // - try to redefine nested Host$A with a top-level
397 // class called Host$A
398 System.out.println("Trying bad retransform that removes the NestHost attribute");
399
400 String name = "Host$A";
401
402 // This is compiled as a top-level class: the $ in the name is not
403 // significant to the compiler.
404 String hostA = "public class " + name + " {}";
405 byte[] bytes = InMemoryJavaCompiler.compile(name, hostA);
406
407 map.put(_Host_A_nested, bytes);
408
409 try {
410 vm().redefineClasses(map);
411 throw new Error("Retransformation to top-level class " + name +
412 " succeeded unexpectedly");
413 }
414 catch (UnsupportedOperationException uoe) {
415 if (uoe.getMessage().contains("changes to class attribute not implemented")) {
416 System.out.println("Got expected exception " + uoe);
417 }
418 else throw new Error("Wrong UnsupportedOperationException", uoe);
419 }
420
421 map.clear();
422
423 // case 2: add NestHost attribute
424 // - This is tricky because the class with no NestHost attribute
425 // has to have the name of a nested class! But we know how to
426 // do that as we already created a top-level Host$A. So now
427 // we try to replace with a really nested Host$A.
428
429 System.out.println("Trying bad retransform that adds the NestHost attribute");
430
431 byte[] nestedBytes;
432 File clsfile = new File(DEST + "/" + name + ".class");
433 if (VERBOSE) System.out.println("Reading bytes from " + clsfile);
434 try (FileInputStream str = new FileInputStream(clsfile)) {
435 nestedBytes = NamedBuffer.loadBufferFromStream(str);
436 }
437
438 map.put(_Host_A_topLevel, nestedBytes);
439
440 try {
441 vm().redefineClasses(map);
442 throw new Error("Retransformation to nested class " + name +
443 " succeeded unexpectedly");
444 }
445 catch (UnsupportedOperationException uoe) {
446 if (uoe.getMessage().contains("changes to class attribute not implemented")) {
447 System.out.println("Got expected exception " + uoe);
448 }
449 else throw new Error("Wrong UnsupportedOperationException", uoe);
450 }
451
452 map.clear();
453
454 // case 3: replace the NestHost attribute
455 // - the easiest way (perhaps only reasonable way) to do this
456 // is to search for the Utf8 entry used by the Constant_ClassRef,
457 // set in the NestHost attribute, and edit it to refer to a different
458 // name. We reuse nestedBytes from above.
459
460 System.out.println("Trying bad retransform that changes the NestHost attribute");
461
462 int utf8Entry_length = 7;
463 boolean found = false;
464 for (int i = 0; i < nestedBytes.length - utf8Entry_length; i++) {
465 if (nestedBytes[i] == 1 && // utf8 tag
466 nestedBytes[i+1] == 0 && // msb of length
467 nestedBytes[i+2] == 4 && // lsb of length
468 nestedBytes[i+3] == (byte) 'H' &&
469 nestedBytes[i+4] == (byte) 'o' &&
470 nestedBytes[i+5] == (byte) 's' &&
471 nestedBytes[i+6] == (byte) 't') {
472
473 if (VERBOSE) System.out.println("Appear to have found Host utf8 entry starting at " + i);
474
475 nestedBytes[i+3] = (byte) 'G';
476 found = true;
477 break;
478 }
479 }
480
481 if (!found)
482 throw new Error("Could not locate 'Host' name in byte array");
483
484 map.put(_Host_A_nested, nestedBytes);
485
486 try {
487 vm().redefineClasses(map);
488 throw new Error("Retransformation to modified nested class" +
489 " succeeded unexpectedly");
490 }
491 catch (UnsupportedOperationException uoe) {
492 if (uoe.getMessage().contains("changes to class attribute not implemented")) {
493 System.out.println("Got expected exception " + uoe);
494 }
495 else throw new Error("Wrong UnsupportedOperationException", uoe);
496 }
497
498 }
499
500 void checkGoodTransforms(ReferenceType c, String[] dirs) throws Throwable {
501 // To verify the redefinition actually took place we will invoke the
502 // Host.getID method and check the result. To do that we need to find the
503 // main thread in the target VM. We don't check that "(new Host()).m()"
504 // returns 2 due to the complexity of setting that up via JDI.
505
506 ThreadReference main = null;
507 List<ThreadReference> threads = vm().allThreads();
508 for (ThreadReference t : threads) {
509 if (t.name().equals("main")) {
510 main = t;
511 break;
512 }
513 }
514
515 assertTrue(main != null);
516
517 // Now find the method
518 Method getID = null;
519 List<Method> methods = _Host.methodsByName("getID");
520 assertTrue(methods.size() == 1);
521 getID = methods.get(0);
522
523 Map<ReferenceType, byte[]> map = new HashMap<>();
524 for (String dir : dirs) {
525 dir += "/redef";
526 System.out.println("Trying good retransform from " + dir);
527 byte[] buf = bytesForHostClass(dir);
528 map.put(c, buf);
529 vm().redefineClasses(map);
530 map.clear();
531 // Test redefinition worked
532 Value v = ((ClassType)_Host).invokeMethod(main, getID, Collections.emptyList(), 0);
533 assertTrue(v instanceof StringReference);
534 String id = ((StringReference)v).value();
535 if (VERBOSE) System.out.println("Redefined ID: " + id);
536 assertTrue(id.startsWith(dir));
537 assertTrue(id.contains("/redef/"));
538 }
539 }
540
541 void checkBadTransforms(ReferenceType c, String[] dirs) throws Throwable {
542 Map<ReferenceType, byte[]> map = new HashMap<>();
543 for (String dir : dirs) {
544 dir += "/redef";
545 System.out.println("Trying bad retransform from " + dir);
546 byte[] buf = bytesForHostClass(dir);
547 map.put(c, buf);
548 try {
549 vm().redefineClasses(map);
550 throw new Error("Retransformation from directory " + dir +
551 " succeeded unexpectedly");
552 }
553 catch (UnsupportedOperationException uoe) {
554 if (uoe.getMessage().contains("changes to class attribute not implemented")) {
555 System.out.println("Got expected exception " + uoe);
556 }
557 else throw new Error("Wrong UnsupportedOperationException", uoe);
558 }
559 }
560 }
561
562 static byte[] bytesForHostClass(String dir) throws Throwable {
563 compile("/" + dir);
564 File clsfile = new File(DEST + "/" + dir + "/Host.class");
565 if (VERBOSE) System.out.println("Reading bytes from " + clsfile);
566 byte[] buf = null;
567 try (FileInputStream str = new FileInputStream(clsfile)) {
568 return buf = NamedBuffer.loadBufferFromStream(str);
569 }
570 }
571
572 static void compile(String dir) throws Throwable {
573 File src = new File(SRC + dir);
574 File dst = new File(DEST + dir);
575 if (VERBOSE) System.out.println("Compiling from: " + src + "\n" +
576 " to: " + dst);
577 CompilerUtils.compile(src.toPath(),
578 dst.toPath(),
579 false /* don't recurse */,
580 new String[0]);
581 }
582 }