bcachefs: bch2_btree_iter_peek_slot() handles navigating to nonexistent depth
PATCH 1/11 bcachefs: bch2_btree_iter_peek_slot() handles navigating to nonexistent depth
--- fs/bcachefs/btree_iter.c | 4 ++++ 1 file changed, 4 insertions(+)
fs/bcachefs/btree_iter.c +4 -0
@@ -2770,6 +2770,10 @@ struct bkey_s_c bch2_btree_iter_peek_slot(struct btree_iter *iter) goto out_no_locked; } +struct btree_path *path =btree_iter_path (trans, iter); +if (unlikely (!btree_path_node (path, path->level))) +return bkey_s_c_null; +if ((iter->flags & BTREE_ITER_cached) || !(iter->flags & (BTREE_ITER_is_extents|BTREE_ITER_filter_snapshots))) { k = bkey_s_c_null;
Signature · 1 line
2.45.2
PATCH 2/11 bcachefs: backpointer_get_key() doesn't pull in btree node
We may not need to pull in a btree node when walking backpointers - don't do so unnecessarily when using backpointer_get_key().
It'll still fall back to backpointer_get_node() in a few situations, including btree roots (where an iterator can't point at just the key), and races due to the interior update path not having deleted a backpointer to an old node yet.
--- fs/bcachefs/backpointers.c | 34 +++++++++++++++++++--------------- 1 file changed, 19 insertions(+), 15 deletions(-)
fs/bcachefs/backpointers.c +19 -15
@@ -244,27 +244,31 @@ struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,if (unlikely (bp.v->btree_id >=btree_id_nr_alive (c)))return bkey_s_c_null; -if (likely (!bp.v->level)) { -bch2_trans_node_iter_init (trans, iter, - bp.v->btree_id, - bp.v->pos, -0 ,0 , - iter_flags); -struct bkey_s_c k =bch2_btree_iter_peek_slot (iter); -if (bkey_err (k)) { -bch2_trans_iter_exit (trans, iter); -return k; - } +bch2_trans_node_iter_init (trans, iter, + bp.v->btree_id, + bp.v->pos, +0 , + bp.v->level, + iter_flags); +struct bkey_s_c k =bch2_btree_iter_peek_slot (iter); +if (bkey_err (k)) { +bch2_trans_iter_exit (trans, iter); +return k; + } -if (k.k && -extent_matches_bp (c, bp.v->btree_id, bp.v->level, k, bp)) -return k; +if (k.k && +extent_matches_bp (c, bp.v->btree_id, bp.v->level, k, bp)) +return k; -bch2_trans_iter_exit (trans, iter); +bch2_trans_iter_exit (trans, iter); + +if (!bp.v->level) {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 (b ==ERR_PTR (-BCH_ERR_backpointer_to_overwritten_btree_node)) +return bkey_s_c_null;if (IS_ERR_OR_NULL (b))return ((struct bkey_s_c ) { .k =ERR_CAST (b) });
Signature · 1 line
2.45.2
PATCH 3/11 bcachefs: bch2_btree_node_rewrite_key()
In reply to Kent OverstreetAdd a new helper for rewriting a btree node given a just the key, not a pointer to the node itself.
--- fs/bcachefs/btree_update_interior.c | 20 ++++++++++++++++++++ fs/bcachefs/btree_update_interior.h | 4 ++++ 2 files changed, 24 insertions(+)
fs/bcachefs/btree_update_interior.c +20 -0
@@ -2189,6 +2189,26 @@ int bch2_btree_node_rewrite(struct btree_trans *trans, goto out; } +int bch2_btree_node_rewrite_key (struct btree_trans *trans, +enum btree_id btree,unsigned level, +struct bpos pos,unsigned flags) +{ +BUG_ON (!level); + +/* Traverse one depth lower to get a pointer to the node itself: */ +struct btree_iter iter; +bch2_trans_node_iter_init (trans, &iter, btree, pos,0 , level -1 ,0 ); +struct btree *b =bch2_btree_iter_peek_node (&iter); +int ret =PTR_ERR_OR_ZERO (b); +if (ret) + goto err; + + ret =bch2_btree_node_rewrite (trans, &iter, b, flags); +err: +bch2_trans_iter_exit (trans, &iter); +return ret; +} +struct async_btree_rewrite {struct bch_fs *c;struct work_struct work;
fs/bcachefs/btree_update_interior.h +4 -0
@@ -169,7 +169,11 @@ static inline int bch2_foreground_maybe_merge(struct btree_trans *trans,int bch2_btree_node_rewrite (struct btree_trans *,struct btree_iter *,struct btree *,unsigned ); +int bch2_btree_node_rewrite_key (struct btree_trans *, +enum btree_id ,unsigned , +struct bpos ,unsigned );void bch2_btree_node_rewrite_async (struct bch_fs *,struct btree *); +int bch2_btree_node_update_key (struct btree_trans *,struct btree_iter *,struct btree *,struct bkey_i *,unsigned ,bool );
Signature · 1 line
2.45.2
PATCH 4/11 bcachefs: bch2_move_data_phys()
In reply to Kent OverstreetAdd a more general version of bch2_evacuate_bucket - to be used for scrub.
--- fs/bcachefs/chardev.c | 4 +- fs/bcachefs/move.c | 115 +++++++++++++++++++++++++++------------ fs/bcachefs/move_types.h | 15 ++++- fs/bcachefs/trace.h | 52 ------------------ 4 files changed, 94 insertions(+), 92 deletions(-)
fs/bcachefs/chardev.c +2 -2
@@ -312,7 +312,7 @@ static int bch2_data_thread(void *arg) struct bch_data_ctx *ctx = container_of(arg, struct bch_data_ctx, thr); ctx->thr.ret =bch2_data_job (ctx->c, &ctx->stats, ctx->arg); - ctx->stats.data_type =U8_MAX ; + ctx->stats.done = true;return 0 ; }
@@ -332,7 +332,7 @@ static ssize_t bch2_data_job_read(struct file *file, char __user *buf,struct bch_fs *c = ctx->c;struct bch_ioctl_data_event e = { .type =BCH_DATA_EVENT_PROGRESS , - .p.data_type = ctx->stats.data_type, + .p.data_type = ctx->stats.done ?U8_MAX : ctx->stats.data_type, .p.btree_id = ctx->stats.pos.btree, .p.pos = ctx->stats.pos.pos, .p.sectors_done =atomic64_read (&ctx->stats.sectors_seen),
fs/bcachefs/move.c +79 -36
204 lines not on this page · raw message
fs/bcachefs/move_types.h +13 -2
@@ -5,9 +5,20 @@#include "bbpos_types.h" struct bch_move_stats { -enum bch_data_type data_type; -struct bbpos pos;char name[32 ]; +bool phys; +bool done; + +union { +struct { +enum bch_data_type data_type; +struct bbpos pos; + }; +struct { +unsigned dev; +u64 offset; + }; + };atomic64_t keys_moved;atomic64_t keys_raced;
fs/bcachefs/trace.h +0 -52
64 lines not on this page · raw message
Signature · 1 line
2.45.2
PATCH 5/11 bcachefs: __bch2_move_data_phys() now uses bch2_btree_node_rewrite_key()
In reply to Kent OverstreetKill most of the separate logic for btree nodes.
--- fs/bcachefs/move.c | 107 ++++++++++++++++----------------------------- 1 file changed, 37 insertions(+), 70 deletions(-)
fs/bcachefs/move.c +37 -70
@@ -771,91 +771,58 @@ static int __bch2_move_data_phys(struct moving_context *ctxt,struct bkey_s_c_backpointer bp =bkey_s_c_to_backpointer (k);if (ctxt->stats) - ctxt->stats->offset = - bp.k->p.offset >>MAX_EXTENT_COMPRESS_RATIO_SHIFT ; + ctxt->stats->offset = bp.k->p.offset >>MAX_EXTENT_COMPRESS_RATIO_SHIFT ; -if (!bp.v->level) { - 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 ; -if (ret) - goto err; -if (!k.k) - goto next; + 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 ; +if (ret) + goto err; +if (!k.k) + goto next; +if (!bp.v->level) { ret =bch2_move_get_io_opts_one (trans, &io_opts, &iter, k);if (ret) {bch2_trans_iter_exit (trans, &iter);continue ; } + } -struct data_update_opts data_opts = {}; -if (!pred (c, arg, k, &io_opts, &data_opts)) { -bch2_trans_iter_exit (trans, &iter); - goto next; - } - -bch2_bkey_buf_reassemble (&sk, c, k); - k =bkey_i_to_s_c (sk.k); - -unsigned sectors = bp.v->bucket_len;/* move_extent will drop locks */ - - ret =bch2_move_extent (ctxt, bucket_in_flight, - &iter, k, io_opts, data_opts); +struct data_update_opts data_opts = {}; +if (!pred (c, arg, k, &io_opts, &data_opts)) {bch2_trans_iter_exit (trans, &iter); + goto next; + } -if (bch2_err_matches (ret, BCH_ERR_transaction_restart)) -continue ; -if (ret == -ENOMEM ) { -/* memory allocation failure, wait for some IO to finish */ -bch2_move_ctxt_wait_for_io (ctxt); -continue ; - } -if (ret) - goto err; - -if (ctxt->stats) -atomic64_add (sectors, &ctxt->stats->sectors_seen); - sectors_moved += sectors; - }else { -struct btree *b; - - 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) - goto next; -if (bch2_err_matches (ret, BCH_ERR_transaction_restart)) -continue ; -if (ret) - goto err; -if (!b) - goto next; - -struct data_update_opts data_opts = {}; -if (!pred (c, arg,bkey_i_to_s_c (&b->key), &io_opts, &data_opts)) { -bch2_trans_iter_exit (trans, &iter); - goto next; - } +bch2_bkey_buf_reassemble (&sk, c, k); + k =bkey_i_to_s_c (sk.k); -unsigned sectors =btree_ptr_sectors_written (bkey_i_to_s_c (&b->key)); +/* move_extent will drop locks */ +unsigned sectors = !bp.v->level + ? bp.v->bucket_len + :btree_ptr_sectors_written (k); - ret =bch2_btree_node_rewrite (trans, &iter, b,0 ); -bch2_trans_iter_exit (trans, &iter); + ret = !bp.v->level + ?bch2_move_extent (ctxt, bucket_in_flight, &iter, k, io_opts, data_opts) + :bch2_btree_node_rewrite_key (trans, bp.v->btree_id, bp.v->level, k.k->p,0 ); -if (bch2_err_matches (ret, BCH_ERR_transaction_restart)) -continue ; -if (ret) - goto err; +bch2_trans_iter_exit (trans, &iter); -if (ctxt->rate) -bch2_ratelimit_increment (ctxt->rate, sectors); -if (ctxt->stats) { -atomic64_add (sectors, &ctxt->stats->sectors_seen); -atomic64_add (sectors, &ctxt->stats->sectors_moved); - } - sectors_moved += sectors; +if (bch2_err_matches (ret, BCH_ERR_transaction_restart)) +continue ; +if (ret == -ENOMEM ) { +/* memory allocation failure, wait for some IO to finish */ +bch2_move_ctxt_wait_for_io (ctxt); +continue ; } +if (ret) + goto err; + +if (ctxt->stats) +atomic64_add (sectors, &ctxt->stats->sectors_seen); + sectors_moved += sectors; next:bch2_btree_iter_advance (&bp_iter); }
Signature · 1 line
2.45.2
PATCH 6/11 bcachefs: printbuf_reset() handles tabstops
In reply to Kent Overstreet--- fs/bcachefs/printbuf.h | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-)
fs/bcachefs/printbuf.h +11 -4
@@ -251,16 +251,23 @@ static inline void prt_hex_byte_upper(struct printbuf *out, u8 byte)printbuf_nul_terminate_reserved (out); } +static inline void printbuf_reset_keep_tabstops (struct printbuf *buf) +{ + buf->pos =0 ; + buf->allocation_failure =0 ; + buf->last_newline =0 ; + buf->last_field =0 ; + buf->indent =0 ; + buf->cur_tabstop =0 ; +} +/** * printbuf_reset - re-use a printbuf without freeing and re-initializing it: */ static inline void printbuf_reset (struct printbuf *buf) { - buf->pos =0 ; - buf->allocation_failure =0 ; - buf->indent =0 ; +printbuf_reset_keep_tabstops (buf); buf->nr_tabstops =0 ; - buf->cur_tabstop =0 ; }/**
Signature · 1 line
2.45.2
PATCH 7/11 bcachefs: bch2_bkey_pick_read_device() can now specify a device
In reply to Kent OverstreetTo be used for scrub, where we want the read to come from a specific device.
--- fs/bcachefs/btree_io.c | 4 ++-- fs/bcachefs/debug.c | 2 +- fs/bcachefs/extents.c | 9 +++++++-- fs/bcachefs/extents.h | 2 +- fs/bcachefs/io_read.c | 8 ++++---- fs/bcachefs/io_read.h | 4 ++-- 6 files changed, 17 insertions(+), 12 deletions(-)
fs/bcachefs/btree_io.c +2 -2
@@ -1352,7 +1352,7 @@ static void btree_node_read_work(struct work_struct *work) can_retry =bch2_bkey_pick_read_device (c,bkey_i_to_s_c (&b->key), - &failed, &rb->pick) >0 ; + &failed, &rb->pick,-1 ) >0 ;if (!bio->bi_status && !bch2_btree_node_read_done (c, ca, b, can_retry, &saw_error)) {
@@ -1697,7 +1697,7 @@ void bch2_btree_node_read(struct btree_trans *trans, struct btree *b,return ; ret =bch2_bkey_pick_read_device (c,bkey_i_to_s_c (&b->key), -NULL , &pick); +NULL , &pick,-1 );if (ret <=0 ) {struct printbuf buf =PRINTBUF ;
fs/bcachefs/debug.c +1 -1
@@ -189,7 +189,7 @@ void bch2_btree_node_ondisk_to_text(struct printbuf *out, struct bch_fs *c,unsigned offset =0 ;int ret; -if (bch2_bkey_pick_read_device (c,bkey_i_to_s_c (&b->key),NULL , &pick) <=0 ) { +if (bch2_bkey_pick_read_device (c,bkey_i_to_s_c (&b->key),NULL , &pick,-1 ) <=0 ) {prt_printf (out,"error getting device to read from: invalid device\n" );return ; }
fs/bcachefs/extents.c +7 -2
@@ -114,8 +114,9 @@ static inline bool ptr_better(struct bch_fs *c,* other devices, it will still pick a pointer from avoid. */ int bch2_bkey_pick_read_device (struct bch_fs *c,struct bkey_s_c k, -struct bch_io_failures *failed, -struct extent_ptr_decoded *pick) +struct bch_io_failures *failed, +struct extent_ptr_decoded *pick, +int dev) {struct bkey_ptrs_c ptrs =bch2_bkey_ptrs_c (k);const union bch_extent_entry *entry;
@@ -137,6 +138,10 @@ int bch2_bkey_pick_read_device(struct bch_fs *c, struct bkey_s_c k,break ; } +/* Are we being asked to read from a specific device? */ +if (dev >=0 && p.ptr.dev != dev) +continue ; +/* * If there are any dirty pointers it's an error if we can't * read:
fs/bcachefs/extents.h +1 -1
@@ -404,7 +404,7 @@ void bch2_mark_io_failure(struct bch_io_failures *, struct extent_ptr_decoded *);int bch2_bkey_pick_read_device (struct bch_fs *,struct bkey_s_c ,struct bch_io_failures *, -struct extent_ptr_decoded *); +struct extent_ptr_decoded *,int );/* KEY_TYPE_btree_ptr: */
fs/bcachefs/io_read.c +4 -4
@@ -444,7 +444,7 @@ static void bch2_read_retry_nodecode(struct bch_fs *c, struct bch_read_bio *rbio ret =__bch2_read_extent (trans, rbio, bvec_iter, rbio->read_pos, rbio->data_btree, - k,0 , failed, flags); + k,0 , failed, flags,-1 );if (ret ==READ_RETRY ) goto retry;if (ret)
@@ -878,7 +878,7 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig, struct bvec_iter iter, struct bpos read_pos, enum btree_id data_btree, struct bkey_s_c k, unsigned offset_into_extent, - struct bch_io_failures *failed, unsigned flags) + struct bch_io_failures *failed, unsigned flags, int dev) { struct bch_fs *c = trans->c;struct extent_ptr_decoded pick;
@@ -900,7 +900,7 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig, goto out_read_done; } retry_pick: - pick_ret =bch2_bkey_pick_read_device (c, k, failed, &pick); + pick_ret =bch2_bkey_pick_read_device (c, k, failed, &pick, dev);/* hole or reservation - just zero fill: */ if (!pick_ret)
@@ -1261,7 +1261,7 @@ void __bch2_read(struct bch_fs *c, struct bch_read_bio *rbio, ret =__bch2_read_extent (trans, rbio, bvec_iter, iter.pos, data_btree, k, - offset_into_extent, failed, flags); + offset_into_extent, failed, flags,-1 );if (ret) goto err;
fs/bcachefs/io_read.h +2 -2
@@ -124,7 +124,7 @@ enum bch_read_flags {int __bch2_read_extent (struct btree_trans *,struct bch_read_bio *,struct bvec_iter ,struct bpos ,enum btree_id ,struct bkey_s_c ,unsigned , -struct bch_io_failures *,unsigned ); +struct bch_io_failures *,unsigned ,int ); static inline void bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *rbio, struct bpos read_pos,
@@ -132,7 +132,7 @@ static inline void bch2_read_extent(struct btree_trans *trans, unsigned offset_into_extent, unsigned flags) { __bch2_read_extent(trans, rbio, rbio->bio.bi_iter, read_pos, -data_btree ,k ,offset_into_extent ,NULL ,flags ); + data_btree, k, offset_into_extent, NULL, flags, -1); } void __bch2_read(struct bch_fs *, struct bch_read_bio *, struct bvec_iter,
Signature · 1 line
2.45.2
PATCH 8/11 bcachefs: __bch2_btree_pos_to_text()
In reply to Kent OverstreetFactor out a version of bch2_btree_pos_to_text() that doesn't take a pointer to a in-memory btree node, to be used for btree node scrub.
--- fs/bcachefs/btree_cache.c | 16 +++++++++++----- fs/bcachefs/btree_cache.h | 2 ++ 2 files changed, 13 insertions(+), 5 deletions(-)
fs/bcachefs/btree_cache.c +11 -5
@@ -1402,18 +1402,24 @@ void bch2_btree_id_level_to_text(struct printbuf *out, enum btree_id btree, unsiprt_printf (out," level=%u" , level); } -void bch2_btree_pos_to_text (struct printbuf *out,struct bch_fs *c,const struct btree *b) +void __bch2_btree_pos_to_text (struct printbuf *out,struct bch_fs *c, +enum btree_id btree,unsigned level,struct bkey_s_c k) { -bch2_btree_id_to_text (out, b->c.btree_id); -prt_printf (out," level %u/" , b->c.level); -struct btree_root *r =bch2_btree_id_root (c, b->c.btree_id); +bch2_btree_id_to_text (out, btree); +prt_printf (out," level %u/" , level); +struct btree_root *r =bch2_btree_id_root (c, btree);if (r)prt_printf (out,"%u" , r->level);else prt_printf (out,"(unknown)" );prt_printf (out,"\n " ); -bch2_bkey_val_to_text (out, c,bkey_i_to_s_c (&b->key)); +bch2_bkey_val_to_text (out, c, k); +} + +void bch2_btree_pos_to_text (struct printbuf *out,struct bch_fs *c,const struct btree *b) +{ +__bch2_btree_pos_to_text (out, c, b->c.btree_id, b->c.level,bkey_i_to_s_c (&b->key)); }void bch2_btree_node_to_text (struct printbuf *out,struct bch_fs *c,const struct btree *b)
fs/bcachefs/btree_cache.h +2 -0
@@ -147,6 +147,8 @@ const char *bch2_btree_id_str(enum btree_id); /* avoid */void bch2_btree_id_to_text (struct printbuf *,enum btree_id );void bch2_btree_id_level_to_text (struct printbuf *,enum btree_id ,unsigned ); +void __bch2_btree_pos_to_text (struct printbuf *,struct bch_fs *, +enum btree_id ,unsigned ,struct bkey_s_c );void bch2_btree_pos_to_text (struct printbuf *,struct bch_fs *,const struct btree *);void bch2_btree_node_to_text (struct printbuf *,struct bch_fs *,const struct btree *);void bch2_btree_cache_to_text (struct printbuf *,const struct btree_cache *);
Signature · 1 line
2.45.2
PATCH 9/11 bcachefs: bch2_btree_node_scrub()
In reply to Kent OverstreetAdd a function for scrubbing btree nodes - reading them in, and kicking off a rewrite if there's an error.
The btree_node_read_done() checks have to be duplicated because we're not using a pointer to a struct btree - the btree node might already be in cache, and we need to check a specific replica, which might not be the one we previously read from.
This will be used in the next patch implementing high-level scrub.
--- fs/bcachefs/bcachefs.h | 3 +- fs/bcachefs/btree_io.c | 185 +++++++++++++++++++++++++++++++++++++++++ fs/bcachefs/btree_io.h | 3 + fs/bcachefs/errcode.h | 1 + 4 files changed, 191 insertions(+), 1 deletion(-)
fs/bcachefs/bcachefs.h +2 -1
@@ -687,7 +687,8 @@ struct btree_trans_buf {x (gc_gens) \x (snapshot_delete_pagecache ) \x (sysfs) \ -x (btree_write_buffer) +x (btree_write_buffer) \ +x (btree_node_scrub) enum bch_write_ref {#define x (n) BCH_WRITE_REF_##n,
fs/bcachefs/btree_io.c +185 -0
197 lines not on this page · raw message
fs/bcachefs/btree_io.h +3 -0
@@ -132,6 +132,9 @@ void bch2_btree_node_read(struct btree_trans *, struct btree *, bool);int bch2_btree_root_read (struct bch_fs *,enum btree_id ,const struct bkey_i *,unsigned ); +int bch2_btree_node_scrub (struct btree_trans *,enum btree_id ,unsigned , +struct bkey_s_c ,unsigned ); +bool bch2_btree_post_write_cleanup (struct bch_fs *,struct btree *);enum btree_write_flags {
fs/bcachefs/errcode.h +1 -0
@@ -269,6 +269,7 @@ x(EIO, invalidate_stripe_to_dev) \ x(EIO, no_encryption_key) \ x(EIO, insufficient_journal_devices) \ + x(EIO, device_offline) \ x(BCH_ERR_btree_node_read_err, btree_node_read_err_fixable) \ x(BCH_ERR_btree_node_read_err, btree_node_read_err_want_retry) \x (BCH_ERR_btree_node_read_err, btree_node_read_err_must_retry) \
Signature · 1 line
2.45.2
PATCH 10/11 bcachefs: Internal reads can now correct errors
In reply to Kent OverstreetRework the read path a bit so that BCH_READ_NODECODE reads now also self-heal after a read error and a successful retry - prerequisite for scrub.
--- fs/bcachefs/io_read.c | 59 +++++++++++++++++++++++-------------------- 1 file changed, 31 insertions(+), 28 deletions(-)
fs/bcachefs/io_read.c +31 -28
@@ -740,7 +740,7 @@ static void __bch2_read_endio(struct work_struct *work)bio_copy_data_iter (dst, &dst_iter, src, &src_iter); } } - +nodecode:if (rbio->promote) {/* * Re encrypt data we decrypted, so it's consistent with
@@ -753,7 +753,7 @@ static void __bch2_read_endio(struct work_struct *work)promote_start (rbio->promote, rbio); rbio->promote =NULL ; } -nodecode: +if (likely (!(rbio->flags &BCH_READ_IN_RETRY ))) { rbio =bch2_rbio_free (rbio);bch2_rbio_done (rbio);
@@ -888,6 +888,8 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig,struct bpos data_pos =bkey_start_pos (k.k);int pick_ret; +//BUG_ON(failed && failed->nr); +if (bkey_extent_is_inline_data (k.k)) {unsigned bytes =min_t (unsigned, iter.bi_size,bkey_inline_data_bytes (k.k));
@@ -952,7 +954,30 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig,*/ bch2_trans_unlock (trans); -if (flags &BCH_READ_NODECODE ) { +if (!(flags &BCH_READ_NODECODE )) { +if (!(flags &BCH_READ_LAST_FRAGMENT ) || +bio_flagged (&orig->bio,BIO_CHAIN )) + flags |=BCH_READ_MUST_CLONE ; + + narrow_crcs = !(flags &BCH_READ_IN_RETRY ) && +bch2_can_narrow_extent_crcs (k, pick.crc); + +if (narrow_crcs && (flags &BCH_READ_USER_MAPPED )) + flags |=BCH_READ_MUST_BOUNCE ; + +EBUG_ON (offset_into_extent +bvec_iter_sectors (iter) > k.k->size); + +if (crc_is_compressed (pick.crc) || + (pick.crc.csum_type != BCH_CSUM_none && + (bvec_iter_sectors (iter) != pick.crc.uncompressed_size || + (bch2_csum_type_is_encryption (pick.crc.csum_type) && + (flags &BCH_READ_USER_MAPPED )) || + (flags &BCH_READ_MUST_BOUNCE )))) { + read_full = true; + bounce = true; + } + }else { + read_full = true;/* * can happen if we retry, and the extent we were going to read * has been merged in the meantime:
@@ -964,32 +989,10 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig, } iter.bi_size = pick.crc.compressed_size <<9 ; - goto get_bio; } -if (!(flags &BCH_READ_LAST_FRAGMENT ) || -bio_flagged (&orig->bio,BIO_CHAIN )) - flags |=BCH_READ_MUST_CLONE ; - - narrow_crcs = !(flags &BCH_READ_IN_RETRY ) && -bch2_can_narrow_extent_crcs (k, pick.crc); - -if (narrow_crcs && (flags &BCH_READ_USER_MAPPED )) - flags |=BCH_READ_MUST_BOUNCE ; - -EBUG_ON (offset_into_extent +bvec_iter_sectors (iter) > k.k->size); - -if (crc_is_compressed (pick.crc) || - (pick.crc.csum_type != BCH_CSUM_none && - (bvec_iter_sectors (iter) != pick.crc.uncompressed_size || - (bch2_csum_type_is_encryption (pick.crc.csum_type) && - (flags &BCH_READ_USER_MAPPED )) || - (flags &BCH_READ_MUST_BOUNCE )))) { - read_full = true; - bounce = true; - } - -if (orig->opts.promote_target)// || failed) +if ((orig->opts.promote_target && !(flags &BCH_READ_NODECODE )) || + (failed && failed->nr)) promote =promote_alloc (trans, iter, k, &pick, orig->opts, flags, &rbio, &bounce, &read_full, failed);
@@ -1010,7 +1013,7 @@ int __bch2_read_extent(struct btree_trans *trans, struct bch_read_bio *orig, pick.crc.offset =0 ; pick.crc.live_size =bvec_iter_sectors (iter); } -get_bio: +if (rbio) {/* * promote already allocated bounce rbio:
Signature · 1 line
2.45.2
PATCH 11/11 bcachefs: Scrub
In reply to Kent OverstreetAdd a new data op to walk all data and metadata in a filesystem, checking if it can be read successfully, and on error repairing from another copy if possible.
- New helper: bch2_dev_idx_is_online(), so that we can bail out and report to userspace when we're unable to scrub because the device is offline
- data_update_opts, which controls the data move path, now understands
scrub: data is only read, not written. The read path is responsible for rewriting on read error, as with other reads.
- scrub_pred skips data extents that don't have checksums
- bch_ioctl_data has a new scrub member, which has a data_types field for data types to check - i.e. all data types, or only metadata.
- Add new entries to bch_move_stats so that we can report numbers for corrected and uncorrected errors
- Add a new enum to bch_ioctl_data_event for explicitly reporting completion and return code (i.e. device offline)
--- fs/bcachefs/bcachefs_ioctl.h | 14 +++- fs/bcachefs/chardev.c | 33 +++++++-- fs/bcachefs/data_update.h | 3 + fs/bcachefs/io_read.c | 1 + fs/bcachefs/io_read.h | 1 + fs/bcachefs/move.c | 127 ++++++++++++++++++++++++++++++----- fs/bcachefs/move_types.h | 5 +- fs/bcachefs/sb-members.h | 12 ++++ 8 files changed, 169 insertions(+), 27 deletions(-)
fs/bcachefs/bcachefs_ioctl.h +13 -1
@@ -213,6 +213,10 @@ struct bch_ioctl_data {struct bpos end_pos;union { +struct { +__u32 dev; +__u32 data_types; + } scrub;struct {__u32 dev;__u32 pad;
@@ -237,11 +241,19 @@ struct bch_ioctl_data_progress {__u64 sectors_done;__u64 sectors_total; +__u64 sectors_error_corrected; +__u64 sectors_error_uncorrected; } __packed__aligned(8) ; +enum bch_ioctl_data_event_ret { + BCH_IOCTL_DATA_EVENT_RET_done =1 , + BCH_IOCTL_DATA_EVENT_RET_device_offline =2 , +}; +struct bch_ioctl_data_event {__u8 type; -__u8 pad[7 ]; +__u8 ret; +__u8 pad[6 ];union {struct bch_ioctl_data_progress p;__u64 pad2[15 ];
fs/bcachefs/chardev.c +26 -7
@@ -312,7 +312,10 @@ static int bch2_data_thread(void *arg) struct bch_data_ctx *ctx = container_of(arg, struct bch_data_ctx, thr); ctx->thr.ret =bch2_data_job (ctx->c, &ctx->stats, ctx->arg); - ctx->stats.done = true; +if (ctx->thr.ret == -BCH_ERR_device_offline) + ctx->stats.ret = BCH_IOCTL_DATA_EVENT_RET_device_offline; +else + ctx->stats.ret = BCH_IOCTL_DATA_EVENT_RET_done;return 0 ; }
@@ -331,14 +334,30 @@ static ssize_t bch2_data_job_read(struct file *file, char __user *buf, struct bch_data_ctx *ctx = container_of(file->private_data, struct bch_data_ctx, thr);struct bch_fs *c = ctx->c;struct bch_ioctl_data_event e = { - .type =BCH_DATA_EVENT_PROGRESS , - .p.data_type = ctx->stats.done ?U8_MAX : ctx->stats.data_type, - .p.btree_id = ctx->stats.pos.btree, - .p.pos = ctx->stats.pos.pos, - .p.sectors_done =atomic64_read (&ctx->stats.sectors_seen), - .p.sectors_total =bch2_fs_usage_read_short (c).used, + .type =BCH_DATA_EVENT_PROGRESS , + .ret = ctx->stats.ret, + .p.data_type = ctx->stats.data_type, + .p.btree_id = ctx->stats.pos.btree, + .p.pos = ctx->stats.pos.pos, + .p.sectors_done =atomic64_read (&ctx->stats.sectors_seen), + .p.sectors_error_corrected =atomic64_read (&ctx->stats.sectors_error_corrected), + .p.sectors_error_uncorrected =atomic64_read (&ctx->stats.sectors_error_uncorrected), }; +if (ctx->arg.op == BCH_DATA_OP_scrub) { +struct bch_dev *ca =bch2_dev_tryget (c, ctx->arg.scrub.dev); +if (ca) { +struct bch_dev_usage u; +bch2_dev_usage_read_fast (ca, &u); +for (unsigned i = BCH_DATA_btree; i <ARRAY_SIZE (u.d); i++) +if (ctx->arg.scrub.data_types &BIT (i)) + e.p.sectors_total += u.d[i].sectors; +bch2_dev_put (ca); + } + }else { + e.p.sectors_total =bch2_fs_usage_read_short (c).used; + } +if (len <sizeof (e))return -EINVAL ;
fs/bcachefs/data_update.h +3 -0
@@ -15,6 +15,9 @@ struct data_update_opts {u8 extra_replicas;unsigned btree_insert_flags;unsigned write_flags; + +int read_dev; +bool scrub; }; void bch2_data_update_opts_to_text(struct printbuf *, struct bch_fs *,
fs/bcachefs/io_read.c +1 -0
@@ -499,6 +499,7 @@ static void bch2_rbio_error(struct bch_read_bio *rbio, int retry, blk_status_t error) { rbio->retry = retry; + rbio->saw_error = true;if (rbio->flags &BCH_READ_IN_RETRY )return ;
fs/bcachefs/io_read.h +1 -0
@@ -41,6 +41,7 @@ struct bch_read_bio { have_ioref:1, narrow_crcs:1, hole:1, + saw_error:1, retry:2, context:2; };
fs/bcachefs/move.c +109 -18
199 lines not on this page · raw message
fs/bcachefs/move_types.h +4 -1
@@ -3,11 +3,12 @@#define _BCACHEFS_MOVE_TYPES_H#include "bbpos_types.h" +#include "bcachefs_ioctl.h" struct bch_move_stats { char name[32]; bool phys; - bool done; + enum bch_ioctl_data_event_ret ret; union { struct {
@@ -25,6 +26,8 @@ struct bch_move_stats {atomic64_t sectors_seen;atomic64_t sectors_moved;atomic64_t sectors_raced; +atomic64_t sectors_error_corrected; +atomic64_t sectors_error_uncorrected; };struct move_bucket_key {
fs/bcachefs/sb-members.h +12 -0
@@ -23,6 +23,18 @@ static inline bool bch2_dev_is_online(struct bch_dev *ca)return !percpu_ref_is_zero (&ca->io_ref); } +static inline struct bch_dev *bch2_dev_rcu (struct bch_fs *,unsigned ); + +static inline bool bch2_dev_idx_is_online (struct bch_fs *c,unsigned dev) +{ +rcu_read_lock (); +struct bch_dev *ca =bch2_dev_rcu (c, dev); +bool ret = ca &&bch2_dev_is_online (ca); +rcu_read_unlock (); + +return ret; +} +static inline bool bch2_dev_is_readable (struct bch_dev *ca) { return bch2_dev_is_online(ca) &&
Signature · 1 line
2.45.2