Auto merge of #1418 - divergentdave:file-sync, r=RalfJung

Add file sync shims

This PR adds shim implementations for these related file syncing functions.
* `fsync`, for POSIX targets, backed by `File::sync_all()`
* `fdatasync`, for POSIX targets, backed by `File::sync_data()`
* `fcntl` with command `F_FULLFSYNC`, for macOS targets, backed by `File::sync_all()`
* `sync_file_range`, for Linux targets, backed by `File::sync_data()`

Author: bors

src/shims/foreign_items/posix.rs

@@ -146,6 +146,16 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 // "lseek" is only used on macOS which is 64bit-only, so `i64` always works.
                 this.write_scalar(Scalar::from_i64(result), dest)?;
             }
+            "fsync" => {
+                let &[fd] = check_arg_count(args)?;
+                let result = this.fsync(fd)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
+            "fdatasync" => {
+                let &[fd] = check_arg_count(args)?;
+                let result = this.fdatasync(fd)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
 
             // Allocation
             "posix_memalign" => {

src/shims/foreign_items/posix/linux.rs

@@ -54,6 +54,11 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 // fadvise is only informational, we can ignore it.
                 this.write_null(dest)?;
             }
+            "sync_file_range" => {
+                let &[fd, offset, nbytes, flags] = check_arg_count(args)?;
+                let result = this.sync_file_range(fd, offset, nbytes, flags)?;
+                this.write_scalar(Scalar::from_i32(result), dest)?;
+            }
 
             // Time related shims
             "clock_gettime" => {

src/shims/fs.rs

@@ -234,6 +234,18 @@ impl Default for DirHandler {
     }
 }
 
+fn maybe_sync_file(file: &File, writable: bool, operation: fn(&File) -> std::io::Result<()>) -> std::io::Result<i32> {
+    if !writable && cfg!(windows) {
+        // sync_all() and sync_data() will return an error on Windows hosts if the file is not opened
+        // for writing. (FlushFileBuffers requires that the file handle have the
+        // GENERIC_WRITE right)
+        Ok(0i32)
+    } else {
+        let result = operation(file);
+        result.map(|_| 0i32)
+    }
+}
+
 impl<'mir, 'tcx: 'mir> EvalContextExt<'mir, 'tcx> for crate::MiriEvalContext<'mir, 'tcx> {}
 pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx> {
     fn open(
@@ -377,6 +389,16 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 fh.insert_fd_with_min_fd(FileHandle { file: duplicated, writable }, start)
             });
             this.try_unwrap_io_result(fd_result)
+        } else if this.tcx.sess.target.target.target_os == "macos"
+            && cmd == this.eval_libc_i32("F_FULLFSYNC")?
+        {
+            let &[_, _] = check_arg_count(args)?;
+            if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
+                let io_result = maybe_sync_file(file, *writable, File::sync_all);
+                this.try_unwrap_io_result(io_result)
+            } else {
+                this.handle_not_found()
+            }
         } else {
             throw_unsup_format!("the {:#x} command is not supported for `fcntl`)", cmd);
         }
@@ -1103,6 +1125,77 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             this.handle_not_found()
         }
     }
+
+    fn fsync(&mut self, fd_op: OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
+        // On macOS, `fsync` (unlike `fcntl(F_FULLFSYNC)`) does not wait for the
+        // underlying disk to finish writing. In the interest of host compatibility,
+        // we conservatively implement this with `sync_all`, which
+        // *does* wait for the disk.
+
+        let this = self.eval_context_mut();
+
+        this.check_no_isolation("fsync")?;
+
+        let fd = this.read_scalar(fd_op)?.to_i32()?;
+        if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
+            let io_result = maybe_sync_file(file, *writable, File::sync_all);
+            this.try_unwrap_io_result(io_result)
+        } else {
+            this.handle_not_found()
+        }
+    }
+
+    fn fdatasync(&mut self, fd_op: OpTy<'tcx, Tag>) -> InterpResult<'tcx, i32> {
+        let this = self.eval_context_mut();
+
+        this.check_no_isolation("fdatasync")?;
+
+        let fd = this.read_scalar(fd_op)?.to_i32()?;
+        if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
+            let io_result = maybe_sync_file(file, *writable, File::sync_data);
+            this.try_unwrap_io_result(io_result)
+        } else {
+            this.handle_not_found()
+        }
+    }
+
+    fn sync_file_range(
+        &mut self,
+        fd_op: OpTy<'tcx, Tag>,
+        offset_op: OpTy<'tcx, Tag>,
+        nbytes_op: OpTy<'tcx, Tag>,
+        flags_op: OpTy<'tcx, Tag>,
+    ) -> InterpResult<'tcx, i32> {
+        let this = self.eval_context_mut();
+
+        this.check_no_isolation("sync_file_range")?;
+
+        let fd = this.read_scalar(fd_op)?.to_i32()?;
+        let offset = this.read_scalar(offset_op)?.to_i64()?;
+        let nbytes = this.read_scalar(nbytes_op)?.to_i64()?;
+        let flags = this.read_scalar(flags_op)?.to_i32()?;
+
+        if offset < 0 || nbytes < 0 {
+            let einval = this.eval_libc("EINVAL")?;
+            this.set_last_error(einval)?;
+            return Ok(-1);
+        }
+        let allowed_flags = this.eval_libc_i32("SYNC_FILE_RANGE_WAIT_BEFORE")?
+            | this.eval_libc_i32("SYNC_FILE_RANGE_WRITE")?
+            | this.eval_libc_i32("SYNC_FILE_RANGE_WAIT_AFTER")?;
+        if flags & allowed_flags != flags {
+            let einval = this.eval_libc("EINVAL")?;
+            this.set_last_error(einval)?;
+            return Ok(-1);
+        }
+
+        if let Some(FileHandle { file, writable }) = this.machine.file_handler.handles.get(&fd) {
+            let io_result = maybe_sync_file(file, *writable, File::sync_data);
+            this.try_unwrap_io_result(io_result)
+        } else {
+            this.handle_not_found()
+        }
+    }
 }
 
 /// Extracts the number of seconds and nanoseconds elapsed between `time` and the unix epoch when

tests/run-pass/fs.rs

@@ -14,6 +14,7 @@ fn main() {
     test_seek();
     test_metadata();
     test_file_set_len();
+    test_file_sync();
     test_symlink();
     test_errors();
     test_rename();
@@ -182,6 +183,23 @@ fn test_file_set_len() {
     remove_file(&path).unwrap();
 }
 
+fn test_file_sync() {
+    let bytes = b"Hello, World!\n";
+    let path = prepare_with_content("miri_test_fs_sync.txt", bytes);
+
+    // Test that we can call sync_data and sync_all (can't readily test effects of this operation)
+    let file = OpenOptions::new().write(true).open(&path).unwrap();
+    file.sync_data().unwrap();
+    file.sync_all().unwrap();
+
+    // Test that we can call sync_data and sync_all on a file opened for reading.
+    let file = File::open(&path).unwrap();
+    file.sync_data().unwrap();
+    file.sync_all().unwrap();
+
+    remove_file(&path).unwrap();
+}
+
 fn test_symlink() {
     let bytes = b"Hello, World!\n";
     let path = prepare_with_content("miri_test_fs_link_target.txt", bytes);

tests/run-pass/libc.rs

@@ -17,7 +17,7 @@ fn test_posix_fadvise() {
     use std::io::Write;
     use std::os::unix::io::AsRawFd;
 
-    let path = tmp().join("miri_test_libc.txt");
+    let path = tmp().join("miri_test_libc_posix_fadvise.txt");
     // Cleanup before test
     remove_file(&path).ok();
 
@@ -40,6 +40,53 @@ fn test_posix_fadvise() {
     assert_eq!(result, 0);
 }
 
+#[cfg(target_os = "linux")]
+fn test_sync_file_range() {
+    use std::fs::{remove_file, File};
+    use std::io::Write;
+    use std::os::unix::io::AsRawFd;
+
+    let path = tmp().join("miri_test_libc_sync_file_range.txt");
+    // Cleanup before test.
+    remove_file(&path).ok();
+
+    // Write to a file.
+    let mut file = File::create(&path).unwrap();
+    let bytes = b"Hello, World!\n";
+    file.write(bytes).unwrap();
+
+    // Test calling sync_file_range on the file.
+    let result_1 = unsafe {
+        libc::sync_file_range(
+            file.as_raw_fd(),
+            0,
+            0,
+            libc::SYNC_FILE_RANGE_WAIT_BEFORE
+                | libc::SYNC_FILE_RANGE_WRITE
+                | libc::SYNC_FILE_RANGE_WAIT_AFTER,
+        )
+    };
+    drop(file);
+
+    // Test calling sync_file_range on a file opened for reading.
+    let file = File::open(&path).unwrap();
+    let result_2 = unsafe {
+        libc::sync_file_range(
+            file.as_raw_fd(),
+            0,
+            0,
+            libc::SYNC_FILE_RANGE_WAIT_BEFORE
+                | libc::SYNC_FILE_RANGE_WRITE
+                | libc::SYNC_FILE_RANGE_WAIT_AFTER,
+        )
+    };
+    drop(file);
+
+    remove_file(&path).unwrap();
+    assert_eq!(result_1, 0);
+    assert_eq!(result_2, 0);
+}
+
 fn test_mutex_libc_init_recursive() {
     unsafe {
         let mut attr: libc::pthread_mutexattr_t = std::mem::zeroed();
@@ -169,6 +216,9 @@ fn main() {
     #[cfg(target_os = "linux")]
     test_posix_fadvise();
 
+    #[cfg(target_os = "linux")]
+    test_sync_file_range();
+
     test_mutex_libc_init_recursive();
     test_mutex_libc_init_normal();
     test_mutex_libc_init_errorcheck();