btrfs: add extra warning when qgroup is marked inconsistent

Unlike qgroup rescan, which always shows whether it cleared the
inconsistent flag, we do not have a proper way to show if qgroup is
marked inconsistent.

This was not a big deal before as there aren't that many locations that
can mark qgroup inconsistent.

But with the introduction of drop_subtree_threshold, qgroup can be
marked inconsistent very frequently, especially when dropping
subvolumes.

Although most user space tools relying on qgroup should do their own
checks and queue a rescan if needed, we have no idea when qgroup is
marked inconsistent, and this would be much harder to debug.

So this patch will add an extra warning (btrfs_warn_rl()) when the
qgroup flag is flipped into inconsistent for the first time.
And add extra reason why qgroup flips inconsistent.

This means we can move the error message immediately before
qgroup_inconsistent_warning() into that function.

For call sites without an obvious reason, or is a shared error handling,
output the function that failed and the error code instead.

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

diff --git a/fs/btrfs/qgroup.c b/fs/btrfs/qgroup.c
index a1afc549c404bcf5e07414506cbf296cafe33548..7791000dcefcb74639569dfaf0920f5bfb7bac69 100644 (file)
--- a/fs/btrfs/qgroup.c
+++ b/fs/btrfs/qgroup.c
@@ -346,13 +346,27 @@ int btrfs_verify_qgroup_counts(const struct btrfs_fs_info *fs_info, u64 qgroupid
 }
 #endif
 
-static void qgroup_mark_inconsistent(struct btrfs_fs_info *fs_info)
+__printf(2, 3)
+static void qgroup_mark_inconsistent(struct btrfs_fs_info *fs_info, const char *fmt, ...)
 {
+       const u64 old_flags = fs_info->qgroup_flags;
+
        if (btrfs_qgroup_mode(fs_info) == BTRFS_QGROUP_MODE_SIMPLE)
                return;
        fs_info->qgroup_flags |= (BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT |
                                  BTRFS_QGROUP_RUNTIME_FLAG_CANCEL_RESCAN |
                                  BTRFS_QGROUP_RUNTIME_FLAG_NO_ACCOUNTING);
+       if (!(old_flags & BTRFS_QGROUP_STATUS_FLAG_INCONSISTENT)) {
+               struct va_format vaf;
+               va_list args;
+
+               va_start(args, fmt);
+               vaf.fmt = fmt;
+               vaf.va = &args;
+
+               btrfs_warn_rl(fs_info, "qgroup marked inconsistent, %pV", &vaf);
+               va_end(args);
+       }
 }
 
 static void qgroup_read_enable_gen(struct btrfs_fs_info *fs_info,
@@ -431,13 +445,10 @@ int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
                                goto out;
                        }
                        fs_info->qgroup_flags = btrfs_qgroup_status_flags(l, ptr);
-                       if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE) {
+                       if (fs_info->qgroup_flags & BTRFS_QGROUP_STATUS_FLAG_SIMPLE_MODE)
                                qgroup_read_enable_gen(fs_info, l, slot, ptr);
-                       } else if (btrfs_qgroup_status_generation(l, ptr) != fs_info->generation) {
-                               qgroup_mark_inconsistent(fs_info);
-                               btrfs_err(fs_info,
-                                       "qgroup generation mismatch, marked as inconsistent");
-                       }
+                       else if (btrfs_qgroup_status_generation(l, ptr) != fs_info->generation)
+                               qgroup_mark_inconsistent(fs_info, "qgroup generation mismatch");
                        rescan_progress = btrfs_qgroup_status_rescan(l, ptr);
                        goto next1;
                }
@@ -448,10 +459,8 @@ int btrfs_read_qgroup_config(struct btrfs_fs_info *fs_info)
 
                qgroup = find_qgroup_rb(fs_info, found_key.offset);
                if ((qgroup && found_key.type == BTRFS_QGROUP_INFO_KEY) ||
-                   (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY)) {
-                       btrfs_err(fs_info, "inconsistent qgroup config");
-                       qgroup_mark_inconsistent(fs_info);
-               }
+                   (!qgroup && found_key.type == BTRFS_QGROUP_LIMIT_KEY))
+                       qgroup_mark_inconsistent(fs_info, "inconsistent qgroup config");
                if (!qgroup) {
                        struct btrfs_qgroup *prealloc;
                        struct btrfs_root *tree_root = fs_info->tree_root;
@@ -1841,13 +1850,12 @@ int btrfs_remove_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid)
                if (qgroup->rfer || qgroup->excl ||
                    qgroup->rfer_cmpr || qgroup->excl_cmpr) {
                        DEBUG_WARN();
-                       btrfs_warn_rl(fs_info,
-"to be deleted qgroup %u/%llu has non-zero numbers, rfer %llu rfer_cmpr %llu excl %llu excl_cmpr %llu",
-                                     btrfs_qgroup_level(qgroup->qgroupid),
-                                     btrfs_qgroup_subvolid(qgroup->qgroupid),
-                                     qgroup->rfer, qgroup->rfer_cmpr,
-                                     qgroup->excl, qgroup->excl_cmpr);
-                       qgroup_mark_inconsistent(fs_info);
+                       qgroup_mark_inconsistent(fs_info,
+                               "to be deleted qgroup %u/%llu has non-zero numbers, rfer %llu rfer_cmpr %llu excl %llu excl_cmpr %llu",
+                               btrfs_qgroup_level(qgroup->qgroupid),
+                               btrfs_qgroup_subvolid(qgroup->qgroupid),
+                               qgroup->rfer, qgroup->rfer_cmpr,
+                               qgroup->excl, qgroup->excl_cmpr);
                }
        }
        del_qgroup_rb(fs_info, qgroupid);
@@ -1965,11 +1973,8 @@ int btrfs_limit_qgroup(struct btrfs_trans_handle *trans, u64 qgroupid,
        spin_unlock(&fs_info->qgroup_lock);
 
        ret = update_qgroup_limit_item(trans, qgroup);
-       if (ret) {
-               qgroup_mark_inconsistent(fs_info);
-               btrfs_info(fs_info, "unable to update quota limit for %llu",
-                      qgroupid);
-       }
+       if (ret)
+               qgroup_mark_inconsistent(fs_info, "qgroup item update error %d", ret);
 
 out:
        mutex_unlock(&fs_info->qgroup_ioctl_lock);
@@ -2024,7 +2029,7 @@ int btrfs_qgroup_trace_extent_nolock(struct btrfs_fs_info *fs_info,
        ret = __xa_store(&delayed_refs->dirty_extents, index, record, GFP_ATOMIC);
        xa_unlock(&delayed_refs->dirty_extents);
        if (xa_is_err(ret)) {
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info, "xarray insert error: %d", xa_err(ret));
                return xa_err(ret);
        }
 
@@ -2091,10 +2096,8 @@ int btrfs_qgroup_trace_extent_post(struct btrfs_trans_handle *trans,
 
        ret = btrfs_find_all_roots(&ctx, true);
        if (ret < 0) {
-               qgroup_mark_inconsistent(fs_info);
-               btrfs_warn(fs_info,
-"error accounting new delayed refs extent (err code: %d), quota inconsistent",
-                       ret);
+               qgroup_mark_inconsistent(fs_info,
+                               "error accounting new delayed refs extent: %d", ret);
                return 0;
        }
 
@@ -2586,7 +2589,7 @@ static int qgroup_trace_subtree_swap(struct btrfs_trans_handle *trans,
 out:
        btrfs_free_path(dst_path);
        if (ret < 0)
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info, "%s error: %d", __func__, ret);
        return ret;
 }
 
@@ -2630,7 +2633,7 @@ int btrfs_qgroup_trace_subtree(struct btrfs_trans_handle *trans,
         * mark qgroup inconsistent.
         */
        if (root_level >= drop_subptree_thres) {
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info, "subtree level reached threshold");
                return 0;
        }
 
@@ -3130,10 +3133,12 @@ int btrfs_run_qgroups(struct btrfs_trans_handle *trans)
                spin_unlock(&fs_info->qgroup_lock);
                ret = update_qgroup_info_item(trans, qgroup);
                if (ret)
-                       qgroup_mark_inconsistent(fs_info);
+                       qgroup_mark_inconsistent(fs_info,
+                                                "qgroup info item update error %d", ret);
                ret = update_qgroup_limit_item(trans, qgroup);
                if (ret)
-                       qgroup_mark_inconsistent(fs_info);
+                       qgroup_mark_inconsistent(fs_info,
+                                                "qgroup limit item update error %d", ret);
                spin_lock(&fs_info->qgroup_lock);
        }
        if (btrfs_qgroup_enabled(fs_info))
@@ -3144,7 +3149,8 @@ int btrfs_run_qgroups(struct btrfs_trans_handle *trans)
 
        ret = update_qgroup_status_item(trans);
        if (ret)
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info,
+                                        "qgroup status item update error %d", ret);
 
        return ret;
 }
@@ -3551,7 +3557,7 @@ out:
        if (!committing)
                mutex_unlock(&fs_info->qgroup_ioctl_lock);
        if (need_rescan)
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info, "qgroup inherit needs a rescan");
        if (qlist_prealloc) {
                for (int i = 0; i < inherit->num_qgroups; i++)
                        kfree(qlist_prealloc[i]);
@@ -4785,7 +4791,7 @@ out_unlock:
        spin_unlock(&blocks->lock);
 out:
        if (ret < 0)
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info, "%s error: %d", __func__, ret);
        return ret;
 }
 
@@ -4863,10 +4869,9 @@ free_out:
        free_extent_buffer(reloc_eb);
 out:
        if (ret < 0) {
-               btrfs_err_rl(fs_info,
-                            "failed to account subtree at bytenr %llu: %d",
-                            subvol_eb->start, ret);
-               qgroup_mark_inconsistent(fs_info);
+               qgroup_mark_inconsistent(fs_info,
+                               "failed to account subtree at bytenr %llu: %d",
+                               subvol_eb->start, ret);
        }
        return ret;
 }