Runtime self healing for missing backpointers
cover Runtime self healing for missing backpointers
Post 6.14 upgrade, there have been some reports of copygc spinning without making any progress, where it turns out it's been attempting to evacuate buckets with missing backpointers.
6.14 made backpointers fsck much faster, partly by deferring the "does this backpointer point to a matching extent" checks until backpointers are used. This means that bad backpointers that haven't yet been cleaned up can cause the "sum up backpointers in a bucket to check if we need to scan for missing backpointers" code to not detect missing backpointers.
Doh.
The solution is to re-run the "do backpointers in a bucket sum up to the bucket sector counts?" checks _after_ we've walked backpointers in a bucket at runtime, by codepaths that use backpointer_get_key() - e.g. move_data_phys. backpointer_get_key() will have then cleaned up bad backpointers, and if there are any missing backpointers we'll be able to reliably detect them.
Note that the "do backpointers sum up to bucket sector counts" check is quite cheap to do at runtime, particularly here where we've just touched these keys.
Then, if we do detect missing backpointers, we can kick off check_extents_to_backpointers. This is also much cheaper than it used to be, since the scan only walks extent -> backpointer for buckets that we know have missing backpointers.
Most of the patch series is the new infrastructure for running recovery passes automatically and asynchronously. We'll be using this for more things in the future, as other recovery passes become online passes - this is one of the last missing pieces for "full runtime self healing from anything".
To avoid unfortunate situations where something is triggering a recovery pass continuously, there's ratelimiting, using the new superblock section for "runtime, time of last run" for each recovery pass. Copygc doesn't need to be able to evacuate any given bucket right away, it can wait until a moderate percentage of buckets have missing backpointers before kicking it off.
Kent Overstreet (8):
bcachefs: struct bch_fs_recovery
bcachefs: __bch2_run_recovery_passes()
bcachefs: Reduce usage of recovery.curr_pass
bcachefs: bch2_recovery_pass_status_to_text()
bcachefs: bch2_run_explicit_recovery_pass() cleanup
bcachefs: Run recovery passes asynchronously
bcachefs: Improve bucket_bitmap code
bcachefs: bch2_check_bucket_backpointer_mismatch()
fs/bcachefs/alloc_background.c | 10 +- fs/bcachefs/alloc_foreground.c | 6 +- fs/bcachefs/backpointers.c | 197 +++++++++---- fs/bcachefs/backpointers.h | 10 +- fs/bcachefs/bcachefs.h | 23 +- fs/bcachefs/btree_cache.c | 2 +- fs/bcachefs/btree_io.c | 7 +- fs/bcachefs/btree_node_scan.c | 2 +- fs/bcachefs/btree_update_interior.c | 2 +- fs/bcachefs/buckets.c | 33 +-- fs/bcachefs/errcode.h | 1 - fs/bcachefs/error.c | 2 +- fs/bcachefs/fsck.c | 9 +- fs/bcachefs/move.c | 21 +- fs/bcachefs/movinggc.c | 11 +- fs/bcachefs/rebalance.c | 2 +- fs/bcachefs/recovery.c | 46 ++- fs/bcachefs/recovery_passes.c | 431 ++++++++++++++++++---------- fs/bcachefs/recovery_passes.h | 23 +- fs/bcachefs/recovery_passes_types.h | 27 ++ fs/bcachefs/sb-members.c | 4 +- fs/bcachefs/snapshot.c | 4 +- fs/bcachefs/subvolume.c | 6 +- fs/bcachefs/super.c | 10 +- fs/bcachefs/sysfs.c | 6 + 25 files changed, 579 insertions(+), 316 deletions(-) create mode 100644 fs/bcachefs/recovery_passes_types.h
Signature · 1 line
2.49.0
PATCH 1/8 bcachefs: struct bch_fs_recovery
bch_fs has gotten obnoxiously big, let's start organizing thins a bit better.
--- fs/bcachefs/alloc_background.c | 2 +- fs/bcachefs/alloc_foreground.c | 6 +-- fs/bcachefs/backpointers.c | 4 +- fs/bcachefs/bcachefs.h | 17 +------- fs/bcachefs/btree_cache.c | 2 +- fs/bcachefs/btree_io.c | 6 +-- fs/bcachefs/btree_update_interior.c | 2 +- fs/bcachefs/fsck.c | 8 ++-- fs/bcachefs/movinggc.c | 2 +- fs/bcachefs/rebalance.c | 2 +- fs/bcachefs/recovery.c | 10 ++--- fs/bcachefs/recovery_passes.c | 60 +++++++++++++++-------------- fs/bcachefs/recovery_passes_types.h | 23 +++++++++++ fs/bcachefs/snapshot.c | 4 +- fs/bcachefs/super.c | 2 +- 15 files changed, 81 insertions(+), 69 deletions(-) create mode 100644 fs/bcachefs/recovery_passes_types.h
fs/bcachefs/alloc_background.c +1 -1
@@ -309,7 +309,7 @@ int bch2_alloc_v4_validate(struct bch_fs *c, struct bkey_s_c k, "data type inconsistency");bkey_fsck_err_on (!a.io_time[READ ] && - c->curr_recovery_pass > BCH_RECOVERY_PASS_check_alloc_to_lru_refs, + c->recovery.curr_pass > BCH_RECOVERY_PASS_check_alloc_to_lru_refs, c, alloc_key_cached_but_read_time_zero,"cached bucket with read_time == 0" );break ;
fs/bcachefs/alloc_foreground.c +3 -3
@@ -154,7 +154,7 @@ static struct open_bucket *bch2_open_bucket_alloc(struct bch_fs *c)static inline bool is_superblock_bucket (struct bch_fs *c,struct bch_dev *ca,u64 b) { -if (c->curr_recovery_pass > BCH_RECOVERY_PASS_trans_mark_dev_sbs) +if (c->recovery.curr_pass > BCH_RECOVERY_PASS_trans_mark_dev_sbs)return false;return bch2_is_superblock_bucket (ca, b);
@@ -524,7 +524,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans,if (!avail) {if (req->watermark > BCH_WATERMARK_normal && - c->curr_recovery_pass <= BCH_RECOVERY_PASS_check_allocations) + c->recovery.curr_pass <= BCH_RECOVERY_PASS_check_allocations) goto alloc;if (cl && !waiting) {
@@ -554,7 +554,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans, goto alloc; } -if (!ob && freespace && c->curr_recovery_pass <= BCH_RECOVERY_PASS_check_alloc_info) { +if (!ob && freespace && c->recovery.curr_pass <= BCH_RECOVERY_PASS_check_alloc_info) { freespace = false; goto alloc; }
fs/bcachefs/backpointers.c +2 -2
@@ -120,7 +120,7 @@ static noinline int backpointer_mod_err(struct btree_trans *trans,bch2_bkey_val_to_text (&buf, c, orig_k);bch_err (c,"%s" , buf.buf); - }else if (c->curr_recovery_pass > BCH_RECOVERY_PASS_check_extents_to_backpointers) { + }else if (c->recovery.curr_pass > BCH_RECOVERY_PASS_check_extents_to_backpointers) {prt_printf (&buf,"backpointer not found when deleting\n" );printbuf_indent_add (&buf,2 );
@@ -136,7 +136,7 @@ static noinline int backpointer_mod_err(struct btree_trans *trans,bch2_bkey_val_to_text (&buf, c, orig_k); } -if (c->curr_recovery_pass > BCH_RECOVERY_PASS_check_extents_to_backpointers && +if (c->recovery.curr_pass > BCH_RECOVERY_PASS_check_extents_to_backpointers &&__bch2_inconsistent_error (c, &buf)) ret = -BCH_ERR_erofs_unfixed_errors;
fs/bcachefs/bcachefs.h +2 -15
@@ -502,6 +502,7 @@ enum bch_time_stats {#include "keylist_types.h" #include "quota_types.h" #include "rebalance_types.h" +#include "recovery_passes_types.h" #include "replicas_types.h" #include "sb-members_types.h" #include "subvolume_types.h"
@@ -1116,21 +1117,7 @@ struct bch_fs {/* RECOVERY */ u64 journal_replay_seq_start;u64 journal_replay_seq_end; -/* -* Two different uses: -* "Has this fsck pass?" - i.e. should this type of error be an -* emergency read-only -* And, in certain situations fsck will rewind to an earlier pass: used -* for signaling to the toplevel code which pass we want to run now. -*/ -enum bch_recovery_pass curr_recovery_pass; -enum bch_recovery_pass next_recovery_pass; -/* bitmask of recovery passes that we actually ran */ -u64 recovery_passes_complete; -/* never rewinds version of curr_recovery_pass */ -enum bch_recovery_pass recovery_pass_done; -spinlock_t recovery_pass_lock; -struct semaphore run_recovery_passes_lock; +struct bch_fs_recovery recovery;/* DEBUG JUNK */ struct dentry *fs_debug_dir;
fs/bcachefs/btree_cache.c +1 -1
@@ -1019,7 +1019,7 @@ static noinline void btree_bad_header(struct bch_fs *c, struct btree *b) {struct printbuf buf =PRINTBUF ; -if (c->curr_recovery_pass <= BCH_RECOVERY_PASS_check_allocations) +if (c->recovery.curr_pass <= BCH_RECOVERY_PASS_check_allocations)return ; prt_printf(&buf,
fs/bcachefs/btree_io.c +3 -3
@@ -556,7 +556,7 @@ static int __btree_err(int ret,struct printbuf *err_msg, const char *fmt, ...) { - if (c->curr_recovery_pass == BCH_RECOVERY_PASS_scan_for_btree_nodes) + if (c->recovery.curr_pass == BCH_RECOVERY_PASS_scan_for_btree_nodes) return -BCH_ERR_fsck_fix;bool have_retry = false;
@@ -1428,7 +1428,7 @@ static void btree_node_read_work(struct work_struct *work)if ((failed.nr ||btree_node_need_rewrite (b)) && !btree_node_read_error (b) && - c->curr_recovery_pass != BCH_RECOVERY_PASS_scan_for_btree_nodes) { + c->recovery.curr_pass != BCH_RECOVERY_PASS_scan_for_btree_nodes) {prt_printf (&buf," (rewriting node)" );bch2_btree_node_rewrite_async (c, b); }
@@ -1776,7 +1776,7 @@ void bch2_btree_node_read(struct btree_trans *trans, struct btree *b,bch2_btree_lost_data (c, &buf, b->c.btree_id);if (c->opts.recovery_passes &BIT_ULL (BCH_RECOVERY_PASS_check_topology) && - c->curr_recovery_pass > BCH_RECOVERY_PASS_check_topology && + c->recovery.curr_pass > BCH_RECOVERY_PASS_check_topology &&bch2_fs_emergency_read_only2 (c, &buf)) ratelimit = false;
fs/bcachefs/btree_update_interior.c +1 -1
@@ -2363,7 +2363,7 @@ void bch2_btree_node_rewrite_async(struct bch_fs *c, struct btree *b)bool now = false, pending = false;spin_lock (&c->btree_node_rewrites_lock); -if (c->curr_recovery_pass > BCH_RECOVERY_PASS_journal_replay && +if (c->recovery.curr_pass > BCH_RECOVERY_PASS_journal_replay &&enumerated_ref_tryget (&c->writes, BCH_WRITE_REF_node_rewrite)) {list_add (&a->list, &c->btree_node_rewrites); now = true;
fs/bcachefs/fsck.c +4 -4
@@ -3140,7 +3140,7 @@ static int bch2_fsck_online_thread_fn(struct thread_with_stdio *stdio) c->opts.fsck = true;set_bit (BCH_FS_in_fsck, &c->flags); - c->curr_recovery_pass = BCH_RECOVERY_PASS_check_alloc_info; + c->recovery.curr_pass = BCH_RECOVERY_PASS_check_alloc_info;int ret =bch2_run_online_recovery_passes (c);clear_bit (BCH_FS_in_fsck, &c->flags);
@@ -3150,7 +3150,7 @@ static int bch2_fsck_online_thread_fn(struct thread_with_stdio *stdio) c->stdio_filter =NULL ; c->opts.fix_errors = old_fix_errors; -up (&c->run_recovery_passes_lock); +up (&c->recovery.run_lock);bch2_ro_ref_put (c);return ret; }
@@ -3174,7 +3174,7 @@ long bch2_ioctl_fsck_online(struct bch_fs *c, struct bch_ioctl_fsck_online arg)if (!bch2_ro_ref_tryget (c))return -EROFS ; -if (down_trylock (&c->run_recovery_passes_lock)) { +if (down_trylock (&c->recovery.run_lock)) {bch2_ro_ref_put (c);return -EAGAIN ; }
@@ -3206,7 +3206,7 @@ long bch2_ioctl_fsck_online(struct bch_fs *c, struct bch_ioctl_fsck_online arg)bch_err_fn (c, ret);if (thr)bch2_fsck_thread_exit (&thr->thr); -up (&c->run_recovery_passes_lock); +up (&c->recovery.run_lock);bch2_ro_ref_put (c); }return ret;
fs/bcachefs/movinggc.c +1 -1
@@ -362,7 +362,7 @@ static int bch2_copygc_thread(void *arg)* Data move operations can't run until after check_snapshots has * completed, and bch2_snapshot_is_ancestor() is available. */ -kthread_wait_freezable (c->recovery_pass_done > BCH_RECOVERY_PASS_check_snapshots || +kthread_wait_freezable (c->recovery.pass_done > BCH_RECOVERY_PASS_check_snapshots ||kthread_should_stop ());bch2_move_stats_init (&move_stats,"copygc" );
fs/bcachefs/rebalance.c +1 -1
@@ -616,7 +616,7 @@ static int bch2_rebalance_thread(void *arg)* Data move operations can't run until after check_snapshots has * completed, and bch2_snapshot_is_ancestor() is available. */ -kthread_wait_freezable (c->recovery_pass_done > BCH_RECOVERY_PASS_check_snapshots || +kthread_wait_freezable (c->recovery.pass_done > BCH_RECOVERY_PASS_check_snapshots ||kthread_should_stop ()); bch2_moving_ctxt_init(&ctxt, c, NULL, &r->work_stats,
fs/bcachefs/recovery.c +5 -5
@@ -434,7 +434,7 @@ int bch2_journal_replay(struct bch_fs *c) trans =NULL ;if (!c->opts.retain_recovery_info && - c->recovery_pass_done >= BCH_RECOVERY_PASS_journal_replay) + c->recovery.pass_done >= BCH_RECOVERY_PASS_journal_replay)bch2_journal_keys_put_initial (c);replay_now_at (j, j->replay_journal_seq_end);
@@ -1001,7 +1001,7 @@ int bch2_fs_recovery(struct bch_fs *c)bch_info (c,"Fixed errors, running fsck a second time to verify fs is clean" );clear_bit (BCH_FS_errors_fixed, &c->flags); - c->curr_recovery_pass = BCH_RECOVERY_PASS_check_alloc_info; + c->recovery.curr_pass = BCH_RECOVERY_PASS_check_alloc_info; ret =bch2_run_recovery_passes (c);if (ret)
@@ -1047,7 +1047,7 @@ int bch2_fs_recovery(struct bch_fs *c)if (c->opts.fsck && !test_bit (BCH_FS_error, &c->flags) && - c->recovery_pass_done ==BCH_RECOVERY_PASS_NR -1 && + c->recovery.pass_done ==BCH_RECOVERY_PASS_NR -1 && ext->btrees_lost_data) { ext->btrees_lost_data =0 ; write_sb = true;
@@ -1234,7 +1234,7 @@ int bch2_fs_initialize(struct bch_fs *c)if (ret) goto err; - c->recovery_pass_done =BCH_RECOVERY_PASS_NR -1 ; + c->recovery.pass_done =BCH_RECOVERY_PASS_NR -1 ;bch2_copygc_wakeup (c);bch2_rebalance_wakeup (c);
@@ -1257,7 +1257,7 @@ int bch2_fs_initialize(struct bch_fs *c)bch2_write_super (c);mutex_unlock (&c->sb_lock); - c->curr_recovery_pass =BCH_RECOVERY_PASS_NR ; + c->recovery.curr_pass =BCH_RECOVERY_PASS_NR ;return 0 ; err:bch_err_fn (c, ret);
fs/bcachefs/recovery_passes.c +31 -29
133 lines not on this page · raw message
fs/bcachefs/recovery_passes_types.h new file +23 -0
@@ -0,0 +1,23 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _BCACHEFS_RECOVERY_PASSES_TYPES_H +#define _BCACHEFS_RECOVERY_PASSES_TYPES_H + +struct bch_fs_recovery { +/* +* Two different uses: +* "Has this fsck pass?" - i.e. should this type of error be an +* emergency read-only +* And, in certain situations fsck will rewind to an earlier pass: used +* for signaling to the toplevel code which pass we want to run now. +*/ +enum bch_recovery_pass curr_pass; +enum bch_recovery_pass next_pass; +/* never rewinds version of curr_pass */ +enum bch_recovery_pass pass_done; +/* bitmask of recovery passes that we actually ran */ +u64 passes_complete; +spinlock_t lock; +struct semaphore run_lock; +}; + +#endif /* _BCACHEFS_RECOVERY_PASSES_TYPES_H */
fs/bcachefs/snapshot.c +2 -2
@@ -143,7 +143,7 @@ bool __bch2_snapshot_is_ancestor(struct bch_fs *c, u32 id, u32 ancestor)rcu_read_lock ();struct snapshot_table *t =rcu_dereference (c->snapshots); -if (unlikely (c->recovery_pass_done < BCH_RECOVERY_PASS_check_snapshots)) { +if (unlikely (c->recovery.pass_done < BCH_RECOVERY_PASS_check_snapshots)) { ret =__bch2_snapshot_is_ancestor_early (t, id, ancestor); goto out; }
@@ -348,7 +348,7 @@ static int __bch2_mark_snapshot(struct btree_trans *trans,if (BCH_SNAPSHOT_WILL_DELETE (s.v)) {set_bit (BCH_FS_need_delete_dead_snapshots, &c->flags); -if (c->curr_recovery_pass > BCH_RECOVERY_PASS_delete_dead_snapshots) +if (c->recovery.curr_pass > BCH_RECOVERY_PASS_delete_dead_snapshots)bch2_delete_dead_snapshots_async (c); } }else {
fs/bcachefs/super.c +1 -1
@@ -392,7 +392,7 @@ void bch2_fs_read_only(struct bch_fs *c) !test_bit(BCH_FS_emergency_ro, &c->flags) && test_bit(BCH_FS_started, &c->flags) && test_bit(BCH_FS_clean_shutdown, &c->flags) && - c->recovery_pass_done >= BCH_RECOVERY_PASS_journal_replay) { + c->recovery.pass_done >= BCH_RECOVERY_PASS_journal_replay) {BUG_ON (c->journal.last_empty_seq !=journal_cur_seq (&c->journal));BUG_ON (atomic_long_read (&c->btree_cache.nr_dirty));BUG_ON (atomic_long_read (&c->btree_key_cache.nr_dirty));
Signature · 1 line
2.49.0
PATCH 2/8 bcachefs: __bch2_run_recovery_passes()
In reply to Kent OverstreetConsolidate bch2_run_recovery_passes() and bch2_run_online_recovery_passes(), prep work for automatically scheduling and running recovery passes in the background.
- Now takes a mask of which passes to run, automatic background repair will pass in sb.recovery_passes_required.
- Skips passes that are failing: a pass that failed may be reattempted after another pass succeeds (some passes depend on repair done by other passes for successful completion).
- bch2_recovery_passes_match() helper to skip alloc passes on a filesystem without alloc info.
--- fs/bcachefs/fsck.c | 2 +- fs/bcachefs/recovery.c | 7 +- fs/bcachefs/recovery_passes.c | 180 +++++++++++++++------------- fs/bcachefs/recovery_passes.h | 4 +- fs/bcachefs/recovery_passes_types.h | 2 + 5 files changed, 104 insertions(+), 91 deletions(-)
fs/bcachefs/fsck.c +1 -1
@@ -3141,7 +3141,7 @@ static int bch2_fsck_online_thread_fn(struct thread_with_stdio *stdio)set_bit (BCH_FS_in_fsck, &c->flags); c->recovery.curr_pass = BCH_RECOVERY_PASS_check_alloc_info; -int ret =bch2_run_online_recovery_passes (c); +int ret =bch2_run_online_recovery_passes (c, ~0ULL );clear_bit (BCH_FS_in_fsck, &c->flags);bch_err_fn (c, ret);
fs/bcachefs/recovery.c +3 -4
@@ -966,7 +966,7 @@ int bch2_fs_recovery(struct bch_fs *c)if (ret) goto err; - ret =bch2_run_recovery_passes (c); + ret =bch2_run_recovery_passes (c,0 );if (ret) goto err;
@@ -1001,9 +1001,8 @@ int bch2_fs_recovery(struct bch_fs *c)bch_info (c,"Fixed errors, running fsck a second time to verify fs is clean" );clear_bit (BCH_FS_errors_fixed, &c->flags); - c->recovery.curr_pass = BCH_RECOVERY_PASS_check_alloc_info; - - ret =bch2_run_recovery_passes (c); + ret =bch2_run_recovery_passes (c, + BCH_RECOVERY_PASS_check_alloc_info);if (ret) goto err;
fs/bcachefs/recovery_passes.c +96 -84
237 lines not on this page · raw message
fs/bcachefs/recovery_passes.h +2 -2
@@ -17,8 +17,8 @@ int __bch2_run_explicit_recovery_pass_persistent(struct bch_fs *, struct printbuint bch2_run_explicit_recovery_pass_persistent (struct bch_fs *,struct printbuf *,enum bch_recovery_pass ); -int bch2_run_online_recovery_passes (struct bch_fs *); -int bch2_run_recovery_passes (struct bch_fs *); +int bch2_run_online_recovery_passes (struct bch_fs *,u64 ); +int bch2_run_recovery_passes (struct bch_fs *,enum bch_recovery_pass );void bch2_fs_recovery_passes_init (struct bch_fs *);
fs/bcachefs/recovery_passes_types.h +2 -0
@@ -14,8 +14,10 @@ struct bch_fs_recovery {enum bch_recovery_pass next_pass;/* never rewinds version of curr_pass */ enum bch_recovery_pass pass_done; +u64 passes_to_run;/* bitmask of recovery passes that we actually ran */ u64 passes_complete; +u64 passes_failing;spinlock_t lock;struct semaphore run_lock; };
Signature · 1 line
2.49.0
PATCH 3/8 bcachefs: Reduce usage of recovery.curr_pass
In reply to Kent OverstreetWe want recovery.curr_pass to be private to the recovery passes code, for better showing recovery pass status; also, it may rewind and is generally not the correct member to use.
--- fs/bcachefs/alloc_background.c | 3 ++- fs/bcachefs/alloc_foreground.c | 6 +++--- fs/bcachefs/backpointers.c | 7 ++++--- fs/bcachefs/btree_cache.c | 2 +- fs/bcachefs/btree_io.c | 3 +-- fs/bcachefs/btree_update_interior.c | 2 +- fs/bcachefs/fsck.c | 1 - fs/bcachefs/snapshot.c | 2 +- 8 files changed, 13 insertions(+), 13 deletions(-)
fs/bcachefs/alloc_background.c +2 -1
@@ -309,7 +309,8 @@ int bch2_alloc_v4_validate(struct bch_fs *c, struct bkey_s_c k, "data type inconsistency");bkey_fsck_err_on (!a.io_time[READ ] && - c->recovery.curr_pass > BCH_RECOVERY_PASS_check_alloc_to_lru_refs, + !(c->recovery.passes_to_run & +BIT_ULL (BCH_RECOVERY_PASS_check_alloc_to_lru_refs)), c, alloc_key_cached_but_read_time_zero,"cached bucket with read_time == 0" );break ;
fs/bcachefs/alloc_foreground.c +3 -3
@@ -154,7 +154,7 @@ static struct open_bucket *bch2_open_bucket_alloc(struct bch_fs *c)static inline bool is_superblock_bucket (struct bch_fs *c,struct bch_dev *ca,u64 b) { -if (c->recovery.curr_pass > BCH_RECOVERY_PASS_trans_mark_dev_sbs) +if (c->recovery.passes_complete &BIT_ULL (BCH_RECOVERY_PASS_trans_mark_dev_sbs))return false;return bch2_is_superblock_bucket (ca, b);
@@ -524,7 +524,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans,if (!avail) {if (req->watermark > BCH_WATERMARK_normal && - c->recovery.curr_pass <= BCH_RECOVERY_PASS_check_allocations) + c->recovery.pass_done < BCH_RECOVERY_PASS_check_allocations) goto alloc;if (cl && !waiting) {
@@ -554,7 +554,7 @@ static struct open_bucket *bch2_bucket_alloc_trans(struct btree_trans *trans, goto alloc; } -if (!ob && freespace && c->recovery.curr_pass <= BCH_RECOVERY_PASS_check_alloc_info) { +if (!ob && freespace && c->recovery.pass_done < BCH_RECOVERY_PASS_check_alloc_info) { freespace = false; goto alloc; }
fs/bcachefs/backpointers.c +4 -3
@@ -104,6 +104,8 @@ static noinline int backpointer_mod_err(struct btree_trans *trans, {struct bch_fs *c = trans->c;struct printbuf buf =PRINTBUF ; +bool will_check = c->recovery.passes_to_run & +BIT_ULL (BCH_RECOVERY_PASS_check_extents_to_backpointers);int ret =0 ;if (insert) {
@@ -120,7 +122,7 @@ static noinline int backpointer_mod_err(struct btree_trans *trans,bch2_bkey_val_to_text (&buf, c, orig_k);bch_err (c,"%s" , buf.buf); - }else if (c->recovery.curr_pass > BCH_RECOVERY_PASS_check_extents_to_backpointers) { + }else if (!will_check) {prt_printf (&buf,"backpointer not found when deleting\n" );printbuf_indent_add (&buf,2 );
@@ -136,8 +138,7 @@ static noinline int backpointer_mod_err(struct btree_trans *trans,bch2_bkey_val_to_text (&buf, c, orig_k); } -if (c->recovery.curr_pass > BCH_RECOVERY_PASS_check_extents_to_backpointers && -__bch2_inconsistent_error (c, &buf)) +if (!will_check &&__bch2_inconsistent_error (c, &buf)) ret = -BCH_ERR_erofs_unfixed_errors;bch_err (c,"%s" , buf.buf);
fs/bcachefs/btree_cache.c +1 -1
@@ -1019,7 +1019,7 @@ static noinline void btree_bad_header(struct bch_fs *c, struct btree *b) {struct printbuf buf =PRINTBUF ; -if (c->recovery.curr_pass <= BCH_RECOVERY_PASS_check_allocations) +if (c->recovery.pass_done < BCH_RECOVERY_PASS_check_allocations)return ; prt_printf(&buf,
fs/bcachefs/btree_io.c +1 -2
@@ -1775,8 +1775,7 @@ void bch2_btree_node_read(struct btree_trans *trans, struct btree *b,prt_newline (&buf);bch2_btree_lost_data (c, &buf, b->c.btree_id); -if (c->opts.recovery_passes &BIT_ULL (BCH_RECOVERY_PASS_check_topology) && - c->recovery.curr_pass > BCH_RECOVERY_PASS_check_topology && +if (c->recovery.passes_complete &BIT_ULL (BCH_RECOVERY_PASS_check_topology) &&bch2_fs_emergency_read_only2 (c, &buf)) ratelimit = false;
fs/bcachefs/btree_update_interior.c +1 -1
@@ -2363,7 +2363,7 @@ void bch2_btree_node_rewrite_async(struct bch_fs *c, struct btree *b)bool now = false, pending = false;spin_lock (&c->btree_node_rewrites_lock); -if (c->recovery.curr_pass > BCH_RECOVERY_PASS_journal_replay && +if (c->recovery.passes_complete &BIT_ULL (BCH_RECOVERY_PASS_journal_replay) &&enumerated_ref_tryget (&c->writes, BCH_WRITE_REF_node_rewrite)) {list_add (&a->list, &c->btree_node_rewrites); now = true;
fs/bcachefs/fsck.c +0 -1
@@ -3140,7 +3140,6 @@ static int bch2_fsck_online_thread_fn(struct thread_with_stdio *stdio) c->opts.fsck = true;set_bit (BCH_FS_in_fsck, &c->flags); - c->recovery.curr_pass = BCH_RECOVERY_PASS_check_alloc_info;int ret =bch2_run_online_recovery_passes (c, ~0ULL );clear_bit (BCH_FS_in_fsck, &c->flags);
fs/bcachefs/snapshot.c +1 -1
@@ -348,7 +348,7 @@ static int __bch2_mark_snapshot(struct btree_trans *trans,if (BCH_SNAPSHOT_WILL_DELETE (s.v)) {set_bit (BCH_FS_need_delete_dead_snapshots, &c->flags); -if (c->recovery.curr_pass > BCH_RECOVERY_PASS_delete_dead_snapshots) +if (c->recovery.pass_done > BCH_RECOVERY_PASS_delete_dead_snapshots)bch2_delete_dead_snapshots_async (c); } }else {
Signature · 1 line
2.49.0
PATCH 4/8 bcachefs: bch2_recovery_pass_status_to_text()
In reply to Kent OverstreetShow recovery pass status in sysfs - important now that we're running them automatically in the background.
--- fs/bcachefs/recovery_passes.c | 24 ++++++++++++++++++++++++ fs/bcachefs/recovery_passes.h | 2 ++ fs/bcachefs/sysfs.c | 6 ++++++ 3 files changed, 32 insertions(+)
fs/bcachefs/recovery_passes.c +24 -0
@@ -444,6 +444,30 @@ int bch2_run_recovery_passes(struct bch_fs *c, enum bch_recovery_pass from)return ret; } +static void prt_passes (struct printbuf *out,const char *msg,u64 passes) +{ +prt_printf (out,"%s:\t" , msg); +prt_bitflags (out, bch2_recovery_passes, passes); +prt_newline (out); +} + +void bch2_recovery_pass_status_to_text (struct printbuf *out,struct bch_fs *c) +{ +struct bch_fs_recovery *r = &c->recovery; + +printbuf_tabstop_push (out,32 ); +prt_passes (out,"Scheduled passes" , c->sb.recovery_passes_required); +prt_passes (out,"Scheduled online passes" , c->sb.recovery_passes_required & +bch2_recovery_passes_match (PASS_ONLINE )); +prt_passes (out,"Complete passes" , r->passes_complete); +prt_passes (out,"Failing passes" , r->passes_failing); + +if (r->curr_pass) { +prt_printf (out,"Current pass:\t%s\n" , bch2_recovery_passes[r->curr_pass]); +prt_passes (out,"Current passes" , r->passes_to_run); + } +} +void bch2_fs_recovery_passes_init (struct bch_fs *c) {spin_lock_init (&c->recovery.lock);
fs/bcachefs/recovery_passes.h +2 -0
@@ -20,6 +20,8 @@ int bch2_run_explicit_recovery_pass_persistent(struct bch_fs *, struct printbufint bch2_run_online_recovery_passes (struct bch_fs *,u64 );int bch2_run_recovery_passes (struct bch_fs *,enum bch_recovery_pass ); +void bch2_recovery_pass_status_to_text (struct printbuf *,struct bch_fs *); +void bch2_fs_recovery_passes_init (struct bch_fs *);#endif /* _BCACHEFS_RECOVERY_PASSES_H */
fs/bcachefs/sysfs.c +6 -0
@@ -35,6 +35,7 @@#include "nocow_locking.h" #include "opts.h" #include "rebalance.h" +#include "recovery_passes.h" #include "replicas.h" #include "super-io.h" #include "tests.h"
@@ -202,6 +203,7 @@ read_attribute(copy_gc_wait);sysfs_pd_controller_attribute (rebalance);read_attribute (rebalance_status);read_attribute (snapshot_delete_status); +read_attribute (recovery_status);read_attribute (new_stripes);
@@ -437,6 +439,9 @@ SHOW(bch2_fs)if (attr == &sysfs_snapshot_delete_status)bch2_snapshot_delete_status_to_text (out, c); +if (attr == &sysfs_recovery_status) +bch2_recovery_pass_status_to_text (out, c); +/* Debugging: */ if (attr == &sysfs_journal_debug)
@@ -587,6 +592,7 @@ struct attribute *bch2_fs_files[] = { &sysfs_rebalance_status, &sysfs_snapshot_delete_status, + &sysfs_recovery_status, &sysfs_compression_stats,
Signature · 1 line
2.49.0
PATCH 5/8 bcachefs: bch2_run_explicit_recovery_pass() cleanup
In reply to Kent OverstreetConsolidate the run_explicit_recovery_pass() interfaces by adding a flags parameter; this will also let us add a RUN_RECOVERY_PASS_ratelimit flag.
--- fs/bcachefs/btree_node_scan.c | 2 +- fs/bcachefs/buckets.c | 8 +- fs/bcachefs/errcode.h | 1 - fs/bcachefs/error.c | 2 +- fs/bcachefs/recovery.c | 31 ++++---- fs/bcachefs/recovery_passes.c | 142 +++++++++++++++++++--------------- fs/bcachefs/recovery_passes.h | 18 +++-- fs/bcachefs/sb-members.c | 4 +- fs/bcachefs/subvolume.c | 6 +- 9 files changed, 117 insertions(+), 97 deletions(-)
fs/bcachefs/btree_node_scan.c +1 -1
@@ -541,7 +541,7 @@ int bch2_get_scanned_nodes(struct bch_fs *c, enum btree_id btree,struct find_btree_nodes *f = &c->found_btree_nodes; -int ret =bch2_run_explicit_recovery_pass (c, BCH_RECOVERY_PASS_scan_for_btree_nodes); +int ret =bch2_run_print_explicit_recovery_pass (c, BCH_RECOVERY_PASS_scan_for_btree_nodes);if (ret)return ret;
fs/bcachefs/buckets.c +4 -4
@@ -399,8 +399,8 @@ static int bucket_ref_update_err(struct btree_trans *trans, struct printbuf *bufbool print =__bch2_count_fsck_err (c, id, buf); -int ret =bch2_run_explicit_recovery_pass_persistent (c, buf, - BCH_RECOVERY_PASS_check_allocations); +int ret =bch2_run_explicit_recovery_pass (c, buf, + BCH_RECOVERY_PASS_check_allocations,0 );if (insert) {bch2_trans_updates_to_text (buf, trans);
@@ -972,8 +972,8 @@ static int __bch2_trans_mark_metadata_bucket(struct btree_trans *trans,bool print =bch2_count_fsck_err (c, bucket_metadata_type_mismatch, &buf); -bch2_run_explicit_recovery_pass_persistent (c, &buf, - BCH_RECOVERY_PASS_check_allocations); +bch2_run_explicit_recovery_pass (c, &buf, + BCH_RECOVERY_PASS_check_allocations,0 );if (print)bch2_print_str (c,KERN_ERR , buf.buf);
fs/bcachefs/errcode.h +0 -1
@@ -183,7 +183,6 @@ x(BCH_ERR_fsck, fsck_repair_unimplemented) \ x(BCH_ERR_fsck, fsck_repair_impossible) \ x(EINVAL, restart_recovery) \ - x(EINVAL, not_in_recovery) \ x(EINVAL, cannot_rewind_recovery) \ x(0, data_update_done) \x (BCH_ERR_data_update_done, data_update_done_would_block) \
fs/bcachefs/error.c +1 -1
@@ -102,7 +102,7 @@ int __bch2_topology_error(struct bch_fs *c, struct printbuf *out)__bch2_inconsistent_error (c, out);return -BCH_ERR_btree_need_topology_repair; }else { -return bch2_run_explicit_recovery_pass_persistent (c, out, BCH_RECOVERY_PASS_check_topology) ?: +return bch2_run_explicit_recovery_pass (c, out, BCH_RECOVERY_PASS_check_topology,0 ) ?: -BCH_ERR_btree_node_read_validate_error; } }
fs/bcachefs/recovery.c +15 -16
@@ -52,24 +52,24 @@ int bch2_btree_lost_data(struct bch_fs *c, }/* Once we have runtime self healing for topology errors we won't need this: */ - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_topology) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_topology,0 ) ?: ret;/* Btree node accounting will be off: */ __set_bit_le64 (BCH_FSCK_ERR_accounting_mismatch, ext->errors_silent); - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_allocations) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_allocations,0 ) ?: ret;#ifdef CONFIG_BCACHEFS_DEBUG /* * These are much more minor, and don't need to be corrected right away, * but in debug mode we want the next fsck run to be clean: */ - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_lrus) ?: ret; - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_backpointers_to_extents) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_lrus,0 ) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_backpointers_to_extents,0 ) ?: ret;#endif switch (btree) {case BTREE_ID_alloc: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_alloc_info) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_alloc_info,0 ) ?: ret;__set_bit_le64 (BCH_FSCK_ERR_alloc_key_data_type_wrong, ext->errors_silent);__set_bit_le64 (BCH_FSCK_ERR_alloc_key_gen_wrong, ext->errors_silent);
@@ -79,30 +79,30 @@ int bch2_btree_lost_data(struct bch_fs *c,__set_bit_le64 (BCH_FSCK_ERR_alloc_key_stripe_redundancy_wrong, ext->errors_silent); goto out;case BTREE_ID_backpointers: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_btree_backpointers) ?: ret; - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_extents_to_backpointers) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_btree_backpointers,0 ) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_extents_to_backpointers,0 ) ?: ret; goto out;case BTREE_ID_need_discard: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_alloc_info) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_alloc_info,0 ) ?: ret; goto out;case BTREE_ID_freespace: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_alloc_info) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_alloc_info,0 ) ?: ret; goto out;case BTREE_ID_bucket_gens: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_alloc_info) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_alloc_info,0 ) ?: ret; goto out;case BTREE_ID_lru: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_alloc_info) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_alloc_info,0 ) ?: ret; goto out;case BTREE_ID_accounting: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_check_allocations) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_check_allocations,0 ) ?: ret; goto out;case BTREE_ID_snapshots: - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_reconstruct_snapshots) ?: ret; - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_scan_for_btree_nodes) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_reconstruct_snapshots,0 ) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_scan_for_btree_nodes,0 ) ?: ret; goto out;default : - ret =__bch2_run_explicit_recovery_pass_persistent (c, msg, BCH_RECOVERY_PASS_scan_for_btree_nodes) ?: ret; + ret =__bch2_run_explicit_recovery_pass (c, msg, BCH_RECOVERY_PASS_scan_for_btree_nodes,0 ) ?: ret; goto out; } out:
@@ -978,7 +978,6 @@ int bch2_fs_recovery(struct bch_fs *c)*/ set_bit (BCH_FS_may_go_rw, &c->flags);clear_bit (BCH_FS_in_fsck, &c->flags); -clear_bit (BCH_FS_in_recovery, &c->flags);/* in case we don't run journal replay, i.e. norecovery mode */ set_bit (BCH_FS_accounting_replay_done, &c->flags);
fs/bcachefs/recovery_passes.c +79 -63
189 lines not on this page · raw message
fs/bcachefs/recovery_passes.h +12 -6
@@ -10,12 +10,18 @@ u64 bch2_recovery_passes_from_stable(u64 v);u64 bch2_fsck_recovery_passes (void ); -int bch2_run_explicit_recovery_pass (struct bch_fs *,enum bch_recovery_pass ); - -int __bch2_run_explicit_recovery_pass_persistent (struct bch_fs *,struct printbuf *, -enum bch_recovery_pass ); -int bch2_run_explicit_recovery_pass_persistent (struct bch_fs *,struct printbuf *, -enum bch_recovery_pass ); +enum bch_run_recovery_pass_flags { + RUN_RECOVERY_PASS_nopersistent =BIT (0 ), +}; + +int bch2_run_print_explicit_recovery_pass (struct bch_fs *,enum bch_recovery_pass ); + +int __bch2_run_explicit_recovery_pass (struct bch_fs *,struct printbuf *, +enum bch_recovery_pass , +enum bch_run_recovery_pass_flags ); +int bch2_run_explicit_recovery_pass (struct bch_fs *,struct printbuf *, +enum bch_recovery_pass , +enum bch_run_recovery_pass_flags );int bch2_run_online_recovery_passes (struct bch_fs *,u64 );int bch2_run_recovery_passes (struct bch_fs *,enum bch_recovery_pass );
fs/bcachefs/sb-members.c +2 -2
@@ -20,8 +20,8 @@ int bch2_dev_missing_bkey(struct bch_fs *c, struct bkey_s_c k, unsigned dev)bool print =bch2_count_fsck_err (c, ptr_to_invalid_device, &buf); -int ret =bch2_run_explicit_recovery_pass_persistent (c, &buf, - BCH_RECOVERY_PASS_check_allocations); +int ret =bch2_run_explicit_recovery_pass (c, &buf, + BCH_RECOVERY_PASS_check_allocations,0 );if (print)bch2_print_str (c,KERN_ERR , buf.buf);
fs/bcachefs/subvolume.c +3 -3
@@ -23,8 +23,8 @@ static int bch2_subvolume_missing(struct bch_fs *c, u32 subvolid)prt_printf (&buf,"missing subvolume %u" , subvolid);bool print =bch2_count_fsck_err (c, subvol_missing, &buf); -int ret =bch2_run_explicit_recovery_pass_persistent (c, &buf, - BCH_RECOVERY_PASS_check_inodes); +int ret =bch2_run_explicit_recovery_pass (c, &buf, + BCH_RECOVERY_PASS_check_inodes,0 );if (print)bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);
@@ -62,7 +62,7 @@ static int check_subvol(struct btree_trans *trans, ret =bch2_snapshot_lookup (trans, snapid, &snapshot);if (bch2_err_matches (ret,ENOENT )) -return bch2_run_explicit_recovery_pass (c, +return bch2_run_print_explicit_recovery_pass (c, BCH_RECOVERY_PASS_reconstruct_snapshots) ?: ret;if (ret)return ret;
Signature · 1 line
2.49.0
PATCH 6/8 bcachefs: Run recovery passes asynchronously
In reply to Kent OverstreetWhen we request a recovery pass to be run online, i.e. not during recovery, if it's an online pass it'll now be run in the background, instead of waiting for the next mount.
To avoid situations where recovery passes are running continuously, this also includes ratelimiting: if the RUN_RECOVERY_PASS_ratelimit flag is passed, the pass may be deferred until later - depending on the runtime and last run stats in the recovery_passes superblock section.
--- fs/bcachefs/bcachefs.h | 3 +- fs/bcachefs/recovery_passes.c | 133 ++++++++++++++++++++++------ fs/bcachefs/recovery_passes.h | 1 + fs/bcachefs/recovery_passes_types.h | 2 + 4 files changed, 113 insertions(+), 26 deletions(-)
fs/bcachefs/bcachefs.h +2 -1
@@ -760,7 +760,8 @@ struct btree_trans_buf {x (snapshot_delete_pagecache) \x (sysfs ) \x (btree_write_buffer) \ -x (btree_node_scrub) +x (btree_node_scrub) \ +x (async_recovery_passes) enum bch_write_ref {#define x (n) BCH_WRITE_REF_##n,
fs/bcachefs/recovery_passes.c +108 -25
199 lines not on this page · raw message
fs/bcachefs/recovery_passes.h +1 -0
@@ -12,6 +12,7 @@ u64 bch2_fsck_recovery_passes(void);enum bch_run_recovery_pass_flags { RUN_RECOVERY_PASS_nopersistent =BIT (0 ), + RUN_RECOVERY_PASS_ratelimit =BIT (1 ), };int bch2_run_print_explicit_recovery_pass (struct bch_fs *,enum bch_recovery_pass );
fs/bcachefs/recovery_passes_types.h +2 -0
@@ -18,8 +18,10 @@ struct bch_fs_recovery {/* bitmask of recovery passes that we actually ran */ u64 passes_complete;u64 passes_failing; +u64 passes_ratelimiting;spinlock_t lock;struct semaphore run_lock; + struct work_struct work; };#endif /* _BCACHEFS_RECOVERY_PASSES_TYPES_H */
Signature · 1 line
2.49.0
PATCH 7/8 bcachefs: Improve bucket_bitmap code
In reply to Kent OverstreetAdd some more helpers, and mismatches is now a superset of the empty bitmap - simplifies most checks.
--- fs/bcachefs/backpointers.c | 123 ++++++++++++++++++++++--------------- fs/bcachefs/backpointers.h | 7 +++ fs/bcachefs/bcachefs.h | 3 +- fs/bcachefs/buckets.c | 25 ++------ fs/bcachefs/movinggc.c | 6 +- fs/bcachefs/super.c | 8 +-- 6 files changed, 92 insertions(+), 80 deletions(-)
fs/bcachefs/backpointers.c +72 -51
@@ -15,6 +15,8 @@#include <linux/mm.h> +static int bch2_bucket_bitmap_set (struct bch_dev *,struct bucket_bitmap *,u64 ); +static inline struct bbpos bp_to_bbpos (struct bch_backpointer bp) {return (struct bbpos ) {
@@ -685,31 +687,28 @@ static int check_extent_to_backpointers(struct btree_trans *trans,continue ; } -u64 b =PTR_BUCKET_NR (ca, &p.ptr); -bool set[2 ]; - -for (unsigned i =0 ; i <ARRAY_SIZE (ca->bucket_backpointer_mismatches); i++) { -unsigned long *bitmap = -READ_ONCE (ca->bucket_backpointer_mismatches[i].buckets); - set[i] = bitmap &&test_bit (b, bitmap); +if (p.ptr.cached &&dev_ptr_stale_rcu (ca, &p.ptr)) { +rcu_read_unlock (); +continue ; } -bool check = set[0 ]; -bool empty = set[1 ]; +u64 b =PTR_BUCKET_NR (ca, &p.ptr); +if (!bch2_bucket_bitmap_test (&ca->bucket_backpointer_mismatch, b)) { +rcu_read_unlock (); +continue ; + } -bool stale = p.ptr.cached && (!ca ||dev_ptr_stale_rcu (ca, &p.ptr)); +bool empty =bch2_bucket_bitmap_test (&ca->bucket_backpointer_empty, b);rcu_read_unlock (); -if ((check || empty) && !stale) { -struct bkey_i_backpointer bp; -bch2_extent_ptr_to_bp (c, btree, level, k, p, entry, &bp); +struct bkey_i_backpointer bp; +bch2_extent_ptr_to_bp (c, btree, level, k, p, entry, &bp); -int ret = check - ?check_bp_exists (trans, s, &bp, k) - :bch2_bucket_backpointer_mod (trans, k, &bp, true); -if (ret) -return ret; - } +int ret = !empty + ?check_bp_exists (trans, s, &bp, k) + :bch2_bucket_backpointer_mod (trans, k, &bp, true); +if (ret) +return ret; }return 0 ;
@@ -952,21 +951,12 @@ static int check_bucket_backpointer_mismatch(struct btree_trans *trans, struct b sectors[ALLOC_stripe] + sectors[ALLOC_cached]) == 0; -struct bucket_bitmap *bitmap = &ca->bucket_backpointer_mismatches[empty]; - -mutex_lock (&bitmap->lock); -if (!bitmap->buckets) { - bitmap->buckets =kvcalloc (BITS_TO_LONGS (ca->mi.nbuckets), -sizeof (unsigned long ),GFP_KERNEL ); -if (!bitmap->buckets) { -mutex_unlock (&bitmap->lock); - ret = -BCH_ERR_ENOMEM_backpointer_mismatches_bitmap; - goto err; - } - } - - bitmap->nr += !__test_and_set_bit (alloc_k.k->p.offset, bitmap->buckets); -mutex_unlock (&bitmap->lock); + ret =bch2_bucket_bitmap_set (ca, &ca->bucket_backpointer_mismatch, + alloc_k.k->p.offset) ?: + (empty + ?bch2_bucket_bitmap_set (ca, &ca->bucket_backpointer_empty, + alloc_k.k->p.offset) + :0 ); } err:bch2_dev_put (ca);
@@ -992,15 +982,10 @@ static bool backpointer_node_has_missing(struct bch_fs *c, struct bkey_s_c k)struct bpos bucket =bp_pos_to_bucket (ca, pos);u64 next = ca->mi.nbuckets; -for (unsigned i =0 ; i <ARRAY_SIZE (ca->bucket_backpointer_mismatches); i++) { -unsigned long *bitmap = -READ_ONCE (ca->bucket_backpointer_mismatches[i].buckets); -if (bitmap) - next =min_t (u64, next, -find_next_bit (bitmap, - ca->mi.nbuckets, - bucket.offset)); - } +unsigned long *bitmap =READ_ONCE (ca->bucket_backpointer_mismatch.buckets); +if (bitmap) + next =min_t (u64, next, +find_next_bit (bitmap, ca->mi.nbuckets, bucket.offset)); bucket.offset = next;if (bucket.offset == ca->mi.nbuckets)
@@ -1124,18 +1109,17 @@ int bch2_check_extents_to_backpointers(struct bch_fs *c)if (ret) goto err; -u64 nr_buckets =0 , nr_mismatches =0 , nr_empty =0 ; +u64 nr_buckets =0 , nr_mismatches =0 ;for_each_member_device (c, ca) { nr_buckets += ca->mi.nbuckets; - nr_mismatches += ca->bucket_backpointer_mismatches[0 ].nr; - nr_empty += ca->bucket_backpointer_mismatches[1 ].nr; + nr_mismatches += ca->bucket_backpointer_mismatch.nr; } -if (!nr_mismatches && !nr_empty) +if (!nr_mismatches) goto err;bch_info (c,"scanning for missing backpointers in %llu/%llu buckets" , - nr_mismatches + nr_empty, nr_buckets); + nr_mismatches, nr_buckets);while (1 ) { ret =bch2_pin_backpointer_nodes_with_missing (trans, s.bp_start, &s.bp_end);
@@ -1171,9 +1155,10 @@ int bch2_check_extents_to_backpointers(struct bch_fs *c)bch2_bkey_buf_exit (&s.last_flushed, c);bch2_btree_cache_unpin (c); -for_each_member_device (c, ca) -for (unsigned i =0 ; i <ARRAY_SIZE (ca->bucket_backpointer_mismatches); i++) -bch2_bucket_bitmap_free (&ca->bucket_backpointer_mismatches[i]); +for_each_member_device (c, ca) { +bch2_bucket_bitmap_free (&ca->bucket_backpointer_mismatch); +bch2_bucket_bitmap_free (&ca->bucket_backpointer_empty); + }bch_err_fn (c, ret);return ret;
@@ -1297,6 +1282,42 @@ int bch2_check_backpointers_to_extents(struct bch_fs *c)return ret; } +static int bch2_bucket_bitmap_set (struct bch_dev *ca,struct bucket_bitmap *b,u64 bit) +{ + scoped_guard(mutex, &b->lock) { +if (!b->buckets) { + b->buckets =kvcalloc (BITS_TO_LONGS (ca->mi.nbuckets), +sizeof (unsigned long ),GFP_KERNEL ); +if (!b->buckets) +return -BCH_ERR_ENOMEM_backpointer_mismatches_bitmap; + } + + b->nr += !__test_and_set_bit (bit, b->buckets); + } + +return 0 ; +} + +int bch2_bucket_bitmap_resize (struct bucket_bitmap *b,u64 old_size,u64 new_size) +{ + scoped_guard(mutex, &b->lock) { +if (!b->buckets) +return 0 ; + +unsigned long *n =kvcalloc (BITS_TO_LONGS (new_size), +sizeof (unsigned long ),GFP_KERNEL ); +if (!n) +return -BCH_ERR_ENOMEM_backpointer_mismatches_bitmap; + +memcpy (n, b->buckets, +BITS_TO_LONGS (min (old_size, new_size)) *sizeof (unsigned long )); +kvfree (b->buckets); + b->buckets = n; + } + +return 0 ; +} +void bch2_bucket_bitmap_free (struct bucket_bitmap *b) {mutex_lock (&b->lock);
fs/bcachefs/backpointers.h +7 -0
@@ -188,6 +188,13 @@ int bch2_check_btree_backpointers(struct bch_fs *);int bch2_check_extents_to_backpointers (struct bch_fs *);int bch2_check_backpointers_to_extents (struct bch_fs *); +static inline bool bch2_bucket_bitmap_test (struct bucket_bitmap *b,u64 i) +{ +unsigned long *bitmap =READ_ONCE (b->buckets); +return bitmap &&test_bit (i, bitmap); +} + +int bch2_bucket_bitmap_resize (struct bucket_bitmap *,u64 ,u64 );void bch2_bucket_bitmap_free (struct bucket_bitmap *);#endif /* _BCACHEFS_BACKPOINTERS_BACKGROUND_H */
fs/bcachefs/bcachefs.h +2 -1
@@ -626,7 +626,8 @@ struct bch_dev {u8 *oldest_gen;unsigned long *buckets_nouse; -struct bucket_bitmap bucket_backpointer_mismatches[2 ]; +struct bucket_bitmap bucket_backpointer_mismatch; +struct bucket_bitmap bucket_backpointer_empty;struct bch_dev_usage_full __percpu *usage;
fs/bcachefs/buckets.c +4 -21
@@ -1324,27 +1324,10 @@ int bch2_dev_buckets_resize(struct bch_fs *c, struct bch_dev *ca, u64 nbuckets) sizeof(bucket_gens->b[0]) * copy); } -for (unsigned i =0 ; i <ARRAY_SIZE (ca->bucket_backpointer_mismatches); i++) { -struct bucket_bitmap *bitmap = &ca->bucket_backpointer_mismatches[i]; - -mutex_lock (&bitmap->lock); -if (bitmap->buckets) { -unsigned long *n =kvcalloc (BITS_TO_LONGS (nbuckets), -sizeof (unsigned long ),GFP_KERNEL ); -if (!n) { -mutex_unlock (&bitmap->lock); - ret = -BCH_ERR_ENOMEM_backpointer_mismatches_bitmap; - goto err; - } - -memcpy (n, bitmap->buckets, -BITS_TO_LONGS (ca->mi.nbuckets) *sizeof (unsigned long )); -kvfree (bitmap->buckets); - bitmap->buckets = n; - - } -mutex_unlock (&bitmap->lock); - } + ret =bch2_bucket_bitmap_resize (&ca->bucket_backpointer_mismatch, + ca->mi.nbuckets, nbuckets) ?: +bch2_bucket_bitmap_resize (&ca->bucket_backpointer_empty, + ca->mi.nbuckets, nbuckets);rcu_assign_pointer (ca->bucket_gens, bucket_gens); bucket_gens = old_bucket_gens;
fs/bcachefs/movinggc.c +3 -3
@@ -8,6 +8,7 @@#include "bcachefs.h" #include "alloc_background.h" #include "alloc_foreground.h" +#include "backpointers.h" #include "btree_iter.h" #include "btree_update.h" #include "btree_write_buffer.h"
@@ -76,7 +77,7 @@ static int bch2_bucket_is_movable(struct btree_trans *trans,if (ca->mi.state != BCH_MEMBER_STATE_rw || !bch2_dev_is_online (ca)) - goto out_put; + goto out;struct bch_alloc_v4 _a;const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (k, &_a);
@@ -85,9 +86,8 @@ static int bch2_bucket_is_movable(struct btree_trans *trans,u64 lru_idx =alloc_lru_idx_fragmentation (*a, ca); ret = lru_idx && lru_idx <= time; -out_put: -bch2_dev_put (ca); out: +bch2_dev_put (ca);bch2_trans_iter_exit (trans, &iter);return ret; }
fs/bcachefs/super.c +4 -4
@@ -1366,8 +1366,8 @@ static void bch2_dev_free(struct bch_dev *ca)if (ca->kobj.state_in_sysfs)kobject_del (&ca->kobj); -for (unsigned i =0 ; i <ARRAY_SIZE (ca->bucket_backpointer_mismatches); i++) -bch2_bucket_bitmap_free (&ca->bucket_backpointer_mismatches[i]); +bch2_bucket_bitmap_free (&ca->bucket_backpointer_mismatch); +bch2_bucket_bitmap_free (&ca->bucket_backpointer_empty);bch2_free_super (&ca->disk_sb);bch2_dev_allocator_background_exit (ca);
@@ -1499,8 +1499,8 @@ static struct bch_dev *__bch2_dev_alloc(struct bch_fs *c,atomic_long_set (&ca->ref,1 );#endif -for (unsigned i =0 ; i <ARRAY_SIZE (ca->bucket_backpointer_mismatches); i++) -mutex_init (&ca->bucket_backpointer_mismatches[i].lock); +mutex_init (&ca->bucket_backpointer_mismatch.lock); +mutex_init (&ca->bucket_backpointer_empty.lock);bch2_dev_allocator_background_init (ca);
Signature · 1 line
2.49.0
PATCH 8/8 bcachefs: bch2_check_bucket_backpointer_mismatch()
In reply to Kent OverstreetDetect buckets with missing backpointers, and run repair on demand.
__bch2_move_data_phys() now calls bch2_check_bucket_backpointer_mismatch() as it walks buckets, which checks for missing backpointers by comparing backpointers against bucket sector counts.
When missing backpointers are detected, we kick off bch2_check_extents_to_backpointers() asynchronously - right away if we're trying to evacuate, or with a threshold if we're just running copygc.
--- fs/bcachefs/alloc_background.c | 7 +++- fs/bcachefs/backpointers.c | 75 +++++++++++++++++++++++++++++++--- fs/bcachefs/backpointers.h | 3 +- fs/bcachefs/move.c | 21 ++++++++-- fs/bcachefs/movinggc.c | 3 ++ 5 files changed, 98 insertions(+), 11 deletions(-)
fs/bcachefs/alloc_background.c +5 -2
@@ -2175,8 +2175,11 @@ static int invalidate_one_bucket(struct btree_trans *trans,BUG_ON (a->data_type != BCH_DATA_cached);BUG_ON (a->dirty_sectors); -if (!a->cached_sectors) -bch_err (c,"invalidating empty bucket, confused" ); +if (!a->cached_sectors) { +bch2_check_bucket_backpointer_mismatch (trans, ca, bucket.offset, + true, last_flushed); + goto out; + }unsigned cached_sectors = a->cached_sectors;u8 gen = a->gen;
fs/bcachefs/backpointers.c +70 -5
133 lines not on this page · raw message
fs/bcachefs/backpointers.h +2 -1
@@ -182,7 +182,8 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *, struct bkey_s_c_bstruct btree *bch2_backpointer_get_node (struct btree_trans *,struct bkey_s_c_backpointer ,struct btree_iter *,struct bkey_buf *); -int bch2_check_bucket_backpointer_mismatch (struct btree_trans *,struct bpos ,struct bkey_buf *); +int bch2_check_bucket_backpointer_mismatch (struct btree_trans *,struct bch_dev *,u64 , +bool ,struct bkey_buf *);int bch2_check_btree_backpointers (struct bch_fs *);int bch2_check_extents_to_backpointers (struct bch_fs *);
fs/bcachefs/move.c +18 -3
@@ -815,6 +815,7 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,u64 bucket_start, u64 bucket_end, unsigned data_types, + bool copygc, move_pred_fn pred, void *arg) { struct btree_trans *trans = ctxt->trans;
@@ -825,6 +826,7 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,struct bkey_buf sk;struct bkey_s_c k;struct bkey_buf last_flushed; +u64 check_mismatch_done = bucket_start;int ret =0 ;struct bch_dev *ca =bch2_dev_tryget (c, dev);
@@ -835,8 +837,6 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,struct bpos bp_start =bucket_pos_to_bp_start (ca,POS (dev, bucket_start));struct bpos bp_end =bucket_pos_to_bp_end (ca,POS (dev, bucket_end)); -bch2_dev_put (ca); - ca =NULL ;bch2_bkey_buf_init (&last_flushed);bkey_init (&last_flushed.k->k);
@@ -871,6 +871,14 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,if (!k.k ||bkey_gt (k.k->p, bp_end))break ; +if (check_mismatch_done <bp_pos_to_bucket (ca, k.k->p).offset) { +while (check_mismatch_done <bp_pos_to_bucket (ca, k.k->p).offset) { +bch2_check_bucket_backpointer_mismatch (trans, ca, check_mismatch_done++, + copygc, &last_flushed); + } +continue ; + } +if (k.k->type != KEY_TYPE_backpointer) goto next;
@@ -946,10 +954,15 @@ static int __bch2_move_data_phys(struct moving_context *ctxt, next:bch2_btree_iter_advance (trans, &bp_iter); } + +while (check_mismatch_done < bucket_end) +bch2_check_bucket_backpointer_mismatch (trans, ca, check_mismatch_done++, + copygc, &last_flushed); err:bch2_trans_iter_exit (trans, &bp_iter);bch2_bkey_buf_exit (&sk, c);bch2_bkey_buf_exit (&last_flushed, c); +bch2_dev_put (ca);return ret; }
@@ -974,7 +987,8 @@ int bch2_move_data_phys(struct bch_fs *c, ctxt.stats->data_type = (int ) DATA_PROGRESS_DATA_TYPE_phys; } -int ret =__bch2_move_data_phys (&ctxt,NULL , dev, start, end, data_types, pred, arg); +int ret =__bch2_move_data_phys (&ctxt,NULL , dev, start, end, + data_types, false, pred, arg);bch2_moving_ctxt_exit (&ctxt);return ret;
@@ -1019,6 +1033,7 @@ int bch2_evacuate_bucket(struct moving_context *ctxt, bucket.offset, bucket.offset +1 , ~0 , + true, evacuate_bucket_pred, &arg); }
fs/bcachefs/movinggc.c +3 -0
@@ -75,6 +75,9 @@ static int bch2_bucket_is_movable(struct btree_trans *trans,if (!ca) goto out; +if (bch2_bucket_bitmap_test (&ca->bucket_backpointer_mismatch, b->k.bucket.offset)) + goto out; +if (ca->mi.state != BCH_MEMBER_STATE_rw || !bch2_dev_is_online (ca)) goto out;
Signature · 1 line
2.49.0