On Wed, Jul 18, 2018 at 08:51:51AM -0700, Darrick J. Wong wrote:
> From: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
>
> Shorten all the metadata checking xfs_scrub_ prefixes to xchk_. After
> this, the only xfs_scrub* symbols are the ones that pertain to both
> scrub and repair. Whitespace damage will be fixed in a subsequent
> patch. There are no functional changes.
>
> Signed-off-by: Darrick J. Wong <darrick.wong@xxxxxxxxxx>
> ---
I have no major preference on the name, but looks like a straight
search/replace to me:
Reviewed-by: Brian Foster <bfoster@xxxxxxxxxx>
> fs/xfs/scrub/agheader.c | 318 ++++++++++++++++++++++++-----------------------
> fs/xfs/scrub/alloc.c | 56 ++++----
> fs/xfs/scrub/attr.c | 106 ++++++++--------
> fs/xfs/scrub/bmap.c | 176 +++++++++++++-------------
> fs/xfs/scrub/btree.c | 166 ++++++++++++-------------
> fs/xfs/scrub/btree.h | 22 ++-
> fs/xfs/scrub/common.c | 172 +++++++++++++------------
> fs/xfs/scrub/common.h | 102 ++++++++-------
> fs/xfs/scrub/dabtree.c | 124 +++++++++---------
> fs/xfs/scrub/dabtree.h | 14 +-
> fs/xfs/scrub/dir.c | 170 +++++++++++++------------
> fs/xfs/scrub/ialloc.c | 138 ++++++++++----------
> fs/xfs/scrub/inode.c | 160 ++++++++++++------------
> fs/xfs/scrub/parent.c | 62 +++++----
> fs/xfs/scrub/quota.c | 64 +++++----
> fs/xfs/scrub/refcount.c | 114 ++++++++---------
> fs/xfs/scrub/repair.c | 4 -
> fs/xfs/scrub/rmap.c | 78 ++++++------
> fs/xfs/scrub/rtbitmap.c | 30 ++--
> fs/xfs/scrub/scrub.c | 142 +++++++++++----------
> fs/xfs/scrub/scrub.h | 82 ++++++------
> fs/xfs/scrub/symlink.c | 14 +-
> fs/xfs/scrub/trace.c | 2
> fs/xfs/scrub/trace.h | 70 +++++-----
> 24 files changed, 1196 insertions(+), 1190 deletions(-)
>
>
> diff --git a/fs/xfs/scrub/agheader.c b/fs/xfs/scrub/agheader.c
> index 9bb0745f1ad2..c0625ec16d63 100644
> --- a/fs/xfs/scrub/agheader.c
> +++ b/fs/xfs/scrub/agheader.c
> @@ -28,7 +28,7 @@
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_superblock_xref(
> +xchk_superblock_xref(
> struct xfs_scrub_context *sc,
> struct xfs_buf *bp)
> {
> @@ -43,15 +43,15 @@ xfs_scrub_superblock_xref(
>
> agbno = XFS_SB_BLOCK(mp);
>
> - error = xfs_scrub_ag_init(sc, agno, &sc->sa);
> - if (!xfs_scrub_xref_process_error(sc, agno, agbno, &error))
> + error = xchk_ag_init(sc, agno, &sc->sa);
> + if (!xchk_xref_process_error(sc, agno, agbno, &error))
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, 1);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
> + xchk_xref_is_used_space(sc, agbno, 1);
> + xchk_xref_is_not_inode_chunk(sc, agbno, 1);
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
> - xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
> - xfs_scrub_xref_is_not_shared(sc, agbno, 1);
> + xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
> + xchk_xref_is_not_shared(sc, agbno, 1);
>
> /* scrub teardown will take care of sc->sa for us */
> }
> @@ -65,7 +65,7 @@ xfs_scrub_superblock_xref(
> * sb 0 is ok and we can use its information to check everything else.
> */
> int
> -xfs_scrub_superblock(
> +xchk_superblock(
> struct xfs_scrub_context *sc)
> {
> struct xfs_mount *mp = sc->mp;
> @@ -98,7 +98,7 @@ xfs_scrub_superblock(
> default:
> break;
> }
> - if (!xfs_scrub_process_error(sc, agno, XFS_SB_BLOCK(mp), &error))
> + if (!xchk_process_error(sc, agno, XFS_SB_BLOCK(mp), &error))
> return error;
>
> sb = XFS_BUF_TO_SBP(bp);
> @@ -110,46 +110,46 @@ xfs_scrub_superblock(
> * checked.
> */
> if (sb->sb_blocksize != cpu_to_be32(mp->m_sb.sb_blocksize))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_dblocks != cpu_to_be64(mp->m_sb.sb_dblocks))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_rblocks != cpu_to_be64(mp->m_sb.sb_rblocks))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_rextents != cpu_to_be64(mp->m_sb.sb_rextents))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (!uuid_equal(&sb->sb_uuid, &mp->m_sb.sb_uuid))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_logstart != cpu_to_be64(mp->m_sb.sb_logstart))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_rootino != cpu_to_be64(mp->m_sb.sb_rootino))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_rbmino != cpu_to_be64(mp->m_sb.sb_rbmino))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_rsumino != cpu_to_be64(mp->m_sb.sb_rsumino))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_rextsize != cpu_to_be32(mp->m_sb.sb_rextsize))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_agblocks != cpu_to_be32(mp->m_sb.sb_agblocks))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_agcount != cpu_to_be32(mp->m_sb.sb_agcount))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_rbmblocks != cpu_to_be32(mp->m_sb.sb_rbmblocks))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_logblocks != cpu_to_be32(mp->m_sb.sb_logblocks))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Check sb_versionnum bits that are set at mkfs time. */
> vernum_mask = cpu_to_be16(~XFS_SB_VERSION_OKBITS |
> @@ -163,7 +163,7 @@ xfs_scrub_superblock(
> XFS_SB_VERSION_DIRV2BIT);
> if ((sb->sb_versionnum & vernum_mask) !=
> (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Check sb_versionnum bits that can be set after mkfs time. */
> vernum_mask = cpu_to_be16(XFS_SB_VERSION_ATTRBIT |
> @@ -171,40 +171,40 @@ xfs_scrub_superblock(
> XFS_SB_VERSION_QUOTABIT);
> if ((sb->sb_versionnum & vernum_mask) !=
> (cpu_to_be16(mp->m_sb.sb_versionnum) & vernum_mask))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_sectsize != cpu_to_be16(mp->m_sb.sb_sectsize))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_inodesize != cpu_to_be16(mp->m_sb.sb_inodesize))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_inopblock != cpu_to_be16(mp->m_sb.sb_inopblock))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (memcmp(sb->sb_fname, mp->m_sb.sb_fname, sizeof(sb->sb_fname)))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_blocklog != mp->m_sb.sb_blocklog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_sectlog != mp->m_sb.sb_sectlog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_inodelog != mp->m_sb.sb_inodelog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_inopblog != mp->m_sb.sb_inopblog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_agblklog != mp->m_sb.sb_agblklog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_rextslog != mp->m_sb.sb_rextslog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_imax_pct != mp->m_sb.sb_imax_pct)
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> /*
> * Skip the summary counters since we track them in memory anyway.
> @@ -212,10 +212,10 @@ xfs_scrub_superblock(
> */
>
> if (sb->sb_uquotino != cpu_to_be64(mp->m_sb.sb_uquotino))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_gquotino != cpu_to_be64(mp->m_sb.sb_gquotino))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> /*
> * Skip the quota flags since repair will force quotacheck.
> @@ -223,46 +223,46 @@ xfs_scrub_superblock(
> */
>
> if (sb->sb_flags != mp->m_sb.sb_flags)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_shared_vn != mp->m_sb.sb_shared_vn)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_inoalignmt != cpu_to_be32(mp->m_sb.sb_inoalignmt))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_unit != cpu_to_be32(mp->m_sb.sb_unit))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_width != cpu_to_be32(mp->m_sb.sb_width))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> if (sb->sb_dirblklog != mp->m_sb.sb_dirblklog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_logsectlog != mp->m_sb.sb_logsectlog)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_logsectsize != cpu_to_be16(mp->m_sb.sb_logsectsize))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_logsunit != cpu_to_be32(mp->m_sb.sb_logsunit))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Do we see any invalid bits in sb_features2? */
> if (!xfs_sb_version_hasmorebits(&mp->m_sb)) {
> if (sb->sb_features2 != 0)
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
> } else {
> v2_ok = XFS_SB_VERSION2_OKBITS;
> if (XFS_SB_VERSION_NUM(&mp->m_sb) >= XFS_SB_VERSION_5)
> v2_ok |= XFS_SB_VERSION2_CRCBIT;
>
> if (!!(sb->sb_features2 & cpu_to_be32(~v2_ok)))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_features2 != sb->sb_bad_features2)
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
> }
>
> /* Check sb_features2 flags that are set at mkfs time. */
> @@ -272,26 +272,26 @@ xfs_scrub_superblock(
> XFS_SB_VERSION2_FTYPE);
> if ((sb->sb_features2 & features_mask) !=
> (cpu_to_be32(mp->m_sb.sb_features2) & features_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Check sb_features2 flags that can be set after mkfs time. */
> features_mask = cpu_to_be32(XFS_SB_VERSION2_ATTR2BIT);
> if ((sb->sb_features2 & features_mask) !=
> (cpu_to_be32(mp->m_sb.sb_features2) & features_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (!xfs_sb_version_hascrc(&mp->m_sb)) {
> /* all v5 fields must be zero */
> if (memchr_inv(&sb->sb_features_compat, 0,
> sizeof(struct xfs_dsb) -
> offsetof(struct xfs_dsb, sb_features_compat)))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
> } else {
> /* Check compat flags; all are set at mkfs time. */
> features_mask = cpu_to_be32(XFS_SB_FEAT_COMPAT_UNKNOWN);
> if ((sb->sb_features_compat & features_mask) !=
> (cpu_to_be32(mp->m_sb.sb_features_compat) & features_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Check ro compat flags; all are set at mkfs time. */
> features_mask = cpu_to_be32(XFS_SB_FEAT_RO_COMPAT_UNKNOWN |
> @@ -301,7 +301,7 @@ xfs_scrub_superblock(
> if ((sb->sb_features_ro_compat & features_mask) !=
> (cpu_to_be32(mp->m_sb.sb_features_ro_compat) &
> features_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Check incompat flags; all are set at mkfs time. */
> features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_UNKNOWN |
> @@ -311,22 +311,22 @@ xfs_scrub_superblock(
> if ((sb->sb_features_incompat & features_mask) !=
> (cpu_to_be32(mp->m_sb.sb_features_incompat) &
> features_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Check log incompat flags; all are set at mkfs time. */
> features_mask = cpu_to_be32(XFS_SB_FEAT_INCOMPAT_LOG_UNKNOWN);
> if ((sb->sb_features_log_incompat & features_mask) !=
> (cpu_to_be32(mp->m_sb.sb_features_log_incompat) &
> features_mask))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> /* Don't care about sb_crc */
>
> if (sb->sb_spino_align != cpu_to_be32(mp->m_sb.sb_spino_align))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> if (sb->sb_pquotino != cpu_to_be64(mp->m_sb.sb_pquotino))
> - xfs_scrub_block_set_preen(sc, bp);
> + xchk_block_set_preen(sc, bp);
>
> /* Don't care about sb_lsn */
> }
> @@ -334,15 +334,15 @@ xfs_scrub_superblock(
> if (xfs_sb_version_hasmetauuid(&mp->m_sb)) {
> /* The metadata UUID must be the same for all supers */
> if (!uuid_equal(&sb->sb_meta_uuid, &mp->m_sb.sb_meta_uuid))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
> }
>
> /* Everything else must be zero. */
> if (memchr_inv(sb + 1, 0,
> BBTOB(bp->b_length) - sizeof(struct xfs_dsb)))
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
>
> - xfs_scrub_superblock_xref(sc, bp);
> + xchk_superblock_xref(sc, bp);
>
> return error;
> }
> @@ -351,7 +351,7 @@ xfs_scrub_superblock(
>
> /* Tally freespace record lengths. */
> STATIC int
> -xfs_scrub_agf_record_bno_lengths(
> +xchk_agf_record_bno_lengths(
> struct xfs_btree_cur *cur,
> struct xfs_alloc_rec_incore *rec,
> void *priv)
> @@ -364,7 +364,7 @@ xfs_scrub_agf_record_bno_lengths(
>
> /* Check agf_freeblks */
> static inline void
> -xfs_scrub_agf_xref_freeblks(
> +xchk_agf_xref_freeblks(
> struct xfs_scrub_context *sc)
> {
> struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
> @@ -375,16 +375,16 @@ xfs_scrub_agf_xref_freeblks(
> return;
>
> error = xfs_alloc_query_all(sc->sa.bno_cur,
> - xfs_scrub_agf_record_bno_lengths, &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
> + xchk_agf_record_bno_lengths, &blocks);
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
> return;
> if (blocks != be32_to_cpu(agf->agf_freeblks))
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> }
>
> /* Cross reference the AGF with the cntbt (freespace by length btree) */
> static inline void
> -xfs_scrub_agf_xref_cntbt(
> +xchk_agf_xref_cntbt(
> struct xfs_scrub_context *sc)
> {
> struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
> @@ -398,25 +398,25 @@ xfs_scrub_agf_xref_cntbt(
>
> /* Any freespace at all? */
> error = xfs_alloc_lookup_le(sc->sa.cnt_cur, 0, -1U, &have);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.cnt_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur))
> return;
> if (!have) {
> if (agf->agf_freeblks != be32_to_cpu(0))
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> return;
> }
>
> /* Check agf_longest */
> error = xfs_alloc_get_rec(sc->sa.cnt_cur, &agbno, &blocks, &have);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.cnt_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur))
> return;
> if (!have || blocks != be32_to_cpu(agf->agf_longest))
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> }
>
> /* Check the btree block counts in the AGF against the btrees. */
> STATIC void
> -xfs_scrub_agf_xref_btreeblks(
> +xchk_agf_xref_btreeblks(
> struct xfs_scrub_context *sc)
> {
> struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
> @@ -428,11 +428,11 @@ xfs_scrub_agf_xref_btreeblks(
> /* Check agf_rmap_blocks; set up for agf_btreeblks check */
> if (sc->sa.rmap_cur) {
> error = xfs_btree_count_blocks(sc->sa.rmap_cur, &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> btreeblks = blocks - 1;
> if (blocks != be32_to_cpu(agf->agf_rmap_blocks))
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> } else {
> btreeblks = 0;
> }
> @@ -447,22 +447,22 @@ xfs_scrub_agf_xref_btreeblks(
>
> /* Check agf_btreeblks */
> error = xfs_btree_count_blocks(sc->sa.bno_cur, &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
> return;
> btreeblks += blocks - 1;
>
> error = xfs_btree_count_blocks(sc->sa.cnt_cur, &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.cnt_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.cnt_cur))
> return;
> btreeblks += blocks - 1;
>
> if (btreeblks != be32_to_cpu(agf->agf_btreeblks))
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> }
>
> /* Check agf_refcount_blocks against tree size */
> static inline void
> -xfs_scrub_agf_xref_refcblks(
> +xchk_agf_xref_refcblks(
> struct xfs_scrub_context *sc)
> {
> struct xfs_agf *agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
> @@ -473,15 +473,15 @@ xfs_scrub_agf_xref_refcblks(
> return;
>
> error = xfs_btree_count_blocks(sc->sa.refc_cur, &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.refc_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur))
> return;
> if (blocks != be32_to_cpu(agf->agf_refcount_blocks))
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agf_bp);
> }
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_agf_xref(
> +xchk_agf_xref(
> struct xfs_scrub_context *sc)
> {
> struct xfs_owner_info oinfo;
> @@ -494,26 +494,26 @@ xfs_scrub_agf_xref(
>
> agbno = XFS_AGF_BLOCK(mp);
>
> - error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
> + error = xchk_ag_btcur_init(sc, &sc->sa);
> if (error)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, 1);
> - xfs_scrub_agf_xref_freeblks(sc);
> - xfs_scrub_agf_xref_cntbt(sc);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
> + xchk_xref_is_used_space(sc, agbno, 1);
> + xchk_agf_xref_freeblks(sc);
> + xchk_agf_xref_cntbt(sc);
> + xchk_xref_is_not_inode_chunk(sc, agbno, 1);
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
> - xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
> - xfs_scrub_agf_xref_btreeblks(sc);
> - xfs_scrub_xref_is_not_shared(sc, agbno, 1);
> - xfs_scrub_agf_xref_refcblks(sc);
> + xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
> + xchk_agf_xref_btreeblks(sc);
> + xchk_xref_is_not_shared(sc, agbno, 1);
> + xchk_agf_xref_refcblks(sc);
>
> /* scrub teardown will take care of sc->sa for us */
> }
>
> /* Scrub the AGF. */
> int
> -xfs_scrub_agf(
> +xchk_agf(
> struct xfs_scrub_context *sc)
> {
> struct xfs_mount *mp = sc->mp;
> @@ -529,54 +529,54 @@ xfs_scrub_agf(
> int error = 0;
>
> agno = sc->sa.agno = sc->sm->sm_agno;
> - error = xfs_scrub_ag_read_headers(sc, agno, &sc->sa.agi_bp,
> + error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp,
> &sc->sa.agf_bp, &sc->sa.agfl_bp);
> - if (!xfs_scrub_process_error(sc, agno, XFS_AGF_BLOCK(sc->mp), &error))
> + if (!xchk_process_error(sc, agno, XFS_AGF_BLOCK(sc->mp), &error))
> goto out;
> - xfs_scrub_buffer_recheck(sc, sc->sa.agf_bp);
> + xchk_buffer_recheck(sc, sc->sa.agf_bp);
>
> agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
>
> /* Check the AG length */
> eoag = be32_to_cpu(agf->agf_length);
> if (eoag != xfs_ag_block_count(mp, agno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> /* Check the AGF btree roots and levels */
> agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_BNO]);
> if (!xfs_verify_agbno(mp, agno, agbno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_CNT]);
> if (!xfs_verify_agbno(mp, agno, agbno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNO]);
> if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]);
> if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
> agbno = be32_to_cpu(agf->agf_roots[XFS_BTNUM_RMAP]);
> if (!xfs_verify_agbno(mp, agno, agbno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> level = be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]);
> if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
> }
>
> if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> agbno = be32_to_cpu(agf->agf_refcount_root);
> if (!xfs_verify_agbno(mp, agno, agbno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> level = be32_to_cpu(agf->agf_refcount_level);
> if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
> }
>
> /* Check the AGFL counters */
> @@ -588,16 +588,16 @@ xfs_scrub_agf(
> else
> fl_count = xfs_agfl_size(mp) - agfl_first + agfl_last + 1;
> if (agfl_count != 0 && fl_count != agfl_count)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
>
> - xfs_scrub_agf_xref(sc);
> + xchk_agf_xref(sc);
> out:
> return error;
> }
>
> /* AGFL */
>
> -struct xfs_scrub_agfl_info {
> +struct xchk_agfl_info {
> struct xfs_owner_info oinfo;
> unsigned int sz_entries;
> unsigned int nr_entries;
> @@ -607,7 +607,7 @@ struct xfs_scrub_agfl_info {
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_agfl_block_xref(
> +xchk_agfl_block_xref(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> struct xfs_owner_info *oinfo)
> @@ -615,20 +615,20 @@ xfs_scrub_agfl_block_xref(
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, 1);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
> - xfs_scrub_xref_is_owned_by(sc, agbno, 1, oinfo);
> - xfs_scrub_xref_is_not_shared(sc, agbno, 1);
> + xchk_xref_is_used_space(sc, agbno, 1);
> + xchk_xref_is_not_inode_chunk(sc, agbno, 1);
> + xchk_xref_is_owned_by(sc, agbno, 1, oinfo);
> + xchk_xref_is_not_shared(sc, agbno, 1);
> }
>
> /* Scrub an AGFL block. */
> STATIC int
> -xfs_scrub_agfl_block(
> +xchk_agfl_block(
> struct xfs_mount *mp,
> xfs_agblock_t agbno,
> void *priv)
> {
> - struct xfs_scrub_agfl_info *sai = priv;
> + struct xchk_agfl_info *sai = priv;
> struct xfs_scrub_context *sc = sai->sc;
> xfs_agnumber_t agno = sc->sa.agno;
>
> @@ -636,9 +636,9 @@ xfs_scrub_agfl_block(
> sai->nr_entries < sai->sz_entries)
> sai->entries[sai->nr_entries++] = agbno;
> else
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agfl_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agfl_bp);
>
> - xfs_scrub_agfl_block_xref(sc, agbno, priv);
> + xchk_agfl_block_xref(sc, agbno, priv);
>
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return XFS_BTREE_QUERY_RANGE_ABORT;
> @@ -647,7 +647,7 @@ xfs_scrub_agfl_block(
> }
>
> static int
> -xfs_scrub_agblock_cmp(
> +xchk_agblock_cmp(
> const void *pa,
> const void *pb)
> {
> @@ -659,7 +659,7 @@ xfs_scrub_agblock_cmp(
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_agfl_xref(
> +xchk_agfl_xref(
> struct xfs_scrub_context *sc)
> {
> struct xfs_owner_info oinfo;
> @@ -672,15 +672,15 @@ xfs_scrub_agfl_xref(
>
> agbno = XFS_AGFL_BLOCK(mp);
>
> - error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
> + error = xchk_ag_btcur_init(sc, &sc->sa);
> if (error)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, 1);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
> + xchk_xref_is_used_space(sc, agbno, 1);
> + xchk_xref_is_not_inode_chunk(sc, agbno, 1);
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
> - xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
> - xfs_scrub_xref_is_not_shared(sc, agbno, 1);
> + xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
> + xchk_xref_is_not_shared(sc, agbno, 1);
>
> /*
> * Scrub teardown will take care of sc->sa for us. Leave sc->sa
> @@ -690,10 +690,10 @@ xfs_scrub_agfl_xref(
>
> /* Scrub the AGFL. */
> int
> -xfs_scrub_agfl(
> +xchk_agfl(
> struct xfs_scrub_context *sc)
> {
> - struct xfs_scrub_agfl_info sai;
> + struct xchk_agfl_info sai;
> struct xfs_agf *agf;
> xfs_agnumber_t agno;
> unsigned int agflcount;
> @@ -701,15 +701,15 @@ xfs_scrub_agfl(
> int error;
>
> agno = sc->sa.agno = sc->sm->sm_agno;
> - error = xfs_scrub_ag_read_headers(sc, agno, &sc->sa.agi_bp,
> + error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp,
> &sc->sa.agf_bp, &sc->sa.agfl_bp);
> - if (!xfs_scrub_process_error(sc, agno, XFS_AGFL_BLOCK(sc->mp), &error))
> + if (!xchk_process_error(sc, agno, XFS_AGFL_BLOCK(sc->mp), &error))
> goto out;
> if (!sc->sa.agf_bp)
> return -EFSCORRUPTED;
> - xfs_scrub_buffer_recheck(sc, sc->sa.agfl_bp);
> + xchk_buffer_recheck(sc, sc->sa.agfl_bp);
>
> - xfs_scrub_agfl_xref(sc);
> + xchk_agfl_xref(sc);
>
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
> @@ -718,7 +718,7 @@ xfs_scrub_agfl(
> agf = XFS_BUF_TO_AGF(sc->sa.agf_bp);
> agflcount = be32_to_cpu(agf->agf_flcount);
> if (agflcount > xfs_agfl_size(sc->mp)) {
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
> goto out;
> }
> memset(&sai, 0, sizeof(sai));
> @@ -734,7 +734,7 @@ xfs_scrub_agfl(
> /* Check the blocks in the AGFL. */
> xfs_rmap_ag_owner(&sai.oinfo, XFS_RMAP_OWN_AG);
> error = xfs_agfl_walk(sc->mp, XFS_BUF_TO_AGF(sc->sa.agf_bp),
> - sc->sa.agfl_bp, xfs_scrub_agfl_block, &sai);
> + sc->sa.agfl_bp, xchk_agfl_block, &sai);
> if (error == XFS_BTREE_QUERY_RANGE_ABORT) {
> error = 0;
> goto out_free;
> @@ -743,16 +743,16 @@ xfs_scrub_agfl(
> goto out_free;
>
> if (agflcount != sai.nr_entries) {
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
> goto out_free;
> }
>
> /* Sort entries, check for duplicates. */
> sort(sai.entries, sai.nr_entries, sizeof(sai.entries[0]),
> - xfs_scrub_agblock_cmp, NULL);
> + xchk_agblock_cmp, NULL);
> for (i = 1; i < sai.nr_entries; i++) {
> if (sai.entries[i] == sai.entries[i - 1]) {
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agf_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agf_bp);
> break;
> }
> }
> @@ -767,7 +767,7 @@ xfs_scrub_agfl(
>
> /* Check agi_count/agi_freecount */
> static inline void
> -xfs_scrub_agi_xref_icounts(
> +xchk_agi_xref_icounts(
> struct xfs_scrub_context *sc)
> {
> struct xfs_agi *agi = XFS_BUF_TO_AGI(sc->sa.agi_bp);
> @@ -779,16 +779,16 @@ xfs_scrub_agi_xref_icounts(
> return;
>
> error = xfs_ialloc_count_inodes(sc->sa.ino_cur, &icount, &freecount);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.ino_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.ino_cur))
> return;
> if (be32_to_cpu(agi->agi_count) != icount ||
> be32_to_cpu(agi->agi_freecount) != freecount)
> - xfs_scrub_block_xref_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_xref_set_corrupt(sc, sc->sa.agi_bp);
> }
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_agi_xref(
> +xchk_agi_xref(
> struct xfs_scrub_context *sc)
> {
> struct xfs_owner_info oinfo;
> @@ -801,23 +801,23 @@ xfs_scrub_agi_xref(
>
> agbno = XFS_AGI_BLOCK(mp);
>
> - error = xfs_scrub_ag_btcur_init(sc, &sc->sa);
> + error = xchk_ag_btcur_init(sc, &sc->sa);
> if (error)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, 1);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, 1);
> - xfs_scrub_agi_xref_icounts(sc);
> + xchk_xref_is_used_space(sc, agbno, 1);
> + xchk_xref_is_not_inode_chunk(sc, agbno, 1);
> + xchk_agi_xref_icounts(sc);
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_FS);
> - xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
> - xfs_scrub_xref_is_not_shared(sc, agbno, 1);
> + xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
> + xchk_xref_is_not_shared(sc, agbno, 1);
>
> /* scrub teardown will take care of sc->sa for us */
> }
>
> /* Scrub the AGI. */
> int
> -xfs_scrub_agi(
> +xchk_agi(
> struct xfs_scrub_context *sc)
> {
> struct xfs_mount *mp = sc->mp;
> @@ -834,36 +834,36 @@ xfs_scrub_agi(
> int error = 0;
>
> agno = sc->sa.agno = sc->sm->sm_agno;
> - error = xfs_scrub_ag_read_headers(sc, agno, &sc->sa.agi_bp,
> + error = xchk_ag_read_headers(sc, agno, &sc->sa.agi_bp,
> &sc->sa.agf_bp, &sc->sa.agfl_bp);
> - if (!xfs_scrub_process_error(sc, agno, XFS_AGI_BLOCK(sc->mp), &error))
> + if (!xchk_process_error(sc, agno, XFS_AGI_BLOCK(sc->mp), &error))
> goto out;
> - xfs_scrub_buffer_recheck(sc, sc->sa.agi_bp);
> + xchk_buffer_recheck(sc, sc->sa.agi_bp);
>
> agi = XFS_BUF_TO_AGI(sc->sa.agi_bp);
>
> /* Check the AG length */
> eoag = be32_to_cpu(agi->agi_length);
> if (eoag != xfs_ag_block_count(mp, agno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> /* Check btree roots and levels */
> agbno = be32_to_cpu(agi->agi_root);
> if (!xfs_verify_agbno(mp, agno, agbno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> level = be32_to_cpu(agi->agi_level);
> if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> if (xfs_sb_version_hasfinobt(&mp->m_sb)) {
> agbno = be32_to_cpu(agi->agi_free_root);
> if (!xfs_verify_agbno(mp, agno, agbno))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> level = be32_to_cpu(agi->agi_free_level);
> if (level <= 0 || level > XFS_BTREE_MAXLEVELS)
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
> }
>
> /* Check inode counters */
> @@ -871,16 +871,16 @@ xfs_scrub_agi(
> icount = be32_to_cpu(agi->agi_count);
> if (icount > last_agino - first_agino + 1 ||
> icount < be32_to_cpu(agi->agi_freecount))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> /* Check inode pointers */
> agino = be32_to_cpu(agi->agi_newino);
> if (agino != NULLAGINO && !xfs_verify_agino(mp, agno, agino))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> agino = be32_to_cpu(agi->agi_dirino);
> if (agino != NULLAGINO && !xfs_verify_agino(mp, agno, agino))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> /* Check unlinked inode buckets */
> for (i = 0; i < XFS_AGI_UNLINKED_BUCKETS; i++) {
> @@ -888,13 +888,13 @@ xfs_scrub_agi(
> if (agino == NULLAGINO)
> continue;
> if (!xfs_verify_agino(mp, agno, agino))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
> }
>
> if (agi->agi_pad32 != cpu_to_be32(0))
> - xfs_scrub_block_set_corrupt(sc, sc->sa.agi_bp);
> + xchk_block_set_corrupt(sc, sc->sa.agi_bp);
>
> - xfs_scrub_agi_xref(sc);
> + xchk_agi_xref(sc);
> out:
> return error;
> }
> diff --git a/fs/xfs/scrub/alloc.c b/fs/xfs/scrub/alloc.c
> index 50e4f7fa06f0..1f6e3a6a1fdd 100644
> --- a/fs/xfs/scrub/alloc.c
> +++ b/fs/xfs/scrub/alloc.c
> @@ -28,11 +28,11 @@
> * Set us up to scrub free space btrees.
> */
> int
> -xfs_scrub_setup_ag_allocbt(
> +xchk_setup_ag_allocbt(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> - return xfs_scrub_setup_ag_btree(sc, ip, false);
> + return xchk_setup_ag_btree(sc, ip, false);
> }
>
> /* Free space btree scrubber. */
> @@ -41,7 +41,7 @@ xfs_scrub_setup_ag_allocbt(
> * bnobt/cntbt record, respectively.
> */
> STATIC void
> -xfs_scrub_allocbt_xref_other(
> +xchk_allocbt_xref_other(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> @@ -56,32 +56,32 @@ xfs_scrub_allocbt_xref_other(
> pcur = &sc->sa.cnt_cur;
> else
> pcur = &sc->sa.bno_cur;
> - if (!*pcur || xfs_scrub_skip_xref(sc->sm))
> + if (!*pcur || xchk_skip_xref(sc->sm))
> return;
>
> error = xfs_alloc_lookup_le(*pcur, agbno, len, &has_otherrec);
> - if (!xfs_scrub_should_check_xref(sc, &error, pcur))
> + if (!xchk_should_check_xref(sc, &error, pcur))
> return;
> if (!has_otherrec) {
> - xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
> + xchk_btree_xref_set_corrupt(sc, *pcur, 0);
> return;
> }
>
> error = xfs_alloc_get_rec(*pcur, &fbno, &flen, &has_otherrec);
> - if (!xfs_scrub_should_check_xref(sc, &error, pcur))
> + if (!xchk_should_check_xref(sc, &error, pcur))
> return;
> if (!has_otherrec) {
> - xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
> + xchk_btree_xref_set_corrupt(sc, *pcur, 0);
> return;
> }
>
> if (fbno != agbno || flen != len)
> - xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
> + xchk_btree_xref_set_corrupt(sc, *pcur, 0);
> }
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_allocbt_xref(
> +xchk_allocbt_xref(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> @@ -89,16 +89,16 @@ xfs_scrub_allocbt_xref(
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return;
>
> - xfs_scrub_allocbt_xref_other(sc, agbno, len);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, len);
> - xfs_scrub_xref_has_no_owner(sc, agbno, len);
> - xfs_scrub_xref_is_not_shared(sc, agbno, len);
> + xchk_allocbt_xref_other(sc, agbno, len);
> + xchk_xref_is_not_inode_chunk(sc, agbno, len);
> + xchk_xref_has_no_owner(sc, agbno, len);
> + xchk_xref_is_not_shared(sc, agbno, len);
> }
>
> /* Scrub a bnobt/cntbt record. */
> STATIC int
> -xfs_scrub_allocbt_rec(
> - struct xfs_scrub_btree *bs,
> +xchk_allocbt_rec(
> + struct xchk_btree *bs,
> union xfs_btree_rec *rec)
> {
> struct xfs_mount *mp = bs->cur->bc_mp;
> @@ -113,16 +113,16 @@ xfs_scrub_allocbt_rec(
> if (bno + len <= bno ||
> !xfs_verify_agbno(mp, agno, bno) ||
> !xfs_verify_agbno(mp, agno, bno + len - 1))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> - xfs_scrub_allocbt_xref(bs->sc, bno, len);
> + xchk_allocbt_xref(bs->sc, bno, len);
>
> return error;
> }
>
> /* Scrub the freespace btrees for some AG. */
> STATIC int
> -xfs_scrub_allocbt(
> +xchk_allocbt(
> struct xfs_scrub_context *sc,
> xfs_btnum_t which)
> {
> @@ -131,26 +131,26 @@ xfs_scrub_allocbt(
>
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
> cur = which == XFS_BTNUM_BNO ? sc->sa.bno_cur : sc->sa.cnt_cur;
> - return xfs_scrub_btree(sc, cur, xfs_scrub_allocbt_rec, &oinfo, NULL);
> + return xchk_btree(sc, cur, xchk_allocbt_rec, &oinfo, NULL);
> }
>
> int
> -xfs_scrub_bnobt(
> +xchk_bnobt(
> struct xfs_scrub_context *sc)
> {
> - return xfs_scrub_allocbt(sc, XFS_BTNUM_BNO);
> + return xchk_allocbt(sc, XFS_BTNUM_BNO);
> }
>
> int
> -xfs_scrub_cntbt(
> +xchk_cntbt(
> struct xfs_scrub_context *sc)
> {
> - return xfs_scrub_allocbt(sc, XFS_BTNUM_CNT);
> + return xchk_allocbt(sc, XFS_BTNUM_CNT);
> }
>
> /* xref check that the extent is not free */
> void
> -xfs_scrub_xref_is_used_space(
> +xchk_xref_is_used_space(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> @@ -158,12 +158,12 @@ xfs_scrub_xref_is_used_space(
> bool is_freesp;
> int error;
>
> - if (!sc->sa.bno_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.bno_cur || xchk_skip_xref(sc->sm))
> return;
>
> error = xfs_alloc_has_record(sc->sa.bno_cur, agbno, len, &is_freesp);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.bno_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.bno_cur))
> return;
> if (is_freesp)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.bno_cur, 0);
> }
> diff --git a/fs/xfs/scrub/attr.c b/fs/xfs/scrub/attr.c
> index de51cf8a8516..0068bebddf3e 100644
> --- a/fs/xfs/scrub/attr.c
> +++ b/fs/xfs/scrub/attr.c
> @@ -32,7 +32,7 @@
>
> /* Set us up to scrub an inode's extended attributes. */
> int
> -xfs_scrub_setup_xattr(
> +xchk_setup_xattr(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> @@ -50,12 +50,12 @@ xfs_scrub_setup_xattr(
> if (!sc->buf)
> return -ENOMEM;
>
> - return xfs_scrub_setup_inode_contents(sc, ip, 0);
> + return xchk_setup_inode_contents(sc, ip, 0);
> }
>
> /* Extended Attributes */
>
> -struct xfs_scrub_xattr {
> +struct xchk_xattr {
> struct xfs_attr_list_context context;
> struct xfs_scrub_context *sc;
> };
> @@ -69,22 +69,22 @@ struct xfs_scrub_xattr {
> * or if we get more or less data than we expected.
> */
> static void
> -xfs_scrub_xattr_listent(
> +xchk_xattr_listent(
> struct xfs_attr_list_context *context,
> int flags,
> unsigned char *name,
> int namelen,
> int valuelen)
> {
> - struct xfs_scrub_xattr *sx;
> + struct xchk_xattr *sx;
> struct xfs_da_args args = { NULL };
> int error = 0;
>
> - sx = container_of(context, struct xfs_scrub_xattr, context);
> + sx = container_of(context, struct xchk_xattr, context);
>
> if (flags & XFS_ATTR_INCOMPLETE) {
> /* Incomplete attr key, just mark the inode for preening. */
> - xfs_scrub_ino_set_preen(sx->sc, context->dp->i_ino);
> + xchk_ino_set_preen(sx->sc, context->dp->i_ino);
> return;
> }
>
> @@ -106,11 +106,11 @@ xfs_scrub_xattr_listent(
> error = xfs_attr_get_ilocked(context->dp, &args);
> if (error == -EEXIST)
> error = 0;
> - if (!xfs_scrub_fblock_process_error(sx->sc, XFS_ATTR_FORK, args.blkno,
> + if (!xchk_fblock_process_error(sx->sc, XFS_ATTR_FORK, args.blkno,
> &error))
> goto fail_xref;
> if (args.valuelen != valuelen)
> - xfs_scrub_fblock_set_corrupt(sx->sc, XFS_ATTR_FORK,
> + xchk_fblock_set_corrupt(sx->sc, XFS_ATTR_FORK,
> args.blkno);
> fail_xref:
> if (sx->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> @@ -126,7 +126,7 @@ xfs_scrub_xattr_listent(
> * the smallest address
> */
> STATIC bool
> -xfs_scrub_xattr_set_map(
> +xchk_xattr_set_map(
> struct xfs_scrub_context *sc,
> unsigned long *map,
> unsigned int start,
> @@ -154,7 +154,7 @@ xfs_scrub_xattr_set_map(
> * attr freemap has problems or points to used space.
> */
> STATIC bool
> -xfs_scrub_xattr_check_freemap(
> +xchk_xattr_check_freemap(
> struct xfs_scrub_context *sc,
> unsigned long *map,
> struct xfs_attr3_icleaf_hdr *leafhdr)
> @@ -168,7 +168,7 @@ xfs_scrub_xattr_check_freemap(
> freemap = (unsigned long *)sc->buf + BITS_TO_LONGS(mapsize);
> bitmap_zero(freemap, mapsize);
> for (i = 0; i < XFS_ATTR_LEAF_MAPSIZE; i++) {
> - if (!xfs_scrub_xattr_set_map(sc, freemap,
> + if (!xchk_xattr_set_map(sc, freemap,
> leafhdr->freemap[i].base,
> leafhdr->freemap[i].size))
> return false;
> @@ -184,8 +184,8 @@ xfs_scrub_xattr_check_freemap(
> * Returns the number of bytes used for the name/value data.
> */
> STATIC void
> -xfs_scrub_xattr_entry(
> - struct xfs_scrub_da_btree *ds,
> +xchk_xattr_entry(
> + struct xchk_da_btree *ds,
> int level,
> char *buf_end,
> struct xfs_attr_leafblock *leaf,
> @@ -204,17 +204,17 @@ xfs_scrub_xattr_entry(
> unsigned int namesize;
>
> if (ent->pad2 != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> /* Hash values in order? */
> if (be32_to_cpu(ent->hashval) < *last_hashval)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> *last_hashval = be32_to_cpu(ent->hashval);
>
> nameidx = be16_to_cpu(ent->nameidx);
> if (nameidx < leafhdr->firstused ||
> nameidx >= mp->m_attr_geo->blksize) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> return;
> }
>
> @@ -225,27 +225,27 @@ xfs_scrub_xattr_entry(
> be16_to_cpu(lentry->valuelen));
> name_end = (char *)lentry + namesize;
> if (lentry->namelen == 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> } else {
> rentry = xfs_attr3_leaf_name_remote(leaf, idx);
> namesize = xfs_attr_leaf_entsize_remote(rentry->namelen);
> name_end = (char *)rentry + namesize;
> if (rentry->namelen == 0 || rentry->valueblk == 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> }
> if (name_end > buf_end)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> - if (!xfs_scrub_xattr_set_map(ds->sc, usedmap, nameidx, namesize))
> - xfs_scrub_da_set_corrupt(ds, level);
> + if (!xchk_xattr_set_map(ds->sc, usedmap, nameidx, namesize))
> + xchk_da_set_corrupt(ds, level);
> if (!(ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> *usedbytes += namesize;
> }
>
> /* Scrub an attribute leaf. */
> STATIC int
> -xfs_scrub_xattr_block(
> - struct xfs_scrub_da_btree *ds,
> +xchk_xattr_block(
> + struct xchk_da_btree *ds,
> int level)
> {
> struct xfs_attr3_icleaf_hdr leafhdr;
> @@ -275,10 +275,10 @@ xfs_scrub_xattr_block(
>
> if (leaf->hdr.pad1 != 0 || leaf->hdr.pad2 != 0 ||
> leaf->hdr.info.hdr.pad != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> } else {
> if (leaf->hdr.pad1 != 0 || leaf->hdr.info.pad != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> }
>
> /* Check the leaf header */
> @@ -286,44 +286,44 @@ xfs_scrub_xattr_block(
> hdrsize = xfs_attr3_leaf_hdr_size(leaf);
>
> if (leafhdr.usedbytes > mp->m_attr_geo->blksize)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> if (leafhdr.firstused > mp->m_attr_geo->blksize)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> if (leafhdr.firstused < hdrsize)
> - xfs_scrub_da_set_corrupt(ds, level);
> - if (!xfs_scrub_xattr_set_map(ds->sc, usedmap, 0, hdrsize))
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> + if (!xchk_xattr_set_map(ds->sc, usedmap, 0, hdrsize))
> + xchk_da_set_corrupt(ds, level);
>
> if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
>
> entries = xfs_attr3_leaf_entryp(leaf);
> if ((char *)&entries[leafhdr.count] > (char *)leaf + leafhdr.firstused)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> buf_end = (char *)bp->b_addr + mp->m_attr_geo->blksize;
> for (i = 0, ent = entries; i < leafhdr.count; ent++, i++) {
> /* Mark the leaf entry itself. */
> off = (char *)ent - (char *)leaf;
> - if (!xfs_scrub_xattr_set_map(ds->sc, usedmap, off,
> + if (!xchk_xattr_set_map(ds->sc, usedmap, off,
> sizeof(xfs_attr_leaf_entry_t))) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out;
> }
>
> /* Check the entry and nameval. */
> - xfs_scrub_xattr_entry(ds, level, buf_end, leaf, &leafhdr,
> + xchk_xattr_entry(ds, level, buf_end, leaf, &leafhdr,
> usedmap, ent, i, &usedbytes, &last_hashval);
>
> if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
> }
>
> - if (!xfs_scrub_xattr_check_freemap(ds->sc, usedmap, &leafhdr))
> - xfs_scrub_da_set_corrupt(ds, level);
> + if (!xchk_xattr_check_freemap(ds->sc, usedmap, &leafhdr))
> + xchk_da_set_corrupt(ds, level);
>
> if (leafhdr.usedbytes != usedbytes)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> out:
> return 0;
> @@ -331,8 +331,8 @@ xfs_scrub_xattr_block(
>
> /* Scrub a attribute btree record. */
> STATIC int
> -xfs_scrub_xattr_rec(
> - struct xfs_scrub_da_btree *ds,
> +xchk_xattr_rec(
> + struct xchk_da_btree *ds,
> int level,
> void *rec)
> {
> @@ -352,14 +352,14 @@ xfs_scrub_xattr_rec(
> blk = &ds->state->path.blk[level];
>
> /* Check the whole block, if necessary. */
> - error = xfs_scrub_xattr_block(ds, level);
> + error = xchk_xattr_block(ds, level);
> if (error)
> goto out;
> if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
>
> /* Check the hash of the entry. */
> - error = xfs_scrub_da_btree_hash(ds, level, &ent->hashval);
> + error = xchk_da_btree_hash(ds, level, &ent->hashval);
> if (error)
> goto out;
>
> @@ -368,7 +368,7 @@ xfs_scrub_xattr_rec(
> hdrsize = xfs_attr3_leaf_hdr_size(bp->b_addr);
> nameidx = be16_to_cpu(ent->nameidx);
> if (nameidx < hdrsize || nameidx >= mp->m_attr_geo->blksize) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out;
> }
>
> @@ -377,12 +377,12 @@ xfs_scrub_xattr_rec(
> badflags = ~(XFS_ATTR_LOCAL | XFS_ATTR_ROOT | XFS_ATTR_SECURE |
> XFS_ATTR_INCOMPLETE);
> if ((ent->flags & badflags) != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> if (ent->flags & XFS_ATTR_LOCAL) {
> lentry = (struct xfs_attr_leaf_name_local *)
> (((char *)bp->b_addr) + nameidx);
> if (lentry->namelen <= 0) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out;
> }
> calc_hash = xfs_da_hashname(lentry->nameval, lentry->namelen);
> @@ -390,13 +390,13 @@ xfs_scrub_xattr_rec(
> rentry = (struct xfs_attr_leaf_name_remote *)
> (((char *)bp->b_addr) + nameidx);
> if (rentry->namelen <= 0) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out;
> }
> calc_hash = xfs_da_hashname(rentry->name, rentry->namelen);
> }
> if (calc_hash != hash)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> out:
> return error;
> @@ -404,10 +404,10 @@ xfs_scrub_xattr_rec(
>
> /* Scrub the extended attribute metadata. */
> int
> -xfs_scrub_xattr(
> +xchk_xattr(
> struct xfs_scrub_context *sc)
> {
> - struct xfs_scrub_xattr sx;
> + struct xchk_xattr sx;
> struct attrlist_cursor_kern cursor = { 0 };
> xfs_dablk_t last_checked = -1U;
> int error = 0;
> @@ -417,7 +417,7 @@ xfs_scrub_xattr(
>
> memset(&sx, 0, sizeof(sx));
> /* Check attribute tree structure */
> - error = xfs_scrub_da_btree(sc, XFS_ATTR_FORK, xfs_scrub_xattr_rec,
> + error = xchk_da_btree(sc, XFS_ATTR_FORK, xchk_xattr_rec,
> &last_checked);
> if (error)
> goto out;
> @@ -429,7 +429,7 @@ xfs_scrub_xattr(
> sx.context.dp = sc->ip;
> sx.context.cursor = &cursor;
> sx.context.resynch = 1;
> - sx.context.put_listent = xfs_scrub_xattr_listent;
> + sx.context.put_listent = xchk_xattr_listent;
> sx.context.tp = sc->tp;
> sx.context.flags = ATTR_INCOMPLETE;
> sx.sc = sc;
> @@ -438,7 +438,7 @@ xfs_scrub_xattr(
> * Look up every xattr in this file by name.
> *
> * Use the backend implementation of xfs_attr_list to call
> - * xfs_scrub_xattr_listent on every attribute key in this inode.
> + * xchk_xattr_listent on every attribute key in this inode.
> * In other words, we use the same iterator/callback mechanism
> * that listattr uses to scrub extended attributes, though in our
> * _listent function, we check the value of the attribute.
> @@ -451,7 +451,7 @@ xfs_scrub_xattr(
> * locking order.
> */
> error = xfs_attr_list_int_ilocked(&sx.context);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_ATTR_FORK, 0, &error))
> + if (!xchk_fblock_process_error(sc, XFS_ATTR_FORK, 0, &error))
> goto out;
> out:
> return error;
> diff --git a/fs/xfs/scrub/bmap.c b/fs/xfs/scrub/bmap.c
> index ebbfab173e97..19cfbd3910a2 100644
> --- a/fs/xfs/scrub/bmap.c
> +++ b/fs/xfs/scrub/bmap.c
> @@ -33,13 +33,13 @@
>
> /* Set us up with an inode's bmap. */
> int
> -xfs_scrub_setup_inode_bmap(
> +xchk_setup_inode_bmap(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> int error;
>
> - error = xfs_scrub_get_inode(sc, ip);
> + error = xchk_get_inode(sc, ip);
> if (error)
> goto out;
>
> @@ -60,7 +60,7 @@ xfs_scrub_setup_inode_bmap(
> }
>
> /* Got the inode, lock it and we're ready to go. */
> - error = xfs_scrub_trans_alloc(sc, 0);
> + error = xchk_trans_alloc(sc, 0);
> if (error)
> goto out;
> sc->ilock_flags |= XFS_ILOCK_EXCL;
> @@ -78,7 +78,7 @@ xfs_scrub_setup_inode_bmap(
> * is in btree format.
> */
>
> -struct xfs_scrub_bmap_info {
> +struct xchk_bmap_info {
> struct xfs_scrub_context *sc;
> xfs_fileoff_t lastoff;
> bool is_rt;
> @@ -88,8 +88,8 @@ struct xfs_scrub_bmap_info {
>
> /* Look for a corresponding rmap for this irec. */
> static inline bool
> -xfs_scrub_bmap_get_rmap(
> - struct xfs_scrub_bmap_info *info,
> +xchk_bmap_get_rmap(
> + struct xchk_bmap_info *info,
> struct xfs_bmbt_irec *irec,
> xfs_agblock_t agbno,
> uint64_t owner,
> @@ -120,7 +120,7 @@ xfs_scrub_bmap_get_rmap(
> if (info->is_shared) {
> error = xfs_rmap_lookup_le_range(info->sc->sa.rmap_cur, agbno,
> owner, offset, rflags, rmap, &has_rmap);
> - if (!xfs_scrub_should_check_xref(info->sc, &error,
> + if (!xchk_should_check_xref(info->sc, &error,
> &info->sc->sa.rmap_cur))
> return false;
> goto out;
> @@ -131,28 +131,28 @@ xfs_scrub_bmap_get_rmap(
> */
> error = xfs_rmap_lookup_le(info->sc->sa.rmap_cur, agbno, 0, owner,
> offset, rflags, &has_rmap);
> - if (!xfs_scrub_should_check_xref(info->sc, &error,
> + if (!xchk_should_check_xref(info->sc, &error,
> &info->sc->sa.rmap_cur))
> return false;
> if (!has_rmap)
> goto out;
>
> error = xfs_rmap_get_rec(info->sc->sa.rmap_cur, rmap, &has_rmap);
> - if (!xfs_scrub_should_check_xref(info->sc, &error,
> + if (!xchk_should_check_xref(info->sc, &error,
> &info->sc->sa.rmap_cur))
> return false;
>
> out:
> if (!has_rmap)
> - xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> return has_rmap;
> }
>
> /* Make sure that we have rmapbt records for this extent. */
> STATIC void
> -xfs_scrub_bmap_xref_rmap(
> - struct xfs_scrub_bmap_info *info,
> +xchk_bmap_xref_rmap(
> + struct xchk_bmap_info *info,
> struct xfs_bmbt_irec *irec,
> xfs_agblock_t agbno)
> {
> @@ -160,7 +160,7 @@ xfs_scrub_bmap_xref_rmap(
> unsigned long long rmap_end;
> uint64_t owner;
>
> - if (!info->sc->sa.rmap_cur || xfs_scrub_skip_xref(info->sc->sm))
> + if (!info->sc->sa.rmap_cur || xchk_skip_xref(info->sc->sm))
> return;
>
> if (info->whichfork == XFS_COW_FORK)
> @@ -169,14 +169,14 @@ xfs_scrub_bmap_xref_rmap(
> owner = info->sc->ip->i_ino;
>
> /* Find the rmap record for this irec. */
> - if (!xfs_scrub_bmap_get_rmap(info, irec, agbno, owner, &rmap))
> + if (!xchk_bmap_get_rmap(info, irec, agbno, owner, &rmap))
> return;
>
> /* Check the rmap. */
> rmap_end = (unsigned long long)rmap.rm_startblock + rmap.rm_blockcount;
> if (rmap.rm_startblock > agbno ||
> agbno + irec->br_blockcount > rmap_end)
> - xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> /*
> @@ -189,12 +189,12 @@ xfs_scrub_bmap_xref_rmap(
> rmap.rm_blockcount;
> if (rmap.rm_offset > irec->br_startoff ||
> irec->br_startoff + irec->br_blockcount > rmap_end)
> - xfs_scrub_fblock_xref_set_corrupt(info->sc,
> + xchk_fblock_xref_set_corrupt(info->sc,
> info->whichfork, irec->br_startoff);
> }
>
> if (rmap.rm_owner != owner)
> - xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> /*
> @@ -207,22 +207,22 @@ xfs_scrub_bmap_xref_rmap(
> if (owner != XFS_RMAP_OWN_COW &&
> irec->br_state == XFS_EXT_UNWRITTEN &&
> !(rmap.rm_flags & XFS_RMAP_UNWRITTEN))
> - xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> if (info->whichfork == XFS_ATTR_FORK &&
> !(rmap.rm_flags & XFS_RMAP_ATTR_FORK))
> - xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> if (rmap.rm_flags & XFS_RMAP_BMBT_BLOCK)
> - xfs_scrub_fblock_xref_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_xref_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> }
>
> /* Cross-reference a single rtdev extent record. */
> STATIC void
> -xfs_scrub_bmap_rt_extent_xref(
> - struct xfs_scrub_bmap_info *info,
> +xchk_bmap_rt_extent_xref(
> + struct xchk_bmap_info *info,
> struct xfs_inode *ip,
> struct xfs_btree_cur *cur,
> struct xfs_bmbt_irec *irec)
> @@ -230,14 +230,14 @@ xfs_scrub_bmap_rt_extent_xref(
> if (info->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return;
>
> - xfs_scrub_xref_is_used_rt_space(info->sc, irec->br_startblock,
> + xchk_xref_is_used_rt_space(info->sc, irec->br_startblock,
> irec->br_blockcount);
> }
>
> /* Cross-reference a single datadev extent record. */
> STATIC void
> -xfs_scrub_bmap_extent_xref(
> - struct xfs_scrub_bmap_info *info,
> +xchk_bmap_extent_xref(
> + struct xchk_bmap_info *info,
> struct xfs_inode *ip,
> struct xfs_btree_cur *cur,
> struct xfs_bmbt_irec *irec)
> @@ -255,38 +255,38 @@ xfs_scrub_bmap_extent_xref(
> agbno = XFS_FSB_TO_AGBNO(mp, irec->br_startblock);
> len = irec->br_blockcount;
>
> - error = xfs_scrub_ag_init(info->sc, agno, &info->sc->sa);
> - if (!xfs_scrub_fblock_process_error(info->sc, info->whichfork,
> + error = xchk_ag_init(info->sc, agno, &info->sc->sa);
> + if (!xchk_fblock_process_error(info->sc, info->whichfork,
> irec->br_startoff, &error))
> return;
>
> - xfs_scrub_xref_is_used_space(info->sc, agbno, len);
> - xfs_scrub_xref_is_not_inode_chunk(info->sc, agbno, len);
> - xfs_scrub_bmap_xref_rmap(info, irec, agbno);
> + xchk_xref_is_used_space(info->sc, agbno, len);
> + xchk_xref_is_not_inode_chunk(info->sc, agbno, len);
> + xchk_bmap_xref_rmap(info, irec, agbno);
> switch (info->whichfork) {
> case XFS_DATA_FORK:
> if (xfs_is_reflink_inode(info->sc->ip))
> break;
> /* fall through */
> case XFS_ATTR_FORK:
> - xfs_scrub_xref_is_not_shared(info->sc, agbno,
> + xchk_xref_is_not_shared(info->sc, agbno,
> irec->br_blockcount);
> break;
> case XFS_COW_FORK:
> - xfs_scrub_xref_is_cow_staging(info->sc, agbno,
> + xchk_xref_is_cow_staging(info->sc, agbno,
> irec->br_blockcount);
> break;
> }
>
> - xfs_scrub_ag_free(info->sc, &info->sc->sa);
> + xchk_ag_free(info->sc, &info->sc->sa);
> }
>
> /* Scrub a single extent record. */
> STATIC int
> -xfs_scrub_bmap_extent(
> +xchk_bmap_extent(
> struct xfs_inode *ip,
> struct xfs_btree_cur *cur,
> - struct xfs_scrub_bmap_info *info,
> + struct xchk_bmap_info *info,
> struct xfs_bmbt_irec *irec)
> {
> struct xfs_mount *mp = info->sc->mp;
> @@ -302,12 +302,12 @@ xfs_scrub_bmap_extent(
> * from the incore list, for which there is no ordering check.
> */
> if (irec->br_startoff < info->lastoff)
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> /* There should never be a "hole" extent in either extent list. */
> if (irec->br_startblock == HOLESTARTBLOCK)
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> /*
> @@ -315,40 +315,40 @@ xfs_scrub_bmap_extent(
> * in-core extent scan, and we should never see these in the bmbt.
> */
> if (isnullstartblock(irec->br_startblock))
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> /* Make sure the extent points to a valid place. */
> if (irec->br_blockcount > MAXEXTLEN)
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> if (irec->br_startblock + irec->br_blockcount <= irec->br_startblock)
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> end = irec->br_startblock + irec->br_blockcount - 1;
> if (info->is_rt &&
> (!xfs_verify_rtbno(mp, irec->br_startblock) ||
> !xfs_verify_rtbno(mp, end)))
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
> if (!info->is_rt &&
> (!xfs_verify_fsbno(mp, irec->br_startblock) ||
> !xfs_verify_fsbno(mp, end) ||
> XFS_FSB_TO_AGNO(mp, irec->br_startblock) !=
> XFS_FSB_TO_AGNO(mp, end)))
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> /* We don't allow unwritten extents on attr forks. */
> if (irec->br_state == XFS_EXT_UNWRITTEN &&
> info->whichfork == XFS_ATTR_FORK)
> - xfs_scrub_fblock_set_corrupt(info->sc, info->whichfork,
> + xchk_fblock_set_corrupt(info->sc, info->whichfork,
> irec->br_startoff);
>
> if (info->is_rt)
> - xfs_scrub_bmap_rt_extent_xref(info, ip, cur, irec);
> + xchk_bmap_rt_extent_xref(info, ip, cur, irec);
> else
> - xfs_scrub_bmap_extent_xref(info, ip, cur, irec);
> + xchk_bmap_extent_xref(info, ip, cur, irec);
>
> info->lastoff = irec->br_startoff + irec->br_blockcount;
> return error;
> @@ -356,12 +356,12 @@ xfs_scrub_bmap_extent(
>
> /* Scrub a bmbt record. */
> STATIC int
> -xfs_scrub_bmapbt_rec(
> - struct xfs_scrub_btree *bs,
> +xchk_bmapbt_rec(
> + struct xchk_btree *bs,
> union xfs_btree_rec *rec)
> {
> struct xfs_bmbt_irec irec;
> - struct xfs_scrub_bmap_info *info = bs->private;
> + struct xchk_bmap_info *info = bs->private;
> struct xfs_inode *ip = bs->cur->bc_private.b.ip;
> struct xfs_buf *bp = NULL;
> struct xfs_btree_block *block;
> @@ -378,22 +378,22 @@ xfs_scrub_bmapbt_rec(
> block = xfs_btree_get_block(bs->cur, i, &bp);
> owner = be64_to_cpu(block->bb_u.l.bb_owner);
> if (owner != ip->i_ino)
> - xfs_scrub_fblock_set_corrupt(bs->sc,
> + xchk_fblock_set_corrupt(bs->sc,
> info->whichfork, 0);
> }
> }
>
> /* Set up the in-core record and scrub it. */
> xfs_bmbt_disk_get_all(&rec->bmbt, &irec);
> - return xfs_scrub_bmap_extent(ip, bs->cur, info, &irec);
> + return xchk_bmap_extent(ip, bs->cur, info, &irec);
> }
>
> /* Scan the btree records. */
> STATIC int
> -xfs_scrub_bmap_btree(
> +xchk_bmap_btree(
> struct xfs_scrub_context *sc,
> int whichfork,
> - struct xfs_scrub_bmap_info *info)
> + struct xchk_bmap_info *info)
> {
> struct xfs_owner_info oinfo;
> struct xfs_mount *mp = sc->mp;
> @@ -403,12 +403,12 @@ xfs_scrub_bmap_btree(
>
> cur = xfs_bmbt_init_cursor(mp, sc->tp, ip, whichfork);
> xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
> - error = xfs_scrub_btree(sc, cur, xfs_scrub_bmapbt_rec, &oinfo, info);
> + error = xchk_btree(sc, cur, xchk_bmapbt_rec, &oinfo, info);
> xfs_btree_del_cursor(cur, error);
> return error;
> }
>
> -struct xfs_scrub_bmap_check_rmap_info {
> +struct xchk_bmap_check_rmap_info {
> struct xfs_scrub_context *sc;
> int whichfork;
> struct xfs_iext_cursor icur;
> @@ -416,13 +416,13 @@ struct xfs_scrub_bmap_check_rmap_info {
>
> /* Can we find bmaps that fit this rmap? */
> STATIC int
> -xfs_scrub_bmap_check_rmap(
> +xchk_bmap_check_rmap(
> struct xfs_btree_cur *cur,
> struct xfs_rmap_irec *rec,
> void *priv)
> {
> struct xfs_bmbt_irec irec;
> - struct xfs_scrub_bmap_check_rmap_info *sbcri = priv;
> + struct xchk_bmap_check_rmap_info *sbcri = priv;
> struct xfs_ifork *ifp;
> struct xfs_scrub_context *sc = sbcri->sc;
> bool have_map;
> @@ -439,14 +439,14 @@ xfs_scrub_bmap_check_rmap(
> /* Now look up the bmbt record. */
> ifp = XFS_IFORK_PTR(sc->ip, sbcri->whichfork);
> if (!ifp) {
> - xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork,
> + xchk_fblock_set_corrupt(sc, sbcri->whichfork,
> rec->rm_offset);
> goto out;
> }
> have_map = xfs_iext_lookup_extent(sc->ip, ifp, rec->rm_offset,
> &sbcri->icur, &irec);
> if (!have_map)
> - xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork,
> + xchk_fblock_set_corrupt(sc, sbcri->whichfork,
> rec->rm_offset);
> /*
> * bmap extent record lengths are constrained to 2^21 blocks in length
> @@ -457,14 +457,14 @@ xfs_scrub_bmap_check_rmap(
> */
> while (have_map) {
> if (irec.br_startoff != rec->rm_offset)
> - xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork,
> + xchk_fblock_set_corrupt(sc, sbcri->whichfork,
> rec->rm_offset);
> if (irec.br_startblock != XFS_AGB_TO_FSB(sc->mp,
> cur->bc_private.a.agno, rec->rm_startblock))
> - xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork,
> + xchk_fblock_set_corrupt(sc, sbcri->whichfork,
> rec->rm_offset);
> if (irec.br_blockcount > rec->rm_blockcount)
> - xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork,
> + xchk_fblock_set_corrupt(sc, sbcri->whichfork,
> rec->rm_offset);
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> break;
> @@ -475,7 +475,7 @@ xfs_scrub_bmap_check_rmap(
> break;
> have_map = xfs_iext_next_extent(ifp, &sbcri->icur, &irec);
> if (!have_map)
> - xfs_scrub_fblock_set_corrupt(sc, sbcri->whichfork,
> + xchk_fblock_set_corrupt(sc, sbcri->whichfork,
> rec->rm_offset);
> }
>
> @@ -487,12 +487,12 @@ xfs_scrub_bmap_check_rmap(
>
> /* Make sure each rmap has a corresponding bmbt entry. */
> STATIC int
> -xfs_scrub_bmap_check_ag_rmaps(
> +xchk_bmap_check_ag_rmaps(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_agnumber_t agno)
> {
> - struct xfs_scrub_bmap_check_rmap_info sbcri;
> + struct xchk_bmap_check_rmap_info sbcri;
> struct xfs_btree_cur *cur;
> struct xfs_buf *agf;
> int error;
> @@ -509,7 +509,7 @@ xfs_scrub_bmap_check_ag_rmaps(
>
> sbcri.sc = sc;
> sbcri.whichfork = whichfork;
> - error = xfs_rmap_query_all(cur, xfs_scrub_bmap_check_rmap, &sbcri);
> + error = xfs_rmap_query_all(cur, xchk_bmap_check_rmap, &sbcri);
> if (error == XFS_BTREE_QUERY_RANGE_ABORT)
> error = 0;
>
> @@ -521,7 +521,7 @@ xfs_scrub_bmap_check_ag_rmaps(
>
> /* Make sure each rmap has a corresponding bmbt entry. */
> STATIC int
> -xfs_scrub_bmap_check_rmaps(
> +xchk_bmap_check_rmaps(
> struct xfs_scrub_context *sc,
> int whichfork)
> {
> @@ -561,7 +561,7 @@ xfs_scrub_bmap_check_rmaps(
> return 0;
>
> for (agno = 0; agno < sc->mp->m_sb.sb_agcount; agno++) {
> - error = xfs_scrub_bmap_check_ag_rmaps(sc, whichfork, agno);
> + error = xchk_bmap_check_ag_rmaps(sc, whichfork, agno);
> if (error)
> return error;
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> @@ -578,12 +578,12 @@ xfs_scrub_bmap_check_rmaps(
> * Then we unconditionally scan the incore extent cache.
> */
> STATIC int
> -xfs_scrub_bmap(
> +xchk_bmap(
> struct xfs_scrub_context *sc,
> int whichfork)
> {
> struct xfs_bmbt_irec irec;
> - struct xfs_scrub_bmap_info info = { NULL };
> + struct xchk_bmap_info info = { NULL };
> struct xfs_mount *mp = sc->mp;
> struct xfs_inode *ip = sc->ip;
> struct xfs_ifork *ifp;
> @@ -605,7 +605,7 @@ xfs_scrub_bmap(
> goto out;
> /* No CoW forks on non-reflink inodes/filesystems. */
> if (!xfs_is_reflink_inode(ip)) {
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> goto out;
> }
> break;
> @@ -614,7 +614,7 @@ xfs_scrub_bmap(
> goto out_check_rmap;
> if (!xfs_sb_version_hasattr(&mp->m_sb) &&
> !xfs_sb_version_hasattr2(&mp->m_sb))
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> break;
> default:
> ASSERT(whichfork == XFS_DATA_FORK);
> @@ -630,22 +630,22 @@ xfs_scrub_bmap(
> goto out;
> case XFS_DINODE_FMT_EXTENTS:
> if (!(ifp->if_flags & XFS_IFEXTENTS)) {
> - xfs_scrub_fblock_set_corrupt(sc, whichfork, 0);
> + xchk_fblock_set_corrupt(sc, whichfork, 0);
> goto out;
> }
> break;
> case XFS_DINODE_FMT_BTREE:
> if (whichfork == XFS_COW_FORK) {
> - xfs_scrub_fblock_set_corrupt(sc, whichfork, 0);
> + xchk_fblock_set_corrupt(sc, whichfork, 0);
> goto out;
> }
>
> - error = xfs_scrub_bmap_btree(sc, whichfork, &info);
> + error = xchk_bmap_btree(sc, whichfork, &info);
> if (error)
> goto out;
> break;
> default:
> - xfs_scrub_fblock_set_corrupt(sc, whichfork, 0);
> + xchk_fblock_set_corrupt(sc, whichfork, 0);
> goto out;
> }
>
> @@ -655,37 +655,37 @@ xfs_scrub_bmap(
> /* Now try to scrub the in-memory extent list. */
> if (!(ifp->if_flags & XFS_IFEXTENTS)) {
> error = xfs_iread_extents(sc->tp, ip, whichfork);
> - if (!xfs_scrub_fblock_process_error(sc, whichfork, 0, &error))
> + if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
> goto out;
> }
>
> /* Find the offset of the last extent in the mapping. */
> error = xfs_bmap_last_offset(ip, &endoff, whichfork);
> - if (!xfs_scrub_fblock_process_error(sc, whichfork, 0, &error))
> + if (!xchk_fblock_process_error(sc, whichfork, 0, &error))
> goto out;
>
> /* Scrub extent records. */
> info.lastoff = 0;
> ifp = XFS_IFORK_PTR(ip, whichfork);
> for_each_xfs_iext(ifp, &icur, &irec) {
> - if (xfs_scrub_should_terminate(sc, &error) ||
> + if (xchk_should_terminate(sc, &error) ||
> (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> break;
> if (isnullstartblock(irec.br_startblock))
> continue;
> if (irec.br_startoff >= endoff) {
> - xfs_scrub_fblock_set_corrupt(sc, whichfork,
> + xchk_fblock_set_corrupt(sc, whichfork,
> irec.br_startoff);
> goto out;
> }
> - error = xfs_scrub_bmap_extent(ip, NULL, &info, &irec);
> + error = xchk_bmap_extent(ip, NULL, &info, &irec);
> if (error)
> goto out;
> }
>
> out_check_rmap:
> - error = xfs_scrub_bmap_check_rmaps(sc, whichfork);
> - if (!xfs_scrub_fblock_xref_process_error(sc, whichfork, 0, &error))
> + error = xchk_bmap_check_rmaps(sc, whichfork);
> + if (!xchk_fblock_xref_process_error(sc, whichfork, 0, &error))
> goto out;
> out:
> return error;
> @@ -693,27 +693,27 @@ xfs_scrub_bmap(
>
> /* Scrub an inode's data fork. */
> int
> -xfs_scrub_bmap_data(
> +xchk_bmap_data(
> struct xfs_scrub_context *sc)
> {
> - return xfs_scrub_bmap(sc, XFS_DATA_FORK);
> + return xchk_bmap(sc, XFS_DATA_FORK);
> }
>
> /* Scrub an inode's attr fork. */
> int
> -xfs_scrub_bmap_attr(
> +xchk_bmap_attr(
> struct xfs_scrub_context *sc)
> {
> - return xfs_scrub_bmap(sc, XFS_ATTR_FORK);
> + return xchk_bmap(sc, XFS_ATTR_FORK);
> }
>
> /* Scrub an inode's CoW fork. */
> int
> -xfs_scrub_bmap_cow(
> +xchk_bmap_cow(
> struct xfs_scrub_context *sc)
> {
> if (!xfs_is_reflink_inode(sc->ip))
> return -ENOENT;
>
> - return xfs_scrub_bmap(sc, XFS_COW_FORK);
> + return xchk_bmap(sc, XFS_COW_FORK);
> }
> diff --git a/fs/xfs/scrub/btree.c b/fs/xfs/scrub/btree.c
> index 5b472045f036..30fe9a147959 100644
> --- a/fs/xfs/scrub/btree.c
> +++ b/fs/xfs/scrub/btree.c
> @@ -29,7 +29,7 @@
> * operational errors in common.c.
> */
> static bool
> -__xfs_scrub_btree_process_error(
> +__xchk_btree_process_error(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> int level,
> @@ -43,7 +43,7 @@ __xfs_scrub_btree_process_error(
> switch (*error) {
> case -EDEADLOCK:
> /* Used to restart an op with deadlock avoidance. */
> - trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
> + trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
> break;
> case -EFSBADCRC:
> case -EFSCORRUPTED:
> @@ -53,10 +53,10 @@ __xfs_scrub_btree_process_error(
> /* fall through */
> default:
> if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
> - trace_xfs_scrub_ifork_btree_op_error(sc, cur, level,
> + trace_xchk_ifork_btree_op_error(sc, cur, level,
> *error, ret_ip);
> else
> - trace_xfs_scrub_btree_op_error(sc, cur, level,
> + trace_xchk_btree_op_error(sc, cur, level,
> *error, ret_ip);
> break;
> }
> @@ -64,30 +64,30 @@ __xfs_scrub_btree_process_error(
> }
>
> bool
> -xfs_scrub_btree_process_error(
> +xchk_btree_process_error(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> int level,
> int *error)
> {
> - return __xfs_scrub_btree_process_error(sc, cur, level, error,
> + return __xchk_btree_process_error(sc, cur, level, error,
> XFS_SCRUB_OFLAG_CORRUPT, __return_address);
> }
>
> bool
> -xfs_scrub_btree_xref_process_error(
> +xchk_btree_xref_process_error(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> int level,
> int *error)
> {
> - return __xfs_scrub_btree_process_error(sc, cur, level, error,
> + return __xchk_btree_process_error(sc, cur, level, error,
> XFS_SCRUB_OFLAG_XFAIL, __return_address);
> }
>
> /* Record btree block corruption. */
> static void
> -__xfs_scrub_btree_set_corrupt(
> +__xchk_btree_set_corrupt(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> int level,
> @@ -97,30 +97,30 @@ __xfs_scrub_btree_set_corrupt(
> sc->sm->sm_flags |= errflag;
>
> if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
> - trace_xfs_scrub_ifork_btree_error(sc, cur, level,
> + trace_xchk_ifork_btree_error(sc, cur, level,
> ret_ip);
> else
> - trace_xfs_scrub_btree_error(sc, cur, level,
> + trace_xchk_btree_error(sc, cur, level,
> ret_ip);
> }
>
> void
> -xfs_scrub_btree_set_corrupt(
> +xchk_btree_set_corrupt(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> int level)
> {
> - __xfs_scrub_btree_set_corrupt(sc, cur, level, XFS_SCRUB_OFLAG_CORRUPT,
> + __xchk_btree_set_corrupt(sc, cur, level, XFS_SCRUB_OFLAG_CORRUPT,
> __return_address);
> }
>
> void
> -xfs_scrub_btree_xref_set_corrupt(
> +xchk_btree_xref_set_corrupt(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> int level)
> {
> - __xfs_scrub_btree_set_corrupt(sc, cur, level, XFS_SCRUB_OFLAG_XCORRUPT,
> + __xchk_btree_set_corrupt(sc, cur, level, XFS_SCRUB_OFLAG_XCORRUPT,
> __return_address);
> }
>
> @@ -129,8 +129,8 @@ xfs_scrub_btree_xref_set_corrupt(
> * keys.
> */
> STATIC void
> -xfs_scrub_btree_rec(
> - struct xfs_scrub_btree *bs)
> +xchk_btree_rec(
> + struct xchk_btree *bs)
> {
> struct xfs_btree_cur *cur = bs->cur;
> union xfs_btree_rec *rec;
> @@ -144,11 +144,11 @@ xfs_scrub_btree_rec(
> block = xfs_btree_get_block(cur, 0, &bp);
> rec = xfs_btree_rec_addr(cur, cur->bc_ptrs[0], block);
>
> - trace_xfs_scrub_btree_rec(bs->sc, cur, 0);
> + trace_xchk_btree_rec(bs->sc, cur, 0);
>
> /* If this isn't the first record, are they in order? */
> if (!bs->firstrec && !cur->bc_ops->recs_inorder(cur, &bs->lastrec, rec))
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, 0);
> + xchk_btree_set_corrupt(bs->sc, cur, 0);
> bs->firstrec = false;
> memcpy(&bs->lastrec, rec, cur->bc_ops->rec_len);
>
> @@ -160,7 +160,7 @@ xfs_scrub_btree_rec(
> keyblock = xfs_btree_get_block(cur, 1, &bp);
> keyp = xfs_btree_key_addr(cur, cur->bc_ptrs[1], keyblock);
> if (cur->bc_ops->diff_two_keys(cur, &key, keyp) < 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, 1);
> + xchk_btree_set_corrupt(bs->sc, cur, 1);
>
> if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
> return;
> @@ -169,7 +169,7 @@ xfs_scrub_btree_rec(
> cur->bc_ops->init_high_key_from_rec(&hkey, rec);
> keyp = xfs_btree_high_key_addr(cur, cur->bc_ptrs[1], keyblock);
> if (cur->bc_ops->diff_two_keys(cur, keyp, &hkey) < 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, 1);
> + xchk_btree_set_corrupt(bs->sc, cur, 1);
> }
>
> /*
> @@ -177,8 +177,8 @@ xfs_scrub_btree_rec(
> * keys.
> */
> STATIC void
> -xfs_scrub_btree_key(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_key(
> + struct xchk_btree *bs,
> int level)
> {
> struct xfs_btree_cur *cur = bs->cur;
> @@ -191,12 +191,12 @@ xfs_scrub_btree_key(
> block = xfs_btree_get_block(cur, level, &bp);
> key = xfs_btree_key_addr(cur, cur->bc_ptrs[level], block);
>
> - trace_xfs_scrub_btree_key(bs->sc, cur, level);
> + trace_xchk_btree_key(bs->sc, cur, level);
>
> /* If this isn't the first key, are they in order? */
> if (!bs->firstkey[level] &&
> !cur->bc_ops->keys_inorder(cur, &bs->lastkey[level], key))
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level);
> + xchk_btree_set_corrupt(bs->sc, cur, level);
> bs->firstkey[level] = false;
> memcpy(&bs->lastkey[level], key, cur->bc_ops->key_len);
>
> @@ -207,7 +207,7 @@ xfs_scrub_btree_key(
> keyblock = xfs_btree_get_block(cur, level + 1, &bp);
> keyp = xfs_btree_key_addr(cur, cur->bc_ptrs[level + 1], keyblock);
> if (cur->bc_ops->diff_two_keys(cur, key, keyp) < 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level);
> + xchk_btree_set_corrupt(bs->sc, cur, level);
>
> if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
> return;
> @@ -216,7 +216,7 @@ xfs_scrub_btree_key(
> key = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level], block);
> keyp = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level + 1], keyblock);
> if (cur->bc_ops->diff_two_keys(cur, keyp, key) < 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level);
> + xchk_btree_set_corrupt(bs->sc, cur, level);
> }
>
> /*
> @@ -224,8 +224,8 @@ xfs_scrub_btree_key(
> * Callers do not need to set the corrupt flag.
> */
> static bool
> -xfs_scrub_btree_ptr_ok(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_ptr_ok(
> + struct xchk_btree *bs,
> int level,
> union xfs_btree_ptr *ptr)
> {
> @@ -242,15 +242,15 @@ xfs_scrub_btree_ptr_ok(
> else
> res = xfs_btree_check_sptr(bs->cur, be32_to_cpu(ptr->s), level);
> if (!res)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, level);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, level);
>
> return res;
> }
>
> /* Check that a btree block's sibling matches what we expect it. */
> STATIC int
> -xfs_scrub_btree_block_check_sibling(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_block_check_sibling(
> + struct xchk_btree *bs,
> int level,
> int direction,
> union xfs_btree_ptr *sibling)
> @@ -264,7 +264,7 @@ xfs_scrub_btree_block_check_sibling(
> int error;
>
> error = xfs_btree_dup_cursor(cur, &ncur);
> - if (!xfs_scrub_btree_process_error(bs->sc, cur, level + 1, &error) ||
> + if (!xchk_btree_process_error(bs->sc, cur, level + 1, &error) ||
> !ncur)
> return error;
>
> @@ -278,7 +278,7 @@ xfs_scrub_btree_block_check_sibling(
> else
> error = xfs_btree_decrement(ncur, level + 1, &success);
> if (error == 0 && success)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level);
> + xchk_btree_set_corrupt(bs->sc, cur, level);
> error = 0;
> goto out;
> }
> @@ -288,23 +288,23 @@ xfs_scrub_btree_block_check_sibling(
> error = xfs_btree_increment(ncur, level + 1, &success);
> else
> error = xfs_btree_decrement(ncur, level + 1, &success);
> - if (!xfs_scrub_btree_process_error(bs->sc, cur, level + 1, &error))
> + if (!xchk_btree_process_error(bs->sc, cur, level + 1, &error))
> goto out;
> if (!success) {
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level + 1);
> + xchk_btree_set_corrupt(bs->sc, cur, level + 1);
> goto out;
> }
>
> /* Compare upper level pointer to sibling pointer. */
> pblock = xfs_btree_get_block(ncur, level + 1, &pbp);
> pp = xfs_btree_ptr_addr(ncur, ncur->bc_ptrs[level + 1], pblock);
> - if (!xfs_scrub_btree_ptr_ok(bs, level + 1, pp))
> + if (!xchk_btree_ptr_ok(bs, level + 1, pp))
> goto out;
> if (pbp)
> - xfs_scrub_buffer_recheck(bs->sc, pbp);
> + xchk_buffer_recheck(bs->sc, pbp);
>
> if (xfs_btree_diff_two_ptrs(cur, pp, sibling))
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level);
> + xchk_btree_set_corrupt(bs->sc, cur, level);
> out:
> xfs_btree_del_cursor(ncur, XFS_BTREE_ERROR);
> return error;
> @@ -312,8 +312,8 @@ xfs_scrub_btree_block_check_sibling(
>
> /* Check the siblings of a btree block. */
> STATIC int
> -xfs_scrub_btree_block_check_siblings(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_block_check_siblings(
> + struct xchk_btree *bs,
> struct xfs_btree_block *block)
> {
> struct xfs_btree_cur *cur = bs->cur;
> @@ -330,7 +330,7 @@ xfs_scrub_btree_block_check_siblings(
> if (level == cur->bc_nlevels - 1) {
> if (!xfs_btree_ptr_is_null(cur, &leftsib) ||
> !xfs_btree_ptr_is_null(cur, &rightsib))
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, level);
> + xchk_btree_set_corrupt(bs->sc, cur, level);
> goto out;
> }
>
> @@ -339,10 +339,10 @@ xfs_scrub_btree_block_check_siblings(
> * parent level pointers?
> * (These function absorbs error codes for us.)
> */
> - error = xfs_scrub_btree_block_check_sibling(bs, level, -1, &leftsib);
> + error = xchk_btree_block_check_sibling(bs, level, -1, &leftsib);
> if (error)
> return error;
> - error = xfs_scrub_btree_block_check_sibling(bs, level, 1, &rightsib);
> + error = xchk_btree_block_check_sibling(bs, level, 1, &rightsib);
> if (error)
> return error;
> out:
> @@ -360,8 +360,8 @@ struct check_owner {
> * an rmap record for it.
> */
> STATIC int
> -xfs_scrub_btree_check_block_owner(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_check_block_owner(
> + struct xchk_btree *bs,
> int level,
> xfs_daddr_t daddr)
> {
> @@ -380,13 +380,13 @@ xfs_scrub_btree_check_block_owner(
>
> init_sa = bs->cur->bc_flags & XFS_BTREE_LONG_PTRS;
> if (init_sa) {
> - error = xfs_scrub_ag_init(bs->sc, agno, &bs->sc->sa);
> - if (!xfs_scrub_btree_xref_process_error(bs->sc, bs->cur,
> + error = xchk_ag_init(bs->sc, agno, &bs->sc->sa);
> + if (!xchk_btree_xref_process_error(bs->sc, bs->cur,
> level, &error))
> return error;
> }
>
> - xfs_scrub_xref_is_used_space(bs->sc, agbno, 1);
> + xchk_xref_is_used_space(bs->sc, agbno, 1);
> /*
> * The bnobt scrubber aliases bs->cur to bs->sc->sa.bno_cur, so we
> * have to nullify it (to shut down further block owner checks) if
> @@ -395,20 +395,20 @@ xfs_scrub_btree_check_block_owner(
> if (!bs->sc->sa.bno_cur && btnum == XFS_BTNUM_BNO)
> bs->cur = NULL;
>
> - xfs_scrub_xref_is_owned_by(bs->sc, agbno, 1, bs->oinfo);
> + xchk_xref_is_owned_by(bs->sc, agbno, 1, bs->oinfo);
> if (!bs->sc->sa.rmap_cur && btnum == XFS_BTNUM_RMAP)
> bs->cur = NULL;
>
> if (init_sa)
> - xfs_scrub_ag_free(bs->sc, &bs->sc->sa);
> + xchk_ag_free(bs->sc, &bs->sc->sa);
>
> return error;
> }
>
> /* Check the owner of a btree block. */
> STATIC int
> -xfs_scrub_btree_check_owner(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_check_owner(
> + struct xchk_btree *bs,
> int level,
> struct xfs_buf *bp)
> {
> @@ -437,7 +437,7 @@ xfs_scrub_btree_check_owner(
> return 0;
> }
>
> - return xfs_scrub_btree_check_block_owner(bs, level, XFS_BUF_ADDR(bp));
> + return xchk_btree_check_block_owner(bs, level, XFS_BUF_ADDR(bp));
> }
>
> /*
> @@ -445,8 +445,8 @@ xfs_scrub_btree_check_owner(
> * special blocks that don't require that.
> */
> STATIC void
> -xfs_scrub_btree_check_minrecs(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_check_minrecs(
> + struct xchk_btree *bs,
> int level,
> struct xfs_btree_block *block)
> {
> @@ -475,7 +475,7 @@ xfs_scrub_btree_check_minrecs(
> if (level >= ok_level)
> return;
>
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, level);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, level);
> }
>
> /*
> @@ -483,8 +483,8 @@ xfs_scrub_btree_check_minrecs(
> * and buffer pointers (if applicable) if they're ok to use.
> */
> STATIC int
> -xfs_scrub_btree_get_block(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_get_block(
> + struct xchk_btree *bs,
> int level,
> union xfs_btree_ptr *pp,
> struct xfs_btree_block **pblock,
> @@ -497,7 +497,7 @@ xfs_scrub_btree_get_block(
> *pbp = NULL;
>
> error = xfs_btree_lookup_get_block(bs->cur, level, pp, pblock);
> - if (!xfs_scrub_btree_process_error(bs->sc, bs->cur, level, &error) ||
> + if (!xchk_btree_process_error(bs->sc, bs->cur, level, &error) ||
> !*pblock)
> return error;
>
> @@ -509,19 +509,19 @@ xfs_scrub_btree_get_block(
> failed_at = __xfs_btree_check_sblock(bs->cur, *pblock,
> level, *pbp);
> if (failed_at) {
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, level);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, level);
> return 0;
> }
> if (*pbp)
> - xfs_scrub_buffer_recheck(bs->sc, *pbp);
> + xchk_buffer_recheck(bs->sc, *pbp);
>
> - xfs_scrub_btree_check_minrecs(bs, level, *pblock);
> + xchk_btree_check_minrecs(bs, level, *pblock);
>
> /*
> * Check the block's owner; this function absorbs error codes
> * for us.
> */
> - error = xfs_scrub_btree_check_owner(bs, level, *pbp);
> + error = xchk_btree_check_owner(bs, level, *pbp);
> if (error)
> return error;
>
> @@ -529,7 +529,7 @@ xfs_scrub_btree_get_block(
> * Check the block's siblings; this function absorbs error codes
> * for us.
> */
> - return xfs_scrub_btree_block_check_siblings(bs, *pblock);
> + return xchk_btree_block_check_siblings(bs, *pblock);
> }
>
> /*
> @@ -537,8 +537,8 @@ xfs_scrub_btree_get_block(
> * in the parent block.
> */
> STATIC void
> -xfs_scrub_btree_block_keys(
> - struct xfs_scrub_btree *bs,
> +xchk_btree_block_keys(
> + struct xchk_btree *bs,
> int level,
> struct xfs_btree_block *block)
> {
> @@ -562,7 +562,7 @@ xfs_scrub_btree_block_keys(
> parent_block);
>
> if (cur->bc_ops->diff_two_keys(cur, &block_keys, parent_keys) != 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, 1);
> + xchk_btree_set_corrupt(bs->sc, cur, 1);
>
> if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
> return;
> @@ -573,7 +573,7 @@ xfs_scrub_btree_block_keys(
> parent_block);
>
> if (cur->bc_ops->diff_two_keys(cur, high_bk, high_pk) != 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, cur, 1);
> + xchk_btree_set_corrupt(bs->sc, cur, 1);
> }
>
> /*
> @@ -582,14 +582,14 @@ xfs_scrub_btree_block_keys(
> * so that the caller can verify individual records.
> */
> int
> -xfs_scrub_btree(
> +xchk_btree(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> - xfs_scrub_btree_rec_fn scrub_fn,
> + xchk_btree_rec_fn scrub_fn,
> struct xfs_owner_info *oinfo,
> void *private)
> {
> - struct xfs_scrub_btree bs = { NULL };
> + struct xchk_btree bs = { NULL };
> union xfs_btree_ptr ptr;
> union xfs_btree_ptr *pp;
> union xfs_btree_rec *recp;
> @@ -614,7 +614,7 @@ xfs_scrub_btree(
>
> /* Don't try to check a tree with a height we can't handle. */
> if (cur->bc_nlevels > XFS_BTREE_MAXLEVELS) {
> - xfs_scrub_btree_set_corrupt(sc, cur, 0);
> + xchk_btree_set_corrupt(sc, cur, 0);
> goto out;
> }
>
> @@ -624,9 +624,9 @@ xfs_scrub_btree(
> */
> level = cur->bc_nlevels - 1;
> cur->bc_ops->init_ptr_from_cur(cur, &ptr);
> - if (!xfs_scrub_btree_ptr_ok(&bs, cur->bc_nlevels, &ptr))
> + if (!xchk_btree_ptr_ok(&bs, cur->bc_nlevels, &ptr))
> goto out;
> - error = xfs_scrub_btree_get_block(&bs, level, &ptr, &block, &bp);
> + error = xchk_btree_get_block(&bs, level, &ptr, &block, &bp);
> if (error || !block)
> goto out;
>
> @@ -639,7 +639,7 @@ xfs_scrub_btree(
> /* End of leaf, pop back towards the root. */
> if (cur->bc_ptrs[level] >
> be16_to_cpu(block->bb_numrecs)) {
> - xfs_scrub_btree_block_keys(&bs, level, block);
> + xchk_btree_block_keys(&bs, level, block);
> if (level < cur->bc_nlevels - 1)
> cur->bc_ptrs[level + 1]++;
> level++;
> @@ -647,14 +647,14 @@ xfs_scrub_btree(
> }
>
> /* Records in order for scrub? */
> - xfs_scrub_btree_rec(&bs);
> + xchk_btree_rec(&bs);
>
> /* Call out to the record checker. */
> recp = xfs_btree_rec_addr(cur, cur->bc_ptrs[0], block);
> error = bs.scrub_rec(&bs, recp);
> if (error)
> break;
> - if (xfs_scrub_should_terminate(sc, &error) ||
> + if (xchk_should_terminate(sc, &error) ||
> (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> break;
>
> @@ -664,7 +664,7 @@ xfs_scrub_btree(
>
> /* End of node, pop back towards the root. */
> if (cur->bc_ptrs[level] > be16_to_cpu(block->bb_numrecs)) {
> - xfs_scrub_btree_block_keys(&bs, level, block);
> + xchk_btree_block_keys(&bs, level, block);
> if (level < cur->bc_nlevels - 1)
> cur->bc_ptrs[level + 1]++;
> level++;
> @@ -672,16 +672,16 @@ xfs_scrub_btree(
> }
>
> /* Keys in order for scrub? */
> - xfs_scrub_btree_key(&bs, level);
> + xchk_btree_key(&bs, level);
>
> /* Drill another level deeper. */
> pp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[level], block);
> - if (!xfs_scrub_btree_ptr_ok(&bs, level, pp)) {
> + if (!xchk_btree_ptr_ok(&bs, level, pp)) {
> cur->bc_ptrs[level]++;
> continue;
> }
> level--;
> - error = xfs_scrub_btree_get_block(&bs, level, pp, &block, &bp);
> + error = xchk_btree_get_block(&bs, level, pp, &block, &bp);
> if (error || !block)
> goto out;
>
> @@ -692,7 +692,7 @@ xfs_scrub_btree(
> /* Process deferred owner checks on btree blocks. */
> list_for_each_entry_safe(co, n, &bs.to_check, list) {
> if (!error && bs.cur)
> - error = xfs_scrub_btree_check_block_owner(&bs,
> + error = xchk_btree_check_block_owner(&bs,
> co->level, co->daddr);
> list_del(&co->list);
> kmem_free(co);
> diff --git a/fs/xfs/scrub/btree.h b/fs/xfs/scrub/btree.h
> index 956627500f2c..598ac04a6c3e 100644
> --- a/fs/xfs/scrub/btree.h
> +++ b/fs/xfs/scrub/btree.h
> @@ -9,32 +9,32 @@
> /* btree scrub */
>
> /* Check for btree operation errors. */
> -bool xfs_scrub_btree_process_error(struct xfs_scrub_context *sc,
> +bool xchk_btree_process_error(struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur, int level, int *error);
>
> /* Check for btree xref operation errors. */
> -bool xfs_scrub_btree_xref_process_error(struct xfs_scrub_context *sc,
> +bool xchk_btree_xref_process_error(struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur, int level,
> int *error);
>
> /* Check for btree corruption. */
> -void xfs_scrub_btree_set_corrupt(struct xfs_scrub_context *sc,
> +void xchk_btree_set_corrupt(struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur, int level);
>
> /* Check for btree xref discrepancies. */
> -void xfs_scrub_btree_xref_set_corrupt(struct xfs_scrub_context *sc,
> +void xchk_btree_xref_set_corrupt(struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur, int level);
>
> -struct xfs_scrub_btree;
> -typedef int (*xfs_scrub_btree_rec_fn)(
> - struct xfs_scrub_btree *bs,
> +struct xchk_btree;
> +typedef int (*xchk_btree_rec_fn)(
> + struct xchk_btree *bs,
> union xfs_btree_rec *rec);
>
> -struct xfs_scrub_btree {
> +struct xchk_btree {
> /* caller-provided scrub state */
> struct xfs_scrub_context *sc;
> struct xfs_btree_cur *cur;
> - xfs_scrub_btree_rec_fn scrub_rec;
> + xchk_btree_rec_fn scrub_rec;
> struct xfs_owner_info *oinfo;
> void *private;
>
> @@ -45,8 +45,8 @@ struct xfs_scrub_btree {
> bool firstkey[XFS_BTREE_MAXLEVELS];
> struct list_head to_check;
> };
> -int xfs_scrub_btree(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> - xfs_scrub_btree_rec_fn scrub_fn,
> +int xchk_btree(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> + xchk_btree_rec_fn scrub_fn,
> struct xfs_owner_info *oinfo, void *private);
>
> #endif /* __XFS_SCRUB_BTREE_H__ */
> diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
> index 70e70c69f83f..a4004a06f482 100644
> --- a/fs/xfs/scrub/common.c
> +++ b/fs/xfs/scrub/common.c
> @@ -68,7 +68,7 @@
>
> /* Check for operational errors. */
> static bool
> -__xfs_scrub_process_error(
> +__xchk_process_error(
> struct xfs_scrub_context *sc,
> xfs_agnumber_t agno,
> xfs_agblock_t bno,
> @@ -81,7 +81,7 @@ __xfs_scrub_process_error(
> return true;
> case -EDEADLOCK:
> /* Used to restart an op with deadlock avoidance. */
> - trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
> + trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
> break;
> case -EFSBADCRC:
> case -EFSCORRUPTED:
> @@ -90,7 +90,7 @@ __xfs_scrub_process_error(
> *error = 0;
> /* fall through */
> default:
> - trace_xfs_scrub_op_error(sc, agno, bno, *error,
> + trace_xchk_op_error(sc, agno, bno, *error,
> ret_ip);
> break;
> }
> @@ -98,30 +98,30 @@ __xfs_scrub_process_error(
> }
>
> bool
> -xfs_scrub_process_error(
> +xchk_process_error(
> struct xfs_scrub_context *sc,
> xfs_agnumber_t agno,
> xfs_agblock_t bno,
> int *error)
> {
> - return __xfs_scrub_process_error(sc, agno, bno, error,
> + return __xchk_process_error(sc, agno, bno, error,
> XFS_SCRUB_OFLAG_CORRUPT, __return_address);
> }
>
> bool
> -xfs_scrub_xref_process_error(
> +xchk_xref_process_error(
> struct xfs_scrub_context *sc,
> xfs_agnumber_t agno,
> xfs_agblock_t bno,
> int *error)
> {
> - return __xfs_scrub_process_error(sc, agno, bno, error,
> + return __xchk_process_error(sc, agno, bno, error,
> XFS_SCRUB_OFLAG_XFAIL, __return_address);
> }
>
> /* Check for operational errors for a file offset. */
> static bool
> -__xfs_scrub_fblock_process_error(
> +__xchk_fblock_process_error(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_fileoff_t offset,
> @@ -134,7 +134,7 @@ __xfs_scrub_fblock_process_error(
> return true;
> case -EDEADLOCK:
> /* Used to restart an op with deadlock avoidance. */
> - trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
> + trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
> break;
> case -EFSBADCRC:
> case -EFSCORRUPTED:
> @@ -143,7 +143,7 @@ __xfs_scrub_fblock_process_error(
> *error = 0;
> /* fall through */
> default:
> - trace_xfs_scrub_file_op_error(sc, whichfork, offset, *error,
> + trace_xchk_file_op_error(sc, whichfork, offset, *error,
> ret_ip);
> break;
> }
> @@ -151,24 +151,24 @@ __xfs_scrub_fblock_process_error(
> }
>
> bool
> -xfs_scrub_fblock_process_error(
> +xchk_fblock_process_error(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_fileoff_t offset,
> int *error)
> {
> - return __xfs_scrub_fblock_process_error(sc, whichfork, offset, error,
> + return __xchk_fblock_process_error(sc, whichfork, offset, error,
> XFS_SCRUB_OFLAG_CORRUPT, __return_address);
> }
>
> bool
> -xfs_scrub_fblock_xref_process_error(
> +xchk_fblock_xref_process_error(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_fileoff_t offset,
> int *error)
> {
> - return __xfs_scrub_fblock_process_error(sc, whichfork, offset, error,
> + return __xchk_fblock_process_error(sc, whichfork, offset, error,
> XFS_SCRUB_OFLAG_XFAIL, __return_address);
> }
>
> @@ -186,12 +186,12 @@ xfs_scrub_fblock_xref_process_error(
>
> /* Record a block which could be optimized. */
> void
> -xfs_scrub_block_set_preen(
> +xchk_block_set_preen(
> struct xfs_scrub_context *sc,
> struct xfs_buf *bp)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
> - trace_xfs_scrub_block_preen(sc, bp->b_bn, __return_address);
> + trace_xchk_block_preen(sc, bp->b_bn, __return_address);
> }
>
> /*
> @@ -200,32 +200,32 @@ xfs_scrub_block_set_preen(
> * the block location of the inode record itself.
> */
> void
> -xfs_scrub_ino_set_preen(
> +xchk_ino_set_preen(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_PREEN;
> - trace_xfs_scrub_ino_preen(sc, ino, __return_address);
> + trace_xchk_ino_preen(sc, ino, __return_address);
> }
>
> /* Record a corrupt block. */
> void
> -xfs_scrub_block_set_corrupt(
> +xchk_block_set_corrupt(
> struct xfs_scrub_context *sc,
> struct xfs_buf *bp)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
> - trace_xfs_scrub_block_error(sc, bp->b_bn, __return_address);
> + trace_xchk_block_error(sc, bp->b_bn, __return_address);
> }
>
> /* Record a corruption while cross-referencing. */
> void
> -xfs_scrub_block_xref_set_corrupt(
> +xchk_block_xref_set_corrupt(
> struct xfs_scrub_context *sc,
> struct xfs_buf *bp)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
> - trace_xfs_scrub_block_error(sc, bp->b_bn, __return_address);
> + trace_xchk_block_error(sc, bp->b_bn, __return_address);
> }
>
> /*
> @@ -234,44 +234,44 @@ xfs_scrub_block_xref_set_corrupt(
> * inode record itself.
> */
> void
> -xfs_scrub_ino_set_corrupt(
> +xchk_ino_set_corrupt(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
> - trace_xfs_scrub_ino_error(sc, ino, __return_address);
> + trace_xchk_ino_error(sc, ino, __return_address);
> }
>
> /* Record a corruption while cross-referencing with an inode. */
> void
> -xfs_scrub_ino_xref_set_corrupt(
> +xchk_ino_xref_set_corrupt(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
> - trace_xfs_scrub_ino_error(sc, ino, __return_address);
> + trace_xchk_ino_error(sc, ino, __return_address);
> }
>
> /* Record corruption in a block indexed by a file fork. */
> void
> -xfs_scrub_fblock_set_corrupt(
> +xchk_fblock_set_corrupt(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_fileoff_t offset)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
> - trace_xfs_scrub_fblock_error(sc, whichfork, offset, __return_address);
> + trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
> }
>
> /* Record a corruption while cross-referencing a fork block. */
> void
> -xfs_scrub_fblock_xref_set_corrupt(
> +xchk_fblock_xref_set_corrupt(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_fileoff_t offset)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XCORRUPT;
> - trace_xfs_scrub_fblock_error(sc, whichfork, offset, __return_address);
> + trace_xchk_fblock_error(sc, whichfork, offset, __return_address);
> }
>
> /*
> @@ -279,32 +279,32 @@ xfs_scrub_fblock_xref_set_corrupt(
> * incorrect.
> */
> void
> -xfs_scrub_ino_set_warning(
> +xchk_ino_set_warning(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
> - trace_xfs_scrub_ino_warning(sc, ino, __return_address);
> + trace_xchk_ino_warning(sc, ino, __return_address);
> }
>
> /* Warn about a block indexed by a file fork that needs review. */
> void
> -xfs_scrub_fblock_set_warning(
> +xchk_fblock_set_warning(
> struct xfs_scrub_context *sc,
> int whichfork,
> xfs_fileoff_t offset)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_WARNING;
> - trace_xfs_scrub_fblock_warning(sc, whichfork, offset, __return_address);
> + trace_xchk_fblock_warning(sc, whichfork, offset, __return_address);
> }
>
> /* Signal an incomplete scrub. */
> void
> -xfs_scrub_set_incomplete(
> +xchk_set_incomplete(
> struct xfs_scrub_context *sc)
> {
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_INCOMPLETE;
> - trace_xfs_scrub_incomplete(sc, __return_address);
> + trace_xchk_incomplete(sc, __return_address);
> }
>
> /*
> @@ -312,18 +312,18 @@ xfs_scrub_set_incomplete(
> * at least according to the reverse mapping data.
> */
>
> -struct xfs_scrub_rmap_ownedby_info {
> +struct xchk_rmap_ownedby_info {
> struct xfs_owner_info *oinfo;
> xfs_filblks_t *blocks;
> };
>
> STATIC int
> -xfs_scrub_count_rmap_ownedby_irec(
> +xchk_count_rmap_ownedby_irec(
> struct xfs_btree_cur *cur,
> struct xfs_rmap_irec *rec,
> void *priv)
> {
> - struct xfs_scrub_rmap_ownedby_info *sroi = priv;
> + struct xchk_rmap_ownedby_info *sroi = priv;
> bool irec_attr;
> bool oinfo_attr;
>
> @@ -344,19 +344,19 @@ xfs_scrub_count_rmap_ownedby_irec(
> * The caller should pass us an rmapbt cursor.
> */
> int
> -xfs_scrub_count_rmap_ownedby_ag(
> +xchk_count_rmap_ownedby_ag(
> struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> struct xfs_owner_info *oinfo,
> xfs_filblks_t *blocks)
> {
> - struct xfs_scrub_rmap_ownedby_info sroi;
> + struct xchk_rmap_ownedby_info sroi;
>
> sroi.oinfo = oinfo;
> *blocks = 0;
> sroi.blocks = blocks;
>
> - return xfs_rmap_query_all(cur, xfs_scrub_count_rmap_ownedby_irec,
> + return xfs_rmap_query_all(cur, xchk_count_rmap_ownedby_irec,
> &sroi);
> }
>
> @@ -392,12 +392,12 @@ want_ag_read_header_failure(
> /*
> * Grab all the headers for an AG.
> *
> - * The headers should be released by xfs_scrub_ag_free, but as a fail
> + * The headers should be released by xchk_ag_free, but as a fail
> * safe we attach all the buffers we grab to the scrub transaction so
> * they'll all be freed when we cancel it.
> */
> int
> -xfs_scrub_ag_read_headers(
> +xchk_ag_read_headers(
> struct xfs_scrub_context *sc,
> xfs_agnumber_t agno,
> struct xfs_buf **agi,
> @@ -425,8 +425,8 @@ xfs_scrub_ag_read_headers(
>
> /* Release all the AG btree cursors. */
> void
> -xfs_scrub_ag_btcur_free(
> - struct xfs_scrub_ag *sa)
> +xchk_ag_btcur_free(
> + struct xchk_ag *sa)
> {
> if (sa->refc_cur)
> xfs_btree_del_cursor(sa->refc_cur, XFS_BTREE_ERROR);
> @@ -451,9 +451,9 @@ xfs_scrub_ag_btcur_free(
>
> /* Initialize all the btree cursors for an AG. */
> int
> -xfs_scrub_ag_btcur_init(
> +xchk_ag_btcur_init(
> struct xfs_scrub_context *sc,
> - struct xfs_scrub_ag *sa)
> + struct xchk_ag *sa)
> {
> struct xfs_mount *mp = sc->mp;
> xfs_agnumber_t agno = sa->agno;
> @@ -511,11 +511,11 @@ xfs_scrub_ag_btcur_init(
>
> /* Release the AG header context and btree cursors. */
> void
> -xfs_scrub_ag_free(
> +xchk_ag_free(
> struct xfs_scrub_context *sc,
> - struct xfs_scrub_ag *sa)
> + struct xchk_ag *sa)
> {
> - xfs_scrub_ag_btcur_free(sa);
> + xchk_ag_btcur_free(sa);
> if (sa->agfl_bp) {
> xfs_trans_brelse(sc->tp, sa->agfl_bp);
> sa->agfl_bp = NULL;
> @@ -543,30 +543,30 @@ xfs_scrub_ag_free(
> * transaction ourselves.
> */
> int
> -xfs_scrub_ag_init(
> +xchk_ag_init(
> struct xfs_scrub_context *sc,
> xfs_agnumber_t agno,
> - struct xfs_scrub_ag *sa)
> + struct xchk_ag *sa)
> {
> int error;
>
> sa->agno = agno;
> - error = xfs_scrub_ag_read_headers(sc, agno, &sa->agi_bp,
> + error = xchk_ag_read_headers(sc, agno, &sa->agi_bp,
> &sa->agf_bp, &sa->agfl_bp);
> if (error)
> return error;
>
> - return xfs_scrub_ag_btcur_init(sc, sa);
> + return xchk_ag_btcur_init(sc, sa);
> }
>
> /*
> * Grab the per-ag structure if we haven't already gotten it. Teardown of the
> - * xfs_scrub_ag will release it for us.
> + * xchk_ag will release it for us.
> */
> void
> -xfs_scrub_perag_get(
> +xchk_perag_get(
> struct xfs_mount *mp,
> - struct xfs_scrub_ag *sa)
> + struct xchk_ag *sa)
> {
> if (!sa->pag)
> sa->pag = xfs_perag_get(mp, sa->agno);
> @@ -585,7 +585,7 @@ xfs_scrub_perag_get(
> * the metadata object.
> */
> int
> -xfs_scrub_trans_alloc(
> +xchk_trans_alloc(
> struct xfs_scrub_context *sc,
> uint resblks)
> {
> @@ -598,19 +598,19 @@ xfs_scrub_trans_alloc(
>
> /* Set us up with a transaction and an empty context. */
> int
> -xfs_scrub_setup_fs(
> +xchk_setup_fs(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> uint resblks;
>
> resblks = xfs_repair_calc_ag_resblks(sc);
> - return xfs_scrub_trans_alloc(sc, resblks);
> + return xchk_trans_alloc(sc, resblks);
> }
>
> /* Set us up with AG headers and btree cursors. */
> int
> -xfs_scrub_setup_ag_btree(
> +xchk_setup_ag_btree(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip,
> bool force_log)
> @@ -625,21 +625,21 @@ xfs_scrub_setup_ag_btree(
> * document why they need to do so.
> */
> if (force_log) {
> - error = xfs_scrub_checkpoint_log(mp);
> + error = xchk_checkpoint_log(mp);
> if (error)
> return error;
> }
>
> - error = xfs_scrub_setup_fs(sc, ip);
> + error = xchk_setup_fs(sc, ip);
> if (error)
> return error;
>
> - return xfs_scrub_ag_init(sc, sc->sm->sm_agno, &sc->sa);
> + return xchk_ag_init(sc, sc->sm->sm_agno, &sc->sa);
> }
>
> /* Push everything out of the log onto disk. */
> int
> -xfs_scrub_checkpoint_log(
> +xchk_checkpoint_log(
> struct xfs_mount *mp)
> {
> int error;
> @@ -657,7 +657,7 @@ xfs_scrub_checkpoint_log(
> * The inode is not locked.
> */
> int
> -xfs_scrub_get_inode(
> +xchk_get_inode(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip_in)
> {
> @@ -704,7 +704,7 @@ xfs_scrub_get_inode(
> error = -EFSCORRUPTED;
> /* fall through */
> default:
> - trace_xfs_scrub_op_error(sc,
> + trace_xchk_op_error(sc,
> XFS_INO_TO_AGNO(mp, sc->sm->sm_ino),
> XFS_INO_TO_AGBNO(mp, sc->sm->sm_ino),
> error, __return_address);
> @@ -721,21 +721,21 @@ xfs_scrub_get_inode(
>
> /* Set us up to scrub a file's contents. */
> int
> -xfs_scrub_setup_inode_contents(
> +xchk_setup_inode_contents(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip,
> unsigned int resblks)
> {
> int error;
>
> - error = xfs_scrub_get_inode(sc, ip);
> + error = xchk_get_inode(sc, ip);
> if (error)
> return error;
>
> /* Got the inode, lock it and we're ready to go. */
> sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
> xfs_ilock(sc->ip, sc->ilock_flags);
> - error = xfs_scrub_trans_alloc(sc, resblks);
> + error = xchk_trans_alloc(sc, resblks);
> if (error)
> goto out;
> sc->ilock_flags |= XFS_ILOCK_EXCL;
> @@ -752,13 +752,13 @@ xfs_scrub_setup_inode_contents(
> * the cursor and skip the check.
> */
> bool
> -xfs_scrub_should_check_xref(
> +xchk_should_check_xref(
> struct xfs_scrub_context *sc,
> int *error,
> struct xfs_btree_cur **curpp)
> {
> /* No point in xref if we already know we're corrupt. */
> - if (xfs_scrub_skip_xref(sc->sm))
> + if (xchk_skip_xref(sc->sm))
> return false;
>
> if (*error == 0)
> @@ -775,7 +775,7 @@ xfs_scrub_should_check_xref(
> }
>
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_XFAIL;
> - trace_xfs_scrub_xref_error(sc, *error, __return_address);
> + trace_xchk_xref_error(sc, *error, __return_address);
>
> /*
> * Errors encountered during cross-referencing with another
> @@ -787,25 +787,25 @@ xfs_scrub_should_check_xref(
>
> /* Run the structure verifiers on in-memory buffers to detect bad memory. */
> void
> -xfs_scrub_buffer_recheck(
> +xchk_buffer_recheck(
> struct xfs_scrub_context *sc,
> struct xfs_buf *bp)
> {
> xfs_failaddr_t fa;
>
> if (bp->b_ops == NULL) {
> - xfs_scrub_block_set_corrupt(sc, bp);
> + xchk_block_set_corrupt(sc, bp);
> return;
> }
> if (bp->b_ops->verify_struct == NULL) {
> - xfs_scrub_set_incomplete(sc);
> + xchk_set_incomplete(sc);
> return;
> }
> fa = bp->b_ops->verify_struct(bp);
> if (!fa)
> return;
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
> - trace_xfs_scrub_block_error(sc, bp->b_bn, fa);
> + trace_xchk_block_error(sc, bp->b_bn, fa);
> }
>
> /*
> @@ -813,7 +813,7 @@ xfs_scrub_buffer_recheck(
> * pointed to by sc->ip and the ILOCK must be held.
> */
> int
> -xfs_scrub_metadata_inode_forks(
> +xchk_metadata_inode_forks(
> struct xfs_scrub_context *sc)
> {
> __u32 smtype;
> @@ -825,26 +825,26 @@ xfs_scrub_metadata_inode_forks(
>
> /* Metadata inodes don't live on the rt device. */
> if (sc->ip->i_d.di_flags & XFS_DIFLAG_REALTIME) {
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> return 0;
> }
>
> /* They should never participate in reflink. */
> if (xfs_is_reflink_inode(sc->ip)) {
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> return 0;
> }
>
> /* They also should never have extended attributes. */
> if (xfs_inode_hasattr(sc->ip)) {
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> return 0;
> }
>
> /* Invoke the data fork scrubber. */
> smtype = sc->sm->sm_type;
> sc->sm->sm_type = XFS_SCRUB_TYPE_BMBTD;
> - error = xfs_scrub_bmap_data(sc);
> + error = xchk_bmap_data(sc);
> sc->sm->sm_type = smtype;
> if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> return error;
> @@ -853,11 +853,11 @@ xfs_scrub_metadata_inode_forks(
> if (xfs_sb_version_hasreflink(&sc->mp->m_sb)) {
> error = xfs_reflink_inode_has_shared_extents(sc->tp, sc->ip,
> &shared);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0,
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0,
> &error))
> return error;
> if (shared)
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> }
>
> return error;
> @@ -871,7 +871,7 @@ xfs_scrub_metadata_inode_forks(
> * we can't.
> */
> int
> -xfs_scrub_ilock_inverted(
> +xchk_ilock_inverted(
> struct xfs_inode *ip,
> uint lock_mode)
> {
> diff --git a/fs/xfs/scrub/common.h b/fs/xfs/scrub/common.h
> index 2172bd5361e2..5881cb2ecc26 100644
> --- a/fs/xfs/scrub/common.h
> +++ b/fs/xfs/scrub/common.h
> @@ -12,7 +12,7 @@
> * Note that we're careful not to make any judgements about *error.
> */
> static inline bool
> -xfs_scrub_should_terminate(
> +xchk_should_terminate(
> struct xfs_scrub_context *sc,
> int *error)
> {
> @@ -24,121 +24,121 @@ xfs_scrub_should_terminate(
> return false;
> }
>
> -int xfs_scrub_trans_alloc(struct xfs_scrub_context *sc, uint resblks);
> -bool xfs_scrub_process_error(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> +int xchk_trans_alloc(struct xfs_scrub_context *sc, uint resblks);
> +bool xchk_process_error(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> xfs_agblock_t bno, int *error);
> -bool xfs_scrub_fblock_process_error(struct xfs_scrub_context *sc, int whichfork,
> +bool xchk_fblock_process_error(struct xfs_scrub_context *sc, int whichfork,
> xfs_fileoff_t offset, int *error);
>
> -bool xfs_scrub_xref_process_error(struct xfs_scrub_context *sc,
> +bool xchk_xref_process_error(struct xfs_scrub_context *sc,
> xfs_agnumber_t agno, xfs_agblock_t bno, int *error);
> -bool xfs_scrub_fblock_xref_process_error(struct xfs_scrub_context *sc,
> +bool xchk_fblock_xref_process_error(struct xfs_scrub_context *sc,
> int whichfork, xfs_fileoff_t offset, int *error);
>
> -void xfs_scrub_block_set_preen(struct xfs_scrub_context *sc,
> +void xchk_block_set_preen(struct xfs_scrub_context *sc,
> struct xfs_buf *bp);
> -void xfs_scrub_ino_set_preen(struct xfs_scrub_context *sc, xfs_ino_t ino);
> +void xchk_ino_set_preen(struct xfs_scrub_context *sc, xfs_ino_t ino);
>
> -void xfs_scrub_block_set_corrupt(struct xfs_scrub_context *sc,
> +void xchk_block_set_corrupt(struct xfs_scrub_context *sc,
> struct xfs_buf *bp);
> -void xfs_scrub_ino_set_corrupt(struct xfs_scrub_context *sc, xfs_ino_t ino);
> -void xfs_scrub_fblock_set_corrupt(struct xfs_scrub_context *sc, int whichfork,
> +void xchk_ino_set_corrupt(struct xfs_scrub_context *sc, xfs_ino_t ino);
> +void xchk_fblock_set_corrupt(struct xfs_scrub_context *sc, int whichfork,
> xfs_fileoff_t offset);
>
> -void xfs_scrub_block_xref_set_corrupt(struct xfs_scrub_context *sc,
> +void xchk_block_xref_set_corrupt(struct xfs_scrub_context *sc,
> struct xfs_buf *bp);
> -void xfs_scrub_ino_xref_set_corrupt(struct xfs_scrub_context *sc,
> +void xchk_ino_xref_set_corrupt(struct xfs_scrub_context *sc,
> xfs_ino_t ino);
> -void xfs_scrub_fblock_xref_set_corrupt(struct xfs_scrub_context *sc,
> +void xchk_fblock_xref_set_corrupt(struct xfs_scrub_context *sc,
> int whichfork, xfs_fileoff_t offset);
>
> -void xfs_scrub_ino_set_warning(struct xfs_scrub_context *sc, xfs_ino_t ino);
> -void xfs_scrub_fblock_set_warning(struct xfs_scrub_context *sc, int whichfork,
> +void xchk_ino_set_warning(struct xfs_scrub_context *sc, xfs_ino_t ino);
> +void xchk_fblock_set_warning(struct xfs_scrub_context *sc, int whichfork,
> xfs_fileoff_t offset);
>
> -void xfs_scrub_set_incomplete(struct xfs_scrub_context *sc);
> -int xfs_scrub_checkpoint_log(struct xfs_mount *mp);
> +void xchk_set_incomplete(struct xfs_scrub_context *sc);
> +int xchk_checkpoint_log(struct xfs_mount *mp);
>
> /* Are we set up for a cross-referencing check? */
> -bool xfs_scrub_should_check_xref(struct xfs_scrub_context *sc, int *error,
> +bool xchk_should_check_xref(struct xfs_scrub_context *sc, int *error,
> struct xfs_btree_cur **curpp);
>
> /* Setup functions */
> -int xfs_scrub_setup_fs(struct xfs_scrub_context *sc, struct xfs_inode *ip);
> -int xfs_scrub_setup_ag_allocbt(struct xfs_scrub_context *sc,
> +int xchk_setup_fs(struct xfs_scrub_context *sc, struct xfs_inode *ip);
> +int xchk_setup_ag_allocbt(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_ag_iallocbt(struct xfs_scrub_context *sc,
> +int xchk_setup_ag_iallocbt(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_ag_rmapbt(struct xfs_scrub_context *sc,
> +int xchk_setup_ag_rmapbt(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_ag_refcountbt(struct xfs_scrub_context *sc,
> +int xchk_setup_ag_refcountbt(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_inode(struct xfs_scrub_context *sc,
> +int xchk_setup_inode(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_inode_bmap(struct xfs_scrub_context *sc,
> +int xchk_setup_inode_bmap(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_inode_bmap_data(struct xfs_scrub_context *sc,
> +int xchk_setup_inode_bmap_data(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_directory(struct xfs_scrub_context *sc,
> +int xchk_setup_directory(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_xattr(struct xfs_scrub_context *sc,
> +int xchk_setup_xattr(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_symlink(struct xfs_scrub_context *sc,
> +int xchk_setup_symlink(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> -int xfs_scrub_setup_parent(struct xfs_scrub_context *sc,
> +int xchk_setup_parent(struct xfs_scrub_context *sc,
> struct xfs_inode *ip);
> #ifdef CONFIG_XFS_RT
> -int xfs_scrub_setup_rt(struct xfs_scrub_context *sc, struct xfs_inode *ip);
> +int xchk_setup_rt(struct xfs_scrub_context *sc, struct xfs_inode *ip);
> #else
> static inline int
> -xfs_scrub_setup_rt(struct xfs_scrub_context *sc, struct xfs_inode *ip)
> +xchk_setup_rt(struct xfs_scrub_context *sc, struct xfs_inode *ip)
> {
> return -ENOENT;
> }
> #endif
> #ifdef CONFIG_XFS_QUOTA
> -int xfs_scrub_setup_quota(struct xfs_scrub_context *sc, struct xfs_inode *ip);
> +int xchk_setup_quota(struct xfs_scrub_context *sc, struct xfs_inode *ip);
> #else
> static inline int
> -xfs_scrub_setup_quota(struct xfs_scrub_context *sc, struct xfs_inode *ip)
> +xchk_setup_quota(struct xfs_scrub_context *sc, struct xfs_inode *ip)
> {
> return -ENOENT;
> }
> #endif
>
> -void xfs_scrub_ag_free(struct xfs_scrub_context *sc, struct xfs_scrub_ag *sa);
> -int xfs_scrub_ag_init(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> - struct xfs_scrub_ag *sa);
> -void xfs_scrub_perag_get(struct xfs_mount *mp, struct xfs_scrub_ag *sa);
> -int xfs_scrub_ag_read_headers(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> +void xchk_ag_free(struct xfs_scrub_context *sc, struct xchk_ag *sa);
> +int xchk_ag_init(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> + struct xchk_ag *sa);
> +void xchk_perag_get(struct xfs_mount *mp, struct xchk_ag *sa);
> +int xchk_ag_read_headers(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> struct xfs_buf **agi, struct xfs_buf **agf,
> struct xfs_buf **agfl);
> -void xfs_scrub_ag_btcur_free(struct xfs_scrub_ag *sa);
> -int xfs_scrub_ag_btcur_init(struct xfs_scrub_context *sc,
> - struct xfs_scrub_ag *sa);
> -int xfs_scrub_count_rmap_ownedby_ag(struct xfs_scrub_context *sc,
> +void xchk_ag_btcur_free(struct xchk_ag *sa);
> +int xchk_ag_btcur_init(struct xfs_scrub_context *sc,
> + struct xchk_ag *sa);
> +int xchk_count_rmap_ownedby_ag(struct xfs_scrub_context *sc,
> struct xfs_btree_cur *cur,
> struct xfs_owner_info *oinfo,
> xfs_filblks_t *blocks);
>
> -int xfs_scrub_setup_ag_btree(struct xfs_scrub_context *sc,
> +int xchk_setup_ag_btree(struct xfs_scrub_context *sc,
> struct xfs_inode *ip, bool force_log);
> -int xfs_scrub_get_inode(struct xfs_scrub_context *sc, struct xfs_inode *ip_in);
> -int xfs_scrub_setup_inode_contents(struct xfs_scrub_context *sc,
> +int xchk_get_inode(struct xfs_scrub_context *sc, struct xfs_inode *ip_in);
> +int xchk_setup_inode_contents(struct xfs_scrub_context *sc,
> struct xfs_inode *ip, unsigned int resblks);
> -void xfs_scrub_buffer_recheck(struct xfs_scrub_context *sc, struct xfs_buf *bp);
> +void xchk_buffer_recheck(struct xfs_scrub_context *sc, struct xfs_buf *bp);
>
> /*
> * Don't bother cross-referencing if we already found corruption or cross
> * referencing discrepancies.
> */
> -static inline bool xfs_scrub_skip_xref(struct xfs_scrub_metadata *sm)
> +static inline bool xchk_skip_xref(struct xfs_scrub_metadata *sm)
> {
> return sm->sm_flags & (XFS_SCRUB_OFLAG_CORRUPT |
> XFS_SCRUB_OFLAG_XCORRUPT);
> }
>
> -int xfs_scrub_metadata_inode_forks(struct xfs_scrub_context *sc);
> -int xfs_scrub_ilock_inverted(struct xfs_inode *ip, uint lock_mode);
> +int xchk_metadata_inode_forks(struct xfs_scrub_context *sc);
> +int xchk_ilock_inverted(struct xfs_inode *ip, uint lock_mode);
>
> #endif /* __XFS_SCRUB_COMMON_H__ */
> diff --git a/fs/xfs/scrub/dabtree.c b/fs/xfs/scrub/dabtree.c
> index d700c4d4d4ef..fee80f6ddfd7 100644
> --- a/fs/xfs/scrub/dabtree.c
> +++ b/fs/xfs/scrub/dabtree.c
> @@ -35,8 +35,8 @@
> * operational errors in common.c.
> */
> bool
> -xfs_scrub_da_process_error(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_process_error(
> + struct xchk_da_btree *ds,
> int level,
> int *error)
> {
> @@ -48,7 +48,7 @@ xfs_scrub_da_process_error(
> switch (*error) {
> case -EDEADLOCK:
> /* Used to restart an op with deadlock avoidance. */
> - trace_xfs_scrub_deadlock_retry(sc->ip, sc->sm, *error);
> + trace_xchk_deadlock_retry(sc->ip, sc->sm, *error);
> break;
> case -EFSBADCRC:
> case -EFSCORRUPTED:
> @@ -57,7 +57,7 @@ xfs_scrub_da_process_error(
> *error = 0;
> /* fall through */
> default:
> - trace_xfs_scrub_file_op_error(sc, ds->dargs.whichfork,
> + trace_xchk_file_op_error(sc, ds->dargs.whichfork,
> xfs_dir2_da_to_db(ds->dargs.geo,
> ds->state->path.blk[level].blkno),
> *error, __return_address);
> @@ -71,15 +71,15 @@ xfs_scrub_da_process_error(
> * operational errors in common.c.
> */
> void
> -xfs_scrub_da_set_corrupt(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_set_corrupt(
> + struct xchk_da_btree *ds,
> int level)
> {
> struct xfs_scrub_context *sc = ds->sc;
>
> sc->sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
>
> - trace_xfs_scrub_fblock_error(sc, ds->dargs.whichfork,
> + trace_xchk_fblock_error(sc, ds->dargs.whichfork,
> xfs_dir2_da_to_db(ds->dargs.geo,
> ds->state->path.blk[level].blkno),
> __return_address);
> @@ -87,8 +87,8 @@ xfs_scrub_da_set_corrupt(
>
> /* Find an entry at a certain level in a da btree. */
> STATIC void *
> -xfs_scrub_da_btree_entry(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_btree_entry(
> + struct xchk_da_btree *ds,
> int level,
> int rec)
> {
> @@ -123,8 +123,8 @@ xfs_scrub_da_btree_entry(
>
> /* Scrub a da btree hash (key). */
> int
> -xfs_scrub_da_btree_hash(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_btree_hash(
> + struct xchk_da_btree *ds,
> int level,
> __be32 *hashp)
> {
> @@ -136,7 +136,7 @@ xfs_scrub_da_btree_hash(
> /* Is this hash in order? */
> hash = be32_to_cpu(*hashp);
> if (hash < ds->hashes[level])
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> ds->hashes[level] = hash;
>
> if (level == 0)
> @@ -144,10 +144,10 @@ xfs_scrub_da_btree_hash(
>
> /* Is this hash no larger than the parent hash? */
> blks = ds->state->path.blk;
> - entry = xfs_scrub_da_btree_entry(ds, level - 1, blks[level - 1].index);
> + entry = xchk_da_btree_entry(ds, level - 1, blks[level - 1].index);
> parent_hash = be32_to_cpu(entry->hashval);
> if (parent_hash < hash)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> return 0;
> }
> @@ -157,13 +157,13 @@ xfs_scrub_da_btree_hash(
> * pointer.
> */
> STATIC bool
> -xfs_scrub_da_btree_ptr_ok(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_btree_ptr_ok(
> + struct xchk_da_btree *ds,
> int level,
> xfs_dablk_t blkno)
> {
> if (blkno < ds->lowest || (ds->highest != 0 && blkno >= ds->highest)) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> return false;
> }
>
> @@ -176,7 +176,7 @@ xfs_scrub_da_btree_ptr_ok(
> * leaf1, we must multiplex the verifiers.
> */
> static void
> -xfs_scrub_da_btree_read_verify(
> +xchk_da_btree_read_verify(
> struct xfs_buf *bp)
> {
> struct xfs_da_blkinfo *info = bp->b_addr;
> @@ -198,7 +198,7 @@ xfs_scrub_da_btree_read_verify(
> }
> }
> static void
> -xfs_scrub_da_btree_write_verify(
> +xchk_da_btree_write_verify(
> struct xfs_buf *bp)
> {
> struct xfs_da_blkinfo *info = bp->b_addr;
> @@ -220,7 +220,7 @@ xfs_scrub_da_btree_write_verify(
> }
> }
> static void *
> -xfs_scrub_da_btree_verify(
> +xchk_da_btree_verify(
> struct xfs_buf *bp)
> {
> struct xfs_da_blkinfo *info = bp->b_addr;
> @@ -236,17 +236,17 @@ xfs_scrub_da_btree_verify(
> }
> }
>
> -static const struct xfs_buf_ops xfs_scrub_da_btree_buf_ops = {
> - .name = "xfs_scrub_da_btree",
> - .verify_read = xfs_scrub_da_btree_read_verify,
> - .verify_write = xfs_scrub_da_btree_write_verify,
> - .verify_struct = xfs_scrub_da_btree_verify,
> +static const struct xfs_buf_ops xchk_da_btree_buf_ops = {
> + .name = "xchk_da_btree",
> + .verify_read = xchk_da_btree_read_verify,
> + .verify_write = xchk_da_btree_write_verify,
> + .verify_struct = xchk_da_btree_verify,
> };
>
> /* Check a block's sibling. */
> STATIC int
> -xfs_scrub_da_btree_block_check_sibling(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_btree_block_check_sibling(
> + struct xchk_da_btree *ds,
> int level,
> int direction,
> xfs_dablk_t sibling)
> @@ -265,7 +265,7 @@ xfs_scrub_da_btree_block_check_sibling(
> error = xfs_da3_path_shift(ds->state, &ds->state->altpath,
> direction, false, &retval);
> if (error == 0 && retval == 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> error = 0;
> goto out;
> }
> @@ -273,19 +273,19 @@ xfs_scrub_da_btree_block_check_sibling(
> /* Move the alternate cursor one block in the direction given. */
> error = xfs_da3_path_shift(ds->state, &ds->state->altpath,
> direction, false, &retval);
> - if (!xfs_scrub_da_process_error(ds, level, &error))
> + if (!xchk_da_process_error(ds, level, &error))
> return error;
> if (retval) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> return error;
> }
> if (ds->state->altpath.blk[level].bp)
> - xfs_scrub_buffer_recheck(ds->sc,
> + xchk_buffer_recheck(ds->sc,
> ds->state->altpath.blk[level].bp);
>
> /* Compare upper level pointer to sibling pointer. */
> if (ds->state->altpath.blk[level].blkno != sibling)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> xfs_trans_brelse(ds->dargs.trans, ds->state->altpath.blk[level].bp);
> out:
> return error;
> @@ -293,8 +293,8 @@ xfs_scrub_da_btree_block_check_sibling(
>
> /* Check a block's sibling pointers. */
> STATIC int
> -xfs_scrub_da_btree_block_check_siblings(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_btree_block_check_siblings(
> + struct xchk_da_btree *ds,
> int level,
> struct xfs_da_blkinfo *hdr)
> {
> @@ -308,7 +308,7 @@ xfs_scrub_da_btree_block_check_siblings(
> /* Top level blocks should not have sibling pointers. */
> if (level == 0) {
> if (forw != 0 || back != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> return 0;
> }
>
> @@ -316,10 +316,10 @@ xfs_scrub_da_btree_block_check_siblings(
> * Check back (left) and forw (right) pointers. These functions
> * absorb error codes for us.
> */
> - error = xfs_scrub_da_btree_block_check_sibling(ds, level, 0, back);
> + error = xchk_da_btree_block_check_sibling(ds, level, 0, back);
> if (error)
> goto out;
> - error = xfs_scrub_da_btree_block_check_sibling(ds, level, 1, forw);
> + error = xchk_da_btree_block_check_sibling(ds, level, 1, forw);
>
> out:
> memset(&ds->state->altpath, 0, sizeof(ds->state->altpath));
> @@ -328,8 +328,8 @@ xfs_scrub_da_btree_block_check_siblings(
>
> /* Load a dir/attribute block from a btree. */
> STATIC int
> -xfs_scrub_da_btree_block(
> - struct xfs_scrub_da_btree *ds,
> +xchk_da_btree_block(
> + struct xchk_da_btree *ds,
> int level,
> xfs_dablk_t blkno)
> {
> @@ -355,17 +355,17 @@ xfs_scrub_da_btree_block(
>
> /* Check the pointer. */
> blk->blkno = blkno;
> - if (!xfs_scrub_da_btree_ptr_ok(ds, level, blkno))
> + if (!xchk_da_btree_ptr_ok(ds, level, blkno))
> goto out_nobuf;
>
> /* Read the buffer. */
> error = xfs_da_read_buf(dargs->trans, dargs->dp, blk->blkno, -2,
> &blk->bp, dargs->whichfork,
> - &xfs_scrub_da_btree_buf_ops);
> - if (!xfs_scrub_da_process_error(ds, level, &error))
> + &xchk_da_btree_buf_ops);
> + if (!xchk_da_process_error(ds, level, &error))
> goto out_nobuf;
> if (blk->bp)
> - xfs_scrub_buffer_recheck(ds->sc, blk->bp);
> + xchk_buffer_recheck(ds->sc, blk->bp);
>
> /*
> * We didn't find a dir btree root block, which means that
> @@ -378,7 +378,7 @@ xfs_scrub_da_btree_block(
>
> /* It's /not/ ok for attr trees not to have a da btree. */
> if (blk->bp == NULL) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out_nobuf;
> }
>
> @@ -388,17 +388,17 @@ xfs_scrub_da_btree_block(
>
> /* We only started zeroing the header on v5 filesystems. */
> if (xfs_sb_version_hascrc(&ds->sc->mp->m_sb) && hdr3->hdr.pad)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
>
> /* Check the owner. */
> if (xfs_sb_version_hascrc(&ip->i_mount->m_sb)) {
> owner = be64_to_cpu(hdr3->owner);
> if (owner != ip->i_ino)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> }
>
> /* Check the siblings. */
> - error = xfs_scrub_da_btree_block_check_siblings(ds, level, &hdr3->hdr);
> + error = xchk_da_btree_block_check_siblings(ds, level, &hdr3->hdr);
> if (error)
> goto out;
>
> @@ -411,7 +411,7 @@ xfs_scrub_da_btree_block(
> blk->magic = XFS_ATTR_LEAF_MAGIC;
> blk->hashval = xfs_attr_leaf_lasthash(blk->bp, pmaxrecs);
> if (ds->tree_level != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> break;
> case XFS_DIR2_LEAFN_MAGIC:
> case XFS_DIR3_LEAFN_MAGIC:
> @@ -420,7 +420,7 @@ xfs_scrub_da_btree_block(
> blk->magic = XFS_DIR2_LEAFN_MAGIC;
> blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
> if (ds->tree_level != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> break;
> case XFS_DIR2_LEAF1_MAGIC:
> case XFS_DIR3_LEAF1_MAGIC:
> @@ -429,7 +429,7 @@ xfs_scrub_da_btree_block(
> blk->magic = XFS_DIR2_LEAF1_MAGIC;
> blk->hashval = xfs_dir2_leaf_lasthash(ip, blk->bp, pmaxrecs);
> if (ds->tree_level != 0)
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> break;
> case XFS_DA_NODE_MAGIC:
> case XFS_DA3_NODE_MAGIC:
> @@ -443,13 +443,13 @@ xfs_scrub_da_btree_block(
> blk->hashval = be32_to_cpu(btree[*pmaxrecs - 1].hashval);
> if (level == 0) {
> if (nodehdr.level >= XFS_DA_NODE_MAXDEPTH) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out_freebp;
> }
> ds->tree_level = nodehdr.level;
> } else {
> if (ds->tree_level != nodehdr.level) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out_freebp;
> }
> }
> @@ -457,7 +457,7 @@ xfs_scrub_da_btree_block(
> /* XXX: Check hdr3.pad32 once we know how to fix it. */
> break;
> default:
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out_freebp;
> }
>
> @@ -473,13 +473,13 @@ xfs_scrub_da_btree_block(
>
> /* Visit all nodes and leaves of a da btree. */
> int
> -xfs_scrub_da_btree(
> +xchk_da_btree(
> struct xfs_scrub_context *sc,
> int whichfork,
> - xfs_scrub_da_btree_rec_fn scrub_fn,
> + xchk_da_btree_rec_fn scrub_fn,
> void *private)
> {
> - struct xfs_scrub_da_btree ds = {};
> + struct xchk_da_btree ds = {};
> struct xfs_mount *mp = sc->mp;
> struct xfs_da_state_blk *blks;
> struct xfs_da_node_entry *key;
> @@ -517,7 +517,7 @@ xfs_scrub_da_btree(
>
> /* Find the root of the da tree, if present. */
> blks = ds.state->path.blk;
> - error = xfs_scrub_da_btree_block(&ds, level, blkno);
> + error = xchk_da_btree_block(&ds, level, blkno);
> if (error)
> goto out_state;
> /*
> @@ -542,12 +542,12 @@ xfs_scrub_da_btree(
> }
>
> /* Dispatch record scrubbing. */
> - rec = xfs_scrub_da_btree_entry(&ds, level,
> + rec = xchk_da_btree_entry(&ds, level,
> blks[level].index);
> error = scrub_fn(&ds, level, rec);
> if (error)
> break;
> - if (xfs_scrub_should_terminate(sc, &error) ||
> + if (xchk_should_terminate(sc, &error) ||
> (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> break;
>
> @@ -566,8 +566,8 @@ xfs_scrub_da_btree(
> }
>
> /* Hashes in order for scrub? */
> - key = xfs_scrub_da_btree_entry(&ds, level, blks[level].index);
> - error = xfs_scrub_da_btree_hash(&ds, level, &key->hashval);
> + key = xchk_da_btree_entry(&ds, level, blks[level].index);
> + error = xchk_da_btree_hash(&ds, level, &key->hashval);
> if (error)
> goto out;
>
> @@ -575,7 +575,7 @@ xfs_scrub_da_btree(
> blkno = be32_to_cpu(key->before);
> level++;
> ds.tree_level--;
> - error = xfs_scrub_da_btree_block(&ds, level, blkno);
> + error = xchk_da_btree_block(&ds, level, blkno);
> if (error)
> goto out;
> if (blks[level].bp == NULL)
> diff --git a/fs/xfs/scrub/dabtree.h b/fs/xfs/scrub/dabtree.h
> index 365f9f0019e6..80e4af0e2589 100644
> --- a/fs/xfs/scrub/dabtree.h
> +++ b/fs/xfs/scrub/dabtree.h
> @@ -8,7 +8,7 @@
>
> /* dir/attr btree */
>
> -struct xfs_scrub_da_btree {
> +struct xchk_da_btree {
> struct xfs_da_args dargs;
> xfs_dahash_t hashes[XFS_DA_NODE_MAXDEPTH];
> int maxrecs[XFS_DA_NODE_MAXDEPTH];
> @@ -28,18 +28,18 @@ struct xfs_scrub_da_btree {
> int tree_level;
> };
>
> -typedef int (*xfs_scrub_da_btree_rec_fn)(struct xfs_scrub_da_btree *ds,
> +typedef int (*xchk_da_btree_rec_fn)(struct xchk_da_btree *ds,
> int level, void *rec);
>
> /* Check for da btree operation errors. */
> -bool xfs_scrub_da_process_error(struct xfs_scrub_da_btree *ds, int level, int *error);
> +bool xchk_da_process_error(struct xchk_da_btree *ds, int level, int *error);
>
> /* Check for da btree corruption. */
> -void xfs_scrub_da_set_corrupt(struct xfs_scrub_da_btree *ds, int level);
> +void xchk_da_set_corrupt(struct xchk_da_btree *ds, int level);
>
> -int xfs_scrub_da_btree_hash(struct xfs_scrub_da_btree *ds, int level,
> +int xchk_da_btree_hash(struct xchk_da_btree *ds, int level,
> __be32 *hashp);
> -int xfs_scrub_da_btree(struct xfs_scrub_context *sc, int whichfork,
> - xfs_scrub_da_btree_rec_fn scrub_fn, void *private);
> +int xchk_da_btree(struct xfs_scrub_context *sc, int whichfork,
> + xchk_da_btree_rec_fn scrub_fn, void *private);
>
> #endif /* __XFS_SCRUB_DABTREE_H__ */
> diff --git a/fs/xfs/scrub/dir.c b/fs/xfs/scrub/dir.c
> index 86324775fc9b..2ac07bb73478 100644
> --- a/fs/xfs/scrub/dir.c
> +++ b/fs/xfs/scrub/dir.c
> @@ -31,18 +31,18 @@
>
> /* Set us up to scrub directories. */
> int
> -xfs_scrub_setup_directory(
> +xchk_setup_directory(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> - return xfs_scrub_setup_inode_contents(sc, ip, 0);
> + return xchk_setup_inode_contents(sc, ip, 0);
> }
>
> /* Directories */
>
> /* Scrub a directory entry. */
>
> -struct xfs_scrub_dir_ctx {
> +struct xchk_dir_ctx {
> /* VFS fill-directory iterator */
> struct dir_context dir_iter;
>
> @@ -51,8 +51,8 @@ struct xfs_scrub_dir_ctx {
>
> /* Check that an inode's mode matches a given DT_ type. */
> STATIC int
> -xfs_scrub_dir_check_ftype(
> - struct xfs_scrub_dir_ctx *sdc,
> +xchk_dir_check_ftype(
> + struct xchk_dir_ctx *sdc,
> xfs_fileoff_t offset,
> xfs_ino_t inum,
> int dtype)
> @@ -64,7 +64,7 @@ xfs_scrub_dir_check_ftype(
>
> if (!xfs_sb_version_hasftype(&mp->m_sb)) {
> if (dtype != DT_UNKNOWN && dtype != DT_DIR)
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> offset);
> goto out;
> }
> @@ -78,7 +78,7 @@ xfs_scrub_dir_check_ftype(
> * inodes can trigger immediate inactive cleanup of the inode.
> */
> error = xfs_iget(mp, sdc->sc->tp, inum, 0, 0, &ip);
> - if (!xfs_scrub_fblock_xref_process_error(sdc->sc, XFS_DATA_FORK, offset,
> + if (!xchk_fblock_xref_process_error(sdc->sc, XFS_DATA_FORK, offset,
> &error))
> goto out;
>
> @@ -86,7 +86,7 @@ xfs_scrub_dir_check_ftype(
> ino_dtype = xfs_dir3_get_dtype(mp,
> xfs_mode_to_ftype(VFS_I(ip)->i_mode));
> if (ino_dtype != dtype)
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK, offset);
> iput(VFS_I(ip));
> out:
> return error;
> @@ -101,7 +101,7 @@ xfs_scrub_dir_check_ftype(
> * we can look up this filename. Finally, we check the ftype.
> */
> STATIC int
> -xfs_scrub_dir_actor(
> +xchk_dir_actor(
> struct dir_context *dir_iter,
> const char *name,
> int namelen,
> @@ -111,13 +111,13 @@ xfs_scrub_dir_actor(
> {
> struct xfs_mount *mp;
> struct xfs_inode *ip;
> - struct xfs_scrub_dir_ctx *sdc;
> + struct xchk_dir_ctx *sdc;
> struct xfs_name xname;
> xfs_ino_t lookup_ino;
> xfs_dablk_t offset;
> int error = 0;
>
> - sdc = container_of(dir_iter, struct xfs_scrub_dir_ctx, dir_iter);
> + sdc = container_of(dir_iter, struct xchk_dir_ctx, dir_iter);
> ip = sdc->sc->ip;
> mp = ip->i_mount;
> offset = xfs_dir2_db_to_da(mp->m_dir_geo,
> @@ -125,17 +125,17 @@ xfs_scrub_dir_actor(
>
> /* Does this inode number make sense? */
> if (!xfs_verify_dir_ino(mp, ino)) {
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK, offset);
> goto out;
> }
>
> if (!strncmp(".", name, namelen)) {
> /* If this is "." then check that the inum matches the dir. */
> if (xfs_sb_version_hasftype(&mp->m_sb) && type != DT_DIR)
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> offset);
> if (ino != ip->i_ino)
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> offset);
> } else if (!strncmp("..", name, namelen)) {
> /*
> @@ -143,10 +143,10 @@ xfs_scrub_dir_actor(
> * matches this dir.
> */
> if (xfs_sb_version_hasftype(&mp->m_sb) && type != DT_DIR)
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> offset);
> if (ip->i_ino == mp->m_sb.sb_rootino && ino != ip->i_ino)
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK,
> offset);
> }
>
> @@ -156,23 +156,23 @@ xfs_scrub_dir_actor(
> xname.type = XFS_DIR3_FT_UNKNOWN;
>
> error = xfs_dir_lookup(sdc->sc->tp, ip, &xname, &lookup_ino, NULL);
> - if (!xfs_scrub_fblock_process_error(sdc->sc, XFS_DATA_FORK, offset,
> + if (!xchk_fblock_process_error(sdc->sc, XFS_DATA_FORK, offset,
> &error))
> goto out;
> if (lookup_ino != ino) {
> - xfs_scrub_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sdc->sc, XFS_DATA_FORK, offset);
> goto out;
> }
>
> /* Verify the file type. This function absorbs error codes. */
> - error = xfs_scrub_dir_check_ftype(sdc, offset, lookup_ino, type);
> + error = xchk_dir_check_ftype(sdc, offset, lookup_ino, type);
> if (error)
> goto out;
> out:
> /*
> * A negative error code returned here is supposed to cause the
> * dir_emit caller (xfs_readdir) to abort the directory iteration
> - * and return zero to xfs_scrub_directory.
> + * and return zero to xchk_directory.
> */
> if (error == 0 && sdc->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return -EFSCORRUPTED;
> @@ -181,8 +181,8 @@ xfs_scrub_dir_actor(
>
> /* Scrub a directory btree record. */
> STATIC int
> -xfs_scrub_dir_rec(
> - struct xfs_scrub_da_btree *ds,
> +xchk_dir_rec(
> + struct xchk_da_btree *ds,
> int level,
> void *rec)
> {
> @@ -203,7 +203,7 @@ xfs_scrub_dir_rec(
> int error;
>
> /* Check the hash of the entry. */
> - error = xfs_scrub_da_btree_hash(ds, level, &ent->hashval);
> + error = xchk_da_btree_hash(ds, level, &ent->hashval);
> if (error)
> goto out;
>
> @@ -218,18 +218,18 @@ xfs_scrub_dir_rec(
> rec_bno = xfs_dir2_db_to_da(mp->m_dir_geo, db);
>
> if (rec_bno >= mp->m_dir_geo->leafblk) {
> - xfs_scrub_da_set_corrupt(ds, level);
> + xchk_da_set_corrupt(ds, level);
> goto out;
> }
> error = xfs_dir3_data_read(ds->dargs.trans, dp, rec_bno, -2, &bp);
> - if (!xfs_scrub_fblock_process_error(ds->sc, XFS_DATA_FORK, rec_bno,
> + if (!xchk_fblock_process_error(ds->sc, XFS_DATA_FORK, rec_bno,
> &error))
> goto out;
> if (!bp) {
> - xfs_scrub_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> + xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> goto out;
> }
> - xfs_scrub_buffer_recheck(ds->sc, bp);
> + xchk_buffer_recheck(ds->sc, bp);
>
> if (ds->sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out_relse;
> @@ -240,7 +240,7 @@ xfs_scrub_dir_rec(
> p = (char *)mp->m_dir_inode_ops->data_entry_p(bp->b_addr);
> endp = xfs_dir3_data_endp(mp->m_dir_geo, bp->b_addr);
> if (!endp) {
> - xfs_scrub_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> + xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> goto out_relse;
> }
> while (p < endp) {
> @@ -258,7 +258,7 @@ xfs_scrub_dir_rec(
> p += mp->m_dir_inode_ops->data_entsize(dep->namelen);
> }
> if (p >= endp) {
> - xfs_scrub_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> + xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> goto out_relse;
> }
>
> @@ -267,14 +267,14 @@ xfs_scrub_dir_rec(
> hash = be32_to_cpu(ent->hashval);
> tag = be16_to_cpup(dp->d_ops->data_entry_tag_p(dent));
> if (!xfs_verify_dir_ino(mp, ino) || tag != off)
> - xfs_scrub_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> + xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> if (dent->namelen == 0) {
> - xfs_scrub_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> + xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> goto out_relse;
> }
> calc_hash = xfs_da_hashname(dent->name, dent->namelen);
> if (calc_hash != hash)
> - xfs_scrub_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
> + xchk_fblock_set_corrupt(ds->sc, XFS_DATA_FORK, rec_bno);
>
> out_relse:
> xfs_trans_brelse(ds->dargs.trans, bp);
> @@ -288,7 +288,7 @@ xfs_scrub_dir_rec(
> * shortest, and that there aren't any bogus entries.
> */
> STATIC void
> -xfs_scrub_directory_check_free_entry(
> +xchk_directory_check_free_entry(
> struct xfs_scrub_context *sc,
> xfs_dablk_t lblk,
> struct xfs_dir2_data_free *bf,
> @@ -308,12 +308,12 @@ xfs_scrub_directory_check_free_entry(
> return;
>
> /* Unused entry should be in the bestfrees but wasn't found. */
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> }
>
> /* Check free space info in a directory data block. */
> STATIC int
> -xfs_scrub_directory_data_bestfree(
> +xchk_directory_data_bestfree(
> struct xfs_scrub_context *sc,
> xfs_dablk_t lblk,
> bool is_block)
> @@ -339,15 +339,15 @@ xfs_scrub_directory_data_bestfree(
> if (is_block) {
> /* dir block format */
> if (lblk != XFS_B_TO_FSBT(mp, XFS_DIR2_DATA_OFFSET))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> error = xfs_dir3_block_read(sc->tp, sc->ip, &bp);
> } else {
> /* dir data format */
> error = xfs_dir3_data_read(sc->tp, sc->ip, lblk, -1, &bp);
> }
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> goto out;
> - xfs_scrub_buffer_recheck(sc, bp);
> + xchk_buffer_recheck(sc, bp);
>
> /* XXX: Check xfs_dir3_data_hdr.pad is zero once we start setting it. */
>
> @@ -362,7 +362,7 @@ xfs_scrub_directory_data_bestfree(
> if (offset == 0)
> continue;
> if (offset >= mp->m_dir_geo->blksize) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out_buf;
> }
> dup = (struct xfs_dir2_data_unused *)(bp->b_addr + offset);
> @@ -372,13 +372,13 @@ xfs_scrub_directory_data_bestfree(
> if (dup->freetag != cpu_to_be16(XFS_DIR2_DATA_FREE_TAG) ||
> be16_to_cpu(dup->length) != be16_to_cpu(dfp->length) ||
> tag != ((char *)dup - (char *)bp->b_addr)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out_buf;
> }
>
> /* bestfree records should be ordered largest to smallest */
> if (smallest_bestfree < be16_to_cpu(dfp->length)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out_buf;
> }
>
> @@ -400,7 +400,7 @@ xfs_scrub_directory_data_bestfree(
> dep = (struct xfs_dir2_data_entry *)ptr;
> newlen = d_ops->data_entsize(dep->namelen);
> if (newlen <= 0) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
> lblk);
> goto out_buf;
> }
> @@ -411,7 +411,7 @@ xfs_scrub_directory_data_bestfree(
> /* Spot check this free entry */
> tag = be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup));
> if (tag != ((char *)dup - (char *)bp->b_addr)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out_buf;
> }
>
> @@ -419,14 +419,14 @@ xfs_scrub_directory_data_bestfree(
> * Either this entry is a bestfree or it's smaller than
> * any of the bestfrees.
> */
> - xfs_scrub_directory_check_free_entry(sc, lblk, bf, dup);
> + xchk_directory_check_free_entry(sc, lblk, bf, dup);
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out_buf;
>
> /* Move on. */
> newlen = be16_to_cpu(dup->length);
> if (newlen <= 0) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out_buf;
> }
> ptr += newlen;
> @@ -436,11 +436,11 @@ xfs_scrub_directory_data_bestfree(
>
> /* We're required to fill all the space. */
> if (ptr != endptr)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
>
> /* Did we see at least as many free slots as there are bestfrees? */
> if (nr_frees < nr_bestfrees)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> out_buf:
> xfs_trans_brelse(sc->tp, bp);
> out:
> @@ -454,7 +454,7 @@ xfs_scrub_directory_data_bestfree(
> * array is in order.
> */
> STATIC void
> -xfs_scrub_directory_check_freesp(
> +xchk_directory_check_freesp(
> struct xfs_scrub_context *sc,
> xfs_dablk_t lblk,
> struct xfs_buf *dbp,
> @@ -465,15 +465,15 @@ xfs_scrub_directory_check_freesp(
> dfp = sc->ip->d_ops->data_bestfree_p(dbp->b_addr);
>
> if (len != be16_to_cpu(dfp->length))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
>
> if (len > 0 && be16_to_cpu(dfp->offset) == 0)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> }
>
> /* Check free space info in a directory leaf1 block. */
> STATIC int
> -xfs_scrub_directory_leaf1_bestfree(
> +xchk_directory_leaf1_bestfree(
> struct xfs_scrub_context *sc,
> struct xfs_da_args *args,
> xfs_dablk_t lblk)
> @@ -497,9 +497,9 @@ xfs_scrub_directory_leaf1_bestfree(
>
> /* Read the free space block. */
> error = xfs_dir3_leaf_read(sc->tp, sc->ip, lblk, -1, &bp);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> goto out;
> - xfs_scrub_buffer_recheck(sc, bp);
> + xchk_buffer_recheck(sc, bp);
>
> leaf = bp->b_addr;
> d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
> @@ -512,7 +512,7 @@ xfs_scrub_directory_leaf1_bestfree(
> struct xfs_dir3_leaf_hdr *hdr3 = bp->b_addr;
>
> if (hdr3->pad != cpu_to_be32(0))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> }
>
> /*
> @@ -520,19 +520,19 @@ xfs_scrub_directory_leaf1_bestfree(
> * blocks that can fit under i_size.
> */
> if (bestcount != xfs_dir2_byte_to_db(geo, sc->ip->i_d.di_size)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out;
> }
>
> /* Is the leaf count even remotely sane? */
> if (leafhdr.count > d_ops->leaf_max_ents(geo)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out;
> }
>
> /* Leaves and bests don't overlap in leaf format. */
> if ((char *)&ents[leafhdr.count] > (char *)bestp) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out;
> }
>
> @@ -540,13 +540,13 @@ xfs_scrub_directory_leaf1_bestfree(
> for (i = 0; i < leafhdr.count; i++) {
> hash = be32_to_cpu(ents[i].hashval);
> if (i > 0 && lasthash > hash)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> lasthash = hash;
> if (ents[i].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
> stale++;
> }
> if (leafhdr.stale != stale)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
>
> @@ -557,10 +557,10 @@ xfs_scrub_directory_leaf1_bestfree(
> continue;
> error = xfs_dir3_data_read(sc->tp, sc->ip,
> i * args->geo->fsbcount, -1, &dbp);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, lblk,
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk,
> &error))
> break;
> - xfs_scrub_directory_check_freesp(sc, lblk, dbp, best);
> + xchk_directory_check_freesp(sc, lblk, dbp, best);
> xfs_trans_brelse(sc->tp, dbp);
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
> @@ -571,7 +571,7 @@ xfs_scrub_directory_leaf1_bestfree(
>
> /* Check free space info in a directory freespace block. */
> STATIC int
> -xfs_scrub_directory_free_bestfree(
> +xchk_directory_free_bestfree(
> struct xfs_scrub_context *sc,
> struct xfs_da_args *args,
> xfs_dablk_t lblk)
> @@ -587,15 +587,15 @@ xfs_scrub_directory_free_bestfree(
>
> /* Read the free space block */
> error = xfs_dir2_free_read(sc->tp, sc->ip, lblk, &bp);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> goto out;
> - xfs_scrub_buffer_recheck(sc, bp);
> + xchk_buffer_recheck(sc, bp);
>
> if (xfs_sb_version_hascrc(&sc->mp->m_sb)) {
> struct xfs_dir3_free_hdr *hdr3 = bp->b_addr;
>
> if (hdr3->pad != cpu_to_be32(0))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> }
>
> /* Check all the entries. */
> @@ -610,22 +610,22 @@ xfs_scrub_directory_free_bestfree(
> error = xfs_dir3_data_read(sc->tp, sc->ip,
> (freehdr.firstdb + i) * args->geo->fsbcount,
> -1, &dbp);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, lblk,
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk,
> &error))
> break;
> - xfs_scrub_directory_check_freesp(sc, lblk, dbp, best);
> + xchk_directory_check_freesp(sc, lblk, dbp, best);
> xfs_trans_brelse(sc->tp, dbp);
> }
>
> if (freehdr.nused + stale != freehdr.nvalid)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> out:
> return error;
> }
>
> /* Check free space information in directories. */
> STATIC int
> -xfs_scrub_directory_blocks(
> +xchk_directory_blocks(
> struct xfs_scrub_context *sc)
> {
> struct xfs_bmbt_irec got;
> @@ -656,7 +656,7 @@ xfs_scrub_directory_blocks(
> args.geo = mp->m_dir_geo;
> args.trans = sc->tp;
> error = xfs_dir2_isblock(&args, &is_block);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, lblk, &error))
> goto out;
>
> /* Iterate all the data extents in the directory... */
> @@ -666,7 +666,7 @@ xfs_scrub_directory_blocks(
> if (is_block &&
> (got.br_startoff > 0 ||
> got.br_blockcount != args.geo->fsbcount)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
> got.br_startoff);
> break;
> }
> @@ -690,7 +690,7 @@ xfs_scrub_directory_blocks(
> args.geo->fsbcount);
> lblk < got.br_startoff + got.br_blockcount;
> lblk += args.geo->fsbcount) {
> - error = xfs_scrub_directory_data_bestfree(sc, lblk,
> + error = xchk_directory_data_bestfree(sc, lblk,
> is_block);
> if (error)
> goto out;
> @@ -709,10 +709,10 @@ xfs_scrub_directory_blocks(
> got.br_blockcount == args.geo->fsbcount &&
> !xfs_iext_next_extent(ifp, &icur, &got)) {
> if (is_block) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out;
> }
> - error = xfs_scrub_directory_leaf1_bestfree(sc, &args,
> + error = xchk_directory_leaf1_bestfree(sc, &args,
> leaf_lblk);
> if (error)
> goto out;
> @@ -731,11 +731,11 @@ xfs_scrub_directory_blocks(
> */
> lblk = got.br_startoff;
> if (lblk & ~0xFFFFFFFFULL) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out;
> }
> if (is_block) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, lblk);
> goto out;
> }
>
> @@ -754,7 +754,7 @@ xfs_scrub_directory_blocks(
> args.geo->fsbcount);
> lblk < got.br_startoff + got.br_blockcount;
> lblk += args.geo->fsbcount) {
> - error = xfs_scrub_directory_free_bestfree(sc, &args,
> + error = xchk_directory_free_bestfree(sc, &args,
> lblk);
> if (error)
> goto out;
> @@ -769,11 +769,11 @@ xfs_scrub_directory_blocks(
>
> /* Scrub a whole directory. */
> int
> -xfs_scrub_directory(
> +xchk_directory(
> struct xfs_scrub_context *sc)
> {
> - struct xfs_scrub_dir_ctx sdc = {
> - .dir_iter.actor = xfs_scrub_dir_actor,
> + struct xchk_dir_ctx sdc = {
> + .dir_iter.actor = xchk_dir_actor,
> .dir_iter.pos = 0,
> .sc = sc,
> };
> @@ -786,12 +786,12 @@ xfs_scrub_directory(
>
> /* Plausible size? */
> if (sc->ip->i_d.di_size < xfs_dir2_sf_hdr_size(0)) {
> - xfs_scrub_ino_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_set_corrupt(sc, sc->ip->i_ino);
> goto out;
> }
>
> /* Check directory tree structure */
> - error = xfs_scrub_da_btree(sc, XFS_DATA_FORK, xfs_scrub_dir_rec, NULL);
> + error = xchk_da_btree(sc, XFS_DATA_FORK, xchk_dir_rec, NULL);
> if (error)
> return error;
>
> @@ -799,7 +799,7 @@ xfs_scrub_directory(
> return error;
>
> /* Check the freespace. */
> - error = xfs_scrub_directory_blocks(sc);
> + error = xchk_directory_blocks(sc);
> if (error)
> return error;
>
> @@ -816,7 +816,7 @@ xfs_scrub_directory(
> /*
> * Look up every name in this directory by hash.
> *
> - * Use the xfs_readdir function to call xfs_scrub_dir_actor on
> + * Use the xfs_readdir function to call xchk_dir_actor on
> * every directory entry in this directory. In _actor, we check
> * the name, inode number, and ftype (if applicable) of the
> * entry. xfs_readdir uses the VFS filldir functions to provide
> @@ -834,7 +834,7 @@ xfs_scrub_directory(
> xfs_iunlock(sc->ip, XFS_ILOCK_EXCL);
> while (true) {
> error = xfs_readdir(sc->tp, sc->ip, &sdc.dir_iter, bufsize);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0,
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0,
> &error))
> goto out;
> if (oldpos == sdc.dir_iter.pos)
> diff --git a/fs/xfs/scrub/ialloc.c b/fs/xfs/scrub/ialloc.c
> index 13d43d108574..69d652b7299c 100644
> --- a/fs/xfs/scrub/ialloc.c
> +++ b/fs/xfs/scrub/ialloc.c
> @@ -35,11 +35,11 @@
> * try again after forcing logged inode cores out to disk.
> */
> int
> -xfs_scrub_setup_ag_iallocbt(
> +xchk_setup_ag_iallocbt(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> - return xfs_scrub_setup_ag_btree(sc, ip, sc->try_harder);
> + return xchk_setup_ag_btree(sc, ip, sc->try_harder);
> }
>
> /* Inode btree scrubber. */
> @@ -50,7 +50,7 @@ xfs_scrub_setup_ag_iallocbt(
> * we have a record or not depending on freecount.
> */
> static inline void
> -xfs_scrub_iallocbt_chunk_xref_other(
> +xchk_iallocbt_chunk_xref_other(
> struct xfs_scrub_context *sc,
> struct xfs_inobt_rec_incore *irec,
> xfs_agino_t agino)
> @@ -66,16 +66,16 @@ xfs_scrub_iallocbt_chunk_xref_other(
> if (!(*pcur))
> return;
> error = xfs_ialloc_has_inode_record(*pcur, agino, agino, &has_irec);
> - if (!xfs_scrub_should_check_xref(sc, &error, pcur))
> + if (!xchk_should_check_xref(sc, &error, pcur))
> return;
> if (((irec->ir_freecount > 0 && !has_irec) ||
> (irec->ir_freecount == 0 && has_irec)))
> - xfs_scrub_btree_xref_set_corrupt(sc, *pcur, 0);
> + xchk_btree_xref_set_corrupt(sc, *pcur, 0);
> }
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_iallocbt_chunk_xref(
> +xchk_iallocbt_chunk_xref(
> struct xfs_scrub_context *sc,
> struct xfs_inobt_rec_incore *irec,
> xfs_agino_t agino,
> @@ -87,17 +87,17 @@ xfs_scrub_iallocbt_chunk_xref(
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, len);
> - xfs_scrub_iallocbt_chunk_xref_other(sc, irec, agino);
> + xchk_xref_is_used_space(sc, agbno, len);
> + xchk_iallocbt_chunk_xref_other(sc, irec, agino);
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
> - xfs_scrub_xref_is_owned_by(sc, agbno, len, &oinfo);
> - xfs_scrub_xref_is_not_shared(sc, agbno, len);
> + xchk_xref_is_owned_by(sc, agbno, len, &oinfo);
> + xchk_xref_is_not_shared(sc, agbno, len);
> }
>
> /* Is this chunk worth checking? */
> STATIC bool
> -xfs_scrub_iallocbt_chunk(
> - struct xfs_scrub_btree *bs,
> +xchk_iallocbt_chunk(
> + struct xchk_btree *bs,
> struct xfs_inobt_rec_incore *irec,
> xfs_agino_t agino,
> xfs_extlen_t len)
> @@ -110,16 +110,16 @@ xfs_scrub_iallocbt_chunk(
> if (bno + len <= bno ||
> !xfs_verify_agbno(mp, agno, bno) ||
> !xfs_verify_agbno(mp, agno, bno + len - 1))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> - xfs_scrub_iallocbt_chunk_xref(bs->sc, irec, agino, bno, len);
> + xchk_iallocbt_chunk_xref(bs->sc, irec, agino, bno, len);
>
> return true;
> }
>
> /* Count the number of free inodes. */
> static unsigned int
> -xfs_scrub_iallocbt_freecount(
> +xchk_iallocbt_freecount(
> xfs_inofree_t freemask)
> {
> BUILD_BUG_ON(sizeof(freemask) != sizeof(__u64));
> @@ -128,8 +128,8 @@ xfs_scrub_iallocbt_freecount(
>
> /* Check a particular inode with ir_free. */
> STATIC int
> -xfs_scrub_iallocbt_check_cluster_freemask(
> - struct xfs_scrub_btree *bs,
> +xchk_iallocbt_check_cluster_freemask(
> + struct xchk_btree *bs,
> xfs_ino_t fsino,
> xfs_agino_t chunkino,
> xfs_agino_t clusterino,
> @@ -143,14 +143,14 @@ xfs_scrub_iallocbt_check_cluster_freemask(
> bool inuse;
> int error = 0;
>
> - if (xfs_scrub_should_terminate(bs->sc, &error))
> + if (xchk_should_terminate(bs->sc, &error))
> return error;
>
> dip = xfs_buf_offset(bp, clusterino * mp->m_sb.sb_inodesize);
> if (be16_to_cpu(dip->di_magic) != XFS_DINODE_MAGIC ||
> (dip->di_version >= 3 &&
> be64_to_cpu(dip->di_ino) != fsino + clusterino)) {
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> goto out;
> }
>
> @@ -175,15 +175,15 @@ xfs_scrub_iallocbt_check_cluster_freemask(
> freemask_ok = inode_is_free ^ inuse;
> }
> if (!freemask_ok)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> out:
> return 0;
> }
>
> /* Make sure the free mask is consistent with what the inodes think. */
> STATIC int
> -xfs_scrub_iallocbt_check_freemask(
> - struct xfs_scrub_btree *bs,
> +xchk_iallocbt_check_freemask(
> + struct xchk_btree *bs,
> struct xfs_inobt_rec_incore *irec)
> {
> struct xfs_owner_info oinfo;
> @@ -223,18 +223,18 @@ xfs_scrub_iallocbt_check_freemask(
> /* The whole cluster must be a hole or not a hole. */
> ir_holemask = (irec->ir_holemask & holemask);
> if (ir_holemask != holemask && ir_holemask != 0) {
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> continue;
> }
>
> /* If any part of this is a hole, skip it. */
> if (ir_holemask) {
> - xfs_scrub_xref_is_not_owned_by(bs->sc, agbno,
> + xchk_xref_is_not_owned_by(bs->sc, agbno,
> blks_per_cluster, &oinfo);
> continue;
> }
>
> - xfs_scrub_xref_is_owned_by(bs->sc, agbno, blks_per_cluster,
> + xchk_xref_is_owned_by(bs->sc, agbno, blks_per_cluster,
> &oinfo);
>
> /* Grab the inode cluster buffer. */
> @@ -245,13 +245,13 @@ xfs_scrub_iallocbt_check_freemask(
>
> error = xfs_imap_to_bp(mp, bs->cur->bc_tp, &imap,
> &dip, &bp, 0, 0);
> - if (!xfs_scrub_btree_xref_process_error(bs->sc, bs->cur, 0,
> + if (!xchk_btree_xref_process_error(bs->sc, bs->cur, 0,
> &error))
> continue;
>
> /* Which inodes are free? */
> for (clusterino = 0; clusterino < nr_inodes; clusterino++) {
> - error = xfs_scrub_iallocbt_check_cluster_freemask(bs,
> + error = xchk_iallocbt_check_cluster_freemask(bs,
> fsino, chunkino, clusterino, irec, bp);
> if (error) {
> xfs_trans_brelse(bs->cur->bc_tp, bp);
> @@ -267,8 +267,8 @@ xfs_scrub_iallocbt_check_freemask(
>
> /* Scrub an inobt/finobt record. */
> STATIC int
> -xfs_scrub_iallocbt_rec(
> - struct xfs_scrub_btree *bs,
> +xchk_iallocbt_rec(
> + struct xchk_btree *bs,
> union xfs_btree_rec *rec)
> {
> struct xfs_mount *mp = bs->cur->bc_mp;
> @@ -289,18 +289,18 @@ xfs_scrub_iallocbt_rec(
>
> if (irec.ir_count > XFS_INODES_PER_CHUNK ||
> irec.ir_freecount > XFS_INODES_PER_CHUNK)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> real_freecount = irec.ir_freecount +
> (XFS_INODES_PER_CHUNK - irec.ir_count);
> - if (real_freecount != xfs_scrub_iallocbt_freecount(irec.ir_free))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + if (real_freecount != xchk_iallocbt_freecount(irec.ir_free))
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> agino = irec.ir_startino;
> /* Record has to be properly aligned within the AG. */
> if (!xfs_verify_agino(mp, agno, agino) ||
> !xfs_verify_agino(mp, agno, agino + XFS_INODES_PER_CHUNK - 1)) {
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> goto out;
> }
>
> @@ -308,7 +308,7 @@ xfs_scrub_iallocbt_rec(
> agbno = XFS_AGINO_TO_AGBNO(mp, irec.ir_startino);
> if ((agbno & (xfs_ialloc_cluster_alignment(mp) - 1)) ||
> (agbno & (xfs_icluster_size_fsb(mp) - 1)))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> *inode_blocks += XFS_B_TO_FSB(mp,
> irec.ir_count * mp->m_sb.sb_inodesize);
> @@ -318,9 +318,9 @@ xfs_scrub_iallocbt_rec(
> len = XFS_B_TO_FSB(mp,
> XFS_INODES_PER_CHUNK * mp->m_sb.sb_inodesize);
> if (irec.ir_count != XFS_INODES_PER_CHUNK)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> - if (!xfs_scrub_iallocbt_chunk(bs, &irec, agino, len))
> + if (!xchk_iallocbt_chunk(bs, &irec, agino, len))
> goto out;
> goto check_freemask;
> }
> @@ -333,12 +333,12 @@ xfs_scrub_iallocbt_rec(
> holes = ~xfs_inobt_irec_to_allocmask(&irec);
> if ((holes & irec.ir_free) != holes ||
> irec.ir_freecount > irec.ir_count)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> for (i = 0; i < XFS_INOBT_HOLEMASK_BITS; i++) {
> if (holemask & 1)
> holecount += XFS_INODES_PER_HOLEMASK_BIT;
> - else if (!xfs_scrub_iallocbt_chunk(bs, &irec, agino, len))
> + else if (!xchk_iallocbt_chunk(bs, &irec, agino, len))
> break;
> holemask >>= 1;
> agino += XFS_INODES_PER_HOLEMASK_BIT;
> @@ -346,10 +346,10 @@ xfs_scrub_iallocbt_rec(
>
> if (holecount > XFS_INODES_PER_CHUNK ||
> holecount + irec.ir_count != XFS_INODES_PER_CHUNK)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> check_freemask:
> - error = xfs_scrub_iallocbt_check_freemask(bs, &irec);
> + error = xchk_iallocbt_check_freemask(bs, &irec);
> if (error)
> goto out;
>
> @@ -362,7 +362,7 @@ xfs_scrub_iallocbt_rec(
> * Don't bother if we're missing btree cursors, as we're already corrupt.
> */
> STATIC void
> -xfs_scrub_iallocbt_xref_rmap_btreeblks(
> +xchk_iallocbt_xref_rmap_btreeblks(
> struct xfs_scrub_context *sc,
> int which)
> {
> @@ -374,27 +374,27 @@ xfs_scrub_iallocbt_xref_rmap_btreeblks(
>
> if (!sc->sa.ino_cur || !sc->sa.rmap_cur ||
> (xfs_sb_version_hasfinobt(&sc->mp->m_sb) && !sc->sa.fino_cur) ||
> - xfs_scrub_skip_xref(sc->sm))
> + xchk_skip_xref(sc->sm))
> return;
>
> /* Check that we saw as many inobt blocks as the rmap says. */
> error = xfs_btree_count_blocks(sc->sa.ino_cur, &inobt_blocks);
> - if (!xfs_scrub_process_error(sc, 0, 0, &error))
> + if (!xchk_process_error(sc, 0, 0, &error))
> return;
>
> if (sc->sa.fino_cur) {
> error = xfs_btree_count_blocks(sc->sa.fino_cur, &finobt_blocks);
> - if (!xfs_scrub_process_error(sc, 0, 0, &error))
> + if (!xchk_process_error(sc, 0, 0, &error))
> return;
> }
>
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
> - error = xfs_scrub_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
> + error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
> &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> if (blocks != inobt_blocks + finobt_blocks)
> - xfs_scrub_btree_set_corrupt(sc, sc->sa.ino_cur, 0);
> + xchk_btree_set_corrupt(sc, sc->sa.ino_cur, 0);
> }
>
> /*
> @@ -402,7 +402,7 @@ xfs_scrub_iallocbt_xref_rmap_btreeblks(
> * the rmap says are owned by inodes.
> */
> STATIC void
> -xfs_scrub_iallocbt_xref_rmap_inodes(
> +xchk_iallocbt_xref_rmap_inodes(
> struct xfs_scrub_context *sc,
> int which,
> xfs_filblks_t inode_blocks)
> @@ -411,22 +411,22 @@ xfs_scrub_iallocbt_xref_rmap_inodes(
> xfs_filblks_t blocks;
> int error;
>
> - if (!sc->sa.rmap_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
> return;
>
> /* Check that we saw as many inode blocks as the rmap knows about. */
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
> - error = xfs_scrub_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
> + error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, &oinfo,
> &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> if (blocks != inode_blocks)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> }
>
> /* Scrub the inode btrees for some AG. */
> STATIC int
> -xfs_scrub_iallocbt(
> +xchk_iallocbt(
> struct xfs_scrub_context *sc,
> xfs_btnum_t which)
> {
> @@ -437,12 +437,12 @@ xfs_scrub_iallocbt(
>
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
> cur = which == XFS_BTNUM_INO ? sc->sa.ino_cur : sc->sa.fino_cur;
> - error = xfs_scrub_btree(sc, cur, xfs_scrub_iallocbt_rec, &oinfo,
> + error = xchk_btree(sc, cur, xchk_iallocbt_rec, &oinfo,
> &inode_blocks);
> if (error)
> return error;
>
> - xfs_scrub_iallocbt_xref_rmap_btreeblks(sc, which);
> + xchk_iallocbt_xref_rmap_btreeblks(sc, which);
>
> /*
> * If we're scrubbing the inode btree, inode_blocks is the number of
> @@ -452,28 +452,28 @@ xfs_scrub_iallocbt(
> * to inode chunks with free inodes.
> */
> if (which == XFS_BTNUM_INO)
> - xfs_scrub_iallocbt_xref_rmap_inodes(sc, which, inode_blocks);
> + xchk_iallocbt_xref_rmap_inodes(sc, which, inode_blocks);
>
> return error;
> }
>
> int
> -xfs_scrub_inobt(
> +xchk_inobt(
> struct xfs_scrub_context *sc)
> {
> - return xfs_scrub_iallocbt(sc, XFS_BTNUM_INO);
> + return xchk_iallocbt(sc, XFS_BTNUM_INO);
> }
>
> int
> -xfs_scrub_finobt(
> +xchk_finobt(
> struct xfs_scrub_context *sc)
> {
> - return xfs_scrub_iallocbt(sc, XFS_BTNUM_FINO);
> + return xchk_iallocbt(sc, XFS_BTNUM_FINO);
> }
>
> /* See if an inode btree has (or doesn't have) an inode chunk record. */
> static inline void
> -xfs_scrub_xref_inode_check(
> +xchk_xref_inode_check(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len,
> @@ -483,33 +483,33 @@ xfs_scrub_xref_inode_check(
> bool has_inodes;
> int error;
>
> - if (!(*icur) || xfs_scrub_skip_xref(sc->sm))
> + if (!(*icur) || xchk_skip_xref(sc->sm))
> return;
>
> error = xfs_ialloc_has_inodes_at_extent(*icur, agbno, len, &has_inodes);
> - if (!xfs_scrub_should_check_xref(sc, &error, icur))
> + if (!xchk_should_check_xref(sc, &error, icur))
> return;
> if (has_inodes != should_have_inodes)
> - xfs_scrub_btree_xref_set_corrupt(sc, *icur, 0);
> + xchk_btree_xref_set_corrupt(sc, *icur, 0);
> }
>
> /* xref check that the extent is not covered by inodes */
> void
> -xfs_scrub_xref_is_not_inode_chunk(
> +xchk_xref_is_not_inode_chunk(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> {
> - xfs_scrub_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, false);
> - xfs_scrub_xref_inode_check(sc, agbno, len, &sc->sa.fino_cur, false);
> + xchk_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, false);
> + xchk_xref_inode_check(sc, agbno, len, &sc->sa.fino_cur, false);
> }
>
> /* xref check that the extent is covered by inodes */
> void
> -xfs_scrub_xref_is_inode_chunk(
> +xchk_xref_is_inode_chunk(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> {
> - xfs_scrub_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, true);
> + xchk_xref_inode_check(sc, agbno, len, &sc->sa.ino_cur, true);
> }
> diff --git a/fs/xfs/scrub/inode.c b/fs/xfs/scrub/inode.c
> index 7a6208505980..d85fbec39e52 100644
> --- a/fs/xfs/scrub/inode.c
> +++ b/fs/xfs/scrub/inode.c
> @@ -37,7 +37,7 @@
> * the goal.
> */
> int
> -xfs_scrub_setup_inode(
> +xchk_setup_inode(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> @@ -47,13 +47,13 @@ xfs_scrub_setup_inode(
> * Try to get the inode. If the verifiers fail, we try again
> * in raw mode.
> */
> - error = xfs_scrub_get_inode(sc, ip);
> + error = xchk_get_inode(sc, ip);
> switch (error) {
> case 0:
> break;
> case -EFSCORRUPTED:
> case -EFSBADCRC:
> - return xfs_scrub_trans_alloc(sc, 0);
> + return xchk_trans_alloc(sc, 0);
> default:
> return error;
> }
> @@ -61,7 +61,7 @@ xfs_scrub_setup_inode(
> /* Got the inode, lock it and we're ready to go. */
> sc->ilock_flags = XFS_IOLOCK_EXCL | XFS_MMAPLOCK_EXCL;
> xfs_ilock(sc->ip, sc->ilock_flags);
> - error = xfs_scrub_trans_alloc(sc, 0);
> + error = xchk_trans_alloc(sc, 0);
> if (error)
> goto out;
> sc->ilock_flags |= XFS_ILOCK_EXCL;
> @@ -76,7 +76,7 @@ xfs_scrub_setup_inode(
>
> /* Validate di_extsize hint. */
> STATIC void
> -xfs_scrub_inode_extsize(
> +xchk_inode_extsize(
> struct xfs_scrub_context *sc,
> struct xfs_dinode *dip,
> xfs_ino_t ino,
> @@ -88,7 +88,7 @@ xfs_scrub_inode_extsize(
> fa = xfs_inode_validate_extsize(sc->mp, be32_to_cpu(dip->di_extsize),
> mode, flags);
> if (fa)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> /*
> @@ -98,7 +98,7 @@ xfs_scrub_inode_extsize(
> * These functions must be kept in sync with each other.
> */
> STATIC void
> -xfs_scrub_inode_cowextsize(
> +xchk_inode_cowextsize(
> struct xfs_scrub_context *sc,
> struct xfs_dinode *dip,
> xfs_ino_t ino,
> @@ -112,12 +112,12 @@ xfs_scrub_inode_cowextsize(
> be32_to_cpu(dip->di_cowextsize), mode, flags,
> flags2);
> if (fa)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> /* Make sure the di_flags make sense for the inode. */
> STATIC void
> -xfs_scrub_inode_flags(
> +xchk_inode_flags(
> struct xfs_scrub_context *sc,
> struct xfs_dinode *dip,
> xfs_ino_t ino,
> @@ -157,12 +157,12 @@ xfs_scrub_inode_flags(
>
> return;
> bad:
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> /* Make sure the di_flags2 make sense for the inode. */
> STATIC void
> -xfs_scrub_inode_flags2(
> +xchk_inode_flags2(
> struct xfs_scrub_context *sc,
> struct xfs_dinode *dip,
> xfs_ino_t ino,
> @@ -200,12 +200,12 @@ xfs_scrub_inode_flags2(
>
> return;
> bad:
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> /* Scrub all the ondisk inode fields. */
> STATIC void
> -xfs_scrub_dinode(
> +xchk_dinode(
> struct xfs_scrub_context *sc,
> struct xfs_dinode *dip,
> xfs_ino_t ino)
> @@ -237,7 +237,7 @@ xfs_scrub_dinode(
> /* mode is recognized */
> break;
> default:
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> }
>
> @@ -248,22 +248,22 @@ xfs_scrub_dinode(
> * We autoconvert v1 inodes into v2 inodes on writeout,
> * so just mark this inode for preening.
> */
> - xfs_scrub_ino_set_preen(sc, ino);
> + xchk_ino_set_preen(sc, ino);
> break;
> case 2:
> case 3:
> if (dip->di_onlink != 0)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> if (dip->di_mode == 0 && sc->ip)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> if (dip->di_projid_hi != 0 &&
> !xfs_sb_version_hasprojid32bit(&mp->m_sb))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> default:
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> return;
> }
>
> @@ -273,40 +273,40 @@ xfs_scrub_dinode(
> */
> if (dip->di_uid == cpu_to_be32(-1U) ||
> dip->di_gid == cpu_to_be32(-1U))
> - xfs_scrub_ino_set_warning(sc, ino);
> + xchk_ino_set_warning(sc, ino);
>
> /* di_format */
> switch (dip->di_format) {
> case XFS_DINODE_FMT_DEV:
> if (!S_ISCHR(mode) && !S_ISBLK(mode) &&
> !S_ISFIFO(mode) && !S_ISSOCK(mode))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> case XFS_DINODE_FMT_LOCAL:
> if (!S_ISDIR(mode) && !S_ISLNK(mode))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> case XFS_DINODE_FMT_EXTENTS:
> if (!S_ISREG(mode) && !S_ISDIR(mode) && !S_ISLNK(mode))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> case XFS_DINODE_FMT_BTREE:
> if (!S_ISREG(mode) && !S_ISDIR(mode))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> case XFS_DINODE_FMT_UUID:
> default:
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> }
>
> /* di_[amc]time.nsec */
> if (be32_to_cpu(dip->di_atime.t_nsec) >= NSEC_PER_SEC)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> if (be32_to_cpu(dip->di_mtime.t_nsec) >= NSEC_PER_SEC)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> if (be32_to_cpu(dip->di_ctime.t_nsec) >= NSEC_PER_SEC)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /*
> * di_size. xfs_dinode_verify checks for things that screw up
> @@ -315,19 +315,19 @@ xfs_scrub_dinode(
> */
> isize = be64_to_cpu(dip->di_size);
> if (isize & (1ULL << 63))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /* Devices, fifos, and sockets must have zero size */
> if (!S_ISDIR(mode) && !S_ISREG(mode) && !S_ISLNK(mode) && isize != 0)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /* Directories can't be larger than the data section size (32G) */
> if (S_ISDIR(mode) && (isize == 0 || isize >= XFS_DIR2_SPACE_SIZE))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /* Symlinks can't be larger than SYMLINK_MAXLEN */
> if (S_ISLNK(mode) && (isize == 0 || isize >= XFS_SYMLINK_MAXLEN))
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /*
> * Warn if the running kernel can't handle the kinds of offsets
> @@ -336,7 +336,7 @@ xfs_scrub_dinode(
> * overly large offsets, flag the inode for admin review.
> */
> if (isize >= mp->m_super->s_maxbytes)
> - xfs_scrub_ino_set_warning(sc, ino);
> + xchk_ino_set_warning(sc, ino);
>
> /* di_nblocks */
> if (flags2 & XFS_DIFLAG2_REFLINK) {
> @@ -351,15 +351,15 @@ xfs_scrub_dinode(
> */
> if (be64_to_cpu(dip->di_nblocks) >=
> mp->m_sb.sb_dblocks + mp->m_sb.sb_rblocks)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> } else {
> if (be64_to_cpu(dip->di_nblocks) >= mp->m_sb.sb_dblocks)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> - xfs_scrub_inode_flags(sc, dip, ino, mode, flags);
> + xchk_inode_flags(sc, dip, ino, mode, flags);
>
> - xfs_scrub_inode_extsize(sc, dip, ino, mode, flags);
> + xchk_inode_extsize(sc, dip, ino, mode, flags);
>
> /* di_nextents */
> nextents = be32_to_cpu(dip->di_nextents);
> @@ -367,31 +367,31 @@ xfs_scrub_dinode(
> switch (dip->di_format) {
> case XFS_DINODE_FMT_EXTENTS:
> if (nextents > fork_recs)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> case XFS_DINODE_FMT_BTREE:
> if (nextents <= fork_recs)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> default:
> if (nextents != 0)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> }
>
> /* di_forkoff */
> if (XFS_DFORK_APTR(dip) >= (char *)dip + mp->m_sb.sb_inodesize)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> if (dip->di_anextents != 0 && dip->di_forkoff == 0)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> if (dip->di_forkoff == 0 && dip->di_aformat != XFS_DINODE_FMT_EXTENTS)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /* di_aformat */
> if (dip->di_aformat != XFS_DINODE_FMT_LOCAL &&
> dip->di_aformat != XFS_DINODE_FMT_EXTENTS &&
> dip->di_aformat != XFS_DINODE_FMT_BTREE)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
>
> /* di_anextents */
> nextents = be16_to_cpu(dip->di_anextents);
> @@ -399,22 +399,22 @@ xfs_scrub_dinode(
> switch (dip->di_aformat) {
> case XFS_DINODE_FMT_EXTENTS:
> if (nextents > fork_recs)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> case XFS_DINODE_FMT_BTREE:
> if (nextents <= fork_recs)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> break;
> default:
> if (nextents != 0)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> if (dip->di_version >= 3) {
> if (be32_to_cpu(dip->di_crtime.t_nsec) >= NSEC_PER_SEC)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> - xfs_scrub_inode_flags2(sc, dip, ino, mode, flags, flags2);
> - xfs_scrub_inode_cowextsize(sc, dip, ino, mode, flags,
> + xchk_ino_set_corrupt(sc, ino);
> + xchk_inode_flags2(sc, dip, ino, mode, flags, flags2);
> + xchk_inode_cowextsize(sc, dip, ino, mode, flags,
> flags2);
> }
> }
> @@ -425,7 +425,7 @@ xfs_scrub_dinode(
> * IGET_UNTRUSTED, which checks the inobt for us.
> */
> static void
> -xfs_scrub_inode_xref_finobt(
> +xchk_inode_xref_finobt(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino)
> {
> @@ -434,7 +434,7 @@ xfs_scrub_inode_xref_finobt(
> int has_record;
> int error;
>
> - if (!sc->sa.fino_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.fino_cur || xchk_skip_xref(sc->sm))
> return;
>
> agino = XFS_INO_TO_AGINO(sc->mp, ino);
> @@ -445,12 +445,12 @@ xfs_scrub_inode_xref_finobt(
> */
> error = xfs_inobt_lookup(sc->sa.fino_cur, agino, XFS_LOOKUP_LE,
> &has_record);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.fino_cur) ||
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.fino_cur) ||
> !has_record)
> return;
>
> error = xfs_inobt_get_rec(sc->sa.fino_cur, &rec, &has_record);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.fino_cur) ||
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.fino_cur) ||
> !has_record)
> return;
>
> @@ -463,12 +463,12 @@ xfs_scrub_inode_xref_finobt(
> return;
>
> if (rec.ir_free & XFS_INOBT_MASK(agino - rec.ir_startino))
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.fino_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.fino_cur, 0);
> }
>
> /* Cross reference the inode fields with the forks. */
> STATIC void
> -xfs_scrub_inode_xref_bmap(
> +xchk_inode_xref_bmap(
> struct xfs_scrub_context *sc,
> struct xfs_dinode *dip)
> {
> @@ -477,32 +477,32 @@ xfs_scrub_inode_xref_bmap(
> xfs_filblks_t acount;
> int error;
>
> - if (xfs_scrub_skip_xref(sc->sm))
> + if (xchk_skip_xref(sc->sm))
> return;
>
> /* Walk all the extents to check nextents/naextents/nblocks. */
> error = xfs_bmap_count_blocks(sc->tp, sc->ip, XFS_DATA_FORK,
> &nextents, &count);
> - if (!xfs_scrub_should_check_xref(sc, &error, NULL))
> + if (!xchk_should_check_xref(sc, &error, NULL))
> return;
> if (nextents < be32_to_cpu(dip->di_nextents))
> - xfs_scrub_ino_xref_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_xref_set_corrupt(sc, sc->ip->i_ino);
>
> error = xfs_bmap_count_blocks(sc->tp, sc->ip, XFS_ATTR_FORK,
> &nextents, &acount);
> - if (!xfs_scrub_should_check_xref(sc, &error, NULL))
> + if (!xchk_should_check_xref(sc, &error, NULL))
> return;
> if (nextents != be16_to_cpu(dip->di_anextents))
> - xfs_scrub_ino_xref_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_xref_set_corrupt(sc, sc->ip->i_ino);
>
> /* Check nblocks against the inode. */
> if (count + acount != be64_to_cpu(dip->di_nblocks))
> - xfs_scrub_ino_xref_set_corrupt(sc, sc->ip->i_ino);
> + xchk_ino_xref_set_corrupt(sc, sc->ip->i_ino);
> }
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_inode_xref(
> +xchk_inode_xref(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino,
> struct xfs_dinode *dip)
> @@ -518,18 +518,18 @@ xfs_scrub_inode_xref(
> agno = XFS_INO_TO_AGNO(sc->mp, ino);
> agbno = XFS_INO_TO_AGBNO(sc->mp, ino);
>
> - error = xfs_scrub_ag_init(sc, agno, &sc->sa);
> - if (!xfs_scrub_xref_process_error(sc, agno, agbno, &error))
> + error = xchk_ag_init(sc, agno, &sc->sa);
> + if (!xchk_xref_process_error(sc, agno, agbno, &error))
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, 1);
> - xfs_scrub_inode_xref_finobt(sc, ino);
> + xchk_xref_is_used_space(sc, agbno, 1);
> + xchk_inode_xref_finobt(sc, ino);
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
> - xfs_scrub_xref_is_owned_by(sc, agbno, 1, &oinfo);
> - xfs_scrub_xref_is_not_shared(sc, agbno, 1);
> - xfs_scrub_inode_xref_bmap(sc, dip);
> + xchk_xref_is_owned_by(sc, agbno, 1, &oinfo);
> + xchk_xref_is_not_shared(sc, agbno, 1);
> + xchk_inode_xref_bmap(sc, dip);
>
> - xfs_scrub_ag_free(sc, &sc->sa);
> + xchk_ag_free(sc, &sc->sa);
> }
>
> /*
> @@ -539,7 +539,7 @@ xfs_scrub_inode_xref(
> * reflink filesystem.
> */
> static void
> -xfs_scrub_inode_check_reflink_iflag(
> +xchk_inode_check_reflink_iflag(
> struct xfs_scrub_context *sc,
> xfs_ino_t ino)
> {
> @@ -552,18 +552,18 @@ xfs_scrub_inode_check_reflink_iflag(
>
> error = xfs_reflink_inode_has_shared_extents(sc->tp, sc->ip,
> &has_shared);
> - if (!xfs_scrub_xref_process_error(sc, XFS_INO_TO_AGNO(mp, ino),
> + if (!xchk_xref_process_error(sc, XFS_INO_TO_AGNO(mp, ino),
> XFS_INO_TO_AGBNO(mp, ino), &error))
> return;
> if (xfs_is_reflink_inode(sc->ip) && !has_shared)
> - xfs_scrub_ino_set_preen(sc, ino);
> + xchk_ino_set_preen(sc, ino);
> else if (!xfs_is_reflink_inode(sc->ip) && has_shared)
> - xfs_scrub_ino_set_corrupt(sc, ino);
> + xchk_ino_set_corrupt(sc, ino);
> }
>
> /* Scrub an inode. */
> int
> -xfs_scrub_inode(
> +xchk_inode(
> struct xfs_scrub_context *sc)
> {
> struct xfs_dinode di;
> @@ -575,13 +575,13 @@ xfs_scrub_inode(
> * and a NULL inode, so flag the corruption error and return.
> */
> if (!sc->ip) {
> - xfs_scrub_ino_set_corrupt(sc, sc->sm->sm_ino);
> + xchk_ino_set_corrupt(sc, sc->sm->sm_ino);
> return 0;
> }
>
> /* Scrub the inode core. */
> xfs_inode_to_disk(sc->ip, &di, 0);
> - xfs_scrub_dinode(sc, &di, sc->ip->i_ino);
> + xchk_dinode(sc, &di, sc->ip->i_ino);
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> goto out;
>
> @@ -591,9 +591,9 @@ xfs_scrub_inode(
> * we scrubbed the dinode.
> */
> if (S_ISREG(VFS_I(sc->ip)->i_mode))
> - xfs_scrub_inode_check_reflink_iflag(sc, sc->ip->i_ino);
> + xchk_inode_check_reflink_iflag(sc, sc->ip->i_ino);
>
> - xfs_scrub_inode_xref(sc, sc->ip->i_ino, &di);
> + xchk_inode_xref(sc, sc->ip->i_ino, &di);
> out:
> return error;
> }
> diff --git a/fs/xfs/scrub/parent.c b/fs/xfs/scrub/parent.c
> index e2bda58c32f0..0a78d8411f23 100644
> --- a/fs/xfs/scrub/parent.c
> +++ b/fs/xfs/scrub/parent.c
> @@ -27,18 +27,18 @@
>
> /* Set us up to scrub parents. */
> int
> -xfs_scrub_setup_parent(
> +xchk_setup_parent(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> - return xfs_scrub_setup_inode_contents(sc, ip, 0);
> + return xchk_setup_inode_contents(sc, ip, 0);
> }
>
> /* Parent pointers */
>
> /* Look for an entry in a parent pointing to this inode. */
>
> -struct xfs_scrub_parent_ctx {
> +struct xchk_parent_ctx {
> struct dir_context dc;
> xfs_ino_t ino;
> xfs_nlink_t nlink;
> @@ -46,7 +46,7 @@ struct xfs_scrub_parent_ctx {
>
> /* Look for a single entry in a directory pointing to an inode. */
> STATIC int
> -xfs_scrub_parent_actor(
> +xchk_parent_actor(
> struct dir_context *dc,
> const char *name,
> int namelen,
> @@ -54,9 +54,9 @@ xfs_scrub_parent_actor(
> u64 ino,
> unsigned type)
> {
> - struct xfs_scrub_parent_ctx *spc;
> + struct xchk_parent_ctx *spc;
>
> - spc = container_of(dc, struct xfs_scrub_parent_ctx, dc);
> + spc = container_of(dc, struct xchk_parent_ctx, dc);
> if (spc->ino == ino)
> spc->nlink++;
> return 0;
> @@ -64,13 +64,13 @@ xfs_scrub_parent_actor(
>
> /* Count the number of dentries in the parent dir that point to this inode. */
> STATIC int
> -xfs_scrub_parent_count_parent_dentries(
> +xchk_parent_count_parent_dentries(
> struct xfs_scrub_context *sc,
> struct xfs_inode *parent,
> xfs_nlink_t *nlink)
> {
> - struct xfs_scrub_parent_ctx spc = {
> - .dc.actor = xfs_scrub_parent_actor,
> + struct xchk_parent_ctx spc = {
> + .dc.actor = xchk_parent_actor,
> .dc.pos = 0,
> .ino = sc->ip->i_ino,
> .nlink = 0,
> @@ -120,7 +120,7 @@ xfs_scrub_parent_count_parent_dentries(
> * entry pointing back to the inode being scrubbed.
> */
> STATIC int
> -xfs_scrub_parent_validate(
> +xchk_parent_validate(
> struct xfs_scrub_context *sc,
> xfs_ino_t dnum,
> bool *try_again)
> @@ -138,7 +138,7 @@ xfs_scrub_parent_validate(
>
> /* '..' must not point to ourselves. */
> if (sc->ip->i_ino == dnum) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out;
> }
>
> @@ -165,13 +165,13 @@ xfs_scrub_parent_validate(
> error = xfs_iget(mp, sc->tp, dnum, XFS_IGET_UNTRUSTED, 0, &dp);
> if (error == -EINVAL) {
> error = -EFSCORRUPTED;
> - xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0, &error);
> + xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error);
> goto out;
> }
> - if (!xfs_scrub_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
> + if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
> goto out;
> if (dp == sc->ip || !S_ISDIR(VFS_I(dp)->i_mode)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out_rele;
> }
>
> @@ -183,12 +183,12 @@ xfs_scrub_parent_validate(
> * the child inodes.
> */
> if (xfs_ilock_nowait(dp, XFS_IOLOCK_SHARED)) {
> - error = xfs_scrub_parent_count_parent_dentries(sc, dp, &nlink);
> - if (!xfs_scrub_fblock_xref_process_error(sc, XFS_DATA_FORK, 0,
> + error = xchk_parent_count_parent_dentries(sc, dp, &nlink);
> + if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0,
> &error))
> goto out_unlock;
> if (nlink != expected_nlink)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out_unlock;
> }
>
> @@ -200,18 +200,18 @@ xfs_scrub_parent_validate(
> */
> xfs_iunlock(sc->ip, sc->ilock_flags);
> sc->ilock_flags = 0;
> - error = xfs_scrub_ilock_inverted(dp, XFS_IOLOCK_SHARED);
> + error = xchk_ilock_inverted(dp, XFS_IOLOCK_SHARED);
> if (error)
> goto out_rele;
>
> /* Go looking for our dentry. */
> - error = xfs_scrub_parent_count_parent_dentries(sc, dp, &nlink);
> - if (!xfs_scrub_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
> + error = xchk_parent_count_parent_dentries(sc, dp, &nlink);
> + if (!xchk_fblock_xref_process_error(sc, XFS_DATA_FORK, 0, &error))
> goto out_unlock;
>
> /* Drop the parent lock, relock this inode. */
> xfs_iunlock(dp, XFS_IOLOCK_SHARED);
> - error = xfs_scrub_ilock_inverted(sc->ip, XFS_IOLOCK_EXCL);
> + error = xchk_ilock_inverted(sc->ip, XFS_IOLOCK_EXCL);
> if (error)
> goto out_rele;
> sc->ilock_flags = XFS_IOLOCK_EXCL;
> @@ -225,7 +225,7 @@ xfs_scrub_parent_validate(
>
> /* Look up '..' to see if the inode changed. */
> error = xfs_dir_lookup(sc->tp, sc->ip, &xfs_name_dotdot, &dnum, NULL);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> goto out_rele;
>
> /* Drat, parent changed. Try again! */
> @@ -241,7 +241,7 @@ xfs_scrub_parent_validate(
> * for us in the parent.
> */
> if (nlink != expected_nlink)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> return error;
>
> out_unlock:
> @@ -254,7 +254,7 @@ xfs_scrub_parent_validate(
>
> /* Scrub a parent pointer. */
> int
> -xfs_scrub_parent(
> +xchk_parent(
> struct xfs_scrub_context *sc)
> {
> struct xfs_mount *mp = sc->mp;
> @@ -272,7 +272,7 @@ xfs_scrub_parent(
>
> /* We're not a special inode, are we? */
> if (!xfs_verify_dir_ino(mp, sc->ip->i_ino)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out;
> }
>
> @@ -288,10 +288,10 @@ xfs_scrub_parent(
>
> /* Look up '..' */
> error = xfs_dir_lookup(sc->tp, sc->ip, &xfs_name_dotdot, &dnum, NULL);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> goto out;
> if (!xfs_verify_dir_ino(mp, dnum)) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out;
> }
>
> @@ -299,12 +299,12 @@ xfs_scrub_parent(
> if (sc->ip == mp->m_rootip) {
> if (sc->ip->i_ino != mp->m_sb.sb_rootino ||
> sc->ip->i_ino != dnum)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out;
> }
>
> do {
> - error = xfs_scrub_parent_validate(sc, dnum, &try_again);
> + error = xchk_parent_validate(sc, dnum, &try_again);
> if (error)
> goto out;
> } while (try_again && ++tries < 20);
> @@ -314,7 +314,7 @@ xfs_scrub_parent(
> * incomplete. Userspace can decide if it wants to try again.
> */
> if (try_again && tries == 20)
> - xfs_scrub_set_incomplete(sc);
> + xchk_set_incomplete(sc);
> out:
> /*
> * If we failed to lock the parent inode even after a retry, just mark
> @@ -322,7 +322,7 @@ xfs_scrub_parent(
> */
> if (sc->try_harder && error == -EDEADLOCK) {
> error = 0;
> - xfs_scrub_set_incomplete(sc);
> + xchk_set_incomplete(sc);
> }
> return error;
> }
> diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
> index 6ff906aa0a3b..d1b52dd7efcd 100644
> --- a/fs/xfs/scrub/quota.c
> +++ b/fs/xfs/scrub/quota.c
> @@ -30,7 +30,7 @@
>
> /* Convert a scrub type code to a DQ flag, or return 0 if error. */
> static inline uint
> -xfs_scrub_quota_to_dqtype(
> +xchk_quota_to_dqtype(
> struct xfs_scrub_context *sc)
> {
> switch (sc->sm->sm_type) {
> @@ -47,7 +47,7 @@ xfs_scrub_quota_to_dqtype(
>
> /* Set us up to scrub a quota. */
> int
> -xfs_scrub_setup_quota(
> +xchk_setup_quota(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> @@ -57,14 +57,14 @@ xfs_scrub_setup_quota(
> if (!XFS_IS_QUOTA_RUNNING(sc->mp) || !XFS_IS_QUOTA_ON(sc->mp))
> return -ENOENT;
>
> - dqtype = xfs_scrub_quota_to_dqtype(sc);
> + dqtype = xchk_quota_to_dqtype(sc);
> if (dqtype == 0)
> return -EINVAL;
> sc->has_quotaofflock = true;
> mutex_lock(&sc->mp->m_quotainfo->qi_quotaofflock);
> if (!xfs_this_quota_on(sc->mp, dqtype))
> return -ENOENT;
> - error = xfs_scrub_setup_fs(sc, ip);
> + error = xchk_setup_fs(sc, ip);
> if (error)
> return error;
> sc->ip = xfs_quota_inode(sc->mp, dqtype);
> @@ -75,19 +75,19 @@ xfs_scrub_setup_quota(
>
> /* Quotas. */
>
> -struct xfs_scrub_quota_info {
> +struct xchk_quota_info {
> struct xfs_scrub_context *sc;
> xfs_dqid_t last_id;
> };
>
> /* Scrub the fields in an individual quota item. */
> STATIC int
> -xfs_scrub_quota_item(
> +xchk_quota_item(
> struct xfs_dquot *dq,
> uint dqtype,
> void *priv)
> {
> - struct xfs_scrub_quota_info *sqi = priv;
> + struct xchk_quota_info *sqi = priv;
> struct xfs_scrub_context *sc = sqi->sc;
> struct xfs_mount *mp = sc->mp;
> struct xfs_disk_dquot *d = &dq->q_core;
> @@ -111,16 +111,16 @@ xfs_scrub_quota_item(
> */
> offset = id / qi->qi_dqperchunk;
> if (id && id <= sqi->last_id)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> sqi->last_id = id;
>
> /* Did we get the dquot type we wanted? */
> if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> /* Check the limits. */
> bhard = be64_to_cpu(d->d_blk_hardlimit);
> @@ -140,19 +140,19 @@ xfs_scrub_quota_item(
> * the hard limit.
> */
> if (bhard > mp->m_sb.sb_dblocks)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> if (bsoft > bhard)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> if (ihard > mp->m_maxicount)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> if (isoft > ihard)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> if (rhard > mp->m_sb.sb_rblocks)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> if (rsoft > rhard)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> /* Check the resource counts. */
> bcount = be64_to_cpu(d->d_bcount);
> @@ -167,15 +167,15 @@ xfs_scrub_quota_item(
> */
> if (xfs_sb_version_hasreflink(&mp->m_sb)) {
> if (mp->m_sb.sb_dblocks < bcount)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK,
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK,
> offset);
> } else {
> if (mp->m_sb.sb_dblocks < bcount)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
> offset);
> }
> if (icount > fs_icount || rcount > mp->m_sb.sb_rblocks)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
>
> /*
> * We can violate the hard limits if the admin suddenly sets a
> @@ -183,18 +183,18 @@ xfs_scrub_quota_item(
> * admin review.
> */
> if (id != 0 && bhard != 0 && bcount > bhard)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> if (id != 0 && ihard != 0 && icount > ihard)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> if (id != 0 && rhard != 0 && rcount > rhard)
> - xfs_scrub_fblock_set_warning(sc, XFS_DATA_FORK, offset);
> + xchk_fblock_set_warning(sc, XFS_DATA_FORK, offset);
>
> return 0;
> }
>
> /* Check the quota's data fork. */
> STATIC int
> -xfs_scrub_quota_data_fork(
> +xchk_quota_data_fork(
> struct xfs_scrub_context *sc)
> {
> struct xfs_bmbt_irec irec = { 0 };
> @@ -205,7 +205,7 @@ xfs_scrub_quota_data_fork(
> int error = 0;
>
> /* Invoke the fork scrubber. */
> - error = xfs_scrub_metadata_inode_forks(sc);
> + error = xchk_metadata_inode_forks(sc);
> if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> return error;
>
> @@ -213,7 +213,7 @@ xfs_scrub_quota_data_fork(
> max_dqid_off = ((xfs_dqid_t)-1) / qi->qi_dqperchunk;
> ifp = XFS_IFORK_PTR(sc->ip, XFS_DATA_FORK);
> for_each_xfs_iext(ifp, &icur, &irec) {
> - if (xfs_scrub_should_terminate(sc, &error))
> + if (xchk_should_terminate(sc, &error))
> break;
> /*
> * delalloc extents or blocks mapped above the highest
> @@ -222,7 +222,7 @@ xfs_scrub_quota_data_fork(
> if (isnullstartblock(irec.br_startblock) ||
> irec.br_startoff > max_dqid_off ||
> irec.br_startoff + irec.br_blockcount - 1 > max_dqid_off) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK,
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK,
> irec.br_startoff);
> break;
> }
> @@ -233,19 +233,19 @@ xfs_scrub_quota_data_fork(
>
> /* Scrub all of a quota type's items. */
> int
> -xfs_scrub_quota(
> +xchk_quota(
> struct xfs_scrub_context *sc)
> {
> - struct xfs_scrub_quota_info sqi;
> + struct xchk_quota_info sqi;
> struct xfs_mount *mp = sc->mp;
> struct xfs_quotainfo *qi = mp->m_quotainfo;
> uint dqtype;
> int error = 0;
>
> - dqtype = xfs_scrub_quota_to_dqtype(sc);
> + dqtype = xchk_quota_to_dqtype(sc);
>
> /* Look for problem extents. */
> - error = xfs_scrub_quota_data_fork(sc);
> + error = xchk_quota_data_fork(sc);
> if (error)
> goto out;
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> @@ -260,10 +260,10 @@ xfs_scrub_quota(
> sc->ilock_flags = 0;
> sqi.sc = sc;
> sqi.last_id = 0;
> - error = xfs_qm_dqiterate(mp, dqtype, xfs_scrub_quota_item, &sqi);
> + error = xfs_qm_dqiterate(mp, dqtype, xchk_quota_item, &sqi);
> sc->ilock_flags = XFS_ILOCK_EXCL;
> xfs_ilock(sc->ip, sc->ilock_flags);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK,
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK,
> sqi.last_id * qi->qi_dqperchunk, &error))
> goto out;
>
> diff --git a/fs/xfs/scrub/refcount.c b/fs/xfs/scrub/refcount.c
> index 607a9faa8ecc..274febc49b23 100644
> --- a/fs/xfs/scrub/refcount.c
> +++ b/fs/xfs/scrub/refcount.c
> @@ -28,11 +28,11 @@
> * Set us up to scrub reference count btrees.
> */
> int
> -xfs_scrub_setup_ag_refcountbt(
> +xchk_setup_ag_refcountbt(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> - return xfs_scrub_setup_ag_btree(sc, ip, false);
> + return xchk_setup_ag_btree(sc, ip, false);
> }
>
> /* Reference count btree scrubber. */
> @@ -73,12 +73,12 @@ xfs_scrub_setup_ag_refcountbt(
> * If the refcount is correct, all the check conditions in the algorithm
> * should always hold true. If not, the refcount is incorrect.
> */
> -struct xfs_scrub_refcnt_frag {
> +struct xchk_refcnt_frag {
> struct list_head list;
> struct xfs_rmap_irec rm;
> };
>
> -struct xfs_scrub_refcnt_check {
> +struct xchk_refcnt_check {
> struct xfs_scrub_context *sc;
> struct list_head fragments;
>
> @@ -99,18 +99,18 @@ struct xfs_scrub_refcnt_check {
> * fragments as the refcountbt says we should have.
> */
> STATIC int
> -xfs_scrub_refcountbt_rmap_check(
> +xchk_refcountbt_rmap_check(
> struct xfs_btree_cur *cur,
> struct xfs_rmap_irec *rec,
> void *priv)
> {
> - struct xfs_scrub_refcnt_check *refchk = priv;
> - struct xfs_scrub_refcnt_frag *frag;
> + struct xchk_refcnt_check *refchk = priv;
> + struct xchk_refcnt_frag *frag;
> xfs_agblock_t rm_last;
> xfs_agblock_t rc_last;
> int error = 0;
>
> - if (xfs_scrub_should_terminate(refchk->sc, &error))
> + if (xchk_should_terminate(refchk->sc, &error))
> return error;
>
> rm_last = rec->rm_startblock + rec->rm_blockcount - 1;
> @@ -118,7 +118,7 @@ xfs_scrub_refcountbt_rmap_check(
>
> /* Confirm that a single-owner refc extent is a CoW stage. */
> if (refchk->refcount == 1 && rec->rm_owner != XFS_RMAP_OWN_COW) {
> - xfs_scrub_btree_xref_set_corrupt(refchk->sc, cur, 0);
> + xchk_btree_xref_set_corrupt(refchk->sc, cur, 0);
> return 0;
> }
>
> @@ -135,7 +135,7 @@ xfs_scrub_refcountbt_rmap_check(
> * is healthy each rmap_irec we see will be in agbno order
> * so we don't need insertion sort here.
> */
> - frag = kmem_alloc(sizeof(struct xfs_scrub_refcnt_frag),
> + frag = kmem_alloc(sizeof(struct xchk_refcnt_frag),
> KM_MAYFAIL);
> if (!frag)
> return -ENOMEM;
> @@ -154,12 +154,12 @@ xfs_scrub_refcountbt_rmap_check(
> * we have a refcountbt error.
> */
> STATIC void
> -xfs_scrub_refcountbt_process_rmap_fragments(
> - struct xfs_scrub_refcnt_check *refchk)
> +xchk_refcountbt_process_rmap_fragments(
> + struct xchk_refcnt_check *refchk)
> {
> struct list_head worklist;
> - struct xfs_scrub_refcnt_frag *frag;
> - struct xfs_scrub_refcnt_frag *n;
> + struct xchk_refcnt_frag *frag;
> + struct xchk_refcnt_frag *n;
> xfs_agblock_t bno;
> xfs_agblock_t rbno;
> xfs_agblock_t next_rbno;
> @@ -277,13 +277,13 @@ xfs_scrub_refcountbt_process_rmap_fragments(
>
> /* Use the rmap entries covering this extent to verify the refcount. */
> STATIC void
> -xfs_scrub_refcountbt_xref_rmap(
> +xchk_refcountbt_xref_rmap(
> struct xfs_scrub_context *sc,
> xfs_agblock_t bno,
> xfs_extlen_t len,
> xfs_nlink_t refcount)
> {
> - struct xfs_scrub_refcnt_check refchk = {
> + struct xchk_refcnt_check refchk = {
> .sc = sc,
> .bno = bno,
> .len = len,
> @@ -292,11 +292,11 @@ xfs_scrub_refcountbt_xref_rmap(
> };
> struct xfs_rmap_irec low;
> struct xfs_rmap_irec high;
> - struct xfs_scrub_refcnt_frag *frag;
> - struct xfs_scrub_refcnt_frag *n;
> + struct xchk_refcnt_frag *frag;
> + struct xchk_refcnt_frag *n;
> int error;
>
> - if (!sc->sa.rmap_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
> return;
>
> /* Cross-reference with the rmapbt to confirm the refcount. */
> @@ -307,13 +307,13 @@ xfs_scrub_refcountbt_xref_rmap(
>
> INIT_LIST_HEAD(&refchk.fragments);
> error = xfs_rmap_query_range(sc->sa.rmap_cur, &low, &high,
> - &xfs_scrub_refcountbt_rmap_check, &refchk);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + &xchk_refcountbt_rmap_check, &refchk);
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> goto out_free;
>
> - xfs_scrub_refcountbt_process_rmap_fragments(&refchk);
> + xchk_refcountbt_process_rmap_fragments(&refchk);
> if (refcount != refchk.seen)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
>
> out_free:
> list_for_each_entry_safe(frag, n, &refchk.fragments, list) {
> @@ -324,7 +324,7 @@ xfs_scrub_refcountbt_xref_rmap(
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_refcountbt_xref(
> +xchk_refcountbt_xref(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len,
> @@ -333,15 +333,15 @@ xfs_scrub_refcountbt_xref(
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, len);
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, len);
> - xfs_scrub_refcountbt_xref_rmap(sc, agbno, len, refcount);
> + xchk_xref_is_used_space(sc, agbno, len);
> + xchk_xref_is_not_inode_chunk(sc, agbno, len);
> + xchk_refcountbt_xref_rmap(sc, agbno, len, refcount);
> }
>
> /* Scrub a refcountbt record. */
> STATIC int
> -xfs_scrub_refcountbt_rec(
> - struct xfs_scrub_btree *bs,
> +xchk_refcountbt_rec(
> + struct xchk_btree *bs,
> union xfs_btree_rec *rec)
> {
> struct xfs_mount *mp = bs->cur->bc_mp;
> @@ -360,7 +360,7 @@ xfs_scrub_refcountbt_rec(
> /* Only CoW records can have refcount == 1. */
> has_cowflag = (bno & XFS_REFC_COW_START);
> if ((refcount == 1 && !has_cowflag) || (refcount != 1 && has_cowflag))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> if (has_cowflag)
> (*cow_blocks) += len;
>
> @@ -369,19 +369,19 @@ xfs_scrub_refcountbt_rec(
> if (bno + len <= bno ||
> !xfs_verify_agbno(mp, agno, bno) ||
> !xfs_verify_agbno(mp, agno, bno + len - 1))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> if (refcount == 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> - xfs_scrub_refcountbt_xref(bs->sc, bno, len, refcount);
> + xchk_refcountbt_xref(bs->sc, bno, len, refcount);
>
> return error;
> }
>
> /* Make sure we have as many refc blocks as the rmap says. */
> STATIC void
> -xfs_scrub_refcount_xref_rmap(
> +xchk_refcount_xref_rmap(
> struct xfs_scrub_context *sc,
> struct xfs_owner_info *oinfo,
> xfs_filblks_t cow_blocks)
> @@ -390,33 +390,33 @@ xfs_scrub_refcount_xref_rmap(
> xfs_filblks_t blocks;
> int error;
>
> - if (!sc->sa.rmap_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
> return;
>
> /* Check that we saw as many refcbt blocks as the rmap knows about. */
> error = xfs_btree_count_blocks(sc->sa.refc_cur, &refcbt_blocks);
> - if (!xfs_scrub_btree_process_error(sc, sc->sa.refc_cur, 0, &error))
> + if (!xchk_btree_process_error(sc, sc->sa.refc_cur, 0, &error))
> return;
> - error = xfs_scrub_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, oinfo,
> + error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, oinfo,
> &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> if (blocks != refcbt_blocks)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
>
> /* Check that we saw as many cow blocks as the rmap knows about. */
> xfs_rmap_ag_owner(oinfo, XFS_RMAP_OWN_COW);
> - error = xfs_scrub_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, oinfo,
> + error = xchk_count_rmap_ownedby_ag(sc, sc->sa.rmap_cur, oinfo,
> &blocks);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> if (blocks != cow_blocks)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> }
>
> /* Scrub the refcount btree for some AG. */
> int
> -xfs_scrub_refcountbt(
> +xchk_refcountbt(
> struct xfs_scrub_context *sc)
> {
> struct xfs_owner_info oinfo;
> @@ -424,19 +424,19 @@ xfs_scrub_refcountbt(
> int error;
>
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_REFC);
> - error = xfs_scrub_btree(sc, sc->sa.refc_cur, xfs_scrub_refcountbt_rec,
> + error = xchk_btree(sc, sc->sa.refc_cur, xchk_refcountbt_rec,
> &oinfo, &cow_blocks);
> if (error)
> return error;
>
> - xfs_scrub_refcount_xref_rmap(sc, &oinfo, cow_blocks);
> + xchk_refcount_xref_rmap(sc, &oinfo, cow_blocks);
>
> return 0;
> }
>
> /* xref check that a cow staging extent is marked in the refcountbt. */
> void
> -xfs_scrub_xref_is_cow_staging(
> +xchk_xref_is_cow_staging(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> @@ -446,35 +446,35 @@ xfs_scrub_xref_is_cow_staging(
> int has_refcount;
> int error;
>
> - if (!sc->sa.refc_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.refc_cur || xchk_skip_xref(sc->sm))
> return;
>
> /* Find the CoW staging extent. */
> error = xfs_refcount_lookup_le(sc->sa.refc_cur,
> agbno + XFS_REFC_COW_START, &has_refcount);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.refc_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur))
> return;
> if (!has_refcount) {
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> return;
> }
>
> error = xfs_refcount_get_rec(sc->sa.refc_cur, &rc, &has_refcount);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.refc_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur))
> return;
> if (!has_refcount) {
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> return;
> }
>
> /* CoW flag must be set, refcount must be 1. */
> has_cowflag = (rc.rc_startblock & XFS_REFC_COW_START);
> if (!has_cowflag || rc.rc_refcount != 1)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
>
> /* Must be at least as long as what was passed in */
> if (rc.rc_blockcount < len)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> }
>
> /*
> @@ -482,7 +482,7 @@ xfs_scrub_xref_is_cow_staging(
> * can have multiple owners.
> */
> void
> -xfs_scrub_xref_is_not_shared(
> +xchk_xref_is_not_shared(
> struct xfs_scrub_context *sc,
> xfs_agblock_t agbno,
> xfs_extlen_t len)
> @@ -490,12 +490,12 @@ xfs_scrub_xref_is_not_shared(
> bool shared;
> int error;
>
> - if (!sc->sa.refc_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.refc_cur || xchk_skip_xref(sc->sm))
> return;
>
> error = xfs_refcount_has_record(sc->sa.refc_cur, agbno, len, &shared);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.refc_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur))
> return;
> if (shared)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> }
> diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
> index ea39e2bdc96a..5eccd89c64a8 100644
> --- a/fs/xfs/scrub/repair.c
> +++ b/fs/xfs/scrub/repair.c
> @@ -50,7 +50,7 @@ xfs_repair_attempt(
>
> trace_xfs_repair_attempt(ip, sc->sm, error);
>
> - xfs_scrub_ag_btcur_free(&sc->sa);
> + xchk_ag_btcur_free(&sc->sa);
>
> /* Repair whatever's broken. */
> ASSERT(sc->ops->repair);
> @@ -110,7 +110,7 @@ xfs_repair_probe(
> {
> int error = 0;
>
> - if (xfs_scrub_should_terminate(sc, &error))
> + if (xchk_should_terminate(sc, &error))
> return error;
>
> return 0;
> diff --git a/fs/xfs/scrub/rmap.c b/fs/xfs/scrub/rmap.c
> index c6d763236ba7..4b75fc2f31f3 100644
> --- a/fs/xfs/scrub/rmap.c
> +++ b/fs/xfs/scrub/rmap.c
> @@ -29,18 +29,18 @@
> * Set us up to scrub reverse mapping btrees.
> */
> int
> -xfs_scrub_setup_ag_rmapbt(
> +xchk_setup_ag_rmapbt(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> - return xfs_scrub_setup_ag_btree(sc, ip, false);
> + return xchk_setup_ag_btree(sc, ip, false);
> }
>
> /* Reverse-mapping scrubber. */
>
> /* Cross-reference a rmap against the refcount btree. */
> STATIC void
> -xfs_scrub_rmapbt_xref_refc(
> +xchk_rmapbt_xref_refc(
> struct xfs_scrub_context *sc,
> struct xfs_rmap_irec *irec)
> {
> @@ -52,7 +52,7 @@ xfs_scrub_rmapbt_xref_refc(
> bool is_unwritten;
> int error;
>
> - if (!sc->sa.refc_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.refc_cur || xchk_skip_xref(sc->sm))
> return;
>
> non_inode = XFS_RMAP_NON_INODE_OWNER(irec->rm_owner);
> @@ -63,15 +63,15 @@ xfs_scrub_rmapbt_xref_refc(
> /* If this is shared, must be a data fork extent. */
> error = xfs_refcount_find_shared(sc->sa.refc_cur, irec->rm_startblock,
> irec->rm_blockcount, &fbno, &flen, false);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.refc_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.refc_cur))
> return;
> if (flen != 0 && (non_inode || is_attr || is_bmbt || is_unwritten))
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.refc_cur, 0);
> }
>
> /* Cross-reference with the other btrees. */
> STATIC void
> -xfs_scrub_rmapbt_xref(
> +xchk_rmapbt_xref(
> struct xfs_scrub_context *sc,
> struct xfs_rmap_irec *irec)
> {
> @@ -81,22 +81,22 @@ xfs_scrub_rmapbt_xref(
> if (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT)
> return;
>
> - xfs_scrub_xref_is_used_space(sc, agbno, len);
> + xchk_xref_is_used_space(sc, agbno, len);
> if (irec->rm_owner == XFS_RMAP_OWN_INODES)
> - xfs_scrub_xref_is_inode_chunk(sc, agbno, len);
> + xchk_xref_is_inode_chunk(sc, agbno, len);
> else
> - xfs_scrub_xref_is_not_inode_chunk(sc, agbno, len);
> + xchk_xref_is_not_inode_chunk(sc, agbno, len);
> if (irec->rm_owner == XFS_RMAP_OWN_COW)
> - xfs_scrub_xref_is_cow_staging(sc, irec->rm_startblock,
> + xchk_xref_is_cow_staging(sc, irec->rm_startblock,
> irec->rm_blockcount);
> else
> - xfs_scrub_rmapbt_xref_refc(sc, irec);
> + xchk_rmapbt_xref_refc(sc, irec);
> }
>
> /* Scrub an rmapbt record. */
> STATIC int
> -xfs_scrub_rmapbt_rec(
> - struct xfs_scrub_btree *bs,
> +xchk_rmapbt_rec(
> + struct xchk_btree *bs,
> union xfs_btree_rec *rec)
> {
> struct xfs_mount *mp = bs->cur->bc_mp;
> @@ -109,12 +109,12 @@ xfs_scrub_rmapbt_rec(
> int error;
>
> error = xfs_rmap_btrec_to_irec(rec, &irec);
> - if (!xfs_scrub_btree_process_error(bs->sc, bs->cur, 0, &error))
> + if (!xchk_btree_process_error(bs->sc, bs->cur, 0, &error))
> goto out;
>
> /* Check extent. */
> if (irec.rm_startblock + irec.rm_blockcount <= irec.rm_startblock)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> if (irec.rm_owner == XFS_RMAP_OWN_FS) {
> /*
> @@ -124,7 +124,7 @@ xfs_scrub_rmapbt_rec(
> */
> if (irec.rm_startblock != 0 ||
> irec.rm_blockcount != XFS_AGFL_BLOCK(mp) + 1)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> } else {
> /*
> * Otherwise we must point somewhere past the static metadata
> @@ -133,7 +133,7 @@ xfs_scrub_rmapbt_rec(
> if (!xfs_verify_agbno(mp, agno, irec.rm_startblock) ||
> !xfs_verify_agbno(mp, agno, irec.rm_startblock +
> irec.rm_blockcount - 1))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> }
>
> /* Check flags. */
> @@ -143,47 +143,47 @@ xfs_scrub_rmapbt_rec(
> is_unwritten = irec.rm_flags & XFS_RMAP_UNWRITTEN;
>
> if (is_bmbt && irec.rm_offset != 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> if (non_inode && irec.rm_offset != 0)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> if (is_unwritten && (is_bmbt || non_inode || is_attr))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> if (non_inode && (is_bmbt || is_unwritten || is_attr))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
>
> if (!non_inode) {
> if (!xfs_verify_ino(mp, irec.rm_owner))
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> } else {
> /* Non-inode owner within the magic values? */
> if (irec.rm_owner <= XFS_RMAP_OWN_MIN ||
> irec.rm_owner > XFS_RMAP_OWN_FS)
> - xfs_scrub_btree_set_corrupt(bs->sc, bs->cur, 0);
> + xchk_btree_set_corrupt(bs->sc, bs->cur, 0);
> }
>
> - xfs_scrub_rmapbt_xref(bs->sc, &irec);
> + xchk_rmapbt_xref(bs->sc, &irec);
> out:
> return error;
> }
>
> /* Scrub the rmap btree for some AG. */
> int
> -xfs_scrub_rmapbt(
> +xchk_rmapbt(
> struct xfs_scrub_context *sc)
> {
> struct xfs_owner_info oinfo;
>
> xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_AG);
> - return xfs_scrub_btree(sc, sc->sa.rmap_cur, xfs_scrub_rmapbt_rec,
> + return xchk_btree(sc, sc->sa.rmap_cur, xchk_rmapbt_rec,
> &oinfo, NULL);
> }
>
> /* xref check that the extent is owned by a given owner */
> static inline void
> -xfs_scrub_xref_check_owner(
> +xchk_xref_check_owner(
> struct xfs_scrub_context *sc,
> xfs_agblock_t bno,
> xfs_extlen_t len,
> @@ -193,42 +193,42 @@ xfs_scrub_xref_check_owner(
> bool has_rmap;
> int error;
>
> - if (!sc->sa.rmap_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
> return;
>
> error = xfs_rmap_record_exists(sc->sa.rmap_cur, bno, len, oinfo,
> &has_rmap);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> if (has_rmap != should_have_rmap)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> }
>
> /* xref check that the extent is owned by a given owner */
> void
> -xfs_scrub_xref_is_owned_by(
> +xchk_xref_is_owned_by(
> struct xfs_scrub_context *sc,
> xfs_agblock_t bno,
> xfs_extlen_t len,
> struct xfs_owner_info *oinfo)
> {
> - xfs_scrub_xref_check_owner(sc, bno, len, oinfo, true);
> + xchk_xref_check_owner(sc, bno, len, oinfo, true);
> }
>
> /* xref check that the extent is not owned by a given owner */
> void
> -xfs_scrub_xref_is_not_owned_by(
> +xchk_xref_is_not_owned_by(
> struct xfs_scrub_context *sc,
> xfs_agblock_t bno,
> xfs_extlen_t len,
> struct xfs_owner_info *oinfo)
> {
> - xfs_scrub_xref_check_owner(sc, bno, len, oinfo, false);
> + xchk_xref_check_owner(sc, bno, len, oinfo, false);
> }
>
> /* xref check that the extent has no reverse mapping at all */
> void
> -xfs_scrub_xref_has_no_owner(
> +xchk_xref_has_no_owner(
> struct xfs_scrub_context *sc,
> xfs_agblock_t bno,
> xfs_extlen_t len)
> @@ -236,12 +236,12 @@ xfs_scrub_xref_has_no_owner(
> bool has_rmap;
> int error;
>
> - if (!sc->sa.rmap_cur || xfs_scrub_skip_xref(sc->sm))
> + if (!sc->sa.rmap_cur || xchk_skip_xref(sc->sm))
> return;
>
> error = xfs_rmap_has_record(sc->sa.rmap_cur, bno, len, &has_rmap);
> - if (!xfs_scrub_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> + if (!xchk_should_check_xref(sc, &error, &sc->sa.rmap_cur))
> return;
> if (has_rmap)
> - xfs_scrub_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> + xchk_btree_xref_set_corrupt(sc, sc->sa.rmap_cur, 0);
> }
> diff --git a/fs/xfs/scrub/rtbitmap.c b/fs/xfs/scrub/rtbitmap.c
> index 1f86e02a07ca..3f0fc83562ae 100644
> --- a/fs/xfs/scrub/rtbitmap.c
> +++ b/fs/xfs/scrub/rtbitmap.c
> @@ -25,13 +25,13 @@
>
> /* Set us up with the realtime metadata locked. */
> int
> -xfs_scrub_setup_rt(
> +xchk_setup_rt(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> int error;
>
> - error = xfs_scrub_setup_fs(sc, ip);
> + error = xchk_setup_fs(sc, ip);
> if (error)
> return error;
>
> @@ -46,7 +46,7 @@ xfs_scrub_setup_rt(
>
> /* Scrub a free extent record from the realtime bitmap. */
> STATIC int
> -xfs_scrub_rtbitmap_rec(
> +xchk_rtbitmap_rec(
> struct xfs_trans *tp,
> struct xfs_rtalloc_rec *rec,
> void *priv)
> @@ -61,24 +61,24 @@ xfs_scrub_rtbitmap_rec(
> if (startblock + blockcount <= startblock ||
> !xfs_verify_rtbno(sc->mp, startblock) ||
> !xfs_verify_rtbno(sc->mp, startblock + blockcount - 1))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> return 0;
> }
>
> /* Scrub the realtime bitmap. */
> int
> -xfs_scrub_rtbitmap(
> +xchk_rtbitmap(
> struct xfs_scrub_context *sc)
> {
> int error;
>
> /* Invoke the fork scrubber. */
> - error = xfs_scrub_metadata_inode_forks(sc);
> + error = xchk_metadata_inode_forks(sc);
> if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> return error;
>
> - error = xfs_rtalloc_query_all(sc->tp, xfs_scrub_rtbitmap_rec, sc);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> + error = xfs_rtalloc_query_all(sc->tp, xchk_rtbitmap_rec, sc);
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> goto out;
>
> out:
> @@ -87,7 +87,7 @@ xfs_scrub_rtbitmap(
>
> /* Scrub the realtime summary. */
> int
> -xfs_scrub_rtsummary(
> +xchk_rtsummary(
> struct xfs_scrub_context *sc)
> {
> struct xfs_inode *rsumip = sc->mp->m_rsumip;
> @@ -107,12 +107,12 @@ xfs_scrub_rtsummary(
> xfs_ilock(sc->ip, sc->ilock_flags);
>
> /* Invoke the fork scrubber. */
> - error = xfs_scrub_metadata_inode_forks(sc);
> + error = xchk_metadata_inode_forks(sc);
> if (error || (sc->sm->sm_flags & XFS_SCRUB_OFLAG_CORRUPT))
> goto out;
>
> /* XXX: implement this some day */
> - xfs_scrub_set_incomplete(sc);
> + xchk_set_incomplete(sc);
> out:
> /* Switch back to the rtbitmap inode and lock flags. */
> xfs_iunlock(sc->ip, sc->ilock_flags);
> @@ -124,7 +124,7 @@ xfs_scrub_rtsummary(
>
> /* xref check that the extent is not free in the rtbitmap */
> void
> -xfs_scrub_xref_is_used_rt_space(
> +xchk_xref_is_used_rt_space(
> struct xfs_scrub_context *sc,
> xfs_rtblock_t fsbno,
> xfs_extlen_t len)
> @@ -135,7 +135,7 @@ xfs_scrub_xref_is_used_rt_space(
> bool is_free;
> int error;
>
> - if (xfs_scrub_skip_xref(sc->sm))
> + if (xchk_skip_xref(sc->sm))
> return;
>
> startext = fsbno;
> @@ -147,10 +147,10 @@ xfs_scrub_xref_is_used_rt_space(
> xfs_ilock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
> error = xfs_rtalloc_extent_is_free(sc->mp, sc->tp, startext, extcount,
> &is_free);
> - if (!xfs_scrub_should_check_xref(sc, &error, NULL))
> + if (!xchk_should_check_xref(sc, &error, NULL))
> goto out_unlock;
> if (is_free)
> - xfs_scrub_ino_xref_set_corrupt(sc, sc->mp->m_rbmip->i_ino);
> + xchk_ino_xref_set_corrupt(sc, sc->mp->m_rbmip->i_ino);
> out_unlock:
> xfs_iunlock(sc->mp->m_rbmip, XFS_ILOCK_SHARED | XFS_ILOCK_RTBITMAP);
> }
> diff --git a/fs/xfs/scrub/scrub.c b/fs/xfs/scrub/scrub.c
> index 58ae76b3a421..ead97ab91a3c 100644
> --- a/fs/xfs/scrub/scrub.c
> +++ b/fs/xfs/scrub/scrub.c
> @@ -131,6 +131,12 @@
> * optimize the structure so that the rebuild knows what to do. The
> * second check evaluates the completeness of the repair; that is what
> * is reported to userspace.
> + *
> + * A quick note on symbol prefixes:
> + * - "xfs_" are general XFS symbols.
> + * - "xchk_" are symbols related to metadata checking.
> + * - "xrep_" are symbols related to metadata repair.
> + * - "xfs_scrub_" are symbols that tie online fsck to the rest of XFS.
> */
>
> /*
> @@ -144,12 +150,12 @@
> * supported by the running kernel.
> */
> static int
> -xfs_scrub_probe(
> +xchk_probe(
> struct xfs_scrub_context *sc)
> {
> int error = 0;
>
> - if (xfs_scrub_should_terminate(sc, &error))
> + if (xchk_should_terminate(sc, &error))
> return error;
>
> return 0;
> @@ -159,12 +165,12 @@ xfs_scrub_probe(
>
> /* Free all the resources and finish the transactions. */
> STATIC int
> -xfs_scrub_teardown(
> +xchk_teardown(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip_in,
> int error)
> {
> - xfs_scrub_ag_free(sc, &sc->sa);
> + xchk_ag_free(sc, &sc->sa);
> if (sc->tp) {
> if (error == 0 && (sc->sm->sm_flags & XFS_SCRUB_IFLAG_REPAIR))
> error = xfs_trans_commit(sc->tp);
> @@ -191,165 +197,165 @@ xfs_scrub_teardown(
>
> /* Scrubbing dispatch. */
>
> -static const struct xfs_scrub_meta_ops meta_scrub_ops[] = {
> +static const struct xchk_meta_ops meta_scrub_ops[] = {
> [XFS_SCRUB_TYPE_PROBE] = { /* ioctl presence test */
> .type = ST_NONE,
> - .setup = xfs_scrub_setup_fs,
> - .scrub = xfs_scrub_probe,
> + .setup = xchk_setup_fs,
> + .scrub = xchk_probe,
> .repair = xfs_repair_probe,
> },
> [XFS_SCRUB_TYPE_SB] = { /* superblock */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_fs,
> - .scrub = xfs_scrub_superblock,
> + .setup = xchk_setup_fs,
> + .scrub = xchk_superblock,
> .repair = xfs_repair_superblock,
> },
> [XFS_SCRUB_TYPE_AGF] = { /* agf */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_fs,
> - .scrub = xfs_scrub_agf,
> + .setup = xchk_setup_fs,
> + .scrub = xchk_agf,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_AGFL]= { /* agfl */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_fs,
> - .scrub = xfs_scrub_agfl,
> + .setup = xchk_setup_fs,
> + .scrub = xchk_agfl,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_AGI] = { /* agi */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_fs,
> - .scrub = xfs_scrub_agi,
> + .setup = xchk_setup_fs,
> + .scrub = xchk_agi,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_BNOBT] = { /* bnobt */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_ag_allocbt,
> - .scrub = xfs_scrub_bnobt,
> + .setup = xchk_setup_ag_allocbt,
> + .scrub = xchk_bnobt,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_CNTBT] = { /* cntbt */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_ag_allocbt,
> - .scrub = xfs_scrub_cntbt,
> + .setup = xchk_setup_ag_allocbt,
> + .scrub = xchk_cntbt,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_INOBT] = { /* inobt */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_ag_iallocbt,
> - .scrub = xfs_scrub_inobt,
> + .setup = xchk_setup_ag_iallocbt,
> + .scrub = xchk_inobt,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_FINOBT] = { /* finobt */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_ag_iallocbt,
> - .scrub = xfs_scrub_finobt,
> + .setup = xchk_setup_ag_iallocbt,
> + .scrub = xchk_finobt,
> .has = xfs_sb_version_hasfinobt,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_RMAPBT] = { /* rmapbt */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_ag_rmapbt,
> - .scrub = xfs_scrub_rmapbt,
> + .setup = xchk_setup_ag_rmapbt,
> + .scrub = xchk_rmapbt,
> .has = xfs_sb_version_hasrmapbt,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_REFCNTBT] = { /* refcountbt */
> .type = ST_PERAG,
> - .setup = xfs_scrub_setup_ag_refcountbt,
> - .scrub = xfs_scrub_refcountbt,
> + .setup = xchk_setup_ag_refcountbt,
> + .scrub = xchk_refcountbt,
> .has = xfs_sb_version_hasreflink,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_INODE] = { /* inode record */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_inode,
> - .scrub = xfs_scrub_inode,
> + .setup = xchk_setup_inode,
> + .scrub = xchk_inode,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_BMBTD] = { /* inode data fork */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_inode_bmap,
> - .scrub = xfs_scrub_bmap_data,
> + .setup = xchk_setup_inode_bmap,
> + .scrub = xchk_bmap_data,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_BMBTA] = { /* inode attr fork */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_inode_bmap,
> - .scrub = xfs_scrub_bmap_attr,
> + .setup = xchk_setup_inode_bmap,
> + .scrub = xchk_bmap_attr,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_BMBTC] = { /* inode CoW fork */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_inode_bmap,
> - .scrub = xfs_scrub_bmap_cow,
> + .setup = xchk_setup_inode_bmap,
> + .scrub = xchk_bmap_cow,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_DIR] = { /* directory */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_directory,
> - .scrub = xfs_scrub_directory,
> + .setup = xchk_setup_directory,
> + .scrub = xchk_directory,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_XATTR] = { /* extended attributes */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_xattr,
> - .scrub = xfs_scrub_xattr,
> + .setup = xchk_setup_xattr,
> + .scrub = xchk_xattr,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_SYMLINK] = { /* symbolic link */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_symlink,
> - .scrub = xfs_scrub_symlink,
> + .setup = xchk_setup_symlink,
> + .scrub = xchk_symlink,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_PARENT] = { /* parent pointers */
> .type = ST_INODE,
> - .setup = xfs_scrub_setup_parent,
> - .scrub = xfs_scrub_parent,
> + .setup = xchk_setup_parent,
> + .scrub = xchk_parent,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_RTBITMAP] = { /* realtime bitmap */
> .type = ST_FS,
> - .setup = xfs_scrub_setup_rt,
> - .scrub = xfs_scrub_rtbitmap,
> + .setup = xchk_setup_rt,
> + .scrub = xchk_rtbitmap,
> .has = xfs_sb_version_hasrealtime,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_RTSUM] = { /* realtime summary */
> .type = ST_FS,
> - .setup = xfs_scrub_setup_rt,
> - .scrub = xfs_scrub_rtsummary,
> + .setup = xchk_setup_rt,
> + .scrub = xchk_rtsummary,
> .has = xfs_sb_version_hasrealtime,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_UQUOTA] = { /* user quota */
> .type = ST_FS,
> - .setup = xfs_scrub_setup_quota,
> - .scrub = xfs_scrub_quota,
> + .setup = xchk_setup_quota,
> + .scrub = xchk_quota,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_GQUOTA] = { /* group quota */
> .type = ST_FS,
> - .setup = xfs_scrub_setup_quota,
> - .scrub = xfs_scrub_quota,
> + .setup = xchk_setup_quota,
> + .scrub = xchk_quota,
> .repair = xfs_repair_notsupported,
> },
> [XFS_SCRUB_TYPE_PQUOTA] = { /* project quota */
> .type = ST_FS,
> - .setup = xfs_scrub_setup_quota,
> - .scrub = xfs_scrub_quota,
> + .setup = xchk_setup_quota,
> + .scrub = xchk_quota,
> .repair = xfs_repair_notsupported,
> },
> };
>
> /* This isn't a stable feature, warn once per day. */
> static inline void
> -xfs_scrub_experimental_warning(
> +xchk_experimental_warning(
> struct xfs_mount *mp)
> {
> static struct ratelimit_state scrub_warning = RATELIMIT_STATE_INIT(
> - "xfs_scrub_warning", 86400 * HZ, 1);
> + "xchk_warning", 86400 * HZ, 1);
> ratelimit_set_flags(&scrub_warning, RATELIMIT_MSG_ON_RELEASE);
>
> if (__ratelimit(&scrub_warning))
> @@ -358,12 +364,12 @@ xfs_scrub_experimental_warning(
> }
>
> static int
> -xfs_scrub_validate_inputs(
> +xchk_validate_inputs(
> struct xfs_mount *mp,
> struct xfs_scrub_metadata *sm)
> {
> int error;
> - const struct xfs_scrub_meta_ops *ops;
> + const struct xchk_meta_ops *ops;
>
> error = -EINVAL;
> /* Check our inputs. */
> @@ -441,7 +447,7 @@ xfs_scrub_validate_inputs(
> }
>
> #ifdef CONFIG_XFS_ONLINE_REPAIR
> -static inline void xfs_scrub_postmortem(struct xfs_scrub_context *sc)
> +static inline void xchk_postmortem(struct xfs_scrub_context *sc)
> {
> /*
> * Userspace asked us to repair something, we repaired it, rescanned
> @@ -454,7 +460,7 @@ static inline void xfs_scrub_postmortem(struct xfs_scrub_context *sc)
> xfs_repair_failure(sc->mp);
> }
> #else
> -static inline void xfs_scrub_postmortem(struct xfs_scrub_context *sc)
> +static inline void xchk_postmortem(struct xfs_scrub_context *sc)
> {
> /*
> * Userspace asked us to scrub something, it's broken, and we have no
> @@ -480,9 +486,9 @@ xfs_scrub_metadata(
> int error = 0;
>
> BUILD_BUG_ON(sizeof(meta_scrub_ops) !=
> - (sizeof(struct xfs_scrub_meta_ops) * XFS_SCRUB_TYPE_NR));
> + (sizeof(struct xchk_meta_ops) * XFS_SCRUB_TYPE_NR));
>
> - trace_xfs_scrub_start(ip, sm, error);
> + trace_xchk_start(ip, sm, error);
>
> /* Forbidden if we are shut down or mounted norecovery. */
> error = -ESHUTDOWN;
> @@ -492,11 +498,11 @@ xfs_scrub_metadata(
> if (mp->m_flags & XFS_MOUNT_NORECOVERY)
> goto out;
>
> - error = xfs_scrub_validate_inputs(mp, sm);
> + error = xchk_validate_inputs(mp, sm);
> if (error)
> goto out;
>
> - xfs_scrub_experimental_warning(mp);
> + xchk_experimental_warning(mp);
>
> retry_op:
> /* Set up for the operation. */
> @@ -518,7 +524,7 @@ xfs_scrub_metadata(
> * Tear down everything we hold, then set up again with
> * preparation for worst-case scenarios.
> */
> - error = xfs_scrub_teardown(&sc, ip, 0);
> + error = xchk_teardown(&sc, ip, 0);
> if (error)
> goto out;
> try_harder = true;
> @@ -553,7 +559,7 @@ xfs_scrub_metadata(
> if (error == -EAGAIN) {
> if (sc.try_harder)
> try_harder = true;
> - error = xfs_scrub_teardown(&sc, ip, 0);
> + error = xchk_teardown(&sc, ip, 0);
> if (error) {
> xfs_repair_failure(mp);
> goto out;
> @@ -563,11 +569,11 @@ xfs_scrub_metadata(
> }
>
> out_nofix:
> - xfs_scrub_postmortem(&sc);
> + xchk_postmortem(&sc);
> out_teardown:
> - error = xfs_scrub_teardown(&sc, ip, error);
> + error = xchk_teardown(&sc, ip, error);
> out:
> - trace_xfs_scrub_done(ip, sm, error);
> + trace_xchk_done(ip, sm, error);
> if (error == -EFSCORRUPTED || error == -EFSBADCRC) {
> sm->sm_flags |= XFS_SCRUB_OFLAG_CORRUPT;
> error = 0;
> diff --git a/fs/xfs/scrub/scrub.h b/fs/xfs/scrub/scrub.h
> index b295edd5fc0e..0f59a47c4bb0 100644
> --- a/fs/xfs/scrub/scrub.h
> +++ b/fs/xfs/scrub/scrub.h
> @@ -9,14 +9,14 @@
> struct xfs_scrub_context;
>
> /* Type info and names for the scrub types. */
> -enum xfs_scrub_type {
> +enum xchk_type {
> ST_NONE = 1, /* disabled */
> ST_PERAG, /* per-AG metadata */
> ST_FS, /* per-FS metadata */
> ST_INODE, /* per-inode metadata */
> };
>
> -struct xfs_scrub_meta_ops {
> +struct xchk_meta_ops {
> /* Acquire whatever resources are needed for the operation. */
> int (*setup)(struct xfs_scrub_context *,
> struct xfs_inode *);
> @@ -31,11 +31,11 @@ struct xfs_scrub_meta_ops {
> bool (*has)(struct xfs_sb *);
>
> /* type describing required/allowed inputs */
> - enum xfs_scrub_type type;
> + enum xchk_type type;
> };
>
> /* Buffer pointers and btree cursors for an entire AG. */
> -struct xfs_scrub_ag {
> +struct xchk_ag {
> xfs_agnumber_t agno;
> struct xfs_perag *pag;
>
> @@ -57,7 +57,7 @@ struct xfs_scrub_context {
> /* General scrub state. */
> struct xfs_mount *mp;
> struct xfs_scrub_metadata *sm;
> - const struct xfs_scrub_meta_ops *ops;
> + const struct xchk_meta_ops *ops;
> struct xfs_trans *tp;
> struct xfs_inode *ip;
> void *buf;
> @@ -66,78 +66,78 @@ struct xfs_scrub_context {
> bool has_quotaofflock;
>
> /* State tracking for single-AG operations. */
> - struct xfs_scrub_ag sa;
> + struct xchk_ag sa;
> };
>
> /* Metadata scrubbers */
> -int xfs_scrub_tester(struct xfs_scrub_context *sc);
> -int xfs_scrub_superblock(struct xfs_scrub_context *sc);
> -int xfs_scrub_agf(struct xfs_scrub_context *sc);
> -int xfs_scrub_agfl(struct xfs_scrub_context *sc);
> -int xfs_scrub_agi(struct xfs_scrub_context *sc);
> -int xfs_scrub_bnobt(struct xfs_scrub_context *sc);
> -int xfs_scrub_cntbt(struct xfs_scrub_context *sc);
> -int xfs_scrub_inobt(struct xfs_scrub_context *sc);
> -int xfs_scrub_finobt(struct xfs_scrub_context *sc);
> -int xfs_scrub_rmapbt(struct xfs_scrub_context *sc);
> -int xfs_scrub_refcountbt(struct xfs_scrub_context *sc);
> -int xfs_scrub_inode(struct xfs_scrub_context *sc);
> -int xfs_scrub_bmap_data(struct xfs_scrub_context *sc);
> -int xfs_scrub_bmap_attr(struct xfs_scrub_context *sc);
> -int xfs_scrub_bmap_cow(struct xfs_scrub_context *sc);
> -int xfs_scrub_directory(struct xfs_scrub_context *sc);
> -int xfs_scrub_xattr(struct xfs_scrub_context *sc);
> -int xfs_scrub_symlink(struct xfs_scrub_context *sc);
> -int xfs_scrub_parent(struct xfs_scrub_context *sc);
> +int xchk_tester(struct xfs_scrub_context *sc);
> +int xchk_superblock(struct xfs_scrub_context *sc);
> +int xchk_agf(struct xfs_scrub_context *sc);
> +int xchk_agfl(struct xfs_scrub_context *sc);
> +int xchk_agi(struct xfs_scrub_context *sc);
> +int xchk_bnobt(struct xfs_scrub_context *sc);
> +int xchk_cntbt(struct xfs_scrub_context *sc);
> +int xchk_inobt(struct xfs_scrub_context *sc);
> +int xchk_finobt(struct xfs_scrub_context *sc);
> +int xchk_rmapbt(struct xfs_scrub_context *sc);
> +int xchk_refcountbt(struct xfs_scrub_context *sc);
> +int xchk_inode(struct xfs_scrub_context *sc);
> +int xchk_bmap_data(struct xfs_scrub_context *sc);
> +int xchk_bmap_attr(struct xfs_scrub_context *sc);
> +int xchk_bmap_cow(struct xfs_scrub_context *sc);
> +int xchk_directory(struct xfs_scrub_context *sc);
> +int xchk_xattr(struct xfs_scrub_context *sc);
> +int xchk_symlink(struct xfs_scrub_context *sc);
> +int xchk_parent(struct xfs_scrub_context *sc);
> #ifdef CONFIG_XFS_RT
> -int xfs_scrub_rtbitmap(struct xfs_scrub_context *sc);
> -int xfs_scrub_rtsummary(struct xfs_scrub_context *sc);
> +int xchk_rtbitmap(struct xfs_scrub_context *sc);
> +int xchk_rtsummary(struct xfs_scrub_context *sc);
> #else
> static inline int
> -xfs_scrub_rtbitmap(struct xfs_scrub_context *sc)
> +xchk_rtbitmap(struct xfs_scrub_context *sc)
> {
> return -ENOENT;
> }
> static inline int
> -xfs_scrub_rtsummary(struct xfs_scrub_context *sc)
> +xchk_rtsummary(struct xfs_scrub_context *sc)
> {
> return -ENOENT;
> }
> #endif
> #ifdef CONFIG_XFS_QUOTA
> -int xfs_scrub_quota(struct xfs_scrub_context *sc);
> +int xchk_quota(struct xfs_scrub_context *sc);
> #else
> static inline int
> -xfs_scrub_quota(struct xfs_scrub_context *sc)
> +xchk_quota(struct xfs_scrub_context *sc)
> {
> return -ENOENT;
> }
> #endif
>
> /* cross-referencing helpers */
> -void xfs_scrub_xref_is_used_space(struct xfs_scrub_context *sc,
> +void xchk_xref_is_used_space(struct xfs_scrub_context *sc,
> xfs_agblock_t agbno, xfs_extlen_t len);
> -void xfs_scrub_xref_is_not_inode_chunk(struct xfs_scrub_context *sc,
> +void xchk_xref_is_not_inode_chunk(struct xfs_scrub_context *sc,
> xfs_agblock_t agbno, xfs_extlen_t len);
> -void xfs_scrub_xref_is_inode_chunk(struct xfs_scrub_context *sc,
> +void xchk_xref_is_inode_chunk(struct xfs_scrub_context *sc,
> xfs_agblock_t agbno, xfs_extlen_t len);
> -void xfs_scrub_xref_is_owned_by(struct xfs_scrub_context *sc,
> +void xchk_xref_is_owned_by(struct xfs_scrub_context *sc,
> xfs_agblock_t agbno, xfs_extlen_t len,
> struct xfs_owner_info *oinfo);
> -void xfs_scrub_xref_is_not_owned_by(struct xfs_scrub_context *sc,
> +void xchk_xref_is_not_owned_by(struct xfs_scrub_context *sc,
> xfs_agblock_t agbno, xfs_extlen_t len,
> struct xfs_owner_info *oinfo);
> -void xfs_scrub_xref_has_no_owner(struct xfs_scrub_context *sc,
> +void xchk_xref_has_no_owner(struct xfs_scrub_context *sc,
> xfs_agblock_t agbno, xfs_extlen_t len);
> -void xfs_scrub_xref_is_cow_staging(struct xfs_scrub_context *sc,
> +void xchk_xref_is_cow_staging(struct xfs_scrub_context *sc,
> xfs_agblock_t bno, xfs_extlen_t len);
> -void xfs_scrub_xref_is_not_shared(struct xfs_scrub_context *sc,
> +void xchk_xref_is_not_shared(struct xfs_scrub_context *sc,
> xfs_agblock_t bno, xfs_extlen_t len);
> #ifdef CONFIG_XFS_RT
> -void xfs_scrub_xref_is_used_rt_space(struct xfs_scrub_context *sc,
> +void xchk_xref_is_used_rt_space(struct xfs_scrub_context *sc,
> xfs_rtblock_t rtbno, xfs_extlen_t len);
> #else
> -# define xfs_scrub_xref_is_used_rt_space(sc, rtbno, len) do { } while (0)
> +# define xchk_xref_is_used_rt_space(sc, rtbno, len) do { } while (0)
> #endif
>
> #endif /* __XFS_SCRUB_SCRUB_H__ */
> diff --git a/fs/xfs/scrub/symlink.c b/fs/xfs/scrub/symlink.c
> index 570a89812116..e2a288e34337 100644
> --- a/fs/xfs/scrub/symlink.c
> +++ b/fs/xfs/scrub/symlink.c
> @@ -25,7 +25,7 @@
>
> /* Set us up to scrub a symbolic link. */
> int
> -xfs_scrub_setup_symlink(
> +xchk_setup_symlink(
> struct xfs_scrub_context *sc,
> struct xfs_inode *ip)
> {
> @@ -34,13 +34,13 @@ xfs_scrub_setup_symlink(
> if (!sc->buf)
> return -ENOMEM;
>
> - return xfs_scrub_setup_inode_contents(sc, ip, 0);
> + return xchk_setup_inode_contents(sc, ip, 0);
> }
>
> /* Symbolic links. */
>
> int
> -xfs_scrub_symlink(
> +xchk_symlink(
> struct xfs_scrub_context *sc)
> {
> struct xfs_inode *ip = sc->ip;
> @@ -55,7 +55,7 @@ xfs_scrub_symlink(
>
> /* Plausible size? */
> if (len > XFS_SYMLINK_MAXLEN || len <= 0) {
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out;
> }
>
> @@ -63,16 +63,16 @@ xfs_scrub_symlink(
> if (ifp->if_flags & XFS_IFINLINE) {
> if (len > XFS_IFORK_DSIZE(ip) ||
> len > strnlen(ifp->if_u1.if_data, XFS_IFORK_DSIZE(ip)))
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> goto out;
> }
>
> /* Remote symlink; must read the contents. */
> error = xfs_readlink_bmap_ilocked(sc->ip, sc->buf);
> - if (!xfs_scrub_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> + if (!xchk_fblock_process_error(sc, XFS_DATA_FORK, 0, &error))
> goto out;
> if (strnlen(sc->buf, XFS_SYMLINK_MAXLEN) < len)
> - xfs_scrub_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> + xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, 0);
> out:
> return error;
> }
> diff --git a/fs/xfs/scrub/trace.c b/fs/xfs/scrub/trace.c
> index 7c76d8b5cb05..1ef1202a1e45 100644
> --- a/fs/xfs/scrub/trace.c
> +++ b/fs/xfs/scrub/trace.c
> @@ -22,7 +22,7 @@
>
> /* Figure out which block the btree cursor was pointing to. */
> static inline xfs_fsblock_t
> -xfs_scrub_btree_cur_fsbno(
> +xchk_btree_cur_fsbno(
> struct xfs_btree_cur *cur,
> int level)
> {
> diff --git a/fs/xfs/scrub/trace.h b/fs/xfs/scrub/trace.h
> index cec3e5ece5a1..11967d3942ac 100644
> --- a/fs/xfs/scrub/trace.h
> +++ b/fs/xfs/scrub/trace.h
> @@ -12,7 +12,7 @@
> #include <linux/tracepoint.h>
> #include "xfs_bit.h"
>
> -DECLARE_EVENT_CLASS(xfs_scrub_class,
> +DECLARE_EVENT_CLASS(xchk_class,
> TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm,
> int error),
> TP_ARGS(ip, sm, error),
> @@ -47,18 +47,18 @@ DECLARE_EVENT_CLASS(xfs_scrub_class,
> __entry->error)
> )
> #define DEFINE_SCRUB_EVENT(name) \
> -DEFINE_EVENT(xfs_scrub_class, name, \
> +DEFINE_EVENT(xchk_class, name, \
> TP_PROTO(struct xfs_inode *ip, struct xfs_scrub_metadata *sm, \
> int error), \
> TP_ARGS(ip, sm, error))
>
> -DEFINE_SCRUB_EVENT(xfs_scrub_start);
> -DEFINE_SCRUB_EVENT(xfs_scrub_done);
> -DEFINE_SCRUB_EVENT(xfs_scrub_deadlock_retry);
> +DEFINE_SCRUB_EVENT(xchk_start);
> +DEFINE_SCRUB_EVENT(xchk_done);
> +DEFINE_SCRUB_EVENT(xchk_deadlock_retry);
> DEFINE_SCRUB_EVENT(xfs_repair_attempt);
> DEFINE_SCRUB_EVENT(xfs_repair_done);
>
> -TRACE_EVENT(xfs_scrub_op_error,
> +TRACE_EVENT(xchk_op_error,
> TP_PROTO(struct xfs_scrub_context *sc, xfs_agnumber_t agno,
> xfs_agblock_t bno, int error, void *ret_ip),
> TP_ARGS(sc, agno, bno, error, ret_ip),
> @@ -87,7 +87,7 @@ TRACE_EVENT(xfs_scrub_op_error,
> __entry->ret_ip)
> );
>
> -TRACE_EVENT(xfs_scrub_file_op_error,
> +TRACE_EVENT(xchk_file_op_error,
> TP_PROTO(struct xfs_scrub_context *sc, int whichfork,
> xfs_fileoff_t offset, int error, void *ret_ip),
> TP_ARGS(sc, whichfork, offset, error, ret_ip),
> @@ -119,7 +119,7 @@ TRACE_EVENT(xfs_scrub_file_op_error,
> __entry->ret_ip)
> );
>
> -DECLARE_EVENT_CLASS(xfs_scrub_block_error_class,
> +DECLARE_EVENT_CLASS(xchk_block_error_class,
> TP_PROTO(struct xfs_scrub_context *sc, xfs_daddr_t daddr, void *ret_ip),
> TP_ARGS(sc, daddr, ret_ip),
> TP_STRUCT__entry(
> @@ -153,15 +153,15 @@ DECLARE_EVENT_CLASS(xfs_scrub_block_error_class,
> )
>
> #define DEFINE_SCRUB_BLOCK_ERROR_EVENT(name) \
> -DEFINE_EVENT(xfs_scrub_block_error_class, name, \
> +DEFINE_EVENT(xchk_block_error_class, name, \
> TP_PROTO(struct xfs_scrub_context *sc, xfs_daddr_t daddr, \
> void *ret_ip), \
> TP_ARGS(sc, daddr, ret_ip))
>
> -DEFINE_SCRUB_BLOCK_ERROR_EVENT(xfs_scrub_block_error);
> -DEFINE_SCRUB_BLOCK_ERROR_EVENT(xfs_scrub_block_preen);
> +DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_error);
> +DEFINE_SCRUB_BLOCK_ERROR_EVENT(xchk_block_preen);
>
> -DECLARE_EVENT_CLASS(xfs_scrub_ino_error_class,
> +DECLARE_EVENT_CLASS(xchk_ino_error_class,
> TP_PROTO(struct xfs_scrub_context *sc, xfs_ino_t ino, void *ret_ip),
> TP_ARGS(sc, ino, ret_ip),
> TP_STRUCT__entry(
> @@ -184,16 +184,16 @@ DECLARE_EVENT_CLASS(xfs_scrub_ino_error_class,
> )
>
> #define DEFINE_SCRUB_INO_ERROR_EVENT(name) \
> -DEFINE_EVENT(xfs_scrub_ino_error_class, name, \
> +DEFINE_EVENT(xchk_ino_error_class, name, \
> TP_PROTO(struct xfs_scrub_context *sc, xfs_ino_t ino, \
> void *ret_ip), \
> TP_ARGS(sc, ino, ret_ip))
>
> -DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_error);
> -DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_preen);
> -DEFINE_SCRUB_INO_ERROR_EVENT(xfs_scrub_ino_warning);
> +DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_error);
> +DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_preen);
> +DEFINE_SCRUB_INO_ERROR_EVENT(xchk_ino_warning);
>
> -DECLARE_EVENT_CLASS(xfs_scrub_fblock_error_class,
> +DECLARE_EVENT_CLASS(xchk_fblock_error_class,
> TP_PROTO(struct xfs_scrub_context *sc, int whichfork,
> xfs_fileoff_t offset, void *ret_ip),
> TP_ARGS(sc, whichfork, offset, ret_ip),
> @@ -223,15 +223,15 @@ DECLARE_EVENT_CLASS(xfs_scrub_fblock_error_class,
> );
>
> #define DEFINE_SCRUB_FBLOCK_ERROR_EVENT(name) \
> -DEFINE_EVENT(xfs_scrub_fblock_error_class, name, \
> +DEFINE_EVENT(xchk_fblock_error_class, name, \
> TP_PROTO(struct xfs_scrub_context *sc, int whichfork, \
> xfs_fileoff_t offset, void *ret_ip), \
> TP_ARGS(sc, whichfork, offset, ret_ip))
>
> -DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xfs_scrub_fblock_error);
> -DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xfs_scrub_fblock_warning);
> +DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_error);
> +DEFINE_SCRUB_FBLOCK_ERROR_EVENT(xchk_fblock_warning);
>
> -TRACE_EVENT(xfs_scrub_incomplete,
> +TRACE_EVENT(xchk_incomplete,
> TP_PROTO(struct xfs_scrub_context *sc, void *ret_ip),
> TP_ARGS(sc, ret_ip),
> TP_STRUCT__entry(
> @@ -250,7 +250,7 @@ TRACE_EVENT(xfs_scrub_incomplete,
> __entry->ret_ip)
> );
>
> -TRACE_EVENT(xfs_scrub_btree_op_error,
> +TRACE_EVENT(xchk_btree_op_error,
> TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> int level, int error, void *ret_ip),
> TP_ARGS(sc, cur, level, error, ret_ip),
> @@ -266,7 +266,7 @@ TRACE_EVENT(xfs_scrub_btree_op_error,
> __field(void *, ret_ip)
> ),
> TP_fast_assign(
> - xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
> + xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
>
> __entry->dev = sc->mp->m_super->s_dev;
> __entry->type = sc->sm->sm_type;
> @@ -290,7 +290,7 @@ TRACE_EVENT(xfs_scrub_btree_op_error,
> __entry->ret_ip)
> );
>
> -TRACE_EVENT(xfs_scrub_ifork_btree_op_error,
> +TRACE_EVENT(xchk_ifork_btree_op_error,
> TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> int level, int error, void *ret_ip),
> TP_ARGS(sc, cur, level, error, ret_ip),
> @@ -308,7 +308,7 @@ TRACE_EVENT(xfs_scrub_ifork_btree_op_error,
> __field(void *, ret_ip)
> ),
> TP_fast_assign(
> - xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
> + xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
> __entry->dev = sc->mp->m_super->s_dev;
> __entry->ino = sc->ip->i_ino;
> __entry->whichfork = cur->bc_private.b.whichfork;
> @@ -335,7 +335,7 @@ TRACE_EVENT(xfs_scrub_ifork_btree_op_error,
> __entry->ret_ip)
> );
>
> -TRACE_EVENT(xfs_scrub_btree_error,
> +TRACE_EVENT(xchk_btree_error,
> TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> int level, void *ret_ip),
> TP_ARGS(sc, cur, level, ret_ip),
> @@ -350,7 +350,7 @@ TRACE_EVENT(xfs_scrub_btree_error,
> __field(void *, ret_ip)
> ),
> TP_fast_assign(
> - xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
> + xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
> __entry->dev = sc->mp->m_super->s_dev;
> __entry->type = sc->sm->sm_type;
> __entry->btnum = cur->bc_btnum;
> @@ -371,7 +371,7 @@ TRACE_EVENT(xfs_scrub_btree_error,
> __entry->ret_ip)
> );
>
> -TRACE_EVENT(xfs_scrub_ifork_btree_error,
> +TRACE_EVENT(xchk_ifork_btree_error,
> TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> int level, void *ret_ip),
> TP_ARGS(sc, cur, level, ret_ip),
> @@ -388,7 +388,7 @@ TRACE_EVENT(xfs_scrub_ifork_btree_error,
> __field(void *, ret_ip)
> ),
> TP_fast_assign(
> - xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
> + xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
> __entry->dev = sc->mp->m_super->s_dev;
> __entry->ino = sc->ip->i_ino;
> __entry->whichfork = cur->bc_private.b.whichfork;
> @@ -413,7 +413,7 @@ TRACE_EVENT(xfs_scrub_ifork_btree_error,
> __entry->ret_ip)
> );
>
> -DECLARE_EVENT_CLASS(xfs_scrub_sbtree_class,
> +DECLARE_EVENT_CLASS(xchk_sbtree_class,
> TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur,
> int level),
> TP_ARGS(sc, cur, level),
> @@ -428,7 +428,7 @@ DECLARE_EVENT_CLASS(xfs_scrub_sbtree_class,
> __field(int, ptr)
> ),
> TP_fast_assign(
> - xfs_fsblock_t fsbno = xfs_scrub_btree_cur_fsbno(cur, level);
> + xfs_fsblock_t fsbno = xchk_btree_cur_fsbno(cur, level);
>
> __entry->dev = sc->mp->m_super->s_dev;
> __entry->type = sc->sm->sm_type;
> @@ -450,15 +450,15 @@ DECLARE_EVENT_CLASS(xfs_scrub_sbtree_class,
> __entry->ptr)
> )
> #define DEFINE_SCRUB_SBTREE_EVENT(name) \
> -DEFINE_EVENT(xfs_scrub_sbtree_class, name, \
> +DEFINE_EVENT(xchk_sbtree_class, name, \
> TP_PROTO(struct xfs_scrub_context *sc, struct xfs_btree_cur *cur, \
> int level), \
> TP_ARGS(sc, cur, level))
>
> -DEFINE_SCRUB_SBTREE_EVENT(xfs_scrub_btree_rec);
> -DEFINE_SCRUB_SBTREE_EVENT(xfs_scrub_btree_key);
> +DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_rec);
> +DEFINE_SCRUB_SBTREE_EVENT(xchk_btree_key);
>
> -TRACE_EVENT(xfs_scrub_xref_error,
> +TRACE_EVENT(xchk_xref_error,
> TP_PROTO(struct xfs_scrub_context *sc, int error, void *ret_ip),
> TP_ARGS(sc, error, ret_ip),
> TP_STRUCT__entry(
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
--
To unsubscribe from this list: send the line "unsubscribe linux-xfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
