Update bcachefs sources to ca3cfad39f fixup! bcachefs: Improve iter->should_be_locked

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

diff --git a/libbcachefs/error.c b/libbcachefs/error.c
index 5b7316de1077453205fd9b9a7cf86a770bce5dac..2cea694575e99a4df6c4af282c76cbc77230f06e 100644 (file)
--- a/libbcachefs/error.c
+++ b/libbcachefs/error.c
@@ -1,53 +1,65 @@
+// SPDX-License-Identifier: GPL-2.0
 #include "bcachefs.h"
 #include "error.h"
 #include "io.h"
 #include "super.h"
 
-void bch2_inconsistent_error(struct bch_fs *c)
+#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:
-               break;
-       case BCH_ON_ERROR_RO:
+       case BCH_ON_ERROR_continue:
+               return false;
+       case BCH_ON_ERROR_ro:
                if (bch2_fs_emergency_read_only(c))
                        bch_err(c, "emergency read only");
-               break;
-       case BCH_ON_ERROR_PANIC:
+               return true;
+       case BCH_ON_ERROR_panic:
                panic(bch2_fmt(c, "panic after error"));
-               break;
+               return true;
+       default:
+               BUG();
        }
 }
 
+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");
 }
 
-void bch2_nonfatal_io_error_work(struct work_struct *work)
+void bch2_io_error_work(struct work_struct *work)
 {
        struct bch_dev *ca = container_of(work, struct bch_dev, io_error_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_nonfatal_io_error(struct bch_dev *ca)
+void bch2_io_error(struct bch_dev *ca)
 {
-       queue_work(system_long_wq, &ca->io_error_work);
+       //queue_work(system_long_wq, &ca->io_error_work);
 }
 
 #ifdef __KERNEL__
@@ -59,21 +71,32 @@ void bch2_nonfatal_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;
 
-       mutex_lock(&c->fsck_error_lock);
+       if (test_bit(BCH_FS_FSCK_DONE, &c->flags)) {
+               va_start(args, fmt);
+               vprintk(fmt, args);
+               va_end(args);
 
-       if (test_bit(BCH_FS_FSCK_DONE, &c->flags))
-               goto print;
+               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);
 
        list_for_each_entry(s, &c->fsck_errors, list)
                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");
@@ -87,19 +110,27 @@ 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);
        vscnprintf(buf, sizeof(_buf), fmt, args);
        va_end(args);
 
-       if (flags & FSCK_CAN_FIX) {
-               if (c->opts.fix_errors == FSCK_ERR_ASK) {
+       if (c->opts.fix_errors == FSCK_OPT_EXIT) {
+               bch_err(c, "%s, exiting", buf);
+       } else if (flags & FSCK_CAN_FIX) {
+               if (c->opts.fix_errors == FSCK_OPT_ASK) {
                        printk(KERN_ERR "%s: fix?", buf);
                        fix = ask_yn();
-               } else if (c->opts.fix_errors == FSCK_ERR_YES ||
+               } else if (c->opts.fix_errors == FSCK_OPT_YES ||
                           (c->opts.nochanges &&
                            !(flags & FSCK_CAN_IGNORE))) {
                        if (print)
@@ -123,12 +154,17 @@ print:
 
        mutex_unlock(&c->fsck_error_lock);
 
-       if (fix)
-               set_bit(BCH_FS_FSCK_FIXED_ERRORS, &c->flags);
-
-       return fix                              ? FSCK_ERR_FIX
-               : flags & FSCK_CAN_IGNORE       ? FSCK_ERR_IGNORE
-                                               : FSCK_ERR_EXIT;
+       if (fix) {
+               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)
+                       ? FSCK_ERR_EXIT
+                       : FSCK_ERR_IGNORE;
+       }
 }
 
 void bch2_flush_fsck_errs(struct bch_fs *c)
@@ -136,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);