Implement hard linking support (closes #46)

Signed-off-by: Alex Saveau <[email protected]>

Author: SUPERCILEX

Cargo.lock

@@ -26,7 +26,7 @@ edition.workspace = true
 publish = false
 
 [dev-dependencies]
-supercilex-tests = { version = "0.4.16", default-features = false }
+supercilex-tests = { version = "0.4.17", default-features = false }
 
 [profile.release]
 lto = true

Cargo.toml

@@ -26,7 +26,7 @@ cache-size = "0.7.0"
 criterion = "0.6.0"
 memmap2 = "0.9.5"
 rand = "0.9.1"
-supercilex-tests = { version = "0.4.16", default-features = false, features = ["clap"] }
+supercilex-tests = { version = "0.4.17", default-features = false, features = ["clap"] }
 tempfile = "3.20.0"
 trycmd = "0.15.9"
 

cpz/Cargo.toml

@@ -92,6 +92,9 @@ Options:
   -L, --dereference
           Follow symlinks in the files to be copied rather than copying the symlinks themselves
 
+  -l, --link
+          Create hard links instead of copying file data
+
   -h, --help
           Print help (use `-h` for a summary)
 

cpz/README.md

@@ -11,5 +11,6 @@ Options:
   -t, --reverse-args  Reverse the argument order so that it becomes `cpz <TO> <FROM>...`
   -L, --dereference   Follow symlinks in the files to be copied rather than copying the symlinks
                       themselves
+  -l, --link          Create hard links instead of copying file data
   -h, --help          Print help (use `--help` for more detail)
   -V, --version       Print version

cpz/command-reference-short.golden

@@ -23,6 +23,9 @@ Options:
   -L, --dereference
           Follow symlinks in the files to be copied rather than copying the symlinks themselves
 
+  -l, --link
+          Create hard links instead of copying file data
+
   -h, --help
           Print help (use `-h` for a summary)
 

cpz/command-reference.golden

@@ -50,6 +50,11 @@ struct Cpz {
     #[cfg_attr(windows, arg(default_value_t = true))]
     dereference: bool,
 
+    /// Create hard links instead of copying file data
+    #[arg(short = 'l', long, default_value_t = false)]
+    #[arg(aliases = ["hard-link"])]
+    link: bool,
+
     #[arg(short, long, short_alias = '?', global = true)]
     #[arg(action = ArgAction::Help, help = "Print help (use `--help` for more detail)")]
     #[arg(long_help = "Print help (use `-h` for a summary)")]
@@ -211,6 +216,7 @@ fn copy(
         force,
         reverse_args,
         dereference,
+        link,
         help: _,
     }: Cpz,
 ) -> Result<(), Error> {
@@ -252,6 +258,7 @@ fn copy(
                 .files($files)
                 .force(force)
                 .follow_symlinks(dereference)
+                .hard_link(link)
                 .build()
                 .run()
         };

cpz/src/main.rs

@@ -28,5 +28,5 @@ remove_dir_all = { version = "1.0.0", features = ["parallel"] }
 ftzz = "3.0.0"
 io-adapters = "0.4.0"
 rstest = { version = "0.25.0", default-features = false }
-supercilex-tests = { version = "0.4.16", default-features = false, features = ["api"] }
+supercilex-tests = { version = "0.4.17", default-features = false, features = ["api"] }
 tempfile = "3.20.0"

fuc_engine/Cargo.toml

@@ -32,6 +32,8 @@ pub struct CopyOp<
     force: bool,
     #[builder(default = false)]
     follow_symlinks: bool,
+    #[builder(default = false)]
+    hard_link: bool,
     #[builder(skip)]
     _marker1: PhantomData<&'a I1>,
     #[builder(skip)]
@@ -52,7 +54,7 @@ impl<
     ///
     /// Returns the underlying I/O errors that occurred.
     pub fn run(self) -> Result<(), Error> {
-        let copy = compat::copy_impl(self.follow_symlinks);
+        let copy = compat::copy_impl(self.follow_symlinks, self.hard_link);
         let result = schedule_copies(self, &copy);
         copy.finish().and(result)
     }
@@ -73,6 +75,7 @@ fn schedule_copies<
         files,
         force,
         follow_symlinks,
+        hard_link,
         _marker1: _,
         _marker2: _,
     }: CopyOp<'a, 'b, I1, I2, F>,
@@ -119,8 +122,20 @@ fn schedule_copies<
                 Err(e) if e.kind() == io::ErrorKind::NotFound => (),
                 r => r.map_io_err(|| format!("Failed to remove existing file: {to:?}"))?,
             }
-            std::os::unix::fs::symlink(link, &to)
-                .map_io_err(|| format!("Failed to create symlink: {to:?}"))?;
+            if hard_link {
+                fs::hard_link(&link, &to)
+                    .map_io_err(|| format!("Failed to create hard link: {to:?} -> {link:?}"))?;
+            } else {
+                std::os::unix::fs::symlink(&link, &to)
+                    .map_io_err(|| format!("Failed to create symlink: {to:?} -> {link:?}"))?;
+            }
+        } else if hard_link {
+            match fs::remove_file(&to) {
+                Err(e) if e.kind() == io::ErrorKind::NotFound => (),
+                r => r.map_io_err(|| format!("Failed to remove existing file: {to:?}"))?,
+            }
+            fs::hard_link(&from, &to)
+                .map_io_err(|| format!("Failed to create hard link: {to:?} -> {from:?}"))?;
         } else {
             fs::copy(&from, &to).map_io_err(|| format!("Failed to copy file: {from:?}"))?;
         }
@@ -156,8 +171,8 @@ mod compat {
     use crossbeam_channel::{Receiver, Sender};
     use rustix::{
         fs::{
-            AtFlags, CWD, FileType, Mode, OFlags, RawDir, StatxFlags, copy_file_range, mkdirat,
-            openat, readlinkat, statx, symlinkat,
+            AtFlags, CWD, FileType, Mode, OFlags, RawDir, StatxFlags, copy_file_range, linkat,
+            mkdirat, openat, readlinkat, statx, symlinkat,
         },
         io::Errno,
         thread::{UnshareFlags, unshare},
@@ -174,12 +189,17 @@ mod compat {
 
     pub fn copy_impl<'a, 'b>(
         follow_symlinks: bool,
+        hard_link: bool,
     ) -> impl DirectoryOp<(Cow<'a, Path>, Cow<'b, Path>)> {
         let scheduling = LazyCell::new(move || {
             let (tx, rx) = crossbeam_channel::unbounded();
             (
                 tx,
-                thread::spawn(move || root_worker_thread(rx, follow_symlinks)),
+                if hard_link {
+                    thread::spawn(move || root_worker_thread::<true>(rx, follow_symlinks))
+                } else {
+                    thread::spawn(move || root_worker_thread::<false>(rx, follow_symlinks))
+                },
             )
         });
 
@@ -221,7 +241,10 @@ mod compat {
     }
 
     #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip(tasks)))]
-    fn root_worker_thread(tasks: Receiver<TreeNode>, follow_symlinks: bool) -> Result<(), Error> {
+    fn root_worker_thread<const HARD_LINK: bool>(
+        tasks: Receiver<TreeNode>,
+        follow_symlinks: bool,
+    ) -> Result<(), Error> {
         unshare_files()?;
 
         let mut available_parallelism = thread::available_parallelism()
@@ -265,13 +288,19 @@ mod compat {
                             available_parallelism -= 1;
                             threads.push(scope.spawn({
                                 let tasks = tasks.clone();
-                                move || worker_thread(tasks, root_to_inode, follow_symlinks)
+                                move || {
+                                    worker_thread::<HARD_LINK>(
+                                        tasks,
+                                        root_to_inode,
+                                        follow_symlinks,
+                                    )
+                                }
                             }));
                         }
                     };
                     maybe_spawn();
 
-                    copy_dir(
+                    copy_dir::<HARD_LINK>(
                         node,
                         root_to_inode,
                         follow_symlinks,
@@ -290,7 +319,7 @@ mod compat {
     }
 
     #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip(tasks)))]
-    fn worker_thread(
+    fn worker_thread<const HARD_LINK: bool>(
         tasks: Receiver<TreeNode>,
         root_to_inode: u64,
         follow_symlinks: bool,
@@ -300,7 +329,7 @@ mod compat {
         let mut buf = [MaybeUninit::<u8>::uninit(); 8192];
         let symlink_buf_cache = Cell::new(Vec::new());
         for node in tasks {
-            copy_dir(
+            copy_dir::<HARD_LINK>(
                 node,
                 root_to_inode,
                 follow_symlinks,
@@ -339,7 +368,7 @@ mod compat {
         feature = "tracing",
         tracing::instrument(level = "info", skip(messages, buf, symlink_buf_cache, maybe_spawn))
     )]
-    fn copy_dir(
+    fn copy_dir<const HARD_LINK: bool>(
         TreeNode { from, to, messages }: TreeNode,
         root_to_inode: u64,
         follow_symlinks: bool,
@@ -402,6 +431,20 @@ mod compat {
                         messages: messages.clone(),
                     })
                     .map_err(|_| Error::Internal)?;
+            } else if HARD_LINK {
+                let name = file.file_name();
+                let flags = if follow_symlinks {
+                    AtFlags::SYMLINK_FOLLOW
+                } else {
+                    AtFlags::empty()
+                };
+                linkat(&from_dir, name, &to_dir, name, flags).map_io_err(|| {
+                    format!(
+                        "Failed to create symlink: {:?} -> {:?}",
+                        join_cstr_paths(&to, name),
+                        join_cstr_paths(&from, name),
+                    )
+                })?;
             } else {
                 copy_one_file(
                     &from_dir,
@@ -614,8 +657,8 @@ mod compat {
 
         symlinkat(&from_symlink, &to_dir, file_name).map_io_err(|| {
             format!(
-                "Failed to create symlink: {:?}",
-                join_cstr_paths(to_path, file_name)
+                "Failed to create symlink: {:?} -> {from_symlink:?}",
+                join_cstr_paths(to_path, file_name),
             )
         })?;
 
@@ -652,18 +695,23 @@ mod compat {
 
     struct Impl {
         follow_symlinks: bool,
+        hard_link: bool,
     }
 
     pub fn copy_impl<'a, 'b>(
         follow_symlinks: bool,
+        hard_link: bool,
     ) -> impl DirectoryOp<(Cow<'a, Path>, Cow<'b, Path>)> {
-        Impl { follow_symlinks }
+        Impl {
+            follow_symlinks,
+            hard_link,
+        }
     }
 
     impl DirectoryOp<(Cow<'_, Path>, Cow<'_, Path>)> for Impl {
         #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip(self)))]
         fn run(&self, (from, to): (Cow<Path>, Cow<Path>)) -> Result<(), Error> {
-            copy_dir(&from, to, self.follow_symlinks, None)
+            copy_dir(&from, to, self.follow_symlinks, self.hard_link, None)
                 .map_io_err(|| format!("Failed to copy directory: {from:?}"))
         }
 
@@ -678,6 +726,7 @@ mod compat {
         from: P,
         to: Q,
         follow_symlinks: bool,
+        hard_link: bool,
         root_to_inode: Option<u64>,
     ) -> Result<(), io::Error> {
         let to = to.as_ref();
@@ -713,17 +762,29 @@ mod compat {
                 };
 
                 if file_type.is_dir() {
-                    copy_dir(dir_entry.path(), to, follow_symlinks, root_to_inode)?;
+                    copy_dir(
+                        dir_entry.path(),
+                        to,
+                        follow_symlinks,
+                        hard_link,
+                        root_to_inode,
+                    )?;
                 } else if file_type.is_symlink() {
                     let from = fs::read_link(dir_entry.path())?;
-                    #[cfg(unix)]
-                    std::os::unix::fs::symlink(from, to)?;
-                    #[cfg(windows)]
-                    if fs::metadata(&from)?.file_type().is_dir() {
-                        std::os::windows::fs::symlink_dir(from, to)?;
+                    if hard_link {
+                        fs::hard_link(dir_entry.path(), to)?;
                     } else {
-                        std::os::windows::fs::symlink_file(from, to)?;
+                        #[cfg(unix)]
+                        std::os::unix::fs::symlink(from, to)?;
+                        #[cfg(windows)]
+                        if fs::metadata(&from)?.file_type().is_dir() {
+                            std::os::windows::fs::symlink_dir(from, to)?;
+                        } else {
+                            std::os::windows::fs::symlink_file(from, to)?;
+                        }
                     }
+                } else if hard_link {
+                    fs::hard_link(dir_entry.path(), to)?;
                 } else {
                     fs::copy(dir_entry.path(), to)?;
                 }

fuc_engine/src/ops/copy.rs

@@ -28,7 +28,7 @@ io-adapters = "0.4.0"
 remove_dir_all = { version = "1.0.0", features = ["parallel"] }
 rm_og_crappy = { path = "../comparisons/rm_og_crappy" }
 rm_rayon = { path = "../comparisons/rm_rayon" }
-supercilex-tests = { version = "0.4.16", default-features = false, features = ["clap"] }
+supercilex-tests = { version = "0.4.17", default-features = false, features = ["clap"] }
 tempfile = "3.20.0"
 trycmd = "0.15.9"