btrfs: add and use helper to commit the current transaction

We have several places that attach to the current transaction with
btrfs_attach_transaction_barrier() and then commit the transaction if
there is one. Add a helper and use it to deduplicate this pattern.

Reviewed-by: Josef Bacik <josef@toxicpanda.com>
Reviewed-by: Qu Wenruo <wqu@suse.com>
Signed-off-by: Filipe Manana <fdmanana@suse.com>
Reviewed-by: David Sterba <dsterba@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index e1186b3197056fa8c3a78f42411002291c75cea2..6b19c2de2c0faf54e281f0529f18ea970e4d27c0 100644 (file)
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -4144,9 +4144,6 @@ void btrfs_drop_and_free_fs_root(struct btrfs_fs_info *fs_info,
 
 int btrfs_commit_super(struct btrfs_fs_info *fs_info)
 {
-       struct btrfs_root *root = fs_info->tree_root;
-       struct btrfs_trans_handle *trans;
-
        mutex_lock(&fs_info->cleaner_mutex);
        btrfs_run_delayed_iputs(fs_info);
        mutex_unlock(&fs_info->cleaner_mutex);
@@ -4156,14 +4153,7 @@ int btrfs_commit_super(struct btrfs_fs_info *fs_info)
        down_write(&fs_info->cleanup_work_sem);
        up_write(&fs_info->cleanup_work_sem);
 
-       trans = btrfs_attach_transaction_barrier(root);
-       if (IS_ERR(trans)) {
-               int ret = PTR_ERR(trans);
-
-               return (ret == -ENOENT) ? 0 : ret;
-       }
-
-       return btrfs_commit_transaction(trans);
+       return btrfs_commit_current_transaction(fs_info->tree_root);
 }
 
 static void warn_about_uncommitted_trans(struct btrfs_fs_info *fs_info)

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 63fdbbf61f15294d8a53ed148578673bc217c14f..4d0d0a041fafa59e4cb705d5816d73b93dda985c 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -1334,7 +1334,6 @@ out:
  */
 static int flush_reservations(struct btrfs_fs_info *fs_info)
 {
-       struct btrfs_trans_handle *trans;
        int ret;
 
        ret = btrfs_start_delalloc_roots(fs_info, LONG_MAX, false);
@@ -1342,13 +1341,7 @@ static int flush_reservations(struct btrfs_fs_info *fs_info)
                return ret;
        btrfs_wait_ordered_roots(fs_info, U64_MAX, NULL);
 
-       trans = btrfs_attach_transaction_barrier(fs_info->tree_root);
-       if (IS_ERR(trans)) {
-               ret = PTR_ERR(trans);
-               return (ret == -ENOENT) ? 0 : ret;
-       }
-
-       return btrfs_commit_transaction(trans);
+       return btrfs_commit_current_transaction(fs_info->tree_root);
 }
 
 int btrfs_quota_disable(struct btrfs_fs_info *fs_info)
@@ -4027,7 +4020,6 @@ int
 btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
 {
        int ret = 0;
-       struct btrfs_trans_handle *trans;
 
        ret = qgroup_rescan_init(fs_info, 0, 1);
        if (ret)
@@ -4044,16 +4036,10 @@ btrfs_qgroup_rescan(struct btrfs_fs_info *fs_info)
         * going to clear all tracking information for a clean start.
         */
 
-       trans = btrfs_attach_transaction_barrier(fs_info->fs_root);
-       if (IS_ERR(trans) && trans != ERR_PTR(-ENOENT)) {
+       ret = btrfs_commit_current_transaction(fs_info->fs_root);
+       if (ret) {
                fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
-               return PTR_ERR(trans);
-       } else if (trans != ERR_PTR(-ENOENT)) {
-               ret = btrfs_commit_transaction(trans);
-               if (ret) {
-                       fs_info->qgroup_flags &= ~BTRFS_QGROUP_STATUS_FLAG_RESCAN;
-                       return ret;
-               }
+               return ret;
        }
 
        qgroup_rescan_zero_tracking(fs_info);
@@ -4189,7 +4175,6 @@ static int qgroup_unreserve_range(struct btrfs_inode *inode,
  */
 static int try_flush_qgroup(struct btrfs_root *root)
 {
-       struct btrfs_trans_handle *trans;
        int ret;
 
        /* Can't hold an open transaction or we run the risk of deadlocking. */
@@ -4212,15 +4197,7 @@ static int try_flush_qgroup(struct btrfs_root *root)
                goto out;
        btrfs_wait_ordered_extents(root, U64_MAX, NULL);
 
-       trans = btrfs_attach_transaction_barrier(root);
-       if (IS_ERR(trans)) {
-               ret = PTR_ERR(trans);
-               if (ret == -ENOENT)
-                       ret = 0;
-               goto out;
-       }
-
-       ret = btrfs_commit_transaction(trans);
+       ret = btrfs_commit_current_transaction(root);
 out:
        clear_bit(BTRFS_ROOT_QGROUP_FLUSHING, &root->state);
        wake_up(&root->qgroup_flush_wait);

diff --git a/fs/btrfs/scrub.c b/fs/btrfs/scrub.c
index fe259e6a635397ca1820138bcb091097de992856..4677a4f55b6aee2a8c5b728babc57c24015ffc4f 100644 (file)
--- a/fs/btrfs/scrub.c
+++ b/fs/btrfs/scrub.c
@@ -2441,7 +2441,6 @@ static int finish_extent_writes_for_zoned(struct btrfs_root *root,
                                          struct btrfs_block_group *cache)
 {
        struct btrfs_fs_info *fs_info = cache->fs_info;
-       struct btrfs_trans_handle *trans;
 
        if (!btrfs_is_zoned(fs_info))
                return 0;
@@ -2450,14 +2449,7 @@ static int finish_extent_writes_for_zoned(struct btrfs_root *root,
        btrfs_wait_nocow_writers(cache);
        btrfs_wait_ordered_roots(fs_info, U64_MAX, cache);
 
-       trans = btrfs_attach_transaction_barrier(root);
-       if (IS_ERR(trans)) {
-               int ret = PTR_ERR(trans);
-
-               return (ret == -ENOENT) ? 0 : ret;
-       }
-
-       return btrfs_commit_transaction(trans);
+       return btrfs_commit_current_transaction(root);
 }
 
 static noinline_for_stack

diff --git a/fs/btrfs/send.c b/fs/btrfs/send.c
index 289e5e6a6c562e5d22012df72da3740dcc39ecb0..7a82132500a84659cdb67e97b84cc8b1e9ec4997 100644 (file)
--- a/fs/btrfs/send.c
+++ b/fs/btrfs/send.c
@@ -7998,7 +7998,6 @@ out:
  */
 static int ensure_commit_roots_uptodate(struct send_ctx *sctx)
 {
-       struct btrfs_trans_handle *trans;
        struct btrfs_root *root = sctx->parent_root;
 
        if (root && root->node != root->commit_root)
@@ -8018,14 +8017,7 @@ commit_trans:
         * an unnecessary update of the root's item in the root tree when
         * committing the transaction if that root wasn't changed before.
         */
-       trans = btrfs_attach_transaction_barrier(root);
-       if (IS_ERR(trans)) {
-               int ret = PTR_ERR(trans);
-
-               return (ret == -ENOENT) ? 0 : ret;
-       }
-
-       return btrfs_commit_transaction(trans);
+       return btrfs_commit_current_transaction(root);
 }
 
 /*

diff --git a/fs/btrfs/space-info.c b/fs/btrfs/space-info.c
index ef68a478ad639a0f2bc2650543038d144b4d5f3d..85ff44a742239199f4124a6b3c8dde0152c8426a 100644 (file)
--- a/fs/btrfs/space-info.c
+++ b/fs/btrfs/space-info.c
@@ -823,14 +823,7 @@ static void flush_space(struct btrfs_fs_info *fs_info,
                 * because that does not wait for a transaction to fully commit
                 * (only for it to be unblocked, state TRANS_STATE_UNBLOCKED).
                 */
-               trans = btrfs_attach_transaction_barrier(root);
-               if (IS_ERR(trans)) {
-                       ret = PTR_ERR(trans);
-                       if (ret == -ENOENT)
-                               ret = 0;
-                       break;
-               }
-               ret = btrfs_commit_transaction(trans);
+               ret = btrfs_commit_current_transaction(root);
                break;
        default:
                ret = -ENOSPC;

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 117a355dbd7ae83279c398fa8bced2cd354bd0d0..21d986e075008339a6a46cc6b71e0b3bff860a5e 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -2257,9 +2257,7 @@ out:
 
 static int btrfs_freeze(struct super_block *sb)
 {
-       struct btrfs_trans_handle *trans;
        struct btrfs_fs_info *fs_info = btrfs_sb(sb);
-       struct btrfs_root *root = fs_info->tree_root;
 
        set_bit(BTRFS_FS_FROZEN, &fs_info->flags);
        /*
@@ -2268,14 +2266,7 @@ static int btrfs_freeze(struct super_block *sb)
         * we want to avoid on a frozen filesystem), or do the commit
         * ourselves.
         */
-       trans = btrfs_attach_transaction_barrier(root);
-       if (IS_ERR(trans)) {
-               /* no transaction, don't bother */
-               if (PTR_ERR(trans) == -ENOENT)
-                       return 0;
-               return PTR_ERR(trans);
-       }
-       return btrfs_commit_transaction(trans);
+       return btrfs_commit_current_transaction(fs_info->tree_root);
 }
 
 static int check_dev_super(struct btrfs_device *dev)

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 639755f025b4c675b6960a628823f75d72b349cd..9590a1899b9d99139d79022a5fc8b98678d68f5d 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1989,6 +1989,25 @@ void btrfs_commit_transaction_async(struct btrfs_trans_handle *trans)
        btrfs_put_transaction(cur_trans);
 }
 
+/*
+ * If there is a running transaction commit it or if it's already committing,
+ * wait for its commit to complete. Does not start and commit a new transaction
+ * if there isn't any running.
+ */
+int btrfs_commit_current_transaction(struct btrfs_root *root)
+{
+       struct btrfs_trans_handle *trans;
+
+       trans = btrfs_attach_transaction_barrier(root);
+       if (IS_ERR(trans)) {
+               int ret = PTR_ERR(trans);
+
+               return (ret == -ENOENT) ? 0 : ret;
+       }
+
+       return btrfs_commit_transaction(trans);
+}
+
 static void cleanup_transaction(struct btrfs_trans_handle *trans, int err)
 {
        struct btrfs_fs_info *fs_info = trans->fs_info;

diff --git a/fs/btrfs/transaction.h b/fs/btrfs/transaction.h
index 90b987941dd12e370b077a447820e1d74f2c972d..81da655b5ee781f9d98f7997aa67b6d0729bff56 100644 (file)
--- a/fs/btrfs/transaction.h
+++ b/fs/btrfs/transaction.h
@@ -268,6 +268,7 @@ void btrfs_maybe_wake_unfinished_drop(struct btrfs_fs_info *fs_info);
 int btrfs_clean_one_deleted_snapshot(struct btrfs_fs_info *fs_info);
 int btrfs_commit_transaction(struct btrfs_trans_handle *trans);
 void btrfs_commit_transaction_async(struct btrfs_trans_handle *trans);
+int btrfs_commit_current_transaction(struct btrfs_root *root);
 int btrfs_end_transaction_throttle(struct btrfs_trans_handle *trans);
 bool btrfs_should_end_transaction(struct btrfs_trans_handle *trans);
 void btrfs_throttle(struct btrfs_fs_info *fs_info);