8294068: Unconditional and eager load of nio library since JDK-8264744

Reviewed-by: alanb, redestad

Author: Brian Burkhalter

src/java.base/linux/classes/sun/nio/fs/LinuxFileSystem.java

@@ -158,32 +158,4 @@ int directCopy(int dst, int src, long addressToPollForCancel)
 
         return directCopy0(dst, src, addressToPollForCancel);
     }
-
-    // -- native methods --
-
-    private static native void init();
-
-    /**
-     * Copies data between file descriptors {@code src} and {@code dst} using
-     * a platform-specific function or system call possibly having kernel
-     * support.
-     *
-     * @param dst destination file descriptor
-     * @param src source file descriptor
-     * @param addressToPollForCancel address to check for cancellation
-     *        (a non-zero value written to this address indicates cancel)
-     *
-     * @return 0 on success, UNAVAILABLE if the platform function would block,
-     *         UNSUPPORTED_CASE if the call does not work with the given
-     *         parameters, or UNSUPPORTED if direct copying is not supported
-     *         on this platform
-     */
-    private static native int directCopy0(int dst, int src,
-                                          long addressToPollForCancel)
-        throws UnixException;
-
-    static {
-        jdk.internal.loader.BootLoader.loadLibrary("nio");
-        init();
-    }
 }

src/java.base/linux/classes/sun/nio/fs/LinuxNativeDispatcher.java

@@ -68,6 +68,24 @@ static native int getmntent0(long fp, UnixMountEntry entry, long buffer, int buf
     static native int posix_fadvise(int fd, long offset, long len, int advice)
         throws UnixException;
 
+    /**
+     * Copies data between file descriptors {@code src} and {@code dst} using
+     * a platform-specific function or system call possibly having kernel
+     * support.
+     *
+     * @param dst destination file descriptor
+     * @param src source file descriptor
+     * @param addressToPollForCancel address to check for cancellation
+     *        (a non-zero value written to this address indicates cancel)
+     *
+     * @return 0 on success, UNAVAILABLE if the platform function would block,
+     *         UNSUPPORTED_CASE if the call does not work with the given
+     *         parameters, or UNSUPPORTED if direct copying is not supported
+     *         on this platform
+     */
+    static native int directCopy0(int dst, int src, long addressToPollForCancel)
+        throws UnixException;
+
     // initialize
     private static native void init();
 

src/java.base/linux/native/libnio/fs/LinuxFileSystem.c

@@ -28,20 +28,34 @@
 #include "jvm.h"
 #include "jlong.h"
 
+#include "nio.h"
+
 #include <stdio.h>
 #include <string.h>
 #include <dlfcn.h>
 #include <errno.h>
 #include <mntent.h>
 #include <fcntl.h>
 
+#include <sys/sendfile.h>
+
 #include "sun_nio_fs_LinuxNativeDispatcher.h"
 
 static jfieldID entry_name;
 static jfieldID entry_dir;
 static jfieldID entry_fstype;
 static jfieldID entry_options;
 
+typedef ssize_t copy_file_range_func(int, loff_t*, int, loff_t*, size_t,
+                                     unsigned int);
+static copy_file_range_func* my_copy_file_range_func = NULL;
+
+#define RESTARTABLE(_cmd, _result) do { \
+  do { \
+    _result = _cmd; \
+  } while((_result == -1) && (errno == EINTR)); \
+} while(0)
+
 static void throwUnixException(JNIEnv* env, int errnum) {
     jobject x = JNU_NewObjectByName(env, "sun/nio/fs/UnixException",
         "(I)V", errnum);
@@ -63,6 +77,9 @@ Java_sun_nio_fs_LinuxNativeDispatcher_init(JNIEnv *env, jclass clazz)
     CHECK_NULL(entry_fstype);
     entry_options = (*env)->GetFieldID(env, clazz, "opts", "[B");
     CHECK_NULL(entry_options);
+
+    my_copy_file_range_func =
+        (copy_file_range_func*) dlsym(RTLD_DEFAULT, "copy_file_range");
 }
 
 JNIEXPORT jlong JNICALL
@@ -150,3 +167,70 @@ Java_sun_nio_fs_LinuxNativeDispatcher_posix_1fadvise(JNIEnv* env, jclass this,
 {
     return posix_fadvise64((int)fd, (off64_t)offset, (off64_t)len, (int)advice);
 }
+
+// Copy all bytes from src to dst, within the kernel if possible,
+// and return zero, otherwise return the appropriate status code.
+//
+// Return value
+//   0 on success
+//   IOS_UNAVAILABLE if the platform function would block
+//   IOS_UNSUPPORTED_CASE if the call does not work with the given parameters
+//   IOS_UNSUPPORTED if direct copying is not supported on this platform
+//   IOS_THROWN if a Java exception is thrown
+//
+JNIEXPORT jint JNICALL
+Java_sun_nio_fs_LinuxNativeDispatcher_directCopy0
+    (JNIEnv* env, jclass this, jint dst, jint src, jlong cancelAddress)
+{
+    volatile jint* cancel = (jint*)jlong_to_ptr(cancelAddress);
+
+    // Transfer within the kernel
+    const size_t count = cancel != NULL ?
+        1048576 :   // 1 MB to give cancellation a chance
+        0x7ffff000; // maximum number of bytes that sendfile() can transfer
+
+    ssize_t bytes_sent;
+    if (my_copy_file_range_func != NULL) {
+        do {
+            RESTARTABLE(my_copy_file_range_func(src, NULL, dst, NULL, count, 0),
+                                                bytes_sent);
+            if (bytes_sent < 0) {
+                switch (errno) {
+                    case EINVAL:
+                    case ENOSYS:
+                    case EXDEV:
+                        // ignore and try sendfile()
+                        break;
+                    default:
+                        JNU_ThrowIOExceptionWithLastError(env, "Copy failed");
+                        return IOS_THROWN;
+                }
+            }
+            if (cancel != NULL && *cancel != 0) {
+                throwUnixException(env, ECANCELED);
+                return IOS_THROWN;
+            }
+        } while (bytes_sent > 0);
+
+        if (bytes_sent == 0)
+            return 0;
+    }
+
+    do {
+        RESTARTABLE(sendfile64(dst, src, NULL, count), bytes_sent);
+        if (bytes_sent < 0) {
+            if (errno == EAGAIN)
+                return IOS_UNAVAILABLE;
+            if (errno == EINVAL || errno == ENOSYS)
+                return IOS_UNSUPPORTED_CASE;
+            throwUnixException(env, errno);
+            return IOS_THROWN;
+        }
+        if (cancel != NULL && *cancel != 0) {
+            throwUnixException(env, ECANCELED);
+            return IOS_THROWN;
+        }
+    } while (bytes_sent > 0);
+
+    return 0;
+}