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