luni/src/main/java/java/nio/FileChannelImpl.java - platform/libcore-snapshot - Git at Google

 /*
  *  Licensed to the Apache Software Foundation (ASF) under one or more
  *  contributor license agreements.  See the NOTICE file distributed with
  *  this work for additional information regarding copyright ownership.
  *  The ASF licenses this file to You under the Apache License, Version 2.0
  *  (the "License"); you may not use this file except in compliance with
  *  the License.  You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */

 package java.nio;

 import java.io.Closeable;
 import java.io.FileDescriptor;
 import java.io.IOException;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.FileChannel;
 import java.nio.channels.FileLock;
 import java.nio.channels.NonReadableChannelException;
 import java.nio.channels.NonWritableChannelException;
 import java.nio.channels.OverlappingFileLockException;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.WritableByteChannel;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import libcore.io.ErrnoException;
 import libcore.io.IoUtils;
 import libcore.io.Libcore;
 import libcore.io.StructFlock;
 import libcore.util.MutableLong;
 import static libcore.io.OsConstants.*;

 /**
  * Our concrete implementation of the abstract FileChannel class.
  */
 final class FileChannelImpl extends FileChannel {
     private static final Comparator<FileLock> LOCK_COMPARATOR = new Comparator<FileLock>() {
         public int compare(FileLock lock1, FileLock lock2) {
             long position1 = lock1.position();
             long position2 = lock2.position();
             return position1 > position2 ? 1 : (position1 < position2 ? -1 : 0);
         }
     };

     private final Object stream;
     private final FileDescriptor fd;
     private final int mode;

     // The set of acquired and pending locks.
     private final SortedSet<FileLock> locks = new TreeSet<FileLock>(LOCK_COMPARATOR);

     /**
      * Create a new file channel implementation class that wraps the given
      * fd and operates in the specified mode.
      */
     public FileChannelImpl(Object stream, FileDescriptor fd, int mode) {
         this.fd = fd;
         this.stream = stream;
         this.mode = mode;
     }

     private void checkOpen() throws ClosedChannelException {
         if (!isOpen()) {
             throw new ClosedChannelException();
         }
     }

     private void checkReadable() {
         if ((mode & O_ACCMODE) == O_WRONLY) {
             throw new NonReadableChannelException();
         }
     }

     private void checkWritable() {
         if ((mode & O_ACCMODE) == O_RDONLY) {
             throw new NonWritableChannelException();
         }
     }

     protected void implCloseChannel() throws IOException {
         if (stream instanceof Closeable) {
             ((Closeable) stream).close();
         }
     }

     private FileLock basicLock(long position, long size, boolean shared, boolean wait) throws IOException {
         int accessMode = (mode & O_ACCMODE);
         if (accessMode == O_RDONLY) {
             if (!shared) {
                 throw new NonWritableChannelException();
             }
         } else if (accessMode == O_WRONLY) {
             if (shared) {
                 throw new NonReadableChannelException();
             }
         }

         if (position < 0 || size < 0) {
             throw new IllegalArgumentException("position=" + position + " size=" + size);
         }

         FileLock pendingLock = new FileLockImpl(this, position, size, shared);
         addLock(pendingLock);

         StructFlock flock = new StructFlock();
         flock.l_type = (short) (shared ? F_RDLCK : F_WRLCK);
         flock.l_whence = (short) SEEK_SET;
         flock.l_start = position;
         flock.l_len = translateLockLength(size);

         boolean success = false;
         try {
             success = (Libcore.os.fcntlFlock(fd, wait ? F_SETLKW64 : F_SETLK64, flock) != -1);
         } catch (ErrnoException errnoException) {
             throw errnoException.rethrowAsIOException();
         } finally {
             if (!success) {
                 removeLock(pendingLock);
             }
         }
         return success ? pendingLock : null;
     }

     private static long translateLockLength(long byteCount) {
         // FileChannel uses Long.MAX_VALUE to mean "lock the whole file" where POSIX uses 0.
         return (byteCount == Long.MAX_VALUE) ? 0 : byteCount;
     }

     private static final class FileLockImpl extends FileLock {
         private boolean isReleased = false;

         public FileLockImpl(FileChannel channel, long position, long size, boolean shared) {
             super(channel, position, size, shared);
         }

         public boolean isValid() {
             return !isReleased && channel().isOpen();
         }

         public void release() throws IOException {
             if (!channel().isOpen()) {
                 throw new ClosedChannelException();
             }
             if (!isReleased) {
                 ((FileChannelImpl) channel()).release(this);
                 isReleased = true;
             }
         }
     }

     public final FileLock lock(long position, long size, boolean shared) throws IOException {
         checkOpen();
         FileLock resultLock = null;
         {
             boolean completed = false;
             try {
                 begin();
                 resultLock = basicLock(position, size, shared, true);
                 completed = true;
             } finally {
                 end(completed);
             }
         }
         return resultLock;
     }

     public final FileLock tryLock(long position, long size, boolean shared) throws IOException {
         checkOpen();
         return basicLock(position, size, shared, false);
     }

     /**
      * Non-API method to release a given lock on a file channel. Assumes that
      * the lock will mark itself invalid after successful unlocking.
      */
     public void release(FileLock lock) throws IOException {
         checkOpen();

         StructFlock flock = new StructFlock();
         flock.l_type = (short) F_UNLCK;
         flock.l_whence = (short) SEEK_SET;
         flock.l_start = lock.position();
         flock.l_len = translateLockLength(lock.size());
         try {
             Libcore.os.fcntlFlock(fd, F_SETLKW64, flock);
         } catch (ErrnoException errnoException) {
             throw errnoException.rethrowAsIOException();
         }

         removeLock(lock);
     }

     public void force(boolean metadata) throws IOException {
         checkOpen();
         if ((mode & O_ACCMODE) != O_RDONLY) {
             try {
                 if (metadata) {
                     Libcore.os.fsync(fd);
                 } else {
                     Libcore.os.fdatasync(fd);
                 }
             } catch (ErrnoException errnoException) {
                 throw errnoException.rethrowAsIOException();
             }
         }
     }

     public final MappedByteBuffer map(MapMode mapMode, long position, long size) throws IOException {
         checkOpen();
         if (mapMode == null) {
             throw new NullPointerException("mapMode == null");
         }
         if (position < 0 || size < 0 || size > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("position=" + position + " size=" + size);
         }
         int accessMode = (mode & O_ACCMODE);
         if (accessMode == O_RDONLY) {
             if (mapMode != MapMode.READ_ONLY) {
                 throw new NonWritableChannelException();
             }
         } else if (accessMode == O_WRONLY) {
             throw new NonReadableChannelException();
         }
         if (position + size > size()) {
             // We can't defer to FileChannel.truncate because that will only make a file shorter,
             // and we only care about making our backing file longer here.
             try {
                 Libcore.os.ftruncate(fd, position + size);
             } catch (ErrnoException errnoException) {
                 throw errnoException.rethrowAsIOException();
             }
         }
         long alignment = position - position % Libcore.os.sysconf(_SC_PAGE_SIZE);
         int offset = (int) (position - alignment);
         MemoryBlock block = MemoryBlock.mmap(fd, alignment, size + offset, mapMode);
         return new MappedByteBufferAdapter(block, (int) size, offset, mapMode);
     }

     public long position() throws IOException {
         checkOpen();
         try {
             return Libcore.os.lseek(fd, 0L, SEEK_CUR);
         } catch (ErrnoException errnoException) {
             throw errnoException.rethrowAsIOException();
         }
     }

     public FileChannel position(long newPosition) throws IOException {
         checkOpen();
         if (newPosition < 0) {
             throw new IllegalArgumentException("position: " + newPosition);
         }
         try {
             Libcore.os.lseek(fd, newPosition, SEEK_SET);
         } catch (ErrnoException errnoException) {
             throw errnoException.rethrowAsIOException();
         }
         return this;
     }

     public int read(ByteBuffer buffer, long position) throws IOException {
         if (position < 0) {
             throw new IllegalArgumentException("position: " + position);
         }
         return readImpl(buffer, position);
     }

     public int read(ByteBuffer buffer) throws IOException {
         return readImpl(buffer, -1);
     }

     private int readImpl(ByteBuffer buffer, long position) throws IOException {
         buffer.checkWritable();
         checkOpen();
         checkReadable();
         if (!buffer.hasRemaining()) {
             return 0;
         }
         int bytesRead = 0;
         boolean completed = false;
         try {
             begin();
             try {
                 if (position == -1) {
                     bytesRead = Libcore.os.read(fd, buffer);
                 } else {
                     bytesRead = Libcore.os.pread(fd, buffer, position);
                 }
                 if (bytesRead == 0) {
                     bytesRead = -1;
                 }
             } catch (ErrnoException errnoException) {
                 if (errnoException.errno == EAGAIN) {
                     // We don't throw if we try to read from an empty non-blocking pipe.
                     bytesRead = 0;
                 } else {
                     throw errnoException.rethrowAsIOException();
                 }
             }
             completed = true;
         } finally {
             end(completed && bytesRead >= 0);
         }
         if (bytesRead > 0) {
             buffer.position(buffer.position() + bytesRead);
         }
         return bytesRead;
     }

     private int transferIoVec(IoVec ioVec) throws IOException {
         if (ioVec.init() == 0) {
             return 0;
         }
         int bytesTransferred = 0;
         boolean completed = false;
         try {
             begin();
             bytesTransferred = ioVec.doTransfer(fd);
             completed = true;
         } finally {
             end(completed);
         }
         ioVec.didTransfer(bytesTransferred);
         return bytesTransferred;
     }

     public long read(ByteBuffer[] buffers, int offset, int length) throws IOException {
         Arrays.checkOffsetAndCount(buffers.length, offset, length);
         checkOpen();
         checkReadable();
         return transferIoVec(new IoVec(buffers, offset, length, IoVec.Direction.READV));
     }

     public long size() throws IOException {
         checkOpen();
         try {
             return Libcore.os.fstat(fd).st_size;
         } catch (ErrnoException errnoException) {
             throw errnoException.rethrowAsIOException();
         }
     }

     public long transferFrom(ReadableByteChannel src, long position, long count) throws IOException {
         checkOpen();
         if (!src.isOpen()) {
             throw new ClosedChannelException();
         }
         checkWritable();
         if (position < 0 || count < 0 || count > Integer.MAX_VALUE) {
             throw new IllegalArgumentException("position=" + position + " count=" + count);
         }
         if (position > size()) {
             return 0;
         }

         // Although sendfile(2) originally supported writing to a regular file.
         // In Linux 2.6 and later, it only supports writing to sockets.

         // If our source is a regular file, mmap(2) rather than reading.
         // Callers should only be using transferFrom for large transfers,
         // so the mmap(2) overhead isn't a concern.
         if (src instanceof FileChannel) {
             FileChannel fileSrc = (FileChannel) src;
             long size = fileSrc.size();
             long filePosition = fileSrc.position();
             count = Math.min(count, size - filePosition);
             ByteBuffer buffer = fileSrc.map(MapMode.READ_ONLY, filePosition, count);
             try {
                 fileSrc.position(filePosition + count);
                 return write(buffer, position);
             } finally {
                 NioUtils.freeDirectBuffer(buffer);
             }
         }

         // For non-file channels, all we can do is read and write via userspace.
         ByteBuffer buffer = ByteBuffer.allocate((int) count);
         src.read(buffer);
         buffer.flip();
         return write(buffer, position);
     }

     public long transferTo(long position, long count, WritableByteChannel target) throws IOException {
         checkOpen();
         if (!target.isOpen()) {
             throw new ClosedChannelException();
         }
         checkReadable();
         if (target instanceof FileChannelImpl) {
             ((FileChannelImpl) target).checkWritable();
         }
         if (position < 0 || count < 0) {
             throw new IllegalArgumentException("position=" + position + " count=" + count);
         }

         if (count == 0 || position >= size()) {
             return 0;
         }
         count = Math.min(count, size() - position);

         // Try sendfile(2) first...
         boolean completed = false;
         if (target instanceof SocketChannelImpl) {
             FileDescriptor outFd = ((SocketChannelImpl) target).getFD();
             try {
                 begin();
                 try {
                     MutableLong offset = new MutableLong(position);
                     long rc = Libcore.os.sendfile(outFd, fd, offset, count);
                     completed = true;
                     return rc;
                 } catch (ErrnoException errnoException) {
                     // If the OS doesn't support what we asked for, we want to fall through and
                     // try a different approach. If it does support it, but it failed, we're done.
                     if (errnoException.errno != ENOSYS && errnoException.errno != EINVAL) {
                         throw errnoException.rethrowAsIOException();
                     }
                 }
             } finally {
                 end(completed);
             }
         }
         // ...fall back to write(2).
         ByteBuffer buffer = null;
         try {
             buffer = map(MapMode.READ_ONLY, position, count);
             return target.write(buffer);
         } finally {
             NioUtils.freeDirectBuffer(buffer);
         }
     }

     public FileChannel truncate(long size) throws IOException {
         checkOpen();
         if (size < 0) {
             throw new IllegalArgumentException("size: " + size);
         }
         checkWritable();
         if (size < size()) {
             try {
                 Libcore.os.ftruncate(fd, size);
             } catch (ErrnoException errnoException) {
                 throw errnoException.rethrowAsIOException();
             }
         }
         return this;
     }

     public int write(ByteBuffer buffer, long position) throws IOException {
         if (position < 0) {
             throw new IllegalArgumentException("position: " + position);
         }
         return writeImpl(buffer, position);
     }

     public int write(ByteBuffer buffer) throws IOException {
         return writeImpl(buffer, -1);
     }

     private int writeImpl(ByteBuffer buffer, long position) throws IOException {
         checkOpen();
         checkWritable();
         if (buffer == null) {
             throw new NullPointerException("buffer == null");
         }
         if (!buffer.hasRemaining()) {
             return 0;
         }
         int bytesWritten = 0;
         boolean completed = false;
         try {
             begin();
             try {
                 if (position == -1) {
                     bytesWritten = Libcore.os.write(fd, buffer);
                 } else {
                     bytesWritten = Libcore.os.pwrite(fd, buffer, position);
                 }
             } catch (ErrnoException errnoException) {
                 throw errnoException.rethrowAsIOException();
             }
             completed = true;
         } finally {
             end(completed);
         }
         if (bytesWritten > 0) {
             buffer.position(buffer.position() + bytesWritten);
         }
         return bytesWritten;
     }

     public long write(ByteBuffer[] buffers, int offset, int length) throws IOException {
         Arrays.checkOffsetAndCount(buffers.length, offset, length);
         checkOpen();
         checkWritable();
         return transferIoVec(new IoVec(buffers, offset, length, IoVec.Direction.WRITEV));
     }

     /**
      * @param copyingIn true if we're copying data into the buffers (typically
      * because the caller is a file/network read operation), false if we're
      * copying data out of the buffers (for a file/network write operation).
      */
     static int calculateTotalRemaining(ByteBuffer[] buffers, int offset, int length, boolean copyingIn) {
         int count = 0;
         for (int i = offset; i < offset + length; ++i) {
             count += buffers[i].remaining();
             if (copyingIn) {
                 buffers[i].checkWritable();
             }
         }
         return count;
     }

     public FileDescriptor getFD() {
         return fd;
     }

     /**
      * Add a new pending lock to the manager. Throws an exception if the lock
      * would overlap an existing lock. Once the lock is acquired it remains in
      * this set as an acquired lock.
      */
     private synchronized void addLock(FileLock lock) throws OverlappingFileLockException {
         long lockEnd = lock.position() + lock.size();
         for (FileLock existingLock : locks) {
             if (existingLock.position() > lockEnd) {
                 // This, and all remaining locks, start beyond our end (so
                 // cannot overlap).
                 break;
             }
             if (existingLock.overlaps(lock.position(), lock.size())) {
                 throw new OverlappingFileLockException();
             }
         }
         locks.add(lock);
     }

     /**
      * Removes an acquired lock from the lock manager. If the lock did not exist
      * in the lock manager the operation is a no-op.
      */
     private synchronized void removeLock(FileLock lock) {
         locks.remove(lock);
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You under the Apache License, Version 2.0
	* (the "License"); you may not use this file except in compliance with
	* the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package java.nio;

	import java.io.Closeable;
	import java.io.FileDescriptor;
	import java.io.IOException;
	import java.nio.channels.ClosedChannelException;
	import java.nio.channels.FileChannel;
	import java.nio.channels.FileLock;
	import java.nio.channels.NonReadableChannelException;
	import java.nio.channels.NonWritableChannelException;
	import java.nio.channels.OverlappingFileLockException;
	import java.nio.channels.ReadableByteChannel;
	import java.nio.channels.WritableByteChannel;
	import java.util.Arrays;
	import java.util.Comparator;
	import java.util.SortedSet;
	import java.util.TreeSet;
	import libcore.io.ErrnoException;
	import libcore.io.IoUtils;
	import libcore.io.Libcore;
	import libcore.io.StructFlock;
	import libcore.util.MutableLong;
	import static libcore.io.OsConstants.*;

	/**
	* Our concrete implementation of the abstract FileChannel class.
	*/
	final class FileChannelImpl extends FileChannel {
	private static final Comparator<FileLock> LOCK_COMPARATOR = new Comparator<FileLock>() {
	public int compare(FileLock lock1, FileLock lock2) {
	long position1 = lock1.position();
	long position2 = lock2.position();
	return position1 > position2 ? 1 : (position1 < position2 ? -1 : 0);
	}
	};

	private final Object stream;
	private final FileDescriptor fd;
	private final int mode;

	// The set of acquired and pending locks.
	private final SortedSet<FileLock> locks = new TreeSet<FileLock>(LOCK_COMPARATOR);

	/**
	* Create a new file channel implementation class that wraps the given
	* fd and operates in the specified mode.
	*/
	public FileChannelImpl(Object stream, FileDescriptor fd, int mode) {
	this.fd = fd;
	this.stream = stream;
	this.mode = mode;
	}

	private void checkOpen() throws ClosedChannelException {
	if (!isOpen()) {
	throw new ClosedChannelException();
	}
	}

	private void checkReadable() {
	if ((mode & O_ACCMODE) == O_WRONLY) {
	throw new NonReadableChannelException();
	}
	}

	private void checkWritable() {
	if ((mode & O_ACCMODE) == O_RDONLY) {
	throw new NonWritableChannelException();
	}
	}

	protected void implCloseChannel() throws IOException {
	if (stream instanceof Closeable) {
	((Closeable) stream).close();
	}
	}

	private FileLock basicLock(long position, long size, boolean shared, boolean wait) throws IOException {
	int accessMode = (mode & O_ACCMODE);
	if (accessMode == O_RDONLY) {
	if (!shared) {
	throw new NonWritableChannelException();
	}
	} else if (accessMode == O_WRONLY) {
	if (shared) {
	throw new NonReadableChannelException();
	}
	}

	if (position < 0 \|\| size < 0) {
	throw new IllegalArgumentException("position=" + position + " size=" + size);
	}

	FileLock pendingLock = new FileLockImpl(this, position, size, shared);
	addLock(pendingLock);

	StructFlock flock = new StructFlock();
	flock.l_type = (short) (shared ? F_RDLCK : F_WRLCK);
	flock.l_whence = (short) SEEK_SET;
	flock.l_start = position;
	flock.l_len = translateLockLength(size);

	boolean success = false;
	try {
	success = (Libcore.os.fcntlFlock(fd, wait ? F_SETLKW64 : F_SETLK64, flock) != -1);
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	} finally {
	if (!success) {
	removeLock(pendingLock);
	}
	}
	return success ? pendingLock : null;
	}

	private static long translateLockLength(long byteCount) {
	// FileChannel uses Long.MAX_VALUE to mean "lock the whole file" where POSIX uses 0.
	return (byteCount == Long.MAX_VALUE) ? 0 : byteCount;
	}

	private static final class FileLockImpl extends FileLock {
	private boolean isReleased = false;

	public FileLockImpl(FileChannel channel, long position, long size, boolean shared) {
	super(channel, position, size, shared);
	}

	public boolean isValid() {
	return !isReleased && channel().isOpen();
	}

	public void release() throws IOException {
	if (!channel().isOpen()) {
	throw new ClosedChannelException();
	}
	if (!isReleased) {
	((FileChannelImpl) channel()).release(this);
	isReleased = true;
	}
	}
	}

	public final FileLock lock(long position, long size, boolean shared) throws IOException {
	checkOpen();
	FileLock resultLock = null;
	{
	boolean completed = false;
	try {
	begin();
	resultLock = basicLock(position, size, shared, true);
	completed = true;
	} finally {
	end(completed);
	}
	}
	return resultLock;
	}

	public final FileLock tryLock(long position, long size, boolean shared) throws IOException {
	checkOpen();
	return basicLock(position, size, shared, false);
	}

	/**
	* Non-API method to release a given lock on a file channel. Assumes that
	* the lock will mark itself invalid after successful unlocking.
	*/
	public void release(FileLock lock) throws IOException {
	checkOpen();

	StructFlock flock = new StructFlock();
	flock.l_type = (short) F_UNLCK;
	flock.l_whence = (short) SEEK_SET;
	flock.l_start = lock.position();
	flock.l_len = translateLockLength(lock.size());
	try {
	Libcore.os.fcntlFlock(fd, F_SETLKW64, flock);
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}

	removeLock(lock);
	}

	public void force(boolean metadata) throws IOException {
	checkOpen();
	if ((mode & O_ACCMODE) != O_RDONLY) {
	try {
	if (metadata) {
	Libcore.os.fsync(fd);
	} else {
	Libcore.os.fdatasync(fd);
	}
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	}
	}

	public final MappedByteBuffer map(MapMode mapMode, long position, long size) throws IOException {
	checkOpen();
	if (mapMode == null) {
	throw new NullPointerException("mapMode == null");
	}
	if (position < 0 \|\| size < 0 \|\| size > Integer.MAX_VALUE) {
	throw new IllegalArgumentException("position=" + position + " size=" + size);
	}
	int accessMode = (mode & O_ACCMODE);
	if (accessMode == O_RDONLY) {
	if (mapMode != MapMode.READ_ONLY) {
	throw new NonWritableChannelException();
	}
	} else if (accessMode == O_WRONLY) {
	throw new NonReadableChannelException();
	}
	if (position + size > size()) {
	// We can't defer to FileChannel.truncate because that will only make a file shorter,
	// and we only care about making our backing file longer here.
	try {
	Libcore.os.ftruncate(fd, position + size);
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	}
	long alignment = position - position % Libcore.os.sysconf(_SC_PAGE_SIZE);
	int offset = (int) (position - alignment);
	MemoryBlock block = MemoryBlock.mmap(fd, alignment, size + offset, mapMode);
	return new MappedByteBufferAdapter(block, (int) size, offset, mapMode);
	}

	public long position() throws IOException {
	checkOpen();
	try {
	return Libcore.os.lseek(fd, 0L, SEEK_CUR);
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	}

	public FileChannel position(long newPosition) throws IOException {
	checkOpen();
	if (newPosition < 0) {
	throw new IllegalArgumentException("position: " + newPosition);
	}
	try {
	Libcore.os.lseek(fd, newPosition, SEEK_SET);
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	return this;
	}

	public int read(ByteBuffer buffer, long position) throws IOException {
	if (position < 0) {
	throw new IllegalArgumentException("position: " + position);
	}
	return readImpl(buffer, position);
	}

	public int read(ByteBuffer buffer) throws IOException {
	return readImpl(buffer, -1);
	}

	private int readImpl(ByteBuffer buffer, long position) throws IOException {
	buffer.checkWritable();
	checkOpen();
	checkReadable();
	if (!buffer.hasRemaining()) {
	return 0;
	}
	int bytesRead = 0;
	boolean completed = false;
	try {
	begin();
	try {
	if (position == -1) {
	bytesRead = Libcore.os.read(fd, buffer);
	} else {
	bytesRead = Libcore.os.pread(fd, buffer, position);
	}
	if (bytesRead == 0) {
	bytesRead = -1;
	}
	} catch (ErrnoException errnoException) {
	if (errnoException.errno == EAGAIN) {
	// We don't throw if we try to read from an empty non-blocking pipe.
	bytesRead = 0;
	} else {
	throw errnoException.rethrowAsIOException();
	}
	}
	completed = true;
	} finally {
	end(completed && bytesRead >= 0);
	}
	if (bytesRead > 0) {
	buffer.position(buffer.position() + bytesRead);
	}
	return bytesRead;
	}

	private int transferIoVec(IoVec ioVec) throws IOException {
	if (ioVec.init() == 0) {
	return 0;
	}
	int bytesTransferred = 0;
	boolean completed = false;
	try {
	begin();
	bytesTransferred = ioVec.doTransfer(fd);
	completed = true;
	} finally {
	end(completed);
	}
	ioVec.didTransfer(bytesTransferred);
	return bytesTransferred;
	}

	public long read(ByteBuffer[] buffers, int offset, int length) throws IOException {
	Arrays.checkOffsetAndCount(buffers.length, offset, length);
	checkOpen();
	checkReadable();
	return transferIoVec(new IoVec(buffers, offset, length, IoVec.Direction.READV));
	}

	public long size() throws IOException {
	checkOpen();
	try {
	return Libcore.os.fstat(fd).st_size;
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	}

	public long transferFrom(ReadableByteChannel src, long position, long count) throws IOException {
	checkOpen();
	if (!src.isOpen()) {
	throw new ClosedChannelException();
	}
	checkWritable();
	if (position < 0 \|\| count < 0 \|\| count > Integer.MAX_VALUE) {
	throw new IllegalArgumentException("position=" + position + " count=" + count);
	}
	if (position > size()) {
	return 0;
	}

	// Although sendfile(2) originally supported writing to a regular file.
	// In Linux 2.6 and later, it only supports writing to sockets.

	// If our source is a regular file, mmap(2) rather than reading.
	// Callers should only be using transferFrom for large transfers,
	// so the mmap(2) overhead isn't a concern.
	if (src instanceof FileChannel) {
	FileChannel fileSrc = (FileChannel) src;
	long size = fileSrc.size();
	long filePosition = fileSrc.position();
	count = Math.min(count, size - filePosition);
	ByteBuffer buffer = fileSrc.map(MapMode.READ_ONLY, filePosition, count);
	try {
	fileSrc.position(filePosition + count);
	return write(buffer, position);
	} finally {
	NioUtils.freeDirectBuffer(buffer);
	}
	}

	// For non-file channels, all we can do is read and write via userspace.
	ByteBuffer buffer = ByteBuffer.allocate((int) count);
	src.read(buffer);
	buffer.flip();
	return write(buffer, position);
	}

	public long transferTo(long position, long count, WritableByteChannel target) throws IOException {
	checkOpen();
	if (!target.isOpen()) {
	throw new ClosedChannelException();
	}
	checkReadable();
	if (target instanceof FileChannelImpl) {
	((FileChannelImpl) target).checkWritable();
	}
	if (position < 0 \|\| count < 0) {
	throw new IllegalArgumentException("position=" + position + " count=" + count);
	}

	if (count == 0 \|\| position >= size()) {
	return 0;
	}
	count = Math.min(count, size() - position);

	// Try sendfile(2) first...
	boolean completed = false;
	if (target instanceof SocketChannelImpl) {
	FileDescriptor outFd = ((SocketChannelImpl) target).getFD();
	try {
	begin();
	try {
	MutableLong offset = new MutableLong(position);
	long rc = Libcore.os.sendfile(outFd, fd, offset, count);
	completed = true;
	return rc;
	} catch (ErrnoException errnoException) {
	// If the OS doesn't support what we asked for, we want to fall through and
	// try a different approach. If it does support it, but it failed, we're done.
	if (errnoException.errno != ENOSYS && errnoException.errno != EINVAL) {
	throw errnoException.rethrowAsIOException();
	}
	}
	} finally {
	end(completed);
	}
	}
	// ...fall back to write(2).
	ByteBuffer buffer = null;
	try {
	buffer = map(MapMode.READ_ONLY, position, count);
	return target.write(buffer);
	} finally {
	NioUtils.freeDirectBuffer(buffer);
	}
	}

	public FileChannel truncate(long size) throws IOException {
	checkOpen();
	if (size < 0) {
	throw new IllegalArgumentException("size: " + size);
	}
	checkWritable();
	if (size < size()) {
	try {
	Libcore.os.ftruncate(fd, size);
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	}
	return this;
	}

	public int write(ByteBuffer buffer, long position) throws IOException {
	if (position < 0) {
	throw new IllegalArgumentException("position: " + position);
	}
	return writeImpl(buffer, position);
	}

	public int write(ByteBuffer buffer) throws IOException {
	return writeImpl(buffer, -1);
	}

	private int writeImpl(ByteBuffer buffer, long position) throws IOException {
	checkOpen();
	checkWritable();
	if (buffer == null) {
	throw new NullPointerException("buffer == null");
	}
	if (!buffer.hasRemaining()) {
	return 0;
	}
	int bytesWritten = 0;
	boolean completed = false;
	try {
	begin();
	try {
	if (position == -1) {
	bytesWritten = Libcore.os.write(fd, buffer);
	} else {
	bytesWritten = Libcore.os.pwrite(fd, buffer, position);
	}
	} catch (ErrnoException errnoException) {
	throw errnoException.rethrowAsIOException();
	}
	completed = true;
	} finally {
	end(completed);
	}
	if (bytesWritten > 0) {
	buffer.position(buffer.position() + bytesWritten);
	}
	return bytesWritten;
	}

	public long write(ByteBuffer[] buffers, int offset, int length) throws IOException {
	Arrays.checkOffsetAndCount(buffers.length, offset, length);
	checkOpen();
	checkWritable();
	return transferIoVec(new IoVec(buffers, offset, length, IoVec.Direction.WRITEV));
	}

	/**
	* @param copyingIn true if we're copying data into the buffers (typically
	* because the caller is a file/network read operation), false if we're
	* copying data out of the buffers (for a file/network write operation).
	*/
	static int calculateTotalRemaining(ByteBuffer[] buffers, int offset, int length, boolean copyingIn) {
	int count = 0;
	for (int i = offset; i < offset + length; ++i) {
	count += buffers[i].remaining();
	if (copyingIn) {
	buffers[i].checkWritable();
	}
	}
	return count;
	}

	public FileDescriptor getFD() {
	return fd;
	}

	/**
	* Add a new pending lock to the manager. Throws an exception if the lock
	* would overlap an existing lock. Once the lock is acquired it remains in
	* this set as an acquired lock.
	*/
	private synchronized void addLock(FileLock lock) throws OverlappingFileLockException {
	long lockEnd = lock.position() + lock.size();
	for (FileLock existingLock : locks) {
	if (existingLock.position() > lockEnd) {
	// This, and all remaining locks, start beyond our end (so
	// cannot overlap).
	break;
	}
	if (existingLock.overlaps(lock.position(), lock.size())) {
	throw new OverlappingFileLockException();
	}
	}
	locks.add(lock);
	}

	/**
	* Removes an acquired lock from the lock manager. If the lock did not exist
	* in the lock manager the operation is a no-op.
	*/
	private synchronized void removeLock(FileLock lock) {
	locks.remove(lock);
	}
	}