Update bcachefs sources to 380885b0b8 bcachefs: Fix counting iterators for reflink...

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

diff --git a/libbcachefs/error.c b/libbcachefs/error.c
index 5b7316de1077453205fd9b9a7cf86a770bce5dac..304ff92500be917022bad5e70e6e4c2a1458d8d4 100644 (file)
--- a/libbcachefs/error.c
+++ b/libbcachefs/error.c
@@ -1,22 +1,27 @@
+// 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;
+               return false;
        case BCH_ON_ERROR_RO:
                if (bch2_fs_emergency_read_only(c))
                        bch_err(c, "emergency read only");
-               break;
+               return true;
        case BCH_ON_ERROR_PANIC:
                panic(bch2_fmt(c, "panic after error"));
-               break;
+               return true;
+       default:
+               BUG();
        }
 }
 
@@ -26,7 +31,7 @@ void bch2_fatal_error(struct bch_fs *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;
@@ -45,9 +50,9 @@ void bch2_nonfatal_io_error_work(struct work_struct *work)
        mutex_unlock(&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__
@@ -64,10 +69,17 @@ enum fsck_err_ret bch2_fsck_err(struct bch_fs *c, unsigned flags,
        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;
+               return bch2_inconsistent_error(c)
+                       ? FSCK_ERR_EXIT
+                       : FSCK_ERR_FIX;
+       }
+
+       mutex_lock(&c->fsck_error_lock);
 
        list_for_each_entry(s, &c->fsck_errors, list)
                if (s->fmt == fmt)
@@ -87,19 +99,21 @@ 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;
+       suppressing     = s->nr == FSCK_ERR_RATELIMIT_NR;
+       print           = s->nr <= FSCK_ERR_RATELIMIT_NR;
        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 +137,16 @@ 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_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 +154,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->nr > FSCK_ERR_RATELIMIT_NR)
                        bch_err(c, "Saw %llu errors like:\n    %s", s->nr, s->buf);
 
                list_del(&s->list);