btrfs: remove root parameter from transaction commit/end routines

Now we only use the root parameter to print the root objectid in
a tracepoint.  We can use the root parameter from the transaction
handle for that.  It's also used to join the transaction with
async commits, so we remove the comment that it's just for checking.

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

diff --git a/fs/btrfs/backref.c b/fs/btrfs/backref.c
index 4577c028333a3408fb21ca56c5ffb58ec60eb934..8299601a35493b28f137cce3074dec455efbb3bf 100644 (file)
--- a/fs/btrfs/backref.c
+++ b/fs/btrfs/backref.c
@@ -2056,7 +2056,7 @@ int iterate_extent_inodes(struct btrfs_fs_info *fs_info,
 out:
        if (!search_commit_root) {
                btrfs_put_tree_mod_seq(fs_info, &tree_mod_seq_elem);
-               btrfs_end_transaction(trans, fs_info->extent_root);
+               btrfs_end_transaction(trans);
        } else {
                up_read(&fs_info->commit_root_sem);
        }

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index 33ed79b8d6cc59ac8f433c08025158169fc49b6c..be007c1b5592281e2d7ca85805797b390b58ee9f 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -1280,7 +1280,7 @@ int btrfs_commit_inode_delayed_inode(struct inode *inode)
        btrfs_free_path(path);
        trans->block_rsv = block_rsv;
 trans_out:
-       btrfs_end_transaction(trans, delayed_node->root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
 out:
        btrfs_release_delayed_node(delayed_node);
@@ -1345,7 +1345,7 @@ static void btrfs_async_run_delayed_root(struct btrfs_work *work)
        __btrfs_commit_inode_delayed_items(trans, path, delayed_node);
 
        trans->block_rsv = block_rsv;
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty_nodelay(root->fs_info);
 
 release_path:

diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
index 1b545885f7b1a0b87fa5b9f00408e08f5e32bcf9..5de280b9ad7303ad90c0070ae17983ff32e7d7de 100644 (file)
--- a/fs/btrfs/dev-replace.c
+++ b/fs/btrfs/dev-replace.c
@@ -335,7 +335,7 @@ int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info, char *tgtdev_name,
         */
        trans = btrfs_attach_transaction(root);
        if (!IS_ERR(trans)) {
-               ret = btrfs_commit_transaction(trans, root);
+               ret = btrfs_commit_transaction(trans);
                if (ret)
                        return ret;
        } else if (PTR_ERR(trans) != -ENOENT) {
@@ -397,7 +397,7 @@ int btrfs_dev_replace_start(struct btrfs_fs_info *fs_info, char *tgtdev_name,
                goto leave;
        }
 
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
        WARN_ON(ret);
 
        /* the disk copy procedure reuses the scrub code */
@@ -513,7 +513,7 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
                return PTR_ERR(trans);
        }
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
        WARN_ON(ret);
 
        mutex_lock(&uuid_mutex);
@@ -603,7 +603,7 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
        /* write back the superblocks */
        trans = btrfs_start_transaction(root, 0);
        if (!IS_ERR(trans))
-               btrfs_commit_transaction(trans, root);
+               btrfs_commit_transaction(trans);
 
        mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
 
@@ -718,7 +718,7 @@ static u64 __btrfs_dev_replace_cancel(struct btrfs_fs_info *fs_info)
                mutex_unlock(&dev_replace->lock_finishing_cancel_unmount);
                return PTR_ERR(trans);
        }
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
        WARN_ON(ret);
        if (tgt_device)
                btrfs_destroy_dev_replace_tgtdev(fs_info, tgt_device);

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index 3ce36b526ebedc2d7fbce75cd8b76de2811610e6..196f1aafcea94ea68b90e81128c70ec05f76c67d 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -1913,7 +1913,7 @@ static int cleaner_kthread(void *arg)
        } else {
                int ret;
 
-               ret = btrfs_commit_transaction(trans, root);
+               ret = btrfs_commit_transaction(trans);
                if (ret)
                        btrfs_err(fs_info,
                                  "cleaner open transaction commit returned %d",
@@ -1965,9 +1965,9 @@ static int transaction_kthread(void *arg)
                        goto sleep;
                }
                if (transid == trans->transid) {
-                       btrfs_commit_transaction(trans, root);
+                       btrfs_commit_transaction(trans);
                } else {
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
                }
 sleep:
                wake_up_process(fs_info->cleaner_kthread);
@@ -3901,7 +3901,7 @@ int btrfs_commit_super(struct btrfs_fs_info *fs_info)
        trans = btrfs_join_transaction(root);
        if (IS_ERR(trans))
                return PTR_ERR(trans);
-       return btrfs_commit_transaction(trans, root);
+       return btrfs_commit_transaction(trans);
 }
 
 void close_ctree(struct btrfs_fs_info *fs_info)

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 0360e973378d44ab10df90b3e6d758cb0d5b2391..2825019cd18f0fab5654b3d12390d713e76e616c 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -2868,7 +2868,7 @@ static void delayed_ref_async_start(struct btrfs_work *work)
        if (ret)
                async->error = ret;
 end:
-       ret = btrfs_end_transaction(trans, async->root);
+       ret = btrfs_end_transaction(trans);
        if (ret && !async->error)
                async->error = ret;
 done:
@@ -4175,7 +4175,7 @@ int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes)
 
                        ret = do_chunk_alloc(trans, fs_info, alloc_target,
                                             CHUNK_ALLOC_NO_FORCE);
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
                        if (ret < 0) {
                                if (ret != -ENOSPC)
                                        return ret;
@@ -4220,7 +4220,7 @@ int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes)
                            test_bit(BTRFS_TRANS_HAVE_FREE_BGS,
                                     &trans->transaction->flags) ||
                            need_commit > 0) {
-                               ret = btrfs_commit_transaction(trans, root);
+                               ret = btrfs_commit_transaction(trans);
                                if (ret)
                                        return ret;
                                /*
@@ -4232,7 +4232,7 @@ int btrfs_alloc_data_chunk_ondemand(struct inode *inode, u64 bytes)
                                mutex_unlock(&fs_info->cleaner_delayed_iput_mutex);
                                goto again;
                        } else {
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        }
                }
 
@@ -4824,7 +4824,7 @@ static int may_commit_transaction(struct btrfs_root *root,
        if (IS_ERR(trans))
                return -ENOSPC;
 
-       return btrfs_commit_transaction(trans, root);
+       return btrfs_commit_transaction(trans);
 }
 
 struct reserve_ticket {
@@ -4857,7 +4857,7 @@ static int flush_space(struct btrfs_root *root,
                        break;
                }
                ret = btrfs_run_delayed_items_nr(trans, fs_info, nr);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                break;
        case FLUSH_DELALLOC:
        case FLUSH_DELALLOC_WAIT:
@@ -4873,7 +4873,7 @@ static int flush_space(struct btrfs_root *root,
                ret = do_chunk_alloc(trans, fs_info,
                                     btrfs_get_alloc_profile(root, 0),
                                     CHUNK_ALLOC_NO_FORCE);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                if (ret > 0 || ret == -ENOSPC)
                        ret = 0;
                break;
@@ -7854,7 +7854,7 @@ static noinline int find_free_extent(struct btrfs_root *orig_root,
                        else
                                ret = 0;
                        if (!exist)
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        if (ret)
                                goto out;
                }
@@ -9106,7 +9106,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
                }
 
                BUG_ON(wc->level == 0);
-               if (btrfs_should_end_transaction(trans, tree_root) ||
+               if (btrfs_should_end_transaction(trans) ||
                    (!for_reloc && btrfs_need_cleaner_sleep(fs_info))) {
                        ret = btrfs_update_root(trans, tree_root,
                                                &root->root_key,
@@ -9117,7 +9117,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
                                goto out_end_trans;
                        }
 
-                       btrfs_end_transaction_throttle(trans, tree_root);
+                       btrfs_end_transaction_throttle(trans);
                        if (!for_reloc && btrfs_need_cleaner_sleep(fs_info)) {
                                btrfs_debug(fs_info,
                                            "drop snapshot early exit");
@@ -9171,7 +9171,7 @@ int btrfs_drop_snapshot(struct btrfs_root *root,
        }
        root_dropped = true;
 out_end_trans:
-       btrfs_end_transaction_throttle(trans, tree_root);
+       btrfs_end_transaction_throttle(trans);
 out_free:
        kfree(wc);
        btrfs_free_path(path);
@@ -9380,7 +9380,7 @@ int btrfs_inc_block_group_ro(struct btrfs_root *root,
                u64 transid = trans->transid;
 
                mutex_unlock(&fs_info->ro_block_group_mutex);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
 
                ret = btrfs_wait_for_commit(fs_info, transid);
                if (ret)
@@ -9425,7 +9425,7 @@ int btrfs_inc_block_group_ro(struct btrfs_root *root,
        }
        mutex_unlock(&fs_info->ro_block_group_mutex);
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        return ret;
 }
 
@@ -9644,7 +9644,7 @@ int btrfs_can_relocate(struct btrfs_fs_info *fs_info, u64 bytenr)
                           "no space to allocate a new chunk for block group %llu",
                           block_group->key.objectid);
        mutex_unlock(&fs_info->chunk_mutex);
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 out:
        btrfs_put_block_group(block_group);
        return ret;
@@ -10596,7 +10596,6 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
 {
        struct btrfs_block_group_cache *block_group;
        struct btrfs_space_info *space_info;
-       struct btrfs_root *root = fs_info->extent_root;
        struct btrfs_trans_handle *trans;
        int ret = 0;
 
@@ -10747,7 +10746,7 @@ void btrfs_delete_unused_bgs(struct btrfs_fs_info *fs_info)
                        btrfs_get_block_group(block_group);
                }
 end_trans:
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
 next:
                mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                btrfs_put_block_group(block_group);

diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
index 3b148e5fcc560616a318e7bae4c987dea2a30c39..bf2defa8ebe05ef19117131c1b204759cb9aa7c3 100644 (file)
--- a/fs/btrfs/extent_io.c
+++ b/fs/btrfs/extent_io.c
@@ -4540,7 +4540,7 @@ int extent_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                                                 root->objectid,
                                                 btrfs_ino(inode), bytenr);
                        if (trans)
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        if (ret < 0)
                                goto out_free;
                        if (ret)

diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
index 2d3b93dd9c2c548c42b67875eb7bac3d0f720b7e..140271b1ea2edb10a4b15323ce7a90ebd7216cd6 100644 (file)
--- a/fs/btrfs/file.c
+++ b/fs/btrfs/file.c
@@ -2146,7 +2146,7 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         * which are indicated by ctx.io_err.
         */
        if (ctx.io_err) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                ret = ctx.io_err;
                goto out;
        }
@@ -2155,20 +2155,20 @@ int btrfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
                if (!ret) {
                        ret = btrfs_sync_log(trans, root, &ctx);
                        if (!ret) {
-                               ret = btrfs_end_transaction(trans, root);
+                               ret = btrfs_end_transaction(trans);
                                goto out;
                        }
                }
                if (!full_sync) {
                        ret = btrfs_wait_ordered_range(inode, start, len);
                        if (ret) {
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                                goto out;
                        }
                }
-               ret = btrfs_commit_transaction(trans, root);
+               ret = btrfs_commit_transaction(trans);
        } else {
-               ret = btrfs_end_transaction(trans, root);
+               ret = btrfs_end_transaction(trans);
        }
 out:
        return ret > 0 ? -EIO : ret;
@@ -2574,7 +2574,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                        break;
                }
 
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                btrfs_btree_balance_dirty(fs_info);
 
                trans = btrfs_start_transaction(root, rsv_count);
@@ -2642,7 +2642,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
        trans->block_rsv = &fs_info->trans_block_rsv;
        ret = btrfs_update_inode(trans, root, inode);
        updated_inode = true;
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
 out_free:
        btrfs_free_path(path);
@@ -2664,7 +2664,7 @@ static int btrfs_punch_hole(struct inode *inode, loff_t offset, loff_t len)
                        err = PTR_ERR(trans);
                } else {
                        err = btrfs_update_inode(trans, root, inode);
-                       ret = btrfs_end_transaction(trans, root);
+                       ret = btrfs_end_transaction(trans);
                }
        }
        inode_unlock(inode);
@@ -2906,9 +2906,9 @@ static long btrfs_fallocate(struct file *file, int mode,
                        btrfs_ordered_update_i_size(inode, actual_end, NULL);
                        ret = btrfs_update_inode(trans, root, inode);
                        if (ret)
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        else
-                               ret = btrfs_end_transaction(trans, root);
+                               ret = btrfs_end_transaction(trans);
                }
        }
 out_unlock:

diff --git a/fs/btrfs/free-space-tree.c b/fs/btrfs/free-space-tree.c
index 2a08f518353b276c998c3c103850c58df87502c4..ff0c55337c2e97ccd7b8a1d5dc9dbcd0bce60450 100644 (file)
--- a/fs/btrfs/free-space-tree.c
+++ b/fs/btrfs/free-space-tree.c
@@ -1189,7 +1189,7 @@ int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)
        btrfs_set_fs_compat_ro(fs_info, FREE_SPACE_TREE_VALID);
        clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);
 
-       ret = btrfs_commit_transaction(trans, tree_root);
+       ret = btrfs_commit_transaction(trans);
        if (ret)
                return ret;
 
@@ -1198,7 +1198,7 @@ int btrfs_create_free_space_tree(struct btrfs_fs_info *fs_info)
 abort:
        clear_bit(BTRFS_FS_CREATING_FREE_SPACE_TREE, &fs_info->flags);
        btrfs_abort_transaction(trans, ret);
-       btrfs_end_transaction(trans, tree_root);
+       btrfs_end_transaction(trans);
        return ret;
 }
 
@@ -1278,7 +1278,7 @@ int btrfs_clear_free_space_tree(struct btrfs_fs_info *fs_info)
        free_extent_buffer(free_space_root->commit_root);
        kfree(free_space_root);
 
-       ret = btrfs_commit_transaction(trans, tree_root);
+       ret = btrfs_commit_transaction(trans);
        if (ret)
                return ret;
 
@@ -1286,7 +1286,7 @@ int btrfs_clear_free_space_tree(struct btrfs_fs_info *fs_info)
 
 abort:
        btrfs_abort_transaction(trans, ret);
-       btrfs_end_transaction(trans, tree_root);
+       btrfs_end_transaction(trans);
        return ret;
 }
 

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 5fa8aeb23e944e56ea6b29af48c48792c6504ab1..dbcec1ced85ab404d7974db7016252bc6b48d28d 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -326,7 +326,7 @@ static noinline int cow_file_range_inline(struct btrfs_root *root,
         */
        btrfs_qgroup_free_data(inode, 0, PAGE_SIZE);
        btrfs_free_path(path);
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        return ret;
 }
 
@@ -1534,7 +1534,7 @@ static noinline int run_delalloc_nocow(struct inode *inode,
        }
 
 error:
-       err = btrfs_end_transaction(trans, root);
+       err = btrfs_end_transaction(trans);
        if (!ret)
                ret = err;
 
@@ -2665,7 +2665,7 @@ static noinline int relink_extent_backref(struct btrfs_path *path,
 out_free_path:
        btrfs_release_path(path);
        path->leave_spinning = 0;
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 out_unlock:
        unlock_extent_cached(&BTRFS_I(inode)->io_tree, lock_start, lock_end,
                             &cached, GFP_NOFS);
@@ -3011,7 +3011,7 @@ static int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent)
        if (root != fs_info->tree_root)
                btrfs_delalloc_release_metadata(inode, ordered_extent->len);
        if (trans)
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
 
        if (ret || truncated) {
                u64 start, end;
@@ -3519,7 +3519,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
                                    found_key.objectid);
                        ret = btrfs_del_orphan_item(trans, root,
                                                    found_key.objectid);
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
                        if (ret)
                                goto out;
                        continue;
@@ -3549,7 +3549,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
                                goto out;
                        }
                        ret = btrfs_orphan_add(trans, inode);
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
                        if (ret) {
                                iput(inode);
                                goto out;
@@ -3580,7 +3580,7 @@ int btrfs_orphan_cleanup(struct btrfs_root *root)
            test_bit(BTRFS_ROOT_ORPHAN_ITEM_INSERTED, &root->state)) {
                trans = btrfs_join_transaction(root);
                if (!IS_ERR(trans))
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
        }
 
        if (nr_unlink)
@@ -4156,7 +4156,7 @@ static int btrfs_unlink(struct inode *dir, struct dentry *dentry)
        }
 
 out:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(root->fs_info);
        return ret;
 }
@@ -4293,7 +4293,7 @@ static int btrfs_rmdir(struct inode *dir, struct dentry *dentry)
                        BTRFS_I(dir)->last_unlink_trans = last_unlink_trans;
        }
 out:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(root->fs_info);
 
        return err;
@@ -4453,7 +4453,7 @@ int btrfs_truncate_inode_items(struct btrfs_trans_handle *trans,
         * bytes_deleted is > 0, it will be huge by the time we get here
         */
        if (be_nice && bytes_deleted > SZ_32M) {
-               if (btrfs_should_end_transaction(trans, root)) {
+               if (btrfs_should_end_transaction(trans)) {
                        err = -EAGAIN;
                        goto error;
                }
@@ -4858,7 +4858,7 @@ static int maybe_insert_hole(struct btrfs_root *root, struct inode *inode,
        ret = btrfs_drop_extents(trans, root, inode, offset, offset + len, 1);
        if (ret) {
                btrfs_abort_transaction(trans, ret);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 
@@ -4868,7 +4868,7 @@ static int maybe_insert_hole(struct btrfs_root *root, struct inode *inode,
                btrfs_abort_transaction(trans, ret);
        else
                btrfs_update_inode(trans, root, inode);
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        return ret;
 }
 
@@ -5032,7 +5032,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
                pagecache_isize_extended(inode, oldsize, newsize);
                ret = btrfs_update_inode(trans, root, inode);
                btrfs_end_write_no_snapshoting(root);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
        } else {
 
                /*
@@ -5063,7 +5063,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
                 * will be consistent.
                 */
                ret = btrfs_orphan_add(trans, inode);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                if (ret)
                        return ret;
 
@@ -5094,7 +5094,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)
                        err = btrfs_orphan_del(trans, inode);
                        if (err)
                                btrfs_abort_transaction(trans, err);
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
                }
        }
 
@@ -5355,7 +5355,7 @@ void btrfs_evict_inode(struct inode *inode)
                 * again.
                 */
                if (ret) {
-                       ret = btrfs_commit_transaction(trans, root);
+                       ret = btrfs_commit_transaction(trans);
                        if (ret) {
                                btrfs_orphan_del(NULL, inode);
                                btrfs_free_block_rsv(fs_info, rsv);
@@ -5373,7 +5373,7 @@ void btrfs_evict_inode(struct inode *inode)
                        break;
 
                trans->block_rsv = &fs_info->trans_block_rsv;
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                trans = NULL;
                btrfs_btree_balance_dirty(fs_info);
        }
@@ -5396,7 +5396,7 @@ void btrfs_evict_inode(struct inode *inode)
              root->root_key.objectid == BTRFS_TREE_RELOC_OBJECTID))
                btrfs_return_ino(root, btrfs_ino(inode));
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
 no_delete:
        btrfs_remove_delayed_node(inode);
@@ -5975,7 +5975,7 @@ int btrfs_write_inode(struct inode *inode, struct writeback_control *wbc)
                        trans = btrfs_join_transaction(root);
                if (IS_ERR(trans))
                        return PTR_ERR(trans);
-               ret = btrfs_commit_transaction(trans, root);
+               ret = btrfs_commit_transaction(trans);
        }
        return ret;
 }
@@ -6003,14 +6003,14 @@ static int btrfs_dirty_inode(struct inode *inode)
        ret = btrfs_update_inode(trans, root, inode);
        if (ret && ret == -ENOSPC) {
                /* whoops, lets try again with the full transaction */
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                trans = btrfs_start_transaction(root, 1);
                if (IS_ERR(trans))
                        return PTR_ERR(trans);
 
                ret = btrfs_update_inode(trans, root, inode);
        }
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        if (BTRFS_I(inode)->delayed_node)
                btrfs_balance_delayed_items(fs_info);
 
@@ -6448,7 +6448,7 @@ static int btrfs_mknod(struct inode *dir, struct dentry *dentry,
        }
 
 out_unlock:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_balance_delayed_items(fs_info);
        btrfs_btree_balance_dirty(fs_info);
        if (drop_inode) {
@@ -6524,7 +6524,7 @@ static int btrfs_create(struct inode *dir, struct dentry *dentry,
        d_instantiate(dentry, inode);
 
 out_unlock:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        if (err && drop_inode_on_err) {
                inode_dec_link_count(inode);
                iput(inode);
@@ -6606,7 +6606,7 @@ static int btrfs_link(struct dentry *old_dentry, struct inode *dir,
        btrfs_balance_delayed_items(fs_info);
 fail:
        if (trans)
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
        if (drop_inode) {
                inode_dec_link_count(inode);
                iput(inode);
@@ -6675,7 +6675,7 @@ static int btrfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
        drop_on_err = 0;
 
 out_fail:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        if (drop_on_err) {
                inode_dec_link_count(inode);
                iput(inode);
@@ -7063,7 +7063,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
 
        btrfs_free_path(path);
        if (trans) {
-               ret = btrfs_end_transaction(trans, root);
+               ret = btrfs_end_transaction(trans);
                if (!err)
                        err = ret;
        }
@@ -7386,7 +7386,7 @@ noinline int can_nocow_extent(struct inode *inode, u64 offset, u64 *len,
 
        ret = btrfs_cross_ref_exist(trans, root, btrfs_ino(inode),
                                    key.offset - backref_offset, disk_bytenr);
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        if (ret) {
                ret = 0;
                goto out;
@@ -9200,7 +9200,7 @@ static int btrfs_truncate(struct inode *inode)
                        break;
                }
 
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                btrfs_btree_balance_dirty(fs_info);
 
                trans = btrfs_start_transaction(root, 2);
@@ -9229,7 +9229,7 @@ static int btrfs_truncate(struct inode *inode)
                if (ret && !err)
                        err = ret;
 
-               ret = btrfs_end_transaction(trans, root);
+               ret = btrfs_end_transaction(trans);
                btrfs_btree_balance_dirty(fs_info);
        }
 out:
@@ -9697,7 +9697,7 @@ static int btrfs_rename_exchange(struct inode *old_dir,
                        dest_log_pinned = false;
                }
        }
-       ret = btrfs_end_transaction(trans, root);
+       ret = btrfs_end_transaction(trans);
 out_notrans:
        if (new_ino == BTRFS_FIRST_FREE_OBJECTID)
                up_read(&fs_info->subvol_sem);
@@ -9967,7 +9967,7 @@ static int btrfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                btrfs_end_log_trans(root);
                log_pinned = false;
        }
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 out_notrans:
        if (old_ino == BTRFS_FIRST_FREE_OBJECTID)
                up_read(&fs_info->subvol_sem);
@@ -10300,7 +10300,7 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
        d_instantiate(dentry, inode);
 
 out_unlock:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        if (drop_inode) {
                inode_dec_link_count(inode);
                iput(inode);
@@ -10356,7 +10356,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                                min_size, 0, *alloc_hint, &ins, 1, 0);
                if (ret) {
                        if (own_trans)
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        break;
                }
                btrfs_dec_block_group_reservations(fs_info, ins.objectid);
@@ -10372,7 +10372,7 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                                                   ins.offset, 0);
                        btrfs_abort_transaction(trans, ret);
                        if (own_trans)
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        break;
                }
 
@@ -10432,12 +10432,12 @@ static int __btrfs_prealloc_file_range(struct inode *inode, int mode,
                if (ret) {
                        btrfs_abort_transaction(trans, ret);
                        if (own_trans)
-                               btrfs_end_transaction(trans, root);
+                               btrfs_end_transaction(trans);
                        break;
                }
 
                if (own_trans)
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
        }
        if (cur_offset < end)
                btrfs_free_reserved_data_space(inode, cur_offset,
@@ -10542,7 +10542,7 @@ static int btrfs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode)
        mark_inode_dirty(inode);
 
 out:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        if (ret)
                iput(inode);
        btrfs_balance_delayed_items(fs_info);

diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index 256af12d0ff00a30ecf9a085e2a09069d781a10b..0a6902555e654e7ff5d99ab1a13d03cbca5ec139 100644 (file)
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -352,7 +352,7 @@ static int btrfs_ioctl_setflags(struct file *file, void __user *arg)
        inode->i_ctime = current_time(inode);
        ret = btrfs_update_inode(trans, root, inode);
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
  out_drop:
        if (ret) {
                ip->flags = ip_oldflags;
@@ -617,11 +617,11 @@ static noinline int create_subvol(struct inode *dir,
 
        if (async_transid) {
                *async_transid = trans->transid;
-               err = btrfs_commit_transaction_async(trans, root, 1);
+               err = btrfs_commit_transaction_async(trans, 1);
                if (err)
-                       err = btrfs_commit_transaction(trans, root);
+                       err = btrfs_commit_transaction(trans);
        } else {
-               err = btrfs_commit_transaction(trans, root);
+               err = btrfs_commit_transaction(trans);
        }
        if (err && !ret)
                ret = err;
@@ -727,13 +727,11 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,
        spin_unlock(&fs_info->trans_lock);
        if (async_transid) {
                *async_transid = trans->transid;
-               ret = btrfs_commit_transaction_async(trans,
-                                    fs_info->extent_root, 1);
+               ret = btrfs_commit_transaction_async(trans, 1);
                if (ret)
-                       ret = btrfs_commit_transaction(trans, root);
+                       ret = btrfs_commit_transaction(trans);
        } else {
-               ret = btrfs_commit_transaction(trans,
-                                              fs_info->extent_root);
+               ret = btrfs_commit_transaction(trans);
        }
        if (ret)
                goto fail;
@@ -1615,7 +1613,7 @@ static noinline int btrfs_ioctl_resize(struct file *file,
                        goto out_free;
                }
                ret = btrfs_grow_device(trans, device, new_size);
-               btrfs_commit_transaction(trans, root);
+               btrfs_commit_transaction(trans);
        } else if (new_size < old_size) {
                ret = btrfs_shrink_device(device, new_size);
        } /* equal, nothing need to do */
@@ -1873,7 +1871,7 @@ static noinline int btrfs_ioctl_subvol_setflags(struct file *file,
        ret = btrfs_update_root(trans, fs_info->tree_root,
                                &root->root_key, &root->root_item);
 
-       btrfs_commit_transaction(trans, root);
+       btrfs_commit_transaction(trans);
 out_reset:
        if (ret)
                btrfs_set_root_flags(&root->root_item, root_flags);
@@ -2552,7 +2550,7 @@ static noinline int btrfs_ioctl_snap_destroy(struct file *file,
 out_end_trans:
        trans->block_rsv = NULL;
        trans->bytes_reserved = 0;
-       ret = btrfs_end_transaction(trans, root);
+       ret = btrfs_end_transaction(trans);
        if (ret && !err)
                err = ret;
        inode->i_flags |= S_DEAD;
@@ -3311,10 +3309,10 @@ static int clone_finish_inode_update(struct btrfs_trans_handle *trans,
        ret = btrfs_update_inode(trans, root, inode);
        if (ret) {
                btrfs_abort_transaction(trans, ret);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                goto out;
        }
-       ret = btrfs_end_transaction(trans, root);
+       ret = btrfs_end_transaction(trans);
 out:
        return ret;
 }
@@ -3715,7 +3713,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
                                        if (ret != -EOPNOTSUPP)
                                                btrfs_abort_transaction(trans,
                                                                        ret);
-                                       btrfs_end_transaction(trans, root);
+                                       btrfs_end_transaction(trans);
                                        goto out;
                                }
 
@@ -3723,7 +3721,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
                                                              &new_key, size);
                                if (ret) {
                                        btrfs_abort_transaction(trans, ret);
-                                       btrfs_end_transaction(trans, root);
+                                       btrfs_end_transaction(trans);
                                        goto out;
                                }
 
@@ -3756,8 +3754,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
                                        if (ret) {
                                                btrfs_abort_transaction(trans,
                                                                        ret);
-                                               btrfs_end_transaction(trans,
-                                                                     root);
+                                               btrfs_end_transaction(trans);
                                                goto out;
 
                                        }
@@ -3776,7 +3773,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
 
                                if (comp && (skip || trim)) {
                                        ret = -EINVAL;
-                                       btrfs_end_transaction(trans, root);
+                                       btrfs_end_transaction(trans);
                                        goto out;
                                }
                                size -= skip + trim;
@@ -3792,7 +3789,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
                                        if (ret != -EOPNOTSUPP)
                                                btrfs_abort_transaction(trans,
                                                                        ret);
-                                       btrfs_end_transaction(trans, root);
+                                       btrfs_end_transaction(trans);
                                        goto out;
                                }
                                leaf = path->nodes[0];
@@ -3852,7 +3849,7 @@ static int btrfs_clone(struct inode *src, struct inode *inode,
                if (ret) {
                        if (ret != -EOPNOTSUPP)
                                btrfs_abort_transaction(trans, ret);
-                       btrfs_end_transaction(trans, root);
+                       btrfs_end_transaction(trans);
                        goto out;
                }
                clone_update_extent_map(inode, trans, NULL, last_dest_end,
@@ -4114,7 +4111,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
                                   dir_id, "default", 7, 1);
        if (IS_ERR_OR_NULL(di)) {
                btrfs_free_path(path);
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                btrfs_err(fs_info,
                          "Umm, you don't have the default diritem, this isn't going to work");
                ret = -ENOENT;
@@ -4127,7 +4124,7 @@ static long btrfs_ioctl_default_subvol(struct file *file, void __user *argp)
        btrfs_free_path(path);
 
        btrfs_set_fs_incompat(fs_info, DEFAULT_SUBVOL);
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 out:
        mnt_drop_write_file(file);
        return ret;
@@ -4307,7 +4304,7 @@ long btrfs_ioctl_trans_end(struct file *file)
                return -EINVAL;
        file->private_data = NULL;
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 
        atomic_dec(&root->fs_info->open_ioctl_trans);
 
@@ -4332,9 +4329,9 @@ static noinline long btrfs_ioctl_start_sync(struct btrfs_root *root,
                goto out;
        }
        transid = trans->transid;
-       ret = btrfs_commit_transaction_async(trans, root, 0);
+       ret = btrfs_commit_transaction_async(trans, 0);
        if (ret) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 out:
@@ -4885,7 +4882,7 @@ static long btrfs_ioctl_quota_ctl(struct file *file, void __user *arg)
                break;
        }
 
-       err = btrfs_commit_transaction(trans, fs_info->tree_root);
+       err = btrfs_commit_transaction(trans);
        if (err && !ret)
                ret = err;
 out:
@@ -4939,7 +4936,7 @@ static long btrfs_ioctl_qgroup_assign(struct file *file, void __user *arg)
        if (err < 0)
                btrfs_handle_fs_error(fs_info, err,
                                      "failed to update qgroup status and info");
-       err = btrfs_end_transaction(trans, root);
+       err = btrfs_end_transaction(trans);
        if (err && !ret)
                ret = err;
 
@@ -4991,7 +4988,7 @@ static long btrfs_ioctl_qgroup_create(struct file *file, void __user *arg)
                ret = btrfs_remove_qgroup(trans, fs_info, sa->qgroupid);
        }
 
-       err = btrfs_end_transaction(trans, root);
+       err = btrfs_end_transaction(trans);
        if (err && !ret)
                ret = err;
 
@@ -5041,7 +5038,7 @@ static long btrfs_ioctl_qgroup_limit(struct file *file, void __user *arg)
        /* FIXME: check if the IDs really exist */
        ret = btrfs_limit_qgroup(trans, fs_info, qgroupid, &sa->lim);
 
-       err = btrfs_end_transaction(trans, root);
+       err = btrfs_end_transaction(trans);
        if (err && !ret)
                ret = err;
 
@@ -5187,7 +5184,7 @@ static long _btrfs_ioctl_set_received_subvol(struct file *file,
        ret = btrfs_update_root(trans, fs_info->tree_root,
                                &root->root_key, &root->root_item);
        if (ret < 0) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                goto out;
        }
        if (received_uuid_changed && !btrfs_is_empty_uuid(sa->uuid)) {
@@ -5199,7 +5196,7 @@ static long _btrfs_ioctl_set_received_subvol(struct file *file,
                        goto out;
                }
        }
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
        if (ret < 0) {
                btrfs_abort_transaction(trans, ret);
                goto out;
@@ -5347,7 +5344,7 @@ static int btrfs_ioctl_set_fslabel(struct file *file, void __user *arg)
        spin_lock(&fs_info->super_lock);
        strcpy(super_block->label, label);
        spin_unlock(&fs_info->super_lock);
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
 
 out_unlock:
        mnt_drop_write_file(file);
@@ -5519,7 +5516,7 @@ static int btrfs_ioctl_set_features(struct file *file, void __user *arg)
        btrfs_set_super_incompat_flags(super_block, newflags);
        spin_unlock(&fs_info->super_lock);
 
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
 out_drop_write:
        mnt_drop_write_file(file);
 

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 135bb7986dfb807111bbeb41b69a236e9a0650c0..3e473e9a4844006d2d235dfb9e5052c41b753a0a 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -2576,9 +2576,9 @@ static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
                        err = qgroup_rescan_leaf(fs_info, path, trans);
                }
                if (err > 0)
-                       btrfs_commit_transaction(trans, fs_info->fs_root);
+                       btrfs_commit_transaction(trans);
                else
-                       btrfs_end_transaction(trans, fs_info->fs_root);
+                       btrfs_end_transaction(trans);
        }
 
 out:
@@ -2613,7 +2613,7 @@ static void btrfs_qgroup_rescan_worker(struct btrfs_work *work)
                err = ret;
                btrfs_err(fs_info, "fail to update qgroup status: %d", err);
        }
-       btrfs_end_transaction(trans, fs_info->quota_root);
+       btrfs_end_transaction(trans);
 
        if (btrfs_fs_closing(fs_info)) {
                btrfs_info(fs_info, "qgroup scan paused");
@@ -2732,7 +2732,7 @@ btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
                return PTR_ERR(trans);
        }
-       ret = btrfs_commit_transaction(trans, fs_info->fs_root);
+       ret = btrfs_commit_transaction(trans);
        if (ret) {
                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
                return ret;

diff --git a/fs/btrfs/relocation.c b/fs/btrfs/relocation.c
index 341a099c4967849c0f3c0938ba224ebd1d1d821a..5d222c8d221383e80d563a726e00e21a770514f1 100644 (file)
--- a/fs/btrfs/relocation.c
+++ b/fs/btrfs/relocation.c
@@ -2270,7 +2270,7 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
                               path->slots[level]);
                root_item->drop_level = level;
 
-               btrfs_end_transaction_throttle(trans, root);
+               btrfs_end_transaction_throttle(trans);
                trans = NULL;
 
                btrfs_btree_balance_dirty(fs_info);
@@ -2301,7 +2301,7 @@ static noinline_for_stack int merge_reloc_root(struct reloc_control *rc,
        }
 
        if (trans)
-               btrfs_end_transaction_throttle(trans, root);
+               btrfs_end_transaction_throttle(trans);
 
        btrfs_btree_balance_dirty(fs_info);
 
@@ -2346,7 +2346,7 @@ int prepare_to_merge(struct reloc_control *rc, int err)
 
        if (!err) {
                if (num_bytes != rc->merging_rsv_size) {
-                       btrfs_end_transaction(trans, rc->extent_root);
+                       btrfs_end_transaction(trans);
                        btrfs_block_rsv_release(fs_info, rc->block_rsv,
                                                num_bytes);
                        goto again;
@@ -2378,9 +2378,9 @@ int prepare_to_merge(struct reloc_control *rc, int err)
        list_splice(&reloc_roots, &rc->reloc_roots);
 
        if (!err)
-               btrfs_commit_transaction(trans, rc->extent_root);
+               btrfs_commit_transaction(trans);
        else
-               btrfs_end_transaction(trans, rc->extent_root);
+               btrfs_end_transaction(trans);
        return err;
 }
 
@@ -3555,7 +3555,7 @@ static int delete_block_group_cache(struct btrfs_fs_info *fs_info,
 
        ret = btrfs_truncate_free_space_cache(root, trans, block_group, inode);
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
 out:
        iput(inode);
@@ -3986,7 +3986,7 @@ int prepare_to_relocate(struct reloc_control *rc)
                 */
                return PTR_ERR(trans);
        }
-       btrfs_commit_transaction(trans, rc->extent_root);
+       btrfs_commit_transaction(trans);
        return 0;
 }
 
@@ -4033,7 +4033,7 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
                }
 restart:
                if (update_backref_cache(trans, &rc->backref_cache)) {
-                       btrfs_end_transaction(trans, rc->extent_root);
+                       btrfs_end_transaction(trans);
                        continue;
                }
 
@@ -4121,7 +4121,7 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
                        }
                }
 
-               btrfs_end_transaction_throttle(trans, rc->extent_root);
+               btrfs_end_transaction_throttle(trans);
                btrfs_btree_balance_dirty(fs_info);
                trans = NULL;
 
@@ -4150,7 +4150,7 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
        clear_extent_bits(&rc->processed_blocks, 0, (u64)-1, EXTENT_DIRTY);
 
        if (trans) {
-               btrfs_end_transaction_throttle(trans, rc->extent_root);
+               btrfs_end_transaction_throttle(trans);
                btrfs_btree_balance_dirty(fs_info);
        }
 
@@ -4181,7 +4181,7 @@ static noinline_for_stack int relocate_block_group(struct reloc_control *rc)
                err = PTR_ERR(trans);
                goto out_free;
        }
-       btrfs_commit_transaction(trans, rc->extent_root);
+       btrfs_commit_transaction(trans);
 out_free:
        btrfs_free_block_rsv(fs_info, rc->block_rsv);
        btrfs_free_path(path);
@@ -4257,7 +4257,7 @@ struct inode *create_reloc_inode(struct btrfs_fs_info *fs_info,
 
        err = btrfs_orphan_add(trans, inode);
 out:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        btrfs_btree_balance_dirty(fs_info);
        if (err) {
                if (inode)
@@ -4442,7 +4442,7 @@ static noinline_for_stack int mark_garbage_root(struct btrfs_root *root)
        ret = btrfs_update_root(trans, fs_info->tree_root,
                                &root->root_key, &root->root_item);
 
-       err = btrfs_end_transaction(trans, fs_info->tree_root);
+       err = btrfs_end_transaction(trans);
        if (err)
                return err;
        return ret;
@@ -4573,7 +4573,7 @@ int btrfs_recover_relocation(struct btrfs_root *root)
                fs_root->reloc_root = reloc_root;
        }
 
-       err = btrfs_commit_transaction(trans, rc->extent_root);
+       err = btrfs_commit_transaction(trans);
        if (err)
                goto out_free;
 
@@ -4586,7 +4586,7 @@ int btrfs_recover_relocation(struct btrfs_root *root)
                err = PTR_ERR(trans);
                goto out_free;
        }
-       err = btrfs_commit_transaction(trans, rc->extent_root);
+       err = btrfs_commit_transaction(trans);
 out_free:
        kfree(rc);
 out:

diff --git a/fs/btrfs/root-tree.c b/fs/btrfs/root-tree.c
index 87728ff39622d37ac89716ac59d5f191574a13d4..4c6735491ee061cf7d6af58ded5064db2e4874cc 100644 (file)
--- a/fs/btrfs/root-tree.c
+++ b/fs/btrfs/root-tree.c
@@ -303,7 +303,7 @@ int btrfs_find_orphan_roots(struct btrfs_fs_info *fs_info)
                        }
                        err = btrfs_del_orphan_item(trans, tree_root,
                                                    root_key.objectid);
-                       btrfs_end_transaction(trans, tree_root);
+                       btrfs_end_transaction(trans);
                        if (err) {
                                btrfs_handle_fs_error(fs_info, err,
                                            "Failed to delete root orphan item");

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index 09fb2fb0848e35de492042ff5d1415b55b70f95b..0d63d994be105dc9c15ab134fc89c330b13f7313 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -839,7 +839,7 @@ static void scrub_fixup_nodatasum(struct btrfs_work *work)
 
 out:
        if (trans && !IS_ERR(trans))
-               btrfs_end_transaction(trans, fixup->root);
+               btrfs_end_transaction(trans);
        if (uncorrectable) {
                spin_lock(&sctx->stat_lock);
                ++sctx->stat.uncorrectable_errors;
@@ -3616,8 +3616,7 @@ int scrub_enumerate_chunks(struct scrub_ctx *sctx,
                                if (IS_ERR(trans))
                                        ret = PTR_ERR(trans);
                                else
-                                       ret = btrfs_commit_transaction(trans,
-                                                                      root);
+                                       ret = btrfs_commit_transaction(trans);
                                if (ret) {
                                        scrub_pause_off(fs_info);
                                        btrfs_put_block_group(cache);
@@ -4202,7 +4201,7 @@ static void copy_nocow_pages_worker(struct btrfs_work *work)
                goto out;
        }
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        trans = NULL;
        while (!list_empty(&nocow_ctx->inodes)) {
                struct scrub_nocow_inode *entry;
@@ -4230,7 +4229,7 @@ static void copy_nocow_pages_worker(struct btrfs_work *work)
                kfree(entry);
        }
        if (trans && !IS_ERR(trans))
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
        if (not_written)
                btrfs_dev_replace_stats_inc(&fs_info->dev_replace.
                                            num_uncorrectable_read_errors);

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 1df3b87983233a0db153b3fb204b567a7273185d..d145ce804620219820b276e627b034c35f18550f 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -6112,7 +6112,7 @@ static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
                        goto commit_trans;
 
        if (trans)
-               return btrfs_end_transaction(trans, sctx->send_root);
+               return btrfs_end_transaction(trans);
 
        return 0;
 
@@ -6125,7 +6125,7 @@ static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
                goto again;
        }
 
-       return btrfs_commit_transaction(trans, sctx->send_root);
+       return btrfs_commit_transaction(trans);
 }
 
 static void btrfs_root_dec_send_in_progress(struct btrfs_root* root)

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 3021b0f32e53ab14aa82a8e9f691f32b92f05f51..4a151930f201b3037d5714492847ff66a29fc0c4 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1206,7 +1206,7 @@ int btrfs_sync_fs(struct super_block *sb, int wait)
                if (IS_ERR(trans))
                        return PTR_ERR(trans);
        }
-       return btrfs_commit_transaction(trans, root);
+       return btrfs_commit_transaction(trans);
 }
 
 static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
@@ -2251,7 +2251,7 @@ static int btrfs_freeze(struct super_block *sb)
                        return 0;
                return PTR_ERR(trans);
        }
-       return btrfs_commit_transaction(trans, root);
+       return btrfs_commit_transaction(trans);
 }
 
 static int btrfs_unfreeze(struct super_block *sb)

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index a23fedde1ba1fff72fd74e86f10fedc1024f93e8..0e0508f488b273929a783ec1048d57cb4b9d1761 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -577,7 +577,7 @@ start_transaction(struct btrfs_root *root, unsigned int num_items,
        if (cur_trans->state >= TRANS_STATE_BLOCKED &&
            may_wait_transaction(fs_info, type)) {
                current->journal_info = h;
-               btrfs_commit_transaction(h, root);
+               btrfs_commit_transaction(h);
                goto again;
        }
 
@@ -637,7 +637,7 @@ struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
        ret = btrfs_cond_migrate_bytes(fs_info, &fs_info->trans_block_rsv,
                                       num_bytes, min_factor);
        if (ret) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ERR_PTR(ret);
        }
 
@@ -795,11 +795,10 @@ static int should_end_transaction(struct btrfs_trans_handle *trans)
        return !!btrfs_block_rsv_check(&fs_info->global_block_rsv, 5);
 }
 
-int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
-                                struct btrfs_root *root)
+int btrfs_should_end_transaction(struct btrfs_trans_handle *trans)
 {
-       struct btrfs_fs_info *fs_info = root->fs_info;
        struct btrfs_transaction *cur_trans = trans->transaction;
+       struct btrfs_fs_info *fs_info = trans->fs_info;
        int updates;
        int err;
 
@@ -820,10 +819,10 @@ int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
 }
 
 static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
-                         struct btrfs_root *root, int throttle)
+                                  int throttle)
 {
+       struct btrfs_fs_info *info = trans->fs_info;
        struct btrfs_transaction *cur_trans = trans->transaction;
-       struct btrfs_fs_info *info = root->fs_info;
        u64 transid = trans->transid;
        unsigned long cur = trans->delayed_ref_updates;
        int lock = (trans->type != TRANS_JOIN_NOLOCK);
@@ -876,7 +875,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
 
        if (lock && ACCESS_ONCE(cur_trans->state) == TRANS_STATE_BLOCKED) {
                if (throttle)
-                       return btrfs_commit_transaction(trans, root);
+                       return btrfs_commit_transaction(trans);
                else
                        wake_up_process(info->transaction_kthread);
        }
@@ -918,16 +917,14 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
        return err;
 }
 
-int btrfs_end_transaction(struct btrfs_trans_handle *trans,
-                         struct btrfs_root *root)
+int btrfs_end_transaction(struct btrfs_trans_handle *trans)
 {
-       return __btrfs_end_transaction(trans, root, 0);
+       return __btrfs_end_transaction(trans, 0);
 }
 
-int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
-                                  struct btrfs_root *root)
+int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans)
 {
-       return __btrfs_end_transaction(trans, root, 1);
+       return __btrfs_end_transaction(trans, 1);
 }
 
 /*
@@ -1319,7 +1316,7 @@ int btrfs_defrag_root(struct btrfs_root *root)
 
                ret = btrfs_defrag_leaves(trans, root);
 
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                btrfs_btree_balance_dirty(info);
                cond_resched();
 
@@ -1794,7 +1791,6 @@ static void wait_current_trans_commit_start_and_unblock(
  */
 struct btrfs_async_commit {
        struct btrfs_trans_handle *newtrans;
-       struct btrfs_root *root;
        struct work_struct work;
 };
 
@@ -1808,19 +1804,18 @@ static void do_async_commit(struct work_struct *work)
         * Tell lockdep about it.
         */
        if (ac->newtrans->type & __TRANS_FREEZABLE)
-               __sb_writers_acquired(ac->root->fs_info->sb, SB_FREEZE_FS);
+               __sb_writers_acquired(ac->newtrans->fs_info->sb, SB_FREEZE_FS);
 
        current->journal_info = ac->newtrans;
 
-       btrfs_commit_transaction(ac->newtrans, ac->root);
+       btrfs_commit_transaction(ac->newtrans);
        kfree(ac);
 }
 
 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
-                                  struct btrfs_root *root,
                                   int wait_for_unblock)
 {
-       struct btrfs_fs_info *fs_info = root->fs_info;
+       struct btrfs_fs_info *fs_info = trans->fs_info;
        struct btrfs_async_commit *ac;
        struct btrfs_transaction *cur_trans;
 
@@ -1829,8 +1824,7 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
                return -ENOMEM;
 
        INIT_WORK(&ac->work, do_async_commit);
-       ac->root = root;
-       ac->newtrans = btrfs_join_transaction(root);
+       ac->newtrans = btrfs_join_transaction(trans->root);
        if (IS_ERR(ac->newtrans)) {
                int err = PTR_ERR(ac->newtrans);
                kfree(ac);
@@ -1841,7 +1835,7 @@ int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
        cur_trans = trans->transaction;
        atomic_inc(&cur_trans->use_count);
 
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 
        /*
         * Tell lockdep we've released the freeze rwsem, since the
@@ -1938,10 +1932,9 @@ btrfs_wait_pending_ordered(struct btrfs_transaction *cur_trans)
                   atomic_read(&cur_trans->pending_ordered) == 0);
 }
 
-int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
-                            struct btrfs_root *root)
+int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
 {
-       struct btrfs_fs_info *fs_info = root->fs_info;
+       struct btrfs_fs_info *fs_info = trans->fs_info;
        struct btrfs_transaction *cur_trans = trans->transaction;
        struct btrfs_transaction *prev_trans = NULL;
        int ret;
@@ -1949,7 +1942,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        /* Stop the commit early if ->aborted is set */
        if (unlikely(ACCESS_ONCE(cur_trans->aborted))) {
                ret = cur_trans->aborted;
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 
@@ -1958,7 +1951,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
         */
        ret = btrfs_run_delayed_refs(trans, fs_info, 0);
        if (ret) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 
@@ -1979,7 +1972,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
 
        ret = btrfs_run_delayed_refs(trans, fs_info, 0);
        if (ret) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 
@@ -2009,7 +2002,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
                        ret = btrfs_start_dirty_block_groups(trans, fs_info);
        }
        if (ret) {
-               btrfs_end_transaction(trans, root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 
@@ -2017,7 +2010,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        if (cur_trans->state >= TRANS_STATE_COMMIT_START) {
                spin_unlock(&fs_info->trans_lock);
                atomic_inc(&cur_trans->use_count);
-               ret = btrfs_end_transaction(trans, root);
+               ret = btrfs_end_transaction(trans);
 
                wait_for_commit(cur_trans);
 
@@ -2293,7 +2286,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        if (trans->type & __TRANS_FREEZABLE)
                sb_end_intwrite(fs_info->sb);
 
-       trace_btrfs_transaction_commit(root);
+       trace_btrfs_transaction_commit(trans->root);
 
        btrfs_scrub_continue(fs_info);
 
@@ -2321,7 +2314,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
        btrfs_warn(fs_info, "Skipping commit of aborted transaction.");
        if (current->journal_info == trans)
                current->journal_info = NULL;
-       cleanup_transaction(trans, root, ret);
+       cleanup_transaction(trans, trans->root, ret);
 
        return ret;
 }

diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index 1c43ed3aa1ac615a24580c378d1c8e1e4c9d98eb..5dfb5590fff654a077fd95704682293bfc948a8f 100644 (file)
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -123,11 +123,6 @@ struct btrfs_trans_handle {
        bool sync;
        bool dirty;
        unsigned int type;
-       /*
-        * this root is only needed to validate that the root passed to
-        * start_transaction is the same as the one passed to end_transaction.
-        * Subvolume quota depends on this
-        */
        struct btrfs_root *root;
        struct btrfs_fs_info *fs_info;
        struct seq_list delayed_ref_elem;
@@ -185,8 +180,7 @@ static inline void btrfs_clear_skip_qgroup(struct btrfs_trans_handle *trans)
        delayed_refs->qgroup_to_skip = 0;
 }
 
-int btrfs_end_transaction(struct btrfs_trans_handle *trans,
-                         struct btrfs_root *root);
+int btrfs_end_transaction(struct btrfs_trans_handle *trans);
 struct btrfs_trans_handle *btrfs_start_transaction(struct btrfs_root *root,
                                                   unsigned int num_items);
 struct btrfs_trans_handle *btrfs_start_transaction_fallback_global_rsv(
@@ -207,15 +201,11 @@ int btrfs_wait_for_commit(struct btrfs_fs_info *fs_info, u64 transid);
 void btrfs_add_dead_root(struct btrfs_root *root);
 int btrfs_defrag_root(struct btrfs_root *root);
 int btrfs_clean_one_deleted_snapshot(struct btrfs_root *root);
-int btrfs_commit_transaction(struct btrfs_trans_handle *trans,
-                            struct btrfs_root *root);
+int btrfs_commit_transaction(struct btrfs_trans_handle *trans);
 int btrfs_commit_transaction_async(struct btrfs_trans_handle *trans,
-                                  struct btrfs_root *root,
                                   int wait_for_unblock);
-int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans,
-                                  struct btrfs_root *root);
-int btrfs_should_end_transaction(struct btrfs_trans_handle *trans,
-                                struct btrfs_root *root);
+int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans);
+int btrfs_should_end_transaction(struct btrfs_trans_handle *trans);
 void btrfs_throttle(struct btrfs_fs_info *fs_info);
 int btrfs_record_root_in_trans(struct btrfs_trans_handle *trans,
                                struct btrfs_root *root);

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 61c7f6f3034e536105e4d7a81812d4b1195149a9..f7324189413c842b269c856681e017e62b04cc1b 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -5695,7 +5695,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
        btrfs_free_path(path);
 
        /* step 4: commit the transaction, which also unpins the blocks */
-       ret = btrfs_commit_transaction(trans, fs_info->tree_root);
+       ret = btrfs_commit_transaction(trans);
        if (ret)
                return ret;
 
@@ -5707,7 +5707,7 @@ int btrfs_recover_log_trees(struct btrfs_root *log_root_tree)
        return 0;
 error:
        if (wc.trans)
-               btrfs_end_transaction(wc.trans, fs_info->tree_root);
+               btrfs_end_transaction(wc.trans);
        btrfs_free_path(path);
        return ret;
 }

diff --git a/fs/btrfs/uuid-tree.c b/fs/btrfs/uuid-tree.c
index 0a211d4ce8e06a83ed9d31181fa733d174bcfca5..161342b73ce50256bd2cba63b0d1c5ece503f599 100644 (file)
--- a/fs/btrfs/uuid-tree.c
+++ b/fs/btrfs/uuid-tree.c
@@ -252,7 +252,7 @@ static int btrfs_uuid_iter_rem(struct btrfs_root *uuid_root, u8 *uuid, u8 type,
        }
 
        ret = btrfs_uuid_tree_rem(trans, uuid_root->fs_info, uuid, type, subid);
-       btrfs_end_transaction(trans, uuid_root);
+       btrfs_end_transaction(trans);
 
 out:
        return ret;

diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
index e7127bd6148534749665eafc15eec3164bbadfe1..cf38386049874a55a9a6ad358450685e73fb3a68 100644 (file)
--- a/fs/btrfs/volumes.c
+++ b/fs/btrfs/volumes.c
@@ -1773,7 +1773,7 @@ static int btrfs_rm_dev_item(struct btrfs_fs_info *fs_info,
                goto out;
 out:
        btrfs_free_path(path);
-       btrfs_commit_transaction(trans, root);
+       btrfs_commit_transaction(trans);
        return ret;
 }
 
@@ -2475,7 +2475,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *device_path)
 
        fs_info->num_tolerated_disk_barrier_failures =
                btrfs_calc_num_tolerated_disk_barrier_failures(fs_info);
-       ret = btrfs_commit_transaction(trans, root);
+       ret = btrfs_commit_transaction(trans);
 
        if (seeding_dev) {
                mutex_unlock(&uuid_mutex);
@@ -2494,7 +2494,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *device_path)
                                return 0;
                        return PTR_ERR(trans);
                }
-               ret = btrfs_commit_transaction(trans, root);
+               ret = btrfs_commit_transaction(trans);
        }
 
        /* Update ctime/mtime for libblkid */
@@ -2502,7 +2502,7 @@ int btrfs_init_new_device(struct btrfs_fs_info *fs_info, char *device_path)
        return ret;
 
 error_trans:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        rcu_string_free(device->name);
        btrfs_sysfs_rm_device_link(fs_info->fs_devices, device);
        kfree(device);
@@ -2899,7 +2899,6 @@ int btrfs_remove_chunk(struct btrfs_trans_handle *trans,
 static int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)
 {
        struct btrfs_root *root = fs_info->chunk_root;
-       struct btrfs_root *extent_root = fs_info->extent_root;
        struct btrfs_trans_handle *trans;
        int ret;
 
@@ -2941,7 +2940,7 @@ static int btrfs_relocate_chunk(struct btrfs_fs_info *fs_info, u64 chunk_offset)
         * chunk tree entries
         */
        ret = btrfs_remove_chunk(trans, fs_info, chunk_offset);
-       btrfs_end_transaction(trans, extent_root);
+       btrfs_end_transaction(trans);
        return ret;
 }
 
@@ -3067,7 +3066,7 @@ static int insert_balance_item(struct btrfs_fs_info *fs_info,
        btrfs_mark_buffer_dirty(leaf);
 out:
        btrfs_free_path(path);
-       err = btrfs_commit_transaction(trans, root);
+       err = btrfs_commit_transaction(trans);
        if (err && !ret)
                ret = err;
        return ret;
@@ -3106,7 +3105,7 @@ static int del_balance_item(struct btrfs_fs_info *fs_info)
        ret = btrfs_del_item(trans, root, path);
 out:
        btrfs_free_path(path);
-       err = btrfs_commit_transaction(trans, root);
+       err = btrfs_commit_transaction(trans);
        if (err && !ret)
                ret = err;
        return ret;
@@ -3513,7 +3512,7 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)
 
                ret = btrfs_grow_device(trans, device, old_size);
                if (ret) {
-                       btrfs_end_transaction(trans, dev_root);
+                       btrfs_end_transaction(trans);
                        /* btrfs_grow_device never returns ret > 0 */
                        WARN_ON(ret > 0);
                        btrfs_info_in_rcu(fs_info,
@@ -3523,7 +3522,7 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)
                        goto error;
                }
 
-               btrfs_end_transaction(trans, dev_root);
+               btrfs_end_transaction(trans);
        }
 
        /* step two, relocate all the chunks */
@@ -3653,7 +3652,7 @@ static int __btrfs_balance(struct btrfs_fs_info *fs_info)
 
                        ret = btrfs_force_chunk_alloc(trans, fs_info,
                                                      BTRFS_BLOCK_GROUP_DATA);
-                       btrfs_end_transaction(trans, chunk_root);
+                       btrfs_end_transaction(trans);
                        if (ret < 0) {
                                mutex_unlock(&fs_info->delete_unused_bgs_mutex);
                                goto error;
@@ -4182,7 +4181,7 @@ static int btrfs_uuid_scan_kthread(void *data)
 
 skip:
                if (trans) {
-                       ret = btrfs_end_transaction(trans, fs_info->uuid_root);
+                       ret = btrfs_end_transaction(trans);
                        trans = NULL;
                        if (ret)
                                break;
@@ -4207,7 +4206,7 @@ static int btrfs_uuid_scan_kthread(void *data)
 out:
        btrfs_free_path(path);
        if (trans && !IS_ERR(trans))
-               btrfs_end_transaction(trans, fs_info->uuid_root);
+               btrfs_end_transaction(trans);
        if (ret)
                btrfs_warn(fs_info, "btrfs_uuid_scan_kthread failed %d", ret);
        else
@@ -4301,13 +4300,13 @@ int btrfs_create_uuid_tree(struct btrfs_fs_info *fs_info)
        if (IS_ERR(uuid_root)) {
                ret = PTR_ERR(uuid_root);
                btrfs_abort_transaction(trans, ret);
-               btrfs_end_transaction(trans, tree_root);
+               btrfs_end_transaction(trans);
                return ret;
        }
 
        fs_info->uuid_root = uuid_root;
 
-       ret = btrfs_commit_transaction(trans, tree_root);
+       ret = btrfs_commit_transaction(trans);
        if (ret)
                return ret;
 
@@ -4479,7 +4478,7 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
                        checked_pending_chunks = true;
                        failed = 0;
                        retried = false;
-                       ret = btrfs_commit_transaction(trans, root);
+                       ret = btrfs_commit_transaction(trans);
                        if (ret)
                                goto done;
                        goto again;
@@ -4497,7 +4496,7 @@ int btrfs_shrink_device(struct btrfs_device *device, u64 new_size)
 
        /* Now btrfs_update_device() will change the on-disk size. */
        ret = btrfs_update_device(trans, device);
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
 done:
        btrfs_free_path(path);
        if (ret) {

diff --git a/fs/btrfs/xattr.c b/fs/btrfs/xattr.c
index 7dfd2f06eb55001be52a406964e32fcd38d092fd..9621c7f2503ed9b2e13961bc592d4a78e39feed2 100644 (file)
--- a/fs/btrfs/xattr.c
+++ b/fs/btrfs/xattr.c
@@ -259,7 +259,7 @@ int __btrfs_setxattr(struct btrfs_trans_handle *trans,
        ret = btrfs_update_inode(trans, root, inode);
        BUG_ON(ret);
 out:
-       btrfs_end_transaction(trans, root);
+       btrfs_end_transaction(trans);
        return ret;
 }