made functions accept both nix::off_t and libc::off_t

Author: inglorion

src/fcntl.rs

@@ -757,13 +757,20 @@ feature! {
 /// file referred to by fd.
 #[cfg(target_os = "linux")]
 #[cfg(feature = "fs")]
-pub fn fallocate(
+pub fn fallocate<Off: Into<off_t>>(
     fd: RawFd,
     mode: FallocateFlags,
-    offset: off_t,
-    len: off_t,
+    offset: Off,
+    len: Off,
 ) -> Result<()> {
-    let res = unsafe { largefile_fn![fallocate](fd, mode.bits(), offset, len) };
+    let res = unsafe {
+        largefile_fn![fallocate](
+            fd,
+            mode.bits(),
+            offset.into(),
+            len.into(),
+        )
+    };
     Errno::result(res).map(drop)
 }
 
@@ -935,14 +942,19 @@ mod posix_fadvise {
 
     feature! {
     #![feature = "fs"]
-    pub fn posix_fadvise(
+    pub fn posix_fadvise<Off: Into<off_t>>(
         fd: RawFd,
-        offset: off_t,
-        len: off_t,
+        offset: Off,
+        len: Off,
         advice: PosixFadviseAdvice,
     ) -> Result<()> {
         let res = unsafe {
-            largefile_fn![posix_fadvise](fd, offset, len, advice as libc::c_int)
+            largefile_fn![posix_fadvise](
+                fd,
+                offset.into(),
+                len.into(),
+                advice as libc::c_int,
+            )
         };
 
         if res == 0 {
@@ -963,12 +975,18 @@ mod posix_fadvise {
     target_os = "wasi",
     target_os = "freebsd"
 ))]
-pub fn posix_fallocate(
+pub fn posix_fallocate<Off: Into<off_t>>(
     fd: RawFd,
-    offset: off_t,
-    len: off_t,
+    offset: Off,
+    len: Off,
 ) -> Result<()> {
-    let res = unsafe { largefile_fn![posix_fallocate](fd, offset, len) };
+    let res = unsafe {
+        largefile_fn![posix_fallocate](
+            fd,
+            offset.into(),
+            len.into(),
+        )
+    };
     match Errno::result(res) {
         Err(err) => Err(err),
         Ok(0) => Ok(()),

src/sys/uio.rs

@@ -45,7 +45,11 @@ pub fn readv<Fd: AsFd>(fd: Fd, iov: &mut [IoSliceMut<'_>]) -> Result<usize> {
 /// See also: [`writev`](fn.writev.html) and [`pwrite`](fn.pwrite.html)
 #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 #[cfg_attr(docsrs, doc(cfg(all())))]
-pub fn pwritev<Fd: AsFd>(fd: Fd, iov: &[IoSlice<'_>], offset: off_t) -> Result<usize> {
+pub fn pwritev<Fd: AsFd, Off: Into<off_t>>(
+    fd: Fd,
+    iov: &[IoSlice<'_>],
+    offset: Off,
+) -> Result<usize> {
     #[cfg(target_env = "uclibc")]
     let offset = offset as libc::off64_t; // uclibc doesn't use off_t
 
@@ -55,7 +59,7 @@ pub fn pwritev<Fd: AsFd>(fd: Fd, iov: &[IoSlice<'_>], offset: off_t) -> Result<u
             fd.as_fd().as_raw_fd(),
             iov.as_ptr() as *const libc::iovec,
             iov.len() as c_int,
-            offset,
+            offset.into(),
         )
     };
 
@@ -71,10 +75,10 @@ pub fn pwritev<Fd: AsFd>(fd: Fd, iov: &[IoSlice<'_>], offset: off_t) -> Result<u
 /// See also: [`readv`](fn.readv.html) and [`pread`](fn.pread.html)
 #[cfg(not(any(target_os = "redox", target_os = "haiku")))]
 #[cfg_attr(docsrs, doc(cfg(all())))]
-pub fn preadv<Fd: AsFd>(
+pub fn preadv<Fd: AsFd, Off: Into<off_t>>(
     fd: Fd,
     iov: &mut [IoSliceMut<'_>],
-    offset: off_t,
+    offset: Off,
 ) -> Result<usize> {
     #[cfg(target_env = "uclibc")]
     let offset = offset as libc::off64_t; // uclibc doesn't use off_t
@@ -85,7 +89,7 @@ pub fn preadv<Fd: AsFd>(
             fd.as_fd().as_raw_fd(),
             iov.as_ptr() as *const libc::iovec,
             iov.len() as c_int,
-            offset,
+            offset.into(),
         )
     };
 
@@ -96,13 +100,17 @@ pub fn preadv<Fd: AsFd>(
 ///
 /// See also [pwrite(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pwrite.html)
 // TODO: move to unistd
-pub fn pwrite<Fd: AsFd>(fd: Fd, buf: &[u8], offset: off_t) -> Result<usize> {
+pub fn pwrite<Fd: AsFd, Off: Into<off_t>>(
+    fd: Fd,
+    buf: &[u8],
+    offset: Off,
+) -> Result<usize> {
     let res = unsafe {
         largefile_fn![pwrite](
             fd.as_fd().as_raw_fd(),
             buf.as_ptr() as *const c_void,
             buf.len() as size_t,
-            offset,
+            offset.into(),
         )
     };
 
@@ -113,13 +121,17 @@ pub fn pwrite<Fd: AsFd>(fd: Fd, buf: &[u8], offset: off_t) -> Result<usize> {
 ///
 /// See also [pread(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/pread.html)
 // TODO: move to unistd
-pub fn pread<Fd: AsFd>(fd: Fd, buf: &mut [u8], offset: off_t) -> Result<usize> {
+pub fn pread<Fd: AsFd, Off: Into<off_t>>(
+    fd: Fd,
+    buf: &mut [u8],
+    offset: Off,
+) -> Result<usize> {
     let res = unsafe {
         largefile_fn![pread](
             fd.as_fd().as_raw_fd(),
             buf.as_mut_ptr() as *mut c_void,
             buf.len() as size_t,
-            offset,
+            offset.into(),
         )
     };
 

src/unistd.rs

@@ -1168,8 +1168,12 @@ pub enum Whence {
 /// Move the read/write file offset.
 ///
 /// See also [lseek(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/lseek.html)
-pub fn lseek(fd: RawFd, offset: off_t, whence: Whence) -> Result<off_t> {
-    let res = unsafe { largefile_fn![lseek](fd, offset, whence as i32) };
+pub fn lseek<Off: Into<off_t>>(
+    fd: RawFd,
+    offset: Off,
+    whence: Whence,
+) -> Result<off_t> {
+    let res = unsafe { largefile_fn![lseek](fd, offset.into(), whence as i32) };
 
     Errno::result(res).map(|r| r as off_t)
 }
@@ -1246,10 +1250,13 @@ pub fn pipe2(flags: OFlag) -> Result<(RawFd, RawFd)> {
 /// See also
 /// [truncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/truncate.html)
 #[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
-pub fn truncate<P: ?Sized + NixPath>(path: &P, len: off_t) -> Result<()> {
+pub fn truncate<P: ?Sized + NixPath, Off: Into<off_t>>(
+    path: &P,
+    len: Off,
+) -> Result<()> {
     let res = path
         .with_nix_path(|cstr| unsafe {
-            largefile_fn![truncate](cstr.as_ptr(), len)
+            largefile_fn![truncate](cstr.as_ptr(), len.into())
         })?;
 
     Errno::result(res).map(drop)
@@ -1259,9 +1266,9 @@ pub fn truncate<P: ?Sized + NixPath>(path: &P, len: off_t) -> Result<()> {
 ///
 /// See also
 /// [ftruncate(2)](https://pubs.opengroup.org/onlinepubs/9699919799/functions/ftruncate.html)
-pub fn ftruncate<Fd: AsFd>(fd: Fd, len: off_t) -> Result<()> {
+pub fn ftruncate<Fd: AsFd, Off: Into<off_t>>(fd: Fd, len: Off) -> Result<()> {
     Errno::result(unsafe {
-        largefile_fn![ftruncate](fd.as_fd().as_raw_fd(), len)
+        largefile_fn![ftruncate](fd.as_fd().as_raw_fd(), len.into())
     }).map(drop)
 }
 

test/sys/test_uio.rs

@@ -1,5 +1,7 @@
 #[cfg(not(target_os = "redox"))]
 use crate::require_largefile;
+#[cfg(not(target_os = "redox"))]
+use nix::off_t;
 use nix::sys::uio::*;
 use nix::unistd::*;
 use rand::distributions::Alphanumeric;
@@ -135,7 +137,7 @@ fn test_pwrite_largefile() {
 
     let mut file = tempfile().unwrap();
     let buf = [255u8; 1];
-    let pos = 0x1_0000_0002u64.try_into().unwrap();
+    let pos: off_t = 0x1_0000_0002u64.try_into().unwrap();
     assert_eq!(pwrite(&file, &buf, pos), Ok(1));
     assert_eq!(file.metadata().unwrap().len(), 0x1_0000_0003);
     file.seek(SeekFrom::End(-1)).unwrap();
@@ -173,7 +175,7 @@ fn test_pread_largefile() {
     let file = tempfile().unwrap();
     file.write_all_at(b"The text", 0x1_0000_0005).unwrap();
     let mut buf = [0u8; 4];
-    let pos = 0x1_0000_0009u64.try_into().unwrap();
+    let pos: off_t = 0x1_0000_0009u64.try_into().unwrap();
     assert_eq!(pread(&file, &mut buf, pos), Ok(4));
     assert_eq!(&buf, b"text");
 }

test/test_fcntl.rs

@@ -565,10 +565,11 @@ mod test_posix_fadvise {
         let mut tmp = tempfile::tempfile().unwrap();
         tmp.seek(std::io::SeekFrom::Start(0xfffffffc)).unwrap();
         tmp.write_all(b"forty-two").unwrap();
+        let pos: nix::off_t = 0x1_0000_0004u64.try_into().unwrap();
         assert!(posix_fadvise(
             tmp.as_raw_fd(),
             0,
-            0x1_0000_0004u64.try_into().unwrap(),
+            pos,
             PosixFadviseAdvice::POSIX_FADV_DONTNEED,
         )
         .is_ok());

test/test_unistd.rs

@@ -803,7 +803,7 @@ fn test_truncate_largefile() {
     let tempdir = tempdir().unwrap();
     let path = tempdir.path().join("file");
     File::create(&path).unwrap();
-    let length = (0x1_0000_0008u64).try_into().unwrap();
+    let length: off_t = (0x1_0000_0008u64).try_into().unwrap();
     truncate(&path, length).unwrap();
     let metadata = fs::metadata(&path).unwrap();
     assert_eq!(0x1_0000_0008, metadata.len());
@@ -830,7 +830,7 @@ fn test_ftruncate_largefile() {
     require_largefile!("test_ftruncate_largefile");
 
     let tmp = tempfile().unwrap();
-    let length = (0x1_0000_000cu64).try_into().unwrap();
+    let length: off_t = (0x1_0000_000cu64).try_into().unwrap();
     ftruncate(&tmp, length).unwrap();
     let metadata = tmp.metadata().unwrap();
     assert_eq!(0x1_0000_000c, metadata.len());