8189330: Cleanup FileDescriptor implementation

Reviewed-by: bpb

make/mapfiles/libjava/mapfile-vers

@@ -74,11 +74,12 @@ SUNWprivate_1.1 {
 		JNU_ThrowStringIndexOutOfBoundsException;
 		JNU_ToString;
 
-		Java_java_io_FileDescriptor_cleanupClose0;
+		Java_java_io_FileCleanable_cleanupClose0;
 		Java_java_io_FileDescriptor_close0;
 		Java_java_io_FileDescriptor_initIDs;
 		Java_java_io_FileDescriptor_sync;
 		Java_java_io_FileDescriptor_getAppend;
+		Java_java_io_FileDescriptor_getHandle;
 		Java_java_io_FileInputStream_available0;
 		Java_java_io_FileInputStream_initIDs;
 		Java_java_io_FileInputStream_open0;

src/java.base/share/classes/java/io/FileCleanable.java

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package java.io;
+
+import jdk.internal.misc.JavaIOFileDescriptorAccess;
+import jdk.internal.misc.SharedSecrets;
+import jdk.internal.ref.CleanerFactory;
+import jdk.internal.ref.PhantomCleanable;
+
+import java.lang.ref.Cleaner;
+
+/**
+ * Cleanable for a FileDescriptor when it becomes phantom reachable.
+ * For regular fds on Unix and regular handles on Windows
+ * register a cleanup if fd != -1 or handle != -1.
+ * <p>
+ * Subclassed from {@code PhantomCleanable} so that {@code clear} can be
+ * called to disable the cleanup when the handle is closed by any means other
+ * than calling {@link FileDescriptor#close}.
+ * Otherwise, it might incorrectly close the handle after it has been reused.
+ */
+final class FileCleanable extends PhantomCleanable<FileDescriptor> {
+
+    // Access to FileDescriptor private fields;
+    // avoids making fd and handle package private
+    private static final JavaIOFileDescriptorAccess fdAccess =
+            SharedSecrets.getJavaIOFileDescriptorAccess();
+
+    /*
+     * Raw close of the file fd and/or handle.
+     * Used only for last chance cleanup.
+     */
+    private static native void cleanupClose0(int fd, long handle) throws IOException;
+
+    // The raw fd to close
+    private final int fd;
+
+    // The handle to close
+    private final long handle;
+
+    /**
+     * Register a Cleanable with the FileDescriptor
+     * if the FileDescriptor is non-null and valid.
+     * @implNote
+     * A exception (OutOfMemoryException) will leave the FileDescriptor
+     * having allocated resources and leak the fd/handle.
+     *
+     * @param fdo the FileDescriptor; may be null
+     */
+    static void register(FileDescriptor fdo) {
+        if (fdo != null && fdo.valid()) {
+            int fd = fdAccess.get(fdo);
+            long handle = fdAccess.getHandle(fdo);
+            fdo.registerCleanup(new FileCleanable(fdo, CleanerFactory.cleaner(), fd, handle));
+        }
+    }
+
+    /**
+     * Unregister a Cleanable from the FileDescriptor.
+     * @param fdo the FileDescriptor; may be null
+     */
+    static void unregister(FileDescriptor fdo) {
+        if (fdo != null) {
+            fdo.unregisterCleanup();
+        }
+    }
+
+    /**
+     * Constructor for a phantom cleanable reference.
+     *
+     * @param obj     the object to monitor
+     * @param cleaner the cleaner
+     * @param fd      file descriptor to close
+     * @param handle  handle to close
+     */
+    private FileCleanable(FileDescriptor obj, Cleaner cleaner, int fd, long handle) {
+        super(obj, cleaner);
+        this.fd = fd;
+        this.handle = handle;
+    }
+
+    /**
+     * Close the native handle or fd.
+     */
+    @Override
+    protected void performCleanup() {
+        try {
+            cleanupClose0(fd, handle);
+        } catch (IOException ioe) {
+            throw new UncheckedIOException("close", ioe);
+        }
+    }
+}

src/java.base/share/classes/java/io/FileDescriptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1995, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -25,13 +25,12 @@
 
 package java.io;
 
-import java.lang.ref.Cleaner;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 
 import jdk.internal.misc.JavaIOFileDescriptorAccess;
 import jdk.internal.misc.SharedSecrets;
-import jdk.internal.ref.CleanerFactory;
 import jdk.internal.ref.PhantomCleanable;
 
 /**
@@ -50,6 +49,8 @@ public final class FileDescriptor {
 
     private int fd;
 
+    private long handle;
+
     private Closeable parent;
     private List<Closeable> otherParents;
     private boolean closed;
@@ -87,11 +88,14 @@ public final class FileDescriptor {
                         fdo.close();
                     }
 
+                    /* Register for a normal FileCleanable fd/handle cleanup. */
                     public void registerCleanup(FileDescriptor fdo) {
-                        fdo.registerCleanup();
+                        FileCleanable.register(fdo);
                     }
 
-                    public void registerCleanup(FileDescriptor fdo, PhantomCleanable<Object> cleanup) {
+                    /* Register a custom PhantomCleanup. */
+                    public void registerCleanup(FileDescriptor fdo,
+                                                PhantomCleanable<FileDescriptor> cleanup) {
                         fdo.registerCleanup(cleanup);
                     }
 
@@ -100,11 +104,11 @@ public final class FileDescriptor {
                     }
 
                     public void setHandle(FileDescriptor fdo, long handle) {
-                        throw new UnsupportedOperationException();
+                        fdo.setHandle(handle);
                     }
 
                     public long getHandle(FileDescriptor fdo) {
-                        throw new UnsupportedOperationException();
+                        return fdo.handle;
                     }
                 }
         );
@@ -113,18 +117,26 @@ public final class FileDescriptor {
     /**
      * Cleanup in case FileDescriptor is not explicitly closed.
      */
-    private PhantomCleanable<Object> cleanup;
+    private PhantomCleanable<FileDescriptor> cleanup;
 
     /**
-     * Constructs an (invalid) FileDescriptor
+     * Constructs an (invalid) FileDescriptor object.
-     * object.
+     * The fd or handle is set later.
      */
     public FileDescriptor() {
         fd = -1;
+        handle = -1;
     }
 
+    /**
+     * Used for standard input, output, and error only.
+     * For Windows the corresponding handle is initialized.
+     * For Unix the append mode is cached.
+     * @param fd the raw fd number (0, 1, 2)
+     */
     private FileDescriptor(int fd) {
         this.fd = fd;
+        this.handle = getHandle(fd);
         this.append = getAppend(fd);
     }
 
@@ -162,7 +174,7 @@ public final class FileDescriptor {
      *          {@code false} otherwise.
      */
     public boolean valid() {
-        return fd != -1;
+        return (handle != -1) || (fd != -1);
     }
 
     /**
@@ -198,11 +210,22 @@ public final class FileDescriptor {
     /* This routine initializes JNI field offsets for the class */
     private static native void initIDs();
 
+    /*
+     * On Windows return the handle for the standard streams.
+     */
+    private static native long getHandle(int d);
+
+    /**
+     * Returns true, if the file was opened for appending.
+     */
+    private static native boolean getAppend(int fd);
+
     /**
      * Set the fd.
+     * Used on Unix and for sockets on Windows and Unix.
      * If setting to -1, clear the cleaner.
-     * The {@link #registerCleanup()} method should be called for new fds.
+     * The {@link #registerCleanup} method should be called for new fds.
-     * @param fd the fd or -1 to indicate closed
+     * @param fd the raw fd or -1 to indicate closed
      */
     @SuppressWarnings("unchecked")
     synchronized void set(int fd) {
@@ -214,31 +237,38 @@ public final class FileDescriptor {
     }
 
     /**
-     * Register a cleanup for the current handle.
+     * Set the handle.
-     * Used directly in java.io and indirectly via fdAccess.
+     * Used on Windows for regular files.
-     * The cleanup should be registered after the handle is set in the FileDescriptor.
+     * If setting to -1, clear the cleaner.
+     * The {@link #registerCleanup} method should be called for new handles.
+     * @param handle the handle or -1 to indicate closed
      */
     @SuppressWarnings("unchecked")
-    void registerCleanup() {
+    void setHandle(long handle) {
-        registerCleanup(null);
+        if (handle == -1 && cleanup != null) {
+            cleanup.clear();
+            cleanup = null;
+        }
+        this.handle = handle;
     }
 
     /**
      * Register a cleanup for the current handle.
      * Used directly in java.io and indirectly via fdAccess.
      * The cleanup should be registered after the handle is set in the FileDescriptor.
-     * @param newCleanable a PhantomCleanable to register
+     * @param cleanable a PhantomCleanable to register
      */
     @SuppressWarnings("unchecked")
-    synchronized void registerCleanup(PhantomCleanable<Object> newCleanable) {
+    synchronized void registerCleanup(PhantomCleanable<FileDescriptor> cleanable) {
+        Objects.requireNonNull(cleanable, "cleanable");
         if (cleanup != null) {
             cleanup.clear();
         }
-        cleanup = (newCleanable == null) ? FDCleanup.create(this) : newCleanable;
+        cleanup = cleanable;
     }
 
     /**
-     * Unregister a cleanup for the current raw fd.
+     * Unregister a cleanup for the current raw fd or handle.
      * Used directly in java.io and indirectly via fdAccess.
      * Normally {@link #close()} should be used except in cases where
      * it is certain the caller will close the raw fd and the cleanup
@@ -255,23 +285,15 @@ public final class FileDescriptor {
     }
 
     /**
-     * Returns true, if the file was opened for appending.
+     * Close the raw file descriptor or handle, if it has not already been closed.
-     */
+     * The native code sets the fd and handle to -1.
-    private static native boolean getAppend(int fd);
-
-    /**
-     * Close the raw file descriptor or handle, if it has not already been closed
-     * and set the fd and handle to -1.
      * Clear the cleaner so the close does not happen twice.
      * Package private to allow it to be used in java.io.
      * @throws IOException if close fails
      */
     @SuppressWarnings("unchecked")
     synchronized void close() throws IOException {
-        if (cleanup != null) {
+        unregisterCleanup();
-            cleanup.clear();
-            cleanup = null;
-        }
         close0();
     }
 
@@ -281,12 +303,6 @@ public final class FileDescriptor {
      */
     private native void close0() throws IOException;
 
-    /*
-     * Raw close of the file descriptor.
-     * Used only for last chance cleanup.
-     */
-    private static native void cleanupClose0(int fd) throws IOException;
-
     /*
      * Package private methods to track referents.
      * If multiple streams point to the same FileDescriptor, we cycle
@@ -350,45 +366,4 @@ public final class FileDescriptor {
             }
         }
     }
-
-    /**
-     * Cleanup for a FileDescriptor when it becomes phantom reachable.
-     * Create a cleanup if fd != -1.
-     * Subclassed from {@code PhantomCleanable} so that {@code clear} can be
-     * called to disable the cleanup when the fd is closed by any means other
-     * than calling {@link FileDescriptor#close}.
-     * Otherwise, it may close the native fd after it has been reused.
-     */
-    static final class FDCleanup extends PhantomCleanable<Object> {
-        private final int fd;
-
-        static FDCleanup create(FileDescriptor fdo) {
-            return fdo.fd == -1
-                ? null
-                : new FDCleanup(fdo, CleanerFactory.cleaner(), fdo.fd);
-        }
-
-        /**
-         * Constructor for a phantom cleanable reference.
-         * @param obj the object to monitor
-         * @param cleaner the cleaner
-         * @param fd file descriptor to close
-         */
-        private FDCleanup(Object obj, Cleaner cleaner, int fd) {
-            super(obj, cleaner);
-            this.fd = fd;
-        }
-
-        /**
-         * Close the native fd.
-         */
-        @Override
-        protected void performCleanup() {
-            try {
-                cleanupClose0(fd);
-            } catch (IOException ioe) {
-                throw new UncheckedIOException("close", ioe);
-            }
-        }
-    }
 }

src/java.base/share/classes/java/io/FileInputStream.java

@@ -25,7 +25,6 @@
 
 package java.io;
 
-import java.lang.reflect.Method;
 import java.nio.channels.FileChannel;
 import sun.nio.ch.FileChannelImpl;
 
@@ -158,7 +157,7 @@ class FileInputStream extends InputStream
         open(name);
         altFinalizer = AltFinalizer.get(this);
         if (altFinalizer == null) {
-            fd.registerCleanup();         // open set the fd, register the cleanup
+            FileCleanable.register(fd);       // open set the fd, register the cleanup
         }
     }
 

src/java.base/share/classes/java/io/FileOutputStream.java

@@ -25,7 +25,6 @@
 
 package java.io;
 
-import java.lang.reflect.Method;
 import java.nio.channels.FileChannel;
 import jdk.internal.misc.SharedSecrets;
 import jdk.internal.misc.JavaIOFileDescriptorAccess;
@@ -238,7 +237,7 @@ class FileOutputStream extends OutputStream
         open(name, append);
         altFinalizer = AltFinalizer.get(this);
         if (altFinalizer == null) {
-            fd.registerCleanup();         // open set the fd, register the cleanup
+            FileCleanable.register(fd);   // open sets the fd, register the cleanup
         }
     }
 

src/java.base/share/classes/java/io/RandomAccessFile.java

@@ -257,7 +257,7 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
         fd.attach(this);
         path = name;
         open(name, imode);
-        fd.registerCleanup();       // open sets the fd, register the cleanup
+        FileCleanable.register(fd);   // open sets the fd, register the cleanup
     }
 
     /**

src/java.base/share/classes/java/net/SocketCleanable.java

@@ -36,20 +36,21 @@ import java.lang.ref.Cleaner;
 
 
 /**
- * Cleanup for a socket/datagramsocket FileDescriptor when it becomes phantom reachable.
+ * Cleanable for a socket/datagramsocket FileDescriptor when it becomes phantom reachable.
  * Create a cleanup if the raw fd != -1. Windows closes sockets using the fd.
  * Subclassed from {@code PhantomCleanable} so that {@code clear} can be
  * called to disable the cleanup when the socket fd is closed by any means
  * other than calling {@link FileDescriptor#close}.
- * Otherwise, it would incorrectly close the handle or fd after it has been reused.
+ * Otherwise, it might incorrectly close the handle or fd after it has been reused.
  */
-final class SocketCleanable extends PhantomCleanable<Object> {
+final class SocketCleanable extends PhantomCleanable<FileDescriptor> {
 
-    // Access to FileDescriptor internals
+    // Access to FileDescriptor private fields
     private static final JavaIOFileDescriptorAccess fdAccess =
             SharedSecrets.getJavaIOFileDescriptorAccess();
 
     // Native function to call NET_SocketClose(fd)
+    // Used only for last chance cleanup.
     private static native void cleanupClose0(int fd) throws IOException;
 
     // The raw fd to close
@@ -62,14 +63,12 @@ final class SocketCleanable extends PhantomCleanable<Object> {
      * @param fdo the FileDescriptor; may be null
      */
     static void register(FileDescriptor fdo) {
-        if (fdo != null) {
+        if (fdo != null && fdo.valid()) {
             int fd = fdAccess.get(fdo);
-            if (fd != -1) {
             fdAccess.registerCleanup(fdo,
                     new SocketCleanable(fdo, CleanerFactory.cleaner(), fd));
         }
     }
-    }
 
     /**
      * Unregister a Cleanable from the FileDescriptor.
@@ -88,7 +87,7 @@ final class SocketCleanable extends PhantomCleanable<Object> {
      * @param cleaner the cleaner
      * @param fd      file descriptor to close
      */
-    private SocketCleanable(Object obj, Cleaner cleaner, int fd) {
+    private SocketCleanable(FileDescriptor obj, Cleaner cleaner, int fd) {
         super(obj, cleaner);
         this.fd = fd;
     }

src/java.base/share/classes/jdk/internal/misc/JavaIOFileDescriptorAccess.java

@@ -40,7 +40,7 @@ public interface JavaIOFileDescriptorAccess {
     public boolean getAppend(FileDescriptor fdo);
     public void close(FileDescriptor fdo) throws IOException;
     public void registerCleanup(FileDescriptor fdo);
-    public void registerCleanup(FileDescriptor fdo, PhantomCleanable<Object> cleanable);
+    public void registerCleanup(FileDescriptor fdo, PhantomCleanable<FileDescriptor> cleanable);
     public void unregisterCleanup(FileDescriptor fdo);
 
     // Only valid on Windows

src/java.base/unix/native/libjava/FileDescriptor_md.c

@@ -64,6 +64,10 @@ Java_java_io_FileDescriptor_sync(JNIEnv *env, jobject this) {
         JNU_ThrowByName(env, "java/io/SyncFailedException", "sync failed");
     }
 }
+JNIEXPORT jlong JNICALL
+Java_java_io_FileDescriptor_getHandle(JNIEnv *env, jclass fdClass, jint fd) {
+    return -1;
+}
 
 JNIEXPORT jboolean JNICALL
 Java_java_io_FileDescriptor_getAppend(JNIEnv *env, jclass fdClass, jint fd) {
@@ -71,17 +75,17 @@ Java_java_io_FileDescriptor_getAppend(JNIEnv *env, jclass fdClass, jint fd) {
     return ((flags & O_APPEND) == 0) ? JNI_FALSE : JNI_TRUE;
 }
 
+// instance method close0 for FileDescriptor
 JNIEXPORT void JNICALL
-Java_java_io_FileDescriptor_cleanupClose0(JNIEnv *env, jclass fdClass, jint fd) {
+Java_java_io_FileDescriptor_close0(JNIEnv *env, jobject this) {
+    fileDescriptorClose(env, this);
+}
+
+JNIEXPORT void JNICALL
+Java_java_io_FileCleanable_cleanupClose0(JNIEnv *env, jclass fdClass, jint fd, jlong unused) {
     if (fd != -1) {
         if (close(fd) == -1) {
             JNU_ThrowIOExceptionWithLastError(env, "close failed");
         }
     }
 }
-
-// instance method close0 for FileDescriptor
-JNIEXPORT void JNICALL
-Java_java_io_FileDescriptor_close0(JNIEnv *env, jobject this) {
-    fileDescriptorClose(env, this);
-}

src/java.base/windows/classes/java/io/FileDescriptor.java

@@ -1,400 +0,0 @@
-/*
- * Copyright (c) 2003, 2018, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-package java.io;
-
-import java.lang.ref.Cleaner;
-import java.util.ArrayList;
-import java.util.List;
-
-import jdk.internal.misc.JavaIOFileDescriptorAccess;
-import jdk.internal.misc.SharedSecrets;
-import jdk.internal.ref.CleanerFactory;
-import jdk.internal.ref.PhantomCleanable;
-
-/**
- * Instances of the file descriptor class serve as an opaque handle
- * to the underlying machine-specific structure representing an open
- * file, an open socket, or another source or sink of bytes.
- * The main practical use for a file descriptor is to create a
- * {@link FileInputStream} or {@link FileOutputStream} to contain it.
- * <p>
- * Applications should not create their own file descriptors.
- *
- * @author  Pavani Diwanji
- * @since   1.0
- */
-public final class FileDescriptor {
-
-    private int fd;
-
-    private long handle;
-
-    private Closeable parent;
-    private List<Closeable> otherParents;
-    private boolean closed;
-
-    /**
-     * true, if file is opened for appending.
-     */
-    private boolean append;
-
-    static {
-        initIDs();
-    }
-
-    // Set up JavaIOFileDescriptorAccess in SharedSecrets
-    static {
-        SharedSecrets.setJavaIOFileDescriptorAccess(
-                new JavaIOFileDescriptorAccess() {
-                    public void set(FileDescriptor fdo, int fd) {
-                        fdo.fd = fd;
-                    }
-
-                    public int get(FileDescriptor fdo) {
-                        return fdo.fd;
-                    }
-
-                    public void setAppend(FileDescriptor fdo, boolean append) {
-                        fdo.append = append;
-                    }
-
-                    public boolean getAppend(FileDescriptor fdo) {
-                        return fdo.append;
-                    }
-
-                    public void close(FileDescriptor fdo) throws IOException {
-                        fdo.close();
-                    }
-
-                    public void registerCleanup(FileDescriptor fdo) {
-                        fdo.registerCleanup(null);
-                    }
-
-                    public void registerCleanup(FileDescriptor fdo, PhantomCleanable<Object> cleanup) {
-                        fdo.registerCleanup(cleanup);
-                    }
-
-                    public void unregisterCleanup(FileDescriptor fdo) {
-                        fdo.unregisterCleanup();
-                    }
-
-                    public void setHandle(FileDescriptor fdo, long handle) {
-                        fdo.setHandle(handle);
-                    }
-
-                    public long getHandle(FileDescriptor fdo) {
-                        return fdo.handle;
-                    }
-                }
-        );
-    }
-
-    /**
-     * Cleanup in case FileDescriptor is not explicitly closed.
-     */
-    private PhantomCleanable<Object> cleanup;
-
-    /**
-     * Constructs an (invalid) FileDescriptor
-     * object.
-     */
-    public FileDescriptor() {
-        fd = -1;
-        handle = -1;
-    }
-
-    /**
-     * A handle to the standard input stream. Usually, this file
-     * descriptor is not used directly, but rather via the input stream
-     * known as {@code System.in}.
-     *
-     * @see     java.lang.System#in
-     */
-    public static final FileDescriptor in = standardStream(0);
-
-    /**
-     * A handle to the standard output stream. Usually, this file
-     * descriptor is not used directly, but rather via the output stream
-     * known as {@code System.out}.
-     * @see     java.lang.System#out
-     */
-    public static final FileDescriptor out = standardStream(1);
-
-    /**
-     * A handle to the standard error stream. Usually, this file
-     * descriptor is not used directly, but rather via the output stream
-     * known as {@code System.err}.
-     *
-     * @see     java.lang.System#err
-     */
-    public static final FileDescriptor err = standardStream(2);
-
-    /**
-     * Tests if this file descriptor object is valid.
-     *
-     * @return  {@code true} if the file descriptor object represents a
-     *          valid, open file, socket, or other active I/O connection;
-     *          {@code false} otherwise.
-     */
-    public boolean valid() {
-        return (handle != -1) || (fd != -1);
-    }
-
-    /**
-     * Force all system buffers to synchronize with the underlying
-     * device.  This method returns after all modified data and
-     * attributes of this FileDescriptor have been written to the
-     * relevant device(s).  In particular, if this FileDescriptor
-     * refers to a physical storage medium, such as a file in a file
-     * system, sync will not return until all in-memory modified copies
-     * of buffers associated with this FileDescriptor have been
-     * written to the physical medium.
-     *
-     * sync is meant to be used by code that requires physical
-     * storage (such as a file) to be in a known state  For
-     * example, a class that provided a simple transaction facility
-     * might use sync to ensure that all changes to a file caused
-     * by a given transaction were recorded on a storage medium.
-     *
-     * sync only affects buffers downstream of this FileDescriptor.  If
-     * any in-memory buffering is being done by the application (for
-     * example, by a BufferedOutputStream object), those buffers must
-     * be flushed into the FileDescriptor (for example, by invoking
-     * OutputStream.flush) before that data will be affected by sync.
-     *
-     * @exception SyncFailedException
-     *        Thrown when the buffers cannot be flushed,
-     *        or because the system cannot guarantee that all the
-     *        buffers have been synchronized with physical media.
-     * @since     1.1
-     */
-    public native void sync() throws SyncFailedException;
-
-    /* This routine initializes JNI field offsets for the class */
-    private static native void initIDs();
-
-    private static FileDescriptor standardStream(int fd) {
-        FileDescriptor desc = new FileDescriptor();
-        desc.handle = getHandle(fd);
-        return desc;
-    }
-
-    private static native long getHandle(int d);
-
-    /**
-     * Set the handle.
-     * If setting to -1, clear the cleaner.
-     * The {@link #registerCleanup()} method should be called for new handles.
-     * @param handle the handle or -1 to indicate closed
-     */
-    @SuppressWarnings("unchecked")
-    void setHandle(long handle) {
-        if (handle == -1 && cleanup != null) {
-            cleanup.clear();
-            cleanup = null;
-        }
-        this.handle = handle;
-    }
-
-    /**
-     * Register a cleanup for the current handle.
-     * Used directly in java.io and indirectly via fdAccess.
-     * The cleanup should be registered after the handle is set in the FileDescriptor.
-     */
-    @SuppressWarnings("unchecked")
-    void registerCleanup() {
-        registerCleanup(null);
-    }
-
-    /**
-     * Register a cleanup for the current handle.
-     * Used directly in java.io and indirectly via fdAccess.
-     * The cleanup should be registered after the handle is set in the FileDescriptor.
-     * @param newCleanable a PhantomCleanable to register
-     */
-    @SuppressWarnings("unchecked")
-    synchronized void registerCleanup(PhantomCleanable<Object> newCleanable) {
-        if (cleanup != null) {
-            cleanup.clear();
-        }
-        cleanup = (newCleanable == null) ? FDCleanup.create(this) : newCleanable;
-    }
-
-   /**
-     * Unregister a cleanup for the current raw fd.
-     * Used directly in java.io and indirectly via fdAccess.
-     * Normally {@link #close()} should be used except in cases where
-     * it is certain the caller will close the raw fd and the cleanup
-     * must not close the raw fd.  {@link #unregisterCleanup()} must be
-     * called before the raw fd is closed to prevent a race that makes
-     * it possible for the fd to be reallocated to another use and later
-     * the cleanup might be invoked.
-     */
-    synchronized void unregisterCleanup() {
-        if (cleanup != null) {
-            cleanup.clear();
-        }
-        cleanup = null;
-    }
-
-    /**
-     * Close the raw file descriptor or handle, if it has not already been closed
-     * and set the fd and handle to -1.
-     * Clear the cleaner so the close does not happen twice.
-     * Package private to allow it to be used in java.io.
-     * @throws IOException if close fails
-     */
-    @SuppressWarnings("unchecked")
-    synchronized void close() throws IOException {
-        if (cleanup != null) {
-            cleanup.clear();
-            cleanup = null;
-        }
-        close0();
-    }
-
-    /*
-     * Close the raw file descriptor or handle, if it has not already been closed
-     * and set the fd and handle to -1.
-     */
-    private native void close0() throws IOException;
-
-    /*
-    * Raw close of the file handle.
-    * Used only for last chance cleanup.
-    */
-    private static native void cleanupClose0(long handle) throws IOException;
-
-    /*
-     * Package private methods to track referents.
-     * If multiple streams point to the same FileDescriptor, we cycle
-     * through the list of all referents and call close()
-     */
-
-    /**
-     * Attach a Closeable to this FD for tracking.
-     * parent reference is added to otherParents when
-     * needed to make closeAll simpler.
-     */
-    synchronized void attach(Closeable c) {
-        if (parent == null) {
-            // first caller gets to do this
-            parent = c;
-        } else if (otherParents == null) {
-            otherParents = new ArrayList<>();
-            otherParents.add(parent);
-            otherParents.add(c);
-        } else {
-            otherParents.add(c);
-        }
-    }
-
-    /**
-     * Cycle through all Closeables sharing this FD and call
-     * close() on each one.
-     *
-     * The caller closeable gets to call close0().
-     */
-    @SuppressWarnings("try")
-    synchronized void closeAll(Closeable releaser) throws IOException {
-        if (!closed) {
-            closed = true;
-            IOException ioe = null;
-            try (releaser) {
-                if (otherParents != null) {
-                    for (Closeable referent : otherParents) {
-                        try {
-                            referent.close();
-                        } catch(IOException x) {
-                            if (ioe == null) {
-                                ioe = x;
-                            } else {
-                                ioe.addSuppressed(x);
-                            }
-                        }
-                    }
-                }
-            } catch(IOException ex) {
-                /*
-                 * If releaser close() throws IOException
-                 * add other exceptions as suppressed.
-                 */
-                if (ioe != null)
-                    ex.addSuppressed(ioe);
-                ioe = ex;
-            } finally {
-                if (ioe != null)
-                    throw ioe;
-            }
-        }
-    }
-
-    /**
-     * Cleanup for a FileDescriptor when it becomes phantom reachable.
-     * Create a cleanup if handle != -1.
-     * Windows closes files using handles and sockets via the fd.
-     * Network FileDescriptors using socket fd must provide their
-     * own PhantomCleanable to {@link #registerCleanup}.
-     * This implementation only clears thehandles.
-     * <p>
-     * Subclassed from {@code PhantomCleanable} so that {@code clear} can be
-     * called to disable the cleanup when the handle is closed by any means other
-     * than calling {@link FileDescriptor#close}.
-     * Otherwise, it may incorrectly close the handle after it has been reused.
-     */
-    static final class FDCleanup extends PhantomCleanable<Object> {
-        private final long handle;
-
-        static FDCleanup create(FileDescriptor fdo) {
-            return fdo.handle == -1L
-                    ? null
-                    : new FDCleanup(fdo, CleanerFactory.cleaner(), fdo.handle);
-        }
-
-        /**
-         * Constructor for a phantom cleanable reference.
-         * @param obj the object to monitor
-         * @param cleaner the cleaner
-         * @param handle file handle to close
-         */
-        private FDCleanup(Object obj, Cleaner cleaner, long handle) {
-            super(obj, cleaner);
-            this.handle = handle;
-        }
-
-        /**
-         * Close the native handle.
-         */
-        @Override
-        protected void performCleanup() {
-            try {
-                cleanupClose0(handle);
-            } catch (IOException ioe) {
-                throw new UncheckedIOException("close", ioe);
-            }
-        }
-    }
-}

src/java.base/windows/native/libjava/FileDescriptor_md.c

@@ -56,11 +56,6 @@ Java_java_io_FileDescriptor_initIDs(JNIEnv *env, jclass fdClass) {
     CHECK_NULL(IO_append_fdID = (*env)->GetFieldID(env, fdClass, "append", "Z"));
 }
 
-JNIEXPORT jlong JNICALL
-Java_java_io_FileDescriptor_getHandle(JNIEnv *env, jclass fdClass, jint fd) {
-    SET_HANDLE(fd);
-}
-
 /**************************************************************
  * File Descriptor
  */
@@ -73,13 +68,14 @@ Java_java_io_FileDescriptor_sync(JNIEnv *env, jobject this) {
     }
 }
 
-JNIEXPORT void JNICALL
+JNIEXPORT jlong JNICALL
-Java_java_io_FileDescriptor_cleanupClose0(JNIEnv *env, jclass fdClass, jlong handle) {
+Java_java_io_FileDescriptor_getHandle(JNIEnv *env, jclass fdClass, jint fd) {
-    if (handle != -1) {
+    SET_HANDLE(fd);
-        if (CloseHandle((HANDLE)handle) == -1) {
-            JNU_ThrowIOExceptionWithLastError(env, "close failed");
-        }
 }
+
+JNIEXPORT jboolean JNICALL
+Java_java_io_FileDescriptor_getAppend(JNIEnv *env, jclass fdClass, jint fd) {
+    return JNI_FALSE;
 }
 
 // instance method close0 for FileDescriptor
@@ -87,3 +83,12 @@ JNIEXPORT void JNICALL
 Java_java_io_FileDescriptor_close0(JNIEnv *env, jobject this) {
     fileDescriptorClose(env, this);
 }
+
+JNIEXPORT void JNICALL
+Java_java_io_FileCleanable_cleanupClose0(JNIEnv *env, jclass fdClass, jint unused, jlong handle) {
+    if (handle != -1) {
+        if (CloseHandle((HANDLE)handle) == -1) {
+            JNU_ThrowIOExceptionWithLastError(env, "close failed");
+        }
+    }
+}

test/jdk/java/io/FileInputStream/UnreferencedFISClosesFd.java

@@ -41,7 +41,14 @@ import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.WeakReference;
 import java.lang.reflect.Field;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayDeque;
 import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import com.sun.management.UnixOperatingSystemMXBean;
@@ -161,6 +168,7 @@ public class UnreferencedFISClosesFd {
         long fdCount = getFdCount();
         System.out.printf("final count of open file descriptors: %d%n", fdCount);
         if (fdCount != fdCount0) {
+            listProcFD();
             throw new AssertionError("raw fd count wrong: expected: " + fdCount0
                     + ", actual: " + fdCount);
         }
@@ -266,4 +274,27 @@ public class UnreferencedFISClosesFd {
         }
         return 0;
     }
+
+    /**
+     * Method to list the open file descriptors (if supported by the 'lsof' command).
+     */
+    static void listProcFD() {
+        List<String> lsofDirs = List.of("/usr/bin", "/usr/sbin");
+        Optional<Path> lsof = lsofDirs.stream()
+                .map(s -> Paths.get(s, "lsof"))
+                .filter(f -> Files.isExecutable(f))
+                .findFirst();
+        lsof.ifPresent(exe -> {
+            try {
+                System.out.printf("Open File Descriptors:%n");
+                long pid = ProcessHandle.current().pid();
+                ProcessBuilder pb = new ProcessBuilder(exe.toString(), "-p", Integer.toString((int) pid));
+                pb.inheritIO();
+                Process p = pb.start();
+                p.waitFor(10, TimeUnit.SECONDS);
+            } catch (IOException | InterruptedException ie) {
+                ie.printStackTrace();
+            }
+        });
+    }
 }