file: implement relaxed sync for macos

On macOS, fsync() flushes the filesystem cache to the drive, but doesn't
request the drive to flush it's internal cache to its persistent
storage. To do the latter, there's a specific fcntl: F_FULLFSYNC.

The reason why they decided to have fsync() behave this way it's because
in Apple Silicon hardware flushing the drive cache has a very
significant performance impact.

In File::sync() we were calling std::fs::File::sync_all(), which does
use F_FULLSYNC, which is safer but comes with a high cost.

Let's allow crate users on macOS opt for a more relaxed synchronization
using fsync() instead of std::fs::File::sync_all(). Expose the option
in StorageOpenOptions as relaxed_sync but gate it behind a build-time
conditional for target_os = macos.

Signed-off-by: Sergio Lopez <slp@redhat.com>
(cherry picked from commit 16db536)
Signed-off-by: Hanna Czenczek <hreitz@redhat.com>

Author: slp

src/file.rs

@@ -54,6 +54,10 @@ pub struct File {
 
     /// Storage helper.
     common_storage_helper: CommonStorageHelper,
+
+    /// macOS-only: Use fsync() instead of F_FULLFSYNC on `sync()` method.
+    #[cfg(target_os = "macos")]
+    relaxed_sync: bool,
 }
 
 impl TryFrom<fs::File> for File {
@@ -66,7 +70,13 @@ impl TryFrom<fs::File> for File {
     /// When using this, the resulting object will not know its own filename.  That makes it
     /// impossible to auto-resolve relative paths to it, e.g. qcow2 backing file names.
     fn try_from(file: fs::File) -> io::Result<Self> {
-        Self::new(file, None, false)
+        Self::new(
+            file,
+            None,
+            false,
+            #[cfg(target_os = "macos")]
+            false,
+        )
     }
 }
 
@@ -333,6 +343,12 @@ impl Storage for File {
     }
 
     async fn sync(&self) -> io::Result<()> {
+        #[cfg(target_os = "macos")]
+        if self.relaxed_sync {
+            // Safe: File descriptor is valid and there aren't any other arguments.
+            while_eintr(|| unsafe { libc::fsync(self.file.write().unwrap().as_raw_fd()) })?;
+            return Ok(());
+        }
         self.file.write().unwrap().sync_all()
     }
 
@@ -346,7 +362,12 @@ impl File {
     ///
     /// `direct_io` should be `true` if direct I/O was requested, and can be `false` if that status
     /// is unknown.
-    fn new(mut file: fs::File, filename: Option<PathBuf>, direct_io: bool) -> io::Result<Self> {
+    fn new(
+        mut file: fs::File,
+        filename: Option<PathBuf>,
+        direct_io: bool,
+        #[cfg(target_os = "macos")] relaxed_sync: bool,
+    ) -> io::Result<Self> {
         let size = get_file_size(&file).err_context(|| "Failed to determine file size")?;
 
         #[cfg(all(unix, not(target_os = "macos")))]
@@ -385,6 +406,8 @@ impl File {
             mem_align,
             size: size.into(),
             common_storage_helper: Default::default(),
+            #[cfg(target_os = "macos")]
+            relaxed_sync,
         })
     }
 
@@ -663,7 +686,13 @@ impl File {
                 .err_context(|| "Failed to disable host cache")?;
         }
 
-        Self::new(file, Some(filename_owned), opts.direct)
+        Self::new(
+            file,
+            Some(filename_owned),
+            opts.direct,
+            #[cfg(target_os = "macos")]
+            opts.relaxed_sync,
+        )
     }
 
     /// Attempt to discard range by truncating the file.

src/storage/mod.rs

@@ -27,6 +27,10 @@ pub struct StorageOpenOptions {
 
     /// Whether to bypass the host page cache (if applicable).
     pub(crate) direct: bool,
+
+    /// macOS-only: Use fsync() instead of F_FULLFSYNC on `sync()` method.
+    #[cfg(target_os = "macos")]
+    pub(crate) relaxed_sync: bool,
 }
 
 /// Implementation for storage objects.
@@ -533,6 +537,18 @@ impl StorageOpenOptions {
         self
     }
 
+    /// macOS-only: whether to use relaxed synchronization on `File`.
+    ///
+    /// If relaxed synchronization is enabled, `File::sync()` will use the `fsync()` syscall
+    /// instead of `fcntl(F_FULLFSYNC)`, which is a lighter synchronization mechanism that flushes
+    /// the filesystem cache to the drive, but doesn't request the drive to flush its internal
+    /// buffers to persistent storage.
+    #[cfg(target_os = "macos")]
+    pub fn relaxed_sync(mut self, relaxed_sync: bool) -> Self {
+        self.relaxed_sync = relaxed_sync;
+        self
+    }
+
     /// Get the set filename (if any).
     pub fn get_filename(&self) -> Option<&Path> {
         self.filename.as_deref()
@@ -547,4 +563,10 @@ impl StorageOpenOptions {
     pub fn get_direct(&self) -> bool {
         self.direct
     }
+
+    /// macOS-only: return the relaxed synchronization state.
+    #[cfg(target_os = "macos")]
+    pub fn get_relaxed_sync(&self) -> bool {
+        self.relaxed_sync
+    }
 }