1 // SPDX-License-Identifier: GPL-2.0
4 #include "alloc_background.h"
5 #include "backpointers.h"
6 #include "btree_cache.h"
7 #include "btree_update.h"
8 #include "btree_write_buffer.h"
13 static bool extent_matches_bp(struct bch_fs *c,
14 enum btree_id btree_id, unsigned level,
17 struct bch_backpointer bp)
19 struct bkey_ptrs_c ptrs = bch2_bkey_ptrs_c(k);
20 const union bch_extent_entry *entry;
21 struct extent_ptr_decoded p;
23 bkey_for_each_ptr_decode(k.k, ptrs, p, entry) {
25 struct bch_backpointer bp2;
30 bch2_extent_ptr_to_bp(c, btree_id, level, k, p,
32 if (bpos_eq(bucket, bucket2) &&
33 !memcmp(&bp, &bp2, sizeof(bp)))
40 int bch2_backpointer_invalid(const struct bch_fs *c, struct bkey_s_c k,
41 unsigned flags, struct printbuf *err)
43 struct bkey_s_c_backpointer bp = bkey_s_c_to_backpointer(k);
44 struct bpos bucket = bp_pos_to_bucket(c, bp.k->p);
46 if (bkey_val_bytes(bp.k) < sizeof(*bp.v)) {
47 prt_str(err, "incorrect value size");
48 return -BCH_ERR_invalid_bkey;
51 if (!bpos_eq(bp.k->p, bucket_pos_to_bp(c, bucket, bp.v->bucket_offset))) {
52 prt_str(err, "backpointer at wrong pos");
53 return -BCH_ERR_invalid_bkey;
59 void bch2_backpointer_to_text(struct printbuf *out, const struct bch_backpointer *bp)
61 prt_printf(out, "btree=%s l=%u offset=%llu:%u len=%u pos=",
62 bch2_btree_ids[bp->btree_id],
64 (u64) (bp->bucket_offset >> MAX_EXTENT_COMPRESS_RATIO_SHIFT),
65 (u32) bp->bucket_offset & ~(~0U << MAX_EXTENT_COMPRESS_RATIO_SHIFT),
67 bch2_bpos_to_text(out, bp->pos);
70 void bch2_backpointer_k_to_text(struct printbuf *out, struct bch_fs *c, struct bkey_s_c k)
72 prt_str(out, "bucket=");
73 bch2_bpos_to_text(out, bp_pos_to_bucket(c, k.k->p));
76 bch2_backpointer_to_text(out, bkey_s_c_to_backpointer(k).v);
79 void bch2_backpointer_swab(struct bkey_s k)
81 struct bkey_s_backpointer bp = bkey_s_to_backpointer(k);
83 bp.v->bucket_offset = swab32(bp.v->bucket_offset);
84 bp.v->bucket_len = swab32(bp.v->bucket_len);
85 bch2_bpos_swab(&bp.v->pos);
88 static noinline int backpointer_mod_err(struct btree_trans *trans,
89 struct bch_backpointer bp,
91 struct bkey_s_c orig_k,
94 struct bch_fs *c = trans->c;
95 struct printbuf buf = PRINTBUF;
98 prt_printf(&buf, "existing backpointer found when inserting ");
99 bch2_backpointer_to_text(&buf, &bp);
101 printbuf_indent_add(&buf, 2);
103 prt_printf(&buf, "found ");
104 bch2_bkey_val_to_text(&buf, c, bp_k);
107 prt_printf(&buf, "for ");
108 bch2_bkey_val_to_text(&buf, c, orig_k);
110 bch_err(c, "%s", buf.buf);
111 } else if (test_bit(BCH_FS_CHECK_BACKPOINTERS_DONE, &c->flags)) {
112 prt_printf(&buf, "backpointer not found when deleting");
114 printbuf_indent_add(&buf, 2);
116 prt_printf(&buf, "searching for ");
117 bch2_backpointer_to_text(&buf, &bp);
120 prt_printf(&buf, "got ");
121 bch2_bkey_val_to_text(&buf, c, bp_k);
124 prt_printf(&buf, "for ");
125 bch2_bkey_val_to_text(&buf, c, orig_k);
127 bch_err(c, "%s", buf.buf);
132 if (test_bit(BCH_FS_CHECK_BACKPOINTERS_DONE, &c->flags)) {
133 bch2_inconsistent_error(c);
140 int bch2_bucket_backpointer_mod_nowritebuffer(struct btree_trans *trans,
142 struct bch_backpointer bp,
143 struct bkey_s_c orig_k,
146 struct bch_fs *c = trans->c;
147 struct bkey_i_backpointer *bp_k;
148 struct btree_iter bp_iter;
152 bp_k = bch2_trans_kmalloc_nomemzero(trans, sizeof(struct bkey_i_backpointer));
153 ret = PTR_ERR_OR_ZERO(bp_k);
157 bkey_backpointer_init(&bp_k->k_i);
158 bp_k->k.p = bucket_pos_to_bp(c, bucket, bp.bucket_offset);
162 bp_k->k.type = KEY_TYPE_deleted;
163 set_bkey_val_u64s(&bp_k->k, 0);
166 bch2_trans_iter_init(trans, &bp_iter, BTREE_ID_backpointers,
170 BTREE_ITER_WITH_UPDATES);
171 k = bch2_btree_iter_peek_slot(&bp_iter);
178 : (k.k->type != KEY_TYPE_backpointer ||
179 memcmp(bkey_s_c_to_backpointer(k).v, &bp, sizeof(bp)))) {
180 ret = backpointer_mod_err(trans, bp, k, orig_k, insert);
185 ret = bch2_trans_update(trans, &bp_iter, &bp_k->k_i, 0);
187 bch2_trans_iter_exit(trans, &bp_iter);
192 * Find the next backpointer >= *bp_offset:
194 int bch2_get_next_backpointer(struct btree_trans *trans,
195 struct bpos bucket, int gen,
197 struct bch_backpointer *bp,
200 struct bch_fs *c = trans->c;
201 struct bpos bp_end_pos = bucket_pos_to_bp(c, bpos_nosnap_successor(bucket), 0);
202 struct btree_iter alloc_iter = { NULL }, bp_iter = { NULL };
206 if (bpos_ge(*bp_pos, bp_end_pos))
210 bch2_trans_iter_init(trans, &alloc_iter, BTREE_ID_alloc,
211 bucket, BTREE_ITER_CACHED|iter_flags);
212 k = bch2_btree_iter_peek_slot(&alloc_iter);
217 if (k.k->type != KEY_TYPE_alloc_v4 ||
218 bkey_s_c_to_alloc_v4(k).v->gen != gen)
222 *bp_pos = bpos_max(*bp_pos, bucket_pos_to_bp(c, bucket, 0));
224 for_each_btree_key_norestart(trans, bp_iter, BTREE_ID_backpointers,
225 *bp_pos, iter_flags, k, ret) {
226 if (bpos_ge(k.k->p, bp_end_pos))
230 *bp = *bkey_s_c_to_backpointer(k).v;
236 bch2_trans_iter_exit(trans, &bp_iter);
237 bch2_trans_iter_exit(trans, &alloc_iter);
241 static void backpointer_not_found(struct btree_trans *trans,
243 struct bch_backpointer bp,
245 const char *thing_it_points_to)
247 struct bch_fs *c = trans->c;
248 struct printbuf buf = PRINTBUF;
249 struct bpos bucket = bp_pos_to_bucket(c, bp_pos);
251 if (likely(!bch2_backpointers_no_use_write_buffer))
254 prt_printf(&buf, "backpointer doesn't match %s it points to:\n ",
256 prt_printf(&buf, "bucket: ");
257 bch2_bpos_to_text(&buf, bucket);
258 prt_printf(&buf, "\n ");
260 prt_printf(&buf, "backpointer pos: ");
261 bch2_bpos_to_text(&buf, bp_pos);
262 prt_printf(&buf, "\n ");
264 bch2_backpointer_to_text(&buf, &bp);
265 prt_printf(&buf, "\n ");
266 bch2_bkey_val_to_text(&buf, c, k);
267 if (!test_bit(BCH_FS_CHECK_BACKPOINTERS_DONE, &c->flags))
268 bch_err_ratelimited(c, "%s", buf.buf);
270 bch2_trans_inconsistent(trans, "%s", buf.buf);
275 struct bkey_s_c bch2_backpointer_get_key(struct btree_trans *trans,
276 struct btree_iter *iter,
278 struct bch_backpointer bp,
281 struct bch_fs *c = trans->c;
282 struct bpos bucket = bp_pos_to_bucket(c, bp_pos);
285 bch2_trans_node_iter_init(trans, iter,
289 min(bp.level, c->btree_roots[bp.btree_id].level),
291 k = bch2_btree_iter_peek_slot(iter);
293 bch2_trans_iter_exit(trans, iter);
297 if (bp.level == c->btree_roots[bp.btree_id].level + 1)
298 k = bkey_i_to_s_c(&c->btree_roots[bp.btree_id].key);
300 if (k.k && extent_matches_bp(c, bp.btree_id, bp.level, k, bucket, bp))
303 bch2_trans_iter_exit(trans, iter);
305 if (unlikely(bch2_backpointers_no_use_write_buffer)) {
310 * If a backpointer for a btree node wasn't found, it may be
311 * because it was overwritten by a new btree node that hasn't
312 * been written out yet - backpointer_get_node() checks for
315 b = bch2_backpointer_get_node(trans, iter, bp_pos, bp);
316 if (!IS_ERR_OR_NULL(b))
317 return bkey_i_to_s_c(&b->key);
319 bch2_trans_iter_exit(trans, iter);
322 return bkey_s_c_err(PTR_ERR(b));
323 return bkey_s_c_null;
326 backpointer_not_found(trans, bp_pos, bp, k, "extent");
329 return bkey_s_c_null;
332 struct btree *bch2_backpointer_get_node(struct btree_trans *trans,
333 struct btree_iter *iter,
335 struct bch_backpointer bp)
337 struct bch_fs *c = trans->c;
338 struct bpos bucket = bp_pos_to_bucket(c, bp_pos);
343 bch2_trans_node_iter_init(trans, iter,
349 b = bch2_btree_iter_peek_node(iter);
353 if (b && extent_matches_bp(c, bp.btree_id, bp.level,
354 bkey_i_to_s_c(&b->key),
358 if (b && btree_node_will_make_reachable(b)) {
359 b = ERR_PTR(-BCH_ERR_backpointer_to_overwritten_btree_node);
361 backpointer_not_found(trans, bp_pos, bp,
362 bkey_i_to_s_c(&b->key), "btree node");
366 bch2_trans_iter_exit(trans, iter);
370 static int bch2_check_btree_backpointer(struct btree_trans *trans, struct btree_iter *bp_iter,
373 struct bch_fs *c = trans->c;
374 struct btree_iter alloc_iter = { NULL };
376 struct bkey_s_c alloc_k;
377 struct printbuf buf = PRINTBUF;
380 if (fsck_err_on(!bch2_dev_exists2(c, k.k->p.inode), c,
381 "backpointer for mising device:\n%s",
382 (bch2_bkey_val_to_text(&buf, c, k), buf.buf))) {
383 ret = bch2_btree_delete_at(trans, bp_iter, 0);
387 ca = bch_dev_bkey_exists(c, k.k->p.inode);
389 bch2_trans_iter_init(trans, &alloc_iter, BTREE_ID_alloc,
390 bp_pos_to_bucket(c, k.k->p), 0);
392 alloc_k = bch2_btree_iter_peek_slot(&alloc_iter);
393 ret = bkey_err(alloc_k);
397 if (fsck_err_on(alloc_k.k->type != KEY_TYPE_alloc_v4, c,
398 "backpointer for nonexistent alloc key: %llu:%llu:0\n%s",
399 alloc_iter.pos.inode, alloc_iter.pos.offset,
400 (bch2_bkey_val_to_text(&buf, c, alloc_k), buf.buf))) {
401 ret = bch2_btree_delete_at(trans, bp_iter, 0);
406 bch2_trans_iter_exit(trans, &alloc_iter);
411 /* verify that every backpointer has a corresponding alloc key */
412 int bch2_check_btree_backpointers(struct bch_fs *c)
414 struct btree_iter iter;
417 return bch2_trans_run(c,
418 for_each_btree_key_commit(&trans, iter,
419 BTREE_ID_backpointers, POS_MIN, 0, k,
420 NULL, NULL, BTREE_INSERT_LAZY_RW|BTREE_INSERT_NOFAIL,
421 bch2_check_btree_backpointer(&trans, &iter, k)));
429 static int check_bp_exists(struct btree_trans *trans,
431 struct bch_backpointer bp,
432 struct bkey_s_c orig_k,
433 struct bpos bucket_start,
434 struct bpos bucket_end,
435 struct bpos_level *last_flushed)
437 struct bch_fs *c = trans->c;
438 struct btree_iter bp_iter = { NULL };
439 struct printbuf buf = PRINTBUF;
440 struct bkey_s_c bp_k;
443 if (bpos_lt(bucket, bucket_start) ||
444 bpos_gt(bucket, bucket_end))
447 if (!bch2_dev_bucket_exists(c, bucket))
450 bch2_trans_iter_init(trans, &bp_iter, BTREE_ID_backpointers,
451 bucket_pos_to_bp(c, bucket, bp.bucket_offset),
453 bp_k = bch2_btree_iter_peek_slot(&bp_iter);
454 ret = bkey_err(bp_k);
458 if (bp_k.k->type != KEY_TYPE_backpointer ||
459 memcmp(bkey_s_c_to_backpointer(bp_k).v, &bp, sizeof(bp))) {
460 if (last_flushed->level != bp.level ||
461 !bpos_eq(last_flushed->pos, orig_k.k->p)) {
462 last_flushed->level = bp.level;
463 last_flushed->pos = orig_k.k->p;
465 ret = bch2_btree_write_buffer_flush_sync(trans) ?:
466 -BCH_ERR_transaction_restart_write_buffer_flush;
474 bch2_trans_iter_exit(trans, &bp_iter);
478 prt_printf(&buf, "missing backpointer for btree=%s l=%u ",
479 bch2_btree_ids[bp.btree_id], bp.level);
480 bch2_bkey_val_to_text(&buf, c, orig_k);
481 prt_printf(&buf, "\nbp pos ");
482 bch2_bpos_to_text(&buf, bp_iter.pos);
484 if (c->sb.version < bcachefs_metadata_version_backpointers ||
485 c->opts.reconstruct_alloc ||
486 fsck_err(c, "%s", buf.buf))
487 ret = bch2_bucket_backpointer_mod(trans, bucket, bp, orig_k, true);
492 static int check_extent_to_backpointers(struct btree_trans *trans,
493 struct btree_iter *iter,
494 struct bpos bucket_start,
495 struct bpos bucket_end,
496 struct bpos_level *last_flushed)
498 struct bch_fs *c = trans->c;
499 struct bkey_ptrs_c ptrs;
500 const union bch_extent_entry *entry;
501 struct extent_ptr_decoded p;
505 k = bch2_btree_iter_peek_all_levels(iter);
512 ptrs = bch2_bkey_ptrs_c(k);
513 bkey_for_each_ptr_decode(k.k, ptrs, p, entry) {
514 struct bpos bucket_pos;
515 struct bch_backpointer bp;
520 bch2_extent_ptr_to_bp(c, iter->btree_id, iter->path->level,
521 k, p, &bucket_pos, &bp);
523 ret = check_bp_exists(trans, bucket_pos, bp, k,
524 bucket_start, bucket_end,
533 static int check_btree_root_to_backpointers(struct btree_trans *trans,
534 enum btree_id btree_id,
535 struct bpos bucket_start,
536 struct bpos bucket_end,
537 struct bpos_level *last_flushed)
539 struct bch_fs *c = trans->c;
540 struct btree_iter iter;
543 struct bkey_ptrs_c ptrs;
544 struct extent_ptr_decoded p;
545 const union bch_extent_entry *entry;
548 bch2_trans_node_iter_init(trans, &iter, btree_id, POS_MIN, 0,
549 c->btree_roots[btree_id].level, 0);
550 b = bch2_btree_iter_peek_node(&iter);
551 ret = PTR_ERR_OR_ZERO(b);
555 BUG_ON(b != btree_node_root(c, b));
557 k = bkey_i_to_s_c(&b->key);
558 ptrs = bch2_bkey_ptrs_c(k);
559 bkey_for_each_ptr_decode(k.k, ptrs, p, entry) {
560 struct bpos bucket_pos;
561 struct bch_backpointer bp;
566 bch2_extent_ptr_to_bp(c, iter.btree_id, b->c.level + 1,
567 k, p, &bucket_pos, &bp);
569 ret = check_bp_exists(trans, bucket_pos, bp, k,
570 bucket_start, bucket_end,
576 bch2_trans_iter_exit(trans, &iter);
580 static inline struct bbpos bp_to_bbpos(struct bch_backpointer bp)
582 return (struct bbpos) {
583 .btree = bp.btree_id,
588 static size_t btree_nodes_fit_in_ram(struct bch_fs *c)
594 mem_bytes = i.totalram * i.mem_unit;
595 return div_u64(mem_bytes >> 1, btree_bytes(c));
598 int bch2_get_btree_in_memory_pos(struct btree_trans *trans,
599 unsigned btree_leaf_mask,
600 unsigned btree_interior_mask,
601 struct bbpos start, struct bbpos *end)
603 struct btree_iter iter;
605 size_t btree_nodes = btree_nodes_fit_in_ram(trans->c);
609 for (btree = start.btree; btree < BTREE_ID_NR && !ret; btree++) {
610 unsigned depth = ((1U << btree) & btree_leaf_mask) ? 1 : 2;
612 if (!((1U << btree) & btree_leaf_mask) &&
613 !((1U << btree) & btree_interior_mask))
616 bch2_trans_node_iter_init(trans, &iter, btree,
617 btree == start.btree ? start.pos : POS_MIN,
620 * for_each_btree_key_contineu() doesn't check the return value
621 * from bch2_btree_iter_advance(), which is needed when
622 * iterating over interior nodes where we'll see keys at
626 k = __bch2_btree_iter_peek_and_restart(trans, &iter, 0);
633 *end = BBPOS(btree, k.k->p);
634 bch2_trans_iter_exit(trans, &iter);
637 } while (bch2_btree_iter_advance(&iter));
638 bch2_trans_iter_exit(trans, &iter);
645 static int bch2_check_extents_to_backpointers_pass(struct btree_trans *trans,
646 struct bpos bucket_start,
647 struct bpos bucket_end)
649 struct btree_iter iter;
650 enum btree_id btree_id;
651 struct bpos_level last_flushed = { UINT_MAX };
654 for (btree_id = 0; btree_id < BTREE_ID_NR; btree_id++) {
655 unsigned depth = btree_type_has_ptrs(btree_id) ? 0 : 1;
657 bch2_trans_node_iter_init(trans, &iter, btree_id, POS_MIN, 0,
659 BTREE_ITER_ALL_LEVELS|
660 BTREE_ITER_PREFETCH);
663 ret = commit_do(trans, NULL, NULL,
664 BTREE_INSERT_LAZY_RW|
666 check_extent_to_backpointers(trans, &iter,
667 bucket_start, bucket_end,
671 } while (!bch2_btree_iter_advance(&iter));
673 bch2_trans_iter_exit(trans, &iter);
678 ret = commit_do(trans, NULL, NULL,
679 BTREE_INSERT_LAZY_RW|
681 check_btree_root_to_backpointers(trans, btree_id,
682 bucket_start, bucket_end,
690 static struct bpos bucket_pos_to_bp_safe(const struct bch_fs *c,
693 return bch2_dev_exists2(c, bucket.inode)
694 ? bucket_pos_to_bp(c, bucket, 0)
698 int bch2_get_alloc_in_memory_pos(struct btree_trans *trans,
699 struct bpos start, struct bpos *end)
701 struct btree_iter alloc_iter;
702 struct btree_iter bp_iter;
703 struct bkey_s_c alloc_k, bp_k;
704 size_t btree_nodes = btree_nodes_fit_in_ram(trans->c);
705 bool alloc_end = false, bp_end = false;
708 bch2_trans_node_iter_init(trans, &alloc_iter, BTREE_ID_alloc,
710 bch2_trans_node_iter_init(trans, &bp_iter, BTREE_ID_backpointers,
711 bucket_pos_to_bp_safe(trans->c, start), 0, 1, 0);
714 ? __bch2_btree_iter_peek_and_restart(trans, &alloc_iter, 0)
717 ? __bch2_btree_iter_peek_and_restart(trans, &bp_iter, 0)
720 ret = bkey_err(alloc_k) ?: bkey_err(bp_k);
721 if ((!alloc_k.k && !bp_k.k) || ret) {
732 if (bpos_lt(alloc_iter.pos, SPOS_MAX) &&
733 bpos_lt(bucket_pos_to_bp_safe(trans->c, alloc_iter.pos), bp_iter.pos)) {
734 if (!bch2_btree_iter_advance(&alloc_iter))
737 if (!bch2_btree_iter_advance(&bp_iter))
741 bch2_trans_iter_exit(trans, &bp_iter);
742 bch2_trans_iter_exit(trans, &alloc_iter);
746 int bch2_check_extents_to_backpointers(struct bch_fs *c)
748 struct btree_trans trans;
749 struct bpos start = POS_MIN, end;
752 bch2_trans_init(&trans, c, 0, 0);
754 ret = bch2_get_alloc_in_memory_pos(&trans, start, &end);
758 if (bpos_eq(start, POS_MIN) && !bpos_eq(end, SPOS_MAX))
759 bch_verbose(c, "%s(): alloc info does not fit in ram, running in multiple passes with %zu nodes per pass",
760 __func__, btree_nodes_fit_in_ram(c));
762 if (!bpos_eq(start, POS_MIN) || !bpos_eq(end, SPOS_MAX)) {
763 struct printbuf buf = PRINTBUF;
765 prt_str(&buf, "check_extents_to_backpointers(): ");
766 bch2_bpos_to_text(&buf, start);
768 bch2_bpos_to_text(&buf, end);
770 bch_verbose(c, "%s", buf.buf);
774 ret = bch2_check_extents_to_backpointers_pass(&trans, start, end);
775 if (ret || bpos_eq(end, SPOS_MAX))
778 start = bpos_successor(end);
780 bch2_trans_exit(&trans);
785 static int check_one_backpointer(struct btree_trans *trans,
788 struct bkey_s_c_backpointer bp,
789 struct bpos *last_flushed_pos)
791 struct bch_fs *c = trans->c;
792 struct btree_iter iter;
793 struct bbpos pos = bp_to_bbpos(*bp.v);
795 struct printbuf buf = PRINTBUF;
798 if (bbpos_cmp(pos, start) < 0 ||
799 bbpos_cmp(pos, end) > 0)
802 k = bch2_backpointer_get_key(trans, &iter, bp.k->p, *bp.v, 0);
804 if (ret == -BCH_ERR_backpointer_to_overwritten_btree_node)
809 if (!k.k && !bpos_eq(*last_flushed_pos, bp.k->p)) {
810 *last_flushed_pos = bp.k->p;
811 ret = bch2_btree_write_buffer_flush_sync(trans) ?:
812 -BCH_ERR_transaction_restart_write_buffer_flush;
816 if (fsck_err_on(!k.k, c,
817 "backpointer for missing extent\n %s",
818 (bch2_backpointer_k_to_text(&buf, c, bp.s_c), buf.buf)))
819 return bch2_btree_delete_at_buffered(trans, BTREE_ID_backpointers, bp.k->p);
822 bch2_trans_iter_exit(trans, &iter);
827 static int bch2_check_backpointers_to_extents_pass(struct btree_trans *trans,
831 struct btree_iter iter;
833 struct bpos last_flushed_pos = SPOS_MAX;
835 return for_each_btree_key_commit(trans, iter, BTREE_ID_backpointers,
836 POS_MIN, BTREE_ITER_PREFETCH, k,
837 NULL, NULL, BTREE_INSERT_LAZY_RW|BTREE_INSERT_NOFAIL,
838 check_one_backpointer(trans, start, end,
839 bkey_s_c_to_backpointer(k),
843 int bch2_check_backpointers_to_extents(struct bch_fs *c)
845 struct btree_trans trans;
846 struct bbpos start = (struct bbpos) { .btree = 0, .pos = POS_MIN, }, end;
849 bch2_trans_init(&trans, c, 0, 0);
851 ret = bch2_get_btree_in_memory_pos(&trans,
852 (1U << BTREE_ID_extents)|
853 (1U << BTREE_ID_reflink),
859 if (!bbpos_cmp(start, BBPOS_MIN) &&
860 bbpos_cmp(end, BBPOS_MAX))
861 bch_verbose(c, "%s(): extents do not fit in ram, running in multiple passes with %zu nodes per pass",
862 __func__, btree_nodes_fit_in_ram(c));
864 if (bbpos_cmp(start, BBPOS_MIN) ||
865 bbpos_cmp(end, BBPOS_MAX)) {
866 struct printbuf buf = PRINTBUF;
868 prt_str(&buf, "check_backpointers_to_extents(): ");
869 bch2_bbpos_to_text(&buf, start);
871 bch2_bbpos_to_text(&buf, end);
873 bch_verbose(c, "%s", buf.buf);
877 ret = bch2_check_backpointers_to_extents_pass(&trans, start, end);
878 if (ret || !bbpos_cmp(end, BBPOS_MAX))
881 start = bbpos_successor(end);
883 bch2_trans_exit(&trans);