Update bcachefs sources to 504729f99c bcachefs: Allow answering y or n to all fsck...

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

diff --git a/libbcachefs/error.h b/libbcachefs/error.h
index 94b53312fbbda9b61e2f192f34f413ff88bcbeff..edf12443822c2599fe99651b3fd1855d40f18c00 100644 (file)
--- a/libbcachefs/error.h
+++ b/libbcachefs/error.h
@@ -29,6 +29,8 @@ struct work_struct;
 
 bool bch2_inconsistent_error(struct bch_fs *);
 
+void bch2_topology_error(struct bch_fs *);
+
 #define bch2_fs_inconsistent(c, ...)                                   \
 ({                                                                     \
        bch_err(c, __VA_ARGS__);                                        \
@@ -37,7 +39,7 @@ bool bch2_inconsistent_error(struct bch_fs *);
 
 #define bch2_fs_inconsistent_on(cond, c, ...)                          \
 ({                                                                     \
-       int _ret = !!(cond);                                            \
+       bool _ret = unlikely(!!(cond));                                 \
                                                                        \
        if (_ret)                                                       \
                bch2_fs_inconsistent(c, __VA_ARGS__);                   \
@@ -57,26 +59,38 @@ do {                                                                        \
 
 #define bch2_dev_inconsistent_on(cond, ca, ...)                                \
 ({                                                                     \
-       int _ret = !!(cond);                                            \
+       bool _ret = unlikely(!!(cond));                                 \
                                                                        \
        if (_ret)                                                       \
                bch2_dev_inconsistent(ca, __VA_ARGS__);                 \
        _ret;                                                           \
 })
 
+/*
+ * When a transaction update discovers or is causing a fs inconsistency, it's
+ * helpful to also dump the pending updates:
+ */
+#define bch2_trans_inconsistent(trans, ...)                            \
+({                                                                     \
+       bch_err(trans->c, __VA_ARGS__);                                 \
+       bch2_dump_trans_updates(trans);                                 \
+       bch2_inconsistent_error(trans->c);                              \
+})
+
+#define bch2_trans_inconsistent_on(cond, trans, ...)                   \
+({                                                                     \
+       bool _ret = unlikely(!!(cond));                                 \
+                                                                       \
+       if (_ret)                                                       \
+               bch2_trans_inconsistent(trans, __VA_ARGS__);            \
+       _ret;                                                           \
+})
+
 /*
  * Fsck errors: inconsistency errors we detect at mount time, and should ideally
  * be able to repair:
  */
 
-enum {
-       BCH_FSCK_OK                     = 0,
-       BCH_FSCK_ERRORS_NOT_FIXED       = 1,
-       BCH_FSCK_REPAIR_UNIMPLEMENTED   = 2,
-       BCH_FSCK_REPAIR_IMPOSSIBLE      = 3,
-       BCH_FSCK_UNKNOWN_VERSION        = 4,
-};
-
 enum fsck_err_opts {
        FSCK_OPT_EXIT,
        FSCK_OPT_YES,
@@ -84,40 +98,36 @@ enum fsck_err_opts {
        FSCK_OPT_ASK,
 };
 
-enum fsck_err_ret {
-       FSCK_ERR_IGNORE = 0,
-       FSCK_ERR_FIX    = 1,
-       FSCK_ERR_EXIT   = 2,
-};
-
 struct fsck_err_state {
        struct list_head        list;
        const char              *fmt;
        u64                     nr;
        bool                    ratelimited;
-       char                    buf[512];
+       int                     ret;
+       int                     fix;
+       char                    *last_msg;
 };
 
 #define FSCK_CAN_FIX           (1 << 0)
 #define FSCK_CAN_IGNORE                (1 << 1)
 #define FSCK_NEED_FSCK         (1 << 2)
+#define FSCK_NO_RATELIMIT      (1 << 3)
 
 __printf(3, 4) __cold
-enum fsck_err_ret bch2_fsck_err(struct bch_fs *,
-                               unsigned, const char *, ...);
+int bch2_fsck_err(struct bch_fs *, unsigned, const char *, ...);
 void bch2_flush_fsck_errs(struct bch_fs *);
 
 #define __fsck_err(c, _flags, msg, ...)                                        \
 ({                                                                     \
-       int _fix = bch2_fsck_err(c, _flags, msg, ##__VA_ARGS__);\
+       int _ret = bch2_fsck_err(c, _flags, msg, ##__VA_ARGS__);        \
                                                                        \
-       if (_fix == FSCK_ERR_EXIT) {                                    \
-               bch_err(c, "Unable to continue, halting");              \
-               ret = BCH_FSCK_ERRORS_NOT_FIXED;                        \
+       if (_ret != -BCH_ERR_fsck_fix &&                                \
+           _ret != -BCH_ERR_fsck_ignore) {                             \
+               ret = _ret;                                             \
                goto fsck_err;                                          \
        }                                                               \
                                                                        \
-       _fix;                                                           \
+       _ret == -BCH_ERR_fsck_fix;                                      \
 })
 
 /* These macros return true if error should be fixed: */
@@ -125,7 +135,7 @@ void bch2_flush_fsck_errs(struct bch_fs *);
 /* XXX: mark in superblock that filesystem contains errors, if we ignore: */
 
 #define __fsck_err_on(cond, c, _flags, ...)                            \
-       ((cond) ? __fsck_err(c, _flags, ##__VA_ARGS__) : false)
+       (unlikely(cond) ? __fsck_err(c, _flags, ##__VA_ARGS__) : false)
 
 #define need_fsck_err_on(cond, c, ...)                                 \
        __fsck_err_on(cond, c, FSCK_CAN_IGNORE|FSCK_NEED_FSCK, ##__VA_ARGS__)
@@ -160,7 +170,7 @@ do {                                                                        \
 
 #define bch2_fs_fatal_err_on(cond, c, ...)                             \
 ({                                                                     \
-       int _ret = !!(cond);                                            \
+       bool _ret = unlikely(!!(cond));                                 \
                                                                        \
        if (_ret)                                                       \
                bch2_fs_fatal_error(c, __VA_ARGS__);                    \
@@ -178,34 +188,26 @@ void bch2_io_error_work(struct work_struct *);
 /* Does the error handling without logging a message */
 void bch2_io_error(struct bch_dev *);
 
-/* Logs message and handles the error: */
-#define bch2_dev_io_error(ca, fmt, ...)                                        \
-do {                                                                   \
-       printk_ratelimited(KERN_ERR bch2_fmt((ca)->fs,                  \
-               "IO error on %s for " fmt),                             \
-               (ca)->name, ##__VA_ARGS__);                             \
-       bch2_io_error(ca);                                              \
-} while (0)
-
 #define bch2_dev_io_err_on(cond, ca, ...)                              \
 ({                                                                     \
        bool _ret = (cond);                                             \
                                                                        \
-       if (_ret)                                                       \
-               bch2_dev_io_error(ca, __VA_ARGS__);                     \
+       if (_ret) {                                                     \
+               bch_err_dev_ratelimited(ca, __VA_ARGS__);               \
+               bch2_io_error(ca);                                      \
+       }                                                               \
        _ret;                                                           \
 })
 
-/* kill? */
-
-#define __bcache_io_error(c, fmt, ...)                                 \
-       printk_ratelimited(KERN_ERR bch2_fmt(c,                         \
-                       "IO error: " fmt), ##__VA_ARGS__)
-
-#define bcache_io_error(c, bio, fmt, ...)                              \
-do {                                                                   \
-       __bcache_io_error(c, fmt, ##__VA_ARGS__);                       \
-       (bio)->bi_status = BLK_STS_IOERR;                                       \
-} while (0)
+#define bch2_dev_inum_io_err_on(cond, ca, ...)                         \
+({                                                                     \
+       bool _ret = (cond);                                             \
+                                                                       \
+       if (_ret) {                                                     \
+               bch_err_inum_offset_ratelimited(ca, __VA_ARGS__);       \
+               bch2_io_error(ca);                                      \
+       }                                                               \
+       _ret;                                                           \
+})
 
 #endif /* _BCACHEFS_ERROR_H */