added separate copy_range function

Author: RomaniukVadim

erts/emulator/nifs/common/prim_file_nif.c

@@ -103,6 +103,7 @@ static ERL_NIF_TERM open_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]
 static ERL_NIF_TERM close_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 
 static ERL_NIF_TERM copy_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
+static ERL_NIF_TERM copy_range_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 
 static ERL_NIF_TERM file_desc_to_ref_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]);
 
@@ -188,6 +189,7 @@ static ErlNifFunc nif_funcs[] = {
     {"advise_nif", 4, advise_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
     {"read_handle_info_nif", 1, read_handle_info_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
     {"copy_file_nif", 2, copy_file_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"copy_range_nif", 3, copy_range_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
 
     /* Filesystem ops */
     {"make_hard_link_nif", 2, make_hard_link_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
@@ -1423,3 +1425,33 @@ static ERL_NIF_TERM copy_file_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM a
 
     return am_ok;
 }
+
+static ERL_NIF_TERM copy_range_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+    efile_path_t file_path_in, file_path_out;
+    off64_t length;
+
+    ASSERT(argc == 3);
+
+    if ((posix_errno = efile_marshal_path(env, argv[0], &file_path_in))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    if ((posix_errno = efile_marshal_path(env, argv[1], &file_path_out))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    if(!enif_is_number(env, argv[2])) {
+        return enif_make_badarg(env);
+    }
+
+    if(!enif_get_int64(env, argv[2], &length) || length < 0) {
+        return posix_error_to_tuple(env, EINVAL);
+    }
+
+     if ((posix_errno = efile_copy_range(&file_path_in, &file_path_out, length))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return am_ok;
+}

erts/emulator/nifs/common/prim_file_nif.h

@@ -177,8 +177,6 @@ posix_errno_t efile_from_fd(int fd,
                             ErlNifResourceType *nif_type,
                             efile_data_t **d);
 
-posix_errno_t efile_copy_file(const efile_path_t *source, const efile_path_t *destination);
-
 /** @brief Closes a file. The file must have entered the CLOSED state prior to
  * calling this to prevent double close.
  *
@@ -263,3 +261,12 @@ posix_errno_t efile_get_device_cwd(ErlNifEnv *env, int device_index, ERL_NIF_TER
 /** @brief A Windows-specific function for returning the 8.3-name of a given
  * file or directory. */
 posix_errno_t efile_altname(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TERM *result);
+
+/** @brief This function an implementation of copy_file_range for Unix systems and CopyFileW for Windows,
+ *  providing the capability to copy data efficiently between file descriptors.
+ *  If the system supports the copy_file_range syscall, it performs a direct data transfer between file descriptors.
+ *  However, if the syscall isn't available, it may default to a standard read and write operation.
+ */
+posix_errno_t efile_copy_range_int(int fd_in, int fd_out, off64_t length);
+posix_errno_t efile_copy_file(const efile_path_t *file_path_in, const efile_path_t *file_path_out);
+posix_errno_t efile_copy_range(const efile_path_t *file_path_in, const efile_path_t *file_path_out, off64_t length);

erts/emulator/nifs/unix/unix_prim_file.c

@@ -1086,10 +1086,53 @@ posix_errno_t efile_altname(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_TE
     return ENOTSUP;
 }
 
+posix_errno_t efile_copy_range_int(int fd_in, int fd_out, off64_t length) {
+    off64_t ret;
+
+#ifdef HAVE_COPY_FILE_RANGE
+    ret = syscall(SYS_copy_file_range, fd_in, NULL, fd_out, NULL, length, 0);
+
+    if (ret < 0) {
+        return errno;
+    }
+#else 
+    char buffer[4096];
+    off64_t bytes_copied = 0;
+    ssize_t bytes_read, bytes_written; 
+    
+    while (bytes_copied < length && (bytes_read = read(fd_in, buffer, sizeof(buffer))) > 0) {
+        ssize_t total_bytes_written = 0;
+
+        do {
+            bytes_written = write(fd_out, buffer + total_bytes_written, bytes_read - total_bytes_written);
+            if (bytes_written >= 0) {
+                total_bytes_written += bytes_written;
+                bytes_copied += bytes_written;
+            } else {
+                if (errno != EINTR) {
+                    return errno;
+                }
+            }
+        } while (total_bytes_written < bytes_read && bytes_copied < length);
+
+        if (bytes_written < 0) {
+            return errno;
+        }
+    }
+
+    if (bytes_read < 0) {
+        return errno;
+    }
+#endif   
+
+    return 0;
+}
+
 posix_errno_t efile_copy_file(const efile_path_t *file_path_in, const efile_path_t *file_path_out) {
     int fd_in, fd_out;
     struct stat file_stat;
-    off64_t ret, length;
+    off64_t length;
+    posix_errno_t result;
 
     do {
         fd_in = open((const char*)file_path_in->data, O_RDONLY);
@@ -1108,71 +1151,53 @@ posix_errno_t efile_copy_file(const efile_path_t *file_path_in, const efile_path
         return errno;
     }
 
-#ifdef HAVE_COPY_FILE_RANGE
-    /* Copy file contents using unix SYS_copy_file_range syscall 
-     * First we should check check for FSTAT to define Source length */
-    
-    #ifdef HAVE_FSTAT
-        if (fstat(fd_in, &file_stat) < 0) {
-            close(fd_in);
-            close(fd_out);
-            return errno;
-        }
+#ifdef HAVE_FSTAT
+    if (fstat(fd_in, &file_stat) < 0) {
+        close(fd_in);
+        close(fd_out);
+        return errno;
+    }
 
-        length = file_stat.st_size;
+    length = file_stat.st_size;
+#else
+    close(fd_in);
+    close(fd_out);
+    return ENOTSUP;
+#endif
 
-        ret = syscall(SYS_copy_file_range, fd_in, NULL, fd_out, NULL, length, 0);
+    result = efile_copy_range_int(fd_in, fd_out, length);
 
-        close(fd_in);
-        close(fd_out);
+    close(fd_in);
+    close(fd_out);
 
-        if (ret < 0) {
-            return errno;
-        }
-    #else
-        close(fd_in);
-        close(fd_out);
-        return ENOTSUP;
-    #endif
+    return result;
+}
 
-#else 
-    /* As a fallback for when copy_file_range(2) is unavailable we could do a simple read(2)+write(2) loop. */
-    char buffer[4096];
-    ssize_t bytes_read, bytes_written; 
-    
-    while ((bytes_read = read(fd_in, buffer, sizeof(buffer))) > 0) {
-        ssize_t total_bytes_written = 0;
+posix_errno_t efile_copy_range(const efile_path_t *file_path_in, const efile_path_t *file_path_out, off64_t length) {
+    int fd_in, fd_out;
+    posix_errno_t result;
 
-        do {
-            bytes_written = write(fd_out, buffer + total_bytes_written, bytes_read - total_bytes_written);
-            if (bytes_written >= 0) {
-                total_bytes_written += bytes_written;
-            } else {
-                if (errno != EINTR) {
-                    close(fd_in);
-                    close(fd_out);
-                    return errno;
-                }
-            }
-        } while (total_bytes_written < bytes_read);
+    do {
+        fd_in = open((const char*)file_path_in->data, O_RDONLY);
+    } while (fd_in == -1 && errno == EINTR);
 
-        if (bytes_written < 0) {
-            close(fd_in);
-            close(fd_out);
-            return errno;
-        }
+    if (fd_in == -1) {
+        return errno;
     }
 
-    if (bytes_read < 0) {
+    do {
+        fd_out = open((const char*)file_path_out->data, O_CREAT | O_WRONLY | O_TRUNC, FILE_MODE);
+    } while (fd_out == -1 && errno == EINTR);
+
+    if (fd_out == -1) {
         close(fd_in);
-        close(fd_out);
         return errno;
     }
 
+    result = efile_copy_range_int(fd_in, fd_out, length);
+
     close(fd_in);
     close(fd_out);
-#endif   
 
-    return 0;
+    return result;
 }
-

erts/emulator/nifs/win32/win_prim_file.c

@@ -1595,18 +1595,67 @@ posix_errno_t efile_copy_file(const efile_path_t *file_path_in, const efile_path
     ASSERT_PATH_FORMAT(file_path_in);
     ASSERT_PATH_FORMAT(file_path_out);
 
-    /* If this parameter is TRUE and the new file specified by lpNewFileName already exists, the function fails.
-     * If this parameter is FALSE and the new file already exists, the function overwrites the existing file and succeeds.
-     * For safety reason, we using TRUE as default value.
-     */
+    if(!CopyFileW((WCHAR*)file_path_in->data, (WCHAR*)file_path_out->data, FALSE)) {
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    return 0;
+}
+
+posix_errno_t efile_copy_range(const efile_path_t *file_path_in, const efile_path_t *file_path_out, off64_t length) {
+    HANDLE hInFile, hOutFile;
 
-    if(!CopyFileW((WCHAR*)file_path_in->data, (WCHAR*)file_path_out->data, TRUE)) {
+    char buffer[4096];
+    DWORD totalBytesRead;
+    DWORD bytesRead, bytesWritten;
+    LARGE_INTEGER li;
+
+    ASSERT_PATH_FORMAT(file_path_in);
+    ASSERT_PATH_FORMAT(file_path_out);
+
+    hInFile = CreateFileW((WCHAR*)file_path_in->data, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hInFile == INVALID_HANDLE_VALUE) {
         return windows_to_posix_errno(GetLastError());
     }
 
+    hOutFile = CreateFileW((WCHAR*)file_path_out->data, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
+    if (hOutFile == INVALID_HANDLE_VALUE) {
+        CloseHandle(hInFile);
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    li.QuadPart = length;
+    if (!SetFilePointerEx(hInFile, li, NULL, FILE_BEGIN)) {
+        CloseHandle(hInFile);
+        CloseHandle(hOutFile);
+        return windows_to_posix_errno(GetLastError());
+    }
+
+    totalBytesRead = 0;
+
+    while (totalBytesRead < length) {
+        if (!ReadFile(hInFile, buffer, sizeof(buffer), &bytesRead, NULL) || bytesRead == 0) {
+            break;
+        }
+
+        if (!WriteFile(hOutFile, buffer, bytesRead, &bytesWritten, NULL)) {
+            break;
+        }
+
+        totalBytesRead += bytesRead;
+    }
+
+    CloseHandle(hInFile);
+    CloseHandle(hOutFile);
+
+    if (totalBytesRead < length) {
+        return errno;
+    }
+
     return 0;
 }
 
+
 static int windows_to_posix_errno(DWORD last_error) {
     switch(last_error) {
     case ERROR_SUCCESS:

erts/preloaded/ebin/prim_file.beam

@@ -25,7 +25,7 @@
          sync/1, datasync/1, truncate/1, advise/4, allocate/3,
          read_line/1, read/2, write/2, position/2,
          pread/2, pread/3, pwrite/2, pwrite/3,
-         copy_file/2]).
+         copy_file/2, copy_range/3]).
 
 %% OTP internal.
 
@@ -74,7 +74,7 @@
        del_dir_nif/1, get_device_cwd_nif/1, set_cwd_nif/1, get_cwd_nif/0,
        ipread_s32bu_p32bu_nif/3, read_file_nif/1,
        get_handle_nif/1, delayed_close_nif/1, altname_nif/1,
-       file_desc_to_ref_nif/1, copy_file_nif/2]).
+       file_desc_to_ref_nif/1, copy_file_nif/2, copy_range_nif/3]).
 
 -type prim_file_name() :: string() | unicode:unicode_binary().
 -type prim_file_name_error() :: 'error' | 'ignore' | 'warning'.
@@ -127,10 +127,13 @@ copy(#file_descriptor{module = ?MODULE} = Source,
     %% XXX Should be moved down to the driver for optimization.
     file:copy_opened(Source, Dest, Length).
 
-%% Returns {error, Reason} | {ok, BytesCopied}
+%% Returns {error, Reason} | ok
 %% Using unix syscall copy_file_range(2)
 copy_file(Source, Destination) ->
     copy_file_nif(encode_path(Source), encode_path(Destination)).
+copy_range(Source, Destination, Length)
+  when is_integer(Length), Length >= 0 ->
+    copy_range_nif(encode_path(Source), encode_path(Destination), Length).
 
 open(Name, Modes) ->
     %% The try/catch pattern seen here is used throughout the file to adhere to
@@ -537,6 +540,8 @@ read_handle_info_nif(_FileRef) ->
     erlang:nif_error(undef).
 copy_file_nif(_Name, _Dest) ->
      erlang:nif_error(undef).
+copy_range_nif(_Name, _Dest, _Length) ->
+     erlang:nif_error(undef).
 
 %%
 %% Quality-of-life helpers