btrfs: make cow_file_range take btrfs_inode

All its children functions take btrfs_inode so convert it to taking
btrfs_inode.

Signed-off-by: Nikolay Borisov <nborisov@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 2d053c3..f1b6690 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -80,7 +80,7 @@ struct kmem_cache *btrfs_free_space_bitmap_cachep;
 static int btrfs_setsize(struct inode *inode, struct iattr *attr);
 static int btrfs_truncate(struct inode *inode, bool skip_writeback);
 static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent);
-static noinline int cow_file_range(struct inode *inode,
+static noinline int cow_file_range(struct btrfs_inode *inode,
                                   struct page *locked_page,
                                   u64 start, u64 end, int *page_started,
                                   unsigned long *nr_written, int unlock);
@@ -789,7 +789,8 @@ retry:
                        unsigned long nr_written = 0;
 
                        /* allocate blocks */
-                       ret = cow_file_range(inode, async_chunk->locked_page,
+                       ret = cow_file_range(BTRFS_I(inode),
+                                            async_chunk->locked_page,
                                             async_extent->start,
                                             async_extent->start +
                                             async_extent->ram_size - 1,
@@ -976,13 +977,13 @@ static u64 get_extent_allocation_hint(struct btrfs_inode *inode, u64 start,
  * required to start IO on it.  It may be clean and already done with
  * IO when we return.
  */
-static noinline int cow_file_range(struct inode *inode,
+static noinline int cow_file_range(struct btrfs_inode *inode,
                                   struct page *locked_page,
                                   u64 start, u64 end, int *page_started,
                                   unsigned long *nr_written, int unlock)
 {
-       struct btrfs_fs_info *fs_info = btrfs_sb(inode->i_sb);
-       struct btrfs_root *root = BTRFS_I(inode)->root;
+       struct btrfs_root *root = inode->root;
+       struct btrfs_fs_info *fs_info = root->fs_info;
        u64 alloc_hint = 0;
        u64 num_bytes;
        unsigned long ram_size;
@@ -996,7 +997,7 @@ static noinline int cow_file_range(struct inode *inode,
        bool extent_reserved = false;
        int ret = 0;
 
-       if (btrfs_is_free_space_inode(BTRFS_I(inode))) {
+       if (btrfs_is_free_space_inode(inode)) {
                WARN_ON_ONCE(1);
                ret = -EINVAL;
                goto out_unlock;
@@ -1006,11 +1007,11 @@ static noinline int cow_file_range(struct inode *inode,
        num_bytes = max(blocksize,  num_bytes);
        ASSERT(num_bytes <= btrfs_super_total_bytes(fs_info->super_copy));
 
-       inode_should_defrag(BTRFS_I(inode), start, end, num_bytes, SZ_64K);
+       inode_should_defrag(inode, start, end, num_bytes, SZ_64K);
 
        if (start == 0) {
                /* lets try to make an inline extent */
-               ret = cow_file_range_inline(BTRFS_I(inode), start, end, 0,
+               ret = cow_file_range_inline(inode, start, end, 0,
                                            BTRFS_COMPRESS_NONE, NULL);
                if (ret == 0) {
                        /*
@@ -1019,8 +1020,7 @@ static noinline int cow_file_range(struct inode *inode,
                         * our outstanding extent for clearing delalloc for this
                         * range.
                         */
-                       extent_clear_unlock_delalloc(BTRFS_I(inode), start, end,
-                                    NULL,
+                       extent_clear_unlock_delalloc(inode, start, end, NULL,
                                     EXTENT_LOCKED | EXTENT_DELALLOC |
                                     EXTENT_DELALLOC_NEW | EXTENT_DEFRAG |
                                     EXTENT_DO_ACCOUNTING, PAGE_UNLOCK |
@@ -1035,10 +1035,8 @@ static noinline int cow_file_range(struct inode *inode,
                }
        }
 
-       alloc_hint = get_extent_allocation_hint(BTRFS_I(inode), start,
-                                               num_bytes);
-       btrfs_drop_extent_cache(BTRFS_I(inode), start,
-                       start + num_bytes - 1, 0);
+       alloc_hint = get_extent_allocation_hint(inode, start, num_bytes);
+       btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
 
        /*
         * Relocation relies on the relocated extents to have exactly the same
@@ -1067,7 +1065,7 @@ static noinline int cow_file_range(struct inode *inode,
                extent_reserved = true;
 
                ram_size = ins.offset;
-               em = create_io_em(BTRFS_I(inode), start, ins.offset, /* len */
+               em = create_io_em(inode, start, ins.offset, /* len */
                                  start, /* orig_start */
                                  ins.objectid, /* block_start */
                                  ins.offset, /* block_len */
@@ -1081,15 +1079,14 @@ static noinline int cow_file_range(struct inode *inode,
                }
                free_extent_map(em);
 
-               ret = btrfs_add_ordered_extent(BTRFS_I(inode), start,
-                                              ins.objectid, ram_size,
-                                              cur_alloc_size, 0);
+               ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
+                                              ram_size, cur_alloc_size, 0);
                if (ret)
                        goto out_drop_extent_cache;
 
                if (root->root_key.objectid ==
                    BTRFS_DATA_RELOC_TREE_OBJECTID) {
-                       ret = btrfs_reloc_clone_csums(BTRFS_I(inode), start,
+                       ret = btrfs_reloc_clone_csums(inode, start,
                                                      cur_alloc_size);
                        /*
                         * Only drop cache here, and process as normal.
@@ -1103,7 +1100,7 @@ static noinline int cow_file_range(struct inode *inode,
                         * skip current ordered extent.
                         */
                        if (ret)
-                               btrfs_drop_extent_cache(BTRFS_I(inode), start,
+                               btrfs_drop_extent_cache(inode, start,
                                                start + ram_size - 1, 0);
                }
 
@@ -1119,8 +1116,7 @@ static noinline int cow_file_range(struct inode *inode,
                page_ops = unlock ? PAGE_UNLOCK : 0;
                page_ops |= PAGE_SET_PRIVATE2;
 
-               extent_clear_unlock_delalloc(BTRFS_I(inode), start,
-                                            start + ram_size - 1,
+               extent_clear_unlock_delalloc(inode, start, start + ram_size - 1,
                                             locked_page,
                                             EXTENT_LOCKED | EXTENT_DELALLOC,
                                             page_ops);
@@ -1144,7 +1140,7 @@ out:
        return ret;
 
 out_drop_extent_cache:
-       btrfs_drop_extent_cache(BTRFS_I(inode), start, start + ram_size - 1, 0);
+       btrfs_drop_extent_cache(inode, start, start + ram_size - 1, 0);
 out_reserve:
        btrfs_dec_block_group_reservations(fs_info, ins.objectid);
        btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, 1);
@@ -1164,7 +1160,7 @@ out_unlock:
         * it the flag EXTENT_CLEAR_DATA_RESV.
         */
        if (extent_reserved) {
-               extent_clear_unlock_delalloc(BTRFS_I(inode), start,
+               extent_clear_unlock_delalloc(inode, start,
                                             start + cur_alloc_size - 1,
                                             locked_page,
                                             clear_bits,
@@ -1173,7 +1169,7 @@ out_unlock:
                if (start >= end)
                        goto out;
        }
-       extent_clear_unlock_delalloc(BTRFS_I(inode), start, end, locked_page,
+       extent_clear_unlock_delalloc(inode, start, end, locked_page,
                                     clear_bits | EXTENT_CLEAR_DATA_RESV,
                                     page_ops);
        goto out;
@@ -1441,8 +1437,8 @@ static int fallback_to_cow(struct inode *inode, struct page *locked_page,
                                         0, 0, NULL);
        }
 
-       return cow_file_range(inode, locked_page, start, end, page_started,
-                             nr_written, 1);
+       return cow_file_range(BTRFS_I(inode), locked_page, start, end,
+                             page_started, nr_written, 1);
 }
 
 /*
@@ -1838,7 +1834,7 @@ int btrfs_run_delalloc_range(struct inode *inode, struct page *locked_page,
                                         page_started, 0, nr_written);
        } else if (!inode_can_compress(inode) ||
                   !inode_need_compress(inode, start, end)) {
-               ret = cow_file_range(inode, locked_page, start, end,
+               ret = cow_file_range(BTRFS_I(inode), locked_page, start, end,
                                      page_started, nr_written, 1);
        } else {
                set_bit(BTRFS_INODE_HAS_ASYNC_EXTENT,