/*

 * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package sun.nio.ch;

import java.io.FileDescriptor;

import java.io.IOException;

import java.io.UncheckedIOException;

import java.lang.ref.Cleaner.Cleanable;

import java.nio.ByteBuffer;

import java.nio.MappedByteBuffer;

import java.nio.channels.AsynchronousCloseException;

import java.nio.channels.ClosedByInterruptException;

import java.nio.channels.ClosedChannelException;

import java.nio.channels.FileChannel;

import java.nio.channels.FileLock;

import java.nio.channels.FileLockInterruptionException;

import java.nio.channels.NonReadableChannelException;

import java.nio.channels.NonWritableChannelException;

import java.nio.channels.ReadableByteChannel;

import java.nio.channels.SelectableChannel;

import java.nio.channels.WritableByteChannel;

import jdk.internal.access.JavaIOFileDescriptorAccess;

import jdk.internal.access.JavaNioAccess;

import jdk.internal.access.SharedSecrets;

import jdk.internal.misc.ExtendedMapMode;

import jdk.internal.misc.Unsafe;

import jdk.internal.ref.Cleaner;

import jdk.internal.ref.CleanerFactory;

public class FileChannelImpl

    extends FileChannel

{

    // Memory allocation size for mapping buffers

    private static final long allocationGranularity;

    // Access to FileDescriptor internals

    private static final JavaIOFileDescriptorAccess fdAccess =

        SharedSecrets.getJavaIOFileDescriptorAccess();

    // Used to make native read and write calls

    private final FileDispatcher nd;

    // File descriptor

    private final FileDescriptor fd;

    // File access mode (immutable)

    private final boolean writable;

    private final boolean readable;

    // Required to prevent finalization of creating stream (immutable)

    private final Object parent;

    // The path of the referenced file

    // (null if the parent stream is created with a file descriptor)

    private final String path;

    // Thread-safe set of IDs of native threads, for signalling

    private final NativeThreadSet threads = new NativeThreadSet(2);

    // Lock for operations involving position and size

    private final Object positionLock = new Object();

    // blocking operations are not interruptible

    private volatile boolean uninterruptible;

    // DirectIO flag

    private final boolean direct;

    // IO alignment value for DirectIO

    private final int alignment;

    // Cleanable with an action which closes this channel's file descriptor

    private final Cleanable closer;

    private static class Closer implements Runnable {

        private final FileDescriptor fd;

        Closer(FileDescriptor fd) {

            this.fd = fd;

        }

        public void run() {

            try {

                fdAccess.close(fd);

            } catch (IOException ioe) {

                // Rethrow as unchecked so the exception can be propagated as needed

                throw new UncheckedIOException("close", ioe);

            }

        }

    }

    private FileChannelImpl(FileDescriptor fd, String path, boolean readable,

                            boolean writable, boolean direct, Object parent)

    {

        this.fd = fd;

        this.readable = readable;

        this.writable = writable;

        this.parent = parent;

        this.path = path;

        this.direct = direct;

        this.nd = new FileDispatcherImpl();

        if (direct) {

            assert path != null;

            this.alignment = nd.setDirectIO(fd, path);

        } else {

            this.alignment = -1;

        }

        // Register a cleaning action if and only if there is no parent

        // as the parent will take care of closing the file descriptor.

        // FileChannel is used by the LambdaMetaFactory so a lambda cannot

        // be used here hence we use a nested class instead.

        this.closer = parent != null ? null :

            CleanerFactory.cleaner().register(this, new Closer(fd));

    }

    // Used by FileInputStream.getChannel(), FileOutputStream.getChannel

    // and RandomAccessFile.getChannel()

    public static FileChannel open(FileDescriptor fd, String path,

                                   boolean readable, boolean writable,

                                   boolean direct, Object parent)

    {

        return new FileChannelImpl(fd, path, readable, writable, direct, parent);

    }

    private void ensureOpen() throws IOException {

        if (!isOpen())

            throw new ClosedChannelException();

    }

    public void setUninterruptible() {

        uninterruptible = true;

    }

    private void beginBlocking() {

        if (!uninterruptible) begin();

    }

    private void endBlocking(boolean completed) throws AsynchronousCloseException {

        if (!uninterruptible) end(completed);

    }

    // -- Standard channel operations --

    protected void implCloseChannel() throws IOException {

        if (!fd.valid())

            return; // nothing to do

        // Release and invalidate any locks that we still hold

        if (fileLockTable != null) {

            for (FileLock fl: fileLockTable.removeAll()) {

                synchronized (fl) {

                    if (fl.isValid()) {

                        nd.release(fd, fl.position(), fl.size());

                        ((FileLockImpl)fl).invalidate();

                    }

                }

            }

        }

        // signal any threads blocked on this channel

        threads.signalAndWait();

        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 if (closer != null) {

            // Perform the cleaning action so it is not redone when

            // this channel becomes phantom reachable.

            try {

                closer.clean();

            } catch (UncheckedIOException uioe) {

                throw uioe.getCause();

            }

        } else {

            fdAccess.close(fd);

        }

    }

    public int read(ByteBuffer dst) throws IOException {

        ensureOpen();

        if (!readable)

            throw new NonReadableChannelException();

        synchronized (positionLock) {

            if (direct)

                Util.checkChannelPositionAligned(position(), alignment);

            int n = 0;

            int ti = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.read(fd, dst, -1, direct, alignment, nd);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                endBlocking(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();

        ensureOpen();

        if (!readable)

            throw new NonReadableChannelException();

        synchronized (positionLock) {

            if (direct)

                Util.checkChannelPositionAligned(position(), alignment);

            long n = 0;

            int ti = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.read(fd, dsts, offset, length,

                            direct, alignment, nd);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                endBlocking(n > 0);

                assert IOStatus.check(n);

            }

        }

    }

    public int write(ByteBuffer src) throws IOException {

        ensureOpen();

        if (!writable)

            throw new NonWritableChannelException();

        synchronized (positionLock) {

            if (direct)

                Util.checkChannelPositionAligned(position(), alignment);

            int n = 0;

            int ti = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.write(fd, src, -1, direct, alignment, nd);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                endBlocking(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();

        ensureOpen();

        if (!writable)

            throw new NonWritableChannelException();

        synchronized (positionLock) {

            if (direct)

                Util.checkChannelPositionAligned(position(), alignment);

            long n = 0;

            int ti = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return 0;

                do {

                    n = IOUtil.write(fd, srcs, offset, length,

                            direct, alignment, nd);

                } while ((n == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(n);

            } finally {

                threads.remove(ti);

                endBlocking(n > 0);

                assert IOStatus.check(n);

            }

        }

    }

    // -- Other operations --

    public long position() throws IOException {

        ensureOpen();

        synchronized (positionLock) {

            long p = -1;

            int ti = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return 0;

                boolean append = fdAccess.getAppend(fd);

                do {

                    // in append-mode then position is advanced to end before writing

                    p = (append) ? nd.size(fd) : nd.seek(fd, -1);

                } while ((p == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(p);

            } finally {

                threads.remove(ti);

                endBlocking(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 {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return null;

                do {

                    p = nd.seek(fd, newPosition);

                } while ((p == IOStatus.INTERRUPTED) && isOpen());

                return this;

            } finally {

                threads.remove(ti);

                endBlocking(p > -1);

                assert IOStatus.check(p);

            }

        }

    }

    public long size() throws IOException {

        ensureOpen();

        synchronized (positionLock) {

            long s = -1;

            int ti = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return -1;

                do {

                    s = nd.size(fd);

                } while ((s == IOStatus.INTERRUPTED) && isOpen());

                return IOStatus.normalize(s);

            } finally {

                threads.remove(ti);

                endBlocking(s > -1);

                assert IOStatus.check(s);

            }

        }

    }

    public FileChannel truncate(long newSize) throws IOException {

        ensureOpen();

        if (newSize < 0)

            throw new IllegalArgumentException("Negative size");

        if (!writable)

            throw new NonWritableChannelException();

        synchronized (positionLock) {

            int rv = -1;

            long p = -1;

            int ti = -1;

            long rp = -1;

            try {

                beginBlocking();

                ti = threads.add();

                if (!isOpen())

                    return null;

                // get current size

                long size;

                do {

                    size = nd.size(fd);

                } while ((size == IOStatus.INTERRUPTED) && isOpen());

                if (!isOpen())

                    return null;

                // get current position

                do {

                    p = nd.seek(fd, -1);

                } while ((p == IOStatus.INTERRUPTED) && isOpen());

                if (!isOpen())

                    return null;

                assert p >= 0;

                // truncate file if given size is less than the current size

                if (newSize < size) {

                    do {

                        rv = nd.truncate(fd, newSize);

                    } while ((rv == IOStatus.INTERRUPTED) && isOpen());

                    if (!isOpen())

                        return null;

                }

                // if position is beyond new size then adjust it

                if (p > newSize)

                    p = newSize;

                do {

                    rp = nd.seek(fd, p);

                } while ((rp == IOStatus.INTERRUPTED) && isOpen());

                return this;

            } finally {

                threads.remove(ti);

                endBlocking(rv > -1);

                assert IOStatus.check(rv);

            }

        }

    }

    public void force(boolean metaData) throws IOException {

        ensureOpen();

        int rv = -1;

        int ti = -1;

        try {

            beginBlocking();

            ti = threads.add();

            if (!isOpen())

                return;

            do {

                rv = nd.force(fd, metaData);

            } while ((rv == IOStatus.INTERRUPTED) && isOpen());

        } finally {

            threads.remove(ti);

            endBlocking(rv > -1);

            assert IOStatus.check(rv);

        }

    }

    // Assume at first that the underlying kernel supports sendfile();

    // set this to false if we find out later that it doesn't

    //

    private static volatile boolean transferSupported = true;

    // Assume that the underlying kernel sendfile() will work if the target

    // fd is a pipe; set this to false if we find out later that it doesn't

    //

    private static volatile boolean pipeSupported = true;

    // Assume that the underlying kernel sendfile() will work if the target

    // fd is a file; set this to false if we find out later that it doesn't

    //

    private static volatile boolean fileSupported = true;

    private long transferToDirectlyInternal(long position, int icount,

                                            WritableByteChannel target,

                                            FileDescriptor targetFD)

        throws IOException

    {

        assert !nd.transferToDirectlyNeedsPositionLock() ||

               Thread.holdsLock(positionLock);

        long n = -1;

        int ti = -1;

        try {

            beginBlocking();

            ti = threads.add();

            if (!isOpen())