Implement reflink copy with automatic fallback for faster tree copying (#557)

This might be faster or use less disk space when source and tmp are on the same filesystem and the filesystem supports reflinks.

Author: sourcefrog

Cargo.lock

@@ -47,6 +47,7 @@ num_cpus = "1.16"
 patch = "0.7"
 path-slash = "0.2"
 quote = "1.0.35"
+reflink = "0.1"
 regex = "1.10"
 schemars = "0.9"
 serde_json = "1.0.128"

Cargo.toml

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Changed: Tree copying now attempts to use reflinks (copy-on-write) for faster copying on supported filesystems (Btrfs, XFS, APFS), with automatic fallback to regular copying.
+
 - Book: Recommend using the `-Zunstable-options --fail-fast` argument to test targets to speed up mutation testing, on recent nightly toolchains.
 
 - Fixed: Don't error if the `--in-diff` patch file contains non-UTF-8 data in non-Rust files.

NEWS.md

@@ -2,10 +2,13 @@
 
 //! Copy a source tree, with some exclusions, to a new temporary directory.
 
+use std::fs;
+use std::path::Path;
+use std::sync::atomic::{AtomicBool, Ordering};
+
 use anyhow::Context;
 use camino::{Utf8Path, Utf8PathBuf};
 use ignore::WalkBuilder;
-use path_slash::PathExt;
 use tempfile::TempDir;
 use tracing::{debug, warn};
 
@@ -24,6 +27,32 @@ use windows::copy_symlink;
 
 static VCS_DIRS: &[&str] = &[".git", ".hg", ".bzr", ".svn", "_darcs", ".jj", ".pijul"];
 
+/// Copy a file, attempting to use reflink if supported.
+/// Returns the number of bytes copied.
+fn copy_file(src: &Path, dest: &Path, reflink_supported: &AtomicBool) -> Result<u64> {
+    // Try reflink first if we haven't determined it's not supported
+    if reflink_supported.load(Ordering::Relaxed) {
+        match reflink::reflink(src, dest) {
+            Ok(()) => {
+                // Reflink succeeded, get file size for progress tracking
+                let metadata = fs::metadata(dest)
+                    .with_context(|| format!("Failed to get metadata for {}", dest.display()))?;
+                return Ok(metadata.len());
+            }
+            Err(e) => {
+                // On Windows, reflink can fail without returning ErrorKind::Unsupported,
+                // so we give up on reflinks after any error to avoid repeated failures.
+                reflink_supported.store(false, Ordering::Relaxed);
+                debug!("Reflink failed: {}, falling back to regular copy", e);
+            }
+        }
+    }
+
+    // Fall back to regular copy
+    fs::copy(src, dest)
+        .with_context(|| format!("Failed to copy {} to {}", src.display(), dest.display()))
+}
+
 /// Copy a source tree, with some exclusions, to a new temporary directory.
 pub fn copy_tree(
     from_path: &Utf8Path,
@@ -33,6 +62,7 @@ pub fn copy_tree(
 ) -> Result<TempDir> {
     let mut total_bytes = 0;
     let mut total_files = 0;
+    let reflink_supported = AtomicBool::new(true);
     let temp_dir = tempfile::Builder::new()
         .prefix(name_base)
         .suffix(".tmp")
@@ -86,12 +116,8 @@ pub fn copy_tree(
             )
         })?;
         if ft.is_file() {
-            let bytes_copied = std::fs::copy(entry.path(), &dest_path).with_context(|| {
-                format!(
-                    "Failed to copy {:?} to {dest_path:?}",
-                    entry.path().to_slash_lossy(),
-                )
-            })?;
+            let bytes_copied =
+                copy_file(entry.path(), dest_path.as_std_path(), &reflink_supported)?;
             total_bytes += bytes_copied;
             total_files += 1;
             console.copy_progress(dest, total_bytes);
@@ -112,7 +138,8 @@ pub fn copy_tree(
         }
     }
     console.finish_copy(dest);
-    debug!(?total_bytes, ?total_files, temp_dir = ?temp_dir.path(), "Copied source tree");
+    let reflink_used = reflink_supported.load(Ordering::Relaxed);
+    debug!(?total_bytes, ?total_files, ?reflink_used, temp_dir = ?temp_dir.path(), "Copied source tree");
     Ok(temp_dir)
 }