1 // SPDX-License-Identifier: GPL-2.0
2
3 #include "bcachefs.h"
4 #include "alloc_background.h"
5 #include "bkey_buf.h"
6 #include "btree_journal_iter.h"
7 #include "btree_node_scan.h"
8 #include "btree_update.h"
9 #include "btree_update_interior.h"
10 #include "btree_io.h"
11 #include "buckets.h"
12 #include "dirent.h"
13 #include "disk_accounting.h"
14 #include "errcode.h"
15 #include "error.h"
16 #include "fs-common.h"
17 #include "journal_io.h"
18 #include "journal_reclaim.h"
19 #include "journal_seq_blacklist.h"
20 #include "logged_ops.h"
21 #include "move.h"
22 #include "quota.h"
23 #include "rebalance.h"
24 #include "recovery.h"
25 #include "recovery_passes.h"
26 #include "replicas.h"
27 #include "sb-clean.h"
28 #include "sb-downgrade.h"
29 #include "snapshot.h"
30 #include "super-io.h"
31
32 #include <linux/sort.h>
33 #include <linux/stat.h>
34
bch2_btree_lost_data(struct bch_fs * c,enum btree_id btree)35 void bch2_btree_lost_data(struct bch_fs *c, enum btree_id btree)
36 {
37 if (btree >= BTREE_ID_NR_MAX)
38 return;
39
40 u64 b = BIT_ULL(btree);
41
42 if (!(c->sb.btrees_lost_data & b)) {
43 bch_err(c, "flagging btree %s lost data", bch2_btree_id_str(btree));
44
45 mutex_lock(&c->sb_lock);
46 bch2_sb_field_get(c->disk_sb.sb, ext)->btrees_lost_data |= cpu_to_le64(b);
47 bch2_write_super(c);
48 mutex_unlock(&c->sb_lock);
49 }
50 }
51
52 /* for -o reconstruct_alloc: */
bch2_reconstruct_alloc(struct bch_fs * c)53 static void bch2_reconstruct_alloc(struct bch_fs *c)
54 {
55 bch2_journal_log_msg(c, "dropping alloc info");
56 bch_info(c, "dropping and reconstructing all alloc info");
57
58 mutex_lock(&c->sb_lock);
59 struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);
60
61 __set_bit_le64(BCH_RECOVERY_PASS_STABLE_check_allocations, ext->recovery_passes_required);
62 __set_bit_le64(BCH_RECOVERY_PASS_STABLE_check_alloc_info, ext->recovery_passes_required);
63 __set_bit_le64(BCH_RECOVERY_PASS_STABLE_check_lrus, ext->recovery_passes_required);
64 __set_bit_le64(BCH_RECOVERY_PASS_STABLE_check_extents_to_backpointers, ext->recovery_passes_required);
65 __set_bit_le64(BCH_RECOVERY_PASS_STABLE_check_alloc_to_lru_refs, ext->recovery_passes_required);
66
67 __set_bit_le64(BCH_FSCK_ERR_ptr_to_missing_alloc_key, ext->errors_silent);
68 __set_bit_le64(BCH_FSCK_ERR_ptr_gen_newer_than_bucket_gen, ext->errors_silent);
69 __set_bit_le64(BCH_FSCK_ERR_stale_dirty_ptr, ext->errors_silent);
70
71 __set_bit_le64(BCH_FSCK_ERR_dev_usage_buckets_wrong, ext->errors_silent);
72 __set_bit_le64(BCH_FSCK_ERR_dev_usage_sectors_wrong, ext->errors_silent);
73 __set_bit_le64(BCH_FSCK_ERR_dev_usage_fragmented_wrong, ext->errors_silent);
74
75 __set_bit_le64(BCH_FSCK_ERR_fs_usage_btree_wrong, ext->errors_silent);
76 __set_bit_le64(BCH_FSCK_ERR_fs_usage_cached_wrong, ext->errors_silent);
77 __set_bit_le64(BCH_FSCK_ERR_fs_usage_persistent_reserved_wrong, ext->errors_silent);
78 __set_bit_le64(BCH_FSCK_ERR_fs_usage_replicas_wrong, ext->errors_silent);
79
80 __set_bit_le64(BCH_FSCK_ERR_alloc_key_data_type_wrong, ext->errors_silent);
81 __set_bit_le64(BCH_FSCK_ERR_alloc_key_gen_wrong, ext->errors_silent);
82 __set_bit_le64(BCH_FSCK_ERR_alloc_key_dirty_sectors_wrong, ext->errors_silent);
83 __set_bit_le64(BCH_FSCK_ERR_alloc_key_cached_sectors_wrong, ext->errors_silent);
84 __set_bit_le64(BCH_FSCK_ERR_alloc_key_stripe_wrong, ext->errors_silent);
85 __set_bit_le64(BCH_FSCK_ERR_alloc_key_stripe_redundancy_wrong, ext->errors_silent);
86 __set_bit_le64(BCH_FSCK_ERR_need_discard_key_wrong, ext->errors_silent);
87 __set_bit_le64(BCH_FSCK_ERR_freespace_key_wrong, ext->errors_silent);
88 __set_bit_le64(BCH_FSCK_ERR_bucket_gens_key_wrong, ext->errors_silent);
89 __set_bit_le64(BCH_FSCK_ERR_freespace_hole_missing, ext->errors_silent);
90 __set_bit_le64(BCH_FSCK_ERR_ptr_to_missing_backpointer, ext->errors_silent);
91 __set_bit_le64(BCH_FSCK_ERR_lru_entry_bad, ext->errors_silent);
92 __set_bit_le64(BCH_FSCK_ERR_accounting_mismatch, ext->errors_silent);
93 c->sb.compat &= ~(1ULL << BCH_COMPAT_alloc_info);
94
95 c->opts.recovery_passes |= bch2_recovery_passes_from_stable(le64_to_cpu(ext->recovery_passes_required[0]));
96
97 bch2_write_super(c);
98 mutex_unlock(&c->sb_lock);
99
100 bch2_shoot_down_journal_keys(c, BTREE_ID_alloc,
101 0, BTREE_MAX_DEPTH, POS_MIN, SPOS_MAX);
102 bch2_shoot_down_journal_keys(c, BTREE_ID_backpointers,
103 0, BTREE_MAX_DEPTH, POS_MIN, SPOS_MAX);
104 bch2_shoot_down_journal_keys(c, BTREE_ID_need_discard,
105 0, BTREE_MAX_DEPTH, POS_MIN, SPOS_MAX);
106 bch2_shoot_down_journal_keys(c, BTREE_ID_freespace,
107 0, BTREE_MAX_DEPTH, POS_MIN, SPOS_MAX);
108 bch2_shoot_down_journal_keys(c, BTREE_ID_bucket_gens,
109 0, BTREE_MAX_DEPTH, POS_MIN, SPOS_MAX);
110 }
111
112 /*
113 * Btree node pointers have a field to stack a pointer to the in memory btree
114 * node; we need to zero out this field when reading in btree nodes, or when
115 * reading in keys from the journal:
116 */
zero_out_btree_mem_ptr(struct journal_keys * keys)117 static void zero_out_btree_mem_ptr(struct journal_keys *keys)
118 {
119 darray_for_each(*keys, i)
120 if (i->k->k.type == KEY_TYPE_btree_ptr_v2)
121 bkey_i_to_btree_ptr_v2(i->k)->v.mem_ptr = 0;
122 }
123
124 /* journal replay: */
125
replay_now_at(struct journal * j,u64 seq)126 static void replay_now_at(struct journal *j, u64 seq)
127 {
128 BUG_ON(seq < j->replay_journal_seq);
129
130 seq = min(seq, j->replay_journal_seq_end);
131
132 while (j->replay_journal_seq < seq)
133 bch2_journal_pin_put(j, j->replay_journal_seq++);
134 }
135
bch2_journal_replay_accounting_key(struct btree_trans * trans,struct journal_key * k)136 static int bch2_journal_replay_accounting_key(struct btree_trans *trans,
137 struct journal_key *k)
138 {
139 struct btree_iter iter;
140 bch2_trans_node_iter_init(trans, &iter, k->btree_id, k->k->k.p,
141 BTREE_MAX_DEPTH, k->level,
142 BTREE_ITER_intent);
143 int ret = bch2_btree_iter_traverse(&iter);
144 if (ret)
145 goto out;
146
147 struct bkey u;
148 struct bkey_s_c old = bch2_btree_path_peek_slot(btree_iter_path(trans, &iter), &u);
149
150 /* Has this delta already been applied to the btree? */
151 if (bversion_cmp(old.k->bversion, k->k->k.bversion) >= 0) {
152 ret = 0;
153 goto out;
154 }
155
156 struct bkey_i *new = k->k;
157 if (old.k->type == KEY_TYPE_accounting) {
158 new = bch2_bkey_make_mut_noupdate(trans, bkey_i_to_s_c(k->k));
159 ret = PTR_ERR_OR_ZERO(new);
160 if (ret)
161 goto out;
162
163 bch2_accounting_accumulate(bkey_i_to_accounting(new),
164 bkey_s_c_to_accounting(old));
165 }
166
167 trans->journal_res.seq = k->journal_seq;
168
169 ret = bch2_trans_update(trans, &iter, new, BTREE_TRIGGER_norun);
170 out:
171 bch2_trans_iter_exit(trans, &iter);
172 return ret;
173 }
174
bch2_journal_replay_key(struct btree_trans * trans,struct journal_key * k)175 static int bch2_journal_replay_key(struct btree_trans *trans,
176 struct journal_key *k)
177 {
178 struct btree_iter iter;
179 unsigned iter_flags =
180 BTREE_ITER_intent|
181 BTREE_ITER_not_extents;
182 unsigned update_flags = BTREE_TRIGGER_norun;
183 int ret;
184
185 if (k->overwritten)
186 return 0;
187
188 trans->journal_res.seq = k->journal_seq;
189
190 /*
191 * BTREE_UPDATE_key_cache_reclaim disables key cache lookup/update to
192 * keep the key cache coherent with the underlying btree. Nothing
193 * besides the allocator is doing updates yet so we don't need key cache
194 * coherency for non-alloc btrees, and key cache fills for snapshots
195 * btrees use BTREE_ITER_filter_snapshots, which isn't available until
196 * the snapshots recovery pass runs.
197 */
198 if (!k->level && k->btree_id == BTREE_ID_alloc)
199 iter_flags |= BTREE_ITER_cached;
200 else
201 update_flags |= BTREE_UPDATE_key_cache_reclaim;
202
203 bch2_trans_node_iter_init(trans, &iter, k->btree_id, k->k->k.p,
204 BTREE_MAX_DEPTH, k->level,
205 iter_flags);
206 ret = bch2_btree_iter_traverse(&iter);
207 if (ret)
208 goto out;
209
210 struct btree_path *path = btree_iter_path(trans, &iter);
211 if (unlikely(!btree_path_node(path, k->level))) {
212 bch2_trans_iter_exit(trans, &iter);
213 bch2_trans_node_iter_init(trans, &iter, k->btree_id, k->k->k.p,
214 BTREE_MAX_DEPTH, 0, iter_flags);
215 ret = bch2_btree_iter_traverse(&iter) ?:
216 bch2_btree_increase_depth(trans, iter.path, 0) ?:
217 -BCH_ERR_transaction_restart_nested;
218 goto out;
219 }
220
221 /* Must be checked with btree locked: */
222 if (k->overwritten)
223 goto out;
224
225 if (k->k->k.type == KEY_TYPE_accounting) {
226 ret = bch2_trans_update_buffered(trans, BTREE_ID_accounting, k->k);
227 goto out;
228 }
229
230 ret = bch2_trans_update(trans, &iter, k->k, update_flags);
231 out:
232 bch2_trans_iter_exit(trans, &iter);
233 return ret;
234 }
235
journal_sort_seq_cmp(const void * _l,const void * _r)236 static int journal_sort_seq_cmp(const void *_l, const void *_r)
237 {
238 const struct journal_key *l = *((const struct journal_key **)_l);
239 const struct journal_key *r = *((const struct journal_key **)_r);
240
241 /*
242 * Map 0 to U64_MAX, so that keys with journal_seq === 0 come last
243 *
244 * journal_seq == 0 means that the key comes from early repair, and
245 * should be inserted last so as to avoid overflowing the journal
246 */
247 return cmp_int(l->journal_seq - 1, r->journal_seq - 1);
248 }
249
bch2_journal_replay(struct bch_fs * c)250 int bch2_journal_replay(struct bch_fs *c)
251 {
252 struct journal_keys *keys = &c->journal_keys;
253 DARRAY(struct journal_key *) keys_sorted = { 0 };
254 struct journal *j = &c->journal;
255 u64 start_seq = c->journal_replay_seq_start;
256 u64 end_seq = c->journal_replay_seq_start;
257 struct btree_trans *trans = NULL;
258 bool immediate_flush = false;
259 int ret = 0;
260
261 if (keys->nr) {
262 ret = bch2_journal_log_msg(c, "Starting journal replay (%zu keys in entries %llu-%llu)",
263 keys->nr, start_seq, end_seq);
264 if (ret)
265 goto err;
266 }
267
268 BUG_ON(!atomic_read(&keys->ref));
269
270 move_gap(keys, keys->nr);
271 trans = bch2_trans_get(c);
272
273 /*
274 * Replay accounting keys first: we can't allow the write buffer to
275 * flush accounting keys until we're done
276 */
277 darray_for_each(*keys, k) {
278 if (!(k->k->k.type == KEY_TYPE_accounting && !k->allocated))
279 continue;
280
281 cond_resched();
282
283 ret = commit_do(trans, NULL, NULL,
284 BCH_TRANS_COMMIT_no_enospc|
285 BCH_TRANS_COMMIT_journal_reclaim|
286 BCH_TRANS_COMMIT_skip_accounting_apply|
287 BCH_TRANS_COMMIT_no_journal_res|
288 BCH_WATERMARK_reclaim,
289 bch2_journal_replay_accounting_key(trans, k));
290 if (bch2_fs_fatal_err_on(ret, c, "error replaying accounting; %s", bch2_err_str(ret)))
291 goto err;
292
293 k->overwritten = true;
294 }
295
296 set_bit(BCH_FS_accounting_replay_done, &c->flags);
297
298 /*
299 * First, attempt to replay keys in sorted order. This is more
300 * efficient - better locality of btree access - but some might fail if
301 * that would cause a journal deadlock.
302 */
303 darray_for_each(*keys, k) {
304 cond_resched();
305
306 /*
307 * k->allocated means the key wasn't read in from the journal,
308 * rather it was from early repair code
309 */
310 if (k->allocated)
311 immediate_flush = true;
312
313 /* Skip fastpath if we're low on space in the journal */
314 ret = c->journal.watermark ? -1 :
315 commit_do(trans, NULL, NULL,
316 BCH_TRANS_COMMIT_no_enospc|
317 BCH_TRANS_COMMIT_journal_reclaim|
318 BCH_TRANS_COMMIT_skip_accounting_apply|
319 (!k->allocated ? BCH_TRANS_COMMIT_no_journal_res : 0),
320 bch2_journal_replay_key(trans, k));
321 BUG_ON(!ret && !k->overwritten && k->k->k.type != KEY_TYPE_accounting);
322 if (ret) {
323 ret = darray_push(&keys_sorted, k);
324 if (ret)
325 goto err;
326 }
327 }
328
329 bch2_trans_unlock_long(trans);
330 /*
331 * Now, replay any remaining keys in the order in which they appear in
332 * the journal, unpinning those journal entries as we go:
333 */
334 sort(keys_sorted.data, keys_sorted.nr,
335 sizeof(keys_sorted.data[0]),
336 journal_sort_seq_cmp, NULL);
337
338 darray_for_each(keys_sorted, kp) {
339 cond_resched();
340
341 struct journal_key *k = *kp;
342
343 if (k->journal_seq)
344 replay_now_at(j, k->journal_seq);
345 else
346 replay_now_at(j, j->replay_journal_seq_end);
347
348 ret = commit_do(trans, NULL, NULL,
349 BCH_TRANS_COMMIT_no_enospc|
350 BCH_TRANS_COMMIT_skip_accounting_apply|
351 (!k->allocated
352 ? BCH_TRANS_COMMIT_no_journal_res|BCH_WATERMARK_reclaim
353 : 0),
354 bch2_journal_replay_key(trans, k));
355 bch_err_msg(c, ret, "while replaying key at btree %s level %u:",
356 bch2_btree_id_str(k->btree_id), k->level);
357 if (ret)
358 goto err;
359
360 BUG_ON(k->btree_id != BTREE_ID_accounting && !k->overwritten);
361 }
362
363 /*
364 * We need to put our btree_trans before calling flush_all_pins(), since
365 * that will use a btree_trans internally
366 */
367 bch2_trans_put(trans);
368 trans = NULL;
369
370 if (!c->opts.retain_recovery_info &&
371 c->recovery_pass_done >= BCH_RECOVERY_PASS_journal_replay)
372 bch2_journal_keys_put_initial(c);
373
374 replay_now_at(j, j->replay_journal_seq_end);
375 j->replay_journal_seq = 0;
376
377 bch2_journal_set_replay_done(j);
378
379 /* if we did any repair, flush it immediately */
380 if (immediate_flush) {
381 bch2_journal_flush_all_pins(&c->journal);
382 ret = bch2_journal_meta(&c->journal);
383 }
384
385 if (keys->nr)
386 bch2_journal_log_msg(c, "journal replay finished");
387 err:
388 if (trans)
389 bch2_trans_put(trans);
390 darray_exit(&keys_sorted);
391 bch_err_fn(c, ret);
392 return ret;
393 }
394
395 /* journal replay early: */
396
journal_replay_entry_early(struct bch_fs * c,struct jset_entry * entry)397 static int journal_replay_entry_early(struct bch_fs *c,
398 struct jset_entry *entry)
399 {
400 int ret = 0;
401
402 switch (entry->type) {
403 case BCH_JSET_ENTRY_btree_root: {
404 struct btree_root *r;
405
406 if (fsck_err_on(entry->btree_id >= BTREE_ID_NR_MAX,
407 c, invalid_btree_id,
408 "invalid btree id %u (max %u)",
409 entry->btree_id, BTREE_ID_NR_MAX))
410 return 0;
411
412 while (entry->btree_id >= c->btree_roots_extra.nr + BTREE_ID_NR) {
413 ret = darray_push(&c->btree_roots_extra, (struct btree_root) { NULL });
414 if (ret)
415 return ret;
416 }
417
418 r = bch2_btree_id_root(c, entry->btree_id);
419
420 if (entry->u64s) {
421 r->level = entry->level;
422 bkey_copy(&r->key, (struct bkey_i *) entry->start);
423 r->error = 0;
424 } else {
425 r->error = -BCH_ERR_btree_node_read_error;
426 }
427 r->alive = true;
428 break;
429 }
430 case BCH_JSET_ENTRY_usage: {
431 struct jset_entry_usage *u =
432 container_of(entry, struct jset_entry_usage, entry);
433
434 switch (entry->btree_id) {
435 case BCH_FS_USAGE_key_version:
436 atomic64_set(&c->key_version, le64_to_cpu(u->v));
437 break;
438 }
439 break;
440 }
441 case BCH_JSET_ENTRY_blacklist: {
442 struct jset_entry_blacklist *bl_entry =
443 container_of(entry, struct jset_entry_blacklist, entry);
444
445 ret = bch2_journal_seq_blacklist_add(c,
446 le64_to_cpu(bl_entry->seq),
447 le64_to_cpu(bl_entry->seq) + 1);
448 break;
449 }
450 case BCH_JSET_ENTRY_blacklist_v2: {
451 struct jset_entry_blacklist_v2 *bl_entry =
452 container_of(entry, struct jset_entry_blacklist_v2, entry);
453
454 ret = bch2_journal_seq_blacklist_add(c,
455 le64_to_cpu(bl_entry->start),
456 le64_to_cpu(bl_entry->end) + 1);
457 break;
458 }
459 case BCH_JSET_ENTRY_clock: {
460 struct jset_entry_clock *clock =
461 container_of(entry, struct jset_entry_clock, entry);
462
463 atomic64_set(&c->io_clock[clock->rw].now, le64_to_cpu(clock->time));
464 }
465 }
466 fsck_err:
467 return ret;
468 }
469
journal_replay_early(struct bch_fs * c,struct bch_sb_field_clean * clean)470 static int journal_replay_early(struct bch_fs *c,
471 struct bch_sb_field_clean *clean)
472 {
473 if (clean) {
474 for (struct jset_entry *entry = clean->start;
475 entry != vstruct_end(&clean->field);
476 entry = vstruct_next(entry)) {
477 int ret = journal_replay_entry_early(c, entry);
478 if (ret)
479 return ret;
480 }
481 } else {
482 struct genradix_iter iter;
483 struct journal_replay *i, **_i;
484
485 genradix_for_each(&c->journal_entries, iter, _i) {
486 i = *_i;
487
488 if (journal_replay_ignore(i))
489 continue;
490
491 vstruct_for_each(&i->j, entry) {
492 int ret = journal_replay_entry_early(c, entry);
493 if (ret)
494 return ret;
495 }
496 }
497 }
498
499 return 0;
500 }
501
502 /* sb clean section: */
503
read_btree_roots(struct bch_fs * c)504 static int read_btree_roots(struct bch_fs *c)
505 {
506 int ret = 0;
507
508 for (unsigned i = 0; i < btree_id_nr_alive(c); i++) {
509 struct btree_root *r = bch2_btree_id_root(c, i);
510
511 if (!r->alive)
512 continue;
513
514 if (btree_id_is_alloc(i) && c->opts.reconstruct_alloc)
515 continue;
516
517 if (mustfix_fsck_err_on((ret = r->error),
518 c, btree_root_bkey_invalid,
519 "invalid btree root %s",
520 bch2_btree_id_str(i)) ||
521 mustfix_fsck_err_on((ret = r->error = bch2_btree_root_read(c, i, &r->key, r->level)),
522 c, btree_root_read_error,
523 "error reading btree root %s l=%u: %s",
524 bch2_btree_id_str(i), r->level, bch2_err_str(ret))) {
525 if (btree_id_is_alloc(i)) {
526 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_allocations);
527 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_alloc_info);
528 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_lrus);
529 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_extents_to_backpointers);
530 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_alloc_to_lru_refs);
531 c->sb.compat &= ~(1ULL << BCH_COMPAT_alloc_info);
532 r->error = 0;
533 } else if (!(c->opts.recovery_passes & BIT_ULL(BCH_RECOVERY_PASS_scan_for_btree_nodes))) {
534 bch_info(c, "will run btree node scan");
535 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_scan_for_btree_nodes);
536 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_topology);
537 }
538
539 ret = 0;
540 bch2_btree_lost_data(c, i);
541 }
542 }
543
544 for (unsigned i = 0; i < BTREE_ID_NR; i++) {
545 struct btree_root *r = bch2_btree_id_root(c, i);
546
547 if (!r->b && !r->error) {
548 r->alive = false;
549 r->level = 0;
550 bch2_btree_root_alloc_fake(c, i, 0);
551 }
552 }
553 fsck_err:
554 return ret;
555 }
556
check_version_upgrade(struct bch_fs * c)557 static bool check_version_upgrade(struct bch_fs *c)
558 {
559 unsigned latest_version = bcachefs_metadata_version_current;
560 unsigned latest_compatible = min(latest_version,
561 bch2_latest_compatible_version(c->sb.version));
562 unsigned old_version = c->sb.version_upgrade_complete ?: c->sb.version;
563 unsigned new_version = 0;
564
565 if (old_version < bcachefs_metadata_required_upgrade_below) {
566 if (c->opts.version_upgrade == BCH_VERSION_UPGRADE_incompatible ||
567 latest_compatible < bcachefs_metadata_required_upgrade_below)
568 new_version = latest_version;
569 else
570 new_version = latest_compatible;
571 } else {
572 switch (c->opts.version_upgrade) {
573 case BCH_VERSION_UPGRADE_compatible:
574 new_version = latest_compatible;
575 break;
576 case BCH_VERSION_UPGRADE_incompatible:
577 new_version = latest_version;
578 break;
579 case BCH_VERSION_UPGRADE_none:
580 new_version = min(old_version, latest_version);
581 break;
582 }
583 }
584
585 if (new_version > old_version) {
586 struct printbuf buf = PRINTBUF;
587
588 if (old_version < bcachefs_metadata_required_upgrade_below)
589 prt_str(&buf, "Version upgrade required:\n");
590
591 if (old_version != c->sb.version) {
592 prt_str(&buf, "Version upgrade from ");
593 bch2_version_to_text(&buf, c->sb.version_upgrade_complete);
594 prt_str(&buf, " to ");
595 bch2_version_to_text(&buf, c->sb.version);
596 prt_str(&buf, " incomplete\n");
597 }
598
599 prt_printf(&buf, "Doing %s version upgrade from ",
600 BCH_VERSION_MAJOR(old_version) != BCH_VERSION_MAJOR(new_version)
601 ? "incompatible" : "compatible");
602 bch2_version_to_text(&buf, old_version);
603 prt_str(&buf, " to ");
604 bch2_version_to_text(&buf, new_version);
605 prt_newline(&buf);
606
607 struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);
608 __le64 passes = ext->recovery_passes_required[0];
609 bch2_sb_set_upgrade(c, old_version, new_version);
610 passes = ext->recovery_passes_required[0] & ~passes;
611
612 if (passes) {
613 prt_str(&buf, " running recovery passes: ");
614 prt_bitflags(&buf, bch2_recovery_passes,
615 bch2_recovery_passes_from_stable(le64_to_cpu(passes)));
616 }
617
618 bch_info(c, "%s", buf.buf);
619
620 bch2_sb_upgrade(c, new_version);
621
622 printbuf_exit(&buf);
623 return true;
624 }
625
626 return false;
627 }
628
bch2_fs_recovery(struct bch_fs * c)629 int bch2_fs_recovery(struct bch_fs *c)
630 {
631 struct bch_sb_field_clean *clean = NULL;
632 struct jset *last_journal_entry = NULL;
633 u64 last_seq = 0, blacklist_seq, journal_seq;
634 int ret = 0;
635
636 if (c->sb.clean) {
637 clean = bch2_read_superblock_clean(c);
638 ret = PTR_ERR_OR_ZERO(clean);
639 if (ret)
640 goto err;
641
642 bch_info(c, "recovering from clean shutdown, journal seq %llu",
643 le64_to_cpu(clean->journal_seq));
644 } else {
645 bch_info(c, "recovering from unclean shutdown");
646 }
647
648 if (!(c->sb.features & (1ULL << BCH_FEATURE_new_extent_overwrite))) {
649 bch_err(c, "feature new_extent_overwrite not set, filesystem no longer supported");
650 ret = -EINVAL;
651 goto err;
652 }
653
654 if (!c->sb.clean &&
655 !(c->sb.features & (1ULL << BCH_FEATURE_extents_above_btree_updates))) {
656 bch_err(c, "filesystem needs recovery from older version; run fsck from older bcachefs-tools to fix");
657 ret = -EINVAL;
658 goto err;
659 }
660
661 if (c->opts.norecovery)
662 c->opts.recovery_pass_last = BCH_RECOVERY_PASS_journal_replay - 1;
663
664 mutex_lock(&c->sb_lock);
665 struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);
666 bool write_sb = false;
667
668 if (BCH_SB_HAS_TOPOLOGY_ERRORS(c->disk_sb.sb)) {
669 ext->recovery_passes_required[0] |=
670 cpu_to_le64(bch2_recovery_passes_to_stable(BIT_ULL(BCH_RECOVERY_PASS_check_topology)));
671 write_sb = true;
672 }
673
674 u64 sb_passes = bch2_recovery_passes_from_stable(le64_to_cpu(ext->recovery_passes_required[0]));
675 if (sb_passes) {
676 struct printbuf buf = PRINTBUF;
677 prt_str(&buf, "superblock requires following recovery passes to be run:\n ");
678 prt_bitflags(&buf, bch2_recovery_passes, sb_passes);
679 bch_info(c, "%s", buf.buf);
680 printbuf_exit(&buf);
681 }
682
683 if (bch2_check_version_downgrade(c)) {
684 struct printbuf buf = PRINTBUF;
685
686 prt_str(&buf, "Version downgrade required:");
687
688 __le64 passes = ext->recovery_passes_required[0];
689 bch2_sb_set_downgrade(c,
690 BCH_VERSION_MINOR(bcachefs_metadata_version_current),
691 BCH_VERSION_MINOR(c->sb.version));
692 passes = ext->recovery_passes_required[0] & ~passes;
693 if (passes) {
694 prt_str(&buf, "\n running recovery passes: ");
695 prt_bitflags(&buf, bch2_recovery_passes,
696 bch2_recovery_passes_from_stable(le64_to_cpu(passes)));
697 }
698
699 bch_info(c, "%s", buf.buf);
700 printbuf_exit(&buf);
701 write_sb = true;
702 }
703
704 if (check_version_upgrade(c))
705 write_sb = true;
706
707 c->opts.recovery_passes |= bch2_recovery_passes_from_stable(le64_to_cpu(ext->recovery_passes_required[0]));
708
709 if (write_sb)
710 bch2_write_super(c);
711 mutex_unlock(&c->sb_lock);
712
713 if (c->opts.fsck && IS_ENABLED(CONFIG_BCACHEFS_DEBUG))
714 c->opts.recovery_passes |= BIT_ULL(BCH_RECOVERY_PASS_check_topology);
715
716 if (c->opts.fsck)
717 set_bit(BCH_FS_fsck_running, &c->flags);
718 if (c->sb.clean)
719 set_bit(BCH_FS_clean_recovery, &c->flags);
720
721 ret = bch2_blacklist_table_initialize(c);
722 if (ret) {
723 bch_err(c, "error initializing blacklist table");
724 goto err;
725 }
726
727 bch2_journal_pos_from_member_info_resume(c);
728
729 if (!c->sb.clean || c->opts.retain_recovery_info) {
730 struct genradix_iter iter;
731 struct journal_replay **i;
732
733 bch_verbose(c, "starting journal read");
734 ret = bch2_journal_read(c, &last_seq, &blacklist_seq, &journal_seq);
735 if (ret)
736 goto err;
737
738 /*
739 * note: cmd_list_journal needs the blacklist table fully up to date so
740 * it can asterisk ignored journal entries:
741 */
742 if (c->opts.read_journal_only)
743 goto out;
744
745 genradix_for_each_reverse(&c->journal_entries, iter, i)
746 if (!journal_replay_ignore(*i)) {
747 last_journal_entry = &(*i)->j;
748 break;
749 }
750
751 if (mustfix_fsck_err_on(c->sb.clean &&
752 last_journal_entry &&
753 !journal_entry_empty(last_journal_entry), c,
754 clean_but_journal_not_empty,
755 "filesystem marked clean but journal not empty")) {
756 c->sb.compat &= ~(1ULL << BCH_COMPAT_alloc_info);
757 SET_BCH_SB_CLEAN(c->disk_sb.sb, false);
758 c->sb.clean = false;
759 }
760
761 if (!last_journal_entry) {
762 fsck_err_on(!c->sb.clean, c,
763 dirty_but_no_journal_entries,
764 "no journal entries found");
765 if (clean)
766 goto use_clean;
767
768 genradix_for_each_reverse(&c->journal_entries, iter, i)
769 if (*i) {
770 last_journal_entry = &(*i)->j;
771 (*i)->ignore_blacklisted = false;
772 (*i)->ignore_not_dirty= false;
773 /*
774 * This was probably a NO_FLUSH entry,
775 * so last_seq was garbage - but we know
776 * we're only using a single journal
777 * entry, set it here:
778 */
779 (*i)->j.last_seq = (*i)->j.seq;
780 break;
781 }
782 }
783
784 ret = bch2_journal_keys_sort(c);
785 if (ret)
786 goto err;
787
788 if (c->sb.clean && last_journal_entry) {
789 ret = bch2_verify_superblock_clean(c, &clean,
790 last_journal_entry);
791 if (ret)
792 goto err;
793 }
794 } else {
795 use_clean:
796 if (!clean) {
797 bch_err(c, "no superblock clean section found");
798 ret = -BCH_ERR_fsck_repair_impossible;
799 goto err;
800
801 }
802 blacklist_seq = journal_seq = le64_to_cpu(clean->journal_seq) + 1;
803 }
804
805 c->journal_replay_seq_start = last_seq;
806 c->journal_replay_seq_end = blacklist_seq - 1;
807
808 if (c->opts.reconstruct_alloc)
809 bch2_reconstruct_alloc(c);
810
811 zero_out_btree_mem_ptr(&c->journal_keys);
812
813 ret = journal_replay_early(c, clean);
814 if (ret)
815 goto err;
816
817 /*
818 * After an unclean shutdown, skip then next few journal sequence
819 * numbers as they may have been referenced by btree writes that
820 * happened before their corresponding journal writes - those btree
821 * writes need to be ignored, by skipping and blacklisting the next few
822 * journal sequence numbers:
823 */
824 if (!c->sb.clean)
825 journal_seq += 8;
826
827 if (blacklist_seq != journal_seq) {
828 ret = bch2_journal_log_msg(c, "blacklisting entries %llu-%llu",
829 blacklist_seq, journal_seq) ?:
830 bch2_journal_seq_blacklist_add(c,
831 blacklist_seq, journal_seq);
832 if (ret) {
833 bch_err_msg(c, ret, "error creating new journal seq blacklist entry");
834 goto err;
835 }
836 }
837
838 ret = bch2_journal_log_msg(c, "starting journal at entry %llu, replaying %llu-%llu",
839 journal_seq, last_seq, blacklist_seq - 1) ?:
840 bch2_fs_journal_start(&c->journal, journal_seq);
841 if (ret)
842 goto err;
843
844 /*
845 * Skip past versions that might have possibly been used (as nonces),
846 * but hadn't had their pointers written:
847 */
848 if (c->sb.encryption_type && !c->sb.clean)
849 atomic64_add(1 << 16, &c->key_version);
850
851 ret = read_btree_roots(c);
852 if (ret)
853 goto err;
854
855 set_bit(BCH_FS_btree_running, &c->flags);
856
857 ret = bch2_sb_set_upgrade_extra(c);
858
859 ret = bch2_run_recovery_passes(c);
860 if (ret)
861 goto err;
862
863 /*
864 * Normally set by the appropriate recovery pass: when cleared, this
865 * indicates we're in early recovery and btree updates should be done by
866 * being applied to the journal replay keys. _Must_ be cleared before
867 * multithreaded use:
868 */
869 set_bit(BCH_FS_may_go_rw, &c->flags);
870 clear_bit(BCH_FS_fsck_running, &c->flags);
871
872 /* in case we don't run journal replay, i.e. norecovery mode */
873 set_bit(BCH_FS_accounting_replay_done, &c->flags);
874
875 /* fsync if we fixed errors */
876 if (test_bit(BCH_FS_errors_fixed, &c->flags) &&
877 bch2_write_ref_tryget(c, BCH_WRITE_REF_fsync)) {
878 bch2_journal_flush_all_pins(&c->journal);
879 bch2_journal_meta(&c->journal);
880 bch2_write_ref_put(c, BCH_WRITE_REF_fsync);
881 }
882
883 /* If we fixed errors, verify that fs is actually clean now: */
884 if (IS_ENABLED(CONFIG_BCACHEFS_DEBUG) &&
885 test_bit(BCH_FS_errors_fixed, &c->flags) &&
886 !test_bit(BCH_FS_errors_not_fixed, &c->flags) &&
887 !test_bit(BCH_FS_error, &c->flags)) {
888 bch2_flush_fsck_errs(c);
889
890 bch_info(c, "Fixed errors, running fsck a second time to verify fs is clean");
891 clear_bit(BCH_FS_errors_fixed, &c->flags);
892
893 c->curr_recovery_pass = BCH_RECOVERY_PASS_check_alloc_info;
894
895 ret = bch2_run_recovery_passes(c);
896 if (ret)
897 goto err;
898
899 if (test_bit(BCH_FS_errors_fixed, &c->flags) ||
900 test_bit(BCH_FS_errors_not_fixed, &c->flags)) {
901 bch_err(c, "Second fsck run was not clean");
902 set_bit(BCH_FS_errors_not_fixed, &c->flags);
903 }
904
905 set_bit(BCH_FS_errors_fixed, &c->flags);
906 }
907
908 if (enabled_qtypes(c)) {
909 bch_verbose(c, "reading quotas");
910 ret = bch2_fs_quota_read(c);
911 if (ret)
912 goto err;
913 bch_verbose(c, "quotas done");
914 }
915
916 mutex_lock(&c->sb_lock);
917 ext = bch2_sb_field_get(c->disk_sb.sb, ext);
918 write_sb = false;
919
920 if (BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb) != le16_to_cpu(c->disk_sb.sb->version)) {
921 SET_BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb, le16_to_cpu(c->disk_sb.sb->version));
922 write_sb = true;
923 }
924
925 if (!test_bit(BCH_FS_error, &c->flags) &&
926 !(c->disk_sb.sb->compat[0] & cpu_to_le64(1ULL << BCH_COMPAT_alloc_info))) {
927 c->disk_sb.sb->compat[0] |= cpu_to_le64(1ULL << BCH_COMPAT_alloc_info);
928 write_sb = true;
929 }
930
931 if (!test_bit(BCH_FS_error, &c->flags) &&
932 !bch2_is_zero(ext->errors_silent, sizeof(ext->errors_silent))) {
933 memset(ext->errors_silent, 0, sizeof(ext->errors_silent));
934 write_sb = true;
935 }
936
937 if (c->opts.fsck &&
938 !test_bit(BCH_FS_error, &c->flags) &&
939 c->recovery_pass_done == BCH_RECOVERY_PASS_NR - 1 &&
940 ext->btrees_lost_data) {
941 ext->btrees_lost_data = 0;
942 write_sb = true;
943 }
944
945 if (c->opts.fsck &&
946 !test_bit(BCH_FS_error, &c->flags) &&
947 !test_bit(BCH_FS_errors_not_fixed, &c->flags)) {
948 SET_BCH_SB_HAS_ERRORS(c->disk_sb.sb, 0);
949 SET_BCH_SB_HAS_TOPOLOGY_ERRORS(c->disk_sb.sb, 0);
950 write_sb = true;
951 }
952
953 if (bch2_blacklist_entries_gc(c))
954 write_sb = true;
955
956 if (write_sb)
957 bch2_write_super(c);
958 mutex_unlock(&c->sb_lock);
959
960 if (!(c->sb.compat & (1ULL << BCH_COMPAT_extents_above_btree_updates_done)) ||
961 c->sb.version_min < bcachefs_metadata_version_btree_ptr_sectors_written) {
962 struct bch_move_stats stats;
963
964 bch2_move_stats_init(&stats, "recovery");
965
966 struct printbuf buf = PRINTBUF;
967 bch2_version_to_text(&buf, c->sb.version_min);
968 bch_info(c, "scanning for old btree nodes: min_version %s", buf.buf);
969 printbuf_exit(&buf);
970
971 ret = bch2_fs_read_write_early(c) ?:
972 bch2_scan_old_btree_nodes(c, &stats);
973 if (ret)
974 goto err;
975 bch_info(c, "scanning for old btree nodes done");
976 }
977
978 ret = 0;
979 out:
980 bch2_flush_fsck_errs(c);
981
982 if (!c->opts.retain_recovery_info) {
983 bch2_journal_keys_put_initial(c);
984 bch2_find_btree_nodes_exit(&c->found_btree_nodes);
985 }
986 if (!IS_ERR(clean))
987 kfree(clean);
988
989 if (!ret &&
990 test_bit(BCH_FS_need_delete_dead_snapshots, &c->flags) &&
991 !c->opts.nochanges) {
992 bch2_fs_read_write_early(c);
993 bch2_delete_dead_snapshots_async(c);
994 }
995
996 bch_err_fn(c, ret);
997 return ret;
998 err:
999 fsck_err:
1000 bch2_fs_emergency_read_only(c);
1001 goto out;
1002 }
1003
bch2_fs_initialize(struct bch_fs * c)1004 int bch2_fs_initialize(struct bch_fs *c)
1005 {
1006 struct bch_inode_unpacked root_inode, lostfound_inode;
1007 struct bkey_inode_buf packed_inode;
1008 struct qstr lostfound = QSTR("lost+found");
1009 struct bch_member *m;
1010 int ret;
1011
1012 bch_notice(c, "initializing new filesystem");
1013 set_bit(BCH_FS_new_fs, &c->flags);
1014
1015 mutex_lock(&c->sb_lock);
1016 c->disk_sb.sb->compat[0] |= cpu_to_le64(1ULL << BCH_COMPAT_extents_above_btree_updates_done);
1017 c->disk_sb.sb->compat[0] |= cpu_to_le64(1ULL << BCH_COMPAT_bformat_overflow_done);
1018
1019 bch2_check_version_downgrade(c);
1020
1021 if (c->opts.version_upgrade != BCH_VERSION_UPGRADE_none) {
1022 bch2_sb_upgrade(c, bcachefs_metadata_version_current);
1023 SET_BCH_SB_VERSION_UPGRADE_COMPLETE(c->disk_sb.sb, bcachefs_metadata_version_current);
1024 bch2_write_super(c);
1025 }
1026
1027 for_each_member_device(c, ca) {
1028 m = bch2_members_v2_get_mut(c->disk_sb.sb, ca->dev_idx);
1029 SET_BCH_MEMBER_FREESPACE_INITIALIZED(m, false);
1030 ca->mi = bch2_mi_to_cpu(m);
1031 }
1032
1033 bch2_write_super(c);
1034 mutex_unlock(&c->sb_lock);
1035
1036 c->curr_recovery_pass = BCH_RECOVERY_PASS_NR;
1037 set_bit(BCH_FS_btree_running, &c->flags);
1038 set_bit(BCH_FS_may_go_rw, &c->flags);
1039
1040 for (unsigned i = 0; i < BTREE_ID_NR; i++)
1041 bch2_btree_root_alloc_fake(c, i, 0);
1042
1043 ret = bch2_fs_journal_alloc(c);
1044 if (ret)
1045 goto err;
1046
1047 /*
1048 * journal_res_get() will crash if called before this has
1049 * set up the journal.pin FIFO and journal.cur pointer:
1050 */
1051 bch2_fs_journal_start(&c->journal, 1);
1052 set_bit(BCH_FS_accounting_replay_done, &c->flags);
1053 bch2_journal_set_replay_done(&c->journal);
1054
1055 ret = bch2_fs_read_write_early(c);
1056 if (ret)
1057 goto err;
1058
1059 for_each_member_device(c, ca) {
1060 ret = bch2_dev_usage_init(ca, false);
1061 if (ret) {
1062 bch2_dev_put(ca);
1063 goto err;
1064 }
1065 }
1066
1067 /*
1068 * Write out the superblock and journal buckets, now that we can do
1069 * btree updates
1070 */
1071 bch_verbose(c, "marking superblocks");
1072 ret = bch2_trans_mark_dev_sbs(c);
1073 bch_err_msg(c, ret, "marking superblocks");
1074 if (ret)
1075 goto err;
1076
1077 for_each_online_member(c, ca)
1078 ca->new_fs_bucket_idx = 0;
1079
1080 ret = bch2_fs_freespace_init(c);
1081 if (ret)
1082 goto err;
1083
1084 ret = bch2_initialize_subvolumes(c);
1085 if (ret)
1086 goto err;
1087
1088 bch_verbose(c, "reading snapshots table");
1089 ret = bch2_snapshots_read(c);
1090 if (ret)
1091 goto err;
1092 bch_verbose(c, "reading snapshots done");
1093
1094 bch2_inode_init(c, &root_inode, 0, 0, S_IFDIR|0755, 0, NULL);
1095 root_inode.bi_inum = BCACHEFS_ROOT_INO;
1096 root_inode.bi_subvol = BCACHEFS_ROOT_SUBVOL;
1097 bch2_inode_pack(&packed_inode, &root_inode);
1098 packed_inode.inode.k.p.snapshot = U32_MAX;
1099
1100 ret = bch2_btree_insert(c, BTREE_ID_inodes, &packed_inode.inode.k_i, NULL, 0, 0);
1101 bch_err_msg(c, ret, "creating root directory");
1102 if (ret)
1103 goto err;
1104
1105 bch2_inode_init_early(c, &lostfound_inode);
1106
1107 ret = bch2_trans_commit_do(c, NULL, NULL, 0,
1108 bch2_create_trans(trans,
1109 BCACHEFS_ROOT_SUBVOL_INUM,
1110 &root_inode, &lostfound_inode,
1111 &lostfound,
1112 0, 0, S_IFDIR|0700, 0,
1113 NULL, NULL, (subvol_inum) { 0 }, 0));
1114 bch_err_msg(c, ret, "creating lost+found");
1115 if (ret)
1116 goto err;
1117
1118 c->recovery_pass_done = BCH_RECOVERY_PASS_NR - 1;
1119
1120 if (enabled_qtypes(c)) {
1121 ret = bch2_fs_quota_read(c);
1122 if (ret)
1123 goto err;
1124 }
1125
1126 ret = bch2_journal_flush(&c->journal);
1127 bch_err_msg(c, ret, "writing first journal entry");
1128 if (ret)
1129 goto err;
1130
1131 mutex_lock(&c->sb_lock);
1132 SET_BCH_SB_INITIALIZED(c->disk_sb.sb, true);
1133 SET_BCH_SB_CLEAN(c->disk_sb.sb, false);
1134
1135 bch2_write_super(c);
1136 mutex_unlock(&c->sb_lock);
1137
1138 return 0;
1139 err:
1140 bch_err_fn(c, ret);
1141 return ret;
1142 }
1143