bcachefs: Log a message when running an explicit recovery pass

Signed-off-by: Kent Overstreet <kent.overstreet@linux.dev>

diff --git a/fs/bcachefs/bcachefs.h b/fs/bcachefs/bcachefs.h
index e1f1e8e871a81259104a0e16c43fdba739995aa2..019d534b73257c4e0930828aedc537ebeed8c543 100644 (file)
--- a/fs/bcachefs/bcachefs.h
+++ b/fs/bcachefs/bcachefs.h
@@ -1139,22 +1139,6 @@ static inline bool bch2_dev_exists2(const struct bch_fs *c, unsigned dev)
        return dev < c->sb.nr_devices && c->devs[dev];
 }
 
-/*
- * For when we need to rewind recovery passes and run a pass we skipped:
- */
-static inline int bch2_run_explicit_recovery_pass(struct bch_fs *c,
-                                                 enum bch_recovery_pass pass)
-{
-       c->recovery_passes_explicit |= BIT_ULL(pass);
-
-       if (c->curr_recovery_pass >= pass) {
-               c->curr_recovery_pass = pass;
-               return -BCH_ERR_restart_recovery;
-       } else {
-               return 0;
-       }
-}
-
 #define BKEY_PADDED_ONSTACK(key, pad)                          \
        struct { struct bkey_i key; __u64 key ## _pad[pad]; }
 

diff --git a/fs/bcachefs/btree_io.c b/fs/bcachefs/btree_io.c
index 2339395e0bd2f123b0451032e34411058fab801c..224ed5216b0a5dffd5869a39327d2adc3f310072 100644 (file)
--- a/fs/bcachefs/btree_io.c
+++ b/fs/bcachefs/btree_io.c
@@ -17,6 +17,7 @@
 #include "io.h"
 #include "journal_reclaim.h"
 #include "journal_seq_blacklist.h"
+#include "recovery.h"
 #include "super-io.h"
 #include "trace.h"
 

diff --git a/fs/bcachefs/fsck.c b/fs/bcachefs/fsck.c
index 28dc8b4e3ed73d754d7d358e46b1b9fb39b3c13c..0b4ddf650a97d83a3fc25146dc730a33a8760f0a 100644 (file)
--- a/fs/bcachefs/fsck.c
+++ b/fs/bcachefs/fsck.c
@@ -11,6 +11,7 @@
 #include "fsck.h"
 #include "inode.h"
 #include "keylist.h"
+#include "recovery.h"
 #include "subvolume.h"
 #include "super.h"
 #include "xattr.h"

diff --git a/fs/bcachefs/recovery.c b/fs/bcachefs/recovery.c
index bcc1ee0b4ef231850132cbe881fd0c803a42bcf4..3fd7f966acd7745b918b7b638de1558c47ec8f2d 100644 (file)
--- a/fs/bcachefs/recovery.c
+++ b/fs/bcachefs/recovery.c
@@ -1120,7 +1120,7 @@ static int bch2_fs_upgrade_for_subvolumes(struct bch_fs *c)
        return ret;
 }
 
-static const char * const recovery_pass_names[] = {
+const char * const bch2_recovery_passes[] = {
 #define x(_fn, _when)  #_fn,
        BCH_RECOVERY_PASSES()
 #undef x
@@ -1143,7 +1143,7 @@ struct recovery_pass_fn {
        unsigned        when;
 };
 
-static struct recovery_pass_fn recovery_passes[] = {
+static struct recovery_pass_fn recovery_pass_fns[] = {
 #define x(_fn, _when)  { .fn = bch2_##_fn, .when = _when },
        BCH_RECOVERY_PASSES()
 #undef x
@@ -1205,7 +1205,7 @@ static void check_version_upgrade(struct bch_fs *c)
                                prt_str(&buf, "fsck required");
                        else {
                                prt_str(&buf, "running recovery passses: ");
-                               prt_bitflags(&buf, recovery_pass_names, recovery_passes);
+                               prt_bitflags(&buf, bch2_recovery_passes, recovery_passes);
                        }
 
                        c->recovery_passes_explicit |= recovery_passes;
@@ -1226,15 +1226,15 @@ u64 bch2_fsck_recovery_passes(void)
 {
        u64 ret = 0;
 
-       for (unsigned i = 0; i < ARRAY_SIZE(recovery_passes); i++)
-               if (recovery_passes[i].when & PASS_FSCK)
+       for (unsigned i = 0; i < ARRAY_SIZE(recovery_pass_fns); i++)
+               if (recovery_pass_fns[i].when & PASS_FSCK)
                        ret |= BIT_ULL(i);
        return ret;
 }
 
 static bool should_run_recovery_pass(struct bch_fs *c, enum bch_recovery_pass pass)
 {
-       struct recovery_pass_fn *p = recovery_passes + c->curr_recovery_pass;
+       struct recovery_pass_fn *p = recovery_pass_fns + c->curr_recovery_pass;
 
        if (c->opts.norecovery && pass > BCH_RECOVERY_PASS_snapshots_read)
                return false;
@@ -1256,11 +1256,11 @@ static int bch2_run_recovery_pass(struct bch_fs *c, enum bch_recovery_pass pass)
        c->curr_recovery_pass = pass;
 
        if (should_run_recovery_pass(c, pass)) {
-               struct recovery_pass_fn *p = recovery_passes + pass;
+               struct recovery_pass_fn *p = recovery_pass_fns + pass;
 
                if (!(p->when & PASS_SILENT))
                        printk(KERN_INFO bch2_log_msg(c, "%s..."),
-                              recovery_pass_names[pass]);
+                              bch2_recovery_passes[pass]);
                ret = p->fn(c);
                if (ret)
                        return ret;
@@ -1275,7 +1275,7 @@ static int bch2_run_recovery_passes(struct bch_fs *c)
 {
        int ret = 0;
 
-       while (c->curr_recovery_pass < ARRAY_SIZE(recovery_passes)) {
+       while (c->curr_recovery_pass < ARRAY_SIZE(recovery_pass_fns)) {
                ret = bch2_run_recovery_pass(c, c->curr_recovery_pass);
                if (bch2_err_matches(ret, BCH_ERR_restart_recovery))
                        continue;
@@ -1593,7 +1593,7 @@ int bch2_fs_initialize(struct bch_fs *c)
        }
        mutex_unlock(&c->sb_lock);
 
-       c->curr_recovery_pass = ARRAY_SIZE(recovery_passes);
+       c->curr_recovery_pass = ARRAY_SIZE(recovery_pass_fns);
        set_bit(BCH_FS_MAY_GO_RW, &c->flags);
        set_bit(BCH_FS_FSCK_DONE, &c->flags);
 

diff --git a/fs/bcachefs/recovery.h b/fs/bcachefs/recovery.h
index f8e796c0f8c86880f6f9b63017f4c0ef4f879ecc..26cd6a230ac0cc8b024d1ff49a40dd9ad6b2cf37 100644 (file)
--- a/fs/bcachefs/recovery.h
+++ b/fs/bcachefs/recovery.h
@@ -52,9 +52,32 @@ void bch2_btree_and_journal_iter_init_node_iter(struct btree_and_journal_iter *,
 void bch2_journal_keys_free(struct journal_keys *);
 void bch2_journal_entries_free(struct bch_fs *);
 
+extern const char * const bch2_recovery_passes[];
+
+/*
+ * For when we need to rewind recovery passes and run a pass we skipped:
+ */
+static inline int bch2_run_explicit_recovery_pass(struct bch_fs *c,
+                                                 enum bch_recovery_pass pass)
+{
+       bch_info(c, "running explicit recovery pass %s (%u), currently at %s (%u)",
+                bch2_recovery_passes[pass], pass,
+                bch2_recovery_passes[c->curr_recovery_pass], c->curr_recovery_pass);
+
+       c->recovery_passes_explicit |= BIT_ULL(pass);
+
+       if (c->curr_recovery_pass >= pass) {
+               c->curr_recovery_pass = pass;
+               return -BCH_ERR_restart_recovery;
+       } else {
+               return 0;
+       }
+}
+
 u64 bch2_fsck_recovery_passes(void);
 
 int bch2_fs_recovery(struct bch_fs *);
 int bch2_fs_initialize(struct bch_fs *);
 
 #endif /* _BCACHEFS_RECOVERY_H */
+