1 // SPDX-License-Identifier: GPL-2.0
21 #include "super-io.h"
30 /* Fake recovery pass, so that scan_for_btree_nodes isn't 0: */
38 	struct journal_keys *keys = &c->journal_keys;  in bch2_set_may_go_rw()
42 	 * setting journal_key->overwritten: it will be accessed by multiple  in bch2_set_may_go_rw()
45 	move_gap(keys, keys->nr);  in bch2_set_may_go_rw()
47 	set_bit(BCH_FS_may_go_rw, &c->flags);  in bch2_set_may_go_rw()
49 	if (keys->nr || c->opts.fsck || !c->sb.clean || c->opts.recovery_passes)  in bch2_set_may_go_rw()
71 static enum bch_recovery_pass_stable bch2_recovery_pass_to_stable(enum bch_recovery_pass pass)  in bch2_recovery_pass_to_stable()  argument
73 	return passes_to_stable_map[pass];  in bch2_recovery_pass_to_stable()
101  * For when we need to rewind recovery passes and run a pass we skipped:
104 				    enum bch_recovery_pass pass)  in bch2_run_explicit_recovery_pass()  argument
106 	if (c->opts.recovery_passes & BIT_ULL(pass))  in bch2_run_explicit_recovery_pass()
109 	bch_info(c, "running explicit recovery pass %s (%u), currently at %s (%u)",  in bch2_run_explicit_recovery_pass()
110 		 bch2_recovery_passes[pass], pass,  in bch2_run_explicit_recovery_pass()
111 		 bch2_recovery_passes[c->curr_recovery_pass], c->curr_recovery_pass);  in bch2_run_explicit_recovery_pass()
113 	c->opts.recovery_passes |= BIT_ULL(pass);  in bch2_run_explicit_recovery_pass()
115 	if (c->curr_recovery_pass >= pass) {  in bch2_run_explicit_recovery_pass()
116 		c->curr_recovery_pass = pass;  in bch2_run_explicit_recovery_pass()
117 		c->recovery_passes_complete &= (1ULL << pass) >> 1;  in bch2_run_explicit_recovery_pass()
118 		return -BCH_ERR_restart_recovery;  in bch2_run_explicit_recovery_pass()
125 					       enum bch_recovery_pass pass)  in bch2_run_explicit_recovery_pass_persistent()  argument
127 	enum bch_recovery_pass_stable s = bch2_recovery_pass_to_stable(pass);  in bch2_run_explicit_recovery_pass_persistent()
129 	mutex_lock(&c->sb_lock);  in bch2_run_explicit_recovery_pass_persistent()
130 	struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);  in bch2_run_explicit_recovery_pass_persistent()
132 	if (!test_bit_le64(s, ext->recovery_passes_required)) {  in bch2_run_explicit_recovery_pass_persistent()
133 		__set_bit_le64(s, ext->recovery_passes_required);  in bch2_run_explicit_recovery_pass_persistent()
136 	mutex_unlock(&c->sb_lock);  in bch2_run_explicit_recovery_pass_persistent()
138 	return bch2_run_explicit_recovery_pass(c, pass);  in bch2_run_explicit_recovery_pass_persistent()
142 					      enum bch_recovery_pass pass)  in bch2_clear_recovery_pass_required()  argument
144 	enum bch_recovery_pass_stable s = bch2_recovery_pass_to_stable(pass);  in bch2_clear_recovery_pass_required()
146 	mutex_lock(&c->sb_lock);  in bch2_clear_recovery_pass_required()
147 	struct bch_sb_field_ext *ext = bch2_sb_field_get(c->disk_sb.sb, ext);  in bch2_clear_recovery_pass_required()
149 	if (test_bit_le64(s, ext->recovery_passes_required)) {  in bch2_clear_recovery_pass_required()
150 		__clear_bit_le64(s, ext->recovery_passes_required);  in bch2_clear_recovery_pass_required()
153 	mutex_unlock(&c->sb_lock);  in bch2_clear_recovery_pass_required()
166 static bool should_run_recovery_pass(struct bch_fs *c, enum bch_recovery_pass pass)  in should_run_recovery_pass()  argument
168 	struct recovery_pass_fn *p = recovery_pass_fns + pass;  in should_run_recovery_pass()
170 	if (c->opts.recovery_passes_exclude & BIT_ULL(pass))  in should_run_recovery_pass()
172 	if (c->opts.recovery_passes & BIT_ULL(pass))  in should_run_recovery_pass()
174 	if ((p->when & PASS_FSCK) && c->opts.fsck)  in should_run_recovery_pass()
176 	if ((p->when & PASS_UNCLEAN) && !c->sb.clean)  in should_run_recovery_pass()
178 	if (p->when & PASS_ALWAYS)  in should_run_recovery_pass()
183 static int bch2_run_recovery_pass(struct bch_fs *c, enum bch_recovery_pass pass)  in bch2_run_recovery_pass()  argument
185 	struct recovery_pass_fn *p = recovery_pass_fns + pass;  in bch2_run_recovery_pass()
188 	if (!(p->when & PASS_SILENT))  in bch2_run_recovery_pass()
190 			   bch2_recovery_passes[pass]);  in bch2_run_recovery_pass()
191 	ret = p->fn(c);  in bch2_run_recovery_pass()
194 	if (!(p->when & PASS_SILENT))  in bch2_run_recovery_pass()
204 	down_read(&c->state_lock);  in bch2_run_online_recovery_passes()
209 		if (!(p->when & PASS_ONLINE))  in bch2_run_online_recovery_passes()
214 			i = c->curr_recovery_pass;  in bch2_run_online_recovery_passes()
221 	up_read(&c->state_lock);  in bch2_run_online_recovery_passes()
234 	c->opts.recovery_passes_exclude &= ~BCH_RECOVERY_PASS_set_may_go_rw;  in bch2_run_recovery_passes()
236 	while (c->curr_recovery_pass < ARRAY_SIZE(recovery_pass_fns)) {  in bch2_run_recovery_passes()
237 		if (c->opts.recovery_pass_last &&  in bch2_run_recovery_passes()
238 		    c->curr_recovery_pass > c->opts.recovery_pass_last)  in bch2_run_recovery_passes()
241 		if (should_run_recovery_pass(c, c->curr_recovery_pass)) {  in bch2_run_recovery_passes()
242 			unsigned pass = c->curr_recovery_pass;  in bch2_run_recovery_passes()  local
244 			ret =   bch2_run_recovery_pass(c, c->curr_recovery_pass) ?:  in bch2_run_recovery_passes()
245 				bch2_journal_flush(&c->journal);  in bch2_run_recovery_passes()
247 			    (ret && c->curr_recovery_pass < pass))  in bch2_run_recovery_passes()
252 			c->recovery_passes_complete |= BIT_ULL(c->curr_recovery_pass);  in bch2_run_recovery_passes()
255 		c->recovery_pass_done = max(c->recovery_pass_done, c->curr_recovery_pass);  in bch2_run_recovery_passes()
257 		if (!test_bit(BCH_FS_error, &c->flags))  in bch2_run_recovery_passes()
258 			bch2_clear_recovery_pass_required(c, c->curr_recovery_pass);  in bch2_run_recovery_passes()
260 		c->curr_recovery_pass++;  in bch2_run_recovery_passes()