1 /*
2 * Copyright (c) 2015, 2025, 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 package jdk.internal.loader;
26
27 import java.io.IOException;
28 import java.io.InputStream;
29 import java.lang.module.ModuleReference;
30 import java.net.MalformedURLException;
31 import java.net.URI;
32 import java.net.URL;
33 import java.nio.file.Files;
34 import java.nio.file.Path;
35 import java.util.Arrays;
36 import java.util.Enumeration;
37 import java.util.concurrent.ConcurrentHashMap;
38 import java.util.jar.JarInputStream;
39 import java.util.jar.Manifest;
40 import java.util.stream.Stream;
41
42 import jdk.internal.access.JavaLangAccess;
43 import jdk.internal.access.SharedSecrets;
44 import jdk.internal.module.Modules;
45 import jdk.internal.module.ServicesCatalog;
46 import jdk.internal.util.StaticProperty;
47
48 /**
49 * Find resources and packages in modules defined to the boot class loader or
50 * resources and packages on the "boot class path" specified via -Xbootclasspath/a.
51 */
52
53 public class BootLoader {
54 private BootLoader() { }
55
56 private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
57
58 // The unnamed module for the boot loader
59 private static final Module UNNAMED_MODULE;
60 private static final String JAVA_HOME = StaticProperty.javaHome();
61
62 static {
63 JavaLangAccess jla = SharedSecrets.getJavaLangAccess();
64 UNNAMED_MODULE = jla.defineUnnamedModule(null);
65 jla.addEnableNativeAccess(UNNAMED_MODULE);
66 setBootLoaderUnnamedModule0(UNNAMED_MODULE);
67 }
68
69 // ClassLoaderValue map for the boot class loader
70 private static final ConcurrentHashMap<?, ?> CLASS_LOADER_VALUE_MAP
71 = new ConcurrentHashMap<>();
72
73 // Holder has the field(s) that need to be initialized during JVM bootstrap even if
74 // the outer is aot-initialized.
75 private static class Holder {
76 // native libraries loaded by the boot class loader
77 private static final NativeLibraries NATIVE_LIBS
78 = NativeLibraries.newInstance(null);
79 }
80
81 /**
82 * Returns the unnamed module for the boot loader.
83 */
84 public static Module getUnnamedModule() {
85 return UNNAMED_MODULE;
86 }
87
88 /**
89 * Returns the ServiceCatalog for modules defined to the boot class loader.
90 */
91 public static ServicesCatalog getServicesCatalog() {
92 return ServicesCatalog.getServicesCatalog(ClassLoaders.bootLoader());
93 }
94
95 /**
96 * Returns the ClassLoaderValue map for the boot class loader.
97 */
98 public static ConcurrentHashMap<?, ?> getClassLoaderValueMap() {
99 return CLASS_LOADER_VALUE_MAP;
100 }
101
102 /**
103 * Returns NativeLibraries for the boot class loader.
104 */
105 public static NativeLibraries getNativeLibraries() {
106 return Holder.NATIVE_LIBS;
107 }
108
109 /**
110 * Returns {@code true} if there is a class path associated with the
111 * BootLoader.
112 */
113 public static boolean hasClassPath() {
114 return ClassLoaders.bootLoader().hasClassPath();
115 }
116
117 /**
118 * Registers a module with this class loader so that its classes
119 * (and resources) become visible via this class loader.
120 */
121 public static void loadModule(ModuleReference mref) {
122 ClassLoaders.bootLoader().loadModule(mref);
123 }
124
125 /**
126 * Loads the Class object with the given name defined to the boot loader.
127 */
128 public static Class<?> loadClassOrNull(String name) {
129 return JLA.findBootstrapClassOrNull(name);
130 }
131
132 /**
133 * Loads the Class object with the given name in the given module
134 * defined to the boot loader. Returns {@code null} if not found.
135 */
136 public static Class<?> loadClass(Module module, String name) {
137 Class<?> c = loadClassOrNull(name);
138 if (c != null && c.getModule() == module) {
139 return c;
140 } else {
141 return null;
142 }
143 }
144
145 /**
146 * Loads a native library from the system library path.
147 */
148 public static void loadLibrary(String name) {
149 getNativeLibraries().loadLibrary(name);
150 }
151
152 /**
153 * Returns a URL to a resource in a module defined to the boot loader.
154 */
155 public static URL findResource(String mn, String name) throws IOException {
156 return ClassLoaders.bootLoader().findResource(mn, name);
157 }
158
159 /**
160 * Returns an input stream to a resource in a module defined to the
161 * boot loader.
162 */
163 public static InputStream findResourceAsStream(String mn, String name)
164 throws IOException
165 {
166 return ClassLoaders.bootLoader().findResourceAsStream(mn, name);
167 }
168
169 /**
170 * Returns the URL to the given resource in any of the modules
171 * defined to the boot loader and the boot class path.
172 */
173 public static URL findResource(String name) {
174 return ClassLoaders.bootLoader().findResource(name);
175 }
176
177 /**
178 * Returns an Iterator to iterate over the resources of the given name
179 * in any of the modules defined to the boot loader.
180 */
181 public static Enumeration<URL> findResources(String name) throws IOException {
182 return ClassLoaders.bootLoader().findResources(name);
183 }
184
185 /**
186 * Define a package for the given class to the boot loader, if not already
187 * defined.
188 */
189 public static Package definePackage(Class<?> c) {
190 return getDefinedPackage(c.getPackageName());
191 }
192
193 /**
194 * Returns the Package of the given name defined to the boot loader or null
195 * if the package has not been defined.
196 */
197 public static Package getDefinedPackage(String pn) {
198 Package pkg = ClassLoaders.bootLoader().getDefinedPackage(pn);
199 if (pkg == null) {
200 String location = getSystemPackageLocation(pn.replace('.', '/'));
201 if (location != null) {
202 pkg = PackageHelper.definePackage(pn.intern(), location);
203 }
204 }
205 return pkg;
206 }
207
208 /**
209 * Returns a stream of the packages defined to the boot loader.
210 */
211 public static Stream<Package> packages() {
212 return Arrays.stream(getSystemPackageNames())
213 .map(name -> getDefinedPackage(name.replace('/', '.')));
214 }
215
216 /**
217 * Helper class to define {@code Package} objects for packages in modules
218 * defined to the boot loader.
219 */
220 static class PackageHelper {
221 private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();
222
223 /**
224 * Define the {@code Package} with the given name. The specified
225 * location is a jrt URL to a named module in the run-time image,
226 * a file URL to a module in an exploded run-time image, or a file
227 * path to an entry on the boot class path (java agent Boot-Class-Path
228 * or -Xbootclasspath/a.
229 *
230 * <p> If the given location is a JAR file containing a manifest,
231 * the defined Package contains the versioning information from
232 * the manifest, if present.
233 *
234 * @param name package name
235 * @param location location where the package is (jrt URL or file URL
236 * for a named module in the run-time or exploded image;
237 * a file path for a package from -Xbootclasspath/a)
238 */
239 static Package definePackage(String name, String location) {
240 Module module = findModule(location);
241 if (module != null) {
242 // named module from runtime image or exploded module
243 if (name.isEmpty())
244 throw new InternalError("empty package in " + location);
245 return JLA.definePackage(ClassLoaders.bootLoader(), name, module);
246 }
247
248 // package in unnamed module (-Xbootclasspath/a)
249 URL url = toFileURL(location);
250 Manifest man = url != null ? getManifest(location) : null;
251
252 return ClassLoaders.bootLoader().defineOrCheckPackage(name, man, url);
253 }
254
255 /**
256 * Finds the module at the given location defined to the boot loader.
257 * The module is either in runtime image or exploded image.
258 * Otherwise this method returns null.
259 */
260 private static Module findModule(String location) {
261 String mn = null;
262 if (location.startsWith("jrt:/")) {
263 // named module in runtime image ("jrt:/".length() == 5)
264 mn = location.substring(5, location.length());
265 } else if (location.startsWith("file:/")) {
266 // named module in exploded image
267 Path path = Path.of(URI.create(location));
268 Path modulesDir = Path.of(JAVA_HOME, "modules");
269 if (path.startsWith(modulesDir)) {
270 mn = path.getFileName().toString();
271 }
272 }
273
274 // return the Module object for the module name. The Module may
275 // in the boot layer or a child layer for the case that the module
276 // is loaded into a running VM
277 if (mn != null) {
278 String name = mn;
279 return Modules.findLoadedModule(mn)
280 .orElseThrow(() -> new InternalError(name + " not loaded"));
281 } else {
282 return null;
283 }
284 }
285
286 /**
287 * Returns URL if the given location is a regular file path.
288 */
289 private static URL toFileURL(String location) {
290 Path path = Path.of(location);
291 if (Files.isRegularFile(path)) {
292 try {
293 return path.toUri().toURL();
294 } catch (MalformedURLException e) {}
295 }
296 return null;
297 }
298
299 /**
300 * Returns the Manifest if the given location is a JAR file
301 * containing a manifest.
302 */
303 private static Manifest getManifest(String location) {
304 Path jar = Path.of(location);
305 try (InputStream in = Files.newInputStream(jar);
306 JarInputStream jis = new JarInputStream(in, false)) {
307 return jis.getManifest();
308 } catch (IOException e) {
309 return null;
310 }
311 }
312 }
313
314 /**
315 * Returns an array of the binary name of the packages defined by
316 * the boot loader, in VM internal form (forward slashes instead of dot).
317 */
318 private static native String[] getSystemPackageNames();
319
320 /**
321 * Returns the location of the package of the given name, if
322 * defined by the boot loader; otherwise {@code null} is returned.
323 *
324 * The location may be a module from the runtime image or exploded image,
325 * or from the boot class append path (i.e. -Xbootclasspath/a or
326 * BOOT-CLASS-PATH attribute specified in java agent).
327 */
328 private static native String getSystemPackageLocation(String name);
329 private static native void setBootLoaderUnnamedModule0(Module module);
330 }