btrfs: Make btrfs_log_inode take btrfs_inode

Signed-off-by: Nikolay Borisov <n.borisov.lkml@gmail.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 92a3963461d8407e558ffc7ade5412acb5d21bb3..c525a685bfa29bfad72fe57f573f387b439c6016 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -97,7 +97,7 @@
 #define LOG_WALK_REPLAY_ALL 3
 
 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *root, struct inode *inode,
+                          struct btrfs_root *root, struct btrfs_inode *inode,
                           int inode_only,
                           const loff_t start,
                           const loff_t end,
@@ -4594,7 +4594,7 @@ out:
  * This handles both files and directories.
  */
 static int btrfs_log_inode(struct btrfs_trans_handle *trans,
-                          struct btrfs_root *root, struct inode *inode,
+                          struct btrfs_root *root, struct btrfs_inode *inode,
                           int inode_only,
                           const loff_t start,
                           const loff_t end,
@@ -4615,8 +4615,8 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
        int ins_start_slot = 0;
        int ins_nr;
        bool fast_search = false;
-       u64 ino = btrfs_ino(BTRFS_I(inode));
-       struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
+       u64 ino = btrfs_ino(inode);
+       struct extent_map_tree *em_tree = &inode->extent_tree;
        u64 logged_isize = 0;
        bool need_log_inode_item = true;
 
@@ -4637,9 +4637,9 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
 
 
        /* today the code can only do partial logging of directories */
-       if (S_ISDIR(inode->i_mode) ||
+       if (S_ISDIR(inode->vfs_inode.i_mode) ||
            (!test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
-                      &BTRFS_I(inode)->runtime_flags) &&
+                      &inode->runtime_flags) &&
             inode_only >= LOG_INODE_EXISTS))
                max_key.type = BTRFS_XATTR_ITEM_KEY;
        else
@@ -4652,11 +4652,11 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
         * order for the log replay code to mark inodes for link count
         * fixup (create temporary BTRFS_TREE_LOG_FIXUP_OBJECTID items).
         */
-       if (S_ISDIR(inode->i_mode) ||
-           BTRFS_I(inode)->generation > fs_info->last_trans_committed)
-               ret = btrfs_commit_inode_delayed_items(trans, BTRFS_I(inode));
+       if (S_ISDIR(inode->vfs_inode.i_mode) ||
+           inode->generation > fs_info->last_trans_committed)
+               ret = btrfs_commit_inode_delayed_items(trans, inode);
        else
-               ret = btrfs_commit_inode_delayed_inode(BTRFS_I(inode));
+               ret = btrfs_commit_inode_delayed_inode(inode);
 
        if (ret) {
                btrfs_free_path(path);
@@ -4666,17 +4666,16 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
 
        if (inode_only == LOG_OTHER_INODE) {
                inode_only = LOG_INODE_EXISTS;
-               mutex_lock_nested(&BTRFS_I(inode)->log_mutex,
-                                 SINGLE_DEPTH_NESTING);
+               mutex_lock_nested(&inode->log_mutex, SINGLE_DEPTH_NESTING);
        } else {
-               mutex_lock(&BTRFS_I(inode)->log_mutex);
+               mutex_lock(&inode->log_mutex);
        }
 
        /*
         * a brute force approach to making sure we get the most uptodate
         * copies of everything.
         */
-       if (S_ISDIR(inode->i_mode)) {
+       if (S_ISDIR(inode->vfs_inode.i_mode)) {
                int max_key_type = BTRFS_DIR_LOG_INDEX_KEY;
 
                if (inode_only == LOG_INODE_EXISTS)
@@ -4697,31 +4696,30 @@ static int btrfs_log_inode(struct btrfs_trans_handle *trans,
                         * (zeroes), as if an expanding truncate happened,
                         * instead of getting a file of 4Kb only.
                         */
-                       err = logged_inode_size(log, BTRFS_I(inode), path,
-                                               &logged_isize);
+                       err = logged_inode_size(log, inode, path, &logged_isize);
                        if (err)
                                goto out_unlock;
                }
                if (test_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
-                            &BTRFS_I(inode)->runtime_flags)) {
+                            &inode->runtime_flags)) {
                        if (inode_only == LOG_INODE_EXISTS) {
                                max_key.type = BTRFS_XATTR_ITEM_KEY;
                                ret = drop_objectid_items(trans, log, path, ino,
                                                          max_key.type);
                        } else {
                                clear_bit(BTRFS_INODE_NEEDS_FULL_SYNC,
-                                         &BTRFS_I(inode)->runtime_flags);
+                                         &inode->runtime_flags);
                                clear_bit(BTRFS_INODE_COPY_EVERYTHING,
-                                         &BTRFS_I(inode)->runtime_flags);
+                                         &inode->runtime_flags);
                                while(1) {
                                        ret = btrfs_truncate_inode_items(trans,
-                                                        log, inode, 0, 0);
+                                               log, &inode->vfs_inode, 0, 0);
                                        if (ret != -EAGAIN)
                                                break;
                                }
                        }
                } else if (test_and_clear_bit(BTRFS_INODE_COPY_EVERYTHING,
-                                             &BTRFS_I(inode)->runtime_flags) ||
+                                             &inode->runtime_flags) ||
                           inode_only == LOG_INODE_EXISTS) {
                        if (inode_only == LOG_INODE_ALL)
                                fast_search = true;
@@ -4762,13 +4760,12 @@ again:
 
                if ((min_key.type == BTRFS_INODE_REF_KEY ||
                     min_key.type == BTRFS_INODE_EXTREF_KEY) &&
-                   BTRFS_I(inode)->generation == trans->transid) {
+                   inode->generation == trans->transid) {
                        u64 other_ino = 0;
 
                        ret = btrfs_check_ref_name_override(path->nodes[0],
-                                                           path->slots[0],
-                                                           &min_key, BTRFS_I(inode),
-                                                           &other_ino);
+                                       path->slots[0], &min_key, inode,
+                                       &other_ino);
                        if (ret < 0) {
                                err = ret;
                                goto out_unlock;
@@ -4783,7 +4780,7 @@ again:
                                        ins_nr = 1;
                                        ins_start_slot = path->slots[0];
                                }
-                               ret = copy_items(trans, BTRFS_I(inode), dst_path, path,
+                               ret = copy_items(trans, inode, dst_path, path,
                                                 &last_extent, ins_start_slot,
                                                 ins_nr, inode_only,
                                                 logged_isize);
@@ -4821,9 +4818,10 @@ again:
                                 * update the log with the new name before we
                                 * unpin it.
                                 */
-                               err = btrfs_log_inode(trans, root, other_inode,
-                                                     LOG_OTHER_INODE,
-                                                     0, LLONG_MAX, ctx);
+                               err = btrfs_log_inode(trans, root,
+                                               BTRFS_I(other_inode),
+                                               LOG_OTHER_INODE, 0, LLONG_MAX,
+                                               ctx);
                                iput(other_inode);
                                if (err)
                                        goto out_unlock;
@@ -4836,7 +4834,7 @@ again:
                if (min_key.type == BTRFS_XATTR_ITEM_KEY) {
                        if (ins_nr == 0)
                                goto next_slot;
-                       ret = copy_items(trans, BTRFS_I(inode), dst_path, path,
+                       ret = copy_items(trans, inode, dst_path, path,
                                         &last_extent, ins_start_slot,
                                         ins_nr, inode_only, logged_isize);
                        if (ret < 0) {
@@ -4861,7 +4859,7 @@ again:
                        goto next_slot;
                }
 
-               ret = copy_items(trans, BTRFS_I(inode), dst_path, path, &last_extent,
+               ret = copy_items(trans, inode, dst_path, path, &last_extent,
                                 ins_start_slot, ins_nr, inode_only,
                                 logged_isize);
                if (ret < 0) {
@@ -4885,7 +4883,7 @@ next_slot:
                        goto again;
                }
                if (ins_nr) {
-                       ret = copy_items(trans, BTRFS_I(inode), dst_path, path,
+                       ret = copy_items(trans, inode, dst_path, path,
                                         &last_extent, ins_start_slot,
                                         ins_nr, inode_only, logged_isize);
                        if (ret < 0) {
@@ -4907,7 +4905,7 @@ next_key:
                }
        }
        if (ins_nr) {
-               ret = copy_items(trans, BTRFS_I(inode), dst_path, path, &last_extent,
+               ret = copy_items(trans, inode, dst_path, path, &last_extent,
                                 ins_start_slot, ins_nr, inode_only,
                                 logged_isize);
                if (ret < 0) {
@@ -4920,13 +4918,13 @@ next_key:
 
        btrfs_release_path(path);
        btrfs_release_path(dst_path);
-       err = btrfs_log_all_xattrs(trans, root, BTRFS_I(inode), path, dst_path);
+       err = btrfs_log_all_xattrs(trans, root, inode, path, dst_path);
        if (err)
                goto out_unlock;
        if (max_key.type >= BTRFS_EXTENT_DATA_KEY && !fast_search) {
                btrfs_release_path(path);
                btrfs_release_path(dst_path);
-               err = btrfs_log_trailing_hole(trans, root, BTRFS_I(inode), path);
+               err = btrfs_log_trailing_hole(trans, root, inode, path);
                if (err)
                        goto out_unlock;
        }
@@ -4934,12 +4932,12 @@ log_extents:
        btrfs_release_path(path);
        btrfs_release_path(dst_path);
        if (need_log_inode_item) {
-               err = log_inode_item(trans, log, dst_path, BTRFS_I(inode));
+               err = log_inode_item(trans, log, dst_path, inode);
                if (err)
                        goto out_unlock;
        }
        if (fast_search) {
-               ret = btrfs_log_changed_extents(trans, root, BTRFS_I(inode), dst_path,
+               ret = btrfs_log_changed_extents(trans, root, inode, dst_path,
                                                &logged_list, ctx, start, end);
                if (ret) {
                        err = ret;
@@ -4977,25 +4975,25 @@ log_extents:
                write_unlock(&em_tree->lock);
        }
 
-       if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->i_mode)) {
-               ret = log_directory_changes(trans, root, BTRFS_I(inode), path,
-                               dst_path, ctx);
+       if (inode_only == LOG_INODE_ALL && S_ISDIR(inode->vfs_inode.i_mode)) {
+               ret = log_directory_changes(trans, root, inode, path, dst_path,
+                                       ctx);
                if (ret) {
                        err = ret;
                        goto out_unlock;
                }
        }
 
-       spin_lock(&BTRFS_I(inode)->lock);
-       BTRFS_I(inode)->logged_trans = trans->transid;
-       BTRFS_I(inode)->last_log_commit = BTRFS_I(inode)->last_sub_trans;
-       spin_unlock(&BTRFS_I(inode)->lock);
+       spin_lock(&inode->lock);
+       inode->logged_trans = trans->transid;
+       inode->last_log_commit = inode->last_sub_trans;
+       spin_unlock(&inode->lock);
 out_unlock:
        if (unlikely(err))
                btrfs_put_logged_extents(&logged_list);
        else
                btrfs_submit_logged_extents(&logged_list, log);
-       mutex_unlock(&BTRFS_I(inode)->log_mutex);
+       mutex_unlock(&inode->log_mutex);
 
        btrfs_free_path(path);
        btrfs_free_path(dst_path);
@@ -5243,7 +5241,7 @@ process_leaf:
                        ctx->log_new_dentries = false;
                        if (type == BTRFS_FT_DIR || type == BTRFS_FT_SYMLINK)
                                log_mode = LOG_INODE_ALL;
-                       ret = btrfs_log_inode(trans, root, di_inode,
+                       ret = btrfs_log_inode(trans, root, BTRFS_I(di_inode),
                                              log_mode, 0, LLONG_MAX, ctx);
                        if (!ret &&
                            btrfs_must_commit_transaction(trans, BTRFS_I(di_inode)))
@@ -5363,7 +5361,7 @@ static int btrfs_log_all_parents(struct btrfs_trans_handle *trans,
 
                        if (ctx)
                                ctx->log_new_dentries = false;
-                       ret = btrfs_log_inode(trans, root, dir_inode,
+                       ret = btrfs_log_inode(trans, root, BTRFS_I(dir_inode),
                                              LOG_INODE_ALL, 0, LLONG_MAX, ctx);
                        if (!ret &&
                            btrfs_must_commit_transaction(trans, BTRFS_I(dir_inode)))
@@ -5443,7 +5441,8 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
        if (ret)
                goto end_no_trans;
 
-       ret = btrfs_log_inode(trans, root, inode, inode_only, start, end, ctx);
+       ret = btrfs_log_inode(trans, root, BTRFS_I(inode), inode_only,
+                       start, end, ctx);
        if (ret)
                goto end_trans;
 
@@ -5519,7 +5518,7 @@ static int btrfs_log_inode_parent(struct btrfs_trans_handle *trans,
                        break;
 
                if (BTRFS_I(inode)->generation > last_committed) {
-                       ret = btrfs_log_inode(trans, root, inode,
+                       ret = btrfs_log_inode(trans, root, BTRFS_I(inode),
                                              LOG_INODE_EXISTS,
                                              0, LLONG_MAX, ctx);
                        if (ret)