Btrfs: Update clone file ioctl

This patch updates the file clone ioctl for the tree locking and new
data ordered code.

---

Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 70 insertions, 80 deletions

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index e1046a54b1c5..3932c7cd0fae 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -517,32 +517,6 @@ out:
         return ret;
 }
 
-int dup_item_to_inode(struct btrfs_trans_handle *trans,
-                       struct btrfs_root *root,
-                       struct btrfs_path *path,
-                       struct extent_buffer *leaf,
-                       int slot,
-                       struct btrfs_key *key,
-                       u64 destino)
-{
-        char *dup;
-        int len = btrfs_item_size_nr(leaf, slot);
-        struct btrfs_key ckey = *key;
-        int ret = 0;
-
-        dup = kmalloc(len, GFP_NOFS);
-        if (!dup)
-                return -ENOMEM;
-
-        read_extent_buffer(leaf, dup, btrfs_item_ptr_offset(leaf, slot), len);
-        btrfs_release_path(root, path);
-
-        ckey.objectid = destino;
-        ret = btrfs_insert_item(trans, root, &ckey, dup, len);
-        kfree(dup);
-        return ret;
-}
-
 long btrfs_ioctl_clone(struct file *file, unsigned long src_fd)
 {
         struct inode *inode = fdentry(file)->d_inode;
@@ -550,22 +524,41 @@ long btrfs_ioctl_clone(struct file *file, unsigned long src_fd)
         struct file *src_file;
         struct inode *src;
         struct btrfs_trans_handle *trans;
-        int ret;
-        u64 pos;
+        struct btrfs_ordered_extent *ordered;
         struct btrfs_path *path;
-        struct btrfs_key key;
         struct extent_buffer *leaf;
+        char *buf;
+        struct btrfs_key key;
+        struct btrfs_key new_key;
+        u32 size;
         u32 nritems;
         int slot;
+        int ret;
 
         src_file = fget(src_fd);
         if (!src_file)
                 return -EBADF;
         src = src_file->f_dentry->d_inode;
 
+        ret = -EISDIR;
+        if (S_ISDIR(src->i_mode) || S_ISDIR(inode->i_mode))
+                goto out_fput;
+
         ret = -EXDEV;
-        if (src->i_sb != inode->i_sb)
+        if (src->i_sb != inode->i_sb || BTRFS_I(src)->root != root)
+                goto out_fput;
+
+        ret = -ENOMEM;
+        buf = vmalloc(btrfs_level_size(root, 0));
+        if (!buf)
+                goto out_fput;
+
+        path = btrfs_alloc_path();
+        if (!path) {
+                vfree(buf);
                 goto out_fput;
+        }
+        path->reada = 2;
 
         if (inode < src) {
                 mutex_lock(&inode->i_mutex);
@@ -582,24 +575,22 @@ long btrfs_ioctl_clone(struct file *file, unsigned long src_fd)
         /* do any pending delalloc/csum calc on src, one way or
            another, and lock file content */
         while (1) {
-                filemap_write_and_wait(src->i_mapping);
                 lock_extent(&BTRFS_I(src)->io_tree, 0, (u64)-1, GFP_NOFS);
-                if (BTRFS_I(src)->delalloc_bytes == 0)
+                ordered = btrfs_lookup_first_ordered_extent(inode, (u64)-1);
+                if (BTRFS_I(src)->delalloc_bytes == 0 && !ordered)
                         break;
                 unlock_extent(&BTRFS_I(src)->io_tree, 0, (u64)-1, GFP_NOFS);
+                if (ordered)
+                        btrfs_put_ordered_extent(ordered);
+                btrfs_wait_ordered_range(src, 0, (u64)-1);
         }
 
-        trans = btrfs_start_transaction(root, 0);
-        path = btrfs_alloc_path();
-        if (!path) {
-                ret = -ENOMEM;
-                goto out;
-        }
-        key.offset = 0;
-        key.type = BTRFS_EXTENT_DATA_KEY;
+        trans = btrfs_start_transaction(root, 1);
+        BUG_ON(!trans);
+
         key.objectid = src->i_ino;
-        pos = 0;
-        path->reada = 2;
+        key.type = BTRFS_EXTENT_DATA_KEY;
+        key.offset = 0;
 
         while (1) {
                 /*
@@ -610,18 +601,19 @@ long btrfs_ioctl_clone(struct file *file, unsigned long src_fd)
                 if (ret < 0)
                         goto out;
 
-                if (path->slots[0] >= btrfs_header_nritems(path->nodes[0])) {
+                nritems = btrfs_header_nritems(path->nodes[0]);
+                if (path->slots[0] >= nritems) {
                         ret = btrfs_next_leaf(root, path);
                         if (ret < 0)
                                 goto out;
                         if (ret > 0)
                                 break;
+                        nritems = btrfs_header_nritems(path->nodes[0]);
                 }
                 leaf = path->nodes[0];
                 slot = path->slots[0];
-                btrfs_item_key_to_cpu(leaf, &key, slot);
-                nritems = btrfs_header_nritems(leaf);
 
+                btrfs_item_key_to_cpu(leaf, &key, slot);
                 if (btrfs_key_type(&key) > BTRFS_CSUM_ITEM_KEY ||
                     key.objectid != src->i_ino)
                         break;
@@ -629,66 +621,64 @@ long btrfs_ioctl_clone(struct file *file, unsigned long src_fd)
                 if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY) {
                         struct btrfs_file_extent_item *extent;
                         int found_type;
-                        pos = key.offset;
+
                         extent = btrfs_item_ptr(leaf, slot,
                                                 struct btrfs_file_extent_item);
                         found_type = btrfs_file_extent_type(leaf, extent);
                         if (found_type == BTRFS_FILE_EXTENT_REG) {
-                                u64 len = btrfs_file_extent_num_bytes(leaf,
-                                                                      extent);
                                 u64 ds = btrfs_file_extent_disk_bytenr(leaf,
                                                                        extent);
                                 u64 dl = btrfs_file_extent_disk_num_bytes(leaf,
                                                                  extent);
-                                u64 off = btrfs_file_extent_offset(leaf,
-                                                                   extent);
-                                btrfs_insert_file_extent(trans, root,
-                                                         inode->i_ino, pos,
-                                                         ds, dl, len, off);
                                 /* ds == 0 means there's a hole */
                                 if (ds != 0) {
-                                        btrfs_inc_extent_ref(trans, root,
+                                        ret = btrfs_inc_extent_ref(trans, root,
                                                      ds, dl,
                                                      root->root_key.objectid,
                                                      trans->transid,
-                                                     inode->i_ino, pos);
+                                                     inode->i_ino, key.offset);
+                                        if (ret)
+                                                goto out;
                                 }
-                                pos = key.offset + len;
-                        } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
-                                ret = dup_item_to_inode(trans, root, path,
-                                                        leaf, slot, &key,
-                                                        inode->i_ino);
-                                if (ret)
-                                        goto out;
-                                pos = key.offset + btrfs_item_size_nr(leaf,
-                                                                      slot);
                         }
-                } else if (btrfs_key_type(&key) == BTRFS_CSUM_ITEM_KEY) {
-                        ret = dup_item_to_inode(trans, root, path, leaf,
-                                                slot, &key, inode->i_ino);
+                }
 
-                        if (ret)
-                                goto out;
+                if (btrfs_key_type(&key) == BTRFS_EXTENT_DATA_KEY ||
+                    btrfs_key_type(&key) == BTRFS_CSUM_ITEM_KEY) {
+                        size = btrfs_item_size_nr(leaf, slot);
+                        read_extent_buffer(leaf, buf,
+                                           btrfs_item_ptr_offset(leaf, slot),
+                                           size);
+                        btrfs_release_path(root, path);
+                        memcpy(&new_key, &key, sizeof(new_key));
+                        new_key.objectid = inode->i_ino;
+                        ret = btrfs_insert_item(trans, root, &new_key,
+                                                buf, size);
+                        BUG_ON(ret);
+                } else {
+                        btrfs_release_path(root, path);
                 }
                 key.offset++;
-                btrfs_release_path(root, path);
         }
-
         ret = 0;
 out:
-        btrfs_free_path(path);
-
-        inode->i_blocks = src->i_blocks;
-        i_size_write(inode, src->i_size);
-        btrfs_update_inode(trans, root, inode);
-
-        unlock_extent(&BTRFS_I(src)->io_tree, 0, (u64)-1, GFP_NOFS);
-
+        btrfs_release_path(root, path);
+        if (ret == 0) {
+                inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+                inode->i_blocks = src->i_blocks;
+                btrfs_i_size_write(inode, src->i_size);
+                BTRFS_I(inode)->flags = BTRFS_I(src)->flags;
+                ret = btrfs_update_inode(trans, root, inode);
+        }
         btrfs_end_transaction(trans, root);
-
+        unlock_extent(&BTRFS_I(src)->io_tree, 0, (u64)-1, GFP_NOFS);
+        if (ret)
+                vmtruncate(inode, 0);
 out_unlock:
         mutex_unlock(&src->i_mutex);
         mutex_unlock(&inode->i_mutex);
+        vfree(buf);
+        btrfs_free_path(path);
 out_fput:
         fput(src_file);
         return ret;