Move preallocate functionality to native access (#110678)

This commit moves the file preallocation functionality into
NativeAccess. The code is basically the same. One small tweak is that
instead of breaking Java access boundaries in order to get an open file
handle, the new code uses posix open directly.

relates #104876

Author: rjernst

build-tools-internal/src/main/java/org/elasticsearch/gradle/internal/InternalDistributionModuleCheckTaskProvider.java

@@ -59,7 +59,6 @@ public class InternalDistributionModuleCheckTaskProvider {
         "org.elasticsearch.plugin",
         "org.elasticsearch.plugin.analysis",
         "org.elasticsearch.pluginclassloader",
-        "org.elasticsearch.preallocate",
         "org.elasticsearch.securesm",
         "org.elasticsearch.server",
         "org.elasticsearch.simdvec",

distribution/build.gradle

@@ -280,8 +280,6 @@ configure(subprojects.findAll { ['archives', 'packages'].contains(it.name) }) {
 
   dependencies {
     libs project(':server')
-    // this is a special circumstance of a jar that is not a dependency of server, but needs to be in the module path
-    libs project(':libs:elasticsearch-preallocate')
 
     libsVersionChecker project(':distribution:tools:java-version-checker')
     libsCliLauncher project(':distribution:tools:cli-launcher')

distribution/tools/server-cli/src/main/java/org/elasticsearch/server/cli/SystemJvmOptions.java

@@ -69,11 +69,6 @@ static List<String> systemJvmOptions(Settings nodeSettings, final Map<String, St
                  * parsing will break in an incompatible way for some date patterns and locales.
                  */
                 "-Djava.locale.providers=SPI,COMPAT",
-                /*
-                 * Temporarily suppress illegal reflective access in searchable snapshots shared cache preallocation; this is temporary
-                 * while we explore alternatives. See org.elasticsearch.xpack.searchablesnapshots.preallocate.Preallocate.
-                 */
-                "--add-opens=java.base/java.io=org.elasticsearch.preallocate",
                 maybeEnableNativeAccess(),
                 maybeOverrideDockerCgroup(distroType),
                 maybeSetActiveProcessorCount(nodeSettings),

libs/native/jna/src/main/java/module-info.java

@@ -14,6 +14,7 @@
     requires org.elasticsearch.nativeaccess;
     requires org.elasticsearch.logging;
     requires com.sun.jna;
+    requires java.desktop;
 
     exports org.elasticsearch.nativeaccess.jna to com.sun.jna;
 

libs/native/jna/src/main/java/org/elasticsearch/nativeaccess/jna/JnaKernel32Library.java

@@ -15,12 +15,14 @@
 import com.sun.jna.Structure;
 import com.sun.jna.Structure.ByReference;
 import com.sun.jna.WString;
+import com.sun.jna.ptr.IntByReference;
 import com.sun.jna.win32.StdCallLibrary;
 
 import org.elasticsearch.nativeaccess.WindowsFunctions.ConsoleCtrlHandler;
 import org.elasticsearch.nativeaccess.lib.Kernel32Library;
 
 import java.util.List;
+import java.util.function.IntConsumer;
 
 class JnaKernel32Library implements Kernel32Library {
     private static class JnaHandle implements Handle {
@@ -158,6 +160,8 @@ private interface NativeFunctions extends StdCallLibrary {
 
         boolean SetProcessWorkingSetSize(Pointer handle, SizeT minSize, SizeT maxSize);
 
+        int GetCompressedFileSizeW(WString lpFileName, IntByReference lpFileSizeHigh);
+
         int GetShortPathNameW(WString lpszLongPath, char[] lpszShortPath, int cchBuffer);
 
         boolean SetConsoleCtrlHandler(StdCallLibrary.StdCallCallback handler, boolean add);
@@ -232,6 +236,15 @@ public boolean SetProcessWorkingSetSize(Handle handle, long minSize, long maxSiz
         return functions.SetProcessWorkingSetSize(jnaHandle.pointer, new SizeT(minSize), new SizeT(maxSize));
     }
 
+    @Override
+    public int GetCompressedFileSizeW(String lpFileName, IntConsumer lpFileSizeHigh) {
+        var wideFileName = new WString(lpFileName);
+        var fileSizeHigh = new IntByReference();
+        int ret = functions.GetCompressedFileSizeW(wideFileName, fileSizeHigh);
+        lpFileSizeHigh.accept(fileSizeHigh.getValue());
+        return ret;
+    }
+
     @Override
     public int GetShortPathNameW(String lpszLongPath, char[] lpszShortPath, int cchBuffer) {
         var wideFileName = new WString(lpszLongPath);

libs/native/jna/src/main/java/org/elasticsearch/nativeaccess/jna/JnaLinuxCLibrary.java

@@ -60,6 +60,8 @@ private interface NativeFunctions extends Library {
          * this is the only way, DON'T use it on some other architecture unless you know wtf you are doing
          */
         NativeLong syscall(NativeLong number, Object... args);
+
+        int fallocate(int fd, int mode, long offset, long length);
     }
 
     private final NativeFunctions functions;
@@ -91,4 +93,9 @@ public int prctl(int option, long arg2, long arg3, long arg4, long arg5) {
     public long syscall(long number, int operation, int flags, long address) {
         return functions.syscall(new NativeLong(number), operation, flags, address).longValue();
     }
+
+    @Override
+    public int fallocate(int fd, int mode, long offset, long length) {
+        return functions.fallocate(fd, mode, offset, length);
+    }
 }

libs/native/jna/src/main/java/org/elasticsearch/nativeaccess/jna/JnaPosixCLibrary.java

@@ -9,8 +9,10 @@
 package org.elasticsearch.nativeaccess.jna;
 
 import com.sun.jna.Library;
+import com.sun.jna.Memory;
 import com.sun.jna.Native;
 import com.sun.jna.NativeLong;
+import com.sun.jna.Pointer;
 import com.sun.jna.Structure;
 
 import org.elasticsearch.nativeaccess.lib.PosixCLibrary;
@@ -51,37 +53,58 @@ public void rlim_max(long v) {
         }
     }
 
-    public static class JnaFStore extends Structure implements Structure.ByReference, FStore {
+    public static final class JnaStat64 implements Stat64 {
+        final Memory memory;
+        private final int stSizeOffset;
+        private final int stBlocksOffset;
 
-        public int fst_flags = 0;
-        public int fst_posmode = 0;
-        public NativeLong fst_offset = new NativeLong(0);
-        public NativeLong fst_length = new NativeLong(0);
-        public NativeLong fst_bytesalloc = new NativeLong(0);
+        JnaStat64(int sizeof, int stSizeOffset, int stBlocksOffset) {
+            this.memory = new Memory(sizeof);
+            this.stSizeOffset = stSizeOffset;
+            this.stBlocksOffset = stBlocksOffset;
+        }
+
+        @Override
+        public long st_size() {
+            return memory.getLong(stSizeOffset);
+        }
+
+        @Override
+        public long st_blocks() {
+            return memory.getLong(stBlocksOffset);
+        }
+    }
+
+    public static class JnaFStore implements FStore {
+        final Memory memory;
+
+        JnaFStore() {
+            this.memory = new Memory(32);
+        }
 
         @Override
         public void set_flags(int flags) {
-            this.fst_flags = flags;
+            memory.setInt(0, flags);
         }
 
         @Override
         public void set_posmode(int posmode) {
-            this.fst_posmode = posmode;
+            memory.setInt(4, posmode);
         }
 
         @Override
         public void set_offset(long offset) {
-            fst_offset.setValue(offset);
+            memory.setLong(8, offset);
         }
 
         @Override
         public void set_length(long length) {
-            fst_length.setValue(length);
+            memory.setLong(16, length);
         }
 
         @Override
         public long bytesalloc() {
-            return fst_bytesalloc.longValue();
+            return memory.getLong(24);
         }
     }
 
@@ -94,15 +117,40 @@ private interface NativeFunctions extends Library {
 
         int mlockall(int flags);
 
-        int fcntl(int fd, int cmd, JnaFStore fst);
+        int fcntl(int fd, int cmd, Pointer fst);
+
+        int ftruncate(int fd, NativeLong length);
+
+        int open(String filename, int flags, Object... mode);
+
+        int close(int fd);
 
         String strerror(int errno);
     }
 
+    private interface FStat64Function extends Library {
+        int fstat64(int fd, Pointer stat);
+    }
+
+    private interface FXStatFunction extends Library {
+        int __fxstat(int version, int fd, Pointer stat);
+    }
+
     private final NativeFunctions functions;
+    private final FStat64Function fstat64;
 
     JnaPosixCLibrary() {
         this.functions = Native.load("c", NativeFunctions.class);
+        FStat64Function fstat64;
+        try {
+            fstat64 = Native.load("c", FStat64Function.class);
+        } catch (UnsatisfiedLinkError e) {
+            // TODO: explain
+            var fxstat = Native.load("c", FXStatFunction.class);
+            int version = System.getProperty("os.arch").equals("aarch64") ? 0 : 1;
+            fstat64 = (fd, stat) -> fxstat.__fxstat(version, fd, stat);
+        }
+        this.fstat64 = fstat64;
     }
 
     @Override
@@ -115,6 +163,11 @@ public RLimit newRLimit() {
         return new JnaRLimit();
     }
 
+    @Override
+    public Stat64 newStat64(int sizeof, int stSizeOffset, int stBlocksOffset) {
+        return new JnaStat64(sizeof, stSizeOffset, stBlocksOffset);
+    }
+
     @Override
     public int getrlimit(int resource, RLimit rlimit) {
         assert rlimit instanceof JnaRLimit;
@@ -143,7 +196,34 @@ public FStore newFStore() {
     public int fcntl(int fd, int cmd, FStore fst) {
         assert fst instanceof JnaFStore;
         var jnaFst = (JnaFStore) fst;
-        return functions.fcntl(fd, cmd, jnaFst);
+        return functions.fcntl(fd, cmd, jnaFst.memory);
+    }
+
+    @Override
+    public int ftruncate(int fd, long length) {
+        return functions.ftruncate(fd, new NativeLong(length));
+    }
+
+    @Override
+    public int open(String pathname, int flags) {
+        return functions.open(pathname, flags);
+    }
+
+    @Override
+    public int open(String pathname, int flags, int mode) {
+        return functions.open(pathname, flags, mode);
+    }
+
+    @Override
+    public int close(int fd) {
+        return functions.close(fd);
+    }
+
+    @Override
+    public int fstat64(int fd, Stat64 stats) {
+        assert stats instanceof JnaStat64;
+        var jnaStats = (JnaStat64) stats;
+        return fstat64.fstat64(fd, jnaStats.memory);
     }
 
     @Override

libs/native/src/main/java/module-info.java

@@ -19,6 +19,7 @@
         to
             org.elasticsearch.nativeaccess.jna,
             org.elasticsearch.server,
+            org.elasticsearch.blobcache,
             org.elasticsearch.simdvec,
             org.elasticsearch.systemd;
     // allows jna to implement a library provider, and ProviderLocator to load it

libs/native/src/main/java/org/elasticsearch/nativeaccess/LinuxNativeAccess.java

@@ -18,6 +18,8 @@
 
 class LinuxNativeAccess extends PosixNativeAccess {
 
+    private static final int STATX_BLOCKS = 0x400; /* Want/got stx_blocks */
+
     /** the preferred method is seccomp(2), since we can apply to all threads of the process */
     static final int SECCOMP_SET_MODE_FILTER = 1;   // since Linux 3.17
     static final int SECCOMP_FILTER_FLAG_TSYNC = 1;   // since Linux 3.17
@@ -88,7 +90,7 @@ record Arch(
     private final Systemd systemd;
 
     LinuxNativeAccess(NativeLibraryProvider libraryProvider) {
-        super("Linux", libraryProvider, new PosixConstants(-1L, 9, 1, 8));
+        super("Linux", libraryProvider, new PosixConstants(-1L, 9, 1, 8, 64, 144, 48, 64));
         this.linuxLibc = libraryProvider.getLibrary(LinuxCLibrary.class);
         this.systemd = new Systemd(libraryProvider.getLibrary(SystemdLibrary.class));
     }
@@ -120,6 +122,16 @@ protected void logMemoryLimitInstructions() {
         logger.warn("If you are logged in interactively, you will have to re-login for the new limits to take effect.");
     }
 
+    @Override
+    protected boolean nativePreallocate(int fd, long currentSize, long newSize) {
+        final int rc = linuxLibc.fallocate(fd, 0, currentSize, newSize - currentSize);
+        if (rc != 0) {
+            logger.warn("fallocate failed: " + libc.strerror(libc.errno()));
+            return false;
+        }
+        return true;
+    }
+
     /**
      * Installs exec system call filtering for Linux.
      * <p>

libs/native/src/main/java/org/elasticsearch/nativeaccess/MacNativeAccess.java

@@ -22,6 +22,11 @@
 
 class MacNativeAccess extends PosixNativeAccess {
 
+    private static final int F_PREALLOCATE = 42;
+    private static final int F_ALLOCATECONTIG = 0x2; // allocate contiguous space
+    private static final int F_ALLOCATEALL = 0x4; // allocate all the requested space or no space at all
+    private static final int F_PEOFPOSMODE = 3; // allocate from the physical end of the file
+
     /** The only supported flag... */
     static final int SANDBOX_NAMED = 1;
     /** Allow everything except process fork and execution */
@@ -30,7 +35,7 @@ class MacNativeAccess extends PosixNativeAccess {
     private final MacCLibrary macLibc;
 
     MacNativeAccess(NativeLibraryProvider libraryProvider) {
-        super("MacOS", libraryProvider, new PosixConstants(9223372036854775807L, 5, 1, 6));
+        super("MacOS", libraryProvider, new PosixConstants(9223372036854775807L, 5, 1, 6, 512, 144, 96, 104));
         this.macLibc = libraryProvider.getLibrary(MacCLibrary.class);
     }
 
@@ -44,6 +49,31 @@ protected void logMemoryLimitInstructions() {
         // we don't have instructions for macos
     }
 
+    @Override
+    protected boolean nativePreallocate(int fd, long currentSize, long newSize) {
+        var fst = libc.newFStore();
+        fst.set_flags(F_ALLOCATECONTIG);
+        fst.set_posmode(F_PEOFPOSMODE);
+        fst.set_offset(0);
+        fst.set_length(newSize);
+        // first, try allocating contiguously
+        if (libc.fcntl(fd, F_PREALLOCATE, fst) != 0) {
+            // TODO: log warning?
+            // that failed, so let us try allocating non-contiguously
+            fst.set_flags(F_ALLOCATEALL);
+            if (libc.fcntl(fd, F_PREALLOCATE, fst) != 0) {
+                // i'm afraid captain dale had to bail
+                logger.warn("Could not allocate non-contiguous size: " + libc.strerror(libc.errno()));
+                return false;
+            }
+        }
+        if (libc.ftruncate(fd, newSize) != 0) {
+            logger.warn("Could not truncate file: " + libc.strerror(libc.errno()));
+            return false;
+        }
+        return true;
+    }
+
     /**
      * Installs exec system call filtering on MacOS.
      * <p>