Update bcachefs sources to e67d924a90 bcachefs: Introduce bch2_journal_keys_peek_...

[bcachefs-tools-debian] / libbcachefs / error.c

diff --git a/libbcachefs/error.c b/libbcachefs/error.c
index afffbfb3695449a6f1c1cb5b3687a8302af8b56d..8279a9ba76a5c5e91524512d31e966e566cb240e 100644 (file)
--- a/libbcachefs/error.c
+++ b/libbcachefs/error.c
@@ -1,20 +1,23 @@
+// SPDX-License-Identifier: GPL-2.0
 #include "bcachefs.h"
 #include "error.h"
 #include "io.h"
 #include "super.h"
 
+#define FSCK_ERR_RATELIMIT_NR  10
+
 bool bch2_inconsistent_error(struct bch_fs *c)
 {
        set_bit(BCH_FS_ERROR, &c->flags);
 
        switch (c->opts.errors) {
-       case BCH_ON_ERROR_CONTINUE:
+       case BCH_ON_ERROR_continue:
                return false;
-       case BCH_ON_ERROR_RO:
+       case BCH_ON_ERROR_ro:
                if (bch2_fs_emergency_read_only(c))
-                       bch_err(c, "emergency read only");
+                       bch_err(c, "inconsistency detected - emergency read only");
                return true;
-       case BCH_ON_ERROR_PANIC:
+       case BCH_ON_ERROR_panic:
                panic(bch2_fmt(c, "panic after error"));
                return true;
        default:
@@ -22,10 +25,17 @@ bool bch2_inconsistent_error(struct bch_fs *c)
        }
 }
 
+void bch2_topology_error(struct bch_fs *c)
+{
+       set_bit(BCH_FS_TOPOLOGY_ERROR, &c->flags);
+       if (test_bit(BCH_FS_INITIAL_GC_DONE, &c->flags))
+               bch2_inconsistent_error(c);
+}
+
 void bch2_fatal_error(struct bch_fs *c)
 {
        if (bch2_fs_emergency_read_only(c))
-               bch_err(c, "emergency read only");
+               bch_err(c, "fatal error - emergency read only");
 }
 
 void bch2_io_error_work(struct work_struct *work)
@@ -34,17 +44,17 @@ void bch2_io_error_work(struct work_struct *work)
        struct bch_fs *c = ca->fs;
        bool dev;
 
-       mutex_lock(&c->state_lock);
-       dev = bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_RO,
+       down_write(&c->state_lock);
+       dev = bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_ro,
                                    BCH_FORCE_IF_DEGRADED);
        if (dev
-           ? __bch2_dev_set_state(c, ca, BCH_MEMBER_STATE_RO,
+           ? __bch2_dev_set_state(c, ca, BCH_MEMBER_STATE_ro,
                                  BCH_FORCE_IF_DEGRADED)
            : bch2_fs_emergency_read_only(c))
                bch_err(ca,
                        "too many IO errors, setting %s RO",
                        dev ? "device" : "filesystem");
-       mutex_unlock(&c->state_lock);
+       up_write(&c->state_lock);
 }
 
 void bch2_io_error(struct bch_dev *ca)
@@ -61,7 +71,7 @@ void bch2_io_error(struct bch_dev *ca)
 enum fsck_err_ret bch2_fsck_err(struct bch_fs *c, unsigned flags,
                                const char *fmt, ...)
 {
-       struct fsck_err_state *s;
+       struct fsck_err_state *s = NULL;
        va_list args;
        bool fix = false, print = true, suppressing = false;
        char _buf[sizeof(s->buf)], *buf = _buf;
@@ -71,9 +81,13 @@ enum fsck_err_ret bch2_fsck_err(struct bch_fs *c, unsigned flags,
                vprintk(fmt, args);
                va_end(args);
 
-               return bch2_inconsistent_error(c)
-                       ? FSCK_ERR_EXIT
-                       : FSCK_ERR_FIX;
+               if (c->opts.errors == BCH_ON_ERROR_continue) {
+                       bch_err(c, "fixing");
+                       return FSCK_ERR_FIX;
+               } else {
+                       bch2_inconsistent_error(c);
+                       return FSCK_ERR_EXIT;
+               }
        }
 
        mutex_lock(&c->fsck_error_lock);
@@ -82,7 +96,7 @@ enum fsck_err_ret bch2_fsck_err(struct bch_fs *c, unsigned flags,
                if (s->fmt == fmt)
                        goto found;
 
-       s = kzalloc(sizeof(*s), GFP_KERNEL);
+       s = kzalloc(sizeof(*s), GFP_NOFS);
        if (!s) {
                if (!c->fsck_alloc_err)
                        bch_err(c, "kmalloc err, cannot ratelimit fsck errs");
@@ -96,8 +110,14 @@ enum fsck_err_ret bch2_fsck_err(struct bch_fs *c, unsigned flags,
 found:
        list_move(&s->list, &c->fsck_errors);
        s->nr++;
-       suppressing     = s->nr == 10;
-       print           = s->nr <= 10;
+       if (c->opts.ratelimit_errors &&
+           !(flags & FSCK_NO_RATELIMIT) &&
+           s->nr >= FSCK_ERR_RATELIMIT_NR) {
+               if (s->nr == FSCK_ERR_RATELIMIT_NR)
+                       suppressing = true;
+               else
+                       print = false;
+       }
        buf             = s->buf;
 print:
        va_start(args, fmt);
@@ -138,6 +158,7 @@ print:
                set_bit(BCH_FS_ERRORS_FIXED, &c->flags);
                return FSCK_ERR_FIX;
        } else {
+               set_bit(BCH_FS_ERRORS_NOT_FIXED, &c->flags);
                set_bit(BCH_FS_ERROR, &c->flags);
                return c->opts.fix_errors == FSCK_OPT_EXIT ||
                        !(flags & FSCK_CAN_IGNORE)
@@ -151,10 +172,9 @@ void bch2_flush_fsck_errs(struct bch_fs *c)
        struct fsck_err_state *s, *n;
 
        mutex_lock(&c->fsck_error_lock);
-       set_bit(BCH_FS_FSCK_DONE, &c->flags);
 
        list_for_each_entry_safe(s, n, &c->fsck_errors, list) {
-               if (s->nr > 10)
+               if (s->ratelimited)
                        bch_err(c, "Saw %llu errors like:\n    %s", s->nr, s->buf);
 
                list_del(&s->list);