Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 60197e8d authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Lachlan McIlroy
Browse files

[XFS] Cleanup maxrecs calculation. 



Clean up the way the maximum and minimum records for the btree blocks are
calculated. For the alloc and inobt btrees all the values are
pre-calculated in xfs_mount_common, and we switch the current loop around
the ugly generic macros that use cpp token pasting to generate type names
to two small helpers in normal C code. For the bmbt and bmdr trees these
helpers also exist, but can be called during runtime, too. Here we also
kill various macros dealing with them and inline the logic into the
get_minrecs / get_maxrecs / get_dmaxrecs methods in xfs_bmap_btree.c.

Note that all these new helpers take an xfs_mount * argument which will be
needed to determine the size of a btree block once we add support for
extended btree blocks with CRCs and other RAS information.

SGI-PV: 988146

SGI-Modid: xfs-linux-melb:xfs-kern:32292a

Signed-off-by: default avatarChristoph Hellwig <hch@infradead.org>
Signed-off-by: default avatarDonald Douwsma <donaldd@sgi.com>
Signed-off-by: default avatarLachlan McIlroy <lachlan@sgi.com>
parent 5b4d89ae

fs/xfs/xfs_alloc_btree.c

+16 −0
Original line number Diff line number Diff line
@@ -480,3 +480,19 @@ xfs_allocbt_init_cursor( 


	return cur;

}



/*

 * Calculate number of records in an alloc btree block.

 */

int

xfs_allocbt_maxrecs(

	struct xfs_mount	*mp,

	int			blocklen,

	int			leaf)

{

	blocklen -= sizeof(struct xfs_btree_sblock);



	if (leaf)

		return blocklen / sizeof(xfs_alloc_rec_t);

	return blocklen / (sizeof(xfs_alloc_key_t) + sizeof(xfs_alloc_ptr_t));

}

fs/xfs/xfs_alloc_btree.h

+1 −6
Original line number Diff line number Diff line
@@ -55,12 +55,6 @@ typedef struct xfs_btree_sblock xfs_alloc_block_t; 


#define	XFS_BUF_TO_ALLOC_BLOCK(bp)	((xfs_alloc_block_t *)XFS_BUF_PTR(bp))



/*

 * Real block structures have a size equal to the disk block size.

 */

#define	XFS_ALLOC_BLOCK_MAXRECS(lev,cur) ((cur)->bc_mp->m_alloc_mxr[lev != 0])

#define	XFS_ALLOC_BLOCK_MINRECS(lev,cur) ((cur)->bc_mp->m_alloc_mnr[lev != 0])



/*

 * Minimum and maximum blocksize and sectorsize.

 * The blocksize upper limit is pretty much arbitrary.
@@ -98,5 +92,6 @@ typedef struct xfs_btree_sblock xfs_alloc_block_t; 
extern struct xfs_btree_cur *xfs_allocbt_init_cursor(struct xfs_mount *,

		struct xfs_trans *, struct xfs_buf *,

		xfs_agnumber_t, xfs_btnum_t);

extern int xfs_allocbt_maxrecs(struct xfs_mount *, int, int);



#endif	/* __XFS_ALLOC_BTREE_H__ */

fs/xfs/xfs_bmap.c

+9 −9
Original line number Diff line number Diff line
@@ -3051,15 +3051,15 @@ xfs_bmap_btree_to_extents( 
	__be64			*pp;	/* ptr to block address */

	xfs_bmbt_block_t	*rblock;/* root btree block */



	mp = ip->i_mount;

	ifp = XFS_IFORK_PTR(ip, whichfork);

	ASSERT(ifp->if_flags & XFS_IFEXTENTS);

	ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);

	rblock = ifp->if_broot;

	ASSERT(be16_to_cpu(rblock->bb_level) == 1);

	ASSERT(be16_to_cpu(rblock->bb_numrecs) == 1);

	ASSERT(XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes) == 1);

	mp = ip->i_mount;

	pp = XFS_BMAP_BROOT_PTR_ADDR(rblock, 1, ifp->if_broot_bytes);

	ASSERT(xfs_bmbt_maxrecs(mp, ifp->if_broot_bytes, 0) == 1);

	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, ifp->if_broot_bytes);

	cbno = be64_to_cpu(*pp);

	*logflagsp = 0;

#ifdef DEBUG
@@ -4221,7 +4221,7 @@ xfs_bmap_compute_maxlevels( 
		maxleafents = MAXAEXTNUM;

		sz = XFS_BMDR_SPACE_CALC(MINABTPTRS);

	}

	maxrootrecs = (int)XFS_BTREE_BLOCK_MAXRECS(sz, xfs_bmdr, 0);

	maxrootrecs = xfs_bmdr_maxrecs(mp, sz, 0);

	minleafrecs = mp->m_bmap_dmnr[0];

	minnoderecs = mp->m_bmap_dmnr[1];

	maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
@@ -4555,7 +4555,7 @@ xfs_bmap_read_extents( 
	 */

	level = be16_to_cpu(block->bb_level);

	ASSERT(level > 0);

	pp = XFS_BMAP_BROOT_PTR_ADDR(block, 1, ifp->if_broot_bytes);

	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);

	bno = be64_to_cpu(*pp);

	ASSERT(bno != NULLDFSBNO);

	ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);
@@ -6205,13 +6205,13 @@ xfs_check_block( 
		 */



		if (root) {

			pp = XFS_BMAP_BROOT_PTR_ADDR(block, i, sz);

			pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, i, sz);

		} else {

			pp = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, i, dmxr);

		}

		for (j = i+1; j <= be16_to_cpu(block->bb_numrecs); j++) {

			if (root) {

				thispa = XFS_BMAP_BROOT_PTR_ADDR(block, j, sz);

				thispa = XFS_BMAP_BROOT_PTR_ADDR(mp, block, j, sz);

			} else {

				thispa = XFS_BTREE_PTR_ADDR(xfs_bmbt, block, j,

							    dmxr);
@@ -6266,7 +6266,7 @@ xfs_bmap_check_leaf_extents( 
	level = be16_to_cpu(block->bb_level);

	ASSERT(level > 0);

	xfs_check_block(block, mp, 1, ifp->if_broot_bytes);

	pp = XFS_BMAP_BROOT_PTR_ADDR(block, 1, ifp->if_broot_bytes);

	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);

	bno = be64_to_cpu(*pp);



	ASSERT(bno != NULLDFSBNO);
@@ -6426,7 +6426,7 @@ xfs_bmap_count_blocks( 
	block = ifp->if_broot;

	level = be16_to_cpu(block->bb_level);

	ASSERT(level > 0);

	pp = XFS_BMAP_BROOT_PTR_ADDR(block, 1, ifp->if_broot_bytes);

	pp = XFS_BMAP_BROOT_PTR_ADDR(mp, block, 1, ifp->if_broot_bytes);

	bno = be64_to_cpu(*pp);

	ASSERT(bno != NULLDFSBNO);

	ASSERT(XFS_FSB_TO_AGNO(mp, bno) < mp->m_sb.sb_agcount);

fs/xfs/xfs_bmap_btree.c

+66 −8
Original line number Diff line number Diff line
@@ -66,6 +66,7 @@ xfs_extent_state( 
 */

void

xfs_bmdr_to_bmbt(

	struct xfs_mount	*mp,

	xfs_bmdr_block_t	*dblock,

	int			dblocklen,

	xfs_bmbt_block_t	*rblock,
@@ -83,11 +84,11 @@ xfs_bmdr_to_bmbt( 
	rblock->bb_numrecs = dblock->bb_numrecs;

	rblock->bb_leftsib = cpu_to_be64(NULLDFSBNO);

	rblock->bb_rightsib = cpu_to_be64(NULLDFSBNO);

	dmxr = (int)XFS_BTREE_BLOCK_MAXRECS(dblocklen, xfs_bmdr, 0);

	dmxr = xfs_bmdr_maxrecs(mp, dblocklen, 0);

	fkp = XFS_BTREE_KEY_ADDR(xfs_bmdr, dblock, 1);

	tkp = XFS_BMAP_BROOT_KEY_ADDR(rblock, 1, rblocklen);

	fpp = XFS_BTREE_PTR_ADDR(xfs_bmdr, dblock, 1, dmxr);

	tpp = XFS_BMAP_BROOT_PTR_ADDR(rblock, 1, rblocklen);

	tpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);

	dmxr = be16_to_cpu(dblock->bb_numrecs);

	memcpy(tkp, fkp, sizeof(*fkp) * dmxr);

	memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
@@ -428,6 +429,7 @@ xfs_bmbt_set_state( 
 */

void

xfs_bmbt_to_bmdr(

	struct xfs_mount	*mp,

	xfs_bmbt_block_t	*rblock,

	int			rblocklen,

	xfs_bmdr_block_t	*dblock,
@@ -445,10 +447,10 @@ xfs_bmbt_to_bmdr( 
	ASSERT(be16_to_cpu(rblock->bb_level) > 0);

	dblock->bb_level = rblock->bb_level;

	dblock->bb_numrecs = rblock->bb_numrecs;

	dmxr = (int)XFS_BTREE_BLOCK_MAXRECS(dblocklen, xfs_bmdr, 0);

	dmxr = xfs_bmdr_maxrecs(mp, dblocklen, 0);

	fkp = XFS_BMAP_BROOT_KEY_ADDR(rblock, 1, rblocklen);

	tkp = XFS_BTREE_KEY_ADDR(xfs_bmdr, dblock, 1);

	fpp = XFS_BMAP_BROOT_PTR_ADDR(rblock, 1, rblocklen);

	fpp = XFS_BMAP_BROOT_PTR_ADDR(mp, rblock, 1, rblocklen);

	tpp = XFS_BTREE_PTR_ADDR(xfs_bmdr, dblock, 1, dmxr);

	dmxr = be16_to_cpu(dblock->bb_numrecs);

	memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
@@ -626,15 +628,36 @@ xfs_bmbt_get_minrecs( 
	struct xfs_btree_cur	*cur,

	int			level)

{

	return XFS_BMAP_BLOCK_IMINRECS(level, cur);

	if (level == cur->bc_nlevels - 1) {

		struct xfs_ifork	*ifp;



		ifp = XFS_IFORK_PTR(cur->bc_private.b.ip,

				    cur->bc_private.b.whichfork);



		return xfs_bmbt_maxrecs(cur->bc_mp,

					ifp->if_broot_bytes, level == 0) / 2;

	}



STATIC int

	return cur->bc_mp->m_bmap_dmnr[level != 0];

}



int

xfs_bmbt_get_maxrecs(

	struct xfs_btree_cur	*cur,

	int			level)

{

	return XFS_BMAP_BLOCK_IMAXRECS(level, cur);

	if (level == cur->bc_nlevels - 1) {

		struct xfs_ifork	*ifp;



		ifp = XFS_IFORK_PTR(cur->bc_private.b.ip,

				    cur->bc_private.b.whichfork);



		return xfs_bmbt_maxrecs(cur->bc_mp,

					ifp->if_broot_bytes, level == 0);

	}



	return cur->bc_mp->m_bmap_dmxr[level != 0];



}



/*
@@ -651,7 +674,10 @@ xfs_bmbt_get_dmaxrecs( 
	struct xfs_btree_cur	*cur,

	int			level)

{

	return XFS_BMAP_BLOCK_DMAXRECS(level, cur);

	if (level != cur->bc_nlevels - 1)

		return cur->bc_mp->m_bmap_dmxr[level != 0];

	return xfs_bmdr_maxrecs(cur->bc_mp, cur->bc_private.b.forksize,

				level == 0);

}



STATIC void
@@ -871,3 +897,35 @@ xfs_bmbt_init_cursor( 


	return cur;

}



/*

 * Calculate number of records in a bmap btree block.

 */

int

xfs_bmbt_maxrecs(

	struct xfs_mount	*mp,

	int			blocklen,

	int			leaf)

{

	blocklen -= sizeof(struct xfs_btree_lblock);



	if (leaf)

		return blocklen / sizeof(xfs_bmbt_rec_t);

	return blocklen / (sizeof(xfs_bmbt_key_t) + sizeof(xfs_bmbt_ptr_t));

}



/*

 * Calculate number of records in a bmap btree inode root.

 */

int

xfs_bmdr_maxrecs(

	struct xfs_mount	*mp,

	int			blocklen,

	int			leaf)

{

	blocklen -= sizeof(xfs_bmdr_block_t);



	if (leaf)

		return blocklen / sizeof(xfs_bmdr_rec_t);

	return blocklen / (sizeof(xfs_bmdr_key_t) + sizeof(xfs_bmdr_ptr_t));

}

fs/xfs/xfs_bmap_btree.h

+12 −36
Original line number Diff line number Diff line
@@ -151,33 +151,6 @@ typedef struct xfs_btree_lblock xfs_bmbt_block_t; 


#define XFS_BUF_TO_BMBT_BLOCK(bp)	((xfs_bmbt_block_t *)XFS_BUF_PTR(bp))



#define XFS_BMAP_RBLOCK_DSIZE(lev,cur)	((cur)->bc_private.b.forksize)

#define XFS_BMAP_RBLOCK_ISIZE(lev,cur)	\

	((int)XFS_IFORK_PTR((cur)->bc_private.b.ip, \

		    (cur)->bc_private.b.whichfork)->if_broot_bytes)



#define XFS_BMAP_BLOCK_DMAXRECS(lev,cur) \

	(((lev) == (cur)->bc_nlevels - 1 ? \

		XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur), \

			xfs_bmdr, (lev) == 0) : \

		((cur)->bc_mp->m_bmap_dmxr[(lev) != 0])))

#define XFS_BMAP_BLOCK_IMAXRECS(lev,cur) \

	(((lev) == (cur)->bc_nlevels - 1 ? \

			XFS_BTREE_BLOCK_MAXRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur),\

				xfs_bmbt, (lev) == 0) : \

			((cur)->bc_mp->m_bmap_dmxr[(lev) != 0])))



#define XFS_BMAP_BLOCK_DMINRECS(lev,cur) \

	(((lev) == (cur)->bc_nlevels - 1 ? \

			XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_DSIZE(lev,cur),\

				xfs_bmdr, (lev) == 0) : \

			((cur)->bc_mp->m_bmap_dmnr[(lev) != 0])))

#define XFS_BMAP_BLOCK_IMINRECS(lev,cur) \

	(((lev) == (cur)->bc_nlevels - 1 ? \

			XFS_BTREE_BLOCK_MINRECS(XFS_BMAP_RBLOCK_ISIZE(lev,cur),\

				xfs_bmbt, (lev) == 0) : \

			((cur)->bc_mp->m_bmap_dmnr[(lev) != 0])))



#define XFS_BMAP_REC_DADDR(bb,i,cur)	(XFS_BTREE_REC_ADDR(xfs_bmbt, bb, i))



#define XFS_BMAP_REC_IADDR(bb,i,cur)	(XFS_BTREE_REC_ADDR(xfs_bmbt, bb, i))
@@ -192,8 +165,8 @@ typedef struct xfs_btree_lblock xfs_bmbt_block_t; 
	(XFS_BTREE_PTR_ADDR(xfs_bmbt, bb, i, XFS_BMAP_BLOCK_DMAXRECS(	\

				be16_to_cpu((bb)->bb_level), cur)))

#define XFS_BMAP_PTR_IADDR(bb,i,cur)	\

	(XFS_BTREE_PTR_ADDR(xfs_bmbt, bb, i, XFS_BMAP_BLOCK_IMAXRECS(	\

				be16_to_cpu((bb)->bb_level), cur)))

	(XFS_BTREE_PTR_ADDR(xfs_bmbt, bb, i, xfs_bmbt_get_maxrecs(cur,	\

				be16_to_cpu((bb)->bb_level))))



/*

 * These are to be used when we know the size of the block and
@@ -203,11 +176,8 @@ typedef struct xfs_btree_lblock xfs_bmbt_block_t; 
	(XFS_BTREE_REC_ADDR(xfs_bmbt,bb,i))

#define XFS_BMAP_BROOT_KEY_ADDR(bb,i,sz) \

	(XFS_BTREE_KEY_ADDR(xfs_bmbt,bb,i))

#define XFS_BMAP_BROOT_PTR_ADDR(bb,i,sz) \

	(XFS_BTREE_PTR_ADDR(xfs_bmbt,bb,i,XFS_BMAP_BROOT_MAXRECS(sz)))



#define XFS_BMAP_BROOT_NUMRECS(bb)	be16_to_cpu((bb)->bb_numrecs)

#define XFS_BMAP_BROOT_MAXRECS(sz)	XFS_BTREE_BLOCK_MAXRECS(sz,xfs_bmbt,0)

#define XFS_BMAP_BROOT_PTR_ADDR(mp, bb,i,sz) \

	(XFS_BTREE_PTR_ADDR(xfs_bmbt,bb,i,xfs_bmbt_maxrecs(mp, sz, 0)))



#define XFS_BMAP_BROOT_SPACE_CALC(nrecs) \

	(int)(sizeof(xfs_bmbt_block_t) + \
@@ -234,7 +204,8 @@ typedef struct xfs_btree_lblock xfs_bmbt_block_t; 
/*

 * Prototypes for xfs_bmap.c to call.

 */

extern void xfs_bmdr_to_bmbt(xfs_bmdr_block_t *, int, xfs_bmbt_block_t *, int);

extern void xfs_bmdr_to_bmbt(struct xfs_mount *, xfs_bmdr_block_t *, int,

			xfs_bmbt_block_t *, int);

extern void xfs_bmbt_get_all(xfs_bmbt_rec_host_t *r, xfs_bmbt_irec_t *s);

extern xfs_filblks_t xfs_bmbt_get_blockcount(xfs_bmbt_rec_host_t *r);

extern xfs_fsblock_t xfs_bmbt_get_startblock(xfs_bmbt_rec_host_t *r);
@@ -257,7 +228,12 @@ extern void xfs_bmbt_disk_set_all(xfs_bmbt_rec_t *r, xfs_bmbt_irec_t *s); 
extern void xfs_bmbt_disk_set_allf(xfs_bmbt_rec_t *r, xfs_fileoff_t o,

			xfs_fsblock_t b, xfs_filblks_t c, xfs_exntst_t v);



extern void xfs_bmbt_to_bmdr(xfs_bmbt_block_t *, int, xfs_bmdr_block_t *, int);

extern void xfs_bmbt_to_bmdr(struct xfs_mount *, xfs_bmbt_block_t *, int,

			xfs_bmdr_block_t *, int);



extern int xfs_bmbt_get_maxrecs(struct xfs_btree_cur *, int level);

extern int xfs_bmdr_maxrecs(struct xfs_mount *, int blocklen, int leaf);

extern int xfs_bmbt_maxrecs(struct xfs_mount *, int blocklen, int leaf);



extern struct xfs_btree_cur *xfs_bmbt_init_cursor(struct xfs_mount *,

		struct xfs_trans *, struct xfs_inode *, int);