5041655: Remove implNote; add special cases for negative and zero sizes; handle overflow; handle zero size on Windows; add test

Author: bplb

src/java.base/share/classes/java/nio/channels/FileChannel.java

@@ -999,7 +999,8 @@ public abstract MappedByteBuffer map(MapMode mode, long position, long size)
      *
      * @param  size
      *         The size of the locked region; must be non-negative, and the sum
-     *         {@code position} + {@code size} must be non-negative
+     *         {@code position} + {@code size} must be non-negative.
+     *         A value of zero indicates the remainder of the file.
      *
      * @param  shared
      *         {@code true} to request a shared lock, in which case this
@@ -1126,7 +1127,8 @@ public final FileLock lock() throws IOException {
      *
      * @param  size
      *         The size of the locked region; must be non-negative, and the sum
-     *         {@code position} + {@code size} must be non-negative
+     *         {@code position} + {@code size} must be non-negative.
+     *         A value of zero indicates the remainder of the file.
      *
      * @param  shared
      *         {@code true} to request a shared lock,

src/java.base/share/classes/java/nio/channels/FileLock.java

@@ -127,6 +127,9 @@ public abstract class FileLock implements AutoCloseable {
     /**
      * Initializes a new instance of this class.
      *
+     * <p> If {@code size} is zero, the entire file from {@code position}
+     * onward is locked.
+     *
      * @param  channel
      *         The file channel upon whose file this lock is held
      *
@@ -164,6 +167,9 @@ protected FileLock(FileChannel channel,
     /**
      * Initializes a new instance of this class.
      *
+     * <p> If {@code size} is zero, the entire file from {@code position}
+     * onward is locked.
+     *
      * @param  channel
      *         The channel upon whose file this lock is held
      *
@@ -264,25 +270,49 @@ public final boolean isShared() {
     /**
      * Tells whether or not this lock overlaps the given lock range.
      *
-     * @implNote
-     * This method assumes that the parameters are non-negative and that
-     * their sum does not overflow a {@code long}, but does not enforce
-     * these preconditions as do the constructors; hence it is the caller's
-     * responsibility to ensure that these parameters are valid.
+     * <p> If {@code size} is negative, {@code false} is returned regardless
+     * of the value of {@code position}. If {@code size} is zero, it means the
+     * lock range is unbounded.
      *
      * @param   position
      *          The starting position of the lock range
      * @param   size
      *          The size of the lock range
      *
-     * @return  {@code true} if, and only if, this lock and the given lock
-     *          range overlap by at least one byte
+     * @return  {@code false} if, and only if, {@code size} is negative or this
+     *          lock and the given lock range do <em>not</em> overlap by at
+     *          least one byte
      */
     public final boolean overlaps(long position, long size) {
-        if (position + size <= this.position)
-            return false;               // That is below this
-        if (this.position + this.size <= position)
-            return false;               // This is below that
+        System.out.printf("%d %d %d %d%n", this.position, this.size,
+            position, size);
+        if (size < 0)
+            return false;
+
+        // if size == 0 then the specified lock range is unbounded and
+        // cannot be below the range of this lock
+        if (size > 0) {
+            try {
+                if (Math.addExact(position, size) <= this.position)
+                    return false;               // That is below this
+            } catch (ArithmeticException ignored) {
+                // the sum of position and size overflows the range of long
+                // hence their mathematical sum is greater than this.position
+            }
+        }
+
+        // if this.size == 0 then the range of this lock is unbounded and
+        // cannot be below the specified lock range
+        if (this.size > 0) {
+            try {
+                if (Math.addExact(this.position, this.size) <= position)
+                    return false;               // This is below that
+            } catch (ArithmeticException ignored) {
+                // the sum of this.position and this.size overflows the range of
+                // long hence their mathematical sum is greater than position
+            }
+        }
+
         return true;
     }
 

src/java.base/windows/native/libnio/ch/FileDispatcherImpl.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2022, 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
@@ -389,8 +389,15 @@ Java_sun_nio_ch_FileDispatcherImpl_lock0(JNIEnv *env, jobject this, jobject fdo,
     HANDLE h = (HANDLE)(handleval(env, fdo));
     DWORD lowPos = (DWORD)pos;
     long highPos = (long)(pos >> 32);
-    DWORD lowNumBytes = (DWORD)size;
-    DWORD highNumBytes = (DWORD)(size >> 32);
+    DWORD lowNumBytes;
+    DWORD highNumBytes;
+    if (size == 0) {
+        lowNumBytes = MAXDWORD;
+        highNumBytes = MAXDWORD;
+    } else {
+        lowNumBytes = (DWORD)size;
+        highNumBytes = (DWORD)(size >> 32);
+    }
     BOOL result;
     DWORD flags = 0;
     OVERLAPPED o;
@@ -434,8 +441,15 @@ Java_sun_nio_ch_FileDispatcherImpl_release0(JNIEnv *env, jobject this,
     HANDLE h = (HANDLE)(handleval(env, fdo));
     DWORD lowPos = (DWORD)pos;
     long highPos = (long)(pos >> 32);
-    DWORD lowNumBytes = (DWORD)size;
-    DWORD highNumBytes = (DWORD)(size >> 32);
+    DWORD lowNumBytes;
+    DWORD highNumBytes;
+    if (size == 0) {
+        lowNumBytes = MAXDWORD;
+        highNumBytes = MAXDWORD;
+    } else {
+        lowNumBytes = (DWORD)size;
+        highNumBytes = (DWORD)(size >> 32);
+    }
     BOOL result = 0;
     OVERLAPPED o;
     o.hEvent = 0;

test/jdk/java/nio/channels/FileLock/Overlaps.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2022, 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.
+ *
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 5041655
+ * @summary Verify FileLock.overlaps
+ * @run testng Overlaps
+ */
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.channels.FileChannel;
+import java.nio.channels.FileLock;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static java.lang.Boolean.*;
+import static java.nio.file.StandardOpenOption.*;
+
+import static org.testng.Assert.assertEquals;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+
+public class Overlaps {
+    private static final long POS = 27;
+    private static final long SIZE = 42;
+
+    private static FileChannel fc;
+
+    @BeforeClass
+    public void before() throws IOException {
+        Path path = Files.createTempFile(Path.of("."), "foo", ".bar");
+        fc = FileChannel.open(path, CREATE, WRITE, DELETE_ON_CLOSE);
+        fc.position(POS);
+        fc.write(ByteBuffer.wrap(new byte[(int)SIZE]));
+    }
+
+    @AfterClass
+    public void after() throws IOException {
+        fc.close();
+    }
+
+    @DataProvider
+    public Object[][] ranges() {
+        return new Object[][] {
+            {POS, SIZE, -1,-1, FALSE},
+            {POS, SIZE, 0, -1, FALSE},
+            {POS, SIZE, POS - 1, -1, FALSE},
+            {POS, SIZE, POS + SIZE/2, -1, FALSE},
+            {POS, SIZE, POS + SIZE, -1, FALSE},
+            {POS, SIZE, -1, POS, FALSE},
+            {POS, SIZE, -1, POS + SIZE/2, TRUE},
+            {POS, SIZE, POS - 2, 1, FALSE},
+            {POS, SIZE, POS + 1, 1, TRUE},
+            {POS, SIZE, POS + SIZE/2, 0, TRUE},
+            {POS, SIZE, Long.MAX_VALUE, 2, FALSE},
+            {POS, SIZE, POS + SIZE / 2, Long.MAX_VALUE, TRUE},
+            {POS, SIZE, 0, 0, TRUE},
+            {Long.MAX_VALUE - SIZE/2, 0, 0, SIZE, FALSE},
+            {Long.MAX_VALUE - SIZE/2, 0, Long.MAX_VALUE - SIZE/4, SIZE, TRUE},
+            {Long.MAX_VALUE - SIZE/2, 0, Long.MAX_VALUE - SIZE, 0, TRUE},
+            {Long.MAX_VALUE - SIZE, 0, Long.MAX_VALUE - SIZE/2, 0, TRUE}
+        };
+    }
+
+    @Test(dataProvider = "ranges")
+    public void overlaps(long lockPos, long lockSize, long pos, long size,
+        boolean overlaps) throws IOException {
+        try (FileLock lock = fc.lock(lockPos, lockSize, false)) {
+            assertEquals(lock.overlaps(pos, size), overlaps);
+        }
+    }
+}