btrfs: fix over-80 lines introduced by previous cleanups

This goes as a separate patch because fixing that inside the patches
caused too many many conflicts.

Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index a64862c53a8a8e96136f074e3dbd925ff0def11e..f7a6ee5ccc809a0ccf8338e058fec98b9d98da33 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -72,7 +72,8 @@ static inline int btrfs_is_continuous_delayed_item(
        return 0;
 }
 
-static struct btrfs_delayed_node *btrfs_get_delayed_node(struct btrfs_inode *btrfs_inode)
+static struct btrfs_delayed_node *btrfs_get_delayed_node(
+               struct btrfs_inode *btrfs_inode)
 {
        struct btrfs_root *root = btrfs_inode->root;
        u64 ino = btrfs_ino(btrfs_inode);
@@ -106,7 +107,7 @@ static struct btrfs_delayed_node *btrfs_get_delayed_node(struct btrfs_inode *btr
 
 /* Will return either the node or PTR_ERR(-ENOMEM) */
 static struct btrfs_delayed_node *btrfs_get_or_create_delayed_node(
-                                                       struct btrfs_inode *btrfs_inode)
+               struct btrfs_inode *btrfs_inode)
 {
        struct btrfs_delayed_node *node;
        struct btrfs_root *root = btrfs_inode->root;

diff --git a/fs/btrfs/dir-item.c b/fs/btrfs/dir-item.c
index 2c2b707567e46e18958b6b84f41bafe303b6f986..724504a2d7ac56986cc67db5da8521353a049636 100644 (file)
--- a/fs/btrfs/dir-item.c
+++ b/fs/btrfs/dir-item.c
@@ -174,8 +174,7 @@ second_insert:
        btrfs_release_path(path);
 
        ret2 = btrfs_insert_delayed_dir_index(trans, root->fs_info, name,
-                                             name_len, BTRFS_I(dir), &disk_key, type,
-                                             index);
+                       name_len, BTRFS_I(dir), &disk_key, type, index);
 out_free:
        btrfs_free_path(path);
        if (ret)

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 2d3325709cf6006d165097480e65cfc390035b5b..8234ef6f6078d73d7275a44ebbd23f27fde534f4 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -6001,7 +6001,7 @@ int btrfs_delalloc_reserve_metadata(struct inode *inode, u64 num_bytes)
 
        if (to_reserve)
                trace_btrfs_space_reservation(fs_info, "delalloc",
-                                             btrfs_ino(BTRFS_I(inode)), to_reserve, 1);
+                                     btrfs_ino(BTRFS_I(inode)), to_reserve, 1);
        if (release_extra)
                btrfs_block_rsv_release(fs_info, block_rsv,
                                btrfs_calc_trans_metadata_size(fs_info, 1));
@@ -6064,7 +6064,7 @@ out_fail:
        if (to_free) {
                btrfs_block_rsv_release(fs_info, block_rsv, to_free);
                trace_btrfs_space_reservation(fs_info, "delalloc",
-                                             btrfs_ino(BTRFS_I(inode)), to_free, 0);
+                                     btrfs_ino(BTRFS_I(inode)), to_free, 0);
        }
        if (delalloc_lock)
                mutex_unlock(&BTRFS_I(inode)->delalloc_mutex);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 64860a3ca68a442a0ea1112dd08ba58f364692ff..9359c1b7ccb8e214b2612a8afe4a8bb0fcc56fb5 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -98,7 +98,7 @@ static inline void __btrfs_debug_check_extent_io_range(const char *caller,
        if (end >= PAGE_SIZE && (end % 2) == 0 && end != isize - 1) {
                btrfs_debug_rl(BTRFS_I(inode)->root->fs_info,
                    "%s: ino %llu isize %llu odd range [%llu,%llu]",
-                               caller, btrfs_ino(BTRFS_I(inode)), isize, start, end);
+                       caller, btrfs_ino(BTRFS_I(inode)), isize, start, end);
        }
 }
 #else
@@ -4413,8 +4413,8 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
         * lookup the last file extent.  We're not using i_size here
         * because there might be preallocation past i_size
         */
-       ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(BTRFS_I(inode)), -1,
-                                      0);
+       ret = btrfs_lookup_file_extent(NULL, root, path,
+                       btrfs_ino(BTRFS_I(inode)), -1, 0);
        if (ret < 0) {
                btrfs_free_path(path);
                return ret;
@@ -4538,8 +4538,8 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                         * lookup stuff.
                         */
                        ret = btrfs_check_shared(trans, root->fs_info,
-                                                root->objectid,
-                                                btrfs_ino(BTRFS_I(inode)), bytenr);
+                                       root->objectid,
+                                       btrfs_ino(BTRFS_I(inode)), bytenr);
                        if (trans)
                                btrfs_end_transaction(trans);
                        if (ret < 0)

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 149b79b3aaf8a37f876726595128143ffe5ca075..18e5146df864b52cb2e0870070211e4fb7381e97 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2285,9 +2285,8 @@ static int fill_holes(struct btrfs_trans_handle *trans, struct inode *inode,
        }
        btrfs_release_path(path);
 
-       ret = btrfs_insert_file_extent(trans, root, btrfs_ino(BTRFS_I(inode)), offset,
-                                      0, 0, end - offset, 0, end - offset,
-                                      0, 0, 0);
+       ret = btrfs_insert_file_extent(trans, root, btrfs_ino(BTRFS_I(inode)),
+                       offset, 0, 0, end - offset, 0, end - offset, 0, 0, 0);
        if (ret)
                return ret;
 

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 12dd9e9523dd00490a9ab0f8bdbc31757de73e4b..4727b52c00e132fa40c092e4b4ddb0df31968171 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -2182,8 +2182,7 @@ static int insert_reserved_file_extent(struct btrfs_trans_handle *trans,
        ins.offset = disk_num_bytes;
        ins.type = BTRFS_EXTENT_ITEM_KEY;
        ret = btrfs_alloc_reserved_file_extent(trans, root->root_key.objectid,
-                                              btrfs_ino(BTRFS_I(inode)), file_pos,
-                                              ram_bytes, &ins);
+                       btrfs_ino(BTRFS_I(inode)), file_pos, ram_bytes, &ins);
        /*
         * Release the reserved range from inode dirty range map, as it is
         * already moved into delayed_ref_head
@@ -3113,7 +3112,7 @@ static int __readpage_endio_check(struct inode *inode,
 zeroit:
        btrfs_warn_rl(BTRFS_I(inode)->root->fs_info,
                "csum failed ino %llu off %llu csum %u expected csum %u",
-                          btrfs_ino(BTRFS_I(inode)), start, csum, csum_expected);
+                  btrfs_ino(BTRFS_I(inode)), start, csum, csum_expected);
        memset(kaddr + pgoff, 1, len);
        flush_dcache_page(page);
        kunmap_atomic(kaddr);
@@ -3314,7 +3313,8 @@ int btrfs_orphan_add(struct btrfs_trans_handle *trans, struct inode *inode)
 
        /* insert an orphan item to track this unlinked/truncated file */
        if (insert >= 1) {
-               ret = btrfs_insert_orphan_item(trans, root, btrfs_ino(BTRFS_I(inode)));
+               ret = btrfs_insert_orphan_item(trans, root,
+                               btrfs_ino(BTRFS_I(inode)));
                if (ret) {
                        atomic_dec(&root->orphan_inodes);
                        if (reserve) {
@@ -3799,7 +3799,7 @@ cache_acl:
         * any xattrs or acls
         */
        maybe_acls = acls_after_inode_item(leaf, path->slots[0],
-                                          btrfs_ino(BTRFS_I(inode)), &first_xattr_slot);
+                       btrfs_ino(BTRFS_I(inode)), &first_xattr_slot);
        if (first_xattr_slot != -1) {
                path->slots[0] = first_xattr_slot;
                ret = btrfs_load_inode_props(inode, path);
@@ -4863,8 +4863,8 @@ static int maybe_insert_hole(struct btrfs_root *root, struct inode *inode,
                return ret;
        }
 
-       ret = btrfs_insert_file_extent(trans, root, btrfs_ino(BTRFS_I(inode)), offset,
-                                      0, 0, len, 0, len, 0, 0, 0);
+       ret = btrfs_insert_file_extent(trans, root, btrfs_ino(BTRFS_I(inode)),
+                       offset, 0, 0, len, 0, len, 0, 0, 0);
        if (ret)
                btrfs_abort_transaction(trans, ret);
        else
@@ -5422,8 +5422,8 @@ static int btrfs_inode_by_name(struct inode *dir, struct dentry *dentry,
        if (!path)
                return -ENOMEM;
 
-       di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(BTRFS_I(dir)), name,
-                                   namelen, 0);
+       di = btrfs_lookup_dir_item(NULL, root, path, btrfs_ino(BTRFS_I(dir)),
+                       name, namelen, 0);
        if (IS_ERR(di))
                ret = PTR_ERR(di);
 
@@ -6287,7 +6287,7 @@ static struct inode *btrfs_new_inode(struct btrfs_trans_handle *trans,
        if (ret)
                btrfs_err(fs_info,
                          "error inheriting props for ino %llu (root %llu): %d",
-                         btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, ret);
+                       btrfs_ino(BTRFS_I(inode)), root->root_key.objectid, ret);
 
        return inode;
 
@@ -6420,8 +6420,8 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
                goto out_unlock;
 
        inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                               dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
-                               mode, &index);
+                       dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
+                       mode, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                goto out_unlock;
@@ -6492,8 +6492,8 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
                goto out_unlock;
 
        inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                               dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
-                               mode, &index);
+                       dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
+                       mode, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                goto out_unlock;
@@ -6642,8 +6642,8 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
                goto out_fail;
 
        inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                               dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
-                               S_IFDIR | mode, &index);
+                       dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
+                       S_IFDIR | mode, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                goto out_fail;
@@ -7295,8 +7295,8 @@ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
        if (!path)
                return -ENOMEM;
 
-       ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(BTRFS_I(inode)),
-                                      offset, 0);
+       ret = btrfs_lookup_file_extent(NULL, root, path,
+                       btrfs_ino(BTRFS_I(inode)), offset, 0);
        if (ret < 0)
                goto out;
 
@@ -8245,7 +8245,8 @@ static void btrfs_end_dio_bio(struct bio *bio)
        if (err)
                btrfs_warn(BTRFS_I(dip->inode)->root->fs_info,
                           "direct IO failed ino %llu rw %d,%u sector %#Lx len %u err no %d",
-                          btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio), bio->bi_opf,
+                          btrfs_ino(BTRFS_I(dip->inode)), bio_op(bio),
+                          bio->bi_opf,
                           (unsigned long long)bio->bi_iter.bi_sector,
                           bio->bi_iter.bi_size, err);
 
@@ -9560,7 +9561,8 @@ static int btrfs_rename_exchange(struct inode *old_dir,
                                             new_dentry->d_name.name,
                                             new_dentry->d_name.len,
                                             old_ino,
-                                            btrfs_ino(BTRFS_I(new_dir)), old_idx);
+                                            btrfs_ino(BTRFS_I(new_dir)),
+                                            old_idx);
                if (ret)
                        goto out_fail;
        }
@@ -9576,7 +9578,8 @@ static int btrfs_rename_exchange(struct inode *old_dir,
                                             old_dentry->d_name.name,
                                             old_dentry->d_name.len,
                                             new_ino,
-                                            btrfs_ino(BTRFS_I(old_dir)), new_idx);
+                                            btrfs_ino(BTRFS_I(old_dir)),
+                                            new_idx);
                if (ret)
                        goto out_fail;
        }
@@ -9592,8 +9595,10 @@ static int btrfs_rename_exchange(struct inode *old_dir,
        new_inode->i_ctime = ctime;
 
        if (old_dentry->d_parent != new_dentry->d_parent) {
-               btrfs_record_unlink_dir(trans, BTRFS_I(old_dir), BTRFS_I(old_inode), 1);
-               btrfs_record_unlink_dir(trans, BTRFS_I(new_dir), BTRFS_I(new_inode), 1);
+               btrfs_record_unlink_dir(trans, BTRFS_I(old_dir),
+                               BTRFS_I(old_inode), 1);
+               btrfs_record_unlink_dir(trans, BTRFS_I(new_dir),
+                               BTRFS_I(new_inode), 1);
        }
 
        /* src is a subvolume */
@@ -9659,13 +9664,15 @@ static int btrfs_rename_exchange(struct inode *old_dir,
 
        if (root_log_pinned) {
                parent = new_dentry->d_parent;
-               btrfs_log_new_name(trans, BTRFS_I(old_inode), BTRFS_I(old_dir), parent);
+               btrfs_log_new_name(trans, BTRFS_I(old_inode), BTRFS_I(old_dir),
+                               parent);
                btrfs_end_log_trans(root);
                root_log_pinned = false;
        }
        if (dest_log_pinned) {
                parent = old_dentry->d_parent;
-               btrfs_log_new_name(trans, BTRFS_I(new_inode), BTRFS_I(new_dir), parent);
+               btrfs_log_new_name(trans, BTRFS_I(new_inode), BTRFS_I(new_dir),
+                               parent);
                btrfs_end_log_trans(dest);
                dest_log_pinned = false;
        }
@@ -9872,7 +9879,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        old_inode->i_ctime = current_time(old_dir);
 
        if (old_dentry->d_parent != new_dentry->d_parent)
-               btrfs_record_unlink_dir(trans, BTRFS_I(old_dir), BTRFS_I(old_inode), 1);
+               btrfs_record_unlink_dir(trans, BTRFS_I(old_dir),
+                               BTRFS_I(old_inode), 1);
 
        if (unlikely(old_ino == BTRFS_FIRST_FREE_OBJECTID)) {
                root_objectid = BTRFS_I(old_inode)->root->root_key.objectid;
@@ -9931,7 +9939,8 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
        if (log_pinned) {
                struct dentry *parent = new_dentry->d_parent;
 
-               btrfs_log_new_name(trans, BTRFS_I(old_inode), BTRFS_I(old_dir), parent);
+               btrfs_log_new_name(trans, BTRFS_I(old_inode), BTRFS_I(old_dir),
+                               parent);
                btrfs_end_log_trans(root);
                log_pinned = false;
        }
@@ -10226,8 +10235,8 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
                goto out_unlock;
 
        inode = btrfs_new_inode(trans, root, dir, dentry->d_name.name,
-                               dentry->d_name.len, btrfs_ino(BTRFS_I(dir)), objectid,
-                               S_IFLNK|S_IRWXUGO, &index);
+                               dentry->d_name.len, btrfs_ino(BTRFS_I(dir)),
+                               objectid, S_IFLNK|S_IRWXUGO, &index);
        if (IS_ERR(inode)) {
                err = PTR_ERR(inode);
                goto out_unlock;
@@ -10506,7 +10515,7 @@ static int btrfs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
                goto out;
 
        inode = btrfs_new_inode(trans, root, dir, NULL, 0,
-                               btrfs_ino(BTRFS_I(dir)), objectid, mode, &index);
+                       btrfs_ino(BTRFS_I(dir)), objectid, mode, &index);
        if (IS_ERR(inode)) {
                ret = PTR_ERR(inode);
                inode = NULL;

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 7a3fc99e93b77370265552510405b932b6f60ca7..37175ace7fae2b74681bf926b796a136ccf959a2 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -1609,8 +1609,8 @@ static int get_new_location(struct inode *reloc_inode, u64 *new_bytenr,
                return -ENOMEM;
 
        bytenr -= BTRFS_I(reloc_inode)->index_cnt;
-       ret = btrfs_lookup_file_extent(NULL, root, path, btrfs_ino(BTRFS_I(reloc_inode)),
-                                      bytenr, 0);
+       ret = btrfs_lookup_file_extent(NULL, root, path,
+                       btrfs_ino(BTRFS_I(reloc_inode)), bytenr, 0);
        if (ret < 0)
                goto out;
        if (ret > 0) {

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 20fd7a6fd00deaceabd2fd23fd068bf3784058a9..010cf768567778eb05f56ef2a1a31737e34e3ac3 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -631,8 +631,8 @@ static noinline int replay_one_extent(struct btrfs_trans_handle *trans,
         * file.  This must be done before the btrfs_drop_extents run
         * so we don't try to drop this extent.
         */
-       ret = btrfs_lookup_file_extent(trans, root, path, btrfs_ino(BTRFS_I(inode)),
-                                      start, 0);
+       ret = btrfs_lookup_file_extent(trans, root, path,
+                       btrfs_ino(BTRFS_I(inode)), start, 0);
 
        if (ret == 0 &&
            (found_type == BTRFS_FILE_EXTENT_REG ||
@@ -1296,8 +1296,9 @@ static noinline int add_inode_ref(struct btrfs_trans_handle *trans,
                        goto out;
 
                /* if we already have a perfect match, we're done */
-               if (!inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)), btrfs_ino(BTRFS_I(inode)),
-                                 ref_index, name, namelen)) {
+               if (!inode_in_dir(root, path, btrfs_ino(BTRFS_I(dir)),
+                                       btrfs_ino(BTRFS_I(inode)), ref_index,
+                                       name, namelen)) {
                        /*
                         * look for a conflicting back reference in the
                         * metadata. if we find one we have to unlink that name
@@ -3676,7 +3677,8 @@ static noinline int copy_items(struct btrfs_trans_handle *trans,
                                                    dst_path->slots[0],
                                                    struct btrfs_inode_item);
                        fill_inode_item(trans, dst_path->nodes[0], inode_item,
-                                       &inode->vfs_inode, inode_only == LOG_INODE_EXISTS,
+                                       &inode->vfs_inode,
+                                       inode_only == LOG_INODE_EXISTS,
                                        logged_isize);
                } else {
                        copy_extent_buffer(dst_path->nodes[0], src, dst_offset,
@@ -3826,7 +3828,8 @@ fill_holes:
        if (need_find_last_extent) {
                /* btrfs_prev_leaf could return 1 without releasing the path */
                btrfs_release_path(src_path);
-               ret = btrfs_search_slot(NULL, inode->root, &first_key, src_path, 0, 0);
+               ret = btrfs_search_slot(NULL, inode->root, &first_key,
+                               src_path, 0, 0);
                if (ret < 0)
                        return ret;
                ASSERT(ret == 0);
@@ -3881,7 +3884,7 @@ fill_holes:
                offset = *last_extent;
                len = key.offset - *last_extent;
                ret = btrfs_insert_file_extent(trans, log, btrfs_ino(inode),
-                                              offset, 0, 0, len, 0, len, 0, 0, 0);
+                               offset, 0, 0, len, 0, len, 0, 0, 0);
                if (ret)
                        break;
                *last_extent = extent_end;
@@ -4071,8 +4074,8 @@ static int log_one_extent(struct btrfs_trans_handle *trans,
        int extent_inserted = 0;
        bool ordered_io_err = false;
 
-       ret = wait_ordered_extents(trans, &inode->vfs_inode, root, em, logged_list,
-                                  &ordered_io_err);
+       ret = wait_ordered_extents(trans, &inode->vfs_inode, root, em,
+                       logged_list, &ordered_io_err);
        if (ret)
                return ret;
 
@@ -5368,7 +5371,7 @@ static int btrfs_log_all_parents(struct btrfs_trans_handle *trans,
                                ret = 1;
                        if (!ret && ctx && ctx->log_new_dentries)
                                ret = log_new_dir_dentries(trans, root,
-                                                          BTRFS_I(dir_inode), ctx);
+                                                  BTRFS_I(dir_inode), ctx);
                        iput(dir_inode);
                        if (ret)
                                goto out;
@@ -5810,7 +5813,7 @@ int btrfs_log_new_name(struct btrfs_trans_handle *trans,
                        struct dentry *parent)
 {
        struct btrfs_fs_info *fs_info = btrfs_sb(inode->vfs_inode.i_sb);
-       struct btrfs_root * root = inode->root;
+       struct btrfs_root *root = inode->root;
 
        /*
         * this will force the logging code to walk the dentry chain

diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 6cf3b0f1bef6e2a9763b490482ffea0ee60b9602..b3cbf80c5acfa2ebe0541f14d60278f477664908 100644 (file)
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -47,8 +47,8 @@ ssize_t __btrfs_getxattr(struct inode *inode, const char *name,
                return -ENOMEM;
 
        /* lookup the xattr by name */
-       di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(BTRFS_I(inode)), name,
-                               strlen(name), 0);
+       di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(BTRFS_I(inode)),
+                       name, strlen(name), 0);
        if (!di) {
                ret = -ENODATA;
                goto out;
@@ -108,8 +108,8 @@ static int do_setxattr(struct btrfs_trans_handle *trans,
        path->skip_release_on_error = 1;
 
        if (!value) {
-               di = btrfs_lookup_xattr(trans, root, path, btrfs_ino(BTRFS_I(inode)),
-                                       name, name_len, -1);
+               di = btrfs_lookup_xattr(trans, root, path,
+                               btrfs_ino(BTRFS_I(inode)), name, name_len, -1);
                if (!di && (flags & XATTR_REPLACE))
                        ret = -ENODATA;
                else if (IS_ERR(di))
@@ -128,8 +128,8 @@ static int do_setxattr(struct btrfs_trans_handle *trans,
         */
        if (flags & XATTR_REPLACE) {
                ASSERT(inode_is_locked(inode));
-               di = btrfs_lookup_xattr(NULL, root, path, btrfs_ino(BTRFS_I(inode)),
-                                       name, name_len, 0);
+               di = btrfs_lookup_xattr(NULL, root, path,
+                               btrfs_ino(BTRFS_I(inode)), name, name_len, 0);
                if (!di)
                        ret = -ENODATA;
                else if (IS_ERR(di))