new on disk format versions, backpointers fsck scalability
cover new on disk format versions, backpointers fsck scalability
- the sort order of disk accounting keys was screwed up, making disk accounting read way more expensive than it needs to be
this is an expensive forced version upgrade, but necessary because we now have counters for every inode for tracking fragmentation - we can't be scanning all of those at startup time
backpointers fsck has been the limiting factor on fsck scalability:
checking every extent <-> backpointer reference inherently doesn't scale, since the references we follow do nearly random cross-btree access so we have to pin in ram, or run in multiple passes.
so:
- change bch_backpointer to include the bucket generation number
with this, we can sum up backpointers in a bucket and check against the bucket sector counts to determine if there's missing backpointers; we need the generation number to avoid counting stale backpointers since the backpointers btree uses the btree write buffer (updates are much faster, reads are always potentially stale).
having done so, we can mark out a bitmap and then only check extents -> backpointers references for those specific buckets.
for backpointers -> extents, those checks can be deferred until when the backpointer is used: the overall self healing project is "run fsck check/repair code at runtime whenever appropriate", so with that done we can switch that pass to only run in debug mode.
Kent Overstreet (8):
bcachefs: bcachefs_metadata_version_backpointer_bucket_gen
bcachefs: bcachefs_metadata_version_disk_accounting_big_endian
bcachefs: bch2_extent_ptr_to_bp() no longer depends on device
bcachefs: kill __bch2_extent_ptr_to_bp()
bcachefs: check_extents_to_backpointers() now only checks buckets with
mismatches
bcachefs: Add write buffer flush param to backpointer_get_key()
bcachefs: bch2_backpointer_get_key() now repairs dangling backpointers
bcachefs: Only run check_backpointers_to_extents in debug mode
fs/bcachefs/backpointers.c | 394 +++++++++++++++++++++------- fs/bcachefs/backpointers.h | 32 +-- fs/bcachefs/bcachefs.h | 2 + fs/bcachefs/bcachefs_format.h | 7 +- fs/bcachefs/btree_cache.c | 1 - fs/bcachefs/buckets.c | 10 +- fs/bcachefs/disk_accounting.c | 25 +- fs/bcachefs/disk_accounting.h | 25 +- fs/bcachefs/ec.c | 14 +- fs/bcachefs/errcode.h | 1 + fs/bcachefs/move.c | 8 +- fs/bcachefs/recovery_passes_types.h | 92 ++++--- fs/bcachefs/sb-downgrade.c | 26 +- fs/bcachefs/sb-errors_format.h | 4 +- fs/bcachefs/util.h | 9 + 15 files changed, 452 insertions(+), 198 deletions(-)
Signature · 1 line
2.45.2
PATCH 1/8 bcachefs: bcachefs_metadata_version_backpointer_bucket_gen
New on disk format version: backpointers new include the generation number of the bucket they refer to, and the obsolete bucket_offset field (no longer needed because we no longer store backpointers in alloc keys) is gone.
This is an expensive forced upgrade - hopefully the last; we have to run the extents_to_backpointers recovery pass to regenerate backpointers.
It's a forced incompatible upgrade because the alternative would've been permamently making backpointers bigger, and as one of the biggest btrees (along with the extents btree) that's not an ideal option.
It's worth it though, because this allows us to make the check_extents_to_backpointers pass drastically cheaper: an upcoming patch changes it to sum up backpointers in a bucket and check the sum against the sector counts for that bucket, only looking for missing backpointers if they don't match (and then only for specific buckets).
--- fs/bcachefs/backpointers.c | 18 ------------------ fs/bcachefs/backpointers.h | 2 +- fs/bcachefs/bcachefs_format.h | 6 ++++-- fs/bcachefs/sb-downgrade.c | 16 ++++++++++++++-- 4 files changed, 19 insertions(+), 23 deletions(-)
fs/bcachefs/backpointers.c +0 -18
@@ -28,23 +28,6 @@ int bch2_backpointer_validate(struct bch_fs *c, struct bkey_s_c k,bkey_fsck_err_on (bp.k->p.inode ==BCH_SB_MEMBER_INVALID , c, backpointer_dev_bad,"backpointer for BCH_SB_MEMBER_INVALID" ); - -rcu_read_lock (); -struct bch_dev *ca =bch2_dev_rcu_noerror (c, bp.k->p.inode); -if (!ca) { -/* these will be caught by fsck */ -rcu_read_unlock (); -return 0 ; - } - -struct bpos bucket =bp_pos_to_bucket (ca, bp.k->p); -struct bpos bp_pos =bucket_pos_to_bp_noerror (ca, bucket, bp.v->bucket_offset); -rcu_read_unlock (); - -bkey_fsck_err_on ((bp.v->bucket_offset >>MAX_EXTENT_COMPRESS_RATIO_SHIFT ) >= ca->mi.bucket_size || - !bpos_eq (bp.k->p, bp_pos), - c, backpointer_bucket_offset_wrong, -"backpointer bucket_offset wrong (%llu)" , (u64 ) bp.v->bucket_offset); fsck_err:return ret; }
@@ -76,7 +59,6 @@ void bch2_backpointer_swab(struct bkey_s k) {struct bkey_s_backpointer bp =bkey_s_to_backpointer (k); - bp.v->bucket_offset =swab40 (bp.v->bucket_offset); bp.v->bucket_len =swab32 (bp.v->bucket_len);bch2_bpos_swab (&bp.v->pos); }
fs/bcachefs/backpointers.h +1 -1
@@ -158,7 +158,7 @@ static inline void __bch2_extent_ptr_to_bp(struct bch_fs *c, struct bch_dev *ca, .btree_id = btree_id, .level = level, .data_type = bch2_bkey_ptr_data_type(k, p, entry), - .bucket_offset = bp_bucket_offset, + .bucket_gen = p.ptr.gen, .bucket_len = sectors, .pos = k.k->p, };
fs/bcachefs/bcachefs_format.h +4 -2
@@ -463,7 +463,8 @@ struct bch_backpointer {__u8 btree_id;__u8 level;__u8 data_type; - __u64 bucket_offset:40; +__u8 bucket_gen; +__u32 pad;__u32 bucket_len;struct bpos pos; } __packed__aligned(8) ;
@@ -677,7 +678,8 @@ struct bch_sb_field_ext { x(disk_accounting_v3, BCH_VERSION(1, 10)) \ x(disk_accounting_inum, BCH_VERSION(1, 11)) \ x(rebalance_work_acct_fix, BCH_VERSION(1, 12)) \ - x(inode_has_child_snapshots, BCH_VERSION(1, 13)) + x(inode_has_child_snapshots, BCH_VERSION(1, 13)) \ + x(backpointer_bucket_gen, BCH_VERSION(1, 14))enum bcachefs_metadata_version { bcachefs_metadata_version_min =9 ,
fs/bcachefs/sb-downgrade.c +14 -2
@@ -81,7 +81,12 @@ BCH_FSCK_ERR_accounting_mismatch) \ x(inode_has_child_snapshots, \ BIT_ULL(BCH_RECOVERY_PASS_check_inodes), \ - BCH_FSCK_ERR_inode_has_child_snapshots_wrong) + BCH_FSCK_ERR_inode_has_child_snapshots_wrong) \ + x(backpointer_bucket_gen, \ + BIT_ULL(BCH_RECOVERY_PASS_check_backpointers_to_extents)|\ + BIT_ULL(BCH_RECOVERY_PASS_check_extents_to_backpointers),\ + BCH_FSCK_ERR_backpointer_to_missing_ptr, \ + BCH_FSCK_ERR_ptr_to_missing_backpointer) #define DOWNGRADE_TABLE() \ x(bucket_stripe_sectors, \
@@ -117,7 +122,14 @@ BCH_FSCK_ERR_bkey_version_in_future) \x (rebalance_work_acct_fix , \BIT_ULL (BCH_RECOVERY_PASS_check_allocations ), \ -BCH_FSCK_ERR_accounting_mismatch ) +BCH_FSCK_ERR_accounting_mismatch , \ +BCH_FSCK_ERR_accounting_key_replicas_nr_devs_0 , \ +BCH_FSCK_ERR_accounting_key_junk_at_end ) \ +x (backpointer_bucket_gen, \ +BIT_ULL (BCH_RECOVERY_PASS_check_extents_to_backpointers),\ + BCH_FSCK_ERR_backpointer_bucket_offset_wrong, \ + BCH_FSCK_ERR_backpointer_to_missing_ptr, \ + BCH_FSCK_ERR_ptr_to_missing_backpointer) struct upgrade_downgrade_entry {u64 recovery_passes;
Signature · 1 line
2.45.2
PATCH 2/8 bcachefs: bcachefs_metadata_version_disk_accounting_big_endian
In reply to Kent OverstreetFix sort order for disk accounting keys.
The typetag is now the most significant byte of the key, meaning disk accounting keys of the same type now sort together.
This lets us skip over disk accounting keys that aren't mirrored in memory when reading accounting at startup, instead of having them interleaved with other counter types.
--- fs/bcachefs/bcachefs_format.h | 3 ++- fs/bcachefs/disk_accounting.c | 25 +++++++++++++++++++++---- fs/bcachefs/disk_accounting.h | 25 +++++++++++++++++-------- fs/bcachefs/sb-downgrade.c | 14 ++++++++++++-- fs/bcachefs/util.h | 9 +++++++++ 5 files changed, 61 insertions(+), 15 deletions(-)
fs/bcachefs/bcachefs_format.h +2 -1
@@ -679,7 +679,8 @@ struct bch_sb_field_ext { x(disk_accounting_inum, BCH_VERSION(1, 11)) \ x(rebalance_work_acct_fix, BCH_VERSION(1, 12)) \ x(inode_has_child_snapshots, BCH_VERSION(1, 13)) \ - x(backpointer_bucket_gen, BCH_VERSION(1, 14)) + x(backpointer_bucket_gen, BCH_VERSION(1, 14)) \ + x(disk_accounting_big_endian, BCH_VERSION(1, 15))enum bcachefs_metadata_version { bcachefs_metadata_version_min =9 ,
fs/bcachefs/disk_accounting.c +21 -4
@@ -716,11 +716,23 @@ int bch2_accounting_read(struct bch_fs *c)percpu_memset (c->usage,0 ,sizeof (*c->usage));percpu_up_write (&c->mark_lock); -int ret =for_each_btree_key (trans, iter, - BTREE_ID_accounting,POS_MIN , +struct btree_iter iter; +bch2_trans_iter_init (trans, &iter, BTREE_ID_accounting,POS_MIN , + BTREE_ITER_prefetch|BTREE_ITER_all_snapshots); + iter.flags &= ~BTREE_ITER_with_journal; +int ret =for_each_btree_key_continue (trans, iter, BTREE_ITER_prefetch|BTREE_ITER_all_snapshots, k, ({ -struct bkey u; -struct bkey_s_c k =bch2_btree_path_peek_slot_exact (btree_iter_path (trans, &iter), &u); +if (k.k->type != KEY_TYPE_accounting) +continue ; + +struct disk_accounting_pos acc_k; +bpos_to_disk_accounting_pos (&acc_k, k.k->p); +if (!bch2_accounting_is_mem (acc_k)) { +struct disk_accounting_pos next = { .type = acc_k.type +1 }; +bch2_btree_iter_set_pos (&iter,disk_accounting_pos_to_bpos (&next)); +continue ; + } +accounting_read_key (trans, k); }));if (ret)
@@ -732,6 +744,11 @@ int bch2_accounting_read(struct bch_fs *c)darray_for_each (*keys, i) {if (i->k->k.type == KEY_TYPE_accounting) { +struct disk_accounting_pos acc_k; +bpos_to_disk_accounting_pos (&acc_k, i->k->k.p); +if (!bch2_accounting_is_mem (acc_k)) +continue ; +struct bkey_s_c k =bkey_i_to_s_c (i->k); unsigned idx = eytzinger0_find(acc->k.data, acc->k.nr, sizeof(acc->k.data[0]),
fs/bcachefs/disk_accounting.h +17 -8
@@ -63,20 +63,24 @@ static inline void fs_usage_data_type_to_base(struct bch_fs_usage_base *fs_usagestatic inline void bpos_to_disk_accounting_pos (struct disk_accounting_pos *acc,struct bpos p) { - acc->_pad = p; +BUILD_BUG_ON (sizeof (*acc) !=sizeof (p)); +#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -bch2_bpos_swab (&acc->_pad); + acc->_pad = p; +#else +memcpy_swab (acc, &p,sizeof (p));#endif } -static inline struct bpos disk_accounting_pos_to_bpos (struct disk_accounting_pos *k) +static inline struct bpos disk_accounting_pos_to_bpos (struct disk_accounting_pos *acc) { -struct bpos ret = k->_pad; - +struct bpos p;#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ -bch2_bpos_swab (&ret); + p = acc->_pad; +#else +memcpy_swab (&p, acc,sizeof (p));#endif -return ret; +return p; } int bch2_disk_accounting_mod(struct btree_trans *, struct disk_accounting_pos *,
@@ -114,6 +118,11 @@ enum bch_accounting_mode {int bch2_accounting_mem_insert (struct bch_fs *,struct bkey_s_c_accounting ,enum bch_accounting_mode );void bch2_accounting_mem_gc (struct bch_fs *); +static inline bool bch2_accounting_is_mem (struct disk_accounting_pos acc) +{ +return acc.type != BCH_DISK_ACCOUNTING_inum; +} +/* * Update in memory counters so they match the btree update we're doing; called * from transaction commit path
@@ -130,7 +139,7 @@ static inline int bch2_accounting_mem_mod_locked(struct btree_trans *trans,EBUG_ON (gc && !acc->gc_running); -if (acc_k.type == BCH_DISK_ACCOUNTING_inum) +if (!bch2_accounting_is_mem (acc_k))return 0 ;if (mode == BCH_ACCOUNTING_normal) {
fs/bcachefs/sb-downgrade.c +12 -2
@@ -86,7 +86,12 @@ BIT_ULL(BCH_RECOVERY_PASS_check_backpointers_to_extents)|\ BIT_ULL(BCH_RECOVERY_PASS_check_extents_to_backpointers),\ BCH_FSCK_ERR_backpointer_to_missing_ptr, \ - BCH_FSCK_ERR_ptr_to_missing_backpointer) + BCH_FSCK_ERR_ptr_to_missing_backpointer) \ +x (disk_accounting_big_endian, \ +BIT_ULL (BCH_RECOVERY_PASS_check_allocations), \ + BCH_FSCK_ERR_accounting_mismatch, \ + BCH_FSCK_ERR_accounting_key_replicas_nr_devs_0, \ + BCH_FSCK_ERR_accounting_key_junk_at_end)#define DOWNGRADE_TABLE () \ x(bucket_stripe_sectors, \
@@ -129,7 +134,12 @@BIT_ULL (BCH_RECOVERY_PASS_check_extents_to_backpointers),\ BCH_FSCK_ERR_backpointer_bucket_offset_wrong, \ BCH_FSCK_ERR_backpointer_to_missing_ptr, \ - BCH_FSCK_ERR_ptr_to_missing_backpointer) + BCH_FSCK_ERR_ptr_to_missing_backpointer) \ + x(disk_accounting_big_endian, \ + BIT_ULL(BCH_RECOVERY_PASS_check_allocations), \ + BCH_FSCK_ERR_accounting_mismatch, \ + BCH_FSCK_ERR_accounting_key_replicas_nr_devs_0, \ + BCH_FSCK_ERR_accounting_key_junk_at_end) struct upgrade_downgrade_entry { u64 recovery_passes;
fs/bcachefs/util.h +9 -0
@@ -709,4 +709,13 @@ static inline bool test_bit_le64(size_t bit, __le64 *addr) return (addr[bit / 64] & cpu_to_le64(BIT_ULL(bit % 64))) != 0; } +static inline void memcpy_swab (void *_dst,void *_src,size_t len) +{ +u8 *dst = _dst + len; +u8 *src = _src; + +while (len--) + *--dst = *src++; +} +#endif /* _BCACHEFS_UTIL_H */
Signature · 1 line
2.45.2
PATCH 3/8 bcachefs: bch2_extent_ptr_to_bp() no longer depends on device
In reply to Kent Overstreetbch_backpointer no longer contains the bucket_offset field, it's just a direct LBA mapping (with low bits to account for compressed extent splitting), so we don't need to refer to the device to construct it anymore.
--- fs/bcachefs/backpointers.c | 26 ++++---------------------- fs/bcachefs/backpointers.h | 17 ++++++----------- fs/bcachefs/buckets.c | 7 ++++--- 3 files changed, 14 insertions(+), 36 deletions(-)
fs/bcachefs/backpointers.c +4 -22
@@ -72,26 +72,14 @@ static bool extent_matches_bp(struct bch_fs *c,const union bch_extent_entry *entry;struct extent_ptr_decoded p; -rcu_read_lock ();bkey_for_each_ptr_decode (k.k, ptrs, p, entry) { -struct bpos bucket2;struct bkey_i_backpointer bp2; +bch2_extent_ptr_to_bp (c, btree_id, level, k, p, entry, &bp2); -if (p.ptr.cached) -continue ; - -struct bch_dev *ca =bch2_dev_rcu (c, p.ptr.dev); -if (!ca) -continue ; - -bch2_extent_ptr_to_bp (c, ca, btree_id, level, k, p, entry, &bucket2, &bp2);if (bpos_eq (bp.k->p, bp2.k.p) && - !memcmp (bp.v, &bp2.v,sizeof (bp2.v))) { -rcu_read_unlock (); + !memcmp (bp.v, &bp2.v,sizeof (bp2.v)))return true; - } } -rcu_read_unlock ();return false; }
@@ -585,21 +573,15 @@ static int check_extent_to_backpointers(struct btree_trans *trans, ptrs =bch2_bkey_ptrs_c (k);bkey_for_each_ptr_decode (k.k, ptrs, p, entry) { -struct bpos bucket_pos;struct bkey_i_backpointer bp;if (p.ptr.cached)continue ; -rcu_read_lock (); -struct bch_dev *ca =bch2_dev_rcu_noerror (c, p.ptr.dev); -if (ca) -bch2_extent_ptr_to_bp (c, ca, btree, level, k, p, entry, &bucket_pos, &bp); -rcu_read_unlock (); - -if (!ca) +if (p.ptr.dev ==BCH_SB_MEMBER_INVALID )continue ; +bch2_extent_ptr_to_bp (c, btree, level, k, p, entry, &bp); ret =check_bp_exists (trans, s, &bp, k);if (ret)return ret;
fs/bcachefs/backpointers.h +6 -11
@@ -140,20 +140,15 @@ static inline enum bch_data_type bch2_bkey_ptr_data_type(struct bkey_s_c k, } } -static inline void __bch2_extent_ptr_to_bp (struct bch_fs *c,struct bch_dev *ca, +static inline void __bch2_extent_ptr_to_bp (enum btree_id btree_id,unsigned level,struct bkey_s_c k,struct extent_ptr_decoded p,const union bch_extent_entry *entry, -struct bpos *bucket,struct bkey_i_backpointer *bp, +struct bkey_i_backpointer *bp,u64 sectors) { -u32 bucket_offset; - *bucket =PTR_BUCKET_POS_OFFSET (ca, &p.ptr, &bucket_offset); - -u64 bp_bucket_offset = ((u64 ) bucket_offset <<MAX_EXTENT_COMPRESS_RATIO_SHIFT ) + p.crc.offset; -bkey_backpointer_init (&bp->k_i); - bp->k.p =bucket_pos_to_bp (ca, *bucket, bp_bucket_offset); + bp->k.p =POS (p.ptr.dev, ((u64 ) p.ptr.offset <<MAX_EXTENT_COMPRESS_RATIO_SHIFT ) + p.crc.offset); bp->v = (struct bch_backpointer ) { .btree_id = btree_id, .level = level,
@@ -164,15 +159,15 @@ static inline void __bch2_extent_ptr_to_bp(struct bch_fs *c, struct bch_dev *ca, }; } -static inline void bch2_extent_ptr_to_bp (struct bch_fs *c,struct bch_dev *ca, +static inline void bch2_extent_ptr_to_bp (struct bch_fs *c,enum btree_id btree_id,unsigned level,struct bkey_s_c k,struct extent_ptr_decoded p,const union bch_extent_entry *entry, -struct bpos *bucket_pos,struct bkey_i_backpointer *bp) +struct bkey_i_backpointer *bp) {u64 sectors =ptr_disk_sectors (level ?btree_sectors (c) : k.k->size, p); -__bch2_extent_ptr_to_bp (c, ca, btree_id, level, k, p, entry, bucket_pos, bp, sectors); +__bch2_extent_ptr_to_bp (btree_id, level, k, p, entry, bp, sectors); } struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *, struct bkey_s_c_backpointer,
fs/bcachefs/buckets.c +4 -3
@@ -577,6 +577,9 @@ static int bch2_trigger_pointer(struct btree_trans *trans,u64 abs_sectors =ptr_disk_sectors (level ?btree_sectors (c) : k.k->size, p); *sectors = insert ? abs_sectors : -abs_sectors; +struct bkey_i_backpointer bp; +__bch2_extent_ptr_to_bp (btree_id, level, k, p, entry, &bp, abs_sectors); +struct bch_dev *ca =bch2_dev_tryget (c, p.ptr.dev);if (unlikely (!ca)) {if (insert && p.ptr.dev !=BCH_SB_MEMBER_INVALID )
@@ -584,9 +587,7 @@ static int bch2_trigger_pointer(struct btree_trans *trans, goto err; } -struct bpos bucket; -struct bkey_i_backpointer bp; -__bch2_extent_ptr_to_bp (trans->c, ca, btree_id, level, k, p, entry, &bucket, &bp, abs_sectors); +struct bpos bucket =PTR_BUCKET_POS (ca, &p.ptr);if (flags & BTREE_TRIGGER_transactional) {struct bkey_i_alloc_v4 *a =bch2_trans_start_alloc_update (trans, bucket,0 );
Signature · 1 line
2.45.2
PATCH 4/8 bcachefs: kill __bch2_extent_ptr_to_bp()
In reply to Kent Overstreet--- fs/bcachefs/backpointers.h | 18 +++--------------- fs/bcachefs/buckets.c | 7 +++---- 2 files changed, 6 insertions(+), 19 deletions(-)
fs/bcachefs/backpointers.h +3 -15
@@ -140,12 +140,11 @@ static inline enum bch_data_type bch2_bkey_ptr_data_type(struct bkey_s_c k, } } -static inline void __bch2_extent_ptr_to_bp ( +static inline void bch2_extent_ptr_to_bp (struct bch_fs *c,enum btree_id btree_id,unsigned level,struct bkey_s_c k,struct extent_ptr_decoded p,const union bch_extent_entry *entry, -struct bkey_i_backpointer *bp, -u64 sectors) +struct bkey_i_backpointer *bp) {bkey_backpointer_init (&bp->k_i); bp->k.p =POS (p.ptr.dev, ((u64 ) p.ptr.offset <<MAX_EXTENT_COMPRESS_RATIO_SHIFT ) + p.crc.offset);
@@ -154,22 +153,11 @@ static inline void __bch2_extent_ptr_to_bp( .level = level, .data_type = bch2_bkey_ptr_data_type(k, p, entry), .bucket_gen = p.ptr.gen, - .bucket_len = sectors, + .bucket_len = ptr_disk_sectors(level ? btree_sectors(c) : k.k->size, p), .pos = k.k->p, }; } -static inline void bch2_extent_ptr_to_bp (struct bch_fs *c, -enum btree_id btree_id,unsigned level, -struct bkey_s_c k,struct extent_ptr_decoded p, -const union bch_extent_entry *entry, -struct bkey_i_backpointer *bp) -{ -u64 sectors =ptr_disk_sectors (level ?btree_sectors (c) : k.k->size, p); - -__bch2_extent_ptr_to_bp (btree_id, level, k, p, entry, bp, sectors); -} -struct bkey_s_c bch2_backpointer_get_key (struct btree_trans *,struct bkey_s_c_backpointer ,struct btree_iter *,unsigned ); struct btree *bch2_backpointer_get_node(struct btree_trans *, struct bkey_s_c_backpointer,
fs/bcachefs/buckets.c +3 -4
@@ -574,11 +574,10 @@ static int bch2_trigger_pointer(struct btree_trans *trans,struct printbuf buf =PRINTBUF ;int ret =0 ; -u64 abs_sectors =ptr_disk_sectors (level ?btree_sectors (c) : k.k->size, p); - *sectors = insert ? abs_sectors : -abs_sectors; -struct bkey_i_backpointer bp; -__bch2_extent_ptr_to_bp (btree_id, level, k, p, entry, &bp, abs_sectors); +bch2_extent_ptr_to_bp (c, btree_id, level, k, p, entry, &bp); + + *sectors = insert ? bp.v.bucket_len : -(s64 ) bp.v.bucket_len;struct bch_dev *ca =bch2_dev_tryget (c, p.ptr.dev);if (unlikely (!ca)) {
Signature · 1 line
2.45.2
PATCH 5/8 bcachefs: check_extents_to_backpointers() now only checks buckets with mismatches
In reply to Kent OverstreetInstead of walking every extent and every backpointer it points to, first sum up backpointers in each bucket and check for mismatches, and only look for missing backpointers if mismatches were detected, and only check extents in those buckets.
This is a major fsck scalability improvement, since the two backpointers passes (backpointers -> extents and extents -> backpointers) are the most expensive fsck passes by far.
--- fs/bcachefs/backpointers.c | 278 ++++++++++++++++++++++++++++++++++--- fs/bcachefs/bcachefs.h | 2 + fs/bcachefs/btree_cache.c | 1 - fs/bcachefs/errcode.h | 1 + 4 files changed, 263 insertions(+), 19 deletions(-)
fs/bcachefs/backpointers.c +260 -18
@@ -566,25 +566,29 @@ static int check_extent_to_backpointers(struct btree_trans *trans, struct bkey_s_c k) {struct bch_fs *c = trans->c; -struct bkey_ptrs_c ptrs; +struct bkey_ptrs_c ptrs =bch2_bkey_ptrs_c (k);const union bch_extent_entry *entry;struct extent_ptr_decoded p; -int ret; - ptrs =bch2_bkey_ptrs_c (k);bkey_for_each_ptr_decode (k.k, ptrs, p, entry) { -struct bkey_i_backpointer bp; -if (p.ptr.cached)continue ;if (p.ptr.dev ==BCH_SB_MEMBER_INVALID )continue ; -bch2_extent_ptr_to_bp (c, btree, level, k, p, entry, &bp); - ret =check_bp_exists (trans, s, &bp, k); -if (ret) -return ret; +rcu_read_lock (); +struct bch_dev *ca =bch2_dev_rcu_noerror (c, p.ptr.dev); +bool check = ca &&test_bit (PTR_BUCKET_NR (ca, &p.ptr), ca->bucket_backpointer_mismatches); +rcu_read_unlock (); + +if (check) { +struct bkey_i_backpointer bp; +bch2_extent_ptr_to_bp (c, btree, level, k, p, entry, &bp); +int ret =check_bp_exists (trans, s, &bp, k); +if (ret) +return ret; + } }return 0 ;
@@ -793,26 +797,259 @@ static int bch2_check_extents_to_backpointers_pass(struct btree_trans *trans,return 0 ; } +enum alloc_sector_counter { + ALLOC_dirty, + ALLOC_cached, + ALLOC_stripe, +ALLOC_SECTORS_NR +}; + +static enum alloc_sector_counter data_type_to_alloc_counter (enum bch_data_type t) +{ +switch (t) { +case BCH_DATA_btree: +case BCH_DATA_user: +return ALLOC_dirty; +case BCH_DATA_cached: +return ALLOC_cached; +case BCH_DATA_stripe: +return ALLOC_stripe; +default : +BUG (); + } +} + +static int check_bucket_backpointer_mismatch_one (struct btree_trans *trans,struct bkey_s_c alloc_k, +struct bkey_buf *last_flushed) +{ +int ret =0 ; +struct bch_alloc_v4 a_convert; +const struct bch_alloc_v4 *a =bch2_alloc_to_v4 (alloc_k, &a_convert); + +if (a->data_type == BCH_DATA_sb || + a->data_type == BCH_DATA_journal || + a->data_type == BCH_DATA_parity) +return 0 ; + +u32 sectors[ALLOC_SECTORS_NR ]; +memset (sectors,0 ,sizeof (sectors)); + +struct bch_dev *ca =bch2_dev_bucket_tryget_noerror (trans->c, alloc_k.k->p); +if (!ca) +return 0 ; + +struct btree_iter iter; +struct bkey_s_c bp_k; +for_each_btree_key_max_norestart (trans, iter, BTREE_ID_backpointers, +bucket_pos_to_bp_start (ca, alloc_k.k->p), +bucket_pos_to_bp_end (ca, alloc_k.k->p),0 , bp_k, ret) { +if (bp_k.k->type != KEY_TYPE_backpointer) +continue ; + +struct bkey_s_c_backpointer bp =bkey_s_c_to_backpointer (bp_k); + +if (bp.v->bucket_gen != a->gen) +continue ; + + sectors[data_type_to_alloc_counter (bp.v->data_type)] += bp.v->bucket_len; + }; +bch2_trans_iter_exit (trans, &iter); +if (ret) + goto err; + +/* Cached pointers don't have backpointers: */ + +if (sectors[ALLOC_dirty] != a->dirty_sectors || + sectors[ALLOC_stripe] != a->stripe_sectors) { + ret =bch2_backpointers_maybe_flush (trans, alloc_k, last_flushed); +if (ret) + goto err; + +__set_bit (alloc_k.k->p.offset, ca->bucket_backpointer_mismatches); + } +err: +bch2_dev_put (ca); +return ret; +} + +static int check_bucket_backpointer_mismatches (struct btree_trans *trans, +struct bkey_buf *last_flushed) +{ +return for_each_btree_key (trans, iter, BTREE_ID_alloc, +POS_MIN , BTREE_ITER_prefetch, k, ({ +check_bucket_backpointer_mismatch_one (trans, k, last_flushed); + })); +} + +static bool backpointer_node_has_missing (struct bch_fs *c,struct bkey_s_c k) +{ +switch (k.k->type) { +case KEY_TYPE_btree_ptr_v2: { +bool ret = false; + +rcu_read_lock (); +struct bpos pos =bkey_s_c_to_btree_ptr_v2 (k).v->min_key; +while (pos.inode <= k.k->p.inode) { +struct bch_dev *ca =bch2_dev_rcu_noerror (c, pos.inode); +if (!ca) + goto next; + +struct bpos bucket =bp_pos_to_bucket (ca, pos); + bucket.offset =find_next_bit (ca->bucket_backpointer_mismatches, + ca->mi.nbuckets, bucket.offset); +if (bucket.offset == ca->mi.nbuckets) + goto next; + + ret =bpos_le (bucket_pos_to_bp_end (ca, bucket), k.k->p); +if (ret) +break ; +next: + pos =SPOS (pos.inode +1 ,0 ,0 ); + } +rcu_read_unlock (); + +return ret; + } +case KEY_TYPE_btree_ptr: +return true; +default : +return false; + } +} + +static int btree_node_get_and_pin (struct btree_trans *trans,struct bkey_i *k, +enum btree_id btree,unsigned level) +{ +struct btree_iter iter; +bch2_trans_node_iter_init (trans, &iter, btree, k->k.p,0 , level,0 ); +struct btree *b =bch2_btree_iter_peek_node (&iter); +int ret =PTR_ERR_OR_ZERO (b); +if (ret) + goto err; + +if (b) +bch2_node_pin (trans->c, b); +err: +bch2_trans_iter_exit (trans, &iter); +return ret; +} + +static int bch2_pin_backpointer_nodes_with_missing (struct btree_trans *trans, +struct bpos start,struct bpos *end) +{ +struct bch_fs *c = trans->c; +int ret =0 ; + +struct bkey_buf tmp; +bch2_bkey_buf_init (&tmp); + +bch2_btree_cache_unpin (c); + + *end =SPOS_MAX ; + +s64 mem_may_pin =mem_may_pin_bytes (c); +struct btree_iter iter; +bch2_trans_node_iter_init (trans, &iter, BTREE_ID_backpointers, start, +0 ,1 , BTREE_ITER_prefetch); + ret =for_each_btree_key_continue (trans, iter,0 , k, ({ +if (!backpointer_node_has_missing (c, k)) +continue ; + + mem_may_pin -= c->opts.btree_node_size; +if (mem_may_pin <=0 ) +break ; + +bch2_bkey_buf_reassemble (&tmp, c, k); +struct btree_path *path =btree_iter_path (trans, &iter); + +BUG_ON (path->level !=1 ); + +bch2_btree_node_prefetch (trans, path, tmp.k, path->btree_id, path->level -1 ); + })); +if (ret) +return ret; + +struct bpos pinned =SPOS_MAX ; + mem_may_pin =mem_may_pin_bytes (c); +bch2_trans_node_iter_init (trans, &iter, BTREE_ID_backpointers, start, +0 ,1 , BTREE_ITER_prefetch); + ret =for_each_btree_key_continue (trans, iter,0 , k, ({ +if (!backpointer_node_has_missing (c, k)) +continue ; + + mem_may_pin -= c->opts.btree_node_size; +if (mem_may_pin <=0 ) { + *end = pinned; +break ; + } + +bch2_bkey_buf_reassemble (&tmp, c, k); +struct btree_path *path =btree_iter_path (trans, &iter); + +BUG_ON (path->level !=1 ); + +int ret2 =btree_node_get_and_pin (trans, tmp.k, path->btree_id, path->level -1 ); + +if (!ret2) + pinned = tmp.k->k.p; + + ret; + })); +if (ret) +return ret; + +return ret; +} +int bch2_check_extents_to_backpointers (struct bch_fs *c) { +int ret =0 ; + +/* +* Can't allow devices to come/go/resize while we have bucket bitmaps +* allocated +*/ +lockdep_assert_held (&c->state_lock); + +for_each_member_device (c, ca) { +BUG_ON (ca->bucket_backpointer_mismatches); + ca->bucket_backpointer_mismatches =kvcalloc (BITS_TO_LONGS (ca->mi.nbuckets), +sizeof (unsigned long ), +GFP_KERNEL ); +if (!ca->bucket_backpointer_mismatches) { +bch2_dev_put (ca); + ret = -BCH_ERR_ENOMEM_backpointer_mismatches_bitmap; + goto err_free_bitmaps; + } + } +struct btree_trans *trans =bch2_trans_get (c);struct extents_to_bp_state s = { .bp_start =POS_MIN }; -int ret;bch2_bkey_buf_init (&s.last_flushed);bkey_init (&s.last_flushed.k->k); + ret =check_bucket_backpointer_mismatches (trans, &s.last_flushed); +if (ret) + goto err; + +u64 nr_buckets =0 , nr_mismatches =0 ; +for_each_member_device (c, ca) { + nr_buckets += ca->mi.nbuckets; + nr_mismatches +=bitmap_weight (ca->bucket_backpointer_mismatches, ca->mi.nbuckets); + } + +if (!nr_mismatches) + goto err; + +bch_info (c,"scanning for missing backpointers in %llu/%llu buckets" , + nr_mismatches, nr_buckets); +while (1 ) { -struct bbpos end; - ret =bch2_get_btree_in_memory_pos (trans, -BIT_ULL (BTREE_ID_backpointers), -BIT_ULL (BTREE_ID_backpointers), -BBPOS (BTREE_ID_backpointers, s.bp_start), &end); + ret =bch2_pin_backpointer_nodes_with_missing (trans, s.bp_start, &s.bp_end);if (ret)break ; - s.bp_end = end.pos; -if (bpos_eq (s.bp_start,POS_MIN ) && !bpos_eq (s.bp_end,SPOS_MAX )) bch_verbose(c, "%s(): alloc info does not fit in ram, running in multiple passes with %zu nodes per pass",
@@ -837,10 +1074,15 @@ int bch2_check_extents_to_backpointers(struct bch_fs *c) s.bp_start =bpos_successor (s.bp_end); } +err:bch2_trans_put (trans);bch2_bkey_buf_exit (&s.last_flushed, c); -bch2_btree_cache_unpin (c); +err_free_bitmaps: +for_each_member_device (c, ca) { +kvfree (ca->bucket_backpointer_mismatches); + ca->bucket_backpointer_mismatches =NULL ; + }bch_err_fn (c, ret);return ret;
fs/bcachefs/bcachefs.h +2 -0
@@ -557,6 +557,8 @@ struct bch_dev {unsigned long *buckets_nouse;struct rw_semaphore bucket_lock; +unsigned long *bucket_backpointer_mismatches; +struct bch_dev_usage __percpu *usage;/* Allocator: */
fs/bcachefs/btree_cache.c +0 -1
@@ -222,7 +222,6 @@ void bch2_node_pin(struct bch_fs *c, struct btree *b)struct btree_cache *bc = &c->btree_cache;mutex_lock (&bc->lock); -BUG_ON (!__btree_node_pinned (bc, b));if (b !=btree_node_root (c, b) && !btree_node_pinned (b)) {set_btree_node_pinned (b);list_move (&b->list, &bc->live[1 ].list);
fs/bcachefs/errcode.h +1 -0
@@ -54,6 +54,7 @@ x(ENOMEM, ENOMEM_compression_bounce_read_init) \ x(ENOMEM, ENOMEM_compression_bounce_write_init) \ x(ENOMEM, ENOMEM_compression_workspace_init) \ + x(ENOMEM, ENOMEM_backpointer_mismatches_bitmap) \ x(EIO, compression_workspace_not_initialized) \ x(ENOMEM, ENOMEM_bucket_gens) \x (ENOMEM , ENOMEM_buckets_nouse) \
Signature · 1 line
2.45.2
PATCH 6/8 bcachefs: Add write buffer flush param to backpointer_get_key()
In reply to Kent OverstreetIn an upcoming patch bch2_backpointer_get_key() will be repairing when it finds a dangling backpointer; it will need to flush the btree write buffer before it can definitively say there's an error.
--- fs/bcachefs/backpointers.c | 12 +++++++----- fs/bcachefs/backpointers.h | 5 +++-- fs/bcachefs/ec.c | 14 ++++++++++---- fs/bcachefs/move.c | 8 ++++++-- 4 files changed, 26 insertions(+), 13 deletions(-)
fs/bcachefs/backpointers.c +7 -5
@@ -217,7 +217,8 @@ static void backpointer_target_not_found(struct btree_trans *trans,struct bkey_s_c bch2_backpointer_get_key (struct btree_trans *trans,struct bkey_s_c_backpointer bp,struct btree_iter *iter, -unsigned iter_flags) +unsigned iter_flags, +struct bkey_buf *last_flushed) {struct bch_fs *c = trans->c;
@@ -244,7 +245,7 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,backpointer_target_not_found (trans, bp, k);return bkey_s_c_null; }else { -struct btree *b =bch2_backpointer_get_node (trans, bp, iter); +struct btree *b =bch2_backpointer_get_node (trans, bp, iter, last_flushed);if (IS_ERR_OR_NULL (b)) {bch2_trans_iter_exit (trans, iter);
@@ -256,7 +257,8 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,struct btree *bch2_backpointer_get_node (struct btree_trans *trans,struct bkey_s_c_backpointer bp, -struct btree_iter *iter) +struct btree_iter *iter, +struct bkey_buf *last_flushed) {struct bch_fs *c = trans->c;
@@ -485,7 +487,7 @@ static int check_bp_exists(struct btree_trans *trans,struct bkey_s_c_backpointer other_bp =bkey_s_c_to_backpointer (bp_k);struct bkey_s_c other_extent = -bch2_backpointer_get_key (trans, other_bp, &other_extent_iter,0 ); +bch2_backpointer_get_key (trans, other_bp, &other_extent_iter,0 , &s->last_flushed); ret =bkey_err (other_extent);if (ret == -BCH_ERR_backpointer_to_overwritten_btree_node) ret =0 ;
@@ -1107,7 +1109,7 @@ static int check_one_backpointer(struct btree_trans *trans,return 0 ;struct btree_iter iter; -struct bkey_s_c k =bch2_backpointer_get_key (trans, bp, &iter,0 ); +struct bkey_s_c k =bch2_backpointer_get_key (trans, bp, &iter,0 , last_flushed);int ret =bkey_err (k);if (ret == -BCH_ERR_backpointer_to_overwritten_btree_node)return 0 ;
fs/bcachefs/backpointers.h +3 -2
@@ -158,10 +158,11 @@ static inline void bch2_extent_ptr_to_bp(struct bch_fs *c, }; } +struct bkey_buf ;struct bkey_s_c bch2_backpointer_get_key (struct btree_trans *,struct bkey_s_c_backpointer , -struct btree_iter *,unsigned ); +struct btree_iter *,unsigned ,struct bkey_buf *);struct btree *bch2_backpointer_get_node (struct btree_trans *,struct bkey_s_c_backpointer , -struct btree_iter *); +struct btree_iter *,struct bkey_buf *);int bch2_check_btree_backpointers (struct bch_fs *);int bch2_check_extents_to_backpointers (struct bch_fs *);
fs/bcachefs/ec.c +10 -4
@@ -1276,7 +1276,8 @@ static int ec_stripe_update_extent(struct btree_trans *trans,struct bch_dev *ca, struct bpos bucket, u8 gen, struct ec_stripe_buf *s, - struct bkey_s_c_backpointer bp) + struct bkey_s_c_backpointer bp, + struct bkey_buf *last_flushed) { struct bch_stripe *v = &bkey_i_to_stripe(&s->key)->v;struct bch_fs *c = trans->c;
@@ -1293,7 +1294,7 @@ static int ec_stripe_update_extent(struct btree_trans *trans,struct btree_iter node_iter;struct btree *b; - b =bch2_backpointer_get_node (trans, bp, &node_iter); + b =bch2_backpointer_get_node (trans, bp, &node_iter, last_flushed);bch2_trans_iter_exit (trans, &node_iter);if (!b)
@@ -1307,7 +1308,7 @@ static int ec_stripe_update_extent(struct btree_trans *trans,return -EIO ; } - k =bch2_backpointer_get_key (trans, bp, &iter, BTREE_ITER_intent); + k =bch2_backpointer_get_key (trans, bp, &iter, BTREE_ITER_intent, last_flushed); ret =bkey_err (k);if (ret)return ret;
@@ -1374,6 +1375,10 @@ static int ec_stripe_update_bucket(struct btree_trans *trans, struct ec_stripe_bstruct bpos bucket_pos =PTR_BUCKET_POS (ca, &ptr); +struct bkey_buf last_flushed; +bch2_bkey_buf_init (&last_flushed); +bkey_init (&last_flushed.k->k); + ret = for_each_btree_key_max_commit(trans, bp_iter, BTREE_ID_backpointers, bucket_pos_to_bp_start(ca, bucket_pos), bucket_pos_to_bp_end(ca, bucket_pos), 0, bp_k,
@@ -1387,9 +1392,10 @@ static int ec_stripe_update_bucket(struct btree_trans *trans, struct ec_stripe_bcontinue ;ec_stripe_update_extent (trans, ca, bucket_pos, ptr.gen, s, -bkey_s_c_to_backpointer (bp_k)); +bkey_s_c_to_backpointer (bp_k), &last_flushed); })); +bch2_bkey_buf_exit (&last_flushed, c);bch2_dev_put (ca);return ret; }
fs/bcachefs/move.c +6 -2
@@ -675,6 +675,7 @@ int bch2_evacuate_bucket(struct moving_context *ctxt,struct bkey_s_c k;struct data_update_opts data_opts;unsigned sectors_moved =0 ; +struct bkey_buf last_flushed;int ret =0 ;struct bch_dev *ca =bch2_dev_tryget (c, bucket.inode);
@@ -683,6 +684,8 @@ int bch2_evacuate_bucket(struct moving_context *ctxt,trace_bucket_evacuate (c, &bucket); +bch2_bkey_buf_init (&last_flushed); +bkey_init (&last_flushed.k->k);bch2_bkey_buf_init (&sk);/*
@@ -724,7 +727,7 @@ int bch2_evacuate_bucket(struct moving_context *ctxt,struct bkey_s_c_backpointer bp =bkey_s_c_to_backpointer (k);if (!bp.v->level) { - k =bch2_backpointer_get_key (trans, bp, &iter,0 ); + k =bch2_backpointer_get_key (trans, bp, &iter,0 , &last_flushed); ret =bkey_err (k);if (bch2_err_matches (ret, BCH_ERR_transaction_restart))continue ;
@@ -782,7 +785,7 @@ int bch2_evacuate_bucket(struct moving_context *ctxt, }else {struct btree *b; - b =bch2_backpointer_get_node (trans, bp, &iter); + b =bch2_backpointer_get_node (trans, bp, &iter, &last_flushed); ret =PTR_ERR_OR_ZERO (b);if (ret == -BCH_ERR_backpointer_to_overwritten_btree_node)continue ;
@@ -820,6 +823,7 @@ int bch2_evacuate_bucket(struct moving_context *ctxt,bch2_trans_iter_exit (trans, &bp_iter);bch2_dev_put (ca);bch2_bkey_buf_exit (&sk, c); +bch2_bkey_buf_exit (&last_flushed, c);return ret; }
Signature · 1 line
2.45.2
PATCH 7/8 bcachefs: bch2_backpointer_get_key() now repairs dangling backpointers
In reply to Kent OverstreetContinuing on with the self healing theme, we should be running any check and repair code at runtime that we can - instead of declaring the filesystemt inconsistent.
This will also let us skip running the backpointers -> extents fsck pass except in debug mode.
--- fs/bcachefs/backpointers.c | 66 +++++++++++++++----------------------- 1 file changed, 25 insertions(+), 41 deletions(-)
fs/bcachefs/backpointers.c +25 -41
@@ -171,9 +171,10 @@ int bch2_bucket_backpointer_mod_nowritebuffer(struct btree_trans *trans,static int bch2_backpointer_del (struct btree_trans *trans,struct bpos pos) { -return likely (!bch2_backpointers_no_use_write_buffer) - ?bch2_btree_delete_at_buffered (trans, BTREE_ID_backpointers, pos) - :bch2_btree_delete (trans, BTREE_ID_backpointers, pos,0 ); +return (likely (!bch2_backpointers_no_use_write_buffer) + ?bch2_btree_delete_at_buffered (trans, BTREE_ID_backpointers, pos) + :bch2_btree_delete (trans, BTREE_ID_backpointers, pos,0 )) ?: +bch2_trans_commit (trans,NULL ,NULL , BCH_TRANS_COMMIT_no_enospc); } static int bch2_backpointers_maybe_flush(struct btree_trans *trans,
@@ -185,20 +186,23 @@ static int bch2_backpointers_maybe_flush(struct btree_trans *trans, : 0; } -static void backpointer_target_not_found (struct btree_trans *trans, -struct bkey_s_c_backpointer bp, -struct bkey_s_c target_k) +static int backpointer_target_not_found (struct btree_trans *trans, +struct bkey_s_c_backpointer bp, +struct bkey_s_c target_k, +struct bkey_buf *last_flushed) {struct bch_fs *c = trans->c;struct printbuf buf =PRINTBUF ; +int ret =0 ;/* * If we're using the btree write buffer, the backpointer we were * looking at may have already been deleted - failure to find what it * pointed to is not an error: */ -if (likely (!bch2_backpointers_no_use_write_buffer)) -return ; + ret =bch2_backpointers_maybe_flush (trans, bp.s_c, last_flushed); +if (ret) +return ret;prt_printf (&buf,"backpointer doesn't match %s it points to:\n " , bp.v->level ?"btree node" :"extent" );
@@ -206,12 +210,13 @@ static void backpointer_target_not_found(struct btree_trans *trans,prt_printf (&buf,"\n " );bch2_bkey_val_to_text (&buf, c, target_k); -if (c->curr_recovery_pass >= BCH_RECOVERY_PASS_check_extents_to_backpointers) -bch_err_ratelimited (c,"%s" , buf.buf); -else -bch2_trans_inconsistent (trans,"%s" , buf.buf); +if (fsck_err (trans, backpointer_to_missing_ptr, +"%s" , buf.buf)) + ret =bch2_backpointer_del (trans, bp.k->p); +fsck_err:printbuf_exit (&buf); +return ret; } struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,
@@ -242,15 +247,13 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,return k;bch2_trans_iter_exit (trans, iter); -backpointer_target_not_found (trans, bp, k); -return bkey_s_c_null; +int ret =backpointer_target_not_found (trans, bp, k, last_flushed); +return ret ?bkey_s_c_err (ret) : bkey_s_c_null; }else {struct btree *b =bch2_backpointer_get_node (trans, bp, iter, last_flushed); +if (IS_ERR_OR_NULL (b)) +return ((struct bkey_s_c ) { .k =ERR_CAST (b) }); -if (IS_ERR_OR_NULL (b)) { -bch2_trans_iter_exit (trans, iter); -return IS_ERR (b) ?bkey_s_c_err (PTR_ERR (b)) : bkey_s_c_null; - }return bkey_i_to_s_c (&b->key); } }
@@ -283,8 +286,8 @@ struct btree *bch2_backpointer_get_node(struct btree_trans *trans,if (btree_node_will_make_reachable (b)) { b =ERR_PTR (-BCH_ERR_backpointer_to_overwritten_btree_node); }else { -backpointer_target_not_found (trans, bp,bkey_i_to_s_c (&b->key)); - b =NULL ; +int ret =backpointer_target_not_found (trans, bp,bkey_i_to_s_c (&b->key), last_flushed); + b = ret ?ERR_PTR (ret) :NULL ; } err:bch2_trans_iter_exit (trans, iter);
@@ -1100,9 +1103,7 @@ static int check_one_backpointer(struct btree_trans *trans,return 0 ;struct bkey_s_c_backpointer bp =bkey_s_c_to_backpointer (bp_k); -struct bch_fs *c = trans->c;struct bbpos pos =bp_to_bbpos (*bp.v); -struct printbuf buf =PRINTBUF ;if (bbpos_cmp (pos, start) <0 ||bbpos_cmp (pos, end) >0 )
@@ -1116,23 +1117,7 @@ static int check_one_backpointer(struct btree_trans *trans,if (ret)return ret; -if (!k.k) { - ret =bch2_backpointers_maybe_flush (trans, bp.s_c, last_flushed); -if (ret) - goto out; - -if (fsck_err (trans, backpointer_to_missing_ptr, -"backpointer for missing %s\n %s" , - bp.v->level ?"btree node" :"extent" , - (bch2_bkey_val_to_text (&buf, c, bp.s_c), buf.buf))) { - ret =bch2_backpointer_del (trans, bp.k->p); - goto out; - } - } -out: -fsck_err:bch2_trans_iter_exit (trans, &iter); -printbuf_exit (&buf);return ret; }
@@ -1148,9 +1133,8 @@ static int bch2_check_backpointers_to_extents_pass(struct btree_trans *trans,bkey_init (&last_flushed.k->k);progress_init (&progress, trans->c,BIT_ULL (BTREE_ID_backpointers)); -int ret =for_each_btree_key_commit (trans, iter, BTREE_ID_backpointers, -POS_MIN , BTREE_ITER_prefetch, k, -NULL ,NULL , BCH_TRANS_COMMIT_no_enospc, ({ +int ret =for_each_btree_key (trans, iter, BTREE_ID_backpointers, +POS_MIN , BTREE_ITER_prefetch, k, ({progress_update_iter (trans, &progress, &iter,"backpointers_to_extents" );check_one_backpointer (trans, start, end, k, &last_flushed); }));
Signature · 1 line
2.45.2
PATCH 8/8 bcachefs: Only run check_backpointers_to_extents in debug mode
In reply to Kent OverstreetThe backpointers passes, check_backpointers_to_extents() and check_extents_to_backpointers() are the most expensive fsck passes.
Now that we're running the same check and repair code when using a backpointer at runtime (via bch2_backpointer_get_key()) that fsck does, there's no reason fsck needs to - except to verify that the filesystem really has no errors in debug mode.
--- fs/bcachefs/recovery_passes_types.h | 92 +++++++++++++++-------------- fs/bcachefs/sb-errors_format.h | 4 +- 2 files changed, 51 insertions(+), 45 deletions(-)
fs/bcachefs/recovery_passes_types.h +49 -43
@@ -8,53 +8,59 @@#define PASS_ALWAYS BIT(3)#define PASS_ONLINE BIT(4) +#ifdef CONFIG_BCACHEFS_DEBUG +#define PASS_FSCK_DEBUG BIT(1) +#else +#define PASS_FSCK_DEBUG 0 +#endif +/* * Passes may be reordered, but the second field is a persistent identifier and * must never change: */ -#define BCH_RECOVERY_PASSES () \ - x(recovery_pass_empty, 41, PASS_SILENT) \ - x(scan_for_btree_nodes, 37, 0) \ - x(check_topology, 4, 0) \ - x(accounting_read, 39, PASS_ALWAYS) \ - x(alloc_read, 0, PASS_ALWAYS) \ - x(stripes_read, 1, PASS_ALWAYS) \ - x(initialize_subvolumes, 2, 0) \ - x(snapshots_read, 3, PASS_ALWAYS) \ - x(check_allocations, 5, PASS_FSCK) \ - x(trans_mark_dev_sbs, 6, PASS_ALWAYS|PASS_SILENT) \ - x(fs_journal_alloc, 7, PASS_ALWAYS|PASS_SILENT) \ - x(set_may_go_rw, 8, PASS_ALWAYS|PASS_SILENT) \ - x(journal_replay, 9, PASS_ALWAYS) \ - x(check_alloc_info, 10, PASS_ONLINE|PASS_FSCK) \ - x(check_lrus, 11, PASS_ONLINE|PASS_FSCK) \ - x(check_btree_backpointers, 12, PASS_ONLINE|PASS_FSCK) \ - x(check_backpointers_to_extents, 13, PASS_ONLINE|PASS_FSCK) \ - x(check_extents_to_backpointers, 14, PASS_ONLINE|PASS_FSCK) \ - x(check_alloc_to_lru_refs, 15, PASS_ONLINE|PASS_FSCK) \ - x(fs_freespace_init, 16, PASS_ALWAYS|PASS_SILENT) \ - x(bucket_gens_init, 17, 0) \ - x(reconstruct_snapshots, 38, 0) \ - x(check_snapshot_trees, 18, PASS_ONLINE|PASS_FSCK) \ - x(check_snapshots, 19, PASS_ONLINE|PASS_FSCK) \ - x(check_subvols, 20, PASS_ONLINE|PASS_FSCK) \ - x(check_subvol_children, 35, PASS_ONLINE|PASS_FSCK) \ - x(delete_dead_snapshots, 21, PASS_ONLINE|PASS_FSCK) \ - x(fs_upgrade_for_subvolumes, 22, 0) \ - x(check_inodes, 24, PASS_FSCK) \ - x(check_extents, 25, PASS_FSCK) \ - x(check_indirect_extents, 26, PASS_FSCK) \ - x(check_dirents, 27, PASS_FSCK) \ - x(check_xattrs, 28, PASS_FSCK) \ - x(check_root, 29, PASS_ONLINE|PASS_FSCK) \ - x(check_unreachable_inodes, 40, PASS_ONLINE|PASS_FSCK) \ - x(check_subvolume_structure, 36, PASS_ONLINE|PASS_FSCK) \ - x(check_directory_structure, 30, PASS_ONLINE|PASS_FSCK) \ - x(check_nlinks, 31, PASS_FSCK) \ - x(resume_logged_ops, 23, PASS_ALWAYS) \ - x(delete_dead_inodes, 32, PASS_ALWAYS) \ - x(fix_reflink_p, 33, 0) \ - x(set_fs_needs_rebalance, 34, 0) \ +#define BCH_RECOVERY_PASSES () \ + x(recovery_pass_empty, 41, PASS_SILENT) \ + x(scan_for_btree_nodes, 37, 0) \ + x(check_topology, 4, 0) \ + x(accounting_read, 39, PASS_ALWAYS) \ + x(alloc_read, 0, PASS_ALWAYS) \ + x(stripes_read, 1, PASS_ALWAYS) \ + x(initialize_subvolumes, 2, 0) \ + x(snapshots_read, 3, PASS_ALWAYS) \ + x(check_allocations, 5, PASS_FSCK) \ + x(trans_mark_dev_sbs, 6, PASS_ALWAYS|PASS_SILENT) \ + x(fs_journal_alloc, 7, PASS_ALWAYS|PASS_SILENT) \ + x(set_may_go_rw, 8, PASS_ALWAYS|PASS_SILENT) \ + x(journal_replay, 9, PASS_ALWAYS) \ + x(check_alloc_info, 10, PASS_ONLINE|PASS_FSCK) \ + x(check_lrus, 11, PASS_ONLINE|PASS_FSCK) \ + x(check_btree_backpointers, 12, PASS_ONLINE|PASS_FSCK) \ + x(check_backpointers_to_extents, 13, PASS_ONLINE|PASS_FSCK_DEBUG) \ + x(check_extents_to_backpointers, 14, PASS_ONLINE|PASS_FSCK) \ + x(check_alloc_to_lru_refs, 15, PASS_ONLINE|PASS_FSCK) \ + x(fs_freespace_init, 16, PASS_ALWAYS|PASS_SILENT) \ + x(bucket_gens_init, 17, 0) \ + x(reconstruct_snapshots, 38, 0) \ + x(check_snapshot_trees, 18, PASS_ONLINE|PASS_FSCK) \ + x(check_snapshots, 19, PASS_ONLINE|PASS_FSCK) \ + x(check_subvols, 20, PASS_ONLINE|PASS_FSCK) \ + x(check_subvol_children, 35, PASS_ONLINE|PASS_FSCK) \ + x(delete_dead_snapshots, 21, PASS_ONLINE|PASS_FSCK) \ + x(fs_upgrade_for_subvolumes, 22, 0) \ + x(check_inodes, 24, PASS_FSCK) \ + x(check_extents, 25, PASS_FSCK) \ + x(check_indirect_extents, 26, PASS_FSCK) \ + x(check_dirents, 27, PASS_FSCK) \ + x(check_xattrs, 28, PASS_FSCK) \ + x(check_root, 29, PASS_ONLINE|PASS_FSCK) \ + x(check_unreachable_inodes, 40, PASS_ONLINE|PASS_FSCK) \ + x(check_subvolume_structure, 36, PASS_ONLINE|PASS_FSCK) \ + x(check_directory_structure, 30, PASS_ONLINE|PASS_FSCK) \ + x(check_nlinks, 31, PASS_FSCK) \ + x(resume_logged_ops, 23, PASS_ALWAYS) \ + x(delete_dead_inodes, 32, PASS_ALWAYS) \ + x(fix_reflink_p, 33, 0) \ + x(set_fs_needs_rebalance, 34, 0)/* We normally enumerate recovery passes in the order we run them: */ enum bch_recovery_pass {
fs/bcachefs/sb-errors_format.h +2 -2
@@ -140,8 +140,8 @@ enum bch_fsck_flags { x(backpointer_bucket_offset_wrong, 125, 0) \ x(backpointer_level_bad, 294, 0) \ x(backpointer_dev_bad, 297, 0) \ - x(backpointer_to_missing_device, 126, 0) \ - x(backpointer_to_missing_alloc, 127, 0) \ + x(backpointer_to_missing_device, 126, FSCK_AUTOFIX) \ + x(backpointer_to_missing_alloc, 127, FSCK_AUTOFIX) \ x(backpointer_to_missing_ptr, 128, FSCK_AUTOFIX) \ x(lru_entry_at_time_0, 129, FSCK_AUTOFIX) \x (lru_entry_to_invalid_bucket,130 ,FSCK_AUTOFIX ) \
Signature · 1 line
2.45.2