Commit 169c030a authored by Chandan Babu R's avatar Chandan Babu R
Browse files

Merge tag 'btree-check-cleanups-6.9_2024-02-23' of... 

Merge tag 'btree-check-cleanups-6.9_2024-02-23' of https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux

 into xfs-6.9-mergeC

xfs: btree check cleanups

Minor cleanups for the btree block pointer checking code.

Signed-off-by: default avatarDarrick J. Wong <djwong@kernel.org>
Signed-off-by: default avatarChandan Babu R <chandanbabu@kernel.org>

* tag 'btree-check-cleanups-6.9_2024-02-23' of https://git.kernel.org/pub/scm/linux/kernel/git/djwong/xfs-linux:
  xfs: factor out a __xfs_btree_check_lblock_hdr helper
  xfs: rename btree helpers that depends on the block number representation
  xfs: consolidate btree block verification
  xfs: tighten up validation of root block in inode forks
  xfs: remove the crc variable in __xfs_btree_check_lblock
  xfs: misc cleanups for __xfs_btree_check_sblock
  xfs: consolidate btree ptr checking
  xfs: open code xfs_btree_check_lptr in xfs_bmap_btree_to_extents
  xfs: simplify xfs_btree_check_lblock_siblings
  xfs: simplify xfs_btree_check_sblock_siblings
parents ee138217 79e72304

fs/xfs/libxfs/xfs_alloc_btree.c

+4 −4
Original line number Diff line number Diff line
@@ -322,7 +322,7 @@ xfs_allocbt_verify( 
		return __this_address;



	if (xfs_has_crc(mp)) {

		fa = xfs_btree_sblock_v5hdr_verify(bp);

		fa = xfs_btree_agblock_v5hdr_verify(bp);

		if (fa)

			return fa;

	}
@@ -362,7 +362,7 @@ xfs_allocbt_verify( 
	} else if (level >= mp->m_alloc_maxlevels)

		return __this_address;



	return xfs_btree_sblock_verify(bp, mp->m_alloc_mxr[level != 0]);

	return xfs_btree_agblock_verify(bp, mp->m_alloc_mxr[level != 0]);

}



static void
@@ -371,7 +371,7 @@ xfs_allocbt_read_verify( 
{

	xfs_failaddr_t	fa;



	if (!xfs_btree_sblock_verify_crc(bp))

	if (!xfs_btree_agblock_verify_crc(bp))

		xfs_verifier_error(bp, -EFSBADCRC, __this_address);

	else {

		fa = xfs_allocbt_verify(bp);
@@ -395,7 +395,7 @@ xfs_allocbt_write_verify( 
		xfs_verifier_error(bp, -EFSCORRUPTED, fa);

		return;

	}

	xfs_btree_sblock_calc_crc(bp);

	xfs_btree_agblock_calc_crc(bp);



}

fs/xfs/libxfs/xfs_bmap.c

+1 −1
Original line number Diff line number Diff line
@@ -568,7 +568,7 @@ xfs_bmap_btree_to_extents( 
	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);

	cbno = be64_to_cpu(*pp);

#ifdef DEBUG

	if (XFS_IS_CORRUPT(cur->bc_mp, !xfs_btree_check_lptr(cur, cbno, 1))) {

	if (XFS_IS_CORRUPT(cur->bc_mp, !xfs_verify_fsbno(mp, cbno))) {

		xfs_btree_mark_sick(cur);

		return -EFSCORRUPTED;

	}

fs/xfs/libxfs/xfs_bmap_btree.c

+4 −4
Original line number Diff line number Diff line
@@ -420,7 +420,7 @@ xfs_bmbt_verify( 
		 * XXX: need a better way of verifying the owner here. Right now

		 * just make sure there has been one set.

		 */

		fa = xfs_btree_lblock_v5hdr_verify(bp, XFS_RMAP_OWN_UNKNOWN);

		fa = xfs_btree_fsblock_v5hdr_verify(bp, XFS_RMAP_OWN_UNKNOWN);

		if (fa)

			return fa;

	}
@@ -436,7 +436,7 @@ xfs_bmbt_verify( 
	if (level > max(mp->m_bm_maxlevels[0], mp->m_bm_maxlevels[1]))

		return __this_address;



	return xfs_btree_lblock_verify(bp, mp->m_bmap_dmxr[level != 0]);

	return xfs_btree_fsblock_verify(bp, mp->m_bmap_dmxr[level != 0]);

}



static void
@@ -445,7 +445,7 @@ xfs_bmbt_read_verify( 
{

	xfs_failaddr_t	fa;



	if (!xfs_btree_lblock_verify_crc(bp))

	if (!xfs_btree_fsblock_verify_crc(bp))

		xfs_verifier_error(bp, -EFSBADCRC, __this_address);

	else {

		fa = xfs_bmbt_verify(bp);
@@ -469,7 +469,7 @@ xfs_bmbt_write_verify( 
		xfs_verifier_error(bp, -EFSCORRUPTED, fa);

		return;

	}

	xfs_btree_lblock_calc_crc(bp);

	xfs_btree_fsblock_calc_crc(bp);

}



const struct xfs_buf_ops xfs_bmbt_buf_ops = {

fs/xfs/libxfs/xfs_btree.c

+122 −130
Original line number Diff line number Diff line
@@ -57,10 +57,8 @@ xfs_btree_magic( 
 * bytes.

 */

static inline xfs_failaddr_t

xfs_btree_check_lblock_siblings(

xfs_btree_check_fsblock_siblings(

	struct xfs_mount	*mp,

	struct xfs_btree_cur	*cur,

	int			level,

	xfs_fsblock_t		fsb,

	__be64			dsibling)

{
@@ -72,22 +70,14 @@ xfs_btree_check_lblock_siblings( 
	sibling = be64_to_cpu(dsibling);

	if (sibling == fsb)

		return __this_address;

	if (level >= 0) {

		if (!xfs_btree_check_lptr(cur, sibling, level + 1))

			return __this_address;

	} else {

	if (!xfs_verify_fsbno(mp, sibling))

		return __this_address;

	}



	return NULL;

}



static inline xfs_failaddr_t

xfs_btree_check_sblock_siblings(

xfs_btree_check_agblock_siblings(

	struct xfs_perag	*pag,

	struct xfs_btree_cur	*cur,

	int			level,

	xfs_agblock_t		agbno,

	__be32			dsibling)

{
@@ -99,33 +89,21 @@ xfs_btree_check_sblock_siblings( 
	sibling = be32_to_cpu(dsibling);

	if (sibling == agbno)

		return __this_address;

	if (level >= 0) {

		if (!xfs_btree_check_sptr(cur, sibling, level + 1))

			return __this_address;

	} else {

	if (!xfs_verify_agbno(pag, sibling))

		return __this_address;

	}

	return NULL;

}



/*

 * Check a long btree block header.  Return the address of the failing check,

 * or NULL if everything is ok.

 */

xfs_failaddr_t

__xfs_btree_check_lblock(

static xfs_failaddr_t

__xfs_btree_check_lblock_hdr(

	struct xfs_btree_cur	*cur,

	struct xfs_btree_block	*block,

	int			level,

	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = cur->bc_mp;

	bool			crc = xfs_has_crc(mp);

	xfs_failaddr_t		fa;

	xfs_fsblock_t		fsb = NULLFSBLOCK;



	if (crc) {

	if (xfs_has_crc(mp)) {

		if (!uuid_equal(&block->bb_u.l.bb_uuid, &mp->m_sb.sb_meta_uuid))

			return __this_address;

		if (block->bb_u.l.bb_blkno !=
@@ -143,20 +121,15 @@ __xfs_btree_check_lblock( 
	    cur->bc_ops->get_maxrecs(cur, level))

		return __this_address;



	if (bp)

		fsb = XFS_DADDR_TO_FSB(mp, xfs_buf_daddr(bp));



	fa = xfs_btree_check_lblock_siblings(mp, cur, level, fsb,

			block->bb_u.l.bb_leftsib);

	if (!fa)

		fa = xfs_btree_check_lblock_siblings(mp, cur, level, fsb,

				block->bb_u.l.bb_rightsib);

	return fa;

	return NULL;

}



/* Check a long btree block header. */

static int

xfs_btree_check_lblock(

/*

 * Check a long btree block header.  Return the address of the failing check,

 * or NULL if everything is ok.

 */

static xfs_failaddr_t

__xfs_btree_check_fsblock(

	struct xfs_btree_cur	*cur,

	struct xfs_btree_block	*block,

	int			level,
@@ -164,24 +137,39 @@ xfs_btree_check_lblock( 
{

	struct xfs_mount	*mp = cur->bc_mp;

	xfs_failaddr_t		fa;

	xfs_fsblock_t		fsb;



	fa = __xfs_btree_check_lblock(cur, block, level, bp);

	if (XFS_IS_CORRUPT(mp, fa != NULL) ||

	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BTREE_CHECK_LBLOCK)) {

		if (bp)

			trace_xfs_btree_corrupt(bp, _RET_IP_);

		xfs_btree_mark_sick(cur);

		return -EFSCORRUPTED;

	fa = __xfs_btree_check_lblock_hdr(cur, block, level, bp);

	if (fa)

		return fa;



	/*

	 * For inode-rooted btrees, the root block sits in the inode fork.  In

	 * that case bp is NULL, and the block must not have any siblings.

	 */

	if (!bp) {

		if (block->bb_u.l.bb_leftsib != cpu_to_be64(NULLFSBLOCK))

			return __this_address;

		if (block->bb_u.l.bb_rightsib != cpu_to_be64(NULLFSBLOCK))

			return __this_address;

		return NULL;

	}

	return 0;



	fsb = XFS_DADDR_TO_FSB(mp, xfs_buf_daddr(bp));

	fa = xfs_btree_check_fsblock_siblings(mp, fsb,

			block->bb_u.l.bb_leftsib);

	if (!fa)

		fa = xfs_btree_check_fsblock_siblings(mp, fsb,

				block->bb_u.l.bb_rightsib);

	return fa;

}



/*

 * Check a short btree block header.  Return the address of the failing check,

 * or NULL if everything is ok.

 */

xfs_failaddr_t

__xfs_btree_check_sblock(

static xfs_failaddr_t

__xfs_btree_check_agblock(

	struct xfs_btree_cur	*cur,

	struct xfs_btree_block	*block,

	int			level,
@@ -189,15 +177,13 @@ __xfs_btree_check_sblock( 
{

	struct xfs_mount	*mp = cur->bc_mp;

	struct xfs_perag	*pag = cur->bc_ag.pag;

	bool			crc = xfs_has_crc(mp);

	xfs_failaddr_t		fa;

	xfs_agblock_t		agbno = NULLAGBLOCK;

	xfs_agblock_t		agbno;



	if (crc) {

	if (xfs_has_crc(mp)) {

		if (!uuid_equal(&block->bb_u.s.bb_uuid, &mp->m_sb.sb_meta_uuid))

			return __this_address;

		if (block->bb_u.s.bb_blkno !=

		    cpu_to_be64(bp ? xfs_buf_daddr(bp) : XFS_BUF_DADDR_NULL))

		if (block->bb_u.s.bb_blkno != cpu_to_be64(xfs_buf_daddr(bp)))

			return __this_address;

	}
@@ -209,37 +195,37 @@ __xfs_btree_check_sblock( 
	    cur->bc_ops->get_maxrecs(cur, level))

		return __this_address;



	if (bp)

	agbno = xfs_daddr_to_agbno(mp, xfs_buf_daddr(bp));



	fa = xfs_btree_check_sblock_siblings(pag, cur, level, agbno,

	fa = xfs_btree_check_agblock_siblings(pag, agbno,

			block->bb_u.s.bb_leftsib);

	if (!fa)

		fa = xfs_btree_check_sblock_siblings(pag, cur, level, agbno,

		fa = xfs_btree_check_agblock_siblings(pag, agbno,

				block->bb_u.s.bb_rightsib);

	return fa;

}



/* Check a short btree block header. */

STATIC int

xfs_btree_check_sblock(

/*

 * Internal btree block check.

 *

 * Return NULL if the block is ok or the address of the failed check otherwise.

 */

xfs_failaddr_t

__xfs_btree_check_block(

	struct xfs_btree_cur	*cur,

	struct xfs_btree_block	*block,

	int			level,

	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = cur->bc_mp;

	xfs_failaddr_t		fa;



	fa = __xfs_btree_check_sblock(cur, block, level, bp);

	if (XFS_IS_CORRUPT(mp, fa != NULL) ||

	    XFS_TEST_ERROR(false, mp, XFS_ERRTAG_BTREE_CHECK_SBLOCK)) {

		if (bp)

			trace_xfs_btree_corrupt(bp, _RET_IP_);

		xfs_btree_mark_sick(cur);

		return -EFSCORRUPTED;

	if (cur->bc_ops->type == XFS_BTREE_TYPE_AG)

		return __xfs_btree_check_agblock(cur, block, level, bp);

	return __xfs_btree_check_fsblock(cur, block, level, bp);

}

	return 0;



static inline unsigned int xfs_btree_block_errtag(struct xfs_btree_cur *cur)

{

	if (cur->bc_ops->ptr_len == XFS_BTREE_SHORT_PTR_LEN)

		return XFS_ERRTAG_BTREE_CHECK_SBLOCK;

	return XFS_ERRTAG_BTREE_CHECK_LBLOCK;

}



/*
@@ -252,34 +238,41 @@ xfs_btree_check_block( 
	int			level,	/* level of the btree block */

	struct xfs_buf		*bp)	/* buffer containing block, if any */

{

	if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN)

		return xfs_btree_check_lblock(cur, block, level, bp);

	else

		return xfs_btree_check_sblock(cur, block, level, bp);

	struct xfs_mount	*mp = cur->bc_mp;

	xfs_failaddr_t		fa;



	fa = __xfs_btree_check_block(cur, block, level, bp);

	if (XFS_IS_CORRUPT(mp, fa != NULL) ||

	    XFS_TEST_ERROR(false, mp, xfs_btree_block_errtag(cur))) {

		if (bp)

			trace_xfs_btree_corrupt(bp, _RET_IP_);

		xfs_btree_mark_sick(cur);

		return -EFSCORRUPTED;

	}

	return 0;

}



/* Check that this long pointer is valid and points within the fs. */

bool

xfs_btree_check_lptr(

int

__xfs_btree_check_ptr(

	struct xfs_btree_cur		*cur,

	xfs_fsblock_t		fsbno,

	const union xfs_btree_ptr	*ptr,

	int				index,

	int				level)

{

	if (level <= 0)

		return false;

	return xfs_verify_fsbno(cur->bc_mp, fsbno);

		return -EFSCORRUPTED;



	if (cur->bc_ops->type == XFS_BTREE_TYPE_INODE) {

		if (!xfs_verify_fsbno(cur->bc_mp,

				be64_to_cpu((&ptr->l)[index])))

			return -EFSCORRUPTED;

	} else {

		if (!xfs_verify_agbno(cur->bc_ag.pag,

				be32_to_cpu((&ptr->s)[index])))

			return -EFSCORRUPTED;

	}



/* Check that this short pointer is valid and points within the AG. */

bool

xfs_btree_check_sptr(

	struct xfs_btree_cur	*cur,

	xfs_agblock_t		agbno,

	int			level)

{

	if (level <= 0)

		return false;

	return xfs_verify_agbno(cur->bc_ag.pag, agbno);

	return 0;

}



/*
@@ -293,27 +286,26 @@ xfs_btree_check_ptr( 
	int				index,

	int				level)

{

	if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN) {

		if (xfs_btree_check_lptr(cur, be64_to_cpu((&ptr->l)[index]),

				level))

			return 0;

	int				error;



	error = __xfs_btree_check_ptr(cur, ptr, index, level);

	if (error) {

		if (cur->bc_ops->type == XFS_BTREE_TYPE_INODE) {

			xfs_err(cur->bc_mp,

"Inode %llu fork %d: Corrupt %sbt pointer at level %d index %d.",

				cur->bc_ino.ip->i_ino,

				cur->bc_ino.whichfork, cur->bc_ops->name,

				level, index);

		} else {

		if (xfs_btree_check_sptr(cur, be32_to_cpu((&ptr->s)[index]),

				level))

			return 0;

			xfs_err(cur->bc_mp,

"AG %u: Corrupt %sbt pointer at level %d index %d.",

				cur->bc_ag.pag->pag_agno, cur->bc_ops->name,

				level, index);

		}



		xfs_btree_mark_sick(cur);

	return -EFSCORRUPTED;

	}



	return error;

}



#ifdef DEBUG
@@ -331,7 +323,7 @@ xfs_btree_check_ptr( 
 * it to disk.

 */

void

xfs_btree_lblock_calc_crc(

xfs_btree_fsblock_calc_crc(

	struct xfs_buf		*bp)

{

	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
@@ -345,7 +337,7 @@ xfs_btree_lblock_calc_crc( 
}



bool

xfs_btree_lblock_verify_crc(

xfs_btree_fsblock_verify_crc(

	struct xfs_buf		*bp)

{

	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
@@ -369,7 +361,7 @@ xfs_btree_lblock_verify_crc( 
 * it to disk.

 */

void

xfs_btree_sblock_calc_crc(

xfs_btree_agblock_calc_crc(

	struct xfs_buf		*bp)

{

	struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
@@ -383,7 +375,7 @@ xfs_btree_sblock_calc_crc( 
}



bool

xfs_btree_sblock_verify_crc(

xfs_btree_agblock_verify_crc(

	struct xfs_buf		*bp)

{

	struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
@@ -938,7 +930,7 @@ xfs_btree_reada_bufs( 
}



STATIC int

xfs_btree_readahead_lblock(

xfs_btree_readahead_fsblock(

	struct xfs_btree_cur	*cur,

	int			lr,

	struct xfs_btree_block	*block)
@@ -963,7 +955,7 @@ xfs_btree_readahead_lblock( 
}



STATIC int

xfs_btree_readahead_sblock(

xfs_btree_readahead_agblock(

	struct xfs_btree_cur	*cur,

	int			lr,

	struct xfs_btree_block *block)
@@ -1014,8 +1006,8 @@ xfs_btree_readahead( 
	block = XFS_BUF_TO_BLOCK(cur->bc_levels[lev].bp);



	if (cur->bc_ops->ptr_len == XFS_BTREE_LONG_PTR_LEN)

		return xfs_btree_readahead_lblock(cur, lr, block);

	return xfs_btree_readahead_sblock(cur, lr, block);

		return xfs_btree_readahead_fsblock(cur, lr, block);

	return xfs_btree_readahead_agblock(cur, lr, block);

}



STATIC int
@@ -4622,7 +4614,7 @@ xfs_btree_change_owner( 


/* Verify the v5 fields of a long-format btree block. */

xfs_failaddr_t

xfs_btree_lblock_v5hdr_verify(

xfs_btree_fsblock_v5hdr_verify(

	struct xfs_buf		*bp,

	uint64_t		owner)

{
@@ -4643,7 +4635,7 @@ xfs_btree_lblock_v5hdr_verify( 


/* Verify a long-format btree block. */

xfs_failaddr_t

xfs_btree_lblock_verify(

xfs_btree_fsblock_verify(

	struct xfs_buf		*bp,

	unsigned int		max_recs)

{
@@ -4658,22 +4650,22 @@ xfs_btree_lblock_verify( 


	/* sibling pointer verification */

	fsb = XFS_DADDR_TO_FSB(mp, xfs_buf_daddr(bp));

	fa = xfs_btree_check_lblock_siblings(mp, NULL, -1, fsb,

	fa = xfs_btree_check_fsblock_siblings(mp, fsb,

			block->bb_u.l.bb_leftsib);

	if (!fa)

		fa = xfs_btree_check_lblock_siblings(mp, NULL, -1, fsb,

		fa = xfs_btree_check_fsblock_siblings(mp, fsb,

				block->bb_u.l.bb_rightsib);

	return fa;

}



/**

 * xfs_btree_sblock_v5hdr_verify() -- verify the v5 fields of a short-format

 * xfs_btree_agblock_v5hdr_verify() -- verify the v5 fields of a short-format

 *				      btree block

 *

 * @bp: buffer containing the btree block

 */

xfs_failaddr_t

xfs_btree_sblock_v5hdr_verify(

xfs_btree_agblock_v5hdr_verify(

	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = bp->b_mount;
@@ -4692,13 +4684,13 @@ xfs_btree_sblock_v5hdr_verify( 
}



/**

 * xfs_btree_sblock_verify() -- verify a short-format btree block

 * xfs_btree_agblock_verify() -- verify a short-format btree block

 *

 * @bp: buffer containing the btree block

 * @max_recs: maximum records allowed in this btree node

 */

xfs_failaddr_t

xfs_btree_sblock_verify(

xfs_btree_agblock_verify(

	struct xfs_buf		*bp,

	unsigned int		max_recs)

{
@@ -4713,10 +4705,10 @@ xfs_btree_sblock_verify( 


	/* sibling pointer verification */

	agbno = xfs_daddr_to_agbno(mp, xfs_buf_daddr(bp));

	fa = xfs_btree_check_sblock_siblings(bp->b_pag, NULL, -1, agbno,

	fa = xfs_btree_check_agblock_siblings(bp->b_pag, agbno,

			block->bb_u.s.bb_leftsib);

	if (!fa)

		fa = xfs_btree_check_sblock_siblings(bp->b_pag, NULL, -1, agbno,

		fa = xfs_btree_check_agblock_siblings(bp->b_pag, agbno,

				block->bb_u.s.bb_rightsib);

	return fa;

}

fs/xfs/libxfs/xfs_btree.h

+11 −33
Original line number Diff line number Diff line
@@ -334,14 +334,10 @@ xfs_btree_cur_sizeof(unsigned int nlevels) 
 */

#define	XFS_BUF_TO_BLOCK(bp)	((struct xfs_btree_block *)((bp)->b_addr))



/*

 * Internal long and short btree block checks.  They return NULL if the

 * block is ok or the address of the failed check otherwise.

 */

xfs_failaddr_t __xfs_btree_check_lblock(struct xfs_btree_cur *cur,

		struct xfs_btree_block *block, int level, struct xfs_buf *bp);

xfs_failaddr_t __xfs_btree_check_sblock(struct xfs_btree_cur *cur,

xfs_failaddr_t __xfs_btree_check_block(struct xfs_btree_cur *cur,

		struct xfs_btree_block *block, int level, struct xfs_buf *bp);

int __xfs_btree_check_ptr(struct xfs_btree_cur *cur,

		const union xfs_btree_ptr *ptr, int index, int level);



/*

 * Check that block header is ok.
@@ -353,24 +349,6 @@ xfs_btree_check_block( 
	int			level,	/* level of the btree block */

	struct xfs_buf		*bp);	/* buffer containing block, if any */



/*

 * Check that (long) pointer is ok.

 */

bool					/* error (0 or EFSCORRUPTED) */

xfs_btree_check_lptr(

	struct xfs_btree_cur	*cur,	/* btree cursor */

	xfs_fsblock_t		fsbno,	/* btree block disk address */

	int			level);	/* btree block level */



/*

 * Check that (short) pointer is ok.

 */

bool					/* error (0 or EFSCORRUPTED) */

xfs_btree_check_sptr(

	struct xfs_btree_cur	*cur,	/* btree cursor */

	xfs_agblock_t		agbno,	/* btree block disk address */

	int			level);	/* btree block level */



/*

 * Delete the btree cursor.

 */
@@ -463,10 +441,10 @@ int xfs_btree_change_owner(struct xfs_btree_cur *cur, uint64_t new_owner, 
/*

 * btree block CRC helpers

 */

void xfs_btree_lblock_calc_crc(struct xfs_buf *);

bool xfs_btree_lblock_verify_crc(struct xfs_buf *);

void xfs_btree_sblock_calc_crc(struct xfs_buf *);

bool xfs_btree_sblock_verify_crc(struct xfs_buf *);

void xfs_btree_fsblock_calc_crc(struct xfs_buf *);

bool xfs_btree_fsblock_verify_crc(struct xfs_buf *);

void xfs_btree_agblock_calc_crc(struct xfs_buf *);

bool xfs_btree_agblock_verify_crc(struct xfs_buf *);



/*

 * Internal btree helpers also used by xfs_bmap.c.
@@ -506,12 +484,12 @@ static inline int xfs_btree_get_level(const struct xfs_btree_block *block) 
#define	XFS_FILBLKS_MIN(a,b)	min_t(xfs_filblks_t, (a), (b))

#define	XFS_FILBLKS_MAX(a,b)	max_t(xfs_filblks_t, (a), (b))



xfs_failaddr_t xfs_btree_sblock_v5hdr_verify(struct xfs_buf *bp);

xfs_failaddr_t xfs_btree_sblock_verify(struct xfs_buf *bp,

xfs_failaddr_t xfs_btree_agblock_v5hdr_verify(struct xfs_buf *bp);

xfs_failaddr_t xfs_btree_agblock_verify(struct xfs_buf *bp,

		unsigned int max_recs);

xfs_failaddr_t xfs_btree_lblock_v5hdr_verify(struct xfs_buf *bp,

xfs_failaddr_t xfs_btree_fsblock_v5hdr_verify(struct xfs_buf *bp,

		uint64_t owner);

xfs_failaddr_t xfs_btree_lblock_verify(struct xfs_buf *bp,

xfs_failaddr_t xfs_btree_fsblock_verify(struct xfs_buf *bp,

		unsigned int max_recs);



unsigned int xfs_btree_compute_maxlevels(const unsigned int *limits,