1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2018 Oracle. All Rights Reserved.
4 * Author: Darrick J. Wong <darrick.wong@oracle.com>
8 #include "xfs_shared.h"
9 #include "xfs_format.h"
10 #include "xfs_trans_resv.h"
11 #include "xfs_mount.h"
12 #include "xfs_defer.h"
13 #include "xfs_btree.h"
15 #include "xfs_log_format.h"
16 #include "xfs_trans.h"
18 #include "xfs_inode.h"
19 #include "xfs_icache.h"
20 #include "xfs_alloc.h"
21 #include "xfs_alloc_btree.h"
22 #include "xfs_ialloc.h"
23 #include "xfs_ialloc_btree.h"
25 #include "xfs_rmap_btree.h"
26 #include "xfs_refcount.h"
27 #include "xfs_refcount_btree.h"
28 #include "xfs_extent_busy.h"
29 #include "xfs_ag_resv.h"
30 #include "xfs_trans_space.h"
31 #include "xfs_quota.h"
33 #include "xfs_reflink.h"
34 #include "scrub/xfs_scrub.h"
35 #include "scrub/scrub.h"
36 #include "scrub/common.h"
37 #include "scrub/trace.h"
38 #include "scrub/repair.h"
39 #include "scrub/bitmap.h"
42 * Attempt to repair some metadata, if the metadata is corrupt and userspace
43 * told us to fix it. This function returns -EAGAIN to mean "re-run scrub",
44 * and will set *fixed to true if it thinks it repaired anything.
54 trace_xrep_attempt(ip
, sc
->sm
, error
);
56 xchk_ag_btcur_free(&sc
->sa
);
58 /* Repair whatever's broken. */
59 ASSERT(sc
->ops
->repair
);
60 error
= sc
->ops
->repair(sc
);
61 trace_xrep_done(ip
, sc
->sm
, error
);
65 * Repair succeeded. Commit the fixes and perform a second
66 * scrub so that we can tell userspace if we fixed the problem.
68 sc
->sm
->sm_flags
&= ~XFS_SCRUB_FLAGS_OUT
;
73 /* Tell the caller to try again having grabbed all the locks. */
74 if (!sc
->try_harder
) {
75 sc
->try_harder
= true;
79 * We tried harder but still couldn't grab all the resources
80 * we needed to fix it. The corruption has not been fixed,
81 * so report back to userspace.
90 * Complain about unfixable problems in the filesystem. We don't log
91 * corruptions when IFLAG_REPAIR wasn't set on the assumption that the driver
92 * program is xfs_scrub, which will call back with IFLAG_REPAIR set if the
93 * administrator isn't running xfs_scrub in no-repairs mode.
95 * Use this helper function because _ratelimited silently declares a static
96 * structure to track rate limiting information.
100 struct xfs_mount
*mp
)
102 xfs_alert_ratelimited(mp
,
103 "Corruption not fixed during online repair. Unmount and run xfs_repair.");
107 * Repair probe -- userspace uses this to probe if we're willing to repair a
112 struct xfs_scrub
*sc
)
116 if (xchk_should_terminate(sc
, &error
))
123 * Roll a transaction, keeping the AG headers locked and reinitializing
128 struct xfs_scrub
*sc
)
132 /* Keep the AG header buffers locked so we can keep going. */
134 xfs_trans_bhold(sc
->tp
, sc
->sa
.agi_bp
);
136 xfs_trans_bhold(sc
->tp
, sc
->sa
.agf_bp
);
138 xfs_trans_bhold(sc
->tp
, sc
->sa
.agfl_bp
);
140 /* Roll the transaction. */
141 error
= xfs_trans_roll(&sc
->tp
);
145 /* Join AG headers to the new transaction. */
147 xfs_trans_bjoin(sc
->tp
, sc
->sa
.agi_bp
);
149 xfs_trans_bjoin(sc
->tp
, sc
->sa
.agf_bp
);
151 xfs_trans_bjoin(sc
->tp
, sc
->sa
.agfl_bp
);
157 * Rolling failed, so release the hold on the buffers. The
158 * buffers will be released during teardown on our way out
162 xfs_trans_bhold_release(sc
->tp
, sc
->sa
.agi_bp
);
164 xfs_trans_bhold_release(sc
->tp
, sc
->sa
.agf_bp
);
166 xfs_trans_bhold_release(sc
->tp
, sc
->sa
.agfl_bp
);
172 * Does the given AG have enough space to rebuild a btree? Neither AG
173 * reservation can be critical, and we must have enough space (factoring
174 * in AG reservations) to construct a whole btree.
178 struct xfs_perag
*pag
,
179 xfs_extlen_t nr_blocks
,
180 enum xfs_ag_resv_type type
)
182 return !xfs_ag_resv_critical(pag
, XFS_AG_RESV_RMAPBT
) &&
183 !xfs_ag_resv_critical(pag
, XFS_AG_RESV_METADATA
) &&
184 pag
->pagf_freeblks
> xfs_ag_resv_needed(pag
, type
) + nr_blocks
;
188 * Figure out how many blocks to reserve for an AG repair. We calculate the
189 * worst case estimate for the number of blocks we'd need to rebuild one of
190 * any type of per-AG btree.
193 xrep_calc_ag_resblks(
194 struct xfs_scrub
*sc
)
196 struct xfs_mount
*mp
= sc
->mp
;
197 struct xfs_scrub_metadata
*sm
= sc
->sm
;
198 struct xfs_perag
*pag
;
200 xfs_agino_t icount
= NULLAGINO
;
201 xfs_extlen_t aglen
= NULLAGBLOCK
;
202 xfs_extlen_t usedlen
;
203 xfs_extlen_t freelen
;
204 xfs_extlen_t bnobt_sz
;
205 xfs_extlen_t inobt_sz
;
206 xfs_extlen_t rmapbt_sz
;
207 xfs_extlen_t refcbt_sz
;
210 if (!(sm
->sm_flags
& XFS_SCRUB_IFLAG_REPAIR
))
213 pag
= xfs_perag_get(mp
, sm
->sm_agno
);
214 if (pag
->pagi_init
) {
215 /* Use in-core icount if possible. */
216 icount
= pag
->pagi_count
;
218 /* Try to get the actual counters from disk. */
219 error
= xfs_ialloc_read_agi(mp
, NULL
, sm
->sm_agno
, &bp
);
221 icount
= pag
->pagi_count
;
226 /* Now grab the block counters from the AGF. */
227 error
= xfs_alloc_read_agf(mp
, NULL
, sm
->sm_agno
, 0, &bp
);
229 aglen
= be32_to_cpu(XFS_BUF_TO_AGF(bp
)->agf_length
);
230 freelen
= be32_to_cpu(XFS_BUF_TO_AGF(bp
)->agf_freeblks
);
231 usedlen
= aglen
- freelen
;
236 /* If the icount is impossible, make some worst-case assumptions. */
237 if (icount
== NULLAGINO
||
238 !xfs_verify_agino(mp
, sm
->sm_agno
, icount
)) {
239 xfs_agino_t first
, last
;
241 xfs_agino_range(mp
, sm
->sm_agno
, &first
, &last
);
242 icount
= last
- first
+ 1;
245 /* If the block counts are impossible, make worst-case assumptions. */
246 if (aglen
== NULLAGBLOCK
||
247 aglen
!= xfs_ag_block_count(mp
, sm
->sm_agno
) ||
249 aglen
= xfs_ag_block_count(mp
, sm
->sm_agno
);
254 trace_xrep_calc_ag_resblks(mp
, sm
->sm_agno
, icount
, aglen
,
258 * Figure out how many blocks we'd need worst case to rebuild
259 * each type of btree. Note that we can only rebuild the
260 * bnobt/cntbt or inobt/finobt as pairs.
262 bnobt_sz
= 2 * xfs_allocbt_calc_size(mp
, freelen
);
263 if (xfs_sb_version_hassparseinodes(&mp
->m_sb
))
264 inobt_sz
= xfs_iallocbt_calc_size(mp
, icount
/
265 XFS_INODES_PER_HOLEMASK_BIT
);
267 inobt_sz
= xfs_iallocbt_calc_size(mp
, icount
/
268 XFS_INODES_PER_CHUNK
);
269 if (xfs_sb_version_hasfinobt(&mp
->m_sb
))
271 if (xfs_sb_version_hasreflink(&mp
->m_sb
))
272 refcbt_sz
= xfs_refcountbt_calc_size(mp
, usedlen
);
275 if (xfs_sb_version_hasrmapbt(&mp
->m_sb
)) {
277 * Guess how many blocks we need to rebuild the rmapbt.
278 * For non-reflink filesystems we can't have more records than
279 * used blocks. However, with reflink it's possible to have
280 * more than one rmap record per AG block. We don't know how
281 * many rmaps there could be in the AG, so we start off with
282 * what we hope is an generous over-estimation.
284 if (xfs_sb_version_hasreflink(&mp
->m_sb
))
285 rmapbt_sz
= xfs_rmapbt_calc_size(mp
,
286 (unsigned long long)aglen
* 2);
288 rmapbt_sz
= xfs_rmapbt_calc_size(mp
, usedlen
);
293 trace_xrep_calc_ag_resblks_btsize(mp
, sm
->sm_agno
, bnobt_sz
,
294 inobt_sz
, rmapbt_sz
, refcbt_sz
);
296 return max(max(bnobt_sz
, inobt_sz
), max(rmapbt_sz
, refcbt_sz
));
299 /* Allocate a block in an AG. */
302 struct xfs_scrub
*sc
,
303 const struct xfs_owner_info
*oinfo
,
304 xfs_fsblock_t
*fsbno
,
305 enum xfs_ag_resv_type resv
)
307 struct xfs_alloc_arg args
= {0};
312 case XFS_AG_RESV_AGFL
:
313 case XFS_AG_RESV_RMAPBT
:
314 error
= xfs_alloc_get_freelist(sc
->tp
, sc
->sa
.agf_bp
, &bno
, 1);
317 if (bno
== NULLAGBLOCK
)
319 xfs_extent_busy_reuse(sc
->mp
, sc
->sa
.agno
, bno
,
321 *fsbno
= XFS_AGB_TO_FSB(sc
->mp
, sc
->sa
.agno
, bno
);
322 if (resv
== XFS_AG_RESV_RMAPBT
)
323 xfs_ag_resv_rmapbt_alloc(sc
->mp
, sc
->sa
.agno
);
332 args
.fsbno
= XFS_AGB_TO_FSB(args
.mp
, sc
->sa
.agno
, 0);
336 args
.type
= XFS_ALLOCTYPE_THIS_AG
;
339 error
= xfs_alloc_vextent(&args
);
342 if (args
.fsbno
== NULLFSBLOCK
)
344 ASSERT(args
.len
== 1);
350 /* Initialize a new AG btree root block with zero entries. */
353 struct xfs_scrub
*sc
,
355 struct xfs_buf
**bpp
,
357 const struct xfs_buf_ops
*ops
)
359 struct xfs_trans
*tp
= sc
->tp
;
360 struct xfs_mount
*mp
= sc
->mp
;
363 trace_xrep_init_btblock(mp
, XFS_FSB_TO_AGNO(mp
, fsb
),
364 XFS_FSB_TO_AGBNO(mp
, fsb
), btnum
);
366 ASSERT(XFS_FSB_TO_AGNO(mp
, fsb
) == sc
->sa
.agno
);
367 bp
= xfs_trans_get_buf(tp
, mp
->m_ddev_targp
, XFS_FSB_TO_DADDR(mp
, fsb
),
368 XFS_FSB_TO_BB(mp
, 1), 0);
369 xfs_buf_zero(bp
, 0, BBTOB(bp
->b_length
));
370 xfs_btree_init_block(mp
, bp
, btnum
, 0, 0, sc
->sa
.agno
, 0);
371 xfs_trans_buf_set_type(tp
, bp
, XFS_BLFT_BTREE_BUF
);
372 xfs_trans_log_buf(tp
, bp
, 0, bp
->b_length
);
380 * Reconstructing per-AG Btrees
382 * When a space btree is corrupt, we don't bother trying to fix it. Instead,
383 * we scan secondary space metadata to derive the records that should be in
384 * the damaged btree, initialize a fresh btree root, and insert the records.
385 * Note that for rebuilding the rmapbt we scan all the primary data to
386 * generate the new records.
388 * However, that leaves the matter of removing all the metadata describing the
389 * old broken structure. For primary metadata we use the rmap data to collect
390 * every extent with a matching rmap owner (bitmap); we then iterate all other
391 * metadata structures with the same rmap owner to collect the extents that
392 * cannot be removed (sublist). We then subtract sublist from bitmap to
393 * derive the blocks that were used by the old btree. These blocks can be
396 * For rmapbt reconstructions we must use different tactics for extent
397 * collection. First we iterate all primary metadata (this excludes the old
398 * rmapbt, obviously) to generate new rmap records. The gaps in the rmap
399 * records are collected as bitmap. The bnobt records are collected as
400 * sublist. As with the other btrees we subtract sublist from bitmap, and the
401 * result (since the rmapbt lives in the free space) are the blocks from the
404 * Disposal of Blocks from Old per-AG Btrees
406 * Now that we've constructed a new btree to replace the damaged one, we want
407 * to dispose of the blocks that (we think) the old btree was using.
408 * Previously, we used the rmapbt to collect the extents (bitmap) with the
409 * rmap owner corresponding to the tree we rebuilt, collected extents for any
410 * blocks with the same rmap owner that are owned by another data structure
411 * (sublist), and subtracted sublist from bitmap. In theory the extents
412 * remaining in bitmap are the old btree's blocks.
414 * Unfortunately, it's possible that the btree was crosslinked with other
415 * blocks on disk. The rmap data can tell us if there are multiple owners, so
416 * if the rmapbt says there is an owner of this block other than @oinfo, then
417 * the block is crosslinked. Remove the reverse mapping and continue.
419 * If there is one rmap record, we can free the block, which removes the
420 * reverse mapping but doesn't add the block to the free space. Our repair
421 * strategy is to hope the other metadata objects crosslinked on this block
422 * will be rebuilt (atop different blocks), thereby removing all the cross
425 * If there are no rmap records at all, we also free the block. If the btree
426 * being rebuilt lives in the free space (bnobt/cntbt/rmapbt) then there isn't
427 * supposed to be a rmap record and everything is ok. For other btrees there
428 * had to have been an rmap entry for the block to have ended up on @bitmap,
429 * so if it's gone now there's something wrong and the fs will shut down.
431 * Note: If there are multiple rmap records with only the same rmap owner as
432 * the btree we're trying to rebuild and the block is indeed owned by another
433 * data structure with the same rmap owner, then the block will be in sublist
434 * and therefore doesn't need disposal. If there are multiple rmap records
435 * with only the same rmap owner but the block is not owned by something with
436 * the same rmap owner, the block will be freed.
438 * The caller is responsible for locking the AG headers for the entire rebuild
439 * operation so that nothing else can sneak in and change the AG state while
440 * we're not looking. We also assume that the caller already invalidated any
441 * buffers associated with @bitmap.
445 * Invalidate buffers for per-AG btree blocks we're dumping. This function
446 * is not intended for use with file data repairs; we have bunmapi for that.
449 xrep_invalidate_blocks(
450 struct xfs_scrub
*sc
,
451 struct xfs_bitmap
*bitmap
)
453 struct xfs_bitmap_range
*bmr
;
454 struct xfs_bitmap_range
*n
;
459 * For each block in each extent, see if there's an incore buffer for
460 * exactly that block; if so, invalidate it. The buffer cache only
461 * lets us look for one buffer at a time, so we have to look one block
462 * at a time. Avoid invalidating AG headers and post-EOFS blocks
463 * because we never own those; and if we can't TRYLOCK the buffer we
464 * assume it's owned by someone else.
466 for_each_xfs_bitmap_block(fsbno
, bmr
, n
, bitmap
) {
467 /* Skip AG headers and post-EOFS blocks */
468 if (!xfs_verify_fsbno(sc
->mp
, fsbno
))
470 bp
= xfs_buf_incore(sc
->mp
->m_ddev_targp
,
471 XFS_FSB_TO_DADDR(sc
->mp
, fsbno
),
472 XFS_FSB_TO_BB(sc
->mp
, 1), XBF_TRYLOCK
);
474 xfs_trans_bjoin(sc
->tp
, bp
);
475 xfs_trans_binval(sc
->tp
, bp
);
482 /* Ensure the freelist is the correct size. */
485 struct xfs_scrub
*sc
,
488 struct xfs_alloc_arg args
= {0};
492 args
.agno
= sc
->sa
.agno
;
494 args
.pag
= sc
->sa
.pag
;
496 return xfs_alloc_fix_freelist(&args
,
497 can_shrink
? 0 : XFS_ALLOC_FLAG_NOSHRINK
);
501 * Put a block back on the AGFL.
505 struct xfs_scrub
*sc
,
510 /* Make sure there's space on the freelist. */
511 error
= xrep_fix_freelist(sc
, true);
516 * Since we're "freeing" a lost block onto the AGFL, we have to
517 * create an rmap for the block prior to merging it or else other
520 error
= xfs_rmap_alloc(sc
->tp
, sc
->sa
.agf_bp
, sc
->sa
.agno
, agbno
, 1,
525 /* Put the block on the AGFL. */
526 error
= xfs_alloc_put_freelist(sc
->tp
, sc
->sa
.agf_bp
, sc
->sa
.agfl_bp
,
530 xfs_extent_busy_insert(sc
->tp
, sc
->sa
.agno
, agbno
, 1,
531 XFS_EXTENT_BUSY_SKIP_DISCARD
);
536 /* Dispose of a single block. */
539 struct xfs_scrub
*sc
,
541 const struct xfs_owner_info
*oinfo
,
542 enum xfs_ag_resv_type resv
)
544 struct xfs_btree_cur
*cur
;
545 struct xfs_buf
*agf_bp
= NULL
;
551 agno
= XFS_FSB_TO_AGNO(sc
->mp
, fsbno
);
552 agbno
= XFS_FSB_TO_AGBNO(sc
->mp
, fsbno
);
555 * If we are repairing per-inode metadata, we need to read in the AGF
556 * buffer. Otherwise, we're repairing a per-AG structure, so reuse
557 * the AGF buffer that the setup functions already grabbed.
560 error
= xfs_alloc_read_agf(sc
->mp
, sc
->tp
, agno
, 0, &agf_bp
);
566 agf_bp
= sc
->sa
.agf_bp
;
568 cur
= xfs_rmapbt_init_cursor(sc
->mp
, sc
->tp
, agf_bp
, agno
);
570 /* Can we find any other rmappings? */
571 error
= xfs_rmap_has_other_keys(cur
, agbno
, 1, oinfo
, &has_other_rmap
);
572 xfs_btree_del_cursor(cur
, error
);
577 * If there are other rmappings, this block is cross linked and must
578 * not be freed. Remove the reverse mapping and move on. Otherwise,
579 * we were the only owner of the block, so free the extent, which will
580 * also remove the rmap.
582 * XXX: XFS doesn't support detecting the case where a single block
583 * metadata structure is crosslinked with a multi-block structure
584 * because the buffer cache doesn't detect aliasing problems, so we
585 * can't fix 100% of crosslinking problems (yet). The verifiers will
586 * blow on writeout, the filesystem will shut down, and the admin gets
590 error
= xfs_rmap_free(sc
->tp
, agf_bp
, agno
, agbno
, 1, oinfo
);
591 else if (resv
== XFS_AG_RESV_AGFL
)
592 error
= xrep_put_freelist(sc
, agbno
);
594 error
= xfs_free_extent(sc
->tp
, fsbno
, 1, oinfo
, resv
);
595 if (agf_bp
!= sc
->sa
.agf_bp
)
596 xfs_trans_brelse(sc
->tp
, agf_bp
);
601 return xfs_trans_roll_inode(&sc
->tp
, sc
->ip
);
602 return xrep_roll_ag_trans(sc
);
605 if (agf_bp
!= sc
->sa
.agf_bp
)
606 xfs_trans_brelse(sc
->tp
, agf_bp
);
610 /* Dispose of every block of every extent in the bitmap. */
613 struct xfs_scrub
*sc
,
614 struct xfs_bitmap
*bitmap
,
615 const struct xfs_owner_info
*oinfo
,
616 enum xfs_ag_resv_type type
)
618 struct xfs_bitmap_range
*bmr
;
619 struct xfs_bitmap_range
*n
;
623 ASSERT(xfs_sb_version_hasrmapbt(&sc
->mp
->m_sb
));
625 for_each_xfs_bitmap_block(fsbno
, bmr
, n
, bitmap
) {
626 ASSERT(sc
->ip
!= NULL
||
627 XFS_FSB_TO_AGNO(sc
->mp
, fsbno
) == sc
->sa
.agno
);
628 trace_xrep_dispose_btree_extent(sc
->mp
,
629 XFS_FSB_TO_AGNO(sc
->mp
, fsbno
),
630 XFS_FSB_TO_AGBNO(sc
->mp
, fsbno
), 1);
632 error
= xrep_reap_block(sc
, fsbno
, oinfo
, type
);
638 xfs_bitmap_destroy(bitmap
);
643 * Finding per-AG Btree Roots for AGF/AGI Reconstruction
645 * If the AGF or AGI become slightly corrupted, it may be necessary to rebuild
646 * the AG headers by using the rmap data to rummage through the AG looking for
647 * btree roots. This is not guaranteed to work if the AG is heavily damaged
648 * or the rmap data are corrupt.
650 * Callers of xrep_find_ag_btree_roots must lock the AGF and AGFL
651 * buffers if the AGF is being rebuilt; or the AGF and AGI buffers if the
652 * AGI is being rebuilt. It must maintain these locks until it's safe for
653 * other threads to change the btrees' shapes. The caller provides
654 * information about the btrees to look for by passing in an array of
655 * xrep_find_ag_btree with the (rmap owner, buf_ops, magic) fields set.
656 * The (root, height) fields will be set on return if anything is found. The
657 * last element of the array should have a NULL buf_ops to mark the end of the
660 * For every rmapbt record matching any of the rmap owners in btree_info,
661 * read each block referenced by the rmap record. If the block is a btree
662 * block from this filesystem matching any of the magic numbers and has a
663 * level higher than what we've already seen, remember the block and the
664 * height of the tree required to have such a block. When the call completes,
665 * we return the highest block we've found for each btree description; those
666 * should be the roots.
669 struct xrep_findroot
{
670 struct xfs_scrub
*sc
;
671 struct xfs_buf
*agfl_bp
;
673 struct xrep_find_ag_btree
*btree_info
;
676 /* See if our block is in the AGFL. */
678 xrep_findroot_agfl_walk(
679 struct xfs_mount
*mp
,
683 xfs_agblock_t
*agbno
= priv
;
685 return (*agbno
== bno
) ? XFS_BTREE_QUERY_RANGE_ABORT
: 0;
688 /* Does this block match the btree information passed in? */
691 struct xrep_findroot
*ri
,
692 struct xrep_find_ag_btree
*fab
,
695 bool *done_with_block
)
697 struct xfs_mount
*mp
= ri
->sc
->mp
;
699 struct xfs_btree_block
*btblock
;
704 daddr
= XFS_AGB_TO_DADDR(mp
, ri
->sc
->sa
.agno
, agbno
);
707 * Blocks in the AGFL have stale contents that might just happen to
708 * have a matching magic and uuid. We don't want to pull these blocks
709 * in as part of a tree root, so we have to filter out the AGFL stuff
710 * here. If the AGFL looks insane we'll just refuse to repair.
712 if (owner
== XFS_RMAP_OWN_AG
) {
713 error
= xfs_agfl_walk(mp
, ri
->agf
, ri
->agfl_bp
,
714 xrep_findroot_agfl_walk
, &agbno
);
715 if (error
== XFS_BTREE_QUERY_RANGE_ABORT
)
722 * Read the buffer into memory so that we can see if it's a match for
723 * our btree type. We have no clue if it is beforehand, and we want to
724 * avoid xfs_trans_read_buf's behavior of dumping the DONE state (which
725 * will cause needless disk reads in subsequent calls to this function)
726 * and logging metadata verifier failures.
728 * Therefore, pass in NULL buffer ops. If the buffer was already in
729 * memory from some other caller it will already have b_ops assigned.
730 * If it was in memory from a previous unsuccessful findroot_block
731 * call, the buffer won't have b_ops but it should be clean and ready
732 * for us to try to verify if the read call succeeds. The same applies
733 * if the buffer wasn't in memory at all.
735 * Note: If we never match a btree type with this buffer, it will be
736 * left in memory with NULL b_ops. This shouldn't be a problem unless
737 * the buffer gets written.
739 error
= xfs_trans_read_buf(mp
, ri
->sc
->tp
, mp
->m_ddev_targp
, daddr
,
740 mp
->m_bsize
, 0, &bp
, NULL
);
744 /* Ensure the block magic matches the btree type we're looking for. */
745 btblock
= XFS_BUF_TO_BLOCK(bp
);
746 if (be32_to_cpu(btblock
->bb_magic
) != fab
->magic
)
750 * If the buffer already has ops applied and they're not the ones for
751 * this btree type, we know this block doesn't match the btree and we
754 * If the buffer ops match ours, someone else has already validated
755 * the block for us, so we can move on to checking if this is a root
758 * If the buffer does not have ops, nobody has successfully validated
759 * the contents and the buffer cannot be dirty. If the magic, uuid,
760 * and structure match this btree type then we'll move on to checking
761 * if it's a root block candidate. If there is no match, bail out.
764 if (bp
->b_ops
!= fab
->buf_ops
)
767 ASSERT(!xfs_trans_buf_is_dirty(bp
));
768 if (!uuid_equal(&btblock
->bb_u
.s
.bb_uuid
,
769 &mp
->m_sb
.sb_meta_uuid
))
772 * Read verifiers can reference b_ops, so we set the pointer
773 * here. If the verifier fails we'll reset the buffer state
774 * to what it was before we touched the buffer.
776 bp
->b_ops
= fab
->buf_ops
;
777 fab
->buf_ops
->verify_read(bp
);
785 * Some read verifiers will (re)set b_ops, so we must be
786 * careful not to change b_ops after running the verifier.
791 * This block passes the magic/uuid and verifier tests for this btree
792 * type. We don't need the caller to try the other tree types.
794 *done_with_block
= true;
797 * Compare this btree block's level to the height of the current
798 * candidate root block.
800 * If the level matches the root we found previously, throw away both
801 * blocks because there can't be two candidate roots.
803 * If level is lower in the tree than the root we found previously,
806 block_level
= xfs_btree_get_level(btblock
);
807 if (block_level
+ 1 == fab
->height
) {
808 fab
->root
= NULLAGBLOCK
;
810 } else if (block_level
< fab
->height
) {
815 * This is the highest block in the tree that we've found so far.
816 * Update the btree height to reflect what we've learned from this
819 fab
->height
= block_level
+ 1;
822 * If this block doesn't have sibling pointers, then it's the new root
823 * block candidate. Otherwise, the root will be found farther up the
826 if (btblock
->bb_u
.s
.bb_leftsib
== cpu_to_be32(NULLAGBLOCK
) &&
827 btblock
->bb_u
.s
.bb_rightsib
== cpu_to_be32(NULLAGBLOCK
))
830 fab
->root
= NULLAGBLOCK
;
832 trace_xrep_findroot_block(mp
, ri
->sc
->sa
.agno
, agbno
,
833 be32_to_cpu(btblock
->bb_magic
), fab
->height
- 1);
835 xfs_trans_brelse(ri
->sc
->tp
, bp
);
840 * Do any of the blocks in this rmap record match one of the btrees we're
845 struct xfs_btree_cur
*cur
,
846 struct xfs_rmap_irec
*rec
,
849 struct xrep_findroot
*ri
= priv
;
850 struct xrep_find_ag_btree
*fab
;
855 /* Ignore anything that isn't AG metadata. */
856 if (!XFS_RMAP_NON_INODE_OWNER(rec
->rm_owner
))
859 /* Otherwise scan each block + btree type. */
860 for (b
= 0; b
< rec
->rm_blockcount
; b
++) {
862 for (fab
= ri
->btree_info
; fab
->buf_ops
; fab
++) {
863 if (rec
->rm_owner
!= fab
->rmap_owner
)
865 error
= xrep_findroot_block(ri
, fab
,
866 rec
->rm_owner
, rec
->rm_startblock
+ b
,
878 /* Find the roots of the per-AG btrees described in btree_info. */
880 xrep_find_ag_btree_roots(
881 struct xfs_scrub
*sc
,
882 struct xfs_buf
*agf_bp
,
883 struct xrep_find_ag_btree
*btree_info
,
884 struct xfs_buf
*agfl_bp
)
886 struct xfs_mount
*mp
= sc
->mp
;
887 struct xrep_findroot ri
;
888 struct xrep_find_ag_btree
*fab
;
889 struct xfs_btree_cur
*cur
;
892 ASSERT(xfs_buf_islocked(agf_bp
));
893 ASSERT(agfl_bp
== NULL
|| xfs_buf_islocked(agfl_bp
));
896 ri
.btree_info
= btree_info
;
897 ri
.agf
= XFS_BUF_TO_AGF(agf_bp
);
898 ri
.agfl_bp
= agfl_bp
;
899 for (fab
= btree_info
; fab
->buf_ops
; fab
++) {
900 ASSERT(agfl_bp
|| fab
->rmap_owner
!= XFS_RMAP_OWN_AG
);
901 ASSERT(XFS_RMAP_NON_INODE_OWNER(fab
->rmap_owner
));
902 fab
->root
= NULLAGBLOCK
;
906 cur
= xfs_rmapbt_init_cursor(mp
, sc
->tp
, agf_bp
, sc
->sa
.agno
);
907 error
= xfs_rmap_query_all(cur
, xrep_findroot_rmap
, &ri
);
908 xfs_btree_del_cursor(cur
, error
);
913 /* Force a quotacheck the next time we mount. */
915 xrep_force_quotacheck(
916 struct xfs_scrub
*sc
,
921 flag
= xfs_quota_chkd_flag(dqtype
);
922 if (!(flag
& sc
->mp
->m_qflags
))
925 sc
->mp
->m_qflags
&= ~flag
;
926 spin_lock(&sc
->mp
->m_sb_lock
);
927 sc
->mp
->m_sb
.sb_qflags
&= ~flag
;
928 spin_unlock(&sc
->mp
->m_sb_lock
);
933 * Attach dquots to this inode, or schedule quotacheck to fix them.
935 * This function ensures that the appropriate dquots are attached to an inode.
936 * We cannot allow the dquot code to allocate an on-disk dquot block here
937 * because we're already in transaction context with the inode locked. The
938 * on-disk dquot should already exist anyway. If the quota code signals
939 * corruption or missing quota information, schedule quotacheck, which will
940 * repair corruptions in the quota metadata.
944 struct xfs_scrub
*sc
)
948 error
= xfs_qm_dqattach_locked(sc
->ip
, false);
953 xfs_err_ratelimited(sc
->mp
,
954 "inode %llu repair encountered quota error %d, quotacheck forced.",
955 (unsigned long long)sc
->ip
->i_ino
, error
);
956 if (XFS_IS_UQUOTA_ON(sc
->mp
) && !sc
->ip
->i_udquot
)
957 xrep_force_quotacheck(sc
, XFS_DQ_USER
);
958 if (XFS_IS_GQUOTA_ON(sc
->mp
) && !sc
->ip
->i_gdquot
)
959 xrep_force_quotacheck(sc
, XFS_DQ_GROUP
);
960 if (XFS_IS_PQUOTA_ON(sc
->mp
) && !sc
->ip
->i_pdquot
)
961 xrep_force_quotacheck(sc
, XFS_DQ_PROJ
);