* NEWS: Mention it.
* doc/coreutils.texi (cp invocation): Describe it.
* src/copy.h (struct cp_options) [reflink]: New member.
* src/copy.c (usage): Describe it.
(copy_reg): If reflink is true try to clone the file.
(main): Check for --reflink.
(cp_option_init): Initialize the new member.
* src/install.c (cp_option_init): Initialize the new member.
* src/mv.c (cp_option_init): Likewise.
* tests/cp/sparse: Add a new test case.
chroot now accepts the options --userspec and --groups.
+ cp accepts a new option, --reflink: create a lightweight copy
+ using copy-on-write (COW). This is currently supported only on
+ btrfs file systems.
+
cp now preserves time stamps on symbolic links, when possible
cp, install, mv: take advantage of btrfs' O(1) copy-on-write feature
unless you also specify @option{-P}, as @acronym{POSIX} allows
implementations that dereference symbolic links by default.
+@item --reflink
+@opindex --reflink
+Perform a lightweight, copy-on-write (COW) copy.
+Copying with this option can succeed only on some relatively new file systems.
+Once it has succeeded, beware that the source and destination files
+share the same disk data blocks as long as they remain unmodified.
+Thus, if a disk I/O error affects data blocks of one of the files,
+the other suffers the exact same fate.
+
@item --remove-destination
@opindex --remove-destination
Remove each existing destination file before attempting to open it
goto close_src_and_dst_desc;
}
- /* If --sparse=auto is in effect, attempt a btrfs clone operation.
- If the operation is not supported or it fails then copy the file
- in the usual way. */
- bool copied = (x->sparse_mode == SPARSE_AUTO
- && clone_file (dest_desc, source_desc) == 0);
+ if (x->reflink)
+ {
+ if (clone_file (dest_desc, source_desc))
+ {
+ error (0, errno, _("failed to clone %s"), quote (dst_name));
+ return_val = false;
+ }
+ goto close_src_and_dst_desc;
+ }
- if (!copied)
{
typedef uintptr_t word;
off_t n_read_total = 0;
assert (VALID_BACKUP_TYPE (co->backup_type));
assert (VALID_SPARSE_MODE (co->sparse_mode));
assert (!(co->hard_link && co->symbolic_link));
+ assert (!(co->reflink && co->sparse_mode != SPARSE_AUTO));
return true;
}
such a symlink) and returns false. */
bool open_dangling_dest_symlink;
+ /* If true, attempt to clone the file instead of copying it. */
+ bool reflink;
+
/* This is a set of destination name/inode/dev triples. Each such triple
represents a file we have created corresponding to a source file name
that was specified on the command line. Use it to avoid clobbering
NO_PRESERVE_ATTRIBUTES_OPTION,
PARENTS_OPTION,
PRESERVE_ATTRIBUTES_OPTION,
+ REFLINK_OPTION,
SPARSE_OPTION,
STRIP_TRAILING_SLASHES_OPTION,
UNLINK_DEST_BEFORE_OPENING
{"recursive", no_argument, NULL, 'R'},
{"remove-destination", no_argument, NULL, UNLINK_DEST_BEFORE_OPENING},
{"sparse", required_argument, NULL, SPARSE_OPTION},
+ {"reflink", no_argument, NULL, REFLINK_OPTION},
{"strip-trailing-slashes", no_argument, NULL, STRIP_TRAILING_SLASHES_OPTION},
{"suffix", required_argument, NULL, 'S'},
{"symbolic-link", no_argument, NULL, 's'},
"), stdout);
fputs (_("\
-R, -r, --recursive copy directories recursively\n\
+ --reflink perform a lightweight (CoW/clone) copy\n\
--remove-destination remove each existing destination file before\n\
attempting to open it (contrast with --force)\n\
"), stdout);
x->interactive = I_UNSPECIFIED;
x->move_mode = false;
x->one_file_system = false;
+ x->reflink = false;
x->preserve_ownership = false;
x->preserve_links = false;
sparse_type_string, sparse_type);
break;
+ case REFLINK_OPTION:
+ x.reflink = true;
+ break;
+
case 'a': /* Like -dR --preserve=all with reduced failure diagnostics. */
x.dereference = DEREF_NEVER;
x.preserve_links = true;
usage (EXIT_FAILURE);
}
+ if (x.reflink && x.sparse_mode != SPARSE_AUTO)
+ {
+ error (0, 0, _("--reflink can be used only with --sparse=auto"));
+ usage (EXIT_FAILURE);
+ }
+
if (backup_suffix_string)
simple_backup_suffix = xstrdup (backup_suffix_string);
{
cp_options_default (x);
x->copy_as_regular = true;
+ x->reflink = false;
x->dereference = DEREF_ALWAYS;
x->unlink_dest_before_opening = true;
x->unlink_dest_after_failed_open = false;
cp_options_default (x);
x->copy_as_regular = false; /* FIXME: maybe make this an option */
+ x->reflink = false;
x->dereference = DEREF_NEVER;
x->unlink_dest_before_opening = false;
x->unlink_dest_after_failed_open = false;
# Ensure that the copy has the same block count as the original.
test `stat --printf %b copy` -le `stat --printf %b sparse` || fail=1
+# Ensure that --sparse={always,never} with --reflink fail.
+cp --sparse=always --reflink sparse copy && fail=1
+cp --sparse=never --reflink sparse copy && fail=1
+
Exit $fail