]> Git Repo - J-linux.git/blob - fs/bcachefs/recovery_passes.c
Merge tag 'vfs-6.13-rc7.fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
[J-linux.git] / fs / bcachefs / recovery_passes.c
1 // SPDX-License-Identifier: GPL-2.0
2
3 #include "bcachefs.h"
4 #include "alloc_background.h"
5 #include "backpointers.h"
6 #include "btree_gc.h"
7 #include "btree_node_scan.h"
8 #include "disk_accounting.h"
9 #include "ec.h"
10 #include "fsck.h"
11 #include "inode.h"
12 #include "journal.h"
13 #include "lru.h"
14 #include "logged_ops.h"
15 #include "rebalance.h"
16 #include "recovery.h"
17 #include "recovery_passes.h"
18 #include "snapshot.h"
19 #include "subvolume.h"
20 #include "super.h"
21 #include "super-io.h"
22
23 const char * const bch2_recovery_passes[] = {
24 #define x(_fn, ...)     #_fn,
25         BCH_RECOVERY_PASSES()
26 #undef x
27         NULL
28 };
29
30 /* Fake recovery pass, so that scan_for_btree_nodes isn't 0: */
31 static int bch2_recovery_pass_empty(struct bch_fs *c)
32 {
33         return 0;
34 }
35
36 static int bch2_set_may_go_rw(struct bch_fs *c)
37 {
38         struct journal_keys *keys = &c->journal_keys;
39
40         /*
41          * After we go RW, the journal keys buffer can't be modified (except for
42          * setting journal_key->overwritten: it will be accessed by multiple
43          * threads
44          */
45         move_gap(keys, keys->nr);
46
47         set_bit(BCH_FS_may_go_rw, &c->flags);
48
49         if (keys->nr || c->opts.fsck || !c->sb.clean || c->opts.recovery_passes)
50                 return bch2_fs_read_write_early(c);
51         return 0;
52 }
53
54 struct recovery_pass_fn {
55         int             (*fn)(struct bch_fs *);
56         unsigned        when;
57 };
58
59 static struct recovery_pass_fn recovery_pass_fns[] = {
60 #define x(_fn, _id, _when)      { .fn = bch2_##_fn, .when = _when },
61         BCH_RECOVERY_PASSES()
62 #undef x
63 };
64
65 static const u8 passes_to_stable_map[] = {
66 #define x(n, id, ...)   [BCH_RECOVERY_PASS_##n] = BCH_RECOVERY_PASS_STABLE_##n,
67         BCH_RECOVERY_PASSES()
68 #undef x
69 };
70
71 static enum bch_recovery_pass_stable bch2_recovery_pass_to_stable(enum bch_recovery_pass pass)
72 {
73         return passes_to_stable_map[pass];
74 }
75
76 u64 bch2_recovery_passes_to_stable(u64 v)
77 {
78         u64 ret = 0;
79         for (unsigned i = 0; i < ARRAY_SIZE(passes_to_stable_map); i++)
80                 if (v & BIT_ULL(i))
81                         ret |= BIT_ULL(passes_to_stable_map[i]);
82         return ret;
83 }
84
85 u64 bch2_recovery_passes_from_stable(u64 v)
86 {
87         static const u8 map[] = {
88 #define x(n, id, ...)   [BCH_RECOVERY_PASS_STABLE_##n] = BCH_RECOVERY_PASS_##n,
89         BCH_RECOVERY_PASSES()
90 #undef x
91         };
92
93         u64 ret = 0;
94         for (unsigned i = 0; i < ARRAY_SIZE(map); i++)
95                 if (v & BIT_ULL(i))
96                         ret |= BIT_ULL(map[i]);
97         return ret;
98 }
99
100 /*
101  * For when we need to rewind recovery passes and run a pass we skipped:
102  */
103 int bch2_run_explicit_recovery_pass(struct bch_fs *c,
104                                     enum bch_recovery_pass pass)
105 {
106         if (c->opts.recovery_passes & BIT_ULL(pass))
107                 return 0;
108
109         bch_info(c, "running explicit recovery pass %s (%u), currently at %s (%u)",
110                  bch2_recovery_passes[pass], pass,
111                  bch2_recovery_passes[c->curr_recovery_pass], c->curr_recovery_pass);
112
113         c->opts.recovery_passes |= BIT_ULL(pass);
114
115         if (c->curr_recovery_pass >= pass) {
116                 c->curr_recovery_pass = pass;
117                 c->recovery_passes_complete &= (1ULL << pass) >> 1;
118                 return -BCH_ERR_restart_recovery;
119         } else {
120                 return 0;
121         }
122 }
123
124 int bch2_run_explicit_recovery_pass_persistent(struct bch_fs *c,
125                                                enum bch_recovery_pass pass)
126 {
127         enum bch_recovery_pass_stable s = bch2_recovery_pass_to_stable(pass);
128
129         mutex_lock(&c->sb_lock);
130         struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);
131
132         if (!test_bit_le64(s, ext->recovery_passes_required)) {
133                 __set_bit_le64(s, ext->recovery_passes_required);
134                 bch2_write_super(c);
135         }
136         mutex_unlock(&c->sb_lock);
137
138         return bch2_run_explicit_recovery_pass(c, pass);
139 }
140
141 static void bch2_clear_recovery_pass_required(struct bch_fs *c,
142                                               enum bch_recovery_pass pass)
143 {
144         enum bch_recovery_pass_stable s = bch2_recovery_pass_to_stable(pass);
145
146         mutex_lock(&c->sb_lock);
147         struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);
148
149         if (test_bit_le64(s, ext->recovery_passes_required)) {
150                 __clear_bit_le64(s, ext->recovery_passes_required);
151                 bch2_write_super(c);
152         }
153         mutex_unlock(&c->sb_lock);
154 }
155
156 u64 bch2_fsck_recovery_passes(void)
157 {
158         u64 ret = 0;
159
160         for (unsigned i = 0; i < ARRAY_SIZE(recovery_pass_fns); i++)
161                 if (recovery_pass_fns[i].when & PASS_FSCK)
162                         ret |= BIT_ULL(i);
163         return ret;
164 }
165
166 static bool should_run_recovery_pass(struct bch_fs *c, enum bch_recovery_pass pass)
167 {
168         struct recovery_pass_fn *p = recovery_pass_fns + pass;
169
170         if (c->opts.recovery_passes_exclude & BIT_ULL(pass))
171                 return false;
172         if (c->opts.recovery_passes & BIT_ULL(pass))
173                 return true;
174         if ((p->when & PASS_FSCK) && c->opts.fsck)
175                 return true;
176         if ((p->when & PASS_UNCLEAN) && !c->sb.clean)
177                 return true;
178         if (p->when & PASS_ALWAYS)
179                 return true;
180         return false;
181 }
182
183 static int bch2_run_recovery_pass(struct bch_fs *c, enum bch_recovery_pass pass)
184 {
185         struct recovery_pass_fn *p = recovery_pass_fns + pass;
186         int ret;
187
188         if (!(p->when & PASS_SILENT))
189                 bch2_print(c, KERN_INFO bch2_log_msg(c, "%s..."),
190                            bch2_recovery_passes[pass]);
191         ret = p->fn(c);
192         if (ret)
193                 return ret;
194         if (!(p->when & PASS_SILENT))
195                 bch2_print(c, KERN_CONT " done\n");
196
197         return 0;
198 }
199
200 int bch2_run_online_recovery_passes(struct bch_fs *c)
201 {
202         int ret = 0;
203
204         down_read(&c->state_lock);
205
206         for (unsigned i = 0; i < ARRAY_SIZE(recovery_pass_fns); i++) {
207                 struct recovery_pass_fn *p = recovery_pass_fns + i;
208
209                 if (!(p->when & PASS_ONLINE))
210                         continue;
211
212                 ret = bch2_run_recovery_pass(c, i);
213                 if (bch2_err_matches(ret, BCH_ERR_restart_recovery)) {
214                         i = c->curr_recovery_pass;
215                         continue;
216                 }
217                 if (ret)
218                         break;
219         }
220
221         up_read(&c->state_lock);
222
223         return ret;
224 }
225
226 int bch2_run_recovery_passes(struct bch_fs *c)
227 {
228         int ret = 0;
229
230         /*
231          * We can't allow set_may_go_rw to be excluded; that would cause us to
232          * use the journal replay keys for updates where it's not expected.
233          */
234         c->opts.recovery_passes_exclude &= ~BCH_RECOVERY_PASS_set_may_go_rw;
235
236         while (c->curr_recovery_pass < ARRAY_SIZE(recovery_pass_fns)) {
237                 if (c->opts.recovery_pass_last &&
238                     c->curr_recovery_pass > c->opts.recovery_pass_last)
239                         break;
240
241                 if (should_run_recovery_pass(c, c->curr_recovery_pass)) {
242                         unsigned pass = c->curr_recovery_pass;
243
244                         ret =   bch2_run_recovery_pass(c, c->curr_recovery_pass) ?:
245                                 bch2_journal_flush(&c->journal);
246                         if (bch2_err_matches(ret, BCH_ERR_restart_recovery) ||
247                             (ret && c->curr_recovery_pass < pass))
248                                 continue;
249                         if (ret)
250                                 break;
251
252                         c->recovery_passes_complete |= BIT_ULL(c->curr_recovery_pass);
253                 }
254
255                 c->recovery_pass_done = max(c->recovery_pass_done, c->curr_recovery_pass);
256
257                 if (!test_bit(BCH_FS_error, &c->flags))
258                         bch2_clear_recovery_pass_required(c, c->curr_recovery_pass);
259
260                 c->curr_recovery_pass++;
261         }
262
263         return ret;
264 }
This page took 0.041923 seconds and 4 git commands to generate.