btrfs: make btrfs_truncate_inode_items take btrfs_inode

Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
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/ctree.h b/fs/btrfs/ctree.h
index 560cbc4..ccc2339 100644 (file)
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -3072,7 +3072,7 @@ int btrfs_truncate_block(struct inode *inode, loff_t from, loff_t len,
                        int front);
 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                               struct btrfs_root *root,
-                              struct inode *inode, u64 new_size,
+                              struct btrfs_inode *inode, u64 new_size,
                               u32 min_type);
 
 int btrfs_start_delalloc_snapshot(struct btrfs_root *root);

diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
index 58bd2d3..d8010df 100644 (file)
--- a/fs/btrfs/free-space-cache.c
+++ b/fs/btrfs/free-space-cache.c
@@ -273,7 +273,7 @@ int btrfs_truncate_free_space_cache(struct btrfs_trans_handle *trans,
         * We skip the throttling logic for free space cache inodes, so we don't
         * need to check for -EAGAIN.
         */
-       ret = btrfs_truncate_inode_items(trans, root, inode,
+       ret = btrfs_truncate_inode_items(trans, root, BTRFS_I(inode),
                                         0, BTRFS_EXTENT_DATA_KEY);
        if (ret)
                goto fail;

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 1d44e63..3dd0b47 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -4299,7 +4299,7 @@ out:
  */
 int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                               struct btrfs_root *root,
-                              struct inode *inode,
+                              struct btrfs_inode *inode,
                               u64 new_size, u32 min_type)
 {
        struct btrfs_fs_info *fs_info = root->fs_info;
@@ -4320,7 +4320,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
        int pending_del_slot = 0;
        int extent_type = -1;
        int ret;
-       u64 ino = btrfs_ino(BTRFS_I(inode));
+       u64 ino = btrfs_ino(inode);
        u64 bytes_deleted = 0;
        bool be_nice = false;
        bool should_throttle = false;
@@ -4334,7 +4334,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         * off from time to time.  This means all inodes in subvolume roots,
         * reloc roots, and data reloc roots.
         */
-       if (!btrfs_is_free_space_inode(BTRFS_I(inode)) &&
+       if (!btrfs_is_free_space_inode(inode) &&
            test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
                be_nice = true;
 
@@ -4344,7 +4344,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
        path->reada = READA_BACK;
 
        if (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID) {
-               lock_extent_bits(&BTRFS_I(inode)->io_tree, lock_start, (u64)-1,
+               lock_extent_bits(&inode->io_tree, lock_start, (u64)-1,
                                 &cached_state);
 
                /*
@@ -4352,7 +4352,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
                 * new size is not block aligned since we will be keeping the
                 * last block of the extent just the way it is.
                 */
-               btrfs_drop_extent_cache(BTRFS_I(inode), ALIGN(new_size,
+               btrfs_drop_extent_cache(inode, ALIGN(new_size,
                                        fs_info->sectorsize),
                                        (u64)-1, 0);
        }
@@ -4363,8 +4363,8 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         * it is used to drop the logged items. So we shouldn't kill the delayed
         * items.
         */
-       if (min_type == 0 && root == BTRFS_I(inode)->root)
-               btrfs_kill_delayed_inode_items(BTRFS_I(inode));
+       if (min_type == 0 && root == inode->root)
+               btrfs_kill_delayed_inode_items(inode);
 
        key.objectid = ino;
        key.offset = (u64)-1;
@@ -4420,14 +4420,13 @@ search_again:
                                    btrfs_file_extent_num_bytes(leaf, fi);
 
                                trace_btrfs_truncate_show_fi_regular(
-                                       BTRFS_I(inode), leaf, fi,
-                                       found_key.offset);
+                                       inode, leaf, fi, found_key.offset);
                        } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
                                item_end += btrfs_file_extent_ram_bytes(leaf,
                                                                        fi);
 
                                trace_btrfs_truncate_show_fi_inline(
-                                       BTRFS_I(inode), leaf, fi, path->slots[0],
+                                       inode, leaf, fi, path->slots[0],
                                        found_key.offset);
                        }
                        item_end--;
@@ -4466,7 +4465,8 @@ search_again:
                                if (test_bit(BTRFS_ROOT_SHAREABLE,
                                             &root->state) &&
                                    extent_start != 0)
-                                       inode_sub_bytes(inode, num_dec);
+                                       inode_sub_bytes(&inode->vfs_inode,
+                                                       num_dec);
                                btrfs_mark_buffer_dirty(leaf);
                        } else {
                                extent_num_bytes =
@@ -4481,7 +4481,8 @@ search_again:
                                        found_extent = 1;
                                        if (test_bit(BTRFS_ROOT_SHAREABLE,
                                                     &root->state))
-                                               inode_sub_bytes(inode, num_dec);
+                                               inode_sub_bytes(&inode->vfs_inode,
+                                                               num_dec);
                                }
                        }
                        clear_len = num_dec;
@@ -4516,7 +4517,8 @@ search_again:
                        }
 
                        if (test_bit(BTRFS_ROOT_SHAREABLE, &root->state))
-                               inode_sub_bytes(inode, item_end + 1 - new_size);
+                               inode_sub_bytes(&inode->vfs_inode,
+                                               item_end + 1 - new_size);
                }
 delete:
                /*
@@ -4524,8 +4526,8 @@ delete:
                 * multiple fsyncs, and in this case we don't want to clear the
                 * file extent range because it's just the log.
                 */
-               if (root == BTRFS_I(inode)->root) {
-                       ret = btrfs_inode_clear_file_extent_range(BTRFS_I(inode),
+               if (root == inode->root) {
+                       ret = btrfs_inode_clear_file_extent_range(inode,
                                                  clear_start, clear_len);
                        if (ret) {
                                btrfs_abort_transaction(trans, ret);
@@ -4633,9 +4635,9 @@ out:
                ASSERT(last_size >= new_size);
                if (!ret && last_size > new_size)
                        last_size = new_size;
-               btrfs_inode_safe_disk_i_size_write(BTRFS_I(inode), last_size);
-               unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start,
-                                    (u64)-1, &cached_state);
+               btrfs_inode_safe_disk_i_size_write(inode, last_size);
+               unlock_extent_cached(&inode->io_tree, lock_start, (u64)-1,
+                                    &cached_state);
        }
 
        btrfs_free_path(path);
@@ -5268,7 +5270,8 @@ void btrfs_evict_inode(struct inode *inode)
 
                trans->block_rsv = rsv;
 
-               ret = btrfs_truncate_inode_items(trans, root, inode, 0, 0);
+               ret = btrfs_truncate_inode_items(trans, root, BTRFS_I(inode),
+                                                0, 0);
                trans->block_rsv = &fs_info->trans_block_rsv;
                btrfs_end_transaction(trans);
                btrfs_btree_balance_dirty(fs_info);
@@ -8512,7 +8515,7 @@ static int btrfs_truncate(struct inode *inode, bool skip_writeback)
        trans->block_rsv = rsv;
 
        while (1) {
-               ret = btrfs_truncate_inode_items(trans, root, inode,
+               ret = btrfs_truncate_inode_items(trans, root, BTRFS_I(inode),
                                                 inode->i_size,
                                                 BTRFS_EXTENT_DATA_KEY);
                trans->block_rsv = &fs_info->trans_block_rsv;

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 932a74a..360732a 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -4378,8 +4378,7 @@ static int btrfs_log_prealloc_extents(struct btrfs_trans_handle *trans,
                        do {
                                ret = btrfs_truncate_inode_items(trans,
                                                         root->log_root,
-                                                        &inode->vfs_inode,
-                                                        truncate_offset,
+                                                        inode, truncate_offset,
                                                         BTRFS_EXTENT_DATA_KEY);
                        } while (ret == -EAGAIN);
                        if (ret)
@@ -5306,7 +5305,7 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                                          &inode->runtime_flags);
                                while(1) {
                                        ret = btrfs_truncate_inode_items(trans,
-                                               log, &inode->vfs_inode, 0, 0);
+                                               log, inode, 0, 0);
                                        if (ret != -EAGAIN)
                                                break;
                                }