1 /*
2 * Copyright (c) 2014, 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
25 import java.io.File;
26 import java.io.FileOutputStream;
27 import jdk.test.lib.process.OutputAnalyzer;
28 import java.nio.file.Files;
29
30 import java.util.*;
31 import jdk.internal.org.objectweb.asm.*;
32
33 /**
34 * The testsets contained in this class are executed by ./VerifierTest_*.java, so that
35 * individual testsets can be executed in parallel to shorten the total time required.
36 */
37 public class VerifierTest implements Opcodes {
38 // Test verification settings for dumping & runtime
39 static final String VFY_ALL = "-Xverify:all";
40 static final String VFY_REMOTE = "-Xverify:remote"; // default
41 static final String VFY_NONE = "-XX:+UnlockDiagnosticVMOptions, -XX:-BytecodeVerificationRemote, -XX:-BytecodeVerificationLocal";
42
43 static final String ERR =
44 "ERROR: class VerifierTestC was loaded unexpectedly";
45 static final String MAP_FAIL =
46 "shared archive file was created with less restrictive verification setting";
47 static final String VFY_ERR = "java.lang.VerifyError";
48 static final String PASS_RESULT = "Hi, how are you?";
49 static final String VFY_INFO_MESSAGE =
50 "All non-system classes will be verified (-Xverify:remote) during CDS dump time.";
51 static final String CDS_LOGGING = "-Xlog:cds,cds+hashtables";
52
53 enum Testset1Part {
54 A, B
55 }
56
57 public static void main(String[] args) throws Exception {
58 String subCaseId = args[0];
59 String jarName_verifier_test_tmp = "verifier_test_tmp" + "_" + subCaseId;
60 String jarName_verifier_test = "verifier_test" + "_" + subCaseId;
61 String jarName_greet = "greet" + "_" + subCaseId;
62 String jarName_hi = "hi" + "_" + subCaseId;
63
64
65 JarBuilder.build(jarName_verifier_test_tmp, "VerifierTest0", "VerifierTestA",
66 "VerifierTestB", "VerifierTestC", "VerifierTestD", "VerifierTestE",
67 "UnverifiableBase", "UnverifiableIntf", "UnverifiableIntfSub");
68 JarBuilder.build(jarName_greet, "Greet");
69 JarBuilder.build(jarName_hi, "Hi", "Hi$MyClass");
70
71 File dir = new File(System.getProperty("test.classes", "."));
72 File jarSrcFile = new File(dir, jarName_verifier_test_tmp + ".jar");
73 File jarFile = new File(dir, jarName_verifier_test + ".jar");
74 String jar = jarFile.getPath();
75
76 if (!jarFile.exists() || jarFile.lastModified() < jarSrcFile.lastModified()) {
77 createTestJarFile(jarSrcFile, jarFile);
78 } else {
79 System.out.println("Already up-to-date: " + jarFile);
80 }
81
82 String noAppClasses[] = TestCommon.list("");
83 String appClasses[] = TestCommon.list("UnverifiableBase",
84 "UnverifiableIntf",
85 "UnverifiableIntfSub",
86 "VerifierTestA",
87 "VerifierTestB",
88 "VerifierTestC",
89 "VerifierTestD",
90 "VerifierTestE",
91 "VerifierTest0");
92
93
94 switch (subCaseId) {
95 case "0": testset_0(jar, noAppClasses, appClasses); return;
96 case "1A": testset_1(jar, noAppClasses, appClasses, Testset1Part.A); return;
97 case "1B": testset_1(jar, noAppClasses, appClasses, Testset1Part.B); return;
98 case "2": testset_2(jarName_greet, jarName_hi); return;
99 default:
100 throw new RuntimeException("Unknown option: " + subCaseId);
101 }
102 }
103
104 static void testset_0(String jar, String[] noAppClasses, String[] appClasses) throws Exception {
105 // Unverifiable classes won't be included in the CDS archive.
106 // Dumping should not fail.
107 OutputAnalyzer output = TestCommon.dump(jar, appClasses);
108 output.shouldHaveExitValue(0);
109 if (output.getStdout().contains("Loading clases to share")) {
110 // last entry in appClasses[] is a verifiable class
111 for (int i = 0; i < (appClasses.length - 1); i++) {
112 output.shouldContain("Verification failed for " + appClasses[i]);
113 output.shouldContain("Removed error class: " + appClasses[i]);
114 }
115 }
116 }
117
118 static void checkRuntimeOutput(OutputAnalyzer output, String expected) throws Exception {
119 output.shouldContain(expected);
120 if (expected.equals(PASS_RESULT) ||
121 expected.equals(VFY_ERR)) {
122 output.shouldHaveExitValue(0);
123 } else {
124 output.shouldNotHaveExitValue(0);
125 }
126 }
127
128 static void testset_1(String jar, String[] noAppClasses, String[] appClasses, Testset1Part part)
129 throws Exception
130 {
131 String config[][] = {
132 // {dump_list, dumptime_verification_setting,
133 // runtime_verification_setting, expected_output_str},
134
135 // Dump app/ext with -Xverify:remote
136 {"app", VFY_REMOTE, VFY_REMOTE, VFY_ERR},
137 {"app", VFY_REMOTE, VFY_ALL, MAP_FAIL},
138 {"app", VFY_REMOTE, VFY_NONE, ERR },
139 // Dump app/ext with -Xverify:all
140 {"app", VFY_ALL, VFY_REMOTE, VFY_ERR },
141 {"app", VFY_ALL, VFY_ALL, VFY_ERR },
142 {"app", VFY_ALL, VFY_NONE, ERR },
143 // Dump app/ext with verifier turned off
144 {"app", VFY_NONE, VFY_REMOTE, VFY_ERR},
145 {"app", VFY_NONE, VFY_ALL, MAP_FAIL},
146 {"app", VFY_NONE, VFY_NONE, ERR },
147 // Dump sys only with -Xverify:remote
148 {"noApp", VFY_REMOTE, VFY_REMOTE, VFY_ERR},
149 {"noApp", VFY_REMOTE, VFY_ALL, VFY_ERR},
150 {"noApp", VFY_REMOTE, VFY_NONE, ERR},
151 // Dump sys only with -Xverify:all
152 {"noApp", VFY_ALL, VFY_REMOTE, VFY_ERR},
153 {"noApp", VFY_ALL, VFY_ALL, VFY_ERR},
154 {"noApp", VFY_ALL, VFY_NONE, ERR},
155 // Dump sys only with verifier turned off
156 {"noApp", VFY_NONE, VFY_REMOTE, VFY_ERR},
157 {"noApp", VFY_NONE, VFY_ALL, VFY_ERR},
158 {"noApp", VFY_NONE, VFY_NONE, ERR},
159 };
160
161 int loop_start, loop_stop;
162
163 // Further break down testset_1 into two parts (to be invoked from VerifierTest_1A.java
164 // and VerifierTest_1B.java) to improve parallel test execution time.
165 switch (part) {
166 case A:
167 loop_start = 0;
168 loop_stop = 9;
169 break;
170 case B:
171 default:
172 assert part == Testset1Part.B;
173 loop_start = 9;
174 loop_stop = config.length;
175 break;
176 }
177
178 String prev_dump_setting = "";
179 for (int i = loop_start; i < loop_stop; i ++) {
180 String dump_list[] = config[i][0].equals("app") ? appClasses :
181 noAppClasses;
182 String dump_setting = config[i][1];
183 String runtime_setting = config[i][2];
184 String expected_output_str = config[i][3];
185 System.out.println("Test case [" + i + "]: dumping " + config[i][0] +
186 " with " + dump_setting +
187 ", run with " + runtime_setting);
188 if (!dump_setting.equals(prev_dump_setting)) {
189 String dump_arg1;
190 String dump_arg2;
191 String dump_arg3;
192 // Need to break this into two separate arguments.
193 if (dump_setting.equals(VFY_NONE)) {
194 dump_arg1 = "-XX:+UnlockDiagnosticVMOptions";
195 dump_arg2 = "-XX:-BytecodeVerificationRemote";
196 dump_arg3 = "-XX:-BytecodeVerificationLocal";
197 } else {
198 // Redundant args should be harmless.
199 dump_arg1 = dump_arg2 = dump_arg3 = dump_setting;
200 }
201
202 OutputAnalyzer dumpOutput = TestCommon.dump(
203 jar, dump_list, dump_arg1, dump_arg2,
204 dump_arg3, CDS_LOGGING,
205 // FIXME: the following options are for working around a GC
206 // issue - assert failure when dumping archive with the -Xverify:all
207 "-Xms256m",
208 "-Xmx256m");
209 if (dump_setting.equals(VFY_NONE) &&
210 runtime_setting.equals(VFY_REMOTE)) {
211 dumpOutput.shouldContain(VFY_INFO_MESSAGE);
212 }
213 }
214 String runtime_arg1;
215 String runtime_arg2;
216 String runtime_arg3;
217 if (runtime_setting.equals(VFY_NONE)) {
218 runtime_arg1 = "-XX:+UnlockDiagnosticVMOptions";
219 runtime_arg2 = "-XX:-BytecodeVerificationRemote";
220 runtime_arg3 = "-XX:-BytecodeVerificationLocal";
221 } else {
222 // Redundant args should be harmless.
223 runtime_arg1 = runtime_arg2 = runtime_arg3 = runtime_setting;
224 }
225 TestCommon.run("-cp", jar,
226 runtime_arg1, runtime_arg2, runtime_arg3,
227 "VerifierTest0")
228 .ifNoMappingFailure(output -> checkRuntimeOutput(output, expected_output_str));
229 prev_dump_setting = dump_setting;
230 }
231 }
232
233 static void testset_2(String jarName_greet, String jarName_hi) throws Exception {
234 String appClasses[];
235 String jar;
236
237 // The following section is for testing the scenarios where
238 // the classes are verifiable during dump time.
239 appClasses = TestCommon.list("Hi",
240 "Greet",
241 "Hi$MyClass");
242 jar = TestCommon.getTestJar(jarName_hi + ".jar") + File.pathSeparator +
243 TestCommon.getTestJar(jarName_greet + ".jar");
244 String config2[][] = {
245 // {dump_list, dumptime_verification_setting,
246 // runtime_verification_setting, expected_output_str},
247
248 // Dump app/ext with -Xverify:remote
249 {"app", VFY_REMOTE, VFY_REMOTE, PASS_RESULT},
250 {"app", VFY_REMOTE, VFY_ALL, MAP_FAIL},
251 {"app", VFY_REMOTE, VFY_NONE, PASS_RESULT },
252 // Dump app/ext with -Xverify:all
253 {"app", VFY_ALL, VFY_REMOTE, PASS_RESULT },
254 {"app", VFY_ALL, VFY_ALL, PASS_RESULT },
255 {"app", VFY_ALL, VFY_NONE, PASS_RESULT },
256 // Dump app/ext with verifier turned off
257 {"app", VFY_NONE, VFY_REMOTE, PASS_RESULT},
258 {"app", VFY_NONE, VFY_ALL, MAP_FAIL},
259 {"app", VFY_NONE, VFY_NONE, PASS_RESULT },
260 };
261 String prev_dump_setting = "";
262 for (int i = 0; i < config2.length; i ++) {
263 // config2[i][0] is always set to "app" in this test
264 String dump_setting = config2[i][1];
265 String runtime_setting = config2[i][2];
266 String expected_output_str = config2[i][3];
267 System.out.println("Test case [" + i + "]: dumping " + config2[i][0] +
268 " with " + dump_setting +
269 ", run with " + runtime_setting);
270 if (!dump_setting.equals(prev_dump_setting)) {
271 String dump_arg1;
272 String dump_arg2;
273 String dump_arg3;
274 if (dump_setting.equals(VFY_NONE)) {
275 dump_arg1 = "-XX:+UnlockDiagnosticVMOptions";
276 dump_arg2 = "-XX:-BytecodeVerificationRemote";
277 dump_arg3 = "-XX:-BytecodeVerificationLocal";
278 } else {
279 // Redundant args should be harmless.
280 dump_arg1 = dump_arg2 = dump_arg3 = dump_setting;
281 }
282 OutputAnalyzer dumpOutput = TestCommon.dump(
283 jar, appClasses, dump_arg1, dump_arg2,
284 dump_arg3, CDS_LOGGING,
285 // FIXME: the following options are for working around a GC
286 // issue - assert failure when dumping archive with the -Xverify:all
287 "-Xms256m",
288 "-Xmx256m");
289 if (dump_setting.equals(VFY_NONE) &&
290 runtime_setting.equals(VFY_REMOTE)) {
291 dumpOutput.shouldContain(VFY_INFO_MESSAGE);
292 }
293 }
294 String runtime_arg1;
295 String runtime_arg2;
296 String runtime_arg3;
297 if (runtime_setting.equals(VFY_NONE)) {
298 runtime_arg1 = "-XX:+UnlockDiagnosticVMOptions";
299 runtime_arg2 = "-XX:-BytecodeVerificationRemote";
300 runtime_arg3 = "-XX:-BytecodeVerificationLocal";
301 } else {
302 // Redundant args should be harmless.
303 runtime_arg1 = runtime_arg2 = runtime_arg3 = runtime_setting;
304 }
305 TestCommon.run("-cp", jar,
306 runtime_arg1, runtime_arg2, runtime_arg3,
307 "Hi")
308 .ifNoMappingFailure(output -> checkRuntimeOutput(output, expected_output_str));
309 prev_dump_setting = dump_setting;
310 }
311 }
312
313 static void createTestJarFile(File jarSrcFile, File jarFile) throws Exception {
314 jarFile.delete();
315 Files.copy(jarSrcFile.toPath(), jarFile.toPath());
316
317 File dir = new File(System.getProperty("test.classes", "."));
318 File outdir = new File(dir, "verifier_test_classes");
319 outdir.mkdir();
320
321 writeClassFile(new File(outdir, "UnverifiableBase.class"), makeUnverifiableBase());
322 writeClassFile(new File(outdir, "UnverifiableIntf.class"), makeUnverifiableIntf());
323
324 JarBuilder.update(jarFile.getPath(), outdir.getPath());
325 }
326
327 static void writeClassFile(File file, byte bytecodes[]) throws Exception {
328 try (FileOutputStream fos = new FileOutputStream(file)) {
329 fos.write(bytecodes);
330 }
331 }
332
333 // This was obtained using JDK8: java jdk.internal.org.objectweb.asm.util.ASMifier tmpclasses/UnverifiableBase.class
334 static byte[] makeUnverifiableBase() throws Exception {
335 ClassWriter cw = new ClassWriter(0);
336 FieldVisitor fv;
337 MethodVisitor mv;
338 AnnotationVisitor av0;
339
340 cw.visit(V1_8, ACC_SUPER, "UnverifiableBase", null, "java/lang/Object", null);
341 {
342 fv = cw.visitField(ACC_FINAL + ACC_STATIC, "x", "LVerifierTest;", null, null);
343 fv.visitEnd();
344 }
345 {
346 mv = cw.visitMethod(0, "<init>", "()V", null, null);
347 mv.visitCode();
348 mv.visitVarInsn(ALOAD, 0);
349 mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
350 mv.visitInsn(RETURN);
351 mv.visitMaxs(1, 1);
352 mv.visitEnd();
353 }
354 {
355 mv = cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
356 mv.visitCode();
357 mv.visitTypeInsn(NEW, "VerifierTest0");
358 mv.visitInsn(DUP);
359 mv.visitMethodInsn(INVOKESPECIAL, "VerifierTest0", "<init>", "()V", false);
360 mv.visitFieldInsn(PUTSTATIC, "UnverifiableBase", "x", "LVerifierTest;");
361 mv.visitInsn(RETURN);
362 mv.visitMaxs(2, 0);
363 mv.visitEnd();
364 }
365 addBadMethod(cw);
366 cw.visitEnd();
367
368 return cw.toByteArray();
369 }
370
371 // This was obtained using JDK8: java jdk.internal.org.objectweb.asm.util.ASMifier tmpclasses/UnverifiableIntf.class
372 static byte[] makeUnverifiableIntf() throws Exception {
373 ClassWriter cw = new ClassWriter(0);
374 FieldVisitor fv;
375 MethodVisitor mv;
376 AnnotationVisitor av0;
377
378 cw.visit(V1_8, ACC_ABSTRACT + ACC_INTERFACE, "UnverifiableIntf", null, "java/lang/Object", null);
379
380 {
381 fv = cw.visitField(ACC_PUBLIC + ACC_FINAL + ACC_STATIC, "x", "LVerifierTest0;", null, null);
382 fv.visitEnd();
383 }
384 {
385 mv = cw.visitMethod(ACC_STATIC, "<clinit>", "()V", null, null);
386 mv.visitCode();
387 mv.visitTypeInsn(NEW, "VerifierTest0");
388 mv.visitInsn(DUP);
389 mv.visitMethodInsn(INVOKESPECIAL, "VerifierTest0", "<init>", "()V", false);
390 mv.visitFieldInsn(PUTSTATIC, "UnverifiableIntf", "x", "LVerifierTest0;");
391 mv.visitInsn(RETURN);
392 mv.visitMaxs(2, 0);
393 mv.visitEnd();
394 }
395 addBadMethod(cw);
396 cw.visitEnd();
397
398 return cw.toByteArray();
399 }
400
401 // Add a bad method to make the class fail verification.
402 static void addBadMethod(ClassWriter cw) throws Exception {
403 MethodVisitor mv = cw.visitMethod(ACC_PUBLIC, "bad", "()V", null, null);
404 mv.visitCode();
405 mv.visitInsn(ARETURN); // java.lang.VerifyError: Operand stack underflow
406 mv.visitMaxs(2, 2);
407 mv.visitEnd();
408 }
409 }