1 /*

     2  * Copyright (c) 2014, 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 import java.io.File;

    25 import java.io.IOException;

    26 import java.io.UncheckedIOException;

    27 import java.nio.file.DirectoryStream;

    28 import java.nio.file.Files;

    29 import java.nio.file.Path;

    30 import java.nio.file.Paths;

    31 import java.nio.file.attribute.BasicFileAttributes;

    32 import java.util.ArrayList;

    33 import java.util.Arrays;

    34 import java.util.Deque;

    35 import java.util.List;

    36 import java.util.Set;

    37 import java.util.concurrent.ConcurrentLinkedDeque;

    38 import java.util.concurrent.ExecutorService;

    39 import java.util.concurrent.Executors;

    40 import java.util.concurrent.TimeUnit;

    41 import java.util.concurrent.atomic.AtomicInteger;

    42 import java.util.stream.Collectors;

    43 import java.util.stream.Stream;

    44 

    45 import jdk.internal.jimage.BasicImageReader;

    46 import jdk.internal.jimage.ImageLocation;

    47 

    48 /*

    49  * @test

    50  * @summary Verify jimage

    51  * @run main/othervm VerifyJimage

    52  */

    53 

    54 /**

    55  * This test runs in two modes:

    56  * (1) No argument: it verifies the jimage by loading all classes in the runtime

    57  * (2) path of exploded modules: it compares bytes of each file in the exploded

    58  *     module with the entry in jimage

    59  *

    60  * FIXME: exception thrown when findLocation from jimage by multiple threads

    61  * -Djdk.test.threads=<n> to specify the number of threads.

    62  */

    63 public class VerifyJimage {

    64     private static final Deque<String> failed = new ConcurrentLinkedDeque<>();

    65 

    66     public static void main(String... args) throws Exception {

    67         long start = System.nanoTime();

    68         int numThreads = Integer.getInteger("jdk.test.threads", 1);

    69         List<JImageReader> readers = newJImageReaders();

    70         VerifyJimage verify = new VerifyJimage(readers, numThreads);

    71         if (args.length == 0) {

    72             // load classes from jimage

    73             verify.loadClasses();

    74         } else {

    75             Path dir = Paths.get(args[0]);

    76             if (Files.notExists(dir) || !Files.isDirectory(dir)) {

    77                 throw new RuntimeException("Invalid argument: " + dir);

    78             }

    79             verify.compareExplodedModules(dir);

    80         }

    81         verify.waitForCompletion();

    82         long end = System.nanoTime();

    83         int entries = readers.stream()

    84                              .mapToInt(JImageReader::entries)

    85                              .sum();

    86         System.out.format("%d entries %d files verified: %d ms %d errors%n",

    87                           entries, verify.count.get(),

    88                           TimeUnit.NANOSECONDS.toMillis(end - start), failed.size());

    89         for (String f : failed) {

    90             System.err.println(f);

    91         }

    92     }

    93 

    94     private final AtomicInteger count = new AtomicInteger(0);

    95     private final List<JImageReader> readers;

    96     private final ExecutorService pool;

    97 

    98     VerifyJimage(List<JImageReader> readers, int numThreads) {

    99         this.readers = readers;

   100         this.pool = Executors.newFixedThreadPool(numThreads);

   101     }

   102 

   103     private void waitForCompletion() throws InterruptedException {

   104         pool.shutdown();

   105         pool.awaitTermination(20, TimeUnit.SECONDS);

   106     }

   107 

   108     private void compareExplodedModules(Path dir) throws IOException {

   109         System.out.println("comparing jimage with " + dir);

   110 

   111         try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {

   112             for (Path mdir : stream) {

   113                 if (Files.isDirectory(mdir)) {

   114                     pool.execute(new Runnable() {

   115                         @Override

   116                         public void run() {

   117                             try {

   118                                 Files.find(mdir, Integer.MAX_VALUE, (Path p, BasicFileAttributes attr)

   119                                            -> !Files.isDirectory(p) &&

   120                                               !mdir.relativize(p).toString().startsWith("_") &&

   121                                               !p.getFileName().toString().equals("MANIFEST.MF"))

   122                                      .forEach(p -> compare(mdir, p, readers));

   123                             } catch (IOException e) {

   124                                 throw new UncheckedIOException(e);

   125                             }

   126                         }

   127                     });

   128                 }

   129             }

   130         }

   131     }

   132 

   133     private final List<String> BOOT_RESOURCES = Arrays.asList(

   134         "java.base/META-INF/services/java.nio.file.spi.FileSystemProvider"

   135     );

   136     private final List<String> EXT_RESOURCES = Arrays.asList(

   137         "jdk.zipfs/META-INF/services/java.nio.file.spi.FileSystemProvider"

   138     );

   139     private final List<String> APP_RESOURCES = Arrays.asList(

   140         "jdk.hotspot.agent/META-INF/services/com.sun.jdi.connect.Connector",

   141         "jdk.jdi/META-INF/services/com.sun.jdi.connect.Connector"

   142     );

   143 

   144     private void compare(Path mdir, Path p, List<JImageReader> readers) {

   145         String entry = mdir.relativize(p).toString().replace(File.separatorChar, '/');

   146 

   147         count.incrementAndGet();

   148         String file = mdir.getFileName().toString() + "/" + entry;

   149         if (APP_RESOURCES.contains(file)) {

   150             // skip until the service config file is merged

   151             System.out.println("Skipped " + file);

   152             return;

   153         }

   154 

   155         String jimage;

   156         if (BOOT_RESOURCES.contains(file)) {

   157             jimage = "bootmodules.jimage";

   158         } else if (EXT_RESOURCES.contains(file)) {

   159             jimage = "extmodules.jimage";

   160         } else {

   161             jimage = "";

   162         }

   163         JImageReader reader = readers.stream()

   164                 .filter(r -> r.findLocation(entry) != null)

   165                 .filter(r -> jimage.isEmpty() || r.imageName().equals(jimage))

   166                 .findFirst().orElse(null);

   167         if (reader == null) {

   168             failed.add(entry + " not found: " + p.getFileName().toString());

   169         } else {

   170             reader.compare(entry, p);

   171         }

   172     }

   173 

   174     private void loadClasses() {

   175         ClassLoader loader = ClassLoader.getSystemClassLoader();

   176         for (JImageReader reader : readers) {

   177             Arrays.stream(reader.getEntryNames())

   178                     .filter(n -> n.endsWith(".class"))

   179                     .forEach(n -> {

   180                         String cn = n.substring(0, n.length()-6).replace('/', '.');

   181                         count.incrementAndGet();

   182                         try {

   183                             Class.forName(cn, false, loader);

   184                         } catch (ClassNotFoundException e) {

   185                             failed.add(reader.imageName() + ": " + cn + " not found");

   186                         }

   187                     });

   188         }

   189     }

   190 

   191 

   192    private static List<JImageReader> newJImageReaders() throws IOException {

   193         String home = System.getProperty("java.home");

   194         Path mlib = Paths.get(home, "lib", "modules");

   195         try (Stream<Path> paths = Files.list(mlib)) {

   196             Set<Path> jimages = paths.filter(p -> p.toString().endsWith(".jimage"))

   197                                      .collect(Collectors.toSet());

   198             List<JImageReader> result = new ArrayList<>();

   199             for (Path jimage: jimages) {

   200                 result.add(new JImageReader(jimage));

   201                 System.out.println("opened " + jimage);

   202             }

   203             return result;

   204         }

   205     }

   206 

   207     static class JImageReader extends BasicImageReader {

   208         final Path jimage;

   209         JImageReader(Path p) throws IOException {

   210             super(p.toString());

   211             this.jimage = p;

   212         }

   213 

   214         String imageName() {

   215             return jimage.getFileName().toString();

   216         }

   217 

   218         int entries() {

   219             return getHeader().getLocationCount();

   220         }

   221 

   222         void compare(String entry, Path p) {

   223             try {

   224                 byte[] bytes = Files.readAllBytes(p);

   225                 byte[] imagebytes = getResource(entry);

   226                 if (!Arrays.equals(bytes, imagebytes)) {

   227                     failed.add(imageName() + ": bytes differs than " + p.toString());

   228                 }

   229             } catch (IOException e) {

   230                 throw new UncheckedIOException(e);

   231             }

   232         }

   233     }

   234 }