vfs: pull btrfs clone API to vfs layer

The btrfs clone ioctls are now adopted by other file systems, with NFS
and CIFS already having support for them, and XFS being under active
development.  To avoid growth of various slightly incompatible
implementations, add one to the VFS.  Note that clones are different from
file copies in several ways:

 - they are atomic vs other writers
 - they support whole file clones
 - they support 64-bit legth clones
 - they do not allow partial success (aka short writes)
 - clones are expected to be a fast metadata operation

Because of that it would be rather cumbersome to try to piggyback them on
top of the recent clone_file_range infrastructure.  The converse isn't
true and the clone_file_range system call could try clone file range as
a first attempt to copy, something that further patches will enable.

Based on earlier work from Peng Tao.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

1 files changed, 59 insertions, 67 deletions

diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index 35cf990f87d3..7a3b84e300f8 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -34,73 +34,36 @@
 #include "cifs_ioctl.h"
 #include <linux/btrfs.h>
 
-static long cifs_ioctl_clone(unsigned int xid, struct file *dst_file,
-                        unsigned long srcfd, u64 off, u64 len, u64 destoff,
-                        bool dup_extents)
+static int cifs_file_clone_range(unsigned int xid, struct file *src_file,
+                          struct file *dst_file)
 {
-        int rc;
-        struct cifsFileInfo *smb_file_target = dst_file->private_data;
+        struct inode *src_inode = file_inode(src_file);
         struct inode *target_inode = file_inode(dst_file);
-        struct cifs_tcon *target_tcon;
-        struct fd src_file;
         struct cifsFileInfo *smb_file_src;
-        struct inode *src_inode;
+        struct cifsFileInfo *smb_file_target;
         struct cifs_tcon *src_tcon;
+        struct cifs_tcon *target_tcon;
+        int rc;
 
         cifs_dbg(FYI, "ioctl clone range\n");
-        /* the destination must be opened for writing */
-        if (!(dst_file->f_mode & FMODE_WRITE)) {
-                cifs_dbg(FYI, "file target not open for write\n");
-                return -EINVAL;
-        }
 
-        /* check if target volume is readonly and take reference */
-        rc = mnt_want_write_file(dst_file);
-        if (rc) {
-                cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc);
-                return rc;
-        }
-
-        src_file = fdget(srcfd);
-        if (!src_file.file) {
-                rc = -EBADF;
-                goto out_drop_write;
-        }
-
-        if (src_file.file->f_op->unlocked_ioctl != cifs_ioctl) {
-                rc = -EBADF;
-                cifs_dbg(VFS, "src file seems to be from a different filesystem type\n");
-                goto out_fput;
-        }
-
-        if ((!src_file.file->private_data) || (!dst_file->private_data)) {
+        if (!src_file->private_data || !dst_file->private_data) {
                 rc = -EBADF;
                 cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
-                goto out_fput;
+                goto out;
         }
 
         rc = -EXDEV;
         smb_file_target = dst_file->private_data;
-        smb_file_src = src_file.file->private_data;
+        smb_file_src = src_file->private_data;
         src_tcon = tlink_tcon(smb_file_src->tlink);
         target_tcon = tlink_tcon(smb_file_target->tlink);
 
-        /* check source and target on same server (or volume if dup_extents) */
-        if (dup_extents && (src_tcon != target_tcon)) {
-                cifs_dbg(VFS, "source and target of copy not on same share\n");
-                goto out_fput;
-        }
-
-        if (!dup_extents && (src_tcon->ses != target_tcon->ses)) {
+        if (src_tcon->ses != target_tcon->ses) {
                 cifs_dbg(VFS, "source and target of copy not on same server\n");
-                goto out_fput;
+                goto out;
         }
 
-        src_inode = file_inode(src_file.file);
-        rc = -EINVAL;
-        if (S_ISDIR(src_inode->i_mode))
-                goto out_fput;
-
         /*
          * Note: cifs case is easier than btrfs since server responsible for
          * checks for proper open modes and file type and if it wants
@@ -108,34 +71,66 @@ static long cifs_ioctl_clone(unsigned int xid, struct file *dst_file,
          */
         lock_two_nondirectories(target_inode, src_inode);
 
-        /* determine range to clone */
-        rc = -EINVAL;
-        if (off + len > src_inode->i_size || off + len < off)
-                goto out_unlock;
-        if (len == 0)
-                len = src_inode->i_size - off;
-
         cifs_dbg(FYI, "about to flush pages\n");
         /* should we flush first and last page first */
-        truncate_inode_pages_range(&target_inode->i_data, destoff,
-                                   PAGE_CACHE_ALIGN(destoff + len)-1);
+        truncate_inode_pages(&target_inode->i_data, 0);
 
-        if (dup_extents && target_tcon->ses->server->ops->duplicate_extents)
-                rc = target_tcon->ses->server->ops->duplicate_extents(xid,
-                        smb_file_src, smb_file_target, off, len, destoff);
-        else if (!dup_extents && target_tcon->ses->server->ops->clone_range)
+        if (target_tcon->ses->server->ops->clone_range)
                 rc = target_tcon->ses->server->ops->clone_range(xid,
-                        smb_file_src, smb_file_target, off, len, destoff);
+                        smb_file_src, smb_file_target, 0, src_inode->i_size, 0);
         else
                 rc = -EOPNOTSUPP;
 
         /* force revalidate of size and timestamps of target file now
            that target is updated on the server */
         CIFS_I(target_inode)->time = 0;
-out_unlock:
         /* although unlocking in the reverse order from locking is not
            strictly necessary here it is a little cleaner to be consistent */
         unlock_two_nondirectories(src_inode, target_inode);
+out:
+        return rc;
+}
+
+static long cifs_ioctl_clone(unsigned int xid, struct file *dst_file,
+                        unsigned long srcfd)
+{
+        int rc;
+        struct fd src_file;
+        struct inode *src_inode;
+
+        cifs_dbg(FYI, "ioctl clone range\n");
+        /* the destination must be opened for writing */
+        if (!(dst_file->f_mode & FMODE_WRITE)) {
+                cifs_dbg(FYI, "file target not open for write\n");
+                return -EINVAL;
+        }
+
+        /* check if target volume is readonly and take reference */
+        rc = mnt_want_write_file(dst_file);
+        if (rc) {
+                cifs_dbg(FYI, "mnt_want_write failed with rc %d\n", rc);
+                return rc;
+        }
+
+        src_file = fdget(srcfd);
+        if (!src_file.file) {
+                rc = -EBADF;
+                goto out_drop_write;
+        }
+
+        if (src_file.file->f_op->unlocked_ioctl != cifs_ioctl) {
+                rc = -EBADF;
+                cifs_dbg(VFS, "src file seems to be from a different filesystem type\n");
+                goto out_fput;
+        }
+
+        src_inode = file_inode(src_file.file);
+        rc = -EINVAL;
+        if (S_ISDIR(src_inode->i_mode))
+                goto out_fput;
+
+        rc = cifs_file_clone_range(xid, src_file.file, dst_file);
+
 out_fput:
         fdput(src_file);
 out_drop_write:
@@ -256,10 +251,7 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
                         }
                         break;
                 case CIFS_IOC_COPYCHUNK_FILE:
-                        rc = cifs_ioctl_clone(xid, filep, arg, 0, 0, 0, false);
-                        break;
-                case BTRFS_IOC_CLONE:
-                        rc = cifs_ioctl_clone(xid, filep, arg, 0, 0, 0, true);
+                        rc = cifs_ioctl_clone(xid, filep, arg);
                         break;
                 case CIFS_IOC_SET_INTEGRITY:
                         if (pSMBFile == NULL)