public  void force(boolean metaData) throws IOException 
{
        ensureOpen();
        int rv = -1;
        int ti = -1;
        try {
            begin();
            if (!isOpen())
                return;
            ti = threads.add();
            do {
                rv = force0(fd, metaData);
            } while ((rv == IOStatus.INTERRUPTED) && isOpen());
        } finally {
            threads.remove(ti);
            end(rv  > -1);
            assert IOStatus.check(rv);
        }
}

 protected  void implCloseChannel() throws IOException 
{
        nd.preClose(fd);
        threads.signal();
        // Invalidate and release any locks that we still hold
        if (fileLockTable != null) {
            fileLockTable.removeAll( new FileLockTable.Releaser() {
                public void release(FileLock fl) throws IOException {
                    ((FileLockImpl)fl).invalidate();
                    release0(fd, fl.position(), fl.size());
                }
            });
        }
        if (parent != null) {
            // Close the fd via the parent stream's close method.  The parent
            // will reinvoke our close method, which is defined in the
            // superclass AbstractInterruptibleChannel, but the isOpen logic in
            // that method will prevent this method from being reinvoked.
            //
            ((java.io.Closeable)parent).close();
        } else {
            nd.close(fd);
        }
}

 public FileLock lock(long position,
    long size,
    boolean shared) throws IOException 
{
        ensureOpen();
        if (shared && !readable)
            throw new NonReadableChannelException();
        if (!shared && !writable)
            throw new NonWritableChannelException();
        FileLockImpl fli = new FileLockImpl(this, position, size, shared);
        FileLockTable flt = fileLockTable();
        flt.add(fli);
        boolean i = true;
        int ti = -1;
        try {
            begin();
            if (!isOpen())
                return null;
            ti = threads.add();
            int result = lock0(fd, true, position, size, shared);
            if (result == RET_EX_LOCK) {
                assert shared;
                FileLockImpl fli2 = new FileLockImpl(this, position, size,
                                                     false);
                flt.replace(fli, fli2);
                return fli2;
            }
            if (result == INTERRUPTED || result == NO_LOCK) {
                flt.remove(fli);
                i = false;
            }
        } catch (IOException e) {
            flt.remove(fli);
            throw e;
        } finally {
            threads.remove(ti);
            try {
                end(i);
            } catch (ClosedByInterruptException e) {
                throw new FileLockInterruptionException();
            }
        }
        return fli;
}

 native int lock0(FileDescriptor fd,
    boolean blocking,
    long pos,
    long size,
    boolean shared) throws IOException

 public MappedByteBuffer map(MapMode mode,
    long position,
    long size) throws IOException 
{
           
        ensureOpen();
        if (position <  0L)
            throw new IllegalArgumentException("Negative position");
        if (size <  0L)
            throw new IllegalArgumentException("Negative size");
        if (position + size <  0)
            throw new IllegalArgumentException("Position + size overflow");
        if (size  > Integer.MAX_VALUE)
            throw new IllegalArgumentException("Size exceeds Integer.MAX_VALUE");
        int imode = -1;
        if (mode == MapMode.READ_ONLY)
            imode = MAP_RO;
        else if (mode == MapMode.READ_WRITE)
            imode = MAP_RW;
        else if (mode == MapMode.PRIVATE)
            imode = MAP_PV;
        assert (imode  >= 0);
        if ((mode != MapMode.READ_ONLY) && !writable)
            throw new NonWritableChannelException();
        if (!readable)
            throw new NonReadableChannelException();
        long addr = -1;
        int ti = -1;
        try {
            begin();
            if (!isOpen())
                return null;
            ti = threads.add();
            if (size() <  position + size) { // Extend file size
                if (!writable) {
                    throw new IOException("Channel not open for writing " +
                        "- cannot extend file to required size");
                }
                int rv;
                do {
                    rv = truncate0(fd, position + size);
                } while ((rv == IOStatus.INTERRUPTED) && isOpen());
            }
            if (size == 0) {
                addr = 0;
                if ((!writable) || (imode == MAP_RO))
                    return Util.newMappedByteBufferR(0, 0, null);
                else
                    return Util.newMappedByteBuffer(0, 0, null);
            }
            int pagePosition = (int)(position % allocationGranularity);
            long mapPosition = position - pagePosition;
            long mapSize = size + pagePosition;
            try {
                // If no exception was thrown from map0, the address is valid
                addr = map0(imode, mapPosition, mapSize);
            } catch (OutOfMemoryError x) {
                // An OutOfMemoryError may indicate that we've exhausted memory
                // so force gc and re-attempt map
                System.gc();
                try {
                    Thread.sleep(100);
                } catch (InterruptedException y) {
                    Thread.currentThread().interrupt();
                }
                try {
                    addr = map0(imode, mapPosition, mapSize);
                } catch (OutOfMemoryError y) {
                    // After a second OOME, fail
                    throw new IOException("Map failed", y);
                }
            }
            assert (IOStatus.checkAll(addr));
            assert (addr % allocationGranularity == 0);
            int isize = (int)size;
            Unmapper um = new Unmapper(addr, size + pagePosition);
            if ((!writable) || (imode == MAP_RO))
                return Util.newMappedByteBufferR(isize, addr + pagePosition, um);
            else
                return Util.newMappedByteBuffer(isize, addr + pagePosition, um);
        } finally {
            threads.remove(ti);
            end(IOStatus.checkAll(addr));
        }
}

 public static FileChannel open(FileDescriptor fd,
    boolean readable,
    boolean writable,
    Object parent) 
{
        return new FileChannelImpl(fd, readable, writable, parent);
}

 public long position() throws IOException 
{
        ensureOpen();
        synchronized (positionLock) {
            long p = -1;
            int ti = -1;
            try {
                begin();
                if (!isOpen())
                    return 0;
                ti = threads.add();
                do {
                    p = position0(fd, -1);
                } while ((p == IOStatus.INTERRUPTED) && isOpen());
                return IOStatus.normalize(p);
            } finally {
                threads.remove(ti);
                end(p  > -1);
                assert IOStatus.check(p);
            }
        }
}

 public FileChannel position(long newPosition) throws IOException 
{
        ensureOpen();
        if (newPosition <  0)
            throw new IllegalArgumentException();
        synchronized (positionLock) {
            long p = -1;
            int ti = -1;
            try {
                begin();
                if (!isOpen())
                    return null;
                ti = threads.add();
                do {
                    p  = position0(fd, newPosition);
                } while ((p == IOStatus.INTERRUPTED) && isOpen());
                return this;
            } finally {
                threads.remove(ti);
                end(p  > -1);
                assert IOStatus.check(p);
            }
        }
}

 public int read(ByteBuffer dst) throws IOException 
{
        ensureOpen();
        if (!readable)
            throw new NonReadableChannelException();
        synchronized (positionLock) {
            int n = 0;
            int ti = -1;
            try {
                begin();
                if (!isOpen())
                    return 0;
                ti = threads.add();
                do {
                    n = IOUtil.read(fd, dst, -1, nd, positionLock);
                } while ((n == IOStatus.INTERRUPTED) && isOpen());
                return IOStatus.normalize(n);
            } finally {
                threads.remove(ti);
                end(n  > 0);
                assert IOStatus.check(n);
            }
        }
}

 public int read(ByteBuffer dst,
    long position) throws IOException 
{
        if (dst == null)
            throw new NullPointerException();
        if (position <  0)
            throw new IllegalArgumentException("Negative position");
        if (!readable)
            throw new NonReadableChannelException();
        ensureOpen();
        int n = 0;
        int ti = -1;
        try {
            begin();
            if (!isOpen())
                return -1;
            ti = threads.add();
            do {
                n = IOUtil.read(fd, dst, position, nd, positionLock);
            } while ((n == IOStatus.INTERRUPTED) && isOpen());
            return IOStatus.normalize(n);
        } finally {
            threads.remove(ti);
            end(n  > 0);
            assert IOStatus.check(n);
        }
}

 public long read(ByteBuffer[] dsts,
    int offset,
    int length) throws IOException 
{
        if ((offset <  0) || (length <  0) || (offset  > dsts.length - length))
           throw new IndexOutOfBoundsException();
        // ## Fix IOUtil.write so that we can avoid this array copy
        return read0(Util.subsequence(dsts, offset, length));
}

  void release(FileLockImpl fli) throws IOException 
{
        ensureOpen();
        release0(fd, fli.position(), fli.size());
        assert fileLockTable != null;
        fileLockTable.remove(fli);
}

 native  void release0(FileDescriptor fd,
    long pos,
    long size) throws IOException

 public long size() throws IOException 
{
        ensureOpen();
        synchronized (positionLock) {
            long s = -1;
            int ti = -1;
            try {
                begin();
                if (!isOpen())
                    return -1;
                ti = threads.add();
                do {
                    s = size0(fd);
                } while ((s == IOStatus.INTERRUPTED) && isOpen());
                return IOStatus.normalize(s);
            } finally {
                threads.remove(ti);
                end(s  > -1);
                assert IOStatus.check(s);
            }
        }
}

 public long transferFrom(ReadableByteChannel src,
    long position,
    long count) throws IOException 
{
        ensureOpen();
        if (!src.isOpen())
            throw new ClosedChannelException();
        if (!writable)
            throw new NonWritableChannelException();
        if ((position <  0) || (count <  0))
            throw new IllegalArgumentException();
        if (position  > size())
            return 0;
        if (src instanceof FileChannelImpl)
           return transferFromFileChannel((FileChannelImpl)src,
                                          position, count);
        return transferFromArbitraryChannel(src, position, count);
}

 public long transferTo(long position,
    long count,
    WritableByteChannel target) throws IOException 
{
        ensureOpen();
        if (!target.isOpen())
            throw new ClosedChannelException();
        if (!readable)
            throw new NonReadableChannelException();
        if (target instanceof FileChannelImpl &&
            !((FileChannelImpl)target).writable)
            throw new NonWritableChannelException();
        if ((position <  0) || (count <  0))
            throw new IllegalArgumentException();
        long sz = size();
        if (position  > sz)
            return 0;
        int icount = (int)Math.min(count, Integer.MAX_VALUE);
        if ((sz - position) <  icount)
            icount = (int)(sz - position);
        long n;
        // Attempt a direct transfer, if the kernel supports it
        if ((n = transferToDirectly(position, icount, target))  >= 0)
            return n;
        // Attempt a mapped transfer, but only to trusted channel types
        if ((n = transferToTrustedChannel(position, icount, target))  >= 0)
            return n;
        // Slow path for untrusted targets
        return transferToArbitraryChannel(position, icount, target);
}

 public FileChannel truncate(long size) throws IOException 
{
        ensureOpen();
        if (size <  0)
            throw new IllegalArgumentException();
        if (size  > size())
            return this;
        if (!writable)
            throw new NonWritableChannelException();
        synchronized (positionLock) {
            int rv = -1;
            long p = -1;
            int ti = -1;
            try {
                begin();
                if (!isOpen())
                    return null;
                ti = threads.add();
                // get current position
                do {
                    p = position0(fd, -1);
                } while ((p == IOStatus.INTERRUPTED) && isOpen());
                if (!isOpen())
                    return null;
                assert p  >= 0;
                // truncate file
                do {
                    rv = truncate0(fd, size);
                } while ((rv == IOStatus.INTERRUPTED) && isOpen());
                if (!isOpen())
                    return null;
                // set position to size if greater than size
                if (p  > size)
                    p = size;
                do {
                    rv = (int)position0(fd, p);
                } while ((rv == IOStatus.INTERRUPTED) && isOpen());
                return this;
            } finally {
                threads.remove(ti);
                end(rv  > -1);
                assert IOStatus.check(rv);
            }
        }
}

 public FileLock tryLock(long position,
    long size,
    boolean shared) throws IOException 
{
        ensureOpen();
        if (shared && !readable)
            throw new NonReadableChannelException();
        if (!shared && !writable)
            throw new NonWritableChannelException();
        FileLockImpl fli = new FileLockImpl(this, position, size, shared);
        FileLockTable flt = fileLockTable();
        flt.add(fli);
        int result = lock0(fd, false, position, size, shared);
        if (result == NO_LOCK) {
            flt.remove(fli);
            return null;
        }
        if (result == RET_EX_LOCK) {
            assert shared;
            FileLockImpl fli2 = new FileLockImpl(this, position, size,
                                                 false);
            flt.replace(fli, fli2);
            return fli2;
        }
        return fli;
}

 public int write(ByteBuffer src) throws IOException 
{
        ensureOpen();
        if (!writable)
            throw new NonWritableChannelException();
        synchronized (positionLock) {
            int n = 0;
            int ti = -1;
            try {
                begin();
                if (!isOpen())
                    return 0;
                ti = threads.add();
                do {
                    n = IOUtil.write(fd, src, -1, nd, positionLock);
                } while ((n == IOStatus.INTERRUPTED) && isOpen());
                return IOStatus.normalize(n);
            } finally {
                threads.remove(ti);
                end(n  > 0);
                assert IOStatus.check(n);
            }
        }
}

 public int write(ByteBuffer src,
    long position) throws IOException 
{
        if (src == null)
            throw new NullPointerException();
        if (position <  0)
            throw new IllegalArgumentException("Negative position");
        if (!writable)
            throw new NonWritableChannelException();
        ensureOpen();
        int n = 0;
        int ti = -1;
        try {
            begin();
            if (!isOpen())
                return -1;
            ti = threads.add();
            do {
                n = IOUtil.write(fd, src, position, nd, positionLock);
            } while ((n == IOStatus.INTERRUPTED) && isOpen());
            return IOStatus.normalize(n);
        } finally {
            threads.remove(ti);
            end(n  > 0);
            assert IOStatus.check(n);
        }
}

 public long write(ByteBuffer[] srcs,
    int offset,
    int length) throws IOException 
{
        if ((offset <  0) || (length <  0) || (offset  > srcs.length - length))
           throw new IndexOutOfBoundsException();
        // ## Fix IOUtil.write so that we can avoid this array copy
        return write0(Util.subsequence(srcs, offset, length));
}