1 /*
2 * Copyright (c) 2014, 2015, 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.jrtfs;
26
27 import java.io.IOException;
28 import java.nio.file.LinkOption;
29 import java.nio.file.FileSystemException;
30 import java.nio.file.InvalidPathException;
31 import java.nio.file.NoSuchFileException;
32 import java.nio.file.NotDirectoryException;
33 import java.nio.file.Path;
34 import java.util.ArrayList;
35 import java.util.Arrays;
36 import java.util.Iterator;
37 import java.util.List;
38 import java.util.Map;
39 import java.util.function.Function;
40 import static java.util.stream.Collectors.toList;
41 import jdk.internal.jimage.ImageReader;
42 import jdk.internal.jimage.ImageReader.Node;
43 import jdk.internal.jimage.UTF8String;
44
45 /**
46 * jrt file system implementation built on System jimage files.
47 */
48 class JrtFileSystem extends AbstractJrtFileSystem {
49
50 // System image reader
51 private ImageReader bootImage;
52 // root path
53 private final JrtPath rootPath;
54 private volatile boolean isOpen;
55
56 // open a .jimage and build directory structure
57 private static ImageReader openImage(Path path) throws IOException {
58 ImageReader image = ImageReader.open(path.toString());
59 image.getRootDirectory();
60 return image;
61 }
62
63 JrtFileSystem(JrtFileSystemProvider provider,
64 Map<String, ?> env)
65 throws IOException {
66 super(provider, env);
67 checkExists(SystemImages.bootImagePath);
68
69 // open image file
70 this.bootImage = openImage(SystemImages.bootImagePath);
71
72 byte[] root = new byte[]{'/'};
73 rootPath = new JrtPath(this, root);
74 isOpen = true;
75 }
76
77 // FileSystem method implementations
78 @Override
79 public boolean isOpen() {
80 return isOpen;
81 }
82
83 @Override
84 public void close() throws IOException {
85 cleanup();
86 }
87
88 @Override
89 protected void finalize() throws Throwable {
90 try {
91 cleanup();
92 } catch (IOException ignored) {
93 }
94 super.finalize();
95 }
96
97 // AbstractJrtFileSystem method implementations
98 @Override
99 JrtPath getRootPath() {
100 return rootPath;
101 }
102
103 @Override
104 boolean isSameFile(AbstractJrtPath p1, AbstractJrtPath p2) throws IOException {
105 ensureOpen();
106 NodeAndImage n1 = findNode(p1.getName());
107 NodeAndImage n2 = findNode(p2.getName());
108 return n1.node.equals(n2.node);
109 }
110
111 @Override
112 boolean isLink(AbstractJrtPath jrtPath) throws IOException {
113 return checkNode(jrtPath.getName()).node.isLink();
114 }
115
116 @Override
117 AbstractJrtPath resolveLink(AbstractJrtPath jrtPath) throws IOException {
118 NodeAndImage ni = checkNode(jrtPath.getName());
119 if (ni.node.isLink()) {
120 Node node = ni.node.resolveLink();
121 return toJrtPath(node.getName().getBytesCopy());
122 }
123
124 return jrtPath;
125 }
126
127 @Override
128 JrtFileAttributes getFileAttributes(byte[] path, LinkOption... options)
129 throws IOException {
130 NodeAndImage ni = checkNode(path);
131 if (ni.node.isLink() && followLinks(options)) {
132 return new JrtFileAttributes(ni.node.resolveLink(true));
133 }
134 return new JrtFileAttributes(ni.node);
135 }
136
137 @Override
138 boolean exists(byte[] path) throws IOException {
139 try {
140 checkNode(path);
141 } catch (NoSuchFileException exp) {
142 return false;
143 }
144 return true;
145 }
146
147 @Override
148 boolean isDirectory(byte[] path, boolean resolveLinks)
149 throws IOException {
150 NodeAndImage ni = checkNode(path);
151 return resolveLinks && ni.node.isLink()
152 ? ni.node.resolveLink(true).isDirectory()
153 : ni.node.isDirectory();
154 }
155
156 @Override
157 Iterator<Path> iteratorOf(byte[] path, String childPrefix)
158 throws IOException {
159 NodeAndImage ni = checkNode(path);
160 Node node = ni.node.resolveLink(true);
161
162 if (!node.isDirectory()) {
163 throw new NotDirectoryException(getString(path));
164 }
165
166 if (node.isRootDir()) {
167 return rootDirIterator(path, childPrefix);
168 } else if (node.isModulesDir()) {
169 return modulesDirIterator(path, childPrefix);
170 } else if (node.isPackagesDir()) {
171 return packagesDirIterator(path, childPrefix);
172 }
173
174 return nodesToIterator(toJrtPath(path), childPrefix, node.getChildren());
175 }
176
177 @Override
178 byte[] getFileContent(byte[] path) throws IOException {
179 final NodeAndImage ni = checkResource(path);
180 return ni.getResource();
181 }
182
183 // Implementation details below this point
184 // clean up this file system - called from finalize and close
185 private void cleanup() throws IOException {
186 if (!isOpen) {
187 return;
188 }
189
190 synchronized (this) {
191 isOpen = false;
192
193 // close all image reader and null out
194 bootImage.close();
195 bootImage = null;
196 }
197 }
198
199 private static class NodeAndImage {
200
201 final Node node;
202 final ImageReader image;
203
204 NodeAndImage(Node node, ImageReader image) {
205 this.node = node;
206 this.image = image;
207 }
208
209 byte[] getResource() throws IOException {
210 return image.getResource(node);
211 }
212 }
213
214 private NodeAndImage lookup(byte[] path) {
215 ImageReader image = bootImage;
216 Node node;
217 try {
218 node = bootImage.findNode(path);
219 } catch (RuntimeException re) {
220 throw new InvalidPathException(getString(path), re.toString());
221 }
222 return node != null ? new NodeAndImage(node, image) : null;
223 }
224
225 private NodeAndImage lookupSymbolic(byte[] path) {
226 for (int i = 1; i < path.length; i++) {
227 if (path[i] == (byte) '/') {
228 byte[] prefix = Arrays.copyOfRange(path, 0, i);
229 NodeAndImage ni = lookup(prefix);
230 if (ni == null) {
231 break;
232 }
233
234 if (ni.node.isLink()) {
235 Node link = ni.node.resolveLink(true);
236 // resolved symbolic path concatenated to the rest of the path
237 UTF8String resPath = link.getName().concat(new UTF8String(path, i));
238 byte[] resPathBytes = resPath.getBytesCopy();
239 ni = lookup(resPathBytes);
240 return ni != null ? ni : lookupSymbolic(resPathBytes);
241 }
242 }
243 }
244
245 return null;
246 }
247
248 private NodeAndImage findNode(byte[] path) throws IOException {
249 NodeAndImage ni = lookup(path);
250 if (ni == null) {
251 ni = lookupSymbolic(path);
252 if (ni == null) {
253 throw new NoSuchFileException(getString(path));
254 }
255 }
256 return ni;
257 }
258
259 private NodeAndImage checkNode(byte[] path) throws IOException {
260 ensureOpen();
261 return findNode(path);
262 }
263
264 private NodeAndImage checkResource(byte[] path) throws IOException {
265 NodeAndImage ni = checkNode(path);
266 if (ni.node.isDirectory()) {
267 throw new FileSystemException(getString(path) + " is a directory");
268 }
269
270 assert ni.node.isResource() : "resource node expected here";
271 return ni;
272 }
273
274 private JrtPath toJrtPath(String path) {
275 return toJrtPath(getBytes(path));
276 }
277
278 private JrtPath toJrtPath(byte[] path) {
279 return new JrtPath(this, path);
280 }
281
282 private Iterator<Path> nodesToIterator(Path path, String childPrefix, List<Node> childNodes) {
283 Function<Node, Path> f = childPrefix == null
284 ? child -> toJrtPath(child.getNameString())
285 : child -> toJrtPath(childPrefix + child.getNameString().substring(1));
286 return childNodes.stream().map(f).collect(toList()).iterator();
287 }
288
289 private List<Node> rootChildren;
290
291 private synchronized void initRootChildren(byte[] path) {
292 if (rootChildren == null) {
293 rootChildren = new ArrayList<>();
294 rootChildren.addAll(bootImage.findNode(path).getChildren());
295 }
296 }
297
298 private Iterator<Path> rootDirIterator(byte[] path, String childPrefix) throws IOException {
299 initRootChildren(path);
300 return nodesToIterator(rootPath, childPrefix, rootChildren);
301 }
302
303 private List<Node> modulesChildren;
304
305 private synchronized void initModulesChildren(byte[] path) {
306 if (modulesChildren == null) {
307 modulesChildren = new ArrayList<>();
308 modulesChildren.addAll(bootImage.findNode(path).getChildren());
309 }
310 }
311
312 private Iterator<Path> modulesDirIterator(byte[] path, String childPrefix) throws IOException {
313 initModulesChildren(path);
314 return nodesToIterator(new JrtPath(this, path), childPrefix, modulesChildren);
315 }
316
317 private List<Node> packagesChildren;
318
319 private synchronized void initPackagesChildren(byte[] path) {
320 if (packagesChildren == null) {
321 packagesChildren = new ArrayList<>();
322 packagesChildren.addAll(bootImage.findNode(path).getChildren());
323 }
324 }
325
326 private Iterator<Path> packagesDirIterator(byte[] path, String childPrefix) throws IOException {
327 initPackagesChildren(path);
328 return nodesToIterator(new JrtPath(this, path), childPrefix, packagesChildren);
329 }
330 }