support 64-bit file offsets on 32-bit glibc/Linux

Adds large file support (64-bit file positions) to the existing Nix
API when used with glibc on 32-bit Linux.

On many platforms that support 64-bit file positions, this support is
present in the standard I/O functions. On 32-bit Linux, there have
historically been two APIs: the standard API, which limits file size
to 2**31-1 bytes, and a separate API that suffixes function names
with "64" and supports 64-bit file sizes. Other platforms do not
provide this API. As a result, using the *64 API will make programs
non-portable, whereas using the standard API will result in programs
that cannot handle large files on 32-bit Linux, even when the system
is actually capable of handling such files.

To support large files with a consistent API across platforms, this
change makes Nix functions call the 64-bit capable equivalents on
Linux when using glibc. Other C libraries may not provide the *64
API, so we continue to call the standard functions on those.

Broadly, the change consists of five parts:

 1. A new nix::off_t type to represent file positions in arguments
    to Nix functions. This is intended to be large enough to
    support all file positions supported by the platform, and
    therefore differs from libc::off_t on platforms where libc::off_t
    is too small to support all file sizes (notably 32-bit Linux
    with glibc).

 2. A new require_largefile macro that is used to skip tests that
    require nix::off_t to be larger than 32 bits.

 3. A largefile_fn macro that is used to select the large-file-capable
    version of a function. E.g. largefile_fn![libc::pwrite] is
    equivalent to libc::pwrite64 on glibc/Linux and plain libc::pwrite
    everywhere else.

 4. Changes to fallocate, ftruncate, lseek, mmap, open, openat,
    posix_fadvise, posix_fallocate, pread, preadv, pwrite, pwritev,
    sendfile, and truncate, making them support large files.

 5. A set of test_*_largefile tests to verify that each of the
    previously mentioned functions now works with files whose size
    requires more than 32 bits to represent.

A few functions are still limited to 32-bit file sizes after this
change. This includes the aio* functions, the *stat* functions, and
mkstemp(). Adding large file support to those requires a bit more
work than simply calling a different function and is therefore left
for later.

Author: inglorion

src/fcntl.rs

@@ -1,4 +1,5 @@
 use crate::errno::Errno;
+use crate::off_t;
 use libc::{self, c_char, c_int, c_uint, size_t, ssize_t};
 use std::ffi::OsString;
 #[cfg(not(target_os = "redox"))]
@@ -199,7 +200,7 @@ pub fn open<P: ?Sized + NixPath>(
     mode: Mode,
 ) -> Result<RawFd> {
     let fd = path.with_nix_path(|cstr| unsafe {
-        libc::open(cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint)
+        largefile_fn![libc::open](cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint)
     })?;
 
     Errno::result(fd)
@@ -215,7 +216,7 @@ pub fn openat<P: ?Sized + NixPath>(
     mode: Mode,
 ) -> Result<RawFd> {
     let fd = path.with_nix_path(|cstr| unsafe {
-        libc::openat(dirfd, cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint)
+        largefile_fn![libc::openat](dirfd, cstr.as_ptr(), oflag.bits(), mode.bits() as c_uint)
     })?;
     Errno::result(fd)
 }
@@ -746,10 +747,10 @@ feature! {
 pub fn fallocate(
     fd: RawFd,
     mode: FallocateFlags,
-    offset: libc::off_t,
-    len: libc::off_t,
+    offset: off_t,
+    len: off_t,
 ) -> Result<()> {
-    let res = unsafe { libc::fallocate(fd, mode.bits(), offset, len) };
+    let res = unsafe { largefile_fn![libc::fallocate](fd, mode.bits(), offset, len) };
     Errno::result(res).map(drop)
 }
 
@@ -901,6 +902,7 @@ pub fn fspacectl_all(
 mod posix_fadvise {
     use crate::errno::Errno;
     use crate::Result;
+    use crate::off_t;
     use std::os::unix::io::RawFd;
 
     #[cfg(feature = "fs")]
@@ -922,11 +924,13 @@ mod posix_fadvise {
     #![feature = "fs"]
     pub fn posix_fadvise(
         fd: RawFd,
-        offset: libc::off_t,
-        len: libc::off_t,
+        offset: off_t,
+        len: off_t,
         advice: PosixFadviseAdvice,
     ) -> Result<()> {
-        let res = unsafe { libc::posix_fadvise(fd, offset, len, advice as libc::c_int) };
+        let res = unsafe {
+            largefile_fn![libc::posix_fadvise](fd, offset, len, advice as libc::c_int)
+        };
 
         if res == 0 {
             Ok(())
@@ -948,10 +952,10 @@ mod posix_fadvise {
 ))]
 pub fn posix_fallocate(
     fd: RawFd,
-    offset: libc::off_t,
-    len: libc::off_t,
+    offset: off_t,
+    len: off_t,
 ) -> Result<()> {
-    let res = unsafe { libc::posix_fallocate(fd, offset, len) };
+    let res = unsafe { largefile_fn![libc::posix_fallocate](fd, offset, len) };
     match Errno::result(res) {
         Err(err) => Err(err),
         Ok(0) => Ok(()),

src/lib.rs

@@ -55,13 +55,33 @@
 #![cfg_attr(docsrs, feature(doc_cfg))]
 #![deny(clippy::cast_ptr_alignment)]
 
+use cfg_if::cfg_if;
+
 // Re-exported external crates
 pub use libc;
 
 // Private internal modules
 #[macro_use]
 mod macros;
 
+// On some platforms, libc::off_t is not large enough to represent all file
+// offsets the platform supports, but the platform provides a different
+// type that allows larger offsets to be used. We define our own off_t type
+// that is large enough to represent all file offsets the platform supports.
+cfg_if! {
+    if #[cfg(all(target_os = "linux", target_env = "gnu"))] {
+        /// Used to represent offsets in files. May differ from libc::off_t
+        /// on platforms where libc::off_t cannot represent the full range
+        /// of file offsets.
+        pub type off_t = libc::off64_t;
+    } else {
+        /// Used to represent offsets in files. May differ from libc::off_t
+        /// on platforms where libc::off_t cannot represent the full range
+        /// of file offsets.
+        pub type off_t = libc::off_t;
+    }
+}
+
 // Public crates
 #[cfg(not(target_os = "redox"))]
 feature! {

src/macros.rs

@@ -1,3 +1,5 @@
+use cfg_if::cfg_if;
+
 // Thanks to Tokio for this macro
 macro_rules! feature {
     (
@@ -327,3 +329,44 @@ macro_rules! libc_enum {
         }
     };
 }
+
+cfg_if! {
+    if #[cfg(all(target_os = "linux", target_env = "gnu"))] {
+        /// Function variant that supports large file positions.
+        ///
+        /// On some platforms, the standard I/O functions support a limited
+        /// range of file positions, and there is an alternate set of
+        /// functions that support larger file positions. This macro takes
+        /// the identifier of a standard I/O function and returns the
+        /// identifier of the corresponding I/O function with large file
+        /// support.
+        macro_rules! largefile_fn {
+            [libc::fallocate] => (libc::fallocate64);
+            [libc::ftruncate] => (libc::ftruncate64);
+            [libc::lseek] => (libc::lseek64);
+            [libc::mmap] => (libc::mmap64);
+            [libc::open] => (libc::open64);
+            [libc::openat] => (libc::openat64);
+            [libc::posix_fadvise] => (libc::posix_fadvise64);
+            [libc::posix_fallocate] => (libc::posix_fallocate64);
+            [libc::pread] => (libc::pread64);
+            [libc::preadv] => (libc::preadv64);
+            [libc::pwrite] => (libc::pwrite64);
+            [libc::pwritev] => (libc::pwritev64);
+            [libc::sendfile] => (libc::sendfile64);
+            [libc::truncate] => (libc::truncate64);
+        }
+    } else {
+        /// Function variant that supports large file positions.
+        ///
+        /// On some platforms, the standard I/O functions support a limited
+        /// range of file positions, and there is an alternate set of
+        /// functions that support larger file positions. This macro takes
+        /// the identifier of a standard I/O function and returns the
+        /// identifier of the corresponding I/O function with large file
+        /// support.
+        macro_rules! largefile_fn {
+            [$id:ident] => ($id);
+        }
+    }
+}

src/sys/mman.rs

@@ -1,13 +1,14 @@
 //! Memory management declarations.
 
 use crate::errno::Errno;
+use crate::off_t;
 #[cfg(not(target_os = "android"))]
 use crate::NixPath;
 use crate::Result;
 #[cfg(not(target_os = "android"))]
 #[cfg(feature = "fs")]
 use crate::{fcntl::OFlag, sys::stat::Mode};
-use libc::{self, c_int, c_void, off_t, size_t};
+use libc::{self, c_int, c_void, size_t};
 use std::{num::NonZeroUsize, os::unix::io::{AsRawFd, AsFd}};
 
 libc_bitflags! {
@@ -428,8 +429,13 @@ pub unsafe fn mmap<F: AsFd>(
         addr.map_or(std::ptr::null_mut(), |a| usize::from(a) as *mut c_void);
 
     let fd = f.map(|f| f.as_fd().as_raw_fd()).unwrap_or(-1);
-    let ret =
-        libc::mmap(ptr, length.into(), prot.bits(), flags.bits(), fd, offset);
+    let ret = largefile_fn![libc::mmap](
+        ptr, length.into(),
+        prot.bits(),
+        flags.bits(),
+        fd,
+        offset,
+    );
 
     if ret == libc::MAP_FAILED {
         Err(Errno::last())

src/sys/sendfile.rs

@@ -4,9 +4,10 @@ use cfg_if::cfg_if;
 use std::os::unix::io::{AsFd, AsRawFd};
 use std::ptr;
 
-use libc::{self, off_t};
+use libc;
 
 use crate::errno::Errno;
+use crate::off_t;
 use crate::Result;
 
 /// Copy up to `count` bytes to `out_fd` from `in_fd` starting at `offset`.
@@ -33,7 +34,7 @@ pub fn sendfile<F1: AsFd, F2: AsFd>(
         .map(|offset| offset as *mut _)
         .unwrap_or(ptr::null_mut());
     let ret = unsafe {
-        libc::sendfile(
+        largefile_fn![libc::sendfile](
             out_fd.as_fd().as_raw_fd(),
             in_fd.as_fd().as_raw_fd(),
             offset,
@@ -125,8 +126,6 @@ cfg_if! {
 
 cfg_if! {
     if #[cfg(target_os = "freebsd")] {
-        use libc::c_int;
-
         libc_bitflags!{
             /// Configuration options for [`sendfile`.](fn.sendfile.html)
             pub struct SfFlags: c_int {

src/sys/uio.rs

@@ -1,8 +1,9 @@
 //! Vectored I/O
 
 use crate::errno::Errno;
+use crate::off_t;
 use crate::Result;
-use libc::{self, c_int, c_void, off_t, size_t};
+use libc::{self, c_int, c_void, size_t};
 use std::io::{IoSlice, IoSliceMut};
 use std::os::unix::io::{AsFd, AsRawFd};
 
@@ -50,7 +51,7 @@ pub fn pwritev<Fd: AsFd>(fd: Fd, iov: &[IoSlice<'_>], offset: off_t) -> Result<u
 
     // SAFETY: same as in writev()
     let res = unsafe {
-        libc::pwritev(
+        largefile_fn![libc::pwritev](
             fd.as_fd().as_raw_fd(),
             iov.as_ptr() as *const libc::iovec,
             iov.len() as c_int,
@@ -80,7 +81,7 @@ pub fn preadv<Fd: AsFd>(
 
     // SAFETY: same as in readv()
     let res = unsafe {
-        libc::preadv(
+        largefile_fn![libc::preadv](
             fd.as_fd().as_raw_fd(),
             iov.as_ptr() as *const libc::iovec,
             iov.len() as c_int,
@@ -97,7 +98,7 @@ pub fn preadv<Fd: AsFd>(
 // TODO: move to unistd
 pub fn pwrite<Fd: AsFd>(fd: Fd, buf: &[u8], offset: off_t) -> Result<usize> {
     let res = unsafe {
-        libc::pwrite(
+        largefile_fn![libc::pwrite](
             fd.as_fd().as_raw_fd(),
             buf.as_ptr() as *const c_void,
             buf.len() as size_t,
@@ -114,7 +115,7 @@ pub fn pwrite<Fd: AsFd>(fd: Fd, buf: &[u8], offset: off_t) -> Result<usize> {
 // TODO: move to unistd
 pub fn pread<Fd: AsFd>(fd: Fd, buf: &mut [u8], offset: off_t) -> Result<usize> {
     let res = unsafe {
-        libc::pread(
+        largefile_fn![libc::pread](
             fd.as_fd().as_raw_fd(),
             buf.as_mut_ptr() as *mut c_void,
             buf.len() as size_t,

src/unistd.rs

@@ -6,6 +6,7 @@ use crate::errno::{self, Errno};
 use crate::fcntl::{at_rawfd, AtFlags};
 #[cfg(feature = "fs")]
 use crate::fcntl::{fcntl, FcntlArg::F_SETFD, FdFlag, OFlag};
+use crate::off_t;
 #[cfg(all(
     feature = "fs",
     any(
@@ -24,8 +25,8 @@ use crate::{Error, NixPath, Result};
 #[cfg(not(target_os = "redox"))]
 use cfg_if::cfg_if;
 use libc::{
-    self, c_char, c_int, c_long, c_uint, c_void, gid_t, mode_t, off_t, pid_t,
-    size_t, uid_t, PATH_MAX,
+    self, c_char, c_int, c_long, c_uint, c_void, gid_t, mode_t, pid_t, size_t,
+    uid_t, PATH_MAX,
 };
 use std::convert::Infallible;
 use std::ffi::{CStr, OsString};
@@ -1168,7 +1169,7 @@ pub enum Whence {
 ///
 /// 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 { libc::lseek(fd, offset, whence as i32) };
+    let res = unsafe { largefile_fn![libc::lseek](fd, offset, whence as i32) };
 
     Errno::result(res).map(|r| r as off_t)
 }
@@ -1247,7 +1248,9 @@ pub fn pipe2(flags: OFlag) -> Result<(RawFd, RawFd)> {
 #[cfg(not(any(target_os = "redox", target_os = "fuchsia")))]
 pub fn truncate<P: ?Sized + NixPath>(path: &P, len: off_t) -> Result<()> {
     let res = path
-        .with_nix_path(|cstr| unsafe { libc::truncate(cstr.as_ptr(), len) })?;
+        .with_nix_path(|cstr| unsafe {
+            largefile_fn![libc::truncate](cstr.as_ptr(), len)
+        })?;
 
     Errno::result(res).map(drop)
 }
@@ -1257,7 +1260,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<()> {
-    Errno::result(unsafe { libc::ftruncate(fd.as_fd().as_raw_fd(), len) }).map(drop)
+    Errno::result(unsafe {
+        largefile_fn![libc::ftruncate](fd.as_fd().as_raw_fd(), len)
+    }).map(drop)
 }
 
 pub fn isatty(fd: RawFd) -> Result<bool> {

test/common/mod.rs

@@ -32,6 +32,20 @@ cfg_if! {
     }
 }
 
+/// Skip the test if we cannot handle offsets larger than 32 bits.
+#[macro_export]
+macro_rules! require_largefile {
+    ($name:expr) => {
+        if (nix::off_t::MAX >> 31) <= 1 {
+            crate::skip!(
+                "{} requires file offsets \
+                          larger than 32 bits. Skipping test.",
+                $name
+            );
+        }
+    };
+}
+
 /// Skip the test if we don't have the ability to mount file systems.
 #[cfg(target_os = "freebsd")]
 #[macro_export]

test/sys/test_mman.rs

@@ -1,5 +1,10 @@
 use nix::sys::mman::{mmap, MapFlags, ProtFlags};
-use std::{num::NonZeroUsize, os::unix::io::BorrowedFd};
+use nix::unistd::{lseek, sysconf, write, SysconfVar, Whence};
+use std::num::NonZeroUsize;
+use std::os::unix::io::{AsRawFd, BorrowedFd};
+use tempfile::tempfile;
+
+use crate::{require_largefile, skip};
 
 #[test]
 fn test_mmap_anonymous() {
@@ -19,6 +24,41 @@ fn test_mmap_anonymous() {
     }
 }
 
+#[test]
+fn test_mmap_largefile() {
+    require_largefile!("test_mmap_largefile");
+
+    // Calculate an offset that requires more than 32 bits to represent
+    // and is a multiple of the page size.
+    let pagesize = match sysconf(SysconfVar::PAGE_SIZE) {
+        Ok(Some(x)) => x,
+        _ => {
+            skip!("test_mmap_largefile: Could not determine page size. Skipping test.");
+        }
+    }
+    as i64;
+    let pages_in_32bits = 1_0000_0000i64 / pagesize;
+    let offset = ((pages_in_32bits + 2) * pagesize).try_into().unwrap();
+    // Create a file, seek to offset, and write some bytes.
+    let file = tempfile().unwrap();
+    lseek(file.as_raw_fd(), offset, Whence::SeekSet).unwrap();
+    write(file.as_raw_fd(), b"xyzzy").unwrap();
+    // Check that we can map it and see the bytes.
+    let slice = unsafe {
+        let res = mmap(
+            None,
+            NonZeroUsize::new(5).unwrap(),
+            ProtFlags::PROT_READ,
+            MapFlags::MAP_PRIVATE,
+            Some(&file),
+            offset,
+        );
+        assert!(res.is_ok());
+        std::slice::from_raw_parts(res.unwrap() as *const u8, 5)
+    };
+    assert_eq!(slice, b"xyzzy");
+}
+
 #[test]
 #[cfg(any(target_os = "linux", target_os = "netbsd"))]
 fn test_mremap_grow() {