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

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

[XFS] move xfs_bmbt_killroot to common code 



xfs_bmbt_killroot is a mostly generic implementation of moving from a real
block based root to an inode based root. So move it to xfs_btree.c where
it can use all the nice infrastructure there and make it pointer size
agnostic

The new name for it is xfs_btree_kill_iroot, following the old naming but
making it clear we're dealing with the root in inode case here, and to
avoid confusion with xfs_btree_new_root which is used for the not inode
rooted case. I've also added a comment describing what it does and why
it's named the way it is.

SGI-PV: 985583

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

Signed-off-by: default avatarChristoph Hellwig <hch@infradead.org>
Signed-off-by: default avatarLachlan McIlroy <lachlan@sgi.com>
Signed-off-by: default avatarBill O'Donnell <billodo@sgi.com>
Signed-off-by: default avatarDavid Chinner <david@fromorbit.com>
parent 4b22a571

fs/xfs/xfs_alloc_btree.c

+32 −0
Original line number Diff line number Diff line
@@ -834,6 +834,37 @@ xfs_allocbt_alloc_block( 
	return 0;

}



STATIC int

xfs_allocbt_free_block(

	struct xfs_btree_cur	*cur,

	struct xfs_buf		*bp)

{

	struct xfs_buf		*agbp = cur->bc_private.a.agbp;

	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);

	xfs_agblock_t		bno;

	int			error;



	bno = XFS_DADDR_TO_AGBNO(cur->bc_mp, XFS_BUF_ADDR(bp));

	error = xfs_alloc_put_freelist(cur->bc_tp, agbp, NULL, bno, 1);

	if (error)

		return error;



	/*

	 * Since blocks move to the free list without the coordination used in

	 * xfs_bmap_finish, we can't allow block to be available for

	 * reallocation and non-transaction writing (user data) until we know

	 * that the transaction that moved it to the free list is permanently

	 * on disk. We track the blocks by declaring these blocks as "busy";

	 * the busy list is maintained on a per-ag basis and each transaction

	 * records which entries should be removed when the iclog commits to

	 * disk. If a busy block is allocated, the iclog is pushed up to the

	 * LSN that freed the block.

	 */

	xfs_alloc_mark_busy(cur->bc_tp, be32_to_cpu(agf->agf_seqno), bno, 1);

	xfs_trans_agbtree_delta(cur->bc_tp, -1);

	return 0;

}



/*

 * Update the longest extent in the AGF

 */
@@ -1025,6 +1056,7 @@ static const struct xfs_btree_ops xfs_allocbt_ops = { 
	.dup_cursor		= xfs_allocbt_dup_cursor,

	.set_root		= xfs_allocbt_set_root,

	.alloc_block		= xfs_allocbt_alloc_block,

	.free_block		= xfs_allocbt_free_block,

	.update_lastrec		= xfs_allocbt_update_lastrec,

	.get_maxrecs		= xfs_allocbt_get_maxrecs,

	.init_key_from_rec	= xfs_allocbt_init_key_from_rec,

fs/xfs/xfs_bmap_btree.c

+22 −94
Original line number Diff line number Diff line
@@ -49,7 +49,6 @@ 
 */





STATIC int xfs_bmbt_killroot(xfs_btree_cur_t *);

STATIC void xfs_bmbt_log_keys(xfs_btree_cur_t *, xfs_buf_t *, int, int);

STATIC void xfs_bmbt_log_ptrs(xfs_btree_cur_t *, xfs_buf_t *, int, int);
@@ -194,7 +193,7 @@ xfs_bmbt_delrec( 
	if (level == cur->bc_nlevels - 1) {

		xfs_iroot_realloc(cur->bc_private.b.ip, -1,

			cur->bc_private.b.whichfork);

		if ((error = xfs_bmbt_killroot(cur))) {

		if ((error = xfs_btree_kill_iroot(cur))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			goto error0;

		}
@@ -228,7 +227,7 @@ xfs_bmbt_delrec( 
	 */

	if (lbno == NULLFSBLOCK && rbno == NULLFSBLOCK &&

	    level == cur->bc_nlevels - 2) {

		if ((error = xfs_bmbt_killroot(cur))) {

		if ((error = xfs_btree_kill_iroot(cur))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			goto error0;

		}
@@ -456,97 +455,6 @@ error0: 
	return error;

}



STATIC int

xfs_bmbt_killroot(

	xfs_btree_cur_t		*cur)

{

	xfs_bmbt_block_t	*block;

	xfs_bmbt_block_t	*cblock;

	xfs_buf_t		*cbp;

	xfs_bmbt_key_t		*ckp;

	xfs_bmbt_ptr_t		*cpp;

#ifdef DEBUG

	int			error;

#endif

	int			i;

	xfs_bmbt_key_t		*kp;

	xfs_inode_t		*ip;

	xfs_ifork_t		*ifp;

	int			level;

	xfs_bmbt_ptr_t		*pp;



	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);

	level = cur->bc_nlevels - 1;

	ASSERT(level >= 1);

	/*

	 * Don't deal with the root block needs to be a leaf case.

	 * We're just going to turn the thing back into extents anyway.

	 */

	if (level == 1) {

		XFS_BMBT_TRACE_CURSOR(cur, EXIT);

		return 0;

	}

	block = xfs_bmbt_get_block(cur, level, &cbp);

	/*

	 * Give up if the root has multiple children.

	 */

	if (be16_to_cpu(block->bb_numrecs) != 1) {

		XFS_BMBT_TRACE_CURSOR(cur, EXIT);

		return 0;

	}

	/*

	 * Only do this if the next level will fit.

	 * Then the data must be copied up to the inode,

	 * instead of freeing the root you free the next level.

	 */

	cbp = cur->bc_bufs[level - 1];

	cblock = XFS_BUF_TO_BMBT_BLOCK(cbp);

	if (be16_to_cpu(cblock->bb_numrecs) > XFS_BMAP_BLOCK_DMAXRECS(level, cur)) {

		XFS_BMBT_TRACE_CURSOR(cur, EXIT);

		return 0;

	}

	ASSERT(be64_to_cpu(cblock->bb_leftsib) == NULLDFSBNO);

	ASSERT(be64_to_cpu(cblock->bb_rightsib) == NULLDFSBNO);

	ip = cur->bc_private.b.ip;

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

	ASSERT(XFS_BMAP_BLOCK_IMAXRECS(level, cur) ==

	       XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes));

	i = (int)(be16_to_cpu(cblock->bb_numrecs) - XFS_BMAP_BLOCK_IMAXRECS(level, cur));

	if (i) {

		xfs_iroot_realloc(ip, i, cur->bc_private.b.whichfork);

		block = ifp->if_broot;

	}

	be16_add_cpu(&block->bb_numrecs, i);

	ASSERT(block->bb_numrecs == cblock->bb_numrecs);

	kp = XFS_BMAP_KEY_IADDR(block, 1, cur);

	ckp = XFS_BMAP_KEY_IADDR(cblock, 1, cur);

	memcpy(kp, ckp, be16_to_cpu(block->bb_numrecs) * sizeof(*kp));

	pp = XFS_BMAP_PTR_IADDR(block, 1, cur);

	cpp = XFS_BMAP_PTR_IADDR(cblock, 1, cur);

#ifdef DEBUG

	for (i = 0; i < be16_to_cpu(cblock->bb_numrecs); i++) {

		if ((error = xfs_btree_check_lptr_disk(cur, cpp[i], level - 1))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			return error;

		}

	}

#endif

	memcpy(pp, cpp, be16_to_cpu(block->bb_numrecs) * sizeof(*pp));

	xfs_bmap_add_free(XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(cbp)), 1,

			cur->bc_private.b.flist, cur->bc_mp);

	ip->i_d.di_nblocks--;

	XFS_TRANS_MOD_DQUOT_BYINO(cur->bc_mp, cur->bc_tp, ip,

			XFS_TRANS_DQ_BCOUNT, -1L);

	xfs_trans_binval(cur->bc_tp, cbp);

	cur->bc_bufs[level - 1] = NULL;

	be16_add_cpu(&block->bb_level, -1);

	xfs_trans_log_inode(cur->bc_tp, ip,

		XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));

	cur->bc_nlevels--;

	XFS_BMBT_TRACE_CURSOR(cur, EXIT);

	return 0;

}



/*

 * Log key values from the btree block.

 */
@@ -1298,6 +1206,25 @@ xfs_bmbt_alloc_block( 
	return error;

}



STATIC int

xfs_bmbt_free_block(

	struct xfs_btree_cur	*cur,

	struct xfs_buf		*bp)

{

	struct xfs_mount	*mp = cur->bc_mp;

	struct xfs_inode	*ip = cur->bc_private.b.ip;

	struct xfs_trans	*tp = cur->bc_tp;

	xfs_fsblock_t		fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));



	xfs_bmap_add_free(fsbno, 1, cur->bc_private.b.flist, mp);

	ip->i_d.di_nblocks--;



	xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);

	XFS_TRANS_MOD_DQUOT_BYINO(mp, tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);

	xfs_trans_binval(tp, bp);

	return 0;

}



STATIC int

xfs_bmbt_get_maxrecs(

	struct xfs_btree_cur	*cur,
@@ -1460,6 +1387,7 @@ static const struct xfs_btree_ops xfs_bmbt_ops = { 
	.dup_cursor		= xfs_bmbt_dup_cursor,

	.update_cursor		= xfs_bmbt_update_cursor,

	.alloc_block		= xfs_bmbt_alloc_block,

	.free_block		= xfs_bmbt_free_block,

	.get_maxrecs		= xfs_bmbt_get_maxrecs,

	.get_dmaxrecs		= xfs_bmbt_get_dmaxrecs,

	.init_key_from_rec	= xfs_bmbt_init_key_from_rec,

fs/xfs/xfs_btree.c

+112 −0
Original line number Diff line number Diff line
@@ -3059,3 +3059,115 @@ error0: 
	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);

	return error;

}



/*

 * Try to merge a non-leaf block back into the inode root.

 *

 * Note: the killroot names comes from the fact that we're effectively

 * killing the old root block.  But because we can't just delete the

 * inode we have to copy the single block it was pointing to into the

 * inode.

 */

int

xfs_btree_kill_iroot(

	struct xfs_btree_cur	*cur)

{

	int			whichfork = cur->bc_private.b.whichfork;

	struct xfs_inode	*ip = cur->bc_private.b.ip;

	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);

	struct xfs_btree_block	*block;

	struct xfs_btree_block	*cblock;

	union xfs_btree_key	*kp;

	union xfs_btree_key	*ckp;

	union xfs_btree_ptr	*pp;

	union xfs_btree_ptr	*cpp;

	struct xfs_buf		*cbp;

	int			level;

	int			index;

	int			numrecs;

#ifdef DEBUG

	union xfs_btree_ptr	ptr;

	int			i;

#endif



	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);



	ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);

	ASSERT(cur->bc_nlevels > 1);



	/*

	 * Don't deal with the root block needs to be a leaf case.

	 * We're just going to turn the thing back into extents anyway.

	 */

	level = cur->bc_nlevels - 1;

	if (level == 1)

		goto out0;



	/*

	 * Give up if the root has multiple children.

	 */

	block = xfs_btree_get_iroot(cur);

	if (xfs_btree_get_numrecs(block) != 1)

		goto out0;



	cblock = xfs_btree_get_block(cur, level - 1, &cbp);

	numrecs = xfs_btree_get_numrecs(cblock);



	/*

	 * Only do this if the next level will fit.

	 * Then the data must be copied up to the inode,

	 * instead of freeing the root you free the next level.

	 */

	if (numrecs > cur->bc_ops->get_dmaxrecs(cur, level))

		goto out0;



	XFS_BTREE_STATS_INC(cur, killroot);



#ifdef DEBUG

	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);

	ASSERT(xfs_btree_ptr_is_null(cur, &ptr));

	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);

	ASSERT(xfs_btree_ptr_is_null(cur, &ptr));

#endif



	index = numrecs - cur->bc_ops->get_maxrecs(cur, level);

	if (index) {

		xfs_iroot_realloc(cur->bc_private.b.ip, index,

				  cur->bc_private.b.whichfork);

		block = (struct xfs_btree_block *)ifp->if_broot;

	}



	be16_add_cpu(&block->bb_numrecs, index);

	ASSERT(block->bb_numrecs == cblock->bb_numrecs);



	kp = xfs_btree_key_addr(cur, 1, block);

	ckp = xfs_btree_key_addr(cur, 1, cblock);

	xfs_btree_copy_keys(cur, kp, ckp, numrecs);



	pp = xfs_btree_ptr_addr(cur, 1, block);

	cpp = xfs_btree_ptr_addr(cur, 1, cblock);

#ifdef DEBUG

	for (i = 0; i < numrecs; i++) {

		int		error;



		error = xfs_btree_check_ptr(cur, cpp, i, level - 1);

		if (error) {

			XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);

			return error;

		}

	}

#endif

	xfs_btree_copy_ptrs(cur, pp, cpp, numrecs);



	cur->bc_ops->free_block(cur, cbp);

	XFS_BTREE_STATS_INC(cur, free);



	cur->bc_bufs[level - 1] = NULL;

	be16_add_cpu(&block->bb_level, -1);

	xfs_trans_log_inode(cur->bc_tp, ip,

		XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));

	cur->bc_nlevels--;

out0:

	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);

	return 0;

}

fs/xfs/xfs_btree.h

+2 −0
Original line number Diff line number Diff line
@@ -198,6 +198,7 @@ struct xfs_btree_ops { 
			       union xfs_btree_ptr *start_bno,

			       union xfs_btree_ptr *new_bno,

			       int length, int *stat);

	int	(*free_block)(struct xfs_btree_cur *cur, struct xfs_buf *bp);



	/* update last record information */

	void	(*update_lastrec)(struct xfs_btree_cur *cur,
@@ -559,6 +560,7 @@ int xfs_btree_split(struct xfs_btree_cur *, int, union xfs_btree_ptr *, 
		union xfs_btree_key *, struct xfs_btree_cur **, int *);

int xfs_btree_new_root(struct xfs_btree_cur *, int *);

int xfs_btree_new_iroot(struct xfs_btree_cur *, int *, int *);

int xfs_btree_kill_iroot(struct xfs_btree_cur *);

int xfs_btree_insert(struct xfs_btree_cur *, int *);



/*

fs/xfs/xfs_ialloc_btree.c

+17 −0
Original line number Diff line number Diff line
@@ -754,6 +754,22 @@ xfs_inobt_alloc_block( 
	return 0;

}



STATIC int

xfs_inobt_free_block(

	struct xfs_btree_cur	*cur,

	struct xfs_buf		*bp)

{

	xfs_fsblock_t		fsbno;

	int			error;



	fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp));

	error = xfs_free_extent(cur->bc_tp, fsbno, 1);

	if (error)

		return error;



	xfs_trans_binval(cur->bc_tp, bp);

	return error;

}



STATIC int

xfs_inobt_get_maxrecs(
@@ -886,6 +902,7 @@ static const struct xfs_btree_ops xfs_inobt_ops = { 
	.dup_cursor		= xfs_inobt_dup_cursor,

	.set_root		= xfs_inobt_set_root,

	.alloc_block		= xfs_inobt_alloc_block,

	.free_block		= xfs_inobt_free_block,

	.get_maxrecs		= xfs_inobt_get_maxrecs,

	.init_key_from_rec	= xfs_inobt_init_key_from_rec,

	.init_rec_from_key	= xfs_inobt_init_rec_from_key,