Expose copy_file_range on FreeBSD

Author: asomers

CHANGELOG.md

@@ -14,6 +14,8 @@ This project adheres to [Semantic Versioning](https://semver.org/).
 - Added `mq_timedreceive` to `::nix::mqueue`.
   ([#1966])(https://github.com/nix-rust/nix/pull/1966)
 - Added `LocalPeerPid` to `nix::sys::socket::sockopt` for macOS. ([#1967](https://github.com/nix-rust/nix/pull/1967))
+- Exposed `copy_file_range` on FreeBSD
+  (#[???](https://github.com/nix-rust/nix/pull/???))
 
 ### Changed
 

src/fcntl.rs

@@ -8,7 +8,7 @@ use std::os::unix::io::RawFd;
 
 #[cfg(feature = "fs")]
 use crate::{sys::stat::Mode, NixPath, Result};
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
 use std::ptr; // For splice and copy_file_range
 
 #[cfg(any(
@@ -605,6 +605,11 @@ libc_bitflags! {
 feature! {
 #![feature = "zerocopy"]
 
+#[cfg(any(target_os = "android", target_os = "linux"))]
+type type_of_off = libc::loff_t;
+#[cfg(target_os = "freebsd")]
+type type_of_off = libc::off_t;
+
 /// Copy a range of data from one file to another
 ///
 /// The `copy_file_range` system call performs an in-kernel copy between
@@ -621,24 +626,23 @@ feature! {
 ///
 /// On successful completion the number of bytes actually copied will be
 /// returned.
-#[cfg(any(target_os = "android", target_os = "linux"))]
+#[cfg(any(target_os = "android", target_os = "freebsd", target_os = "linux"))]
 pub fn copy_file_range(
     fd_in: RawFd,
-    off_in: Option<&mut libc::loff_t>,
+    off_in: Option<&mut type_of_off>,
     fd_out: RawFd,
-    off_out: Option<&mut libc::loff_t>,
+    off_out: Option<&mut type_of_off>,
     len: usize,
 ) -> Result<usize> {
     let off_in = off_in
-        .map(|offset| offset as *mut libc::loff_t)
+        .map(|offset| offset as *mut type_of_off)
         .unwrap_or(ptr::null_mut());
     let off_out = off_out
-        .map(|offset| offset as *mut libc::loff_t)
+        .map(|offset| offset as *mut type_of_off)
         .unwrap_or(ptr::null_mut());
 
     let ret = unsafe {
-        libc::syscall(
-            libc::SYS_copy_file_range,
+        libc::copy_file_range(
             fd_in,
             off_in,
             fd_out,

test/test_fcntl.rs

@@ -26,7 +26,7 @@ use std::io::prelude::*;
 #[cfg(not(target_os = "redox"))]
 use std::os::unix::fs;
 #[cfg(not(target_os = "redox"))]
-use tempfile::{self, NamedTempFile};
+use tempfile::NamedTempFile;
 
 #[test]
 #[cfg(not(target_os = "redox"))]
@@ -227,6 +227,51 @@ fn test_readlink() {
     );
 }
 
+/// This test creates a temporary file containing the contents
+/// 'foobarbaz' and uses the `copy_file_range` call to transfer
+/// 3 bytes at offset 3 (`bar`) to another empty file at offset 0. The
+/// resulting file is read and should contain the contents `bar`.
+/// The from_offset should be updated by the call to reflect
+/// the 3 bytes read (6).
+#[cfg(any(
+        target_os = "linux",
+        // Not available until FreeBSD 13.0
+        all(target_os = "freebsd", fbsd14),
+        target_os = "android"
+))]
+#[test]
+// QEMU does not support copy_file_range. Skip under qemu
+#[cfg_attr(qemu, ignore)]
+fn test_copy_file_range() {
+    use std::os::unix::io::AsRawFd;
+    use nix::fcntl::copy_file_range;
+
+    const CONTENTS: &[u8] = b"foobarbaz";
+
+    let mut tmp1 = tempfile::tempfile().unwrap();
+    let mut tmp2 = tempfile::tempfile().unwrap();
+
+    tmp1.write_all(CONTENTS).unwrap();
+    tmp1.flush().unwrap();
+
+    let mut from_offset: i64 = 3;
+    copy_file_range(
+        tmp1.as_raw_fd(),
+        Some(&mut from_offset),
+        tmp2.as_raw_fd(),
+        None,
+        3,
+    )
+    .unwrap();
+
+    let mut res: String = String::new();
+    tmp2.rewind().unwrap();
+    tmp2.read_to_string(&mut res).unwrap();
+
+    assert_eq!(res, String::from("bar"));
+    assert_eq!(from_offset, 6);
+}
+
 #[cfg(any(target_os = "linux", target_os = "android"))]
 mod linux_android {
     use libc::loff_t;
@@ -237,48 +282,12 @@ mod linux_android {
     use nix::fcntl::*;
     use nix::unistd::{close, pipe, read, write};
 
-    use tempfile::tempfile;
     #[cfg(any(target_os = "linux"))]
     use tempfile::NamedTempFile;
+    use tempfile::tempfile;
 
     use crate::*;
 
-    /// This test creates a temporary file containing the contents
-    /// 'foobarbaz' and uses the `copy_file_range` call to transfer
-    /// 3 bytes at offset 3 (`bar`) to another empty file at offset 0. The
-    /// resulting file is read and should contain the contents `bar`.
-    /// The from_offset should be updated by the call to reflect
-    /// the 3 bytes read (6).
-    #[test]
-    // QEMU does not support copy_file_range. Skip under qemu
-    #[cfg_attr(qemu, ignore)]
-    fn test_copy_file_range() {
-        const CONTENTS: &[u8] = b"foobarbaz";
-
-        let mut tmp1 = tempfile().unwrap();
-        let mut tmp2 = tempfile().unwrap();
-
-        tmp1.write_all(CONTENTS).unwrap();
-        tmp1.flush().unwrap();
-
-        let mut from_offset: i64 = 3;
-        copy_file_range(
-            tmp1.as_raw_fd(),
-            Some(&mut from_offset),
-            tmp2.as_raw_fd(),
-            None,
-            3,
-        )
-        .unwrap();
-
-        let mut res: String = String::new();
-        tmp2.rewind().unwrap();
-        tmp2.read_to_string(&mut res).unwrap();
-
-        assert_eq!(res, String::from("bar"));
-        assert_eq!(from_offset, 6);
-    }
-
     #[test]
     fn test_splice() {
         const CONTENTS: &[u8] = b"abcdef123456";