src/java.base/share/classes/sun/nio/ch/FileChannelImpl.java

@@ -945,16 +945,25 @@
             throw new IllegalArgumentException("Position + size overflow");
         if (size > Integer.MAX_VALUE)
             throw new IllegalArgumentException("Size exceeds Integer.MAX_VALUE");
 
         int imode = -1;
+        boolean isPersistent = false;
         if (mode == MapMode.READ_ONLY)
             imode = MAP_RO;
         else if (mode == MapMode.READ_WRITE)
             imode = MAP_RW;
-        else if (mode == MapMode.PRIVATE)
+        else if (mode == MapMode.PRIVATE) {
             imode = MAP_PV;
+        } else if (mode == MapMode.READ_ONLY_PERSISTENT) {
+            imode = MAP_RO;
+            isPersistent = true;
+        } else if (mode == MapMode.READ_WRITE_PERSISTENT) {
+            imode = MAP_RW;
+            isPersistent = true;
+        }
+
         assert (imode >= 0);
         if ((mode != MapMode.READ_ONLY) && !writable)
             throw new NonWritableChannelException();
         if (!readable)
             throw new NonReadableChannelException();

@@ -993,32 +1002,32 @@
                 if (size == 0) {
                     addr = 0;
                     // a valid file descriptor is not required
                     FileDescriptor dummy = new FileDescriptor();
                     if ((!writable) || (imode == MAP_RO))
-                        return Util.newMappedByteBufferR(0, 0, dummy, null);
+                        return Util.newMappedByteBufferR(0, 0, dummy, null, isPersistent);
                     else
-                        return Util.newMappedByteBuffer(0, 0, dummy, null);
+                        return Util.newMappedByteBuffer(0, 0, dummy, null, isPersistent);
                 }
 
                 pagePosition = (int)(position % allocationGranularity);
                 long mapPosition = position - pagePosition;
                 mapSize = size + pagePosition;
                 try {
                     // If map0 did not throw an exception, the address is valid
-                    addr = map0(imode, mapPosition, mapSize);
+                    addr = map0(imode, mapPosition, mapSize, isPersistent);
                 } catch (OutOfMemoryError x) {
                     // An OutOfMemoryError may indicate that we've exhausted
                     // memory so force gc and re-attempt map
                     System.gc();
                     try {
                         Thread.sleep(100);
                     } catch (InterruptedException y) {
                         Thread.currentThread().interrupt();
                     }
                     try {
-                        addr = map0(imode, mapPosition, mapSize);
+                        addr = map0(imode, mapPosition, mapSize, isPersistent);
                     } catch (OutOfMemoryError y) {
                         // After a second OOME, fail
                         throw new IOException("Map failed", y);
                     }
                 }

@@ -1040,16 +1049,18 @@
             Unmapper um = new Unmapper(addr, mapSize, isize, mfd);
             if ((!writable) || (imode == MAP_RO)) {
                 return Util.newMappedByteBufferR(isize,
                                                  addr + pagePosition,
                                                  mfd,
-                                                 um);
+                                                 um,
+                                                 isPersistent);
             } else {
                 return Util.newMappedByteBuffer(isize,
                                                 addr + pagePosition,
                                                 mfd,
-                                                um);
+                                                um,
+                                                isPersistent);
             }
         } finally {
             threads.remove(ti);
             endBlocking(IOStatus.checkAll(addr));
         }

@@ -1199,11 +1210,11 @@
     }
 
     // -- Native methods --
 
     // Creates a new mapping
-    private native long map0(int prot, long position, long length)
+    private native long map0(int prot, long position, long length, boolean isPersistent)
         throws IOException;
 
     // Removes an existing mapping
     private static native int unmap0(long address, long length);