DSP-24615: Fix reading mmapped trie-index exceeding 2GiB (#1574)

szymon-miezal · web-flow · commit c7948183eb4e · 2025-02-18T12:22:19.000+01:00
### What is the issue
Memory-mapping is done in buffers of size less than 2GiB.
When these buffers aren't aligned to 4KiB and the trie-index file
spans many buffers then reading it results in going out of buffer
bounds.

### What does this PR fix and why was it fixed
This patch fixes it by making sure that the buffers are correctly
aligned.
diff --git a/src/java/org/apache/cassandra/io/util/FileHandle.java b/src/java/org/apache/cassandra/io/util/FileHandle.java
@@ -515,9 +515,9 @@ private void updateRegions(ChannelProxy channel, long length, long startOffset)
             }
 
             if (regions == null)
-                regions = MmappedRegions.map(channel, length, startOffset, adviseRandom);
+                regions = MmappedRegions.map(channel, length, bufferSize, startOffset, adviseRandom);
             else
-                regions.extend(length);
+                regions.extend(length, bufferSize);
         }
     }
 
diff --git a/src/java/org/apache/cassandra/io/util/MmappedRegions.java b/src/java/org/apache/cassandra/io/util/MmappedRegions.java
@@ -19,10 +19,6 @@
 package org.apache.cassandra.io.util;
 
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
-import java.nio.FloatBuffer;
-import java.nio.IntBuffer;
-import java.nio.LongBuffer;
 import java.nio.channels.FileChannel;
 import java.util.Arrays;
 
@@ -61,34 +57,22 @@ public class MmappedRegions extends SharedCloseableImpl
      */
     private volatile State copy;
 
-    private MmappedRegions(ChannelProxy channel, CompressionMetadata metadata, long length, long uncompressedSliceOffset, boolean adviseRandom)
+    private MmappedRegions(State state, CompressionMetadata metadata, long uncompressedSliceOffset)
     {
-        this(new State(channel, offsetFrom(metadata, uncompressedSliceOffset), adviseRandom),
-             metadata,
-             length,
-             uncompressedSliceOffset);
-    }
-
-    private static long offsetFrom(CompressionMetadata metadata, long uncompressedSliceOffset)
-    {
-        return metadata == null ? uncompressedSliceOffset : metadata.chunkFor(uncompressedSliceOffset).offset;
+        super(new Tidier(state));
+        this.state = state;
+        updateState(metadata, uncompressedSliceOffset);
+        this.copy = new State(state);
     }
 
-    private MmappedRegions(State state, CompressionMetadata metadata, long length, long uncompressedOffset)
+    private MmappedRegions(State state, long length, int chunkSize)
     {
         super(new Tidier(state));
 
         this.state = state;
 
-        if (metadata != null)
-        {
-            assert length == 0 : "expected no length with metadata";
-            updateState(metadata, uncompressedOffset);
-        }
-        else if (length > 0)
-        {
-            updateState(length);
-        }
+        if (length > 0)
+            updateState(length, chunkSize);
 
         this.copy = new State(state);
     }
@@ -101,7 +85,7 @@ private MmappedRegions(MmappedRegions original)
 
     public static MmappedRegions empty(ChannelProxy channel)
     {
-        return new MmappedRegions(channel, null, 0, 0, false);
+        return new MmappedRegions(new State(channel, 0, false), 0, 0);
     }
 
     /**
@@ -119,16 +103,17 @@ public static MmappedRegions map(ChannelProxy channel, CompressionMetadata metad
     {
         if (metadata == null)
             throw new IllegalArgumentException("metadata cannot be null");
-
-        return new MmappedRegions(channel, metadata, 0, uncompressedSliceOffset, adviseRandom);
+        State state = new State(channel, metadata.chunkFor(uncompressedSliceOffset).offset, adviseRandom);
+        return new MmappedRegions(state, metadata, uncompressedSliceOffset);
     }
 
-    public static MmappedRegions map(ChannelProxy channel, long length, long uncompressedSliceOffset, boolean adviseRandom)
+    public static MmappedRegions map(ChannelProxy channel, long length, int chunkSize, long uncompressedSliceOffset, boolean adviseRandom)
     {
         if (length <= 0)
             throw new IllegalArgumentException("Length must be positive");
 
-        return new MmappedRegions(channel, null, length, uncompressedSliceOffset, adviseRandom);
+        State state = new State(channel, uncompressedSliceOffset, adviseRandom);
+        return new MmappedRegions(state, length, chunkSize);
     }
 
     /**
@@ -145,8 +130,10 @@ private boolean isCopy()
         return copy == null;
     }
 
-    public void extend(long length)
+    public void extend(long length, int chunkSize)
     {
+        // We cannot enforce length to be a multiple of chunkSize (at the very least the last extend on a file
+        // will not satisfy this), so we hope the caller knows what they are doing.
         if (length < 0)
             throw new IllegalArgumentException("Length must not be negative");
 
@@ -155,17 +142,19 @@ public void extend(long length)
         if (length <= state.length)
             return;
 
-        updateState(length);
+        updateState(length, chunkSize);
         copy = new State(state);
     }
 
-    private void updateState(long length)
+    private void updateState(long length, int chunkSize)
     {
+        // make sure the regions span whole chunks
+        long maxSize = (long) (MAX_SEGMENT_SIZE / chunkSize) * chunkSize;
         state.length = length;
         long pos = state.getPosition();
         while (pos < length)
         {
-            long size = Math.min(MAX_SEGMENT_SIZE, length - pos);
+            long size = Math.min(maxSize, length - pos);
             state.add(pos, size);
             pos += size;
         }
@@ -292,7 +281,7 @@ private static final class State
         private final long onDiskSliceOffset;
 
         /** whether to apply fadv_random to mapped regions */
-        private boolean adviseRandom;
+        private final boolean adviseRandom;
 
         private State(ChannelProxy channel, long onDiskSliceOffset, boolean adviseRandom)
         {
diff --git a/test/unit/org/apache/cassandra/io/util/MmappedRegionsTest.java b/test/unit/org/apache/cassandra/io/util/MmappedRegionsTest.java
@@ -96,10 +96,11 @@ public void testEmpty() throws Exception
     public void testTwoSegments() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(2048);
+        int bufSize = 1024;
         try(ChannelProxy channel = new ChannelProxy(writeFile("testTwoSegments", buffer));
             MmappedRegions regions = MmappedRegions.empty(channel))
         {
-            regions.extend(1024);
+            regions.extend(1024, bufSize);
             for (int i = 0; i < 1024; i++)
             {
                 MmappedRegions.Region region = regions.floor(i);
@@ -108,7 +109,7 @@ public void testTwoSegments() throws Exception
                 assertEquals(1024, region.end());
             }
 
-            regions.extend(2048);
+            regions.extend(2048, bufSize);
             for (int i = 0; i < 2048; i++)
             {
                 MmappedRegions.Region region = regions.floor(i);
@@ -131,15 +132,16 @@ public void testTwoSegments() throws Exception
     public void testSmallSegmentSize() throws Exception
     {
         int OLD_MAX_SEGMENT_SIZE = MmappedRegions.MAX_SEGMENT_SIZE;
+        int bufSize = 1024;
         MmappedRegions.MAX_SEGMENT_SIZE = 1024;
 
         ByteBuffer buffer = allocateBuffer(4096);
         try(ChannelProxy channel = new ChannelProxy(writeFile("testSmallSegmentSize", buffer));
             MmappedRegions regions = MmappedRegions.empty(channel))
         {
-            regions.extend(1024);
-            regions.extend(2048);
-            regions.extend(4096);
+            regions.extend(1024, bufSize);
+            regions.extend(2048, bufSize);
+            regions.extend(4096, bufSize);
 
             final int SIZE = MmappedRegions.MAX_SEGMENT_SIZE;
             for (int i = 0; i < buffer.capacity(); i++)
@@ -156,18 +158,46 @@ public void testSmallSegmentSize() throws Exception
         }
     }
 
+    @Test
+    public void testSizeIsChunkMultiple() throws Exception
+    {
+        final int oldMaxSegmentSize = MmappedRegions.MAX_SEGMENT_SIZE;
+        final int bufSize = 1024;
+        MmappedRegions.MAX_SEGMENT_SIZE = 2047;
+        ByteBuffer buffer = allocateBuffer(4096);
+        try(ChannelProxy channel = new ChannelProxy(writeFile("testSmallSegmentSize", buffer));
+            MmappedRegions regions = MmappedRegions.empty(channel))
+        {
+            regions.extend(1024, bufSize);
+            regions.extend(2048, bufSize);
+            regions.extend(4096, bufSize);
+            for (int i = 0; i < buffer.capacity(); i++)
+            {
+                MmappedRegions.Region region = regions.floor(i);
+                assertNotNull(region);
+                assertEquals(bufSize * (i / bufSize), region.offset());
+                assertEquals(bufSize + (bufSize * (i / bufSize)), region.end());
+            }
+        }
+        finally
+        {
+            MmappedRegions.MAX_SEGMENT_SIZE = oldMaxSegmentSize;
+        }
+    }
+
     @Test
     public void testAllocRegions() throws Exception
     {
         int OLD_MAX_SEGMENT_SIZE = MmappedRegions.MAX_SEGMENT_SIZE;
         MmappedRegions.MAX_SEGMENT_SIZE = 1024;
+        int bufSize = 1024;
 
         ByteBuffer buffer = allocateBuffer(MmappedRegions.MAX_SEGMENT_SIZE * MmappedRegions.REGION_ALLOC_SIZE * 3);
 
         try(ChannelProxy channel = new ChannelProxy(writeFile("testAllocRegions", buffer));
             MmappedRegions regions = MmappedRegions.empty(channel))
         {
-            regions.extend(buffer.capacity());
+            regions.extend(buffer.capacity(), bufSize);
 
             final int SIZE = MmappedRegions.MAX_SEGMENT_SIZE;
             for (int i = 0; i < buffer.capacity(); i++)
@@ -188,17 +218,18 @@ public void testAllocRegions() throws Exception
     public void testCopy() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(128 * 1024);
+        int bufSize = 4096;
 
         MmappedRegions snapshot;
         ChannelProxy channelCopy;
 
         try(ChannelProxy channel = new ChannelProxy(writeFile("testSnapshot", buffer));
-            MmappedRegions regions = MmappedRegions.map(channel, buffer.capacity() / 4, 0, false))
+            MmappedRegions regions = MmappedRegions.map(channel, buffer.capacity() / 4, bufSize, 0, false))
         {
             // create 3 more segments, one per quater capacity
-            regions.extend(buffer.capacity() / 2);
-            regions.extend(3 * buffer.capacity() / 4);
-            regions.extend(buffer.capacity());
+            regions.extend(buffer.capacity() / 2, bufSize);
+            regions.extend(3 * buffer.capacity() / 4, bufSize);
+            regions.extend(buffer.capacity(), bufSize);
 
             // make a snapshot
             snapshot = regions.sharedCopy();
@@ -230,14 +261,15 @@ public void testCopy() throws Exception
     public void testCopyCannotExtend() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(128 * 1024);
+        int bufSize = 1024;
 
         MmappedRegions snapshot;
         ChannelProxy channelCopy;
 
         try(ChannelProxy channel = new ChannelProxy(writeFile("testSnapshotCannotExtend", buffer));
             MmappedRegions regions = MmappedRegions.empty(channel))
         {
-            regions.extend(buffer.capacity() / 2);
+            regions.extend(buffer.capacity() / 2, bufSize);
 
             // make a snapshot
             snapshot = regions.sharedCopy();
@@ -248,7 +280,7 @@ public void testCopyCannotExtend() throws Exception
 
         try
         {
-            snapshot.extend(buffer.capacity());
+            snapshot.extend(buffer.capacity(), bufSize);
         }
         finally
         {
@@ -261,12 +293,13 @@ public void testCopyCannotExtend() throws Exception
     public void testExtendOutOfOrder() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(4096);
+        int bufSize = 1024;
         try(ChannelProxy channel = new ChannelProxy(writeFile("testExtendOutOfOrder", buffer));
             MmappedRegions regions = MmappedRegions.empty(channel))
         {
-            regions.extend(4096);
-            regions.extend(1024);
-            regions.extend(2048);
+            regions.extend(4096, bufSize);
+            regions.extend(1024, bufSize);
+            regions.extend(2048, bufSize);
 
             for (int i = 0; i < buffer.capacity(); i++)
             {
@@ -282,10 +315,11 @@ public void testExtendOutOfOrder() throws Exception
     public void testNegativeExtend() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(1024);
+        int bufSize = 1024;
         try(ChannelProxy channel = new ChannelProxy(writeFile("testNegativeExtend", buffer));
             MmappedRegions regions = MmappedRegions.empty(channel))
         {
-            regions.extend(-1);
+            regions.extend(-1, bufSize);
         }
     }
 
@@ -346,8 +380,9 @@ public void testMapForCompressionMetadata() throws Exception
     public void testIllegalArgForMap1() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(1024);
+        int bufSize = 1024;
         try(ChannelProxy channel = new ChannelProxy(writeFile("testIllegalArgForMap1", buffer));
-            MmappedRegions regions = MmappedRegions.map(channel, 0, 0, false))
+            MmappedRegions regions = MmappedRegions.map(channel, 0, bufSize, 0, false))
         {
             assertTrue(regions.isEmpty());
         }
@@ -357,8 +392,9 @@ public void testIllegalArgForMap1() throws Exception
     public void testIllegalArgForMap2() throws Exception
     {
         ByteBuffer buffer = allocateBuffer(1024);
+        int bufSize = 1024;
         try(ChannelProxy channel = new ChannelProxy(writeFile("testIllegalArgForMap2", buffer));
-            MmappedRegions regions = MmappedRegions.map(channel, -1L, 0, false))
+            MmappedRegions regions = MmappedRegions.map(channel, -1L, bufSize, 0, false))
         {
             assertTrue(regions.isEmpty());
         }
@@ -374,5 +410,4 @@ public void testIllegalArgForMap3() throws Exception
             assertTrue(regions.isEmpty());
         }
     }
-
 }

Original file line number	Diff line number	Diff line change
`@@ -515,9 +515,9 @@ private void updateRegions(ChannelProxy channel, long length, long startOffset)`
`515`	`515`	`}`
`516`	`516`
`517`	`517`	`if (regions == null)`
`518`		`- regions = MmappedRegions.map(channel, length, startOffset, adviseRandom);`
	`518`	`+ regions = MmappedRegions.map(channel, length, bufferSize, startOffset, adviseRandom);`
`519`	`519`	`else`
`520`		`- regions.extend(length);`
	`520`	`+ regions.extend(length, bufferSize);`
`521`	`521`	`}`
`522`	`522`	`}`
`523`	`523`
Original file line number	Diff line number	Diff line change
`@@ -96,10 +96,11 @@ public void testEmpty() throws Exception`
`96`	`96`	`public void testTwoSegments() throws Exception`
`97`	`97`	`{`
`98`	`98`	`ByteBuffer buffer = allocateBuffer(2048);`
	`99`	`+ int bufSize = 1024;`
`99`	`100`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testTwoSegments", buffer));`
`100`	`101`	`MmappedRegions regions = MmappedRegions.empty(channel))`
`101`	`102`	`{`
`102`		`- regions.extend(1024);`
	`103`	`+ regions.extend(1024, bufSize);`
`103`	`104`	`for (int i = 0; i < 1024; i++)`
`104`	`105`	`{`
`105`	`106`	`MmappedRegions.Region region = regions.floor(i);`
`@@ -108,7 +109,7 @@ public void testTwoSegments() throws Exception`
`108`	`109`	`assertEquals(1024, region.end());`
`109`	`110`	`}`
`110`	`111`
`111`		`- regions.extend(2048);`
	`112`	`+ regions.extend(2048, bufSize);`
`112`	`113`	`for (int i = 0; i < 2048; i++)`
`113`	`114`	`{`
`114`	`115`	`MmappedRegions.Region region = regions.floor(i);`
`@@ -131,15 +132,16 @@ public void testTwoSegments() throws Exception`
`131`	`132`	`public void testSmallSegmentSize() throws Exception`
`132`	`133`	`{`
`133`	`134`	`int OLD_MAX_SEGMENT_SIZE = MmappedRegions.MAX_SEGMENT_SIZE;`
	`135`	`+ int bufSize = 1024;`
`134`	`136`	`MmappedRegions.MAX_SEGMENT_SIZE = 1024;`
`135`	`137`
`136`	`138`	`ByteBuffer buffer = allocateBuffer(4096);`
`137`	`139`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testSmallSegmentSize", buffer));`
`138`	`140`	`MmappedRegions regions = MmappedRegions.empty(channel))`
`139`	`141`	`{`
`140`		`- regions.extend(1024);`
`141`		`- regions.extend(2048);`
`142`		`- regions.extend(4096);`
	`142`	`+ regions.extend(1024, bufSize);`
	`143`	`+ regions.extend(2048, bufSize);`
	`144`	`+ regions.extend(4096, bufSize);`
`143`	`145`
`144`	`146`	`final int SIZE = MmappedRegions.MAX_SEGMENT_SIZE;`
`145`	`147`	`for (int i = 0; i < buffer.capacity(); i++)`
`@@ -156,18 +158,46 @@ public void testSmallSegmentSize() throws Exception`
`156`	`158`	`}`
`157`	`159`	`}`
`158`	`160`
	`161`	`+ @Test`
	`162`	`+ public void testSizeIsChunkMultiple() throws Exception`
	`163`	`+ {`
	`164`	`+ final int oldMaxSegmentSize = MmappedRegions.MAX_SEGMENT_SIZE;`
	`165`	`+ final int bufSize = 1024;`
	`166`	`+ MmappedRegions.MAX_SEGMENT_SIZE = 2047;`
	`167`	`+ ByteBuffer buffer = allocateBuffer(4096);`
	`168`	`+ try(ChannelProxy channel = new ChannelProxy(writeFile("testSmallSegmentSize", buffer));`
	`169`	`+ MmappedRegions regions = MmappedRegions.empty(channel))`
	`170`	`+ {`
	`171`	`+ regions.extend(1024, bufSize);`
	`172`	`+ regions.extend(2048, bufSize);`
	`173`	`+ regions.extend(4096, bufSize);`
	`174`	`+ for (int i = 0; i < buffer.capacity(); i++)`
	`175`	`+ {`
	`176`	`+ MmappedRegions.Region region = regions.floor(i);`
	`177`	`+ assertNotNull(region);`
	`178`	`+ assertEquals(bufSize * (i / bufSize), region.offset());`
	`179`	`+ assertEquals(bufSize + (bufSize * (i / bufSize)), region.end());`
	`180`	`+ }`
	`181`	`+ }`
	`182`	`+ finally`
	`183`	`+ {`
	`184`	`+ MmappedRegions.MAX_SEGMENT_SIZE = oldMaxSegmentSize;`
	`185`	`+ }`
	`186`	`+ }`
	`187`	`+`
`159`	`188`	`@Test`
`160`	`189`	`public void testAllocRegions() throws Exception`
`161`	`190`	`{`
`162`	`191`	`int OLD_MAX_SEGMENT_SIZE = MmappedRegions.MAX_SEGMENT_SIZE;`
`163`	`192`	`MmappedRegions.MAX_SEGMENT_SIZE = 1024;`
	`193`	`+ int bufSize = 1024;`
`164`	`194`
`165`	`195`	`ByteBuffer buffer = allocateBuffer(MmappedRegions.MAX_SEGMENT_SIZE * MmappedRegions.REGION_ALLOC_SIZE * 3);`
`166`	`196`
`167`	`197`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testAllocRegions", buffer));`
`168`	`198`	`MmappedRegions regions = MmappedRegions.empty(channel))`
`169`	`199`	`{`
`170`		`- regions.extend(buffer.capacity());`
	`200`	`+ regions.extend(buffer.capacity(), bufSize);`
`171`	`201`
`172`	`202`	`final int SIZE = MmappedRegions.MAX_SEGMENT_SIZE;`
`173`	`203`	`for (int i = 0; i < buffer.capacity(); i++)`
`@@ -188,17 +218,18 @@ public void testAllocRegions() throws Exception`
`188`	`218`	`public void testCopy() throws Exception`
`189`	`219`	`{`
`190`	`220`	`ByteBuffer buffer = allocateBuffer(128 * 1024);`
	`221`	`+ int bufSize = 4096;`
`191`	`222`
`192`	`223`	`MmappedRegions snapshot;`
`193`	`224`	`ChannelProxy channelCopy;`
`194`	`225`
`195`	`226`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testSnapshot", buffer));`
`196`		`- MmappedRegions regions = MmappedRegions.map(channel, buffer.capacity() / 4, 0, false))`
	`227`	`+ MmappedRegions regions = MmappedRegions.map(channel, buffer.capacity() / 4, bufSize, 0, false))`
`197`	`228`	`{`
`198`	`229`	`// create 3 more segments, one per quater capacity`
`199`		`- regions.extend(buffer.capacity() / 2);`
`200`		`- regions.extend(3 * buffer.capacity() / 4);`
`201`		`- regions.extend(buffer.capacity());`
	`230`	`+ regions.extend(buffer.capacity() / 2, bufSize);`
	`231`	`+ regions.extend(3 * buffer.capacity() / 4, bufSize);`
	`232`	`+ regions.extend(buffer.capacity(), bufSize);`
`202`	`233`
`203`	`234`	`// make a snapshot`
`204`	`235`	`snapshot = regions.sharedCopy();`
`@@ -230,14 +261,15 @@ public void testCopy() throws Exception`
`230`	`261`	`public void testCopyCannotExtend() throws Exception`
`231`	`262`	`{`
`232`	`263`	`ByteBuffer buffer = allocateBuffer(128 * 1024);`
	`264`	`+ int bufSize = 1024;`
`233`	`265`
`234`	`266`	`MmappedRegions snapshot;`
`235`	`267`	`ChannelProxy channelCopy;`
`236`	`268`
`237`	`269`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testSnapshotCannotExtend", buffer));`
`238`	`270`	`MmappedRegions regions = MmappedRegions.empty(channel))`
`239`	`271`	`{`
`240`		`- regions.extend(buffer.capacity() / 2);`
	`272`	`+ regions.extend(buffer.capacity() / 2, bufSize);`
`241`	`273`
`242`	`274`	`// make a snapshot`
`243`	`275`	`snapshot = regions.sharedCopy();`
`@@ -248,7 +280,7 @@ public void testCopyCannotExtend() throws Exception`
`248`	`280`
`249`	`281`	`try`
`250`	`282`	`{`
`251`		`- snapshot.extend(buffer.capacity());`
	`283`	`+ snapshot.extend(buffer.capacity(), bufSize);`
`252`	`284`	`}`
`253`	`285`	`finally`
`254`	`286`	`{`
`@@ -261,12 +293,13 @@ public void testCopyCannotExtend() throws Exception`
`261`	`293`	`public void testExtendOutOfOrder() throws Exception`
`262`	`294`	`{`
`263`	`295`	`ByteBuffer buffer = allocateBuffer(4096);`
	`296`	`+ int bufSize = 1024;`
`264`	`297`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testExtendOutOfOrder", buffer));`
`265`	`298`	`MmappedRegions regions = MmappedRegions.empty(channel))`
`266`	`299`	`{`
`267`		`- regions.extend(4096);`
`268`		`- regions.extend(1024);`
`269`		`- regions.extend(2048);`
	`300`	`+ regions.extend(4096, bufSize);`
	`301`	`+ regions.extend(1024, bufSize);`
	`302`	`+ regions.extend(2048, bufSize);`
`270`	`303`
`271`	`304`	`for (int i = 0; i < buffer.capacity(); i++)`
`272`	`305`	`{`
`@@ -282,10 +315,11 @@ public void testExtendOutOfOrder() throws Exception`
`282`	`315`	`public void testNegativeExtend() throws Exception`
`283`	`316`	`{`
`284`	`317`	`ByteBuffer buffer = allocateBuffer(1024);`
	`318`	`+ int bufSize = 1024;`
`285`	`319`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testNegativeExtend", buffer));`
`286`	`320`	`MmappedRegions regions = MmappedRegions.empty(channel))`
`287`	`321`	`{`
`288`		`- regions.extend(-1);`
	`322`	`+ regions.extend(-1, bufSize);`
`289`	`323`	`}`
`290`	`324`	`}`
`291`	`325`
`@@ -346,8 +380,9 @@ public void testMapForCompressionMetadata() throws Exception`
`346`	`380`	`public void testIllegalArgForMap1() throws Exception`
`347`	`381`	`{`
`348`	`382`	`ByteBuffer buffer = allocateBuffer(1024);`
	`383`	`+ int bufSize = 1024;`
`349`	`384`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testIllegalArgForMap1", buffer));`
`350`		`- MmappedRegions regions = MmappedRegions.map(channel, 0, 0, false))`
	`385`	`+ MmappedRegions regions = MmappedRegions.map(channel, 0, bufSize, 0, false))`
`351`	`386`	`{`
`352`	`387`	`assertTrue(regions.isEmpty());`
`353`	`388`	`}`
`@@ -357,8 +392,9 @@ public void testIllegalArgForMap1() throws Exception`
`357`	`392`	`public void testIllegalArgForMap2() throws Exception`
`358`	`393`	`{`
`359`	`394`	`ByteBuffer buffer = allocateBuffer(1024);`
	`395`	`+ int bufSize = 1024;`
`360`	`396`	`try(ChannelProxy channel = new ChannelProxy(writeFile("testIllegalArgForMap2", buffer));`
`361`		`- MmappedRegions regions = MmappedRegions.map(channel, -1L, 0, false))`
	`397`	`+ MmappedRegions regions = MmappedRegions.map(channel, -1L, bufSize, 0, false))`
`362`	`398`	`{`
`363`	`399`	`assertTrue(regions.isEmpty());`
`364`	`400`	`}`
`@@ -374,5 +410,4 @@ public void testIllegalArgForMap3() throws Exception`
`374`	`410`	`assertTrue(regions.isEmpty());`
`375`	`411`	`}`
`376`	`412`	`}`
`377`		`-`
`378`	`413`	`}`