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

rev 6099 : [mq]: io-trace

*** 25,34 ****
--- 25,36 ----
  
  package java.io;
  
  import java.nio.channels.FileChannel;
  import sun.nio.ch.FileChannelImpl;
+ import sun.misc.IoTrace;
+ import sun.misc.IoTraceContext;
  
  
  /**
   * A <code>FileInputStream</code> obtains input bytes
   * from a file in a file system. What files
*** 49,58 ****
--- 51,63 ----
  class FileInputStream extends InputStream
  {
      /* File Descriptor - handle to the open file */
      private final FileDescriptor fd;
  
+     /* The path of the referenced file (null if the stream is created with a file descriptor) */
+     private final String path;
+ 
      private FileChannel channel = null;
  
      private final Object closeLock = new Object();
      private volatile boolean closed = false;
  
*** 123,132 ****
--- 128,138 ----
          if (name == null) {
              throw new NullPointerException();
          }
          fd = new FileDescriptor();
          fd.attach(this);
+         this.path = name;
          open(name);
      }
  
      /**
       * Creates a <code>FileInputStream</code> by using the file descriptor
*** 159,168 ****
--- 165,175 ----
          }
          if (security != null) {
              security.checkRead(fdObj);
          }
          fd = fdObj;
+         path = null;
  
          /*
           * FileDescriptor is being shared by streams.
           * Register this stream with FileDescriptor tracker.
           */
*** 181,191 ****
       *
       * @return     the next byte of data, or <code>-1</code> if the end of the
       *             file is reached.
       * @exception  IOException  if an I/O error occurs.
       */
!     public native int read() throws IOException;
  
      /**
       * Reads a subarray as a sequence of bytes.
       * @param b the data to be written
       * @param off the start offset in the data
--- 188,209 ----
       *
       * @return     the next byte of data, or <code>-1</code> if the end of the
       *             file is reached.
       * @exception  IOException  if an I/O error occurs.
       */
!     public int read() throws IOException {
!         IoTraceContext traceContext = IoTrace.fileReadBegin(path);
!         int b = 0;
!         try {
!             b = read0();
!         } finally {
!             IoTrace.fileReadEnd(traceContext, b == -1 ? 0 : 1);
!         }
!         return b;
!     }
! 
!     private native int read0() throws IOException;
  
      /**
       * Reads a subarray as a sequence of bytes.
       * @param b the data to be written
       * @param off the start offset in the data
*** 204,214 ****
       *             <code>-1</code> if there is no more data because the end of
       *             the file has been reached.
       * @exception  IOException  if an I/O error occurs.
       */
      public int read(byte b[]) throws IOException {
!         return readBytes(b, 0, b.length);
      }
  
      /**
       * Reads up to <code>len</code> bytes of data from this input stream
       * into an array of bytes. If <code>len</code> is not zero, the method
--- 222,239 ----
       *             <code>-1</code> if there is no more data because the end of
       *             the file has been reached.
       * @exception  IOException  if an I/O error occurs.
       */
      public int read(byte b[]) throws IOException {
!         IoTraceContext traceContext = IoTrace.fileReadBegin(path);
!         int bytesRead = 0;
!         try {
!             bytesRead = readBytes(b, 0, b.length);
!         } finally {
!             IoTrace.fileReadEnd(traceContext, bytesRead);
!         }
!         return bytesRead;
      }
  
      /**
       * Reads up to <code>len</code> bytes of data from this input stream
       * into an array of bytes. If <code>len</code> is not zero, the method
*** 226,236 ****
       * <code>len</code> is negative, or <code>len</code> is greater than
       * <code>b.length - off</code>
       * @exception  IOException  if an I/O error occurs.
       */
      public int read(byte b[], int off, int len) throws IOException {
!         return readBytes(b, off, len);
      }
  
      /**
       * Skips over and discards <code>n</code> bytes of data from the
       * input stream.
--- 251,268 ----
       * <code>len</code> is negative, or <code>len</code> is greater than
       * <code>b.length - off</code>
       * @exception  IOException  if an I/O error occurs.
       */
      public int read(byte b[], int off, int len) throws IOException {
!         IoTraceContext traceContext = IoTrace.fileReadBegin(path);
!         int bytesRead = 0;
!         try {
!             bytesRead = readBytes(b, off, len);
!         } finally {
!             IoTrace.fileReadEnd(traceContext, bytesRead);
!         }
!         return bytesRead;
      }
  
      /**
       * Skips over and discards <code>n</code> bytes of data from the
       * input stream.
*** 337,347 ****
       * @spec JSR-51
       */
      public FileChannel getChannel() {
          synchronized (this) {
              if (channel == null) {
!                 channel = FileChannelImpl.open(fd, true, false, this);
              }
              return channel;
          }
      }
  
--- 369,379 ----
       * @spec JSR-51
       */
      public FileChannel getChannel() {
          synchronized (this) {
              if (channel == null) {
!                 channel = FileChannelImpl.open(fd, path, true, false, this);
              }
              return channel;
          }
      }