ModelService: Cannot add model because it already exists!

[l0ca1]

Environment

• Operating System:mac
• JDK version:8u191
• Visual Studio Code version:1.43.0
• Java extension version:letast

Steps To Reproduce

1. Use the Call Hierarchy
   

2. Double click to view
   

4.dependencise all file can't open,error:"JSON.class”: ModelService: Cannot add model because it already exists!。"

[fbricon]

The Java Dependencies view is provided by a 3rd party extension,, so I'm not sure this is a vscode-java issue. Can you please provide the server logs to see who's misbehaving?

[github-actions]

This issue has been closed automatically because it needs more information and has not had recent activity. Please reach out if you have or find the answers we need so that we can investigate further.

[jul1u5]

The same happens to me when I try to look up FileChannelImpl through Go to Symbol in Workspace....

Here are the logs:

[Trace - 2:07:10 PM] Sending request 'workspace/executeCommand - (192)'.
Params: {
    "command": "java.project.resolveWorkspaceSymbol",
    "arguments": [
        "{\"name\":\"FileChannelImpl\",\"kind\":\"Class\",\"location\":{\"uri\":\"jdt://contents/java.base/sun.nio.ch/FileChannelImpl.class?%3Djdt.ls-java-project%2F%5C%2Fnix%5C%2Fstore%5C%2Frd5mwiwjrdqig62czw3n7c088znxa0im-zulu19.30.11-ca-jdk-19.0.1%5C%2Fzulu-19.jdk%5C%2FContents%5C%2FHome%5C%2Flib%5C%2Fjrt-fs.jar%60java.base%3D%2Fjavadoc_location%3D%2Fhttps%3A%5C%2F%5C%2Fdocs.oracle.com%5C%2Fen%5C%2Fjava%5C%2Fjavase%5C%2F19%5C%2Fdocs%5C%2Fapi%5C%2F%3D%2F%3Csun.nio.ch%28FileChannelImpl.class\",\"range\":{\"start\":{\"line\":0,\"character\":0},\"end\":{\"line\":0,\"character\":0}}},\"containerName\":\"sun.nio.ch\"}"
    ]
}


[Trace - 2:07:10 PM] Received response 'workspace/executeCommand - (192)' in 3ms.
Result: {
    "name": "FileChannelImpl",
    "kind": 5,
    "location": {
        "uri": "jdt://contents/java.base/sun.nio.ch/FileChannelImpl.class?=jdt.ls-java-project/%5C/nix%5C/store%5C/rd5mwiwjrdqig62czw3n7c088znxa0im-zulu19.30.11-ca-jdk-19.0.1%5C/zulu-19.jdk%5C/Contents%5C/Home%5C/lib%5C/jrt-fs.jar%60java.base=/javadoc_location=/https:%5C/%5C/docs.oracle.com%5C/en%5C/java%5C/javase%5C/19%5C/docs%5C/api%5C/=/%3Csun.nio.ch(FileChannelImpl.class",
        "range": {
            "start": {
                "line": 63,
                "character": 13
            },
            "end": {
                "line": 63,
                "character": 28
            }
        }
    },
    "containerName": "sun.nio.ch"
}


[Trace - 2:07:10 PM] Sending request 'java/classFileContents - (193)'.
Params: {
    "uri": "jdt://contents/java.base/sun.nio.ch/FileChannelImpl.class?%3Djdt.ls-java-project%2F%5C%2Fnix%5C%2Fstore%5C%2Frd5mwiwjrdqig62czw3n7c088znxa0im-zulu19.30.11-ca-jdk-19.0.1%5C%2Fzulu-19.jdk%5C%2FContents%5C%2FHome%5C%2Flib%5C%2Fjrt-fs.jar%60java.base%3D%2Fjavadoc_location%3D%2Fhttps%3A%5C%2F%5C%2Fdocs.oracle.com%5C%2Fen%5C%2Fjava%5C%2Fjavase%5C%2F19%5C%2Fdocs%5C%2Fapi%5C%2F%3D%2F%3Csun.nio.ch%28FileChannelImpl.class"
}


[Trace - 2:07:10 PM] Received response 'java/classFileContents - (193)' in 3ms.
Result: "/*\n * Copyright (c) 2000, 2022, Oracle and/or its affiliates. All rights reserved.\n * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.\n *\n * This code is free software; you can redistribute it and/or modify it\n * under the terms of the GNU General Public License version 2 only, as\n * published by the Free Software Foundation.  Oracle designates this\n * particular file as subject to the \"Classpath\" exception as provided\n * by Oracle in the LICENSE file that accompanied this code.\n *\n * This code is distributed in the hope that it will be useful, but WITHOUT\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\n * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\n * version 2 for more details (a copy is included in the LICENSE file that\n * accompanied this code).\n *\n * You should have received a copy of the GNU General Public License version\n * 2 along with this work; if not, write to the Free Software Foundation,\n * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.\n *\n * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA\n * or visit www.oracle.com if you need additional information or have any\n * questions.\n */\n\npackage sun.nio.ch;\n\nimport java.io.FileDescriptor;\nimport java.io.IOException;\nimport java.io.UncheckedIOException;\nimport java.lang.foreign.MemorySegment;\nimport java.lang.foreign.MemorySession;\nimport java.lang.ref.Cleaner.Cleanable;\nimport java.nio.ByteBuffer;\nimport java.nio.MappedByteBuffer;\nimport java.nio.channels.AsynchronousCloseException;\nimport java.nio.channels.ClosedByInterruptException;\nimport java.nio.channels.ClosedChannelException;\nimport java.nio.channels.FileChannel;\nimport java.nio.channels.FileLock;\nimport java.nio.channels.FileLockInterruptionException;\nimport java.nio.channels.NonReadableChannelException;\nimport java.nio.channels.NonWritableChannelException;\nimport java.nio.channels.ReadableByteChannel;\nimport java.nio.channels.SelectableChannel;\nimport java.nio.channels.WritableByteChannel;\nimport java.util.Objects;\n\nimport jdk.internal.access.JavaIOFileDescriptorAccess;\nimport jdk.internal.access.SharedSecrets;\nimport jdk.internal.foreign.AbstractMemorySegmentImpl;\nimport jdk.internal.foreign.MappedMemorySegmentImpl;\nimport jdk.internal.foreign.MemorySessionImpl;\nimport jdk.internal.misc.Blocker;\nimport jdk.internal.misc.ExtendedMapMode;\nimport jdk.internal.misc.Unsafe;\nimport jdk.internal.misc.VM;\nimport jdk.internal.misc.VM.BufferPool;\nimport jdk.internal.ref.Cleaner;\nimport jdk.internal.ref.CleanerFactory;\n\nimport jdk.internal.access.foreign.UnmapperProxy;\n\npublic class FileChannelImpl\n    extends FileChannel\n{\n    // Memory allocation size for mapping buffers\n    private static final long allocationGranularity;\n\n    // Access to FileDescriptor internals\n    private static final JavaIOFileDescriptorAccess fdAccess =\n        SharedSecrets.getJavaIOFileDescriptorAccess();\n\n    // Maximum direct transfer size\n    private static final int MAX_DIRECT_TRANSFER_SIZE;\n\n    // Used to make native read and write calls\n    private final FileDispatcher nd;\n\n    // File descriptor\n    private final FileDescriptor fd;\n\n    // File access mode (immutable)\n    private final boolean writable;\n    private final boolean readable;\n\n    // Required to prevent finalization of creating stream (immutable)\n    private final Object parent;\n\n    // The path of the referenced file\n    // (null if the parent stream is created with a file descriptor)\n    private final String path;\n\n    // Thread-safe set of IDs of native threads, for signalling\n    private final NativeThreadSet threads = new NativeThreadSet(2);\n\n    // Lock for operations involving position and size\n    private final Object positionLock = new Object();\n\n    // blocking operations are not interruptible\n    private volatile boolean uninterruptible;\n\n    // DirectIO flag\n    private final boolean direct;\n\n    // IO alignment value for DirectIO\n    private final int alignment;\n\n    // Cleanable with an action which closes this channel's file descriptor\n    private final Cleanable closer;\n\n    private static class Closer implements Runnable {\n        private final FileDescriptor fd;\n\n        Closer(FileDescriptor fd) {\n            this.fd = fd;\n        }\n\n        public void run() {\n            try {\n                fdAccess.close(fd);\n            } catch (IOException ioe) {\n                // Rethrow as unchecked so the exception can be propagated as needed\n                throw new UncheckedIOException(\"close\", ioe);\n            }\n        }\n    }\n\n    private FileChannelImpl(FileDescriptor fd, String path, boolean readable,\n                            boolean writable, boolean direct, Object parent)\n    {\n        this.fd = fd;\n        this.readable = readable;\n        this.writable = writable;\n        this.parent = parent;\n        this.path = path;\n        this.direct = direct;\n        this.nd = new FileDispatcherImpl();\n        if (direct) {\n            assert path != null;\n            this.alignment = nd.setDirectIO(fd, path);\n        } else {\n            this.alignment = -1;\n        }\n\n        // Register a cleaning action if and only if there is no parent\n        // as the parent will take care of closing the file descriptor.\n        // FileChannel is used by the LambdaMetaFactory so a lambda cannot\n        // be used here hence we use a nested class instead.\n        this.closer = parent != null ? null :\n            CleanerFactory.cleaner().register(this, new Closer(fd));\n    }\n\n    // Used by FileInputStream.getChannel(), FileOutputStream.getChannel\n    // and RandomAccessFile.getChannel()\n    public static FileChannel open(FileDescriptor fd, String path,\n                                   boolean readable, boolean writable,\n                                   boolean direct, Object parent)\n    {\n        return new FileChannelImpl(fd, path, readable, writable, direct, parent);\n    }\n\n    private void ensureOpen() throws IOException {\n        if (!isOpen())\n            throw new ClosedChannelException();\n    }\n\n    public void setUninterruptible() {\n        uninterruptible = true;\n    }\n\n    private void beginBlocking() {\n        if (!uninterruptible) begin();\n    }\n\n    private void endBlocking(boolean completed) throws AsynchronousCloseException {\n        if (!uninterruptible) end(completed);\n    }\n\n    // -- Standard channel operations --\n\n    protected void implCloseChannel() throws IOException {\n        if (!fd.valid())\n            return; // nothing to do\n\n        // Release and invalidate any locks that we still hold\n        if (fileLockTable != null) {\n            for (FileLock fl: fileLockTable.removeAll()) {\n                synchronized (fl) {\n                    if (fl.isValid()) {\n                        nd.release(fd, fl.position(), fl.size());\n                        ((FileLockImpl)fl).invalidate();\n                    }\n                }\n            }\n        }\n\n        // signal any threads blocked on this channel\n        threads.signalAndWait();\n\n        if (parent != null) {\n\n            // Close the fd via the parent stream's close method.  The parent\n            // will reinvoke our close method, which is defined in the\n            // superclass AbstractInterruptibleChannel, but the isOpen logic in\n            // that method will prevent this method from being reinvoked.\n            //\n            ((java.io.Closeable)parent).close();\n        } else if (closer != null) {\n            // Perform the cleaning action so it is not redone when\n            // this channel becomes phantom reachable.\n            try {\n                closer.clean();\n            } catch (UncheckedIOException uioe) {\n                throw uioe.getCause();\n            }\n        } else {\n            fdAccess.close(fd);\n        }\n\n    }\n\n    public int read(ByteBuffer dst) throws IOException {\n        ensureOpen();\n        if (!readable)\n            throw new NonReadableChannelException();\n        synchronized (positionLock) {\n            if (direct)\n                Util.checkChannelPositionAligned(position(), alignment);\n            int n = 0;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return 0;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        n = IOUtil.read(fd, dst, -1, direct, alignment, nd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((n == IOStatus.INTERRUPTED) && isOpen());\n                return IOStatus.normalize(n);\n            } finally {\n                threads.remove(ti);\n                endBlocking(n > 0);\n                assert IOStatus.check(n);\n            }\n        }\n    }\n\n    public long read(ByteBuffer[] dsts, int offset, int length)\n        throws IOException\n    {\n        Objects.checkFromIndexSize(offset, length, dsts.length);\n        ensureOpen();\n        if (!readable)\n            throw new NonReadableChannelException();\n        synchronized (positionLock) {\n            if (direct)\n                Util.checkChannelPositionAligned(position(), alignment);\n            long n = 0;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return 0;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        n = IOUtil.read(fd, dsts, offset, length, direct, alignment, nd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n\n                } while ((n == IOStatus.INTERRUPTED) && isOpen());\n                return IOStatus.normalize(n);\n            } finally {\n                threads.remove(ti);\n                endBlocking(n > 0);\n                assert IOStatus.check(n);\n            }\n        }\n    }\n\n    public int write(ByteBuffer src) throws IOException {\n        ensureOpen();\n        if (!writable)\n            throw new NonWritableChannelException();\n        synchronized (positionLock) {\n            if (direct)\n                Util.checkChannelPositionAligned(position(), alignment);\n            int n = 0;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return 0;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        n = IOUtil.write(fd, src, -1, direct, alignment, nd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n\n                } while ((n == IOStatus.INTERRUPTED) && isOpen());\n                return IOStatus.normalize(n);\n            } finally {\n                threads.remove(ti);\n                endBlocking(n > 0);\n                assert IOStatus.check(n);\n            }\n        }\n    }\n\n    public long write(ByteBuffer[] srcs, int offset, int length)\n        throws IOException\n    {\n        Objects.checkFromIndexSize(offset, length, srcs.length);\n        ensureOpen();\n        if (!writable)\n            throw new NonWritableChannelException();\n        synchronized (positionLock) {\n            if (direct)\n                Util.checkChannelPositionAligned(position(), alignment);\n            long n = 0;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return 0;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        n = IOUtil.write(fd, srcs, offset, length, direct, alignment, nd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((n == IOStatus.INTERRUPTED) && isOpen());\n                return IOStatus.normalize(n);\n            } finally {\n                threads.remove(ti);\n                endBlocking(n > 0);\n                assert IOStatus.check(n);\n            }\n        }\n    }\n\n    // -- Other operations --\n\n    public long position() throws IOException {\n        ensureOpen();\n        synchronized (positionLock) {\n            long p = -1;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return 0;\n                boolean append = fdAccess.getAppend(fd);\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        // in append-mode then position is advanced to end before writing\n                        p = (append) ? nd.size(fd) : nd.seek(fd, -1);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((p == IOStatus.INTERRUPTED) && isOpen());\n                return IOStatus.normalize(p);\n            } finally {\n                threads.remove(ti);\n                endBlocking(p > -1);\n                assert IOStatus.check(p);\n            }\n        }\n    }\n\n    public FileChannel position(long newPosition) throws IOException {\n        ensureOpen();\n        if (newPosition < 0)\n            throw new IllegalArgumentException();\n        synchronized (positionLock) {\n            long p = -1;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return null;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        p = nd.seek(fd, newPosition);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((p == IOStatus.INTERRUPTED) && isOpen());\n                return this;\n            } finally {\n                threads.remove(ti);\n                endBlocking(p > -1);\n                assert IOStatus.check(p);\n            }\n        }\n    }\n\n    public long size() throws IOException {\n        ensureOpen();\n        synchronized (positionLock) {\n            long s = -1;\n            int ti = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return -1;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        s = nd.size(fd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((s == IOStatus.INTERRUPTED) && isOpen());\n                return IOStatus.normalize(s);\n            } finally {\n                threads.remove(ti);\n                endBlocking(s > -1);\n                assert IOStatus.check(s);\n            }\n        }\n    }\n\n    public FileChannel truncate(long newSize) throws IOException {\n        ensureOpen();\n        if (newSize < 0)\n            throw new IllegalArgumentException(\"Negative size\");\n        if (!writable)\n            throw new NonWritableChannelException();\n        synchronized (positionLock) {\n            int rv = -1;\n            long p = -1;\n            int ti = -1;\n            long rp = -1;\n            try {\n                beginBlocking();\n                ti = threads.add();\n                if (!isOpen())\n                    return null;\n\n                // get current size\n                long size;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        size = nd.size(fd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((size == IOStatus.INTERRUPTED) && isOpen());\n                if (!isOpen())\n                    return null;\n\n                // get current position\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        p = nd.seek(fd, -1);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((p == IOStatus.INTERRUPTED) && isOpen());\n                if (!isOpen())\n                    return null;\n                assert p >= 0;\n\n                // truncate file if given size is less than the current size\n                if (newSize < size) {\n                    do {\n                        long comp = Blocker.begin();\n                        try {\n                            rv = nd.truncate(fd, newSize);\n                        } finally {\n                            Blocker.end(comp);\n                        }\n                    } while ((rv == IOStatus.INTERRUPTED) && isOpen());\n                    if (!isOpen())\n                        return null;\n                }\n\n                // if position is beyond new size then adjust it\n                if (p > newSize)\n                    p = newSize;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        rp = nd.seek(fd, p);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((rp == IOStatus.INTERRUPTED) && isOpen());\n                return this;\n            } finally {\n                threads.remove(ti);\n                endBlocking(rv > -1);\n                assert IOStatus.check(rv);\n            }\n        }\n    }\n\n    public void force(boolean metaData) throws IOException {\n        ensureOpen();\n        int rv = -1;\n        int ti = -1;\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return;\n            do {\n                long comp = Blocker.begin();\n                try {\n                    rv = nd.force(fd, metaData);\n                } finally {\n                    Blocker.end(comp);\n                }\n            } while ((rv == IOStatus.INTERRUPTED) && isOpen());\n        } finally {\n            threads.remove(ti);\n            endBlocking(rv > -1);\n            assert IOStatus.check(rv);\n        }\n    }\n\n    // Assume at first that the underlying kernel supports sendfile();\n    // set this to true if we find out later that it doesn't\n    //\n    private static volatile boolean transferToNotSupported;\n\n    // Assume that the underlying kernel sendfile() will work if the target\n    // fd is a pipe; set this to false if we find out later that it doesn't\n    //\n    private static volatile boolean pipeSupported = true;\n\n    // Assume that the underlying kernel sendfile() will work if the target\n    // fd is a file; set this to false if we find out later that it doesn't\n    //\n    private static volatile boolean fileSupported = true;\n\n    private long transferToDirectlyInternal(long position, int icount,\n                                            WritableByteChannel target,\n                                            FileDescriptor targetFD)\n        throws IOException\n    {\n        assert !nd.transferToDirectlyNeedsPositionLock() ||\n               Thread.holdsLock(positionLock);\n\n        long n = -1;\n        int ti = -1;\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return -1;\n            do {\n                long comp = Blocker.begin();\n                try {\n                    n = transferTo0(fd, position, icount, targetFD);\n                } finally {\n                    Blocker.end(comp);\n                }\n            } while ((n == IOStatus.INTERRUPTED) && isOpen());\n            if (n == IOStatus.UNSUPPORTED_CASE) {\n                if (target instanceof SinkChannelImpl)\n                    pipeSupported = false;\n                if (target instanceof FileChannelImpl)\n                    fileSupported = false;\n                return IOStatus.UNSUPPORTED_CASE;\n            }\n            if (n == IOStatus.UNSUPPORTED) {\n                // Don't bother trying again\n                transferToNotSupported = true;\n                return IOStatus.UNSUPPORTED;\n            }\n            return IOStatus.normalize(n);\n        } finally {\n            threads.remove(ti);\n            end (n > -1);\n        }\n    }\n\n    private long transferToDirectly(long position, int icount,\n                                    WritableByteChannel target)\n        throws IOException\n    {\n        if (transferToNotSupported)\n            return IOStatus.UNSUPPORTED;\n\n        FileDescriptor targetFD = null;\n        if (target instanceof FileChannelImpl) {\n            if (!fileSupported)\n                return IOStatus.UNSUPPORTED_CASE;\n            targetFD = ((FileChannelImpl)target).fd;\n        } else if (target instanceof SelChImpl) {\n            // Direct transfer to pipe causes EINVAL on some configurations\n            if ((target instanceof SinkChannelImpl) && !pipeSupported)\n                return IOStatus.UNSUPPORTED_CASE;\n\n            // Platform-specific restrictions. Now there is only one:\n            // Direct transfer to non-blocking channel could be forbidden\n            SelectableChannel sc = (SelectableChannel)target;\n            if (!nd.canTransferToDirectly(sc))\n                return IOStatus.UNSUPPORTED_CASE;\n\n            targetFD = ((SelChImpl)target).getFD();\n        }\n\n        if (targetFD == null)\n            return IOStatus.UNSUPPORTED;\n        int thisFDVal = IOUtil.fdVal(fd);\n        int targetFDVal = IOUtil.fdVal(targetFD);\n        if (thisFDVal == targetFDVal) // Not supported on some configurations\n            return IOStatus.UNSUPPORTED;\n\n        if (nd.transferToDirectlyNeedsPositionLock()) {\n            synchronized (positionLock) {\n                long pos = position();\n                try {\n                    return transferToDirectlyInternal(position, icount,\n                                                      target, targetFD);\n                } finally {\n                    position(pos);\n                }\n            }\n        } else {\n            return transferToDirectlyInternal(position, icount, target, targetFD);\n        }\n    }\n\n    // Size threshold above which to use a mapped buffer;\n    // transferToArbitraryChannel() and transferFromArbitraryChannel()\n    // are faster for smaller transfers\n    private static final long MAPPED_TRANSFER_THRESHOLD = 16L*1024L;\n\n    // Maximum size to map when using a mapped buffer\n    private static final long MAPPED_TRANSFER_SIZE = 8L*1024L*1024L;\n\n    private long transferToTrustedChannel(long position, long count,\n                                          WritableByteChannel target)\n        throws IOException\n    {\n        if (count < MAPPED_TRANSFER_THRESHOLD)\n            return IOStatus.UNSUPPORTED_CASE;\n\n        boolean isSelChImpl = (target instanceof SelChImpl);\n        if (!((target instanceof FileChannelImpl) || isSelChImpl))\n            return IOStatus.UNSUPPORTED;\n\n        if (target == this) {\n            long posThis = position();\n            if (posThis - count + 1 <= position &&\n                position - count + 1 <= posThis &&\n                !nd.canTransferToFromOverlappedMap()) {\n                return IOStatus.UNSUPPORTED_CASE;\n            }\n        }\n\n        // Trusted target: Use a mapped buffer\n        long remaining = count;\n        while (remaining > 0L) {\n            long size = Math.min(remaining, MAPPED_TRANSFER_SIZE);\n            try {\n                MappedByteBuffer dbb = map(MapMode.READ_ONLY, position, size);\n                try {\n                    // ## Bug: Closing this channel will not terminate the write\n                    int n = target.write(dbb);\n                    assert n >= 0;\n                    remaining -= n;\n                    if (isSelChImpl) {\n                        // one attempt to write to selectable channel\n                        break;\n                    }\n                    assert n > 0;\n                    position += n;\n                } finally {\n                    unmap(dbb);\n                }\n            } catch (ClosedByInterruptException e) {\n                // target closed by interrupt as ClosedByInterruptException needs\n                // to be thrown after closing this channel.\n                assert !target.isOpen();\n                try {\n                    close();\n                } catch (Throwable suppressed) {\n                    e.addSuppressed(suppressed);\n                }\n                throw e;\n            } catch (IOException ioe) {\n                // Only throw exception if no bytes have been written\n                if (remaining == count)\n                    throw ioe;\n                break;\n            }\n        }\n        return count - remaining;\n    }\n\n    private long transferToArbitraryChannel(long position, long count,\n                                            WritableByteChannel target)\n        throws IOException\n    {\n        // Untrusted target: Use a newly-erased buffer\n        int c = (int)Math.min(count, TRANSFER_SIZE);\n        ByteBuffer bb = ByteBuffer.allocate(c);\n        long tw = 0;                    // Total bytes written\n        long pos = position;\n        try {\n            while (tw < count) {\n                bb.limit((int)Math.min(count - tw, TRANSFER_SIZE));\n                int nr = read(bb, pos);\n                if (nr <= 0)\n                    break;\n                bb.flip();\n                // ## Bug: Will block writing target if this channel\n                // ##      is asynchronously closed\n                int nw = target.write(bb);\n                tw += nw;\n                if (nw != nr)\n                    break;\n                pos += nw;\n                bb.clear();\n            }\n            return tw;\n        } catch (IOException x) {\n            if (tw > 0)\n                return tw;\n            throw x;\n        }\n    }\n\n    public long transferTo(long position, long count,\n                           WritableByteChannel target)\n        throws IOException\n    {\n        ensureOpen();\n        if (!target.isOpen())\n            throw new ClosedChannelException();\n        if (!readable)\n            throw new NonReadableChannelException();\n        if (target instanceof FileChannelImpl &&\n            !((FileChannelImpl)target).writable)\n            throw new NonWritableChannelException();\n        if ((position < 0) || (count < 0))\n            throw new IllegalArgumentException();\n        long sz = size();\n        if (position > sz)\n            return 0;\n\n        if ((sz - position) < count)\n            count = sz - position;\n\n        // Attempt a direct transfer, if the kernel supports it, limiting\n        // the number of bytes according to which platform\n        int icount = (int)Math.min(count, MAX_DIRECT_TRANSFER_SIZE);\n        long n;\n        if ((n = transferToDirectly(position, icount, target)) >= 0)\n            return n;\n\n        // Attempt a mapped transfer, but only to trusted channel types\n        if ((n = transferToTrustedChannel(position, count, target)) >= 0)\n            return n;\n\n        // Slow path for untrusted targets\n        return transferToArbitraryChannel(position, count, target);\n    }\n\n    // Assume at first that the underlying kernel supports copy_file_range();\n    // set this to true if we find out later that it doesn't\n    //\n    private static volatile boolean transferFromNotSupported;\n\n    private long transferFromDirectlyInternal(FileDescriptor srcFD,\n                                              long position, long count)\n        throws IOException\n    {\n        long n = -1;\n        int ti = -1;\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return -1;\n            do {\n                long comp = Blocker.begin();\n                try {\n                    n = transferFrom0(srcFD, fd, position, count);\n                } finally {\n                    Blocker.end(comp);\n                }\n            } while ((n == IOStatus.INTERRUPTED) && isOpen());\n            if (n == IOStatus.UNSUPPORTED) {\n                // Don't bother trying again\n                transferFromNotSupported = true;\n                return IOStatus.UNSUPPORTED;\n            }\n            return IOStatus.normalize(n);\n        } finally {\n            threads.remove(ti);\n            end (n > -1);\n        }\n    }\n\n    private long transferFromDirectly(FileChannelImpl src,\n                                      long position, long count)\n        throws IOException\n    {\n        if (!src.readable)\n            throw new NonReadableChannelException();\n        if (transferFromNotSupported)\n            return IOStatus.UNSUPPORTED;\n        FileDescriptor srcFD = src.fd;\n        if (srcFD == null)\n            return IOStatus.UNSUPPORTED_CASE;\n\n        return transferFromDirectlyInternal(srcFD, position, count);\n    }\n\n    private long transferFromFileChannel(FileChannelImpl src,\n                                         long position, long count)\n        throws IOException\n    {\n        if (!src.readable)\n            throw new NonReadableChannelException();\n        if (count < MAPPED_TRANSFER_THRESHOLD)\n            return IOStatus.UNSUPPORTED_CASE;\n\n        synchronized (src.positionLock) {\n            long pos = src.position();\n            long max = Math.min(count, src.size() - pos);\n\n            if (src == this) {\n                if (position() - max + 1 <= pos &&\n                    pos - max + 1 <= position() &&\n                    !nd.canTransferToFromOverlappedMap()) {\n                    return IOStatus.UNSUPPORTED_CASE;\n                }\n            }\n\n            long remaining = max;\n            long p = pos;\n            while (remaining > 0L) {\n                long size = Math.min(remaining, MAPPED_TRANSFER_SIZE);\n                // ## Bug: Closing this channel will not terminate the write\n                MappedByteBuffer bb = src.map(MapMode.READ_ONLY, p, size);\n                try {\n                    long n = write(bb, position);\n                    assert n > 0;\n                    p += n;\n                    position += n;\n                    remaining -= n;\n                } catch (IOException ioe) {\n                    // Only throw exception if no bytes have been written\n                    if (remaining == max)\n                        throw ioe;\n                    break;\n                } finally {\n                    unmap(bb);\n                }\n            }\n            long nwritten = max - remaining;\n            src.position(pos + nwritten);\n            return nwritten;\n        }\n    }\n\n    private static final int TRANSFER_SIZE = 8192;\n\n    private long transferFromArbitraryChannel(ReadableByteChannel src,\n                                              long position, long count)\n        throws IOException\n    {\n        // Untrusted target: Use a newly-erased buffer\n        int c = (int)Math.min(count, TRANSFER_SIZE);\n        ByteBuffer bb = ByteBuffer.allocate(c);\n        long tw = 0;                    // Total bytes written\n        long pos = position;\n        try {\n            while (tw < count) {\n                bb.limit((int)Math.min((count - tw), (long)TRANSFER_SIZE));\n                // ## Bug: Will block reading src if this channel\n                // ##      is asynchronously closed\n                int nr = src.read(bb);\n                if (nr <= 0)\n                    break;\n                bb.flip();\n                int nw = write(bb, pos);\n                tw += nw;\n                if (nw != nr)\n                    break;\n                pos += nw;\n                bb.clear();\n            }\n            return tw;\n        } catch (IOException x) {\n            if (tw > 0)\n                return tw;\n            throw x;\n        }\n    }\n\n    public long transferFrom(ReadableByteChannel src,\n                             long position, long count)\n        throws IOException\n    {\n        ensureOpen();\n        if (!src.isOpen())\n            throw new ClosedChannelException();\n        if (!writable)\n            throw new NonWritableChannelException();\n        if ((position < 0) || (count < 0))\n            throw new IllegalArgumentException();\n        if (position > size())\n            return 0;\n\n        if (src instanceof FileChannelImpl fci) {\n            long n;\n            if ((n = transferFromDirectly(fci, position, count)) >= 0)\n                return n;\n            if ((n = transferFromFileChannel(fci, position, count)) >= 0)\n                return n;\n        }\n\n        return transferFromArbitraryChannel(src, position, count);\n    }\n\n    public int read(ByteBuffer dst, long position) throws IOException {\n        if (dst == null)\n            throw new NullPointerException();\n        if (position < 0)\n            throw new IllegalArgumentException(\"Negative position\");\n        ensureOpen();\n        if (!readable)\n            throw new NonReadableChannelException();\n        if (direct)\n            Util.checkChannelPositionAligned(position, alignment);\n        if (nd.needsPositionLock()) {\n            synchronized (positionLock) {\n                return readInternal(dst, position);\n            }\n        } else {\n            return readInternal(dst, position);\n        }\n    }\n\n    private int readInternal(ByteBuffer dst, long position) throws IOException {\n        assert !nd.needsPositionLock() || Thread.holdsLock(positionLock);\n        int n = 0;\n        int ti = -1;\n\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return -1;\n            do {\n                long comp = Blocker.begin();\n                try {\n                    n = IOUtil.read(fd, dst, position, direct, alignment, nd);\n                } finally {\n                    Blocker.end(comp);\n                }\n            } while ((n == IOStatus.INTERRUPTED) && isOpen());\n            return IOStatus.normalize(n);\n        } finally {\n            threads.remove(ti);\n            endBlocking(n > 0);\n            assert IOStatus.check(n);\n        }\n    }\n\n    public int write(ByteBuffer src, long position) throws IOException {\n        if (src == null)\n            throw new NullPointerException();\n        if (position < 0)\n            throw new IllegalArgumentException(\"Negative position\");\n        ensureOpen();\n        if (!writable)\n            throw new NonWritableChannelException();\n        if (direct)\n            Util.checkChannelPositionAligned(position, alignment);\n        if (nd.needsPositionLock()) {\n            synchronized (positionLock) {\n                return writeInternal(src, position);\n            }\n        } else {\n            return writeInternal(src, position);\n        }\n    }\n\n    private int writeInternal(ByteBuffer src, long position) throws IOException {\n        assert !nd.needsPositionLock() || Thread.holdsLock(positionLock);\n        int n = 0;\n        int ti = -1;\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return -1;\n            do {\n                long comp = Blocker.begin();\n                try {\n                    n = IOUtil.write(fd, src, position, direct, alignment, nd);\n                } finally {\n                    Blocker.end(comp);\n                }\n            } while ((n == IOStatus.INTERRUPTED) && isOpen());\n            return IOStatus.normalize(n);\n        } finally {\n            threads.remove(ti);\n            endBlocking(n > 0);\n            assert IOStatus.check(n);\n        }\n    }\n\n\n    // -- Memory-mapped buffers --\n\n    private abstract static class Unmapper\n        implements Runnable, UnmapperProxy\n    {\n        // may be required to close file\n        private static final NativeDispatcher nd = new FileDispatcherImpl();\n\n        private volatile long address;\n        protected final long size;\n        protected final long cap;\n        private final FileDescriptor fd;\n        private final int pagePosition;\n\n        private Unmapper(long address, long size, long cap,\n                         FileDescriptor fd, int pagePosition)\n        {\n            assert (address != 0);\n            this.address = address;\n            this.size = size;\n            this.cap = cap;\n            this.fd = fd;\n            this.pagePosition = pagePosition;\n        }\n\n        @Override\n        public long address() {\n            return address + pagePosition;\n        }\n\n        @Override\n        public FileDescriptor fileDescriptor() {\n            return fd;\n        }\n\n        @Override\n        public void run() {\n            unmap();\n        }\n\n        public long capacity() {\n            return cap;\n        }\n\n        public void unmap() {\n            if (address == 0)\n                return;\n            unmap0(address, size);\n            address = 0;\n\n            // if this mapping has a valid file descriptor then we close it\n            if (fd.valid()) {\n                try {\n                    nd.close(fd);\n                } catch (IOException ignore) {\n                    // nothing we can do\n                }\n            }\n\n            decrementStats();\n        }\n        protected abstract void incrementStats();\n        protected abstract void decrementStats();\n    }\n\n    private static class DefaultUnmapper extends Unmapper {\n\n        // keep track of non-sync mapped buffer usage\n        static volatile int count;\n        static volatile long totalSize;\n        static volatile long totalCapacity;\n\n        public DefaultUnmapper(long address, long size, long cap,\n                               FileDescriptor fd, int pagePosition) {\n            super(address, size, cap, fd, pagePosition);\n            incrementStats();\n        }\n\n        protected void incrementStats() {\n            synchronized (DefaultUnmapper.class) {\n                count++;\n                totalSize += size;\n                totalCapacity += cap;\n            }\n        }\n        protected void decrementStats() {\n            synchronized (DefaultUnmapper.class) {\n                count--;\n                totalSize -= size;\n                totalCapacity -= cap;\n            }\n        }\n\n        public boolean isSync() {\n            return false;\n        }\n    }\n\n    private static class SyncUnmapper extends Unmapper {\n\n        // keep track of mapped buffer usage\n        static volatile int count;\n        static volatile long totalSize;\n        static volatile long totalCapacity;\n\n        public SyncUnmapper(long address, long size, long cap,\n                            FileDescriptor fd, int pagePosition) {\n            super(address, size, cap, fd, pagePosition);\n            incrementStats();\n        }\n\n        protected void incrementStats() {\n            synchronized (SyncUnmapper.class) {\n                count++;\n                totalSize += size;\n                totalCapacity += cap;\n            }\n        }\n        protected void decrementStats() {\n            synchronized (SyncUnmapper.class) {\n                count--;\n                totalSize -= size;\n                totalCapacity -= cap;\n            }\n        }\n\n        public boolean isSync() {\n            return true;\n        }\n    }\n\n    private static void unmap(MappedByteBuffer bb) {\n        Cleaner cl = ((DirectBuffer)bb).cleaner();\n        if (cl != null)\n            cl.clean();\n    }\n\n    private static final int MAP_INVALID = -1;\n    private static final int MAP_RO = 0;\n    private static final int MAP_RW = 1;\n    private static final int MAP_PV = 2;\n\n    public MappedByteBuffer map(MapMode mode, long position, long size) throws IOException {\n        if (size > Integer.MAX_VALUE)\n            throw new IllegalArgumentException(\"Size exceeds Integer.MAX_VALUE\");\n        boolean isSync = isSync(Objects.requireNonNull(mode, \"Mode is null\"));\n        int prot = toProt(mode);\n        Unmapper unmapper = mapInternal(mode, position, size, prot, isSync);\n        if (unmapper == null) {\n            // a valid file descriptor is not required\n            FileDescriptor dummy = new FileDescriptor();\n            if ((!writable) || (prot == MAP_RO))\n                return Util.newMappedByteBufferR(0, 0, dummy, null, isSync);\n            else\n                return Util.newMappedByteBuffer(0, 0, dummy, null, isSync);\n        } else if ((!writable) || (prot == MAP_RO)) {\n            return Util.newMappedByteBufferR((int)unmapper.capacity(),\n                    unmapper.address(),\n                    unmapper.fileDescriptor(),\n                    unmapper, unmapper.isSync());\n        } else {\n            return Util.newMappedByteBuffer((int)unmapper.capacity(),\n                    unmapper.address(),\n                    unmapper.fileDescriptor(),\n                    unmapper, unmapper.isSync());\n        }\n    }\n\n    @Override\n    public MemorySegment map(MapMode mode, long offset, long size,\n                             MemorySession session)\n            throws IOException\n    {\n        Objects.requireNonNull(mode,\"Mode is null\");\n        Objects.requireNonNull(session, \"Session is null\");\n        MemorySessionImpl sessionImpl = MemorySessionImpl.toSessionImpl(session);\n        sessionImpl.checkValidState();\n        if (offset < 0)\n            throw new IllegalArgumentException(\"Requested bytes offset must be >= 0.\");\n        if (size < 0)\n            throw new IllegalArgumentException(\"Requested bytes size must be >= 0.\");\n\n        boolean isSync = isSync(mode);\n        int prot = toProt(mode);\n        Unmapper unmapper = mapInternal(mode, offset, size, prot, isSync);\n        boolean readOnly = false;\n        if (mode == MapMode.READ_ONLY) {\n            readOnly = true;\n        }\n        if (unmapper != null) {\n            AbstractMemorySegmentImpl segment =\n                new MappedMemorySegmentImpl(unmapper.address(), unmapper, size,\n                                            readOnly, session);\n            MemorySessionImpl.ResourceList.ResourceCleanup resource =\n                new MemorySessionImpl.ResourceList.ResourceCleanup() {\n                    @Override\n                    public void cleanup() {\n                        unmapper.unmap();\n                    }\n                };\n            sessionImpl.addOrCleanupIfFail(resource);\n            return segment;\n        } else {\n            return new MappedMemorySegmentImpl.EmptyMappedMemorySegmentImpl(readOnly, sessionImpl);\n        }\n    }\n\n    private Unmapper mapInternal(MapMode mode, long position, long size, int prot, boolean isSync)\n        throws IOException\n    {\n        ensureOpen();\n        if (mode == null)\n            throw new NullPointerException(\"Mode is null\");\n        if (position < 0L)\n            throw new IllegalArgumentException(\"Negative position\");\n        if (size < 0L)\n            throw new IllegalArgumentException(\"Negative size\");\n        if (position + size < 0)\n            throw new IllegalArgumentException(\"Position + size overflow\");\n\n        checkMode(mode, prot, isSync);\n        long addr = -1;\n        int ti = -1;\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return null;\n\n            long mapSize;\n            int pagePosition;\n            synchronized (positionLock) {\n                long filesize;\n                do {\n                    long comp = Blocker.begin();\n                    try {\n                        filesize = nd.size(fd);\n                    } finally {\n                        Blocker.end(comp);\n                    }\n                } while ((filesize == IOStatus.INTERRUPTED) && isOpen());\n                if (!isOpen())\n                    return null;\n\n                if (filesize < position + size) { // Extend file size\n                    if (!writable) {\n                        throw new IOException(\"Channel not open for writing \" +\n                            \"- cannot extend file to required size\");\n                    }\n                    int rv;\n                    do {\n                        long comp = Blocker.begin();\n                        try {\n                            rv = nd.truncate(fd, position + size);\n                        } finally {\n                            Blocker.end(comp);\n                        }\n                    } while ((rv == IOStatus.INTERRUPTED) && isOpen());\n                    if (!isOpen())\n                        return null;\n                }\n\n                if (size == 0) {\n                    return null;\n                }\n\n                pagePosition = (int)(position % allocationGranularity);\n                long mapPosition = position - pagePosition;\n                mapSize = size + pagePosition;\n                try {\n                    // If map0 did not throw an exception, the address is valid\n                    addr = map0(fd, prot, mapPosition, mapSize, isSync);\n                } catch (OutOfMemoryError x) {\n                    // An OutOfMemoryError may indicate that we've exhausted\n                    // memory so force gc and re-attempt map\n                    System.gc();\n                    try {\n                        Thread.sleep(100);\n                    } catch (InterruptedException y) {\n                        Thread.currentThread().interrupt();\n                    }\n                    try {\n                        addr = map0(fd, prot, mapPosition, mapSize, isSync);\n                    } catch (OutOfMemoryError y) {\n                        // After a second OOME, fail\n                        throw new IOException(\"Map failed\", y);\n                    }\n                }\n            } // synchronized\n\n            // On Windows, and potentially other platforms, we need an open\n            // file descriptor for some mapping operations.\n            FileDescriptor mfd;\n            try {\n                mfd = nd.duplicateForMapping(fd);\n            } catch (IOException ioe) {\n                unmap0(addr, mapSize);\n                throw ioe;\n            }\n\n            assert (IOStatus.checkAll(addr));\n            assert (addr % allocationGranularity == 0);\n            Unmapper um = (isSync\n                           ? new SyncUnmapper(addr, mapSize, size, mfd, pagePosition)\n                           : new DefaultUnmapper(addr, mapSize, size, mfd, pagePosition));\n            return um;\n        } finally {\n            threads.remove(ti);\n            endBlocking(IOStatus.checkAll(addr));\n        }\n    }\n\n    private boolean isSync(MapMode mode) {\n        // Do not want to initialize ExtendedMapMode until\n        // after the module system has been initialized\n        return !VM.isModuleSystemInited() ? false :\n            (mode == ExtendedMapMode.READ_ONLY_SYNC ||\n                mode == ExtendedMapMode.READ_WRITE_SYNC);\n    }\n\n    private int toProt(MapMode mode) {\n        int prot;\n        if (mode == MapMode.READ_ONLY) {\n            prot = MAP_RO;\n        } else if (mode == MapMode.READ_WRITE) {\n            prot = MAP_RW;\n        } else if (mode == MapMode.PRIVATE) {\n            prot = MAP_PV;\n        } else if (mode == ExtendedMapMode.READ_ONLY_SYNC) {\n            prot = MAP_RO;\n        } else if (mode == ExtendedMapMode.READ_WRITE_SYNC) {\n            prot = MAP_RW;\n        } else {\n            prot = MAP_INVALID;\n        }\n        return prot;\n    }\n\n    private void checkMode(MapMode mode, int prot, boolean isSync) {\n        if (prot == MAP_INVALID) {\n            throw new UnsupportedOperationException();\n        }\n        if ((mode != MapMode.READ_ONLY) && mode != ExtendedMapMode.READ_ONLY_SYNC && !writable)\n            throw new NonWritableChannelException();\n        if (!readable)\n            throw new NonReadableChannelException();\n        // reject SYNC request if writeback is not enabled for this platform\n        if (isSync && !Unsafe.isWritebackEnabled()) {\n            throw new UnsupportedOperationException();\n        }\n    }\n\n    /**\n     * Invoked by sun.management.ManagementFactoryHelper to create the management\n     * interface for mapped buffers.\n     */\n    public static BufferPool getMappedBufferPool() {\n        return new BufferPool() {\n            @Override\n            public String getName() {\n                return \"mapped\";\n            }\n            @Override\n            public long getCount() {\n                return DefaultUnmapper.count;\n            }\n            @Override\n            public long getTotalCapacity() {\n                return DefaultUnmapper.totalCapacity;\n            }\n            @Override\n            public long getMemoryUsed() {\n                return DefaultUnmapper.totalSize;\n            }\n        };\n    }\n\n    /**\n     * Invoked by sun.management.ManagementFactoryHelper to create the management\n     * interface for sync mapped buffers.\n     */\n    public static BufferPool getSyncMappedBufferPool() {\n        return new BufferPool() {\n            @Override\n            public String getName() {\n                return \"mapped - 'non-volatile memory'\";\n            }\n            @Override\n            public long getCount() {\n                return SyncUnmapper.count;\n            }\n            @Override\n            public long getTotalCapacity() {\n                return SyncUnmapper.totalCapacity;\n            }\n            @Override\n            public long getMemoryUsed() {\n                return SyncUnmapper.totalSize;\n            }\n        };\n    }\n\n    // -- Locks --\n\n    // keeps track of locks on this file\n    private volatile FileLockTable fileLockTable;\n\n    private FileLockTable fileLockTable() throws IOException {\n        if (fileLockTable == null) {\n            synchronized (this) {\n                if (fileLockTable == null) {\n                    int ti = threads.add();\n                    try {\n                        ensureOpen();\n                        fileLockTable = new FileLockTable(this, fd);\n                    } finally {\n                        threads.remove(ti);\n                    }\n                }\n            }\n        }\n        return fileLockTable;\n    }\n\n    public FileLock lock(long position, long size, boolean shared)\n        throws IOException\n    {\n        ensureOpen();\n        if (shared && !readable)\n            throw new NonReadableChannelException();\n        if (!shared && !writable)\n            throw new NonWritableChannelException();\n        if (size == 0)\n            size = Long.MAX_VALUE - Math.max(0, position);\n        FileLockImpl fli = new FileLockImpl(this, position, size, shared);\n        FileLockTable flt = fileLockTable();\n        flt.add(fli);\n        boolean completed = false;\n        int ti = -1;\n        try {\n            beginBlocking();\n            ti = threads.add();\n            if (!isOpen())\n                return null;\n            int n;\n            do {\n                long comp = Blocker.begin();\n                try {\n                    n = nd.lock(fd, true, position, size, shared);\n                } finally {\n                    Blocker.end(comp);\n                }\n            } while ((n == FileDispatcher.INTERRUPTED) && isOpen());\n            if (isOpen()) {\n                if (n == FileDispatcher.RET_EX_LOCK) {\n                    assert shared;\n                    FileLockImpl fli2 = new FileLockImpl(this, position, size,\n                                                         false);\n                    flt.replace(fli, fli2);\n                    fli = fli2;\n                }\n                completed = true;\n            }\n        } finally {\n            if (!completed)\n                flt.remove(fli);\n            threads.remove(ti);\n            try {\n                endBlocking(completed);\n            } catch (ClosedByInterruptException e) {\n                throw new FileLockInterruptionException();\n            }\n        }\n        return fli;\n    }\n\n    public FileLock tryLock(long position, long size, boolean shared)\n        throws IOException\n    {\n        ensureOpen();\n        if (shared && !readable)\n            throw new NonReadableChannelException();\n        if (!shared && !writable)\n            throw new NonWritableChannelException();\n        if (size == 0)\n            size = Long.MAX_VALUE - Math.max(0, position);\n        FileLockImpl fli = new FileLockImpl(this, position, size, shared);\n        FileLockTable flt = fileLockTable();\n        flt.add(fli);\n        int result;\n\n        int ti = threads.add();\n        try {\n            try {\n                ensureOpen();\n                result = nd.lock(fd, false, position, size, shared);\n            } catch (IOException e) {\n                flt.remove(fli);\n                throw e;\n            }\n            if (result == FileDispatcher.NO_LOCK) {\n                flt.remove(fli);\n                return null;\n            }\n            if (result == FileDispatcher.RET_EX_LOCK) {\n                assert shared;\n                FileLockImpl fli2 = new FileLockImpl(this, position, size,\n                                                     false);\n                flt.replace(fli, fli2);\n                return fli2;\n            }\n            return fli;\n        } finally {\n            threads.remove(ti);\n        }\n    }\n\n    void release(FileLockImpl fli) throws IOException {\n        int ti = threads.add();\n        try {\n            ensureOpen();\n            nd.release(fd, fli.position(), fli.size());\n        } finally {\n            threads.remove(ti);\n        }\n        assert fileLockTable != null;\n        fileLockTable.remove(fli);\n    }\n\n    // -- Native methods --\n\n    // Creates a new mapping\n    private native long map0(FileDescriptor fd, int prot, long position,\n                             long length, boolean isSync)\n        throws IOException;\n\n    // Removes an existing mapping\n    private static native int unmap0(long address, long length);\n\n    // Transfers from src to dst, or returns IOStatus.UNSUPPORTED (-4) or\n    // IOStatus.UNSUPPORTED_CASE (-6) if the kernel does not support it\n    private static native long transferTo0(FileDescriptor src, long position,\n                                           long count, FileDescriptor dst);\n\n    private static native long transferFrom0(FileDescriptor src,\n                                             FileDescriptor dst,\n                                             long position, long count);\n\n    // Retrieves the maximum size of a transfer\n    private static native int maxDirectTransferSize0();\n\n    // Retrieves allocation granularity\n    private static native long allocationGranularity0();\n\n    static {\n        IOUtil.load();\n        allocationGranularity = allocationGranularity0();\n        MAX_DIRECT_TRANSFER_SIZE = maxDirectTransferSize0();\n    }\n}\n"

From the logs, it looks like the source code for FileChannelImpl gets returned successfully, but it's not shown in the VS Code editor. Looking up other classes, e.g. FileLockImpl, work without problems for me.

Additionally, the error doesn't arise and I can see the source of FileChannelImpl if I go to definition by clicking on FileChannelImpl found inside RandomAccessFile's getChannel() method:

public final FileChannel getChannel() {
    ...
    this.channel = fc = FileChannelImpl.open(fd, path, true, rw, false, this);
    ...
}