bcachefs: bch2_run_explicit_recovery_pass_printbuf()
PATCH 1/6 bcachefs: bch2_run_explicit_recovery_pass_printbuf()
We prefer helpers that emit log messages to printbufs rather than printing them directly; that way, we can ensure that different log messages from the same event are grouped together and formatted appropriately in the dmesg log.
--- fs/bcachefs/buckets.c | 33 +++++++++++++++++++++--------- fs/bcachefs/error.c | 2 +- fs/bcachefs/recovery_passes.c | 38 +++++++++++++++++++++++++++-------- fs/bcachefs/recovery_passes.h | 3 +++ 4 files changed, 57 insertions(+), 19 deletions(-)
fs/bcachefs/buckets.c +23 -10
@@ -400,7 +400,8 @@ static int bucket_ref_update_err(struct btree_trans *trans, struct printbuf *buf__bch2_count_fsck_err (c, id, buf->buf, &repeat, &print, &suppress); -int ret =bch2_run_explicit_recovery_pass (c, BCH_RECOVERY_PASS_check_allocations); +int ret =bch2_run_explicit_recovery_pass_printbuf (c, buf, + BCH_RECOVERY_PASS_check_allocations);if (insert) { print = true;
@@ -959,14 +960,27 @@ static int __bch2_trans_mark_metadata_bucket(struct btree_trans *trans,return PTR_ERR (a);if (a->v.data_type && type && a->v.data_type != type) { -bch2_run_explicit_recovery_pass (c, BCH_RECOVERY_PASS_check_allocations); -log_fsck_err (trans, bucket_metadata_type_mismatch, -"bucket %llu:%llu gen %u different types of data in same bucket: %s, %s\n" -"while marking %s" , - iter.pos.inode, iter.pos.offset, a->v.gen, -bch2_data_type_str (a->v.data_type), -bch2_data_type_str (type), -bch2_data_type_str (type)); +struct printbuf buf =PRINTBUF ; +bch2_log_msg_start (c, &buf); +prt_printf (&buf,"bucket %llu:%llu gen %u different types of data in same bucket: %s, %s\n" +"while marking %s\n" , + iter.pos.inode, iter.pos.offset, a->v.gen, +bch2_data_type_str (a->v.data_type), +bch2_data_type_str (type), +bch2_data_type_str (type)); + +bool repeat = false, print = true, suppress = false; +bch2_count_fsck_err (c, bucket_metadata_type_mismatch, buf.buf, + &repeat, &print, &suppress); + +bch2_run_explicit_recovery_pass_printbuf (c, &buf, + BCH_RECOVERY_PASS_check_allocations); + +if (suppress) +prt_printf (&buf,"Ratelimiting new instances of previous error\n" ); +if (print) +bch2_print_string_as_lines (KERN_ERR , buf.buf); +printbuf_exit (&buf); ret = -BCH_ERR_metadata_bucket_inconsistency; goto err; }
@@ -978,7 +992,6 @@ static int __bch2_trans_mark_metadata_bucket(struct btree_trans *trans, ret =bch2_trans_update (trans, &iter, &a->k_i,0 ); } err: -fsck_err:bch2_trans_iter_exit (trans, &iter);return ret; }
fs/bcachefs/error.c +1 -1
@@ -104,7 +104,7 @@ int __bch2_topology_error(struct bch_fs *c, struct printbuf *out)__bch2_inconsistent_error (c, out);return -BCH_ERR_btree_need_topology_repair; }else { -return bch2_run_explicit_recovery_pass (c, BCH_RECOVERY_PASS_check_topology) ?: +return bch2_run_explicit_recovery_pass_printbuf (c, out, BCH_RECOVERY_PASS_check_topology) ?: -BCH_ERR_btree_node_read_validate_error; } }
fs/bcachefs/recovery_passes.c +30 -8
@@ -100,7 +100,8 @@ u64 bch2_recovery_passes_from_stable(u64 v)/* * For when we need to rewind recovery passes and run a pass we skipped: */ -static int __bch2_run_explicit_recovery_pass (struct bch_fs *c, +static int __bch2_run_explicit_recovery_pass (struct printbuf *out, +struct bch_fs *c,enum bch_recovery_pass pass) {if (c->curr_recovery_pass ==ARRAY_SIZE (recovery_pass_fns))
@@ -114,15 +115,15 @@ static int __bch2_run_explicit_recovery_pass(struct bch_fs *c,if (pass < BCH_RECOVERY_PASS_set_may_go_rw && c->curr_recovery_pass >= BCH_RECOVERY_PASS_set_may_go_rw) {if (print) -bch_info (c,"need recovery pass %s (%u), but already rw" , - bch2_recovery_passes[pass], pass); +prt_printf (out,"need recovery pass %s (%u), but already rw" , + bch2_recovery_passes[pass], pass);return -BCH_ERR_cannot_rewind_recovery; }if (print) -bch_info (c,"running explicit recovery pass %s (%u), currently at %s (%u)" , - bch2_recovery_passes[pass], pass, - bch2_recovery_passes[c->curr_recovery_pass], c->curr_recovery_pass); +prt_printf (out,"running explicit recovery pass %s (%u), currently at %s (%u)" , + bch2_recovery_passes[pass], pass, + bch2_recovery_passes[c->curr_recovery_pass], c->curr_recovery_pass); c->opts.recovery_passes |=BIT_ULL (pass);
@@ -135,13 +136,34 @@ static int __bch2_run_explicit_recovery_pass(struct bch_fs *c, } } -int bch2_run_explicit_recovery_pass (struct bch_fs *c, +int bch2_run_explicit_recovery_pass_printbuf (struct bch_fs *c, +struct printbuf *out,enum bch_recovery_pass pass) { +bch2_printbuf_make_room (out,1024 ); + out->atomic++; +unsigned long flags;spin_lock_irqsave (&c->recovery_pass_lock, flags); -int ret =__bch2_run_explicit_recovery_pass (c, pass); +int ret =__bch2_run_explicit_recovery_pass (out, c, pass);spin_unlock_irqrestore (&c->recovery_pass_lock, flags); + + --out->atomic; +return ret; +} + +int bch2_run_explicit_recovery_pass (struct bch_fs *c, +enum bch_recovery_pass pass) +{ +struct printbuf buf =PRINTBUF ; +bch2_log_msg_start (c, &buf); +unsigned len = buf.pos; + +int ret =bch2_run_explicit_recovery_pass_printbuf (c, &buf, pass); + +if (len != buf.pos) +bch2_print_string_as_lines (KERN_NOTICE , buf.buf); +printbuf_exit (&buf);return ret; }
fs/bcachefs/recovery_passes.h +3 -0
@@ -8,6 +8,9 @@ u64 bch2_recovery_passes_from_stable(u64 v);u64 bch2_fsck_recovery_passes (void ); +int bch2_run_explicit_recovery_pass_printbuf (struct bch_fs *, +struct printbuf *, +enum bch_recovery_pass );int bch2_run_explicit_recovery_pass (struct bch_fs *,enum bch_recovery_pass );int bch2_run_explicit_recovery_pass_persistent_locked (struct bch_fs *,enum bch_recovery_pass );int bch2_run_explicit_recovery_pass_persistent (struct bch_fs *,enum bch_recovery_pass );
Signature · 1 line
2.49.0
PATCH 2/6 bcachefs: Simplify bch2_count_fsck_err()
--- fs/bcachefs/buckets.c | 16 +++------------- fs/bcachefs/error.c | 14 ++++++++++---- fs/bcachefs/error.h | 4 +--- 3 files changed, 14 insertions(+), 20 deletions(-)
fs/bcachefs/buckets.c +3 -13
@@ -392,29 +392,23 @@ static int bucket_ref_update_err(struct btree_trans *trans, struct printbuf *buf struct bkey_s_c k, bool insert, enum bch_sb_error_id id) { struct bch_fs *c = trans->c; -bool repeat = false, print = true, suppress = false;prt_printf (buf,"\nwhile marking " );bch2_bkey_val_to_text (buf, c, k);prt_newline (buf); -__bch2_count_fsck_err (c, id, buf->buf, &repeat, &print, &suppress); +bool print =__bch2_count_fsck_err (c, id, buf);int ret =bch2_run_explicit_recovery_pass_printbuf (c, buf, BCH_RECOVERY_PASS_check_allocations);if (insert) { - print = true; - suppress = false; -bch2_trans_updates_to_text (buf, trans);__bch2_inconsistent_error (c, buf); ret = -BCH_ERR_bucket_ref_update; } -if (suppress) -prt_printf (buf,"Ratelimiting new instances of previous error\n" ); -if (print) +if (print || insert)bch2_print_string_as_lines (KERN_ERR , buf->buf);return ret; }
@@ -969,15 +963,11 @@ static int __bch2_trans_mark_metadata_bucket(struct btree_trans *trans,bch2_data_type_str (type), bch2_data_type_str(type)); -bool repeat = false, print = true, suppress = false; -bch2_count_fsck_err (c, bucket_metadata_type_mismatch, buf.buf, - &repeat, &print, &suppress); +bool print =bch2_count_fsck_err (c, bucket_metadata_type_mismatch, &buf);bch2_run_explicit_recovery_pass_printbuf (c, &buf, BCH_RECOVERY_PASS_check_allocations); -if (suppress) -prt_printf (&buf,"Ratelimiting new instances of previous error\n" );if (print)bch2_print_string_as_lines (KERN_ERR , buf.buf);printbuf_exit (&buf);
fs/bcachefs/error.c +10 -4
@@ -379,15 +379,21 @@ static struct fsck_err_state *count_fsck_err_locked(struct bch_fs *c,return s; } -void __bch2_count_fsck_err (struct bch_fs *c, -enum bch_sb_error_id id,const char *msg, -bool *repeat,bool *print,bool *suppress) +bool __bch2_count_fsck_err (struct bch_fs *c, +enum bch_sb_error_id id,struct printbuf *msg) {bch2_sb_error_count (c, id);mutex_lock (&c->fsck_error_msgs_lock); -count_fsck_err_locked (c, id, msg, repeat, print, suppress); +bool print = true, repeat = false, suppress = false; + +count_fsck_err_locked (c, id, msg->buf, &repeat, &print, &suppress);mutex_unlock (&c->fsck_error_msgs_lock); + +if (suppress) +prt_printf (msg,"Ratelimiting new instances of previous error\n" ); + +return print && !repeat; } int __bch2_fsck_err(struct bch_fs *c,
fs/bcachefs/error.h +1 -3
@@ -76,9 +76,7 @@ struct fsck_err_state {#define fsck_err_count (_c, _err) bch2_sb_err_count(_c, BCH_FSCK_ERR_##_err) -void __bch2_count_fsck_err (struct bch_fs *, -enum bch_sb_error_id ,const char *, -bool *,bool *,bool *); +bool __bch2_count_fsck_err (struct bch_fs *,enum bch_sb_error_id ,struct printbuf *);#define bch2_count_fsck_err (_c, _err, ...) \ __bch2_count_fsck_err(_c, BCH_FSCK_ERR_##_err, __VA_ARGS__)
Signature · 1 line
2.49.0
PATCH 3/6 bcachefs: bch2_dev_missing_bkey()
In reply to Kent OverstreetPart of the ongoing project to kill off bch2_(fs|trans)_inconsistent calls - they generally need to be replaced with either
- a fsck_err() call that can repair the error, or
- logging an error of the appropriate type in the superblock, and flagging the appropriate recovery pass to repair the error
--- fs/bcachefs/extents.c | 10 +++++++++- fs/bcachefs/sb-members.c | 22 +++++++++++++++++++++- fs/bcachefs/sb-members.h | 8 +++++--- 3 files changed, 35 insertions(+), 5 deletions(-)
fs/bcachefs/extents.c +9 -1
@@ -158,7 +158,15 @@ int bch2_bkey_pick_read_device(struct bch_fs *c, struct bkey_s_c k,if (dev >=0 && p.ptr.dev != dev)continue ; -struct bch_dev *ca =bch2_dev_rcu (c, p.ptr.dev); +struct bch_dev *ca =bch2_dev_rcu_noerror (c, p.ptr.dev); + +if (unlikely (!ca && p.ptr.dev !=BCH_SB_MEMBER_INVALID )) { +rcu_read_unlock (); +int ret =bch2_dev_missing_bkey (c, k, p.ptr.dev); +if (ret) +return ret; +rcu_read_lock (); + }if (p.ptr.cached && (!ca ||dev_ptr_stale_rcu (ca, &p.ptr)))continue ;
fs/bcachefs/sb-members.c +21 -1
@@ -5,11 +5,31 @@#include "disk_groups.h" #include "error.h" #include "opts.h" +#include "recovery_passes.h" #include "replicas.h" #include "sb-members.h" #include "super-io.h" -void bch2_dev_missing (struct bch_fs *c,unsigned dev) +int bch2_dev_missing_bkey (struct bch_fs *c,struct bkey_s_c k,unsigned dev) +{ +struct printbuf buf =PRINTBUF ; +bch2_log_msg_start (c, &buf); + +prt_printf (&buf,"pointer to nonexistent device %u in key\n" , dev); +bch2_bkey_val_to_text (&buf, c, k); + +bool print =bch2_count_fsck_err (c, ptr_to_invalid_device, &buf); + +int ret =bch2_run_explicit_recovery_pass_printbuf (c, &buf, + BCH_RECOVERY_PASS_check_allocations); + +if (print) +bch2_print_string_as_lines (KERN_ERR , buf.buf); +printbuf_exit (&buf); +return ret; +} + +void bch2_dev_missing_atomic (struct bch_fs *c,unsigned dev) {if (dev !=BCH_SB_MEMBER_INVALID )bch2_fs_inconsistent (c,"pointer to nonexistent device %u" , dev);
fs/bcachefs/sb-members.h +5 -3
@@ -218,13 +218,15 @@ static inline struct bch_dev *bch2_dev_rcu_noerror(struct bch_fs *c, unsigned de : NULL; } -void bch2_dev_missing (struct bch_fs *,unsigned ); +int bch2_dev_missing_bkey (struct bch_fs *,struct bkey_s_c ,unsigned ); + +void bch2_dev_missing_atomic (struct bch_fs *,unsigned );static inline struct bch_dev *bch2_dev_rcu (struct bch_fs *c,unsigned dev) {struct bch_dev *ca =bch2_dev_rcu_noerror (c, dev);if (unlikely (!ca)) -bch2_dev_missing (c, dev); +bch2_dev_missing_atomic (c, dev);return ca; }
@@ -242,7 +244,7 @@ static inline struct bch_dev *bch2_dev_tryget(struct bch_fs *c, unsigned dev) {struct bch_dev *ca =bch2_dev_tryget_noerror (c, dev);if (unlikely (!ca)) -bch2_dev_missing (c, dev); +bch2_dev_missing_atomic (c, dev);return ca; }
Signature · 1 line
2.49.0
PATCH 4/6 bcachefs: print_str_as_lines() -> print_str()
In reply to Kent Overstreetbch2_print_string_as_lines() is a low level helper that allows messages longer than 1k to be printed without truncation.
But we should always be printing with the helpers that take a filesystem object, if we're in fsck they direct output to the userspace process controlling fsck instead of the dmesg log.
--- fs/bcachefs/alloc_foreground.c | 2 +- fs/bcachefs/bcachefs.h | 3 ++- fs/bcachefs/btree_io.c | 2 +- fs/bcachefs/btree_iter.c | 4 ++-- fs/bcachefs/btree_locking.c | 2 +- fs/bcachefs/btree_node_scan.c | 6 +++--- fs/bcachefs/btree_update_interior.c | 2 +- fs/bcachefs/buckets.c | 6 +++--- fs/bcachefs/data_update.c | 2 +- fs/bcachefs/error.c | 10 +++++----- fs/bcachefs/journal.c | 4 ++-- fs/bcachefs/journal_io.c | 2 +- fs/bcachefs/recovery_passes.c | 2 +- fs/bcachefs/sb-members.c | 2 +- fs/bcachefs/super.c | 15 +++++++++++++-- fs/bcachefs/util.c | 14 ++------------ fs/bcachefs/util.h | 3 +-- 17 files changed, 41 insertions(+), 40 deletions(-)
fs/bcachefs/alloc_foreground.c +1 -1
@@ -1642,7 +1642,7 @@ static noinline void bch2_print_allocator_stuck(struct bch_fs *c)bch2_journal_debug_to_text (&buf, &c->journal);printbuf_indent_sub (&buf,2 ); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf); }
fs/bcachefs/bcachefs.h +2 -1
@@ -269,7 +269,8 @@ do { \#define bch2_fmt (_c, fmt) bch2_log_msg(_c, fmt "\n") -void bch2_print_str (struct bch_fs *,const char *); +void bch2_print_str (struct bch_fs *,const char *,const char *); +void bch2_print_str_nonblocking (struct bch_fs *,const char *,const char *); __printf(2, 3)void bch2_print_opts (struct bch_opts *,const char *, ...);
fs/bcachefs/btree_io.c +1 -1
@@ -604,7 +604,7 @@ static int __btree_err(int ret, }if (!silent) -bch2_print_string_as_lines (KERN_ERR , out.buf); +bch2_print_str (c,KERN_ERR , out.buf); out: fsck_err:printbuf_exit (&out);
fs/bcachefs/btree_iter.c +2 -2
@@ -1591,7 +1591,7 @@ void __bch2_dump_trans_paths_updates(struct btree_trans *trans, bool nosort)__bch2_trans_paths_to_text (&buf, trans, nosort);bch2_trans_updates_to_text (&buf, trans); -bch2_print_str (trans->c, buf.buf); +bch2_print_str (trans->c,KERN_ERR , buf.buf);printbuf_exit (&buf); }
@@ -3112,7 +3112,7 @@ void *__bch2_trans_kmalloc(struct btree_trans *trans, size_t size, unsigned long#ifdef CONFIG_BCACHEFS_DEBUG struct printbuf buf =PRINTBUF ;bch2_trans_kmalloc_trace_to_text (&buf, &trans->trans_kmalloc_trace); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);#endif }
fs/bcachefs/btree_locking.c +1 -1
@@ -236,7 +236,7 @@ static noinline int break_cycle(struct lock_graph *g, struct printbuf *cycle,prt_newline (&buf); } -bch2_print_string_as_lines_nonblocking (KERN_ERR , buf.buf); +bch2_print_str_nonblocking (g->g->trans->c,KERN_ERR , buf.buf);printbuf_exit (&buf);BUG (); }
fs/bcachefs/btree_node_scan.c +3 -3
@@ -395,7 +395,7 @@ int bch2_scan_for_btree_nodes(struct bch_fs *c)printbuf_reset (&buf);prt_printf (&buf,"%s: nodes found:\n" , __func__);found_btree_nodes_to_text (&buf, c, f->nodes); -bch2_print_string_as_lines (KERN_INFO , buf.buf); +bch2_print_str (c,KERN_INFO , buf.buf); }sort_nonatomic (f->nodes.data, f->nodes.nr,sizeof (f->nodes.data[0 ]), found_btree_node_cmp_cookie,NULL );
@@ -424,7 +424,7 @@ int bch2_scan_for_btree_nodes(struct bch_fs *c)printbuf_reset (&buf);prt_printf (&buf,"%s: nodes after merging replicas:\n" , __func__);found_btree_nodes_to_text (&buf, c, f->nodes); -bch2_print_string_as_lines (KERN_INFO , buf.buf); +bch2_print_str (c,KERN_INFO , buf.buf); }swap (nodes_heap, f->nodes);
@@ -470,7 +470,7 @@ int bch2_scan_for_btree_nodes(struct bch_fs *c)printbuf_reset (&buf);prt_printf (&buf,"%s: nodes found after overwrites:\n" , __func__);found_btree_nodes_to_text (&buf, c, f->nodes); -bch2_print_string_as_lines (KERN_INFO , buf.buf); +bch2_print_str (c,KERN_INFO , buf.buf); }else {bch_info (c,"btree node scan found %zu nodes after overwrites" , f->nodes.nr); }
fs/bcachefs/btree_update_interior.c +1 -1
@@ -1792,7 +1792,7 @@ static int bch2_btree_insert_node(struct btree_update *as, struct btree_trans *tbch2_btree_update_to_text (&buf, as);bch2_btree_path_to_text (&buf, trans, path_idx); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);bch2_fs_emergency_read_only (c);return -EIO ;
fs/bcachefs/buckets.c +3 -3
@@ -409,7 +409,7 @@ static int bucket_ref_update_err(struct btree_trans *trans, struct printbuf *buf }if (print || insert) -bch2_print_string_as_lines (KERN_ERR , buf->buf); +bch2_print_str (c,KERN_ERR , buf->buf);return ret; }
@@ -699,7 +699,7 @@ static int bch2_trigger_stripe_ptr(struct btree_trans *trans, (u64) p.ec.idx);bch2_bkey_val_to_text (&buf, c, k);__bch2_inconsistent_error (c, &buf); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);return -BCH_ERR_trigger_stripe_pointer; }
@@ -969,7 +969,7 @@ static int __bch2_trans_mark_metadata_bucket(struct btree_trans *trans, BCH_RECOVERY_PASS_check_allocations);if (print) -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf); ret = -BCH_ERR_metadata_bucket_inconsistency; goto err;
fs/bcachefs/data_update.c +1 -1
@@ -358,7 +358,7 @@ static int __bch2_data_update_index_update(struct btree_trans *trans,prt_str (&buf,"\nnew: " );bch2_bkey_val_to_text (&buf, c,bkey_i_to_s_c (insert)); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);bch2_fatal_error (c);
fs/bcachefs/error.c +5 -5
@@ -34,7 +34,7 @@ bool __bch2_inconsistent_error(struct bch_fs *c, struct printbuf *out) journal_cur_seq(&c->journal));return true;case BCH_ON_ERROR_panic: -bch2_print_string_as_lines_nonblocking (KERN_ERR , out->buf); +bch2_print_str (c,KERN_ERR , out->buf);panic (bch2_fmt (c,"panic after error" ));return true;default :
@@ -71,7 +71,7 @@ static bool bch2_fs_trans_inconsistent(struct bch_fs *c, struct btree_trans *traif (trans)bch2_trans_updates_to_text (&buf, trans);bool ret =__bch2_inconsistent_error (c, &buf); -bch2_print_string_as_lines_nonblocking (KERN_ERR , buf.buf); +bch2_print_str_nonblocking (c,KERN_ERR , buf.buf);printbuf_exit (&buf);return ret;
@@ -121,7 +121,7 @@ int bch2_fs_topology_error(struct bch_fs *c, const char *fmt, ...)va_end (args);int ret =__bch2_topology_error (c, &buf); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);return ret;
@@ -331,7 +331,7 @@ static int do_fsck_ask_yn(struct bch_fs *c,if (bch2_fs_stdio_redirect (c))bch2_print (c,"%s" , question->buf);else -bch2_print_string_as_lines (KERN_ERR , question->buf); +bch2_print_str (c,KERN_ERR , question->buf);int ask =bch2_fsck_ask_yn (c, trans);
@@ -566,7 +566,7 @@ int __bch2_fsck_err(struct bch_fs *c,if (bch2_fs_stdio_redirect (c))bch2_print (c,"%s" , out->buf);else -bch2_print_string_as_lines (KERN_ERR , out->buf); +bch2_print_str (c,KERN_ERR , out->buf); }if (s)
fs/bcachefs/journal.c +2 -2
@@ -173,7 +173,7 @@ journal_error_check_stuck(struct journal *j, int error, unsigned flags)spin_unlock (&j->lock);prt_printf (&buf,bch2_fmt (c,"Journal stuck! Hava a pre-reservation but journal full (error %s)" ),bch2_err_str (error)); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_reset (&buf);bch2_journal_pins_to_text (&buf, j);
@@ -726,7 +726,7 @@ int bch2_journal_res_get_slowpath(struct journal *j, struct journal_res *res,struct printbuf buf =PRINTBUF ;bch2_journal_debug_to_text (&buf, j); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);prt_printf (&buf,bch2_fmt (c,"Journal stuck? Waited for 10 seconds, err %s" ),bch2_err_str (ret));printbuf_exit (&buf);
fs/bcachefs/journal_io.c +1 -1
@@ -2105,7 +2105,7 @@ CLOSURE_CALLBACK(bch2_journal_write)le64_to_cpu (w->data->seq),vstruct_sectors (w->data, c->block_bits), bch2_err_str(ret)); -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf); }if (ret)
fs/bcachefs/recovery_passes.c +1 -1
@@ -162,7 +162,7 @@ int bch2_run_explicit_recovery_pass(struct bch_fs *c,int ret =bch2_run_explicit_recovery_pass_printbuf (c, &buf, pass);if (len != buf.pos) -bch2_print_string_as_lines (KERN_NOTICE , buf.buf); +bch2_print_str (c,KERN_NOTICE , buf.buf);printbuf_exit (&buf);return ret; }
fs/bcachefs/sb-members.c +1 -1
@@ -24,7 +24,7 @@ int bch2_dev_missing_bkey(struct bch_fs *c, struct bkey_s_c k, unsigned dev) BCH_RECOVERY_PASS_check_allocations);if (print) -bch2_print_string_as_lines (KERN_ERR , buf.buf); +bch2_print_str (c,KERN_ERR , buf.buf);printbuf_exit (&buf);return ret; }
fs/bcachefs/super.c +13 -2
@@ -84,7 +84,8 @@ const char * const bch2_fs_flag_strs[] = { NULL }; -void bch2_print_str (struct bch_fs *c,const char *str) +static void __bch2_print_str (struct bch_fs *c,const char *prefix, +const char *str,bool nonblocking) {#ifdef __KERNEL__struct stdio_redirect *stdio =bch2_fs_stdio_redirect (c);
@@ -94,7 +95,17 @@ void bch2_print_str(struct bch_fs *c, const char *str) return; }#endif -bch2_print_string_as_lines (KERN_ERR , str); +bch2_print_string_as_lines (KERN_ERR , str, nonblocking); +} + +void bch2_print_str (struct bch_fs *c,const char *prefix,const char *str) +{ +__bch2_print_str (c, prefix, str, false); +} + +void bch2_print_str_nonblocking (struct bch_fs *c,const char *prefix,const char *str) +{ +__bch2_print_str (c, prefix, str, true); }__printf (2 ,0 )
fs/bcachefs/util.c +2 -12
@@ -252,8 +252,8 @@ void bch2_prt_u64_base2(struct printbuf *out, u64 v)bch2_prt_u64_base2_nbits (out, v,fls64 (v) ?:1 ); } -static void __bch2_print_string_as_lines (const char *prefix,const char *lines, -bool nonblocking) +void bch2_print_string_as_lines (const char *prefix,const char *lines, +bool nonblocking) {bool locked = false;const char *p;
@@ -281,16 +281,6 @@ static void __bch2_print_string_as_lines(const char *prefix, const char *lines,console_unlock (); } -void bch2_print_string_as_lines (const char *prefix,const char *lines) -{ -return __bch2_print_string_as_lines (prefix, lines, false); -} - -void bch2_print_string_as_lines_nonblocking (const char *prefix,const char *lines) -{ -return __bch2_print_string_as_lines (prefix, lines, true); -} -int bch2_save_backtrace (bch_stacktrace *stack,struct task_struct *task,unsigned skipnr,gfp_t gfp) {
fs/bcachefs/util.h +1 -2
@@ -212,8 +212,7 @@ u64 bch2_read_flag_list(const char *, const char * const[]);void bch2_prt_u64_base2_nbits (struct printbuf *,u64 ,unsigned );void bch2_prt_u64_base2 (struct printbuf *,u64 ); -void bch2_print_string_as_lines (const char *prefix,const char *lines); -void bch2_print_string_as_lines_nonblocking (const char *prefix,const char *lines); +void bch2_print_string_as_lines (const char *,const char *,bool );typedef DARRAY (unsigned long )bch_stacktrace ;int bch2_save_backtrace (bch_stacktrace *stack,struct task_struct *,unsigned ,gfp_t );
Signature · 1 line
2.49.0
PATCH 5/6 bcachefs: Flag for repair on missing subvolume
In reply to Kent OverstreetInstead of going emegency read only with a bch2_fs_inconsistent() call, log the error and recovery pass appropriately.
If we're still in recovery it'll be repaired immediately, otherwise it'll be repaired on the next mount.
--- fs/bcachefs/sb-errors_format.h | 3 ++- fs/bcachefs/subvolume.c | 44 ++++++++++++++++++++++------------ 2 files changed, 31 insertions(+), 16 deletions(-)
fs/bcachefs/sb-errors_format.h +2 -1
@@ -298,6 +298,7 @@ enum bch_fsck_flags { x(btree_ptr_v2_written_0, 268, 0) \ x(subvol_snapshot_bad, 269, 0) \ x(subvol_inode_bad, 270, 0) \ + x(subvol_missing, 308, FSCK_AUTOFIX) \ x(alloc_key_stripe_sectors_wrong, 271, FSCK_AUTOFIX) \ x(accounting_mismatch, 272, FSCK_AUTOFIX) \x (accounting_replicas_not_marked,273 ,0 ) \
@@ -317,7 +318,7 @@ enum bch_fsck_flags { x(directory_size_mismatch, 303, FSCK_AUTOFIX) \ x(dirent_cf_name_too_big, 304, 0) \ x(dirent_stray_data_after_cf_name, 305, 0) \ - x(MAX, 308, 0) + x(MAX, 309, 0)enum bch_sb_error_id {#define x(t, n, ...) BCH_FSCK_ERR_##t = n,
fs/bcachefs/subvolume.c +29 -15
88 lines not on this page · raw message
Signature · 1 line
2.49.0
PATCH 6/6 bcachefs: Add a recovery pass for making sure root inode is readable
In reply to Kent OverstreetIf the root inode/subvolume is unreadable we can repair automatically - but only if we're still in recovery, so that we can rewind to the appropriate recovery pass.
--- fs/bcachefs/recovery_passes.c | 15 +++++++++++++++ fs/bcachefs/recovery_passes_types.h | 3 ++- 2 files changed, 17 insertions(+), 1 deletion(-)
fs/bcachefs/recovery_passes.c +15 -0
@@ -51,6 +51,21 @@ static int bch2_set_may_go_rw(struct bch_fs *c)return 0 ; } +/* +* Make sure root inode is readable while we're still in recovery and can rewind +* for repair: +*/ +static int bch2_lookup_root_inode (struct bch_fs *c) +{ +subvol_inum inum =BCACHEFS_ROOT_SUBVOL_INUM ; +struct bch_inode_unpacked inode_u; +struct bch_subvolume subvol; + +return bch2_trans_do (c, +bch2_subvolume_get (trans, inum.subvol, true, &subvol) ?: +bch2_inode_find_by_inum_trans (trans, inum, &inode_u)); +} +struct recovery_pass_fn {int (*fn)(struct bch_fs *);unsigned when;
fs/bcachefs/recovery_passes_types.h +2 -1
@@ -60,7 +60,8 @@ 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 ) + x(set_fs_needs_rebalance, 34, 0) \ +x (lookup_root_inode,42 ,PASS_ALWAYS |PASS_SILENT ) /* We normally enumerate recovery passes in the order we run them: */enum bch_recovery_pass {
Signature · 1 line
2.49.0