1 // SPDX-License-Identifier: GPL-2.0 2 #include "bcachefs.h" 3 #include "error.h" 4 #include "super.h" 5 6 #define FSCK_ERR_RATELIMIT_NR 10 7 8 bool bch2_inconsistent_error(struct bch_fs *c) 9 { 10 set_bit(BCH_FS_ERROR, &c->flags); 11 12 switch (c->opts.errors) { 13 case BCH_ON_ERROR_continue: 14 return false; 15 case BCH_ON_ERROR_ro: 16 if (bch2_fs_emergency_read_only(c)) 17 bch_err(c, "inconsistency detected - emergency read only"); 18 return true; 19 case BCH_ON_ERROR_panic: 20 panic(bch2_fmt(c, "panic after error")); 21 return true; 22 default: 23 BUG(); 24 } 25 } 26 27 void bch2_topology_error(struct bch_fs *c) 28 { 29 set_bit(BCH_FS_TOPOLOGY_ERROR, &c->flags); 30 if (test_bit(BCH_FS_FSCK_DONE, &c->flags)) 31 bch2_inconsistent_error(c); 32 } 33 34 void bch2_fatal_error(struct bch_fs *c) 35 { 36 if (bch2_fs_emergency_read_only(c)) 37 bch_err(c, "fatal error - emergency read only"); 38 } 39 40 void bch2_io_error_work(struct work_struct *work) 41 { 42 struct bch_dev *ca = container_of(work, struct bch_dev, io_error_work); 43 struct bch_fs *c = ca->fs; 44 bool dev; 45 46 down_write(&c->state_lock); 47 dev = bch2_dev_state_allowed(c, ca, BCH_MEMBER_STATE_ro, 48 BCH_FORCE_IF_DEGRADED); 49 if (dev 50 ? __bch2_dev_set_state(c, ca, BCH_MEMBER_STATE_ro, 51 BCH_FORCE_IF_DEGRADED) 52 : bch2_fs_emergency_read_only(c)) 53 bch_err(ca, 54 "too many IO errors, setting %s RO", 55 dev ? "device" : "filesystem"); 56 up_write(&c->state_lock); 57 } 58 59 void bch2_io_error(struct bch_dev *ca) 60 { 61 //queue_work(system_long_wq, &ca->io_error_work); 62 } 63 64 enum ask_yn { 65 YN_NO, 66 YN_YES, 67 YN_ALLNO, 68 YN_ALLYES, 69 }; 70 71 #ifdef __KERNEL__ 72 #define bch2_fsck_ask_yn() YN_NO 73 #else 74 75 #include "tools-util.h" 76 77 enum ask_yn bch2_fsck_ask_yn(void) 78 { 79 char *buf = NULL; 80 size_t buflen = 0; 81 bool ret; 82 83 while (true) { 84 fputs(" (y,n, or Y,N for all errors of this type) ", stdout); 85 fflush(stdout); 86 87 if (getline(&buf, &buflen, stdin) < 0) 88 die("error reading from standard input"); 89 90 strim(buf); 91 if (strlen(buf) != 1) 92 continue; 93 94 switch (buf[0]) { 95 case 'n': 96 return YN_NO; 97 case 'y': 98 return YN_YES; 99 case 'N': 100 return YN_ALLNO; 101 case 'Y': 102 return YN_ALLYES; 103 } 104 } 105 106 free(buf); 107 return ret; 108 } 109 110 #endif 111 112 static struct fsck_err_state *fsck_err_get(struct bch_fs *c, const char *fmt) 113 { 114 struct fsck_err_state *s; 115 116 if (test_bit(BCH_FS_FSCK_DONE, &c->flags)) 117 return NULL; 118 119 list_for_each_entry(s, &c->fsck_errors, list) 120 if (s->fmt == fmt) { 121 /* 122 * move it to the head of the list: repeated fsck errors 123 * are common 124 */ 125 list_move(&s->list, &c->fsck_errors); 126 return s; 127 } 128 129 s = kzalloc(sizeof(*s), GFP_NOFS); 130 if (!s) { 131 if (!c->fsck_alloc_err) 132 bch_err(c, "kmalloc err, cannot ratelimit fsck errs"); 133 c->fsck_alloc_err = true; 134 return NULL; 135 } 136 137 INIT_LIST_HEAD(&s->list); 138 s->fmt = fmt; 139 list_add(&s->list, &c->fsck_errors); 140 return s; 141 } 142 143 int bch2_fsck_err(struct bch_fs *c, unsigned flags, const char *fmt, ...) 144 { 145 struct fsck_err_state *s = NULL; 146 va_list args; 147 bool print = true, suppressing = false, inconsistent = false; 148 struct printbuf buf = PRINTBUF, *out = &buf; 149 int ret = -BCH_ERR_fsck_ignore; 150 151 va_start(args, fmt); 152 prt_vprintf(out, fmt, args); 153 va_end(args); 154 155 mutex_lock(&c->fsck_error_lock); 156 s = fsck_err_get(c, fmt); 157 if (s) { 158 /* 159 * We may be called multiple times for the same error on 160 * transaction restart - this memoizes instead of asking the user 161 * multiple times for the same error: 162 */ 163 if (s->last_msg && !strcmp(buf.buf, s->last_msg)) { 164 ret = s->ret; 165 mutex_unlock(&c->fsck_error_lock); 166 printbuf_exit(&buf); 167 return ret; 168 } 169 170 kfree(s->last_msg); 171 s->last_msg = kstrdup(buf.buf, GFP_KERNEL); 172 173 if (c->opts.ratelimit_errors && 174 !(flags & FSCK_NO_RATELIMIT) && 175 s->nr >= FSCK_ERR_RATELIMIT_NR) { 176 if (s->nr == FSCK_ERR_RATELIMIT_NR) 177 suppressing = true; 178 else 179 print = false; 180 } 181 182 s->nr++; 183 } 184 185 #ifdef BCACHEFS_LOG_PREFIX 186 if (!strncmp(fmt, "bcachefs:", 9)) 187 prt_printf(out, bch2_log_msg(c, "")); 188 #endif 189 190 if (test_bit(BCH_FS_FSCK_DONE, &c->flags)) { 191 if (c->opts.errors != BCH_ON_ERROR_continue || 192 !(flags & (FSCK_CAN_FIX|FSCK_CAN_IGNORE))) { 193 prt_str(out, ", shutting down"); 194 inconsistent = true; 195 ret = -BCH_ERR_fsck_errors_not_fixed; 196 } else if (flags & FSCK_CAN_FIX) { 197 prt_str(out, ", fixing"); 198 ret = -BCH_ERR_fsck_fix; 199 } else { 200 prt_str(out, ", continuing"); 201 ret = -BCH_ERR_fsck_ignore; 202 } 203 } else if (c->opts.fix_errors == FSCK_FIX_exit) { 204 prt_str(out, ", exiting"); 205 ret = -BCH_ERR_fsck_errors_not_fixed; 206 } else if (flags & FSCK_CAN_FIX) { 207 int fix = s && s->fix 208 ? s->fix 209 : c->opts.fix_errors; 210 211 if (fix == FSCK_FIX_ask) { 212 int ask; 213 214 prt_str(out, ": fix?"); 215 bch2_print_string_as_lines(KERN_ERR, out->buf); 216 print = false; 217 218 ask = bch2_fsck_ask_yn(); 219 220 if (ask >= YN_ALLNO && s) 221 s->fix = ask == YN_ALLNO 222 ? FSCK_FIX_no 223 : FSCK_FIX_yes; 224 225 ret = ask & 1 226 ? -BCH_ERR_fsck_fix 227 : -BCH_ERR_fsck_ignore; 228 } else if (fix == FSCK_FIX_yes || 229 (c->opts.nochanges && 230 !(flags & FSCK_CAN_IGNORE))) { 231 prt_str(out, ", fixing"); 232 ret = -BCH_ERR_fsck_fix; 233 } else { 234 prt_str(out, ", not fixing"); 235 } 236 } else if (flags & FSCK_NEED_FSCK) { 237 prt_str(out, " (run fsck to correct)"); 238 } else { 239 prt_str(out, " (repair unimplemented)"); 240 } 241 242 if (ret == -BCH_ERR_fsck_ignore && 243 (c->opts.fix_errors == FSCK_FIX_exit || 244 !(flags & FSCK_CAN_IGNORE))) 245 ret = -BCH_ERR_fsck_errors_not_fixed; 246 247 if (print) 248 bch2_print_string_as_lines(KERN_ERR, out->buf); 249 250 if (!test_bit(BCH_FS_FSCK_DONE, &c->flags) && 251 (ret != -BCH_ERR_fsck_fix && 252 ret != -BCH_ERR_fsck_ignore)) 253 bch_err(c, "Unable to continue, halting"); 254 else if (suppressing) 255 bch_err(c, "Ratelimiting new instances of previous error"); 256 257 if (s) 258 s->ret = ret; 259 260 mutex_unlock(&c->fsck_error_lock); 261 262 printbuf_exit(&buf); 263 264 if (inconsistent) 265 bch2_inconsistent_error(c); 266 267 if (ret == -BCH_ERR_fsck_fix) { 268 set_bit(BCH_FS_ERRORS_FIXED, &c->flags); 269 } else { 270 set_bit(BCH_FS_ERRORS_NOT_FIXED, &c->flags); 271 set_bit(BCH_FS_ERROR, &c->flags); 272 } 273 274 return ret; 275 } 276 277 void bch2_flush_fsck_errs(struct bch_fs *c) 278 { 279 struct fsck_err_state *s, *n; 280 281 mutex_lock(&c->fsck_error_lock); 282 283 list_for_each_entry_safe(s, n, &c->fsck_errors, list) { 284 if (s->ratelimited && s->last_msg) 285 bch_err(c, "Saw %llu errors like:\n %s", s->nr, s->last_msg); 286 287 list_del(&s->list); 288 kfree(s->last_msg); 289 kfree(s); 290 } 291 292 mutex_unlock(&c->fsck_error_lock); 293 } 294