Always set O_LARGEFILE when opening or F_SETFLing files. (#700)

Author: sunfishcode

src/backend/linux_raw/c.rs

@@ -23,7 +23,8 @@ pub(crate) use linux_raw_sys::general::epoll_event;
 
 #[cfg(feature = "fs")]
 pub(crate) use linux_raw_sys::general::{
-    AT_FDCWD, NFS_SUPER_MAGIC, PROC_SUPER_MAGIC, UTIME_NOW, UTIME_OMIT, XATTR_CREATE, XATTR_REPLACE,
+    AT_FDCWD, NFS_SUPER_MAGIC, O_LARGEFILE, PROC_SUPER_MAGIC, UTIME_NOW, UTIME_OMIT, XATTR_CREATE,
+    XATTR_REPLACE,
 };
 
 #[cfg(feature = "io_uring")]

src/backend/linux_raw/fs/syscalls.rs

@@ -48,6 +48,9 @@ use {
 
 #[inline]
 pub(crate) fn open(path: &CStr, flags: OFlags, mode: Mode) -> io::Result<OwnedFd> {
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
     #[cfg(any(target_arch = "aarch64", target_arch = "riscv64"))]
     {
         openat(CWD.as_fd(), path, flags, mode)
@@ -65,6 +68,9 @@ pub(crate) fn openat(
     flags: OFlags,
     mode: Mode,
 ) -> io::Result<OwnedFd> {
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
     unsafe { ret_owned_fd(syscall_readonly!(__NR_openat, dirfd, path, flags, mode)) }
 }
 
@@ -76,6 +82,9 @@ pub(crate) fn openat2(
     mode: Mode,
     resolve: ResolveFlags,
 ) -> io::Result<OwnedFd> {
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
     unsafe {
         ret_owned_fd(syscall_readonly!(
             __NR_openat2,
@@ -883,17 +892,19 @@ pub(crate) fn fcntl_getfl(fd: BorrowedFd<'_>) -> io::Result<OFlags> {
     #[cfg(target_pointer_width = "32")]
     unsafe {
         ret_c_uint(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_GETFL)))
-            .map(OFlags::from_bits_truncate)
+            .map(OFlags::from_bits_retain)
     }
     #[cfg(target_pointer_width = "64")]
     unsafe {
-        ret_c_uint(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETFL)))
-            .map(OFlags::from_bits_truncate)
+        ret_c_uint(syscall_readonly!(__NR_fcntl, fd, c_uint(F_GETFL))).map(OFlags::from_bits_retain)
     }
 }
 
 #[inline]
 pub(crate) fn fcntl_setfl(fd: BorrowedFd<'_>, flags: OFlags) -> io::Result<()> {
+    // Always enable support for large files.
+    let flags = flags | OFlags::from_bits_retain(c::O_LARGEFILE);
+
     #[cfg(target_pointer_width = "32")]
     unsafe {
         ret(syscall_readonly!(__NR_fcntl64, fd, c_uint(F_SETFL), flags))

tests/fs/file.rs

@@ -88,8 +88,9 @@ fn test_file() {
         rustix::io::fcntl_getfd(&file).unwrap(),
         rustix::io::FdFlags::empty()
     );
+    // Use `from_bits_truncate` to ignore `O_LARGEFILE` if present.
     assert_eq!(
-        rustix::fs::fcntl_getfl(&file).unwrap(),
+        rustix::fs::OFlags::from_bits_truncate(rustix::fs::fcntl_getfl(&file).unwrap().bits()),
         rustix::fs::OFlags::empty()
     );
 
@@ -120,3 +121,35 @@ fn test_file() {
 
     assert_ne!(rustix::io::ioctl_fionread(&file).unwrap(), 0);
 }
+
+#[test]
+fn test_setfl_append() {
+    use rustix::fs::{Mode, OFlags};
+
+    let tmp = tempfile::tempdir().unwrap();
+
+    // Write some bytes to a file.
+    let file = rustix::fs::open(
+        tmp.path().join("test.file"),
+        OFlags::WRONLY | OFlags::CREATE,
+        Mode::RWXU,
+    )
+    .unwrap();
+    assert_eq!(rustix::io::write(&file, b"abcdefghijklmnop"), Ok(16));
+
+    // Overwite the first few bytes.
+    let file =
+        rustix::fs::open(tmp.path().join("test.file"), OFlags::WRONLY, Mode::empty()).unwrap();
+    assert_eq!(rustix::io::write(&file, b"uvw"), Ok(3));
+
+    // Append a few bytes.
+    rustix::fs::fcntl_setfl(&file, OFlags::APPEND).unwrap();
+    assert_eq!(rustix::io::write(&file, b"xyz"), Ok(3));
+
+    // Check the final contents.
+    let file =
+        rustix::fs::open(tmp.path().join("test.file"), OFlags::RDONLY, Mode::empty()).unwrap();
+    let mut buf = [0_u8; 32];
+    assert_eq!(rustix::io::read(&file, &mut buf), Ok(19));
+    assert_eq!(&buf, b"uvwdefghijklmnopxyz\0\0\0\0\0\0\0\0\0\0\0\0\0");
+}