1 /*
2 * Copyright (c) 2011, 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 * @test
26 * @bug 6322678 7082769
27 * @summary FileInputStream/FileOutputStream/RandomAccessFile allow file descriptor
28 * to be closed while still in use.
29 * @run main/othervm FileDescriptorSharing
30 */
31
32 import java.io.*;
33 import java.nio.channels.FileChannel;
34 import java.nio.channels.FileLock;
35 import java.util.concurrent.CountDownLatch;
36
37 public class FileDescriptorSharing {
38
39 final static int numFiles = 10;
40 volatile static boolean fail;
41
42 public static void main(String[] args) throws Exception {
43 TestFinalizer();
44 TestMultipleFD();
45 TestIsValid();
46 MultiThreadedFD();
47 }
48
49 /**
50 * We shouldn't discard a file descriptor until all streams have
51 * finished with it
52 */
53 private static void TestFinalizer() throws Exception {
54 FileDescriptor fd = null;
55 File tempFile = new File("TestFinalizer1.txt");
56 tempFile.deleteOnExit();
57 try (Writer writer = new FileWriter(tempFile)) {
58 for (int i=0; i<5; i++) {
59 writer.write("test file content test file content");
60 }
61 }
62
63 FileInputStream fis1 = new FileInputStream(tempFile);
64 fd = fis1.getFD();
65 // Create a new FIS based on the existing FD (so the two FIS's share the same native fd)
66 try (FileInputStream fis2 = new FileInputStream(fd)) {
67 // allow fis1 to be gc'ed
68 fis1 = null;
69 int ret = 0;
70 while(ret >= 0) {
71 // encourage gc
72 System.gc();
73 // read from fis2 - when fis1 is gc'ed and finalizer is run, read will fail
74 System.out.print(".");
75 ret = fis2.read();
76 }
77 }
78
79 // variation of above. Use RandomAccessFile to obtain a filedescriptor
80 File testFinalizerFile = new File("TestFinalizer");
81 RandomAccessFile raf = new RandomAccessFile(testFinalizerFile, "rw");
82 raf.writeBytes("test file content test file content");
83 raf.seek(0L);
84 fd = raf.getFD();
85 try (FileInputStream fis3 = new FileInputStream(fd)) {
86 // allow raf to be gc'ed
87 raf = null;
88 int ret = 0;
89 while (ret >= 0) {
90 // encourage gc
91 System.gc();
92 /*
93 * read from fis3 - when raf is gc'ed and finalizer is run,
94 * fd should still be valid.
95 */
96 System.out.print(".");
97 ret = fis3.read();
98 }
99 if(!fd.valid()) {
100 throw new RuntimeException("TestFinalizer() : FileDescriptor should be valid");
101 }
102 } finally {
103 testFinalizerFile.delete();
104 }
105 }
106
107 /**
108 * Exercise FileDispatcher close()/preClose()
109 */
110 private static void TestMultipleFD() throws Exception {
111 RandomAccessFile raf = null;
112 FileOutputStream fos = null;
113 FileInputStream fis = null;
114 FileChannel fc = null;
115 FileLock fileLock = null;
116
117 File test1 = new File("test1");
118 try {
119 raf = new RandomAccessFile(test1, "rw");
120 fos = new FileOutputStream(raf.getFD());
121 fis = new FileInputStream(raf.getFD());
122 fc = raf.getChannel();
123 fileLock = fc.lock();
124 raf.setLength(0L);
125 fos.flush();
126 fos.write("TEST".getBytes());
127 } finally {
128 if (fileLock != null) fileLock.release();
129 if (fis != null) fis.close();
130 if (fos != null) fos.close();
131 if (raf != null) raf.close();
132 test1.delete();
133 }
134
135 /*
136 * Close out in different order to ensure FD is not
137 * closed out too early
138 */
139 File test2 = new File("test2");
140 try {
141 raf = new RandomAccessFile(test2, "rw");
142 fos = new FileOutputStream(raf.getFD());
143 fis = new FileInputStream(raf.getFD());
144 fc = raf.getChannel();
145 fileLock = fc.lock();
146 raf.setLength(0L);
147 fos.flush();
148 fos.write("TEST".getBytes());
149 } finally {
150 if (fileLock != null) fileLock.release();
151 if (raf != null) raf.close();
152 if (fos != null) fos.close();
153 if (fis != null) fis.close();
154 test2.delete();
155 }
156
157 // one more time, fos first this time
158 File test3 = new File("test3");
159 try {
160 raf = new RandomAccessFile(test3, "rw");
161 fos = new FileOutputStream(raf.getFD());
162 fis = new FileInputStream(raf.getFD());
163 fc = raf.getChannel();
164 fileLock = fc.lock();
165 raf.setLength(0L);
166 fos.flush();
167 fos.write("TEST".getBytes());
168 } finally {
169 if (fileLock != null) fileLock.release();
170 if (fos != null) fos.close();
171 if (raf != null) raf.close();
172 if (fis != null) fis.close();
173 test3.delete();
174 }
175 }
176
177 /**
178 * Similar to TestMultipleFD() but this time we
179 * just get and use FileDescriptor.valid() for testing.
180 */
181 private static void TestIsValid() throws Exception {
182 FileDescriptor fd = null;
183 RandomAccessFile raf = null;
184 FileOutputStream fos = null;
185 FileInputStream fis = null;
186 FileChannel fc = null;
187
188 File test1 = new File("test1");
189 try {
190 raf = new RandomAccessFile(test1, "rw");
191 fd = raf.getFD();
192 fos = new FileOutputStream(fd);
193 fis = new FileInputStream(fd);
194 } finally {
195 try {
196 if (fis != null) fis.close();
197 if (fos != null) fos.close();
198 if (!fd.valid()) {
199 throw new RuntimeException("FileDescriptor should be valid");
200 }
201 if (raf != null) raf.close();
202 if (fd.valid()) {
203 throw new RuntimeException("close() called and FileDescriptor still valid");
204 }
205 } finally {
206 if (raf != null) raf.close();
207 test1.delete();
208 }
209 }
210
211 /*
212 * Close out in different order to ensure FD is not
213 * closed out too early
214 */
215 File test2 = new File("test2");
216 try {
217 raf = new RandomAccessFile(test2, "rw");
218 fd = raf.getFD();
219 fos = new FileOutputStream(fd);
220 fis = new FileInputStream(fd);
221 } finally {
222 try {
223 if (raf != null) raf.close();
224 if (fos != null) fos.close();
225 if (!fd.valid()) {
226 throw new RuntimeException("FileDescriptor should be valid");
227 }
228 if (fis != null) fis.close();
229 if (fd.valid()) {
230 throw new RuntimeException("close() called and FileDescriptor still valid");
231 }
232 } finally {
233 test2.delete();
234 }
235 }
236
237 // one more time, fos first this time
238 File test3 = new File("test3");
239 try {
240 raf = new RandomAccessFile(test3, "rw");
241 fd = raf.getFD();
242 fos = new FileOutputStream(fd);
243 fis = new FileInputStream(fd);
244 } finally {
245 try {
246 if (fos != null) fos.close();
247 if (raf != null) raf.close();
248 if (!fd.valid()) {
249 throw new RuntimeException("FileDescriptor should be valid");
250 }
251 if (fis != null) fis.close();
252 if (fd.valid()) {
253 throw new RuntimeException("close() called and FileDescriptor still valid");
254 }
255 } finally {
256 test3.delete();
257 }
258 }
259 }
260
261 /**
262 * Test concurrent access to the same fd.useCount field
263 */
264 private static void MultiThreadedFD() throws Exception {
265 RandomAccessFile raf = null;
266 FileDescriptor fd = null;
267 int numThreads = 2;
268 CountDownLatch done = new CountDownLatch(numThreads);
269 OpenClose[] fileOpenClose = new OpenClose[numThreads];
270 File MultipleThreadedFD = new File("MultipleThreadedFD");
271 try {
272 raf = new RandomAccessFile(MultipleThreadedFD, "rw");
273 fd = raf.getFD();
274 for(int count=0;count<numThreads;count++) {
275 fileOpenClose[count] = new OpenClose(fd, done);
276 fileOpenClose[count].start();
277 }
278 done.await();
279 } finally {
280 try {
281 if(raf != null) raf.close();
282 // fd should now no longer be valid
283 if(fd.valid()) {
284 throw new RuntimeException("FileDescriptor should not be valid");
285 }
286 // OpenClose thread tests failed
287 if(fail) {
288 throw new RuntimeException("OpenClose thread tests failed.");
289 }
290 } finally {
291 MultipleThreadedFD.delete();
292 }
293 }
294 }
295
296 /**
297 * A thread which will open and close a number of FileInputStreams and
298 * FileOutputStreams referencing the same native file descriptor.
299 */
300 private static class OpenClose extends Thread {
301 private FileDescriptor fd = null;
302 private CountDownLatch done;
303 FileInputStream[] fisArray = new FileInputStream[numFiles];
304 FileOutputStream[] fosArray = new FileOutputStream[numFiles];
305
306 OpenClose(FileDescriptor filedescriptor, CountDownLatch done) {
307 this.fd = filedescriptor;
308 this.done = done;
309 }
310
311 public void run() {
312 try {
313 for(int i=0;i<numFiles;i++) {
314 fisArray[i] = new FileInputStream(fd);
315 fosArray[i] = new FileOutputStream(fd);
316 }
317
318 // Now close out
319 for(int i=0;i<numFiles;i++) {
320 if(fisArray[i] != null) fisArray[i].close();
321 if(fosArray[i] != null) fosArray[i].close();
322 }
323
324 } catch(IOException ioe) {
325 System.out.println("OpenClose encountered IO issue :" + ioe);
326 fail = true;
327 } finally {
328 if (!fd.valid()) { // fd should still be valid given RAF reference
329 System.out.println("OpenClose: FileDescriptor should be valid");
330 fail = true;
331 }
332 done.countDown();
333 }
334 }
335 }
336 }