{

private static final int DEFAULT_BUFFER_SIZE = 8192;

/**

private static boolean jfrTracing;

/* File Descriptor - handle to the open file */

private final FileDescriptor fd;

/**

private final String path;

private volatile FileChannel channel;

private final Object closeLock = new Object();

private volatile boolean closed;

// This field indicates whether the file is a regular file as some

// operations need the current position which requires seeking

private @Stable Boolean isRegularFile;

/**

public FileInputStream(String name) throws FileNotFoundException {

this(name != null ? new File(name) : null);

}

/**

@SuppressWarnings("this-escape")

public FileInputStream(File file) throws FileNotFoundException {

if (file.isInvalid()) {

throw new FileNotFoundException("Invalid file path");

}

path = file.getPath();

fd = new FileDescriptor();

fd.attach(this);

open(path);

FileCleanable.register(fd); // open set the fd, register the cleanup

}

/**

@SuppressWarnings("this-escape")

public FileInputStream(FileDescriptor fdObj) {

if (fdObj == null) {

throw new NullPointerException();

}

fd = fdObj;

path = null;

/*

fd.attach(this);

}

/**

private native void open0(String name) throws FileNotFoundException;

// wrap native call to allow instrumentation

/**

private void open(String name) throws FileNotFoundException {

open0(name);

}

/**

@Override

public int read() throws IOException {

if (jfrTracing && FileReadEvent.enabled()) {

return traceRead0();

}

return read0();

}

private native int read0() throws IOException;

private int traceRead0() throws IOException {

int result = 0;

long bytesRead = 0;

long start = FileReadEvent.timestamp();

try {

result = read0();

if (result < 0) {

bytesRead = -1;

} else {

bytesRead = 1;

}

} finally {

FileReadEvent.offer(start, path, bytesRead);

}

return result;

}

/**

private native int readBytes(byte[] b, int off, int len) throws IOException;

private int traceReadBytes(byte b[], int off, int len) throws IOException {

int bytesRead = 0;

long start = FileReadEvent.timestamp();

try {

bytesRead = readBytes(b, off, len);

} finally {

FileReadEvent.offer(start, path, bytesRead);

}

return bytesRead;

}

/**

@Override

public int read(byte[] b) throws IOException {

if (jfrTracing && FileReadEvent.enabled()) {

return traceReadBytes(b, 0, b.length);

}

return readBytes(b, 0, b.length);

}

/**

@Override

public int read(byte[] b, int off, int len) throws IOException {

if (jfrTracing && FileReadEvent.enabled()) {

return traceReadBytes(b, off, len);

}

return readBytes(b, off, len);

}

@Override

public byte[] readAllBytes() throws IOException {

if (!isRegularFile())

return super.readAllBytes();

long length = length();

long position = position();

long size = length - position;

if (length <= 0 || size <= 0)

return super.readAllBytes();

if (size > (long) Integer.MAX_VALUE) {

String msg =

String.format("Required array size too large for %s: %d = %d - %d",

path, size, length, position);

throw new OutOfMemoryError(msg);

}

int capacity = (int)size;

byte[] buf = new byte[capacity];

int nread = 0;

int n;

for (;;) {

// read to EOF which may read more or less than initial size, e.g.,

// file is truncated while we are reading

while ((n = read(buf, nread, capacity - nread)) > 0)

nread += n;

// if last call to read() returned -1, we are done; otherwise,

// try to read one more byte and if that fails we're done too

if (n < 0 || (n = read()) < 0)

break;

// one more byte was read; need to allocate a larger buffer

capacity = Math.max(ArraysSupport.newLength(capacity,

1, // min growth

capacity), // pref growth

DEFAULT_BUFFER_SIZE);

buf = Arrays.copyOf(buf, capacity);

buf[nread++] = (byte)n;

}

return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);

}

/**

@Override

public byte[] readNBytes(int len) throws IOException {

if (len < 0)

throw new IllegalArgumentException("len < 0");

if (len == 0)

return new byte[0];

if (!isRegularFile())

return super.readNBytes(len);

long length = length();

long position = position();

long size = length - position;

if (length <= 0 || size <= 0)

return super.readNBytes(len);

int capacity = (int)Math.min(len, size);

byte[] buf = new byte[capacity];

int remaining = capacity;

int nread = 0;

int n;

do {

n = read(buf, nread, remaining);

if (n > 0) {

nread += n;

remaining -= n;

} else if (n == 0) {

// Block until a byte is read or EOF is detected

byte b = (byte)read();

if (b == -1 )

break;

buf[nread++] = b;

remaining--;

}

} while (n >= 0 && remaining > 0);

return (capacity == nread) ? buf : Arrays.copyOf(buf, nread);

}

/**

@Override

public long transferTo(OutputStream out) throws IOException {

long transferred = 0L;

if (out instanceof FileOutputStream fos && isRegularFile()) {

FileChannel fc = getChannel();

long pos = fc.position();

transferred = fc.transferTo(pos, Long.MAX_VALUE, fos.getChannel());

long newPos = pos + transferred;

fc.position(newPos);

if (newPos >= fc.size()) {

return transferred;

}

}

try {

return Math.addExact(transferred, super.transferTo(out));

} catch (ArithmeticException ignore) {

return Long.MAX_VALUE;

}

}

private long length() throws IOException {

return length0();

}

private native long length0() throws IOException;

private long position() throws IOException {

return position0();

}

private native long position0() throws IOException;

/**

@Override

public long skip(long n) throws IOException {

if (isRegularFile())

return skip0(n);

return super.skip(n);

}

private native long skip0(long n) throws IOException;

/**

@Override

public int available() throws IOException {

return available0();

}

private native int available0() throws IOException;

/**

@Override

public void close() throws IOException {

if (closed) {

return;

}

synchronized (closeLock) {

if (closed) {

return;

}

closed = true;

}

FileChannel fc = channel;

if (fc != null) {

// possible race with getChannel(), benign since

// FileChannel.close is final and idempotent

fc.close();

}

fd.closeAll(new Closeable() {

public void close() throws IOException {

fd.close();

}

});

}

/**

public final FileDescriptor getFD() throws IOException {

if (fd != null) {

return fd;

}

throw new IOException();

}

/**

public FileChannel getChannel() {

FileChannel fc = this.channel;

if (fc == null) {

synchronized (this) {

fc = this.channel;

if (fc == null) {

fc = FileChannelImpl.open(fd, path, true, false, false, false, this);

this.channel = fc;

if (closed) {

try {

// possible race with close(), benign since

// FileChannel.close is final and idempotent

fc.close();

} catch (IOException ioe) {

throw new InternalError(ioe); // should not happen

}

}

}

}

}

return fc;

}

/**

private boolean isRegularFile() {

Boolean isRegularFile = this.isRegularFile;

if (isRegularFile == null) {

this.isRegularFile = isRegularFile = isRegularFile0(fd);

}

return isRegularFile;

}

private native boolean isRegularFile0(FileDescriptor fd);

private static native void initIDs();

static {

initIDs();

}