btrfs: qgroup: Cleanup btrfs_qgroup_prepare_account_extents function

Quite a lot of qgroup corruption happens due to wrong time of calling
btrfs_qgroup_prepare_account_extents().

Since the safest time is to call it just before
btrfs_qgroup_account_extents(), there is no need to separate these 2
functions.

Merging them will make code cleaner and less bug prone.

Signed-off-by: Qu Wenruo <quwenruo@cn.fujitsu.com>
[ changelog and comment adjustments ]
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index 34116f6cb5d5c5f71b987fb795a721fc6b9748de..fc226035921156cdcdd7e6a4aca232c14b873a4a 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -1406,38 +1406,6 @@ out:
        return ret;
 }
 
-int btrfs_qgroup_prepare_account_extents(struct btrfs_trans_handle *trans,
-                                        struct btrfs_fs_info *fs_info)
-{
-       struct btrfs_qgroup_extent_record *record;
-       struct btrfs_delayed_ref_root *delayed_refs;
-       struct rb_node *node;
-       u64 qgroup_to_skip;
-       int ret = 0;
-
-       delayed_refs = &trans->transaction->delayed_refs;
-       qgroup_to_skip = delayed_refs->qgroup_to_skip;
-
-       /*
-        * No need to do lock, since this function will only be called in
-        * btrfs_commit_transaction().
-        */
-       node = rb_first(&delayed_refs->dirty_extent_root);
-       while (node) {
-               record = rb_entry(node, struct btrfs_qgroup_extent_record,
-                                 node);
-               if (WARN_ON(!record->old_roots))
-                       ret = btrfs_find_all_roots(NULL, fs_info,
-                                       record->bytenr, 0, &record->old_roots);
-               if (ret < 0)
-                       break;
-               if (qgroup_to_skip)
-                       ulist_del(record->old_roots, qgroup_to_skip, 0);
-               node = rb_next(node);
-       }
-       return ret;
-}
-
 int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info *fs_info,
                                struct btrfs_delayed_ref_root *delayed_refs,
                                struct btrfs_qgroup_extent_record *record)
@@ -2056,6 +2024,19 @@ int btrfs_qgroup_account_extents(struct btrfs_trans_handle *trans,
                trace_btrfs_qgroup_account_extents(fs_info, record);
 
                if (!ret) {
+                       /*
+                        * Old roots should be searched when inserting qgroup
+                        * extent record
+                        */
+                       if (WARN_ON(!record->old_roots)) {
+                               /* Search commit root to find old_roots */
+                               ret = btrfs_find_all_roots(NULL, fs_info,
+                                               record->bytenr, 0,
+                                               &record->old_roots);
+                               if (ret < 0)
+                                       goto cleanup;
+                       }
+
                        /*
                         * Use SEQ_LAST as time_seq to do special search, which
                         * doesn't lock tree or delayed_refs and search current
@@ -2065,8 +2046,11 @@ int btrfs_qgroup_account_extents(struct btrfs_trans_handle *trans,
                                        record->bytenr, SEQ_LAST, &new_roots);
                        if (ret < 0)
                                goto cleanup;
-                       if (qgroup_to_skip)
+                       if (qgroup_to_skip) {
                                ulist_del(new_roots, qgroup_to_skip, 0);
+                               ulist_del(record->old_roots, qgroup_to_skip,
+                                         0);
+                       }
                        ret = btrfs_qgroup_account_extent(trans, fs_info,
                                        record->bytenr, record->num_bytes,
                                        record->old_roots, new_roots);

diff --git a/fs/btrfs/qgroup.h b/fs/btrfs/qgroup.h
index fe04d3f295c67f0b97b79095885878237260a274..d11125d6afb9bf8db8b3166bb5d347c65b1a349c 100644 (file)
--- a/fs/btrfs/qgroup.h
+++ b/fs/btrfs/qgroup.h
@@ -134,8 +134,7 @@ int btrfs_limit_qgroup(struct btrfs_trans_handle *trans,
 int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info);
 void btrfs_free_qgroup_config(struct btrfs_fs_info *fs_info);
 struct btrfs_delayed_extent_op;
-int btrfs_qgroup_prepare_account_extents(struct btrfs_trans_handle *trans,
-                                        struct btrfs_fs_info *fs_info);
+
 /*
  * Inform qgroup to trace one dirty extent, its info is recorded in @record.
  * So qgroup can account it at transaction committing time.

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index 97e33513b19586a2c332b9d13eaa6e13150c736c..309b73da756b8f07ede0f4d35afc388ba3800749 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -1374,9 +1374,6 @@ static int qgroup_account_snapshot(struct btrfs_trans_handle *trans,
        ret = commit_fs_roots(trans, fs_info);
        if (ret)
                goto out;
-       ret = btrfs_qgroup_prepare_account_extents(trans, fs_info);
-       if (ret < 0)
-               goto out;
        ret = btrfs_qgroup_account_extents(trans, fs_info);
        if (ret < 0)
                goto out;
@@ -2180,13 +2177,6 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)
                goto scrub_continue;
        }
 
-       ret = btrfs_qgroup_prepare_account_extents(trans, fs_info);
-       if (ret) {
-               mutex_unlock(&fs_info->tree_log_mutex);
-               mutex_unlock(&fs_info->reloc_mutex);
-               goto scrub_continue;
-       }
-
        /*
         * Since fs roots are all committed, we can get a quite accurate
         * new_roots. So let's do quota accounting.