Update bcachefs sources to feaca6edbd24 mean and variance: Promote to lib/math

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

diff --git a/libbcachefs/error.c b/libbcachefs/error.c
index 685464b8cce365c75306eda899878d48de17771b..655e3ba9bfd2c09f221011ae16c38ba9f101e6ff 100644 (file)
--- a/libbcachefs/error.c
+++ b/libbcachefs/error.c
@@ -1,14 +1,13 @@
 // 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);
+       set_bit(BCH_FS_error, &c->flags);
 
        switch (c->opts.errors) {
        case BCH_ON_ERROR_continue:
@@ -27,11 +26,8 @@ bool bch2_inconsistent_error(struct bch_fs *c)
 
 void bch2_topology_error(struct bch_fs *c)
 {
-       if (!test_bit(BCH_FS_TOPOLOGY_REPAIR_DONE, &c->flags))
-               return;
-
-       set_bit(BCH_FS_TOPOLOGY_ERROR, &c->flags);
-       if (test_bit(BCH_FS_FSCK_DONE, &c->flags))
+       set_bit(BCH_FS_topology_error, &c->flags);
+       if (test_bit(BCH_FS_fsck_done, &c->flags))
                bch2_inconsistent_error(c);
 }
 
@@ -60,8 +56,9 @@ void bch2_io_error_work(struct work_struct *work)
        up_write(&c->state_lock);
 }
 
-void bch2_io_error(struct bch_dev *ca)
+void bch2_io_error(struct bch_dev *ca, enum bch_member_error_type type)
 {
+       atomic64_inc(&ca->errors[type]);
        //queue_work(system_long_wq, &ca->io_error_work);
 }
 
@@ -117,34 +114,37 @@ static struct fsck_err_state *fsck_err_get(struct bch_fs *c, const char *fmt)
 {
        struct fsck_err_state *s;
 
-       if (test_bit(BCH_FS_FSCK_DONE, &c->flags))
+       if (test_bit(BCH_FS_fsck_done, &c->flags))
                return NULL;
 
-       list_for_each_entry(s, &c->fsck_errors, list)
+       list_for_each_entry(s, &c->fsck_error_msgs, list)
                if (s->fmt == fmt) {
                        /*
                         * move it to the head of the list: repeated fsck errors
                         * are common
                         */
-                       list_move(&s->list, &c->fsck_errors);
+                       list_move(&s->list, &c->fsck_error_msgs);
                        return s;
                }
 
        s = kzalloc(sizeof(*s), GFP_NOFS);
        if (!s) {
-               if (!c->fsck_alloc_err)
+               if (!c->fsck_alloc_msgs_err)
                        bch_err(c, "kmalloc err, cannot ratelimit fsck errs");
-               c->fsck_alloc_err = true;
+               c->fsck_alloc_msgs_err = true;
                return NULL;
        }
 
        INIT_LIST_HEAD(&s->list);
        s->fmt = fmt;
-       list_add(&s->list, &c->fsck_errors);
+       list_add(&s->list, &c->fsck_error_msgs);
        return s;
 }
 
-int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
+int bch2_fsck_err(struct bch_fs *c,
+                 enum bch_fsck_flags flags,
+                 enum bch_sb_error_id err,
+                 const char *fmt, ...)
 {
        struct fsck_err_state *s = NULL;
        va_list args;
@@ -152,11 +152,13 @@ int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
        struct printbuf buf = PRINTBUF, *out = &buf;
        int ret = -BCH_ERR_fsck_ignore;
 
+       bch2_sb_error_count(c, err);
+
        va_start(args, fmt);
        prt_vprintf(out, fmt, args);
        va_end(args);
 
-       mutex_lock(&c->fsck_error_lock);
+       mutex_lock(&c->fsck_error_msgs_lock);
        s = fsck_err_get(c, fmt);
        if (s) {
                /*
@@ -166,7 +168,7 @@ int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
                 */
                if (s->last_msg && !strcmp(buf.buf, s->last_msg)) {
                        ret = s->ret;
-                       mutex_unlock(&c->fsck_error_lock);
+                       mutex_unlock(&c->fsck_error_msgs_lock);
                        printbuf_exit(&buf);
                        return ret;
                }
@@ -191,7 +193,7 @@ int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
                prt_printf(out, bch2_log_msg(c, ""));
 #endif
 
-       if (test_bit(BCH_FS_FSCK_DONE, &c->flags)) {
+       if (test_bit(BCH_FS_fsck_done, &c->flags)) {
                if (c->opts.errors != BCH_ON_ERROR_continue ||
                    !(flags & (FSCK_CAN_FIX|FSCK_CAN_IGNORE))) {
                        prt_str(out, ", shutting down");
@@ -251,7 +253,7 @@ int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
        if (print)
                bch2_print_string_as_lines(KERN_ERR, out->buf);
 
-       if (!test_bit(BCH_FS_FSCK_DONE, &c->flags) &&
+       if (!test_bit(BCH_FS_fsck_done, &c->flags) &&
            (ret != -BCH_ERR_fsck_fix &&
             ret != -BCH_ERR_fsck_ignore))
                bch_err(c, "Unable to continue, halting");
@@ -261,7 +263,7 @@ int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
        if (s)
                s->ret = ret;
 
-       mutex_unlock(&c->fsck_error_lock);
+       mutex_unlock(&c->fsck_error_msgs_lock);
 
        printbuf_exit(&buf);
 
@@ -269,10 +271,10 @@ int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...)
                bch2_inconsistent_error(c);
 
        if (ret == -BCH_ERR_fsck_fix) {
-               set_bit(BCH_FS_ERRORS_FIXED, &c->flags);
+               set_bit(BCH_FS_errors_fixed, &c->flags);
        } else {
-               set_bit(BCH_FS_ERRORS_NOT_FIXED, &c->flags);
-               set_bit(BCH_FS_ERROR, &c->flags);
+               set_bit(BCH_FS_errors_not_fixed, &c->flags);
+               set_bit(BCH_FS_error, &c->flags);
        }
 
        return ret;
@@ -282,9 +284,9 @@ void bch2_flush_fsck_errs(struct bch_fs *c)
 {
        struct fsck_err_state *s, *n;
 
-       mutex_lock(&c->fsck_error_lock);
+       mutex_lock(&c->fsck_error_msgs_lock);
 
-       list_for_each_entry_safe(s, n, &c->fsck_errors, list) {
+       list_for_each_entry_safe(s, n, &c->fsck_error_msgs, list) {
                if (s->ratelimited && s->last_msg)
                        bch_err(c, "Saw %llu errors like:\n    %s", s->nr, s->last_msg);
 
@@ -293,5 +295,5 @@ void bch2_flush_fsck_errs(struct bch_fs *c)
                kfree(s);
        }
 
-       mutex_unlock(&c->fsck_error_lock);
+       mutex_unlock(&c->fsck_error_msgs_lock);
 }