1 /*

     2  * Copyright (c) 2015, 2016, 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.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.internal.module;

    27 

    28 import java.io.ByteArrayInputStream;

    29 import java.io.IOException;

    30 import java.io.InputStream;

    31 import java.io.UncheckedIOException;

    32 import java.lang.module.ModuleDescriptor;

    33 import java.lang.module.ModuleFinder;

    34 import java.lang.module.ModuleReader;

    35 import java.lang.module.ModuleReference;

    36 import java.net.URI;

    37 import java.net.URLConnection;

    38 import java.nio.ByteBuffer;

    39 import java.util.ArrayDeque;

    40 import java.util.Collections;

    41 import java.util.Deque;

    42 import java.util.HashMap;

    43 import java.util.Iterator;

    44 import java.util.Map;

    45 import java.util.Map.Entry;

    46 import java.util.Objects;

    47 import java.util.Optional;

    48 import java.util.Set;

    49 import java.util.Spliterator;

    50 import java.util.function.Consumer;

    51 import java.util.function.Supplier;

    52 import java.util.stream.Stream;

    53 import java.util.stream.StreamSupport;

    54 

    55 import jdk.internal.jimage.ImageLocation;

    56 import jdk.internal.jimage.ImageReader;

    57 import jdk.internal.jimage.ImageReaderFactory;

    58 import jdk.internal.misc.JavaNetUriAccess;

    59 import jdk.internal.misc.SharedSecrets;

    60 import jdk.internal.module.ModuleHashes.HashSupplier;

    61 import jdk.internal.perf.PerfCounter;

    62 

    63 /**

    64  * A {@code ModuleFinder} that finds modules that are linked into the

    65  * run-time image.

    66  *

    67  * The modules linked into the run-time image are assumed to have the

    68  * Packages attribute.

    69  */

    70 

    71 public class SystemModuleFinder implements ModuleFinder {

    72 

    73     private static final JavaNetUriAccess JNUA = SharedSecrets.getJavaNetUriAccess();

    74 

    75     private static final PerfCounter initTime

    76         = PerfCounter.newPerfCounter("jdk.module.finder.jimage.initTime");

    77     private static final PerfCounter moduleCount

    78         = PerfCounter.newPerfCounter("jdk.module.finder.jimage.modules");

    79     private static final PerfCounter packageCount

    80         = PerfCounter.newPerfCounter("jdk.module.finder.jimage.packages");

    81     private static final PerfCounter exportsCount

    82         = PerfCounter.newPerfCounter("jdk.module.finder.jimage.exports");

    83 

    84     // singleton finder to find modules in the run-time images

    85     private static final SystemModuleFinder INSTANCE;

    86 

    87     public static SystemModuleFinder getInstance() {

    88         return INSTANCE;

    89     }

    90 

    91     /**

    92      * For now, the module references are created eagerly on the assumption

    93      * that service binding will require all modules to be located.

    94      */

    95     static {

    96         long t0 = System.nanoTime();

    97 

    98         INSTANCE = new SystemModuleFinder();

    99 

   100         initTime.addElapsedTimeFrom(t0);

   101     }

   102 

   103     /**

   104      * Holder class for the ImageReader

   105      */

   106     private static class SystemImage {

   107         static final ImageReader READER;

   108         static {

   109             long t0 = System.nanoTime();

   110             READER = ImageReaderFactory.getImageReader();

   111             initTime.addElapsedTimeFrom(t0);

   112         }

   113 

   114         static ImageReader reader() {

   115             return READER;

   116         }

   117     }

   118 

   119     private static boolean isFastPathSupported() {

   120        return SystemModules.MODULE_NAMES.length > 0;

   121     }

   122 

   123     private static String[] moduleNames() {

   124         if (isFastPathSupported())

   125             // module names recorded at link time

   126             return SystemModules.MODULE_NAMES;

   127 

   128         // this happens when java.base is patched with java.base

   129         // from an exploded image

   130         return SystemImage.reader().getModuleNames();

   131     }

   132 

   133     // the set of modules in the run-time image

   134     private final Set<ModuleReference> modules;

   135 

   136     // maps module name to module reference

   137     private final Map<String, ModuleReference> nameToModule;

   138 

   139     // module name to hashes

   140     private final Map<String, byte[]> hashes;

   141 

   142     private SystemModuleFinder() {

   143         String[] names = moduleNames();

   144         int n = names.length;

   145         moduleCount.add(n);

   146 

   147         // fastpath is enabled by default.

   148         // It can be disabled for troubleshooting purpose.

   149         boolean disabled =

   150             System.getProperty("jdk.system.module.finder.disabledFastPath") != null;

   151 

   152         ModuleDescriptor[] descriptors;

   153         ModuleTarget[] targets;

   154         ModuleHashes[] recordedHashes;

   155         ModuleResolution[] moduleResolutions;

   156 

   157         // fast loading of ModuleDescriptor of system modules

   158         if (isFastPathSupported() && !disabled) {

   159             descriptors = SystemModules.descriptors();

   160             targets = SystemModules.targets();

   161             recordedHashes = SystemModules.hashes();

   162             moduleResolutions = SystemModules.moduleResolutions();

   163         } else {

   164             // if fast loading of ModuleDescriptors is disabled

   165             // fallback to read module-info.class

   166             descriptors = new ModuleDescriptor[n];

   167             targets = new ModuleTarget[n];

   168             recordedHashes = new ModuleHashes[n];

   169             moduleResolutions = new ModuleResolution[n];

   170             ImageReader imageReader = SystemImage.reader();

   171             for (int i = 0; i < names.length; i++) {

   172                 String mn = names[i];

   173                 ImageLocation loc = imageReader.findLocation(mn, "module-info.class");

   174                 ModuleInfo.Attributes attrs =

   175                     ModuleInfo.read(imageReader.getResourceBuffer(loc), null);

   176                 descriptors[i] = attrs.descriptor();

   177                 targets[i] = attrs.target();

   178                 recordedHashes[i] = attrs.recordedHashes();

   179                 moduleResolutions[i] = attrs.moduleResolution();

   180             }

   181         }

   182 

   183         Map<String, byte[]> hashes = null;

   184         boolean secondSeen = false;

   185         // record the hashes to build HashSupplier

   186         for (ModuleHashes mh : recordedHashes) {

   187             if (mh != null) {

   188                 // if only one module contain ModuleHashes, use it

   189                 if (hashes == null) {

   190                     hashes = mh.hashes();

   191                 } else {

   192                     if (!secondSeen) {

   193                         hashes = new HashMap<>(hashes);

   194                         secondSeen = true;

   195                     }

   196                     hashes.putAll(mh.hashes());

   197                 }

   198             }

   199         }

   200         this.hashes = (hashes == null) ? Map.of() : hashes;

   201 

   202         ModuleReference[] mods = new ModuleReference[n];

   203 

   204         @SuppressWarnings(value = {"rawtypes", "unchecked"})

   205         Entry<String, ModuleReference>[] map

   206             = (Entry<String, ModuleReference>[])new Entry[n];

   207 

   208         for (int i = 0; i < n; i++) {

   209             ModuleDescriptor md = descriptors[i];

   210 

   211             // create the ModuleReference

   212             ModuleReference mref = toModuleReference(md,

   213                                                      targets[i],

   214                                                      recordedHashes[i],

   215                                                      hashSupplier(names[i]),

   216                                                      moduleResolutions[i]);

   217             mods[i] = mref;

   218             map[i] = Map.entry(names[i], mref);

   219 

   220             // counters

   221             packageCount.add(md.packages().size());

   222             exportsCount.add(md.exports().size());

   223         }

   224 

   225         modules = Set.of(mods);

   226         nameToModule = Map.ofEntries(map);

   227     }

   228 

   229     @Override

   230     public Optional<ModuleReference> find(String name) {

   231         Objects.requireNonNull(name);

   232         return Optional.ofNullable(nameToModule.get(name));

   233     }

   234 

   235     @Override

   236     public Set<ModuleReference> findAll() {

   237         return modules;

   238     }

   239 

   240     private ModuleReference toModuleReference(ModuleDescriptor md,

   241                                               ModuleTarget target,

   242                                               ModuleHashes recordedHashes,

   243                                               HashSupplier hasher,

   244                                               ModuleResolution mres) {

   245         String mn = md.name();

   246         URI uri = JNUA.create("jrt", "/".concat(mn));

   247 

   248         Supplier<ModuleReader> readerSupplier = new Supplier<>() {

   249             @Override

   250             public ModuleReader get() {

   251                 return new ImageModuleReader(mn, uri);

   252             }

   253         };

   254 

   255         ModuleReference mref = new ModuleReferenceImpl(md,

   256                                                        uri,

   257                                                        readerSupplier,

   258                                                        null,

   259                                                        target,

   260                                                        recordedHashes,

   261                                                        hasher,

   262                                                        mres);

   263 

   264         // may need a reference to a patched module if --patch-module specified

   265         mref = ModuleBootstrap.patcher().patchIfNeeded(mref);

   266 

   267         return mref;

   268     }

   269 

   270     private HashSupplier hashSupplier(String name) {

   271         if (!hashes.containsKey(name))

   272             return null;

   273 

   274         return new HashSupplier() {

   275             @Override

   276             public byte[] generate(String algorithm) {

   277                 return hashes.get(name);

   278             }

   279         };

   280     }

   281 

   282     /**

   283      * A ModuleReader for reading resources from a module linked into the

   284      * run-time image.

   285      */

   286     static class ImageModuleReader implements ModuleReader {

   287         private final String module;

   288         private volatile boolean closed;

   289 

   290         /**

   291          * If there is a security manager set then check permission to

   292          * connect to the run-time image.

   293          */

   294         private static void checkPermissionToConnect(URI uri) {

   295             SecurityManager sm = System.getSecurityManager();

   296             if (sm != null) {

   297                 try {

   298                     URLConnection uc = uri.toURL().openConnection();

   299                     sm.checkPermission(uc.getPermission());

   300                 } catch (IOException ioe) {

   301                     throw new UncheckedIOException(ioe);

   302                 }

   303             }

   304         }

   305 

   306         ImageModuleReader(String module, URI uri) {

   307             checkPermissionToConnect(uri);

   308             this.module = module;

   309         }

   310 

   311         /**

   312          * Returns the ImageLocation for the given resource, {@code null}

   313          * if not found.

   314          */

   315         private ImageLocation findImageLocation(String name) throws IOException {

   316             Objects.requireNonNull(name);

   317             if (closed)

   318                 throw new IOException("ModuleReader is closed");

   319             ImageReader imageReader = SystemImage.reader();

   320             if (imageReader != null) {

   321                 return imageReader.findLocation(module, name);

   322             } else {

   323                 // not an images build

   324                 return null;

   325             }

   326         }

   327 

   328         @Override

   329         public Optional<URI> find(String name) throws IOException {

   330             ImageLocation location = findImageLocation(name);

   331             if (location != null) {

   332                 URI u = URI.create("jrt:/" + module + "/" + name);

   333                 return Optional.of(u);

   334             } else {

   335                 return Optional.empty();

   336             }

   337         }

   338 

   339         @Override

   340         public Optional<InputStream> open(String name) throws IOException {

   341             return read(name).map(this::toInputStream);

   342         }

   343 

   344         private InputStream toInputStream(ByteBuffer bb) { // ## -> ByteBuffer?

   345             try {

   346                 int rem = bb.remaining();

   347                 byte[] bytes = new byte[rem];

   348                 bb.get(bytes);

   349                 return new ByteArrayInputStream(bytes);

   350             } finally {

   351                 release(bb);

   352             }

   353         }

   354 

   355         @Override

   356         public Optional<ByteBuffer> read(String name) throws IOException {

   357             ImageLocation location = findImageLocation(name);

   358             if (location != null) {

   359                 return Optional.of(SystemImage.reader().getResourceBuffer(location));

   360             } else {

   361                 return Optional.empty();

   362             }

   363         }

   364 

   365         @Override

   366         public void release(ByteBuffer bb) {

   367             Objects.requireNonNull(bb);

   368             ImageReader.releaseByteBuffer(bb);

   369         }

   370 

   371         @Override

   372         public Stream<String> list() throws IOException {

   373             if (closed)

   374                 throw new IOException("ModuleReader is closed");

   375 

   376             Spliterator<String> s = new ModuleContentSpliterator(module);

   377             return StreamSupport.stream(s, false);

   378         }

   379 

   380         @Override

   381         public void close() {

   382             // nothing else to do

   383             closed = true;

   384         }

   385     }

   386 

   387     /**

   388      * A Spliterator for traversing the resources of a module linked into the

   389      * run-time image.

   390      */

   391     static class ModuleContentSpliterator implements Spliterator<String> {

   392         final String moduleRoot;

   393         final Deque<ImageReader.Node> stack;

   394         Iterator<ImageReader.Node> iterator;

   395 

   396         ModuleContentSpliterator(String module) throws IOException {

   397             moduleRoot = "/modules/" + module;

   398             stack = new ArrayDeque<>();

   399 

   400             // push the root node to the stack to get started

   401             ImageReader.Node dir = SystemImage.reader().findNode(moduleRoot);

   402             if (dir == null || !dir.isDirectory())

   403                 throw new IOException(moduleRoot + " not a directory");

   404             stack.push(dir);

   405             iterator = Collections.emptyIterator();

   406         }

   407 

   408         /**

   409          * Returns the name of the next non-directory node or {@code null} if

   410          * there are no remaining nodes to visit.

   411          */

   412         private String next() throws IOException {

   413             for (;;) {

   414                 while (iterator.hasNext()) {

   415                     ImageReader.Node node = iterator.next();

   416                     String name = node.getName();

   417                     if (node.isDirectory()) {

   418                         // build node

   419                         ImageReader.Node dir = SystemImage.reader().findNode(name);

   420                         assert dir.isDirectory();

   421                         stack.push(dir);

   422                     } else {

   423                         // strip /modules/$MODULE/ prefix

   424                         return name.substring(moduleRoot.length() + 1);

   425                     }

   426                 }

   427 

   428                 if (stack.isEmpty()) {

   429                     return null;

   430                 } else {

   431                     ImageReader.Node dir = stack.poll();

   432                     assert dir.isDirectory();

   433                     iterator = dir.getChildren().iterator();

   434                 }

   435             }

   436         }

   437 

   438         @Override

   439         public boolean tryAdvance(Consumer<? super String> action) {

   440             String next;

   441             try {

   442                 next = next();

   443             } catch (IOException ioe) {

   444                 throw new UncheckedIOException(ioe);

   445             }

   446             if (next != null) {

   447                 action.accept(next);

   448                 return true;

   449             } else {

   450                 return false;

   451             }

   452         }

   453 

   454         @Override

   455         public Spliterator<String> trySplit() {

   456             return null;

   457         }

   458 

   459         @Override

   460         public int characteristics() {

   461             return Spliterator.DISTINCT + Spliterator.NONNULL + Spliterator.IMMUTABLE;

   462         }

   463 

   464         @Override

   465         public long estimateSize() {

   466             return Long.MAX_VALUE;

   467         }

   468     }

   469 }