Add the option to use reflinks (i.e. copy on write semantics).

Using the reflink crate, with the option to disallow completely
(never), auto (use when available), or always (fail if not possible).

Conditional on the new feature "copy_on_write", enabled by default
(given this already is an "extra" crate).

Author: mwanner

Cargo.toml

@@ -16,4 +16,9 @@ include = [
     "CHANGELOG.md",
 ]
 
+[features]
+default = ["copy_on_write"]
+copy_on_write = ["reflink"]
+
 [dependencies]
+reflink = { version = "^0.1.0", optional = true }

src/dir.rs

@@ -4,9 +4,10 @@ use std::convert::From;
 use std::fs::{create_dir, create_dir_all, read_dir, remove_dir_all, Metadata};
 use std::path::{Path, PathBuf};
 use std::time::SystemTime;
+use super::RefLinkUsage;
 
 ///	Options and flags which can be used to configure how a file will be  copied  or moved.
-#[derive(Clone)]
+#[derive(Debug, Copy, Clone)]
 pub struct CopyOptions {
     /// Sets the option true for overwrite existing files.
     pub overwrite: bool,
@@ -22,6 +23,8 @@ pub struct CopyOptions {
     ///
     /// Warning: Work only for copy operations!
     pub depth: u64,
+    /// Controls the usage of reflinks for files on filesystems supporting it.
+    pub reflink: RefLinkUsage,
 }
 
 impl CopyOptions {
@@ -44,6 +47,7 @@ impl CopyOptions {
             copy_inside: false,
             content_only: false,
             depth: 0,
+            reflink: RefLinkUsage::Never,
         }
     }
 }

src/file.rs

@@ -4,6 +4,7 @@ use std::convert::From;
 use std::fs::{remove_file, File};
 use std::io::{Read, Write};
 use std::path::Path;
+use super::RefLinkUsage;
 
 ///	Options and flags which can be used to configure how a file will be  copied  or moved.
 #[derive(Debug, Copy, Clone)]
@@ -14,6 +15,8 @@ pub struct CopyOptions {
     pub skip_exist: bool,
     /// Sets buffer size for copy/move work only with receipt information about process work.
     pub buffer_size: usize,
+    /// Controls the usage of reflinks on filesystems supporting it.
+    pub reflink: RefLinkUsage,
 }
 
 impl CopyOptions {
@@ -32,6 +35,7 @@ impl CopyOptions {
             overwrite: false,
             skip_exist: false,
             buffer_size: 64000, //64kb
+            reflink: RefLinkUsage::Never,
         }
     }
 }
@@ -48,6 +52,7 @@ impl From<&super::dir::CopyOptions> for CopyOptions {
             overwrite: dir_options.overwrite,
             skip_exist: dir_options.skip_exist,
             buffer_size: dir_options.buffer_size,
+            reflink: dir_options.reflink,
         }
     }
 }
@@ -118,7 +123,18 @@ where
         }
     }
 
-    Ok(std::fs::copy(from, to)?)
+    Ok(match options.reflink {
+        RefLinkUsage::Never => std::fs::copy(from, to)?,
+
+        #[cfg(feature = "copy_on_write")]
+        RefLinkUsage::Auto => reflink::reflink_or_copy(from, to)?.unwrap_or(0),
+
+        #[cfg(feature = "copy_on_write")]
+        RefLinkUsage::Always => {
+            reflink::reflink(from, to)?;
+            0
+        },
+    })
 }
 
 /// Copies the contents of one file to another with recept information about process.
@@ -187,6 +203,18 @@ where
             err!(&msg, ErrorKind::AlreadyExists);
         }
     }
+
+    #[cfg(feature = "copy_on_write")]
+    if options.reflink != RefLinkUsage::Never {
+        match reflink::reflink(&from, &to) {
+            Ok(()) => return Ok(0),
+            Err(e) if options.reflink == RefLinkUsage::Always => {
+                return Err(::std::convert::From::from(e));
+            },
+            Err(_) => { /* continue with plain copy */ }
+        }
+    }
+
     let mut file_from = File::open(from)?;
     let mut buf = vec![0; options.buffer_size];
     let file_size = file_from.metadata()?.len();

src/lib.rs

@@ -1,3 +1,6 @@
+#[cfg(feature = "copy_on_write")]
+extern crate reflink;
+
 macro_rules! err {
     ($text:expr, $kind:expr) => {
         return Err(Error::new($kind, $text));
@@ -156,6 +159,20 @@ pub mod dir;
 use error::*;
 use std::path::Path;
 
+/// Possible values for the reflink field in CopyOptions.  These
+/// correspond to the `--reflink` option of the Unix `cp` command.
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum RefLinkUsage {
+    /// Do not use reflinks.
+    Never,
+    /// Use reflinks if possible.
+    #[cfg(feature = "copy_on_write")]
+    Auto,
+    /// Force use of reflinks, error out if not possible.
+    #[cfg(feature = "copy_on_write")]
+    Always,
+}
+
 /// Copies list directories and files to another place using recursive method. This function will
 /// also copy the permission bits of the original files to destionation files (not for
 /// directories).