CIFS: SMB2/SMB3 Copy offload support (refcopy) phase 1

This first patch adds the ability for us to do a server side copy
(ie fast copy offloaded to the server to perform, aka refcopy)

"cp --reflink"

of one file to another located on the same server.  This
is much faster than traditional copy (which requires
reading and writing over the network and extra
memcpys).

This first version is not going to be copy
files larger than about 1MB (to Samba) until I add
support for multiple chunks and for autoconfiguring
the chunksize.

It includes:
1) processing of the ioctl
2) marshalling and sending the SMB2/SMB3 fsctl over the network
3) simple parsing of the response

It does not include yet (these will be in followon patches to come soon):
1) support for multiple chunks
2) support for autoconfiguring and remembering the chunksize
3) Support for the older style copychunk which Samba 4.1 server supports
(because this requires write permission on the target file, which
cp does not give you, apparently per-posix).  This may require
a distinct tool (other than cp) and other ioctl to implement.

Reviewed-by: Pavel Shilovsky <piastry@etersoft.ru>
Signed-off-by: Steve French <smfrench@gmail.com>

1 files changed, 111 insertions, 0 deletions

diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index ba54bf6ab116..409b45eefe70 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -22,12 +22,120 @@
  */
 
 #include <linux/fs.h>
+#include <linux/file.h>
+#include <linux/mount.h>
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/btrfs.h>
 #include "cifspdu.h"
 #include "cifsglob.h"
 #include "cifsproto.h"
 #include "cifs_debug.h"
 #include "cifsfs.h"
 
+static long cifs_ioctl_clone(unsigned int xid, struct file *dst_file,
+                        unsigned long srcfd, u64 off, u64 len, u64 destoff)
+{
+        int rc;
+        struct cifsFileInfo *smb_file_target = dst_file->private_data;
+        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 cifs_tcon *src_tcon;
+
+        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->private_data) || (!dst_file->private_data)) {
+                rc = -EBADF;
+                cifs_dbg(VFS, "missing cifsFileInfo on copy range src file\n");
+                goto out_fput;
+        }
+
+        rc = -EXDEV;
+        smb_file_target = dst_file->private_data;
+        smb_file_src = src_file.file->private_data;
+        src_tcon = tlink_tcon(smb_file_src->tlink);
+        target_tcon = tlink_tcon(smb_file_target->tlink);
+
+        /* check if source and target are on same tree connection */
+        if (src_tcon != target_tcon) {
+                cifs_dbg(VFS, "file copy src and target on different volume\n");
+                goto out_fput;
+        }
+
+        src_inode = src_file.file->f_dentry->d_inode;
+
+        /*
+         * Note: cifs case is easier than btrfs since server responsible for
+         * checks for proper open modes and file type and if it wants
+         * server could even support copy of range where source = target
+         */
+
+        /* so we do not deadlock racing two ioctls on same files */
+        if (target_inode < src_inode) {
+                mutex_lock_nested(&target_inode->i_mutex, I_MUTEX_PARENT);
+                mutex_lock_nested(&src_inode->i_mutex, I_MUTEX_CHILD);
+        } else {
+                mutex_lock_nested(&src_inode->i_mutex, I_MUTEX_PARENT);
+                mutex_lock_nested(&target_inode->i_mutex, I_MUTEX_CHILD);
+        }
+
+        /* 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);
+
+        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);
+
+        /* 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 */
+        if (target_inode < src_inode) {
+                mutex_unlock(&src_inode->i_mutex);
+                mutex_unlock(&target_inode->i_mutex);
+        } else {
+                mutex_unlock(&target_inode->i_mutex);
+                mutex_unlock(&src_inode->i_mutex);
+        }
+out_fput:
+        fdput(src_file);
+out_drop_write:
+        mnt_drop_write_file(dst_file);
+        return rc;
+}
+
 long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
 {
         struct inode *inode = file_inode(filep);
@@ -105,6 +213,9 @@ long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
                                 cifs_dbg(FYI, "set compress flag rc %d\n", rc);
                         }
                         break;
+                case BTRFS_IOC_CLONE:
+                        rc = cifs_ioctl_clone(xid, filep, arg, 0, 0, 0);
+                        break;
                 default:
                         cifs_dbg(FYI, "unsupported ioctl\n");
                         break;