Internalize FileDescriptor

Author: minborg

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

@@ -25,14 +25,7 @@
 
 package java.io;
 
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-
-import jdk.internal.access.JavaIOFileDescriptorAccess;
-import jdk.internal.access.SharedSecrets;
-import jdk.internal.misc.Blocker;
-import jdk.internal.ref.PhantomCleanable;
+import jdk.internal.io.InternalFileDescriptor;
 
 /**
  * Instances of the file descriptor class serve as an opaque handle
@@ -46,87 +39,19 @@
  * @author  Pavani Diwanji
  * @since   1.0
  */
-public final class FileDescriptor {
-
-    private int fd;
+@SuppressWarnings("exports") // Todo: check this
+public final class FileDescriptor extends InternalFileDescriptor {
 
-    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.set(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();
-                    }
-
-                    /* Register for a normal FileCleanable fd/handle cleanup. */
-                    public void registerCleanup(FileDescriptor fdo) {
-                        FileCleanable.register(fdo);
-                    }
-
-                    /* Register a custom PhantomCleanup. */
-                    public void registerCleanup(FileDescriptor fdo,
-                                                PhantomCleanable<FileDescriptor> 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<FileDescriptor> cleanup;
+/*    @Stable
+    private final InternalFileDescriptor internalFileDescriptor;*/
 
     /**
      * Constructs an (invalid) FileDescriptor object.
      * The fd or handle is set later.
      */
     public FileDescriptor() {
-        fd = -1;
-        handle = -1;
+        super();
+        //internalFileDescriptor = new InternalFileDescriptor();
     }
 
     /**
@@ -136,9 +61,8 @@ public FileDescriptor() {
      * @param fd the raw fd number (0, 1, 2)
      */
     private FileDescriptor(int fd) {
-        this.fd = fd;
-        this.handle = getHandle(fd);
-        this.append = getAppend(fd);
+        super(fd);
+        //internalFileDescriptor = new InternalFileDescriptor(fd);
     }
 
     /**
@@ -175,7 +99,8 @@ private FileDescriptor(int fd) {
      *          {@code false} otherwise.
      */
     public boolean valid() {
-        return (handle != -1) || (fd != -1);
+        return super.valid();
+        //return internalFileDescriptor.valid();
     }
 
     /**
@@ -207,89 +132,24 @@ public boolean valid() {
      * @since     1.1
      */
     public void sync() throws SyncFailedException {
-        boolean attempted = Blocker.begin();
-        try {
-            sync0();
-        } finally {
-            Blocker.end(attempted);
-        }
+        super.sync();
+        //internalFileDescriptor.sync();
     }
 
-    /* fsync/equivalent this file descriptor */
-    private native void sync0() throws SyncFailedException;
-
-    /* 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.
-     * @param fd the raw fd or -1 to indicate closed
-     */
-    synchronized void set(int fd) {
-        if (fd == -1 && cleanup != null) {
-            cleanup.clear();
-            cleanup = null;
-        }
-        this.fd = fd;
-    }
-
-    /**
-     * Set the handle.
-     * Used on Windows for regular files.
-     * 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
-     */
-    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.
-     * @param cleanable a PhantomCleanable to register
+     * 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()
      */
-    synchronized void registerCleanup(PhantomCleanable<FileDescriptor> cleanable) {
-        Objects.requireNonNull(cleanable, "cleanable");
-        if (cleanup != null) {
-            cleanup.clear();
-        }
-        cleanup = cleanable;
-    }
 
     /**
-     * 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
-     * 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.
+     * Attach a Closeable to this FD for tracking.
+     * parent reference is added to otherParents when
+     * needed to make closeAll simpler.
      */
-    synchronized void unregisterCleanup() {
-        if (cleanup != null) {
-            cleanup.clear();
-        }
-        cleanup = null;
+    void attach(Closeable c) {
+        super.attach0(c);
+        //internalFileDescriptor.attach(c);
     }
 
     /**
@@ -299,39 +159,9 @@ synchronized void unregisterCleanup() {
      * Package private to allow it to be used in java.io.
      * @throws IOException if close fails
      */
-    synchronized void close() throws IOException {
-        unregisterCleanup();
-        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;
-
-    /*
-     * 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);
-        }
+    void close() throws IOException {
+        super.close1();
+        //internalFileDescriptor.close();
     }
 
     /**
@@ -340,36 +170,9 @@ synchronized void attach(Closeable c) {
      *
      * The caller closeable gets to call close0().
      */
-    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;
-            }
-        }
+    void closeAll(Closeable releaser) throws IOException {
+        super.closeAll0(releaser);
+        //internalFileDescriptor.closeAll(releaser);
     }
+
 }

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

@@ -27,6 +27,8 @@
 
 import java.nio.channels.FileChannel;
 import java.util.Arrays;
+
+import jdk.internal.io.FileCleanable;
 import jdk.internal.util.ArraysSupport;
 import jdk.internal.event.FileReadEvent;
 import jdk.internal.vm.annotation.Stable;

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

@@ -26,9 +26,9 @@
 package java.io;
 
 import java.nio.channels.FileChannel;
-import jdk.internal.access.SharedSecrets;
-import jdk.internal.access.JavaIOFileDescriptorAccess;
 import jdk.internal.event.FileWriteEvent;
+import jdk.internal.access.JavaIOFileDescriptorAccessUtil;
+import jdk.internal.io.FileCleanable;
 import sun.nio.ch.FileChannelImpl;
 
 
@@ -63,11 +63,6 @@
  */
 public class FileOutputStream extends OutputStream
 {
-    /**
-     * Access to FileDescriptor internals.
-     */
-    private static final JavaIOFileDescriptorAccess FD_ACCESS =
-        SharedSecrets.getJavaIOFileDescriptorAccess();
 
     /**
      * Flag set by jdk.internal.event.JFRTracing to indicate if
@@ -284,7 +279,7 @@ private void traceWrite(int b, boolean append) throws IOException {
      */
     @Override
     public void write(int b) throws IOException {
-        boolean append = FD_ACCESS.getAppend(fd);
+        boolean append = JavaIOFileDescriptorAccessUtil.getAppend(fd);
         if (jfrTracing && FileWriteEvent.enabled()) {
             traceWrite(b, append);
             return;
@@ -324,7 +319,7 @@ private void traceWriteBytes(byte b[], int off, int len, boolean append) throws
      */
     @Override
     public void write(byte[] b) throws IOException {
-        boolean append = FD_ACCESS.getAppend(fd);
+        boolean append = JavaIOFileDescriptorAccessUtil.getAppend(fd);
         if (jfrTracing && FileWriteEvent.enabled()) {
             traceWriteBytes(b, 0, b.length, append);
             return;
@@ -344,7 +339,7 @@ public void write(byte[] b) throws IOException {
      */
     @Override
     public void write(byte[] b, int off, int len) throws IOException {
-        boolean append = FD_ACCESS.getAppend(fd);
+        boolean append = JavaIOFileDescriptorAccessUtil.getAppend(fd);
         if (jfrTracing && FileWriteEvent.enabled()) {
             traceWriteBytes(b, off, len, append);
             return;

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

@@ -29,6 +29,7 @@
 
 import jdk.internal.access.JavaIORandomAccessFileAccess;
 import jdk.internal.access.SharedSecrets;
+import jdk.internal.io.FileCleanable;
 import jdk.internal.misc.Blocker;
 import jdk.internal.util.ByteArray;
 import jdk.internal.event.FileReadEvent;

src/java.base/share/classes/jdk/internal/access/JavaIOFileDescriptorAccessUtil.java

@@ -0,0 +1,5 @@
+package jdk.internal.access;
+
+import jdk.internal.io.InternalFileDescriptor;
+
+public final class JavaIOFileDescriptorAccessUtil extends InternalFileDescriptor.JavaIOFileDescriptorAccessUtilImpl {}