bcachefs async object debugging
cover bcachefs async object debugging
More debugging infrastructure that might perhaps be of wider interest.
Currently, when an asynchronous op gets stuck and never completes, it's a real problem to debug: all our normal introspection (e.g. /proc/pid/stack) doesn't work.
e.g. if a bio doesn't (seem to) complete - what happened to it? Difficult question to answer. We have giant state machines, and debugging issues where we stop making forward progress requires visibility into the whole thing.
(basic question: did the bio complete and the endio not funtion not flip the correct state bit, or did it get lost?)
In the reports/test failures I look at, I've been seeing these the most in or at the boundary of mm - compaction/migration, writeback...
This series introduces infrastructure that'll allow us to debug these kinds of issues in production:
- fast_list, which is a high-enough performance "list" to track these kinds of objects (radix tree + percpu buffer)
- infrastructure for making them visible in debugfs, hooking them up to pretty printers
- and the last patch hooks into just some of the bcachefs paths where we we need this
Kent Overstreet (5):
bcachefs: bch2_bio_to_text()
bcachefs: bch2_read_bio_to_text
bcachefs: fast_list
bcachefs: Async object debugging
bcachefs: Make various async objs visible in debugfs
fs/bcachefs/Kconfig | 5 ++ fs/bcachefs/Makefile | 3 + fs/bcachefs/async_objs.c | 126 +++++++++++++++++++++++++++++ fs/bcachefs/async_objs.h | 39 +++++++++ fs/bcachefs/async_objs_types.h | 24 ++++++ fs/bcachefs/bcachefs.h | 7 ++ fs/bcachefs/btree_io.c | 12 +++ fs/bcachefs/btree_io.h | 8 ++ fs/bcachefs/data_update.c | 18 ++++- fs/bcachefs/data_update.h | 15 ++++ fs/bcachefs/debug.c | 52 +++++------- fs/bcachefs/debug.h | 18 +++++ fs/bcachefs/errcode.h | 1 + fs/bcachefs/fast_list.c | 140 +++++++++++++++++++++++++++++++++ fs/bcachefs/fast_list.h | 41 ++++++++++ fs/bcachefs/io_read.c | 76 +++++++++++++++--- fs/bcachefs/io_read.h | 14 ++++ fs/bcachefs/super.c | 3 + fs/bcachefs/util.c | 10 +++ fs/bcachefs/util.h | 2 + 20 files changed, 566 insertions(+), 48 deletions(-) create mode 100644 fs/bcachefs/async_objs.c create mode 100644 fs/bcachefs/async_objs.h create mode 100644 fs/bcachefs/async_objs_types.h create mode 100644 fs/bcachefs/fast_list.c create mode 100644 fs/bcachefs/fast_list.h
Signature · 1 line
2.49.0
PATCH 1/5 bcachefs: bch2_bio_to_text()
Pretty printer for struct bio, to be used for async object debugging.
This is pretty minimal, we'll add more to it as we discover what we need.
--- fs/bcachefs/util.c | 10 ++++++++++ fs/bcachefs/util.h | 2 ++ 2 files changed, 12 insertions(+)
fs/bcachefs/util.c +10 -0
@@ -715,6 +715,16 @@ void bch2_corrupt_bio(struct bio *bio) }#endif +void bch2_bio_to_text (struct printbuf *out,struct bio *bio) +{ +prt_printf (out,"bi_remaining:\t%u\n" , +atomic_read (&bio->__bi_remaining)); +prt_printf (out,"bi_end_io:\t%ps\n" , + bio->bi_end_io); +prt_printf (out,"bi_status:\t%u\n" , + bio->bi_status); +} +#if 0 void eytzinger1_test (void ) {
fs/bcachefs/util.h +2 -0
@@ -419,6 +419,8 @@ static inline void bch2_maybe_corrupt_bio(struct bio *bio, unsigned ratio)#define bch2_maybe_corrupt_bio (...) do {} while (0)#endif +void bch2_bio_to_text (struct printbuf *,struct bio *); +static inline void memcpy_u64s_small (void *dst,const void *src,unsigned u64s) {
Signature · 1 line
2.49.0
PATCH 2/5 bcachefs: bch2_read_bio_to_text
In reply to Kent OverstreetPretty printer for struct bch_read_bio.
--- fs/bcachefs/data_update.c | 18 +++++++++++++++--- fs/bcachefs/io_read.c | 35 +++++++++++++++++++++++++++++++++++ fs/bcachefs/io_read.h | 2 ++ 3 files changed, 52 insertions(+), 3 deletions(-)
fs/bcachefs/data_update.c +15 -3
@@ -587,6 +587,10 @@ void bch2_data_update_opts_to_text(struct printbuf *out, struct bch_fs *c,prt_str_indented (out,"extra replicas:\t" );prt_u64 (out, data_opts->extra_replicas); +prt_newline (out); + +prt_str_indented (out,"scrub:\t" ); +prt_u64 (out, data_opts->scrub); }void bch2_data_update_to_text (struct printbuf *out,struct data_update *m)
@@ -607,9 +611,17 @@ void bch2_data_update_inflight_to_text(struct printbuf *out, struct data_updateprt_newline (out);printbuf_indent_add (out,2 );bch2_data_update_opts_to_text (out, m->op.c, &m->op.opts, &m->data_opts); -prt_printf (out,"read_done:\t%u\n" , m->read_done); -bch2_write_op_to_text (out, &m->op); -printbuf_indent_sub (out,2 ); + +if (!m->read_done) { +prt_printf (out,"read:\n" ); +printbuf_indent_add (out,2 ); +bch2_read_bio_to_text (out, &m->rbio); + }else { +prt_printf (out,"write:\n" ); +printbuf_indent_add (out,2 ); +bch2_write_op_to_text (out, &m->op); + } +printbuf_indent_sub (out,4 ); } int bch2_extent_drop_ptrs(struct btree_trans *trans,
fs/bcachefs/io_read.c +35 -0
@@ -1482,6 +1482,41 @@ int __bch2_read(struct btree_trans *trans, struct bch_read_bio *rbio,return ret; } +static const char *const bch2_read_bio_flags[] = { +#define x(n) #n, +BCH_READ_FLAGS () +#undef x + NULL +}; + +void bch2_read_bio_to_text (struct printbuf *out,struct bch_read_bio *rbio) +{ +u64 now =local_clock (); +prt_printf (out,"start_time:\t%llu\n" , rbio->start_time ? now - rbio->start_time :0 ); +prt_printf (out,"submit_time:\t%llu\n" , rbio->submit_time ? now - rbio->submit_time :0 ); + +if (!rbio->split) +prt_printf (out,"end_io:\t%ps\n" , rbio->end_io); +else +prt_printf (out,"parent:\t%px\n" , rbio->parent); + +prt_printf (out,"bi_end_io:\t%ps\n" , rbio->bio.bi_end_io); + +prt_printf (out,"promote:\t%u\n" , rbio->promote); +prt_printf (out,"bounce:\t%u\n" , rbio->bounce); +prt_printf (out,"split:\t%u\n" , rbio->split); +prt_printf (out,"have_ioref:\t%u\n" , rbio->have_ioref); +prt_printf (out,"narrow_crcs:\t%u\n" , rbio->narrow_crcs); +prt_printf (out,"context:\t%u\n" , rbio->context); +prt_printf (out,"ret:\t%s\n" ,bch2_err_str (rbio->ret)); + +prt_printf (out,"flags:\t" ); +bch2_prt_bitflags (out, bch2_read_bio_flags, rbio->flags); +prt_newline (out); + +bch2_bio_to_text (out, &rbio->bio); +} +void bch2_fs_io_read_exit (struct bch_fs *c) {if (c->promote_table.tbl)
fs/bcachefs/io_read.h +2 -0
@@ -193,6 +193,8 @@ static inline struct bch_read_bio *rbio_init(struct bio *bio,return rbio; } +void bch2_read_bio_to_text (struct printbuf *,struct bch_read_bio *); +void bch2_fs_io_read_exit (struct bch_fs *);int bch2_fs_io_read_init (struct bch_fs *);
Signature · 1 line
2.49.0
PATCH 3/5 bcachefs: fast_list
In reply to Kent OverstreetA fast "list" data structure, which is actually a radix tree, with an IDA for slot allocation and a percpu buffer on top of that.
Items cannot be added or moved to the head or tail, only added at some (arbitrary) position and removed. The advantage is that adding, removing and iteration is generally lockless, only hitting the lock in ida when the percpu buffer is full or empty.
--- fs/bcachefs/Makefile | 1 + fs/bcachefs/fast_list.c | 140 ++++++++++++++++++++++++++++++++++++++++ fs/bcachefs/fast_list.h | 41 ++++++++++++ 3 files changed, 182 insertions(+) create mode 100644 fs/bcachefs/fast_list.c create mode 100644 fs/bcachefs/fast_list.h
fs/bcachefs/Makefile +1 -0
@@ -41,6 +41,7 @@ bcachefs-y := \ extents.o \ extent_update.o \ eytzinger.o \ + fast_list.o \ fs.o \ fs-ioctl.o \ fs-io.o \
fs/bcachefs/fast_list.c new file +140 -0
140 lines not on this page · raw message
fs/bcachefs/fast_list.h new file +41 -0
41 lines not on this page · raw message
Signature · 1 line
2.49.0
PATCH 4/5 bcachefs: Async object debugging
In reply to Kent OverstreetDebugging infrastructure for async objs: this lets us easily create fast_lists for various object types so they'll be visible in debugfs.
Add new object types to the BCH_ASYNC_OBJS_TYPES() enum, and drop a pretty-printer wrapper in async_objs.c.
--- fs/bcachefs/Kconfig | 5 ++ fs/bcachefs/Makefile | 2 + fs/bcachefs/async_objs.c | 105 +++++++++++++++++++++++++++++++++ fs/bcachefs/async_objs.h | 39 ++++++++++++ fs/bcachefs/async_objs_types.h | 20 +++++++ fs/bcachefs/bcachefs.h | 7 +++ fs/bcachefs/debug.c | 52 +++++++--------- fs/bcachefs/debug.h | 18 ++++++ fs/bcachefs/errcode.h | 1 + fs/bcachefs/super.c | 3 + 10 files changed, 220 insertions(+), 32 deletions(-) create mode 100644 fs/bcachefs/async_objs.c create mode 100644 fs/bcachefs/async_objs.h create mode 100644 fs/bcachefs/async_objs_types.h
fs/bcachefs/Kconfig +5 -0
@@ -103,6 +103,11 @@ config BCACHEFS_PATH_TRACEPOINTS Enable extra tracepoints for debugging btree_path operations; we don't normally want these enabled because they happen at very high rates. +config BCACHEFS_ASYNC_OBJECT_LISTS + bool "Keep async objects on fast_lists for debugfs visibility" + depends on BCACHEFS_FS && DEBUG_FS + default y + config MEAN_AND_VARIANCE_UNIT_TEST tristate "mean_and_variance unit tests" if !KUNIT_ALL_TESTS depends on KUNIT
fs/bcachefs/Makefile +2 -0
@@ -99,6 +99,8 @@ bcachefs-y := \ varint.o \ xattr.o +obj-$(CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS) += async_objs.o + obj-$(CONFIG_MEAN_AND_VARIANCE_UNIT_TEST) += mean_and_variance_test.o # Silence "note: xyz changed in GCC X.X" messages
fs/bcachefs/async_objs.c new file +105 -0
105 lines not on this page · raw message
fs/bcachefs/async_objs.h new file +39 -0
@@ -0,0 +1,39 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _BCACHEFS_ASYNC_OBJS_H +#define _BCACHEFS_ASYNC_OBJS_H + +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS +static inline void __async_object_list_del (struct fast_list *head,unsigned idx) +{ +fast_list_remove (head, idx); +} + +static inline int __async_object_list_add (struct fast_list *head,void *obj,unsigned *idx) +{ +int ret =fast_list_add (head, obj); + *idx = ret >0 ? ret :0 ; +return ret <0 ? ret :0 ; +} + +#define async_object_list_del (_c, _list, idx) \ + __async_object_list_del(&(_c)->async_objs[BCH_ASYNC_OBJ_LIST_##_list].list, idx) + +#define async_object_list_add (_c, _list, obj, idx) \ + __async_object_list_add(&(_c)->async_objs[BCH_ASYNC_OBJ_LIST_##_list].list, obj, idx) + +void bch2_fs_async_obj_debugfs_init (struct bch_fs *); +void bch2_fs_async_obj_exit (struct bch_fs *); +int bch2_fs_async_obj_init (struct bch_fs *); + +#else /* CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS */ + +#define async_object_list_del (_c, _n, idx) do {} while (0) +#define async_object_list_add (_c, _n, obj, idx) 0 + +static inline void bch2_fs_async_obj_debugfs_init (struct bch_fs *c) {} +static inline void bch2_fs_async_obj_exit (struct bch_fs *c) {} +static inline int bch2_fs_async_obj_init (struct bch_fs *c) {return 0 ; } + +#endif /* CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS */ + +#endif /* _BCACHEFS_ASYNC_OBJS_H */
fs/bcachefs/async_objs_types.h new file +20 -0
@@ -0,0 +1,20 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _BCACHEFS_ASYNC_OBJS_TYPES_H +#define _BCACHEFS_ASYNC_OBJS_TYPES_H + +#define BCH_ASYNC_OBJ_LISTS () + +enum bch_async_obj_lists { +#define x(n) BCH_ASYNC_OBJ_LIST_##n, + BCH_ASYNC_OBJ_LISTS() +#undef x +BCH_ASYNC_OBJ_NR +}; + +struct async_obj_list { +struct fast_list list; +void (*obj_to_text)(struct printbuf *,void *); +unsigned idx; +}; + +#endif /* _BCACHEFS_ASYNC_OBJS_TYPES_H */
fs/bcachefs/bcachefs.h +7 -0
@@ -209,6 +209,7 @@#include "btree_journal_iter_types.h" #include "disk_accounting_types.h" #include "errcode.h" +#include "fast_list.h" #include "fifo.h" #include "nocow_locking_types.h" #include "opts.h"
@@ -474,6 +475,7 @@ enum bch_time_stats { };#include "alloc_types.h" +#include "async_objs_types.h" #include "btree_gc_types.h" #include "btree_types.h" #include "btree_node_scan_types.h"
@@ -1027,6 +1029,10 @@ struct bch_fs { nocow_locks;struct rhashtable promote_table; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS +struct async_obj_list async_objs[BCH_ASYNC_OBJ_NR ]; +#endif +mempool_t compression_bounce[2 ];mempool_t compress_workspace[BCH_COMPRESSION_OPT_NR ];size_t zstd_workspace_size;
@@ -1115,6 +1121,7 @@ struct bch_fs {/* DEBUG JUNK */ struct dentry *fs_debug_dir;struct dentry *btree_debug_dir; +struct dentry *async_obj_dir;struct btree_debug btree_debug[BTREE_ID_NR ];struct btree *verify_data;struct btree_node *verify_ondisk;
fs/bcachefs/debug.c +20 -32
166 lines not on this page · raw message
fs/bcachefs/debug.h +18 -0
@@ -19,6 +19,24 @@ static inline void bch2_btree_verify(struct bch_fs *c, struct btree *b) }#ifdef CONFIG_DEBUG_FS +struct dump_iter { +struct bch_fs *c; +struct async_obj_list *list; +enum btree_id id; +struct bpos from; +struct bpos prev_node; +u64 iter; + +struct printbuf buf; + +char __user *ubuf;/* destination user buffer */ +size_t size;/* size of requested read */ +ssize_t ret;/* bytes read so far */ +}; + +ssize_t bch2_debugfs_flush_buf (struct dump_iter *); +int bch2_dump_release (struct inode *,struct file *); +void bch2_fs_debug_exit (struct bch_fs *);void bch2_fs_debug_init (struct bch_fs *);#else
fs/bcachefs/errcode.h +1 -0
@@ -53,6 +53,7 @@ x(ENOMEM, ENOMEM_dio_write_bioset_init) \ x(ENOMEM, ENOMEM_nocow_flush_bioset_init) \ x(ENOMEM, ENOMEM_promote_table_init) \ + x(ENOMEM, ENOMEM_async_obj_init) \ x(ENOMEM, ENOMEM_compression_bounce_read_init) \ x(ENOMEM, ENOMEM_compression_bounce_write_init) \x (ENOMEM , ENOMEM_compression_workspace_init) \
fs/bcachefs/super.c +3 -0
@@ -10,6 +10,7 @@#include "bcachefs.h" #include "alloc_background.h" #include "alloc_foreground.h" +#include "async_objs.h" #include "bkey_sort.h" #include "btree_cache.h" #include "btree_gc.h"
@@ -570,6 +571,7 @@ static void __bch2_fs_free(struct bch_fs *c)bch2_free_pending_node_rewrites (c);bch2_free_fsck_errs (c);bch2_fs_accounting_exit (c); +bch2_fs_async_obj_exit (c);bch2_fs_sb_errors_exit (c);bch2_fs_counters_exit (c);bch2_fs_snapshots_exit (c);
@@ -981,6 +983,7 @@ static struct bch_fs *bch2_fs_alloc(struct bch_sb *sb, struct bch_opts opts, } ret = +bch2_fs_async_obj_init (c) ?:bch2_fs_btree_cache_init (c) ?:bch2_fs_btree_iter_init (c) ?: bch2_fs_btree_key_cache_init(&c->btree_key_cache) ?:
Signature · 1 line
2.49.0
PATCH 5/5 bcachefs: Make various async objs visible in debugfs
In reply to Kent OverstreetAdd async objs list for
- promote_op
- bch_read_bio
- btree_read_bio
- btree_write_bio
This gets us introspection on in-flight async ops, and because under the hood it uses fast_lists (percpu slot buffer on top of a radix tree), it'll be fast enough to enable in production.
This will be very helpful for debugging "something got stuck" issues, which have been cropping up from time to time (in the CI, especially with folio writeback).
--- fs/bcachefs/async_objs.c | 23 ++++++++++++++++++- fs/bcachefs/async_objs_types.h | 6 ++++- fs/bcachefs/btree_io.c | 12 ++++++++++ fs/bcachefs/btree_io.h | 8 +++++++ fs/bcachefs/data_update.h | 15 +++++++++++++ fs/bcachefs/io_read.c | 41 +++++++++++++++++++++++----------- fs/bcachefs/io_read.h | 12 ++++++++++ 7 files changed, 102 insertions(+), 15 deletions(-)
fs/bcachefs/async_objs.c +22 -1
@@ -12,6 +12,28 @@#include <linux/debugfs.h> +static void promote_obj_to_text (struct printbuf *out,void *obj) +{ +bch2_promote_op_to_text (out, obj); +} + +static void rbio_obj_to_text (struct printbuf *out,void *obj) +{ +bch2_read_bio_to_text (out, obj); +} + +static void btree_read_bio_obj_to_text (struct printbuf *out,void *obj) +{ +struct btree_read_bio *rbio = obj; +bch2_btree_read_bio_to_text (out, rbio); +} + +static void btree_write_bio_obj_to_text (struct printbuf *out,void *obj) +{ +struct btree_write_bio *wbio = obj; +bch2_bio_to_text (out, &wbio->wbio.bio); +} +static int bch2_async_obj_list_open (struct inode *inode,struct file *file) {struct async_obj_list *list = inode->i_private;
@@ -65,7 +87,6 @@ static ssize_t bch2_async_obj_list_read(struct file *file, char __user *buf,return ret ?: i->ret; } -__maybe_unused static const struct file_operations async_obj_ops = { .owner =THIS_MODULE , .open = bch2_async_obj_list_open,
fs/bcachefs/async_objs_types.h +5 -1
@@ -2,7 +2,11 @@#ifndef _BCACHEFS_ASYNC_OBJS_TYPES_H#define _BCACHEFS_ASYNC_OBJS_TYPES_H -#define BCH_ASYNC_OBJ_LISTS () +#define BCH_ASYNC_OBJ_LISTS () \ + x(promote) \ + x(rbio) \ + x(btree_read_bio) \ + x(btree_write_bio)enum bch_async_obj_lists {#define x(n) BCH_ASYNC_OBJ_LIST_##n,
fs/bcachefs/btree_io.c +12 -0
@@ -1,6 +1,7 @@// SPDX-License-Identifier: GPL-2.0 #include "bcachefs.h" +#include "async_objs.h" #include "bkey_buf.h" #include "bkey_methods.h" #include "bkey_sort.h"
@@ -1375,6 +1376,7 @@ static void btree_node_read_work(struct work_struct *work) } } +async_object_list_del (c, btree_read_bio, rb->list_idx);bch2_time_stats_update (&c->times[BCH_TIME_btree_node_read], rb->start_time);bio_put (&rb->bio);
@@ -1414,6 +1416,11 @@ static void btree_node_read_endio(struct bio *bio)queue_work (c->btree_read_complete_wq, &rb->work); } +void bch2_btree_read_bio_to_text (struct printbuf *out,struct btree_read_bio *rbio) +{ +bch2_bio_to_text (out, &rbio->bio); +} +struct btree_node_read_all {struct closure cl;struct bch_fs *c;
@@ -1744,6 +1751,8 @@ void bch2_btree_node_read(struct btree_trans *trans, struct btree *b, bio->bi_end_io = btree_node_read_endio;bch2_bio_map (bio, b->data,btree_buf_bytes (b)); +async_object_list_add (c, btree_read_bio, rb, &rb->list_idx); +if (rb->have_ioref) {this_cpu_add (ca->io_done->sectors[READ ][BCH_DATA_btree],bio_sectors (bio));
@@ -2115,6 +2124,7 @@ static void btree_node_write_work(struct work_struct *work) goto err; } out: +async_object_list_del (c, btree_write_bio, wbio->list_idx);bio_put (&wbio->wbio.bio);btree_node_write_done (c, b, start_time);return ;
@@ -2466,6 +2476,8 @@ void __bch2_btree_node_write(struct bch_fs *c, struct btree *b, unsigned flags)atomic64_inc (&c->btree_write_stats[type].nr);atomic64_add (bytes_to_write, &c->btree_write_stats[type].bytes); +async_object_list_add (c, btree_write_bio, wbio, &wbio->list_idx); +INIT_WORK (&wbio->work, btree_write_submit);queue_work (c->btree_write_submit_wq, &wbio->work);return ;
fs/bcachefs/btree_io.h +8 -0
@@ -41,6 +41,9 @@ struct btree_read_bio {u64 start_time; unsigned have_ioref:1; unsigned idx:7; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS +unsigned list_idx; +#endif struct extent_ptr_decoded pick;struct work_struct work;struct bio bio;
@@ -53,6 +56,9 @@ struct btree_write_bio {unsigned data_bytes;unsigned sector_offset;u64 start_time; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS +unsigned list_idx; +#endif struct bch_write_bio wbio; };
@@ -133,6 +139,8 @@ 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 ); +void bch2_btree_read_bio_to_text (struct printbuf *,struct btree_read_bio *); +int bch2_btree_node_scrub (struct btree_trans *,enum btree_id ,unsigned ,struct bkey_s_c ,unsigned );
fs/bcachefs/data_update.h +15 -0
@@ -50,6 +50,21 @@ struct data_update {struct bio_vec *bvecs; }; +struct promote_op { +struct rcu_head rcu; +u64 start_time; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS +unsigned list_idx; +#endif + +struct rhash_head hash; +struct bpos pos; + +struct work_struct work; +struct data_update write; +struct bio_vec bi_inline_vecs[];/* must be last */ +}; +void bch2_data_update_to_text (struct printbuf *,struct data_update *);void bch2_data_update_inflight_to_text (struct printbuf *,struct data_update *);
fs/bcachefs/io_read.c +28 -13
101 lines not on this page · raw message
fs/bcachefs/io_read.h +12 -0
@@ -4,6 +4,7 @@#include "bkey_buf.h" #include "btree_iter.h" +#include "extents_types.h" #include "reflink.h" struct bch_read_bio {
@@ -48,6 +49,9 @@ struct bch_read_bio {u16 _state; };s16 ret; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS +unsigned list_idx; +#endif struct extent_ptr_decoded pick;
@@ -173,6 +177,9 @@ static inline struct bch_read_bio *rbio_init_fragment(struct bio *bio, rbio->split = true; rbio->parent = orig; rbio->opts = orig->opts; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS + rbio->list_idx =0 ; +#endif return rbio; }
@@ -190,9 +197,14 @@ static inline struct bch_read_bio *rbio_init(struct bio *bio, rbio->ret =0 ; rbio->opts = opts; rbio->bio.bi_end_io = end_io; +#ifdef CONFIG_BCACHEFS_ASYNC_OBJECT_LISTS + rbio->list_idx =0 ; +#endif return rbio; } +struct promote_op ; +void bch2_promote_op_to_text (struct printbuf *,struct promote_op *);void bch2_read_bio_to_text (struct printbuf *,struct bch_read_bio *);void bch2_fs_io_read_exit (struct bch_fs *);
Signature · 1 line
2.49.0