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

[XFS] implement generic xfs_btree_split 



Make the btree split code generic. Based on a patch from David Chinner
with lots of changes to follow the original btree implementations more
closely. While this loses some of the generic helper routines for
inserting/moving/removing records it also solves some of the one off bugs
in the original code and makes it easier to verify.

SGI-PV: 985583

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

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 687b890a

fs/xfs/xfs_alloc_btree.c

+42 −158
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include "xfs_dinode.h"

#include "xfs_inode.h"

#include "xfs_btree.h"

#include "xfs_btree_trace.h"

#include "xfs_ialloc.h"

#include "xfs_alloc.h"

#include "xfs_error.h"
@@ -48,8 +49,6 @@ STATIC void xfs_alloc_log_keys(xfs_btree_cur_t *, xfs_buf_t *, int, int); 
STATIC void xfs_alloc_log_ptrs(xfs_btree_cur_t *, xfs_buf_t *, int, int);

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

STATIC int xfs_alloc_newroot(xfs_btree_cur_t *, int *);

STATIC int xfs_alloc_split(xfs_btree_cur_t *, int, xfs_agblock_t *,

		xfs_alloc_key_t *, xfs_btree_cur_t **, int *);



/*

 * Internal functions.
@@ -695,15 +694,18 @@ xfs_alloc_insrec( 
			if (i)

				optr = ptr = cur->bc_ptrs[level];

			else {

				union xfs_btree_ptr bno = { .s = cpu_to_be32(nbno) };

				/*

				 * Next, try splitting the current block in

				 * half. If this works we have to re-set our

				 * variables because we could be in a

				 * different block now.

				 */

				if ((error = xfs_alloc_split(cur, level, &nbno,

						&nkey, &ncur, &i)))

				if ((error = xfs_btree_split(cur, level, &bno,

						(union xfs_btree_key *)&nkey,

						&ncur, &i)))

					return error;

				nbno = be32_to_cpu(bno.s);

				if (i) {

					bp = cur->bc_bufs[level];

					block = XFS_BUF_TO_ALLOC_BLOCK(bp);
@@ -1089,160 +1091,6 @@ xfs_alloc_newroot( 
	return 0;

}



/*

 * Split cur/level block in half.

 * Return new block number and its first record (to be inserted into parent).

 */

STATIC int				/* error */

xfs_alloc_split(

	xfs_btree_cur_t		*cur,	/* btree cursor */

	int			level,	/* level to split */

	xfs_agblock_t		*bnop,	/* output: block number allocated */

	xfs_alloc_key_t		*keyp,	/* output: first key of new block */

	xfs_btree_cur_t		**curp,	/* output: new cursor */

	int			*stat)	/* success/failure */

{

	int			error;	/* error return value */

	int			i;	/* loop index/record number */

	xfs_agblock_t		lbno;	/* left (current) block number */

	xfs_buf_t		*lbp;	/* buffer for left block */

	xfs_alloc_block_t	*left;	/* left (current) btree block */

	xfs_agblock_t		rbno;	/* right (new) block number */

	xfs_buf_t		*rbp;	/* buffer for right block */

	xfs_alloc_block_t	*right;	/* right (new) btree block */



	/*

	 * Allocate the new block from the freelist.

	 * If we can't do it, we're toast.  Give up.

	 */

	error = xfs_alloc_get_freelist(cur->bc_tp,

					 cur->bc_private.a.agbp, &rbno, 1);

	if (error)

		return error;

	if (rbno == NULLAGBLOCK) {

		*stat = 0;

		return 0;

	}

	xfs_trans_agbtree_delta(cur->bc_tp, 1);

	rbp = xfs_btree_get_bufs(cur->bc_mp, cur->bc_tp, cur->bc_private.a.agno,

		rbno, 0);

	/*

	 * Set up the new block as "right".

	 */

	right = XFS_BUF_TO_ALLOC_BLOCK(rbp);

	/*

	 * "Left" is the current (according to the cursor) block.

	 */

	lbp = cur->bc_bufs[level];

	left = XFS_BUF_TO_ALLOC_BLOCK(lbp);

#ifdef DEBUG

	if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))

		return error;

#endif

	/*

	 * Fill in the btree header for the new block.

	 */

	right->bb_magic = cpu_to_be32(xfs_magics[cur->bc_btnum]);

	right->bb_level = left->bb_level;

	right->bb_numrecs = cpu_to_be16(be16_to_cpu(left->bb_numrecs) / 2);

	/*

	 * Make sure that if there's an odd number of entries now, that

	 * each new block will have the same number of entries.

	 */

	if ((be16_to_cpu(left->bb_numrecs) & 1) &&

	    cur->bc_ptrs[level] <= be16_to_cpu(right->bb_numrecs) + 1)

		be16_add_cpu(&right->bb_numrecs, 1);

	i = be16_to_cpu(left->bb_numrecs) - be16_to_cpu(right->bb_numrecs) + 1;

	/*

	 * For non-leaf blocks, copy keys and addresses over to the new block.

	 */

	if (level > 0) {

		xfs_alloc_key_t	*lkp;	/* left btree key pointer */

		xfs_alloc_ptr_t	*lpp;	/* left btree address pointer */

		xfs_alloc_key_t	*rkp;	/* right btree key pointer */

		xfs_alloc_ptr_t	*rpp;	/* right btree address pointer */



		lkp = XFS_ALLOC_KEY_ADDR(left, i, cur);

		lpp = XFS_ALLOC_PTR_ADDR(left, i, cur);

		rkp = XFS_ALLOC_KEY_ADDR(right, 1, cur);

		rpp = XFS_ALLOC_PTR_ADDR(right, 1, cur);

#ifdef DEBUG

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

			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(lpp[i]), level)))

				return error;

		}

#endif

		memcpy(rkp, lkp, be16_to_cpu(right->bb_numrecs) * sizeof(*rkp));

		memcpy(rpp, lpp, be16_to_cpu(right->bb_numrecs) * sizeof(*rpp));

		xfs_alloc_log_keys(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));

		xfs_alloc_log_ptrs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));

		*keyp = *rkp;

	}

	/*

	 * For leaf blocks, copy records over to the new block.

	 */

	else {

		xfs_alloc_rec_t	*lrp;	/* left btree record pointer */

		xfs_alloc_rec_t	*rrp;	/* right btree record pointer */



		lrp = XFS_ALLOC_REC_ADDR(left, i, cur);

		rrp = XFS_ALLOC_REC_ADDR(right, 1, cur);

		memcpy(rrp, lrp, be16_to_cpu(right->bb_numrecs) * sizeof(*rrp));

		xfs_alloc_log_recs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));

		keyp->ar_startblock = rrp->ar_startblock;

		keyp->ar_blockcount = rrp->ar_blockcount;

	}

	/*

	 * Find the left block number by looking in the buffer.

	 * Adjust numrecs, sibling pointers.

	 */

	lbno = XFS_DADDR_TO_AGBNO(cur->bc_mp, XFS_BUF_ADDR(lbp));

	be16_add_cpu(&left->bb_numrecs, -(be16_to_cpu(right->bb_numrecs)));

	right->bb_rightsib = left->bb_rightsib;

	left->bb_rightsib = cpu_to_be32(rbno);

	right->bb_leftsib = cpu_to_be32(lbno);

	xfs_alloc_log_block(cur->bc_tp, rbp, XFS_BB_ALL_BITS);

	xfs_alloc_log_block(cur->bc_tp, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);

	/*

	 * If there's a block to the new block's right, make that block

	 * point back to right instead of to left.

	 */

	if (be32_to_cpu(right->bb_rightsib) != NULLAGBLOCK) {

		xfs_alloc_block_t	*rrblock;	/* rr btree block */

		xfs_buf_t		*rrbp;		/* buffer for rrblock */



		if ((error = xfs_btree_read_bufs(cur->bc_mp, cur->bc_tp,

				cur->bc_private.a.agno, be32_to_cpu(right->bb_rightsib), 0,

				&rrbp, XFS_ALLOC_BTREE_REF)))

			return error;

		rrblock = XFS_BUF_TO_ALLOC_BLOCK(rrbp);

		if ((error = xfs_btree_check_sblock(cur, rrblock, level, rrbp)))

			return error;

		rrblock->bb_leftsib = cpu_to_be32(rbno);

		xfs_alloc_log_block(cur->bc_tp, rrbp, XFS_BB_LEFTSIB);

	}

	/*

	 * If the cursor is really in the right block, move it there.

	 * If it's just pointing past the last entry in left, then we'll

	 * insert there, so don't change anything in that case.

	 */

	if (cur->bc_ptrs[level] > be16_to_cpu(left->bb_numrecs) + 1) {

		xfs_btree_setbuf(cur, level, rbp);

		cur->bc_ptrs[level] -= be16_to_cpu(left->bb_numrecs);

	}

	/*

	 * If there are more levels, we'll need another cursor which refers to

	 * the right block, no matter where this cursor was.

	 */

	if (level + 1 < cur->bc_nlevels) {

		if ((error = xfs_btree_dup_cursor(cur, curp)))

			return error;

		(*curp)->bc_ptrs[level + 1]++;

	}

	*bnop = rbno;

	*stat = 1;

	return 0;

}



/*

 * Externally visible routines.
@@ -1396,6 +1244,41 @@ xfs_allocbt_dup_cursor( 
			cur->bc_btnum);

}



STATIC int

xfs_allocbt_alloc_block(

	struct xfs_btree_cur	*cur,

	union xfs_btree_ptr	*start,

	union xfs_btree_ptr	*new,

	int			length,

	int			*stat)

{

	int			error;

	xfs_agblock_t		bno;



	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);



	/* Allocate the new block from the freelist. If we can't, give up.  */

	error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_private.a.agbp,

				       &bno, 1);

	if (error) {

		XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);

		return error;

	}



	if (bno == NULLAGBLOCK) {

		XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);

		*stat = 0;

		return 0;

	}



	xfs_trans_agbtree_delta(cur->bc_tp, 1);

	new->s = cpu_to_be32(bno);



	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);

	*stat = 1;

	return 0;

}



/*

 * Update the longest extent in the AGF

 */
@@ -1557,6 +1440,7 @@ static const struct xfs_btree_ops xfs_allocbt_ops = { 
	.key_len		= sizeof(xfs_alloc_key_t),



	.dup_cursor		= xfs_allocbt_dup_cursor,

	.alloc_block		= xfs_allocbt_alloc_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

+93 −182
Original line number Diff line number Diff line
@@ -52,8 +52,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);

STATIC int xfs_bmbt_split(xfs_btree_cur_t *, int, xfs_fsblock_t *,

		__uint64_t *, xfs_btree_cur_t **, int *);



#undef EXIT
@@ -550,13 +548,17 @@ xfs_bmbt_insrec( 
				if (i) {

					optr = ptr = cur->bc_ptrs[level];

				} else {

					if ((error = xfs_bmbt_split(cur, level,

							&nbno, &startoff, &ncur,

					union xfs_btree_ptr bno = { .l = cpu_to_be64(nbno) };

					union xfs_btree_key skey;

					if ((error = xfs_btree_split(cur, level,

							&bno, &skey, &ncur,

							&i))) {

						XFS_BMBT_TRACE_CURSOR(cur,

							ERROR);

						return error;

					}

					nbno = be64_to_cpu(bno.l);

					startoff = be64_to_cpu(skey.bmbt.br_startoff);

					if (i) {

						block = xfs_bmbt_get_block(

							    cur, level, &bp);
@@ -825,184 +827,6 @@ xfs_extent_state( 
	return XFS_EXT_NORM;

}





/*

 * Split cur/level block in half.

 * Return new block number and its first record (to be inserted into parent).

 */

STATIC int					/* error */

xfs_bmbt_split(

	xfs_btree_cur_t		*cur,

	int			level,

	xfs_fsblock_t		*bnop,

	__uint64_t		*startoff,

	xfs_btree_cur_t		**curp,

	int			*stat)		/* success/failure */

{

	xfs_alloc_arg_t		args;		/* block allocation args */

	int			error;		/* error return value */

	int			i;		/* loop counter */

	xfs_fsblock_t		lbno;		/* left sibling block number */

	xfs_buf_t		*lbp;		/* left buffer pointer */

	xfs_bmbt_block_t	*left;		/* left btree block */

	xfs_bmbt_key_t		*lkp;		/* left btree key */

	xfs_bmbt_ptr_t		*lpp;		/* left address pointer */

	xfs_bmbt_rec_t		*lrp;		/* left record pointer */

	xfs_buf_t		*rbp;		/* right buffer pointer */

	xfs_bmbt_block_t	*right;		/* right btree block */

	xfs_bmbt_key_t		*rkp;		/* right btree key */

	xfs_bmbt_ptr_t		*rpp;		/* right address pointer */

	xfs_bmbt_block_t	*rrblock;	/* right-right btree block */

	xfs_buf_t		*rrbp;		/* right-right buffer pointer */

	xfs_bmbt_rec_t		*rrp;		/* right record pointer */



	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);

	// disable until merged into common code

//	XFS_BMBT_TRACE_ARGIFK(cur, level, *bnop, *startoff);

	args.tp = cur->bc_tp;

	args.mp = cur->bc_mp;

	lbp = cur->bc_bufs[level];

	lbno = XFS_DADDR_TO_FSB(args.mp, XFS_BUF_ADDR(lbp));

	left = XFS_BUF_TO_BMBT_BLOCK(lbp);

	args.fsbno = cur->bc_private.b.firstblock;

	args.firstblock = args.fsbno;

	args.minleft = 0;

	if (args.fsbno == NULLFSBLOCK) {

		args.fsbno = lbno;

		args.type = XFS_ALLOCTYPE_START_BNO;

		/*

		 * Make sure there is sufficient room left in the AG to

		 * complete a full tree split for an extent insert.  If

		 * we are converting the middle part of an extent then

		 * we may need space for two tree splits.

		 *

		 * We are relying on the caller to make the correct block

		 * reservation for this operation to succeed.  If the

		 * reservation amount is insufficient then we may fail a

		 * block allocation here and corrupt the filesystem.

		 */

		args.minleft = xfs_trans_get_block_res(args.tp);

	} else if (cur->bc_private.b.flist->xbf_low)

		args.type = XFS_ALLOCTYPE_START_BNO;

	else

		args.type = XFS_ALLOCTYPE_NEAR_BNO;

	args.mod = args.alignment = args.total = args.isfl =

		args.userdata = args.minalignslop = 0;

	args.minlen = args.maxlen = args.prod = 1;

	args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;

	if (!args.wasdel && xfs_trans_get_block_res(args.tp) == 0) {

		XFS_BMBT_TRACE_CURSOR(cur, ERROR);

		return XFS_ERROR(ENOSPC);

	}

	if ((error = xfs_alloc_vextent(&args))) {

		XFS_BMBT_TRACE_CURSOR(cur, ERROR);

		return error;

	}

	if (args.fsbno == NULLFSBLOCK && args.minleft) {

		/*

		 * Could not find an AG with enough free space to satisfy

		 * a full btree split.  Try again without minleft and if

		 * successful activate the lowspace algorithm.

		 */

		args.fsbno = 0;

		args.type = XFS_ALLOCTYPE_FIRST_AG;

		args.minleft = 0;

		if ((error = xfs_alloc_vextent(&args))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			return error;

		}

		cur->bc_private.b.flist->xbf_low = 1;

	}

	if (args.fsbno == NULLFSBLOCK) {

		XFS_BMBT_TRACE_CURSOR(cur, EXIT);

		*stat = 0;

		return 0;

	}

	ASSERT(args.len == 1);

	cur->bc_private.b.firstblock = args.fsbno;

	cur->bc_private.b.allocated++;

	cur->bc_private.b.ip->i_d.di_nblocks++;

	xfs_trans_log_inode(args.tp, cur->bc_private.b.ip, XFS_ILOG_CORE);

	XFS_TRANS_MOD_DQUOT_BYINO(args.mp, args.tp, cur->bc_private.b.ip,

			XFS_TRANS_DQ_BCOUNT, 1L);

	rbp = xfs_btree_get_bufl(args.mp, args.tp, args.fsbno, 0);

	right = XFS_BUF_TO_BMBT_BLOCK(rbp);

#ifdef DEBUG

	if ((error = xfs_btree_check_lblock(cur, left, level, rbp))) {

		XFS_BMBT_TRACE_CURSOR(cur, ERROR);

		return error;

	}

#endif

	right->bb_magic = cpu_to_be32(XFS_BMAP_MAGIC);

	right->bb_level = left->bb_level;

	right->bb_numrecs = cpu_to_be16(be16_to_cpu(left->bb_numrecs) / 2);

	if ((be16_to_cpu(left->bb_numrecs) & 1) &&

	    cur->bc_ptrs[level] <= be16_to_cpu(right->bb_numrecs) + 1)

		be16_add_cpu(&right->bb_numrecs, 1);

	i = be16_to_cpu(left->bb_numrecs) - be16_to_cpu(right->bb_numrecs) + 1;

	if (level > 0) {

		lkp = XFS_BMAP_KEY_IADDR(left, i, cur);

		lpp = XFS_BMAP_PTR_IADDR(left, i, cur);

		rkp = XFS_BMAP_KEY_IADDR(right, 1, cur);

		rpp = XFS_BMAP_PTR_IADDR(right, 1, cur);

#ifdef DEBUG

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

			if ((error = xfs_btree_check_lptr_disk(cur, lpp[i], level))) {

				XFS_BMBT_TRACE_CURSOR(cur, ERROR);

				return error;

			}

		}

#endif

		memcpy(rkp, lkp, be16_to_cpu(right->bb_numrecs) * sizeof(*rkp));

		memcpy(rpp, lpp, be16_to_cpu(right->bb_numrecs) * sizeof(*rpp));

		xfs_bmbt_log_keys(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));

		xfs_bmbt_log_ptrs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));

		*startoff = be64_to_cpu(rkp->br_startoff);

	} else {

		lrp = XFS_BMAP_REC_IADDR(left, i, cur);

		rrp = XFS_BMAP_REC_IADDR(right, 1, cur);

		memcpy(rrp, lrp, be16_to_cpu(right->bb_numrecs) * sizeof(*rrp));

		xfs_bmbt_log_recs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));

		*startoff = xfs_bmbt_disk_get_startoff(rrp);

	}

	be16_add_cpu(&left->bb_numrecs, -(be16_to_cpu(right->bb_numrecs)));

	right->bb_rightsib = left->bb_rightsib;

	left->bb_rightsib = cpu_to_be64(args.fsbno);

	right->bb_leftsib = cpu_to_be64(lbno);

	xfs_bmbt_log_block(cur, rbp, XFS_BB_ALL_BITS);

	xfs_bmbt_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);

	if (be64_to_cpu(right->bb_rightsib) != NULLDFSBNO) {

		if ((error = xfs_btree_read_bufl(args.mp, args.tp,

				be64_to_cpu(right->bb_rightsib), 0, &rrbp,

				XFS_BMAP_BTREE_REF))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			return error;

		}

		rrblock = XFS_BUF_TO_BMBT_BLOCK(rrbp);

		if ((error = xfs_btree_check_lblock(cur, rrblock, level, rrbp))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			return error;

		}

		rrblock->bb_leftsib = cpu_to_be64(args.fsbno);

		xfs_bmbt_log_block(cur, rrbp, XFS_BB_LEFTSIB);

	}

	if (cur->bc_ptrs[level] > be16_to_cpu(left->bb_numrecs) + 1) {

		xfs_btree_setbuf(cur, level, rbp);

		cur->bc_ptrs[level] -= be16_to_cpu(left->bb_numrecs);

	}

	if (level + 1 < cur->bc_nlevels) {

		if ((error = xfs_btree_dup_cursor(cur, curp))) {

			XFS_BMBT_TRACE_CURSOR(cur, ERROR);

			return error;

		}

		(*curp)->bc_ptrs[level + 1]++;

	}

	*bnop = args.fsbno;

	XFS_BMBT_TRACE_CURSOR(cur, EXIT);

	*stat = 1;

	return 0;

}



/*

 * Convert on-disk form of btree root to in-memory form.

 */
@@ -1737,6 +1561,92 @@ xfs_bmbt_dup_cursor( 
	return new;

}



STATIC int

xfs_bmbt_alloc_block(

	struct xfs_btree_cur	*cur,

	union xfs_btree_ptr	*start,

	union xfs_btree_ptr	*new,

	int			length,

	int			*stat)

{

	xfs_alloc_arg_t		args;		/* block allocation args */

	int			error;		/* error return value */



	memset(&args, 0, sizeof(args));

	args.tp = cur->bc_tp;

	args.mp = cur->bc_mp;

	args.fsbno = cur->bc_private.b.firstblock;

	args.firstblock = args.fsbno;



	if (args.fsbno == NULLFSBLOCK) {

		args.fsbno = be64_to_cpu(start->l);

		args.type = XFS_ALLOCTYPE_START_BNO;

		/*

		 * Make sure there is sufficient room left in the AG to

		 * complete a full tree split for an extent insert.  If

		 * we are converting the middle part of an extent then

		 * we may need space for two tree splits.

		 *

		 * We are relying on the caller to make the correct block

		 * reservation for this operation to succeed.  If the

		 * reservation amount is insufficient then we may fail a

		 * block allocation here and corrupt the filesystem.

		 */

		args.minleft = xfs_trans_get_block_res(args.tp);

	} else if (cur->bc_private.b.flist->xbf_low) {

		args.type = XFS_ALLOCTYPE_START_BNO;

	} else {

		args.type = XFS_ALLOCTYPE_NEAR_BNO;

	}



	args.minlen = args.maxlen = args.prod = 1;

	args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;

	if (!args.wasdel && xfs_trans_get_block_res(args.tp) == 0) {

		error = XFS_ERROR(ENOSPC);

		goto error0;

	}

	error = xfs_alloc_vextent(&args);

	if (error)

		goto error0;



	if (args.fsbno == NULLFSBLOCK && args.minleft) {

		/*

		 * Could not find an AG with enough free space to satisfy

		 * a full btree split.  Try again without minleft and if

		 * successful activate the lowspace algorithm.

		 */

		args.fsbno = 0;

		args.type = XFS_ALLOCTYPE_FIRST_AG;

		args.minleft = 0;

		error = xfs_alloc_vextent(&args);

		if (error)

			goto error0;

		cur->bc_private.b.flist->xbf_low = 1;

	}

	if (args.fsbno == NULLFSBLOCK) {

		XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);

		*stat = 0;

		return 0;

	}

	ASSERT(args.len == 1);

	cur->bc_private.b.firstblock = args.fsbno;

	cur->bc_private.b.allocated++;

	cur->bc_private.b.ip->i_d.di_nblocks++;

	xfs_trans_log_inode(args.tp, cur->bc_private.b.ip, XFS_ILOG_CORE);

	XFS_TRANS_MOD_DQUOT_BYINO(args.mp, args.tp, cur->bc_private.b.ip,

			XFS_TRANS_DQ_BCOUNT, 1L);



	new->l = cpu_to_be64(args.fsbno);



	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);

	*stat = 1;

	return 0;



 error0:

	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);

	return error;

}



STATIC int

xfs_bmbt_get_maxrecs(

	struct xfs_btree_cur	*cur,
@@ -1861,6 +1771,7 @@ static const struct xfs_btree_ops xfs_bmbt_ops = { 
	.key_len		= sizeof(xfs_bmbt_key_t),



	.dup_cursor		= xfs_bmbt_dup_cursor,

	.alloc_block		= xfs_bmbt_alloc_block,

	.get_maxrecs		= xfs_bmbt_get_maxrecs,

	.init_key_from_rec	= xfs_bmbt_init_key_from_rec,

	.init_ptr_from_cur	= xfs_bmbt_init_ptr_from_cur,

fs/xfs/xfs_btree.c

+268 −0

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/xfs_btree.h

+8 −0
Original line number Diff line number Diff line
@@ -187,6 +187,12 @@ struct xfs_btree_ops { 
	/* cursor operations */

	struct xfs_btree_cur *(*dup_cursor)(struct xfs_btree_cur *);



	/* block allocation / freeing */

	int	(*alloc_block)(struct xfs_btree_cur *cur,

			       union xfs_btree_ptr *start_bno,

			       union xfs_btree_ptr *new_bno,

			       int length, int *stat);



	/* update last record information */

	void	(*update_lastrec)(struct xfs_btree_cur *cur,

				  struct xfs_btree_block *block,
@@ -535,6 +541,8 @@ int xfs_btree_updkey(struct xfs_btree_cur *, union xfs_btree_key *, int); 
int xfs_btree_update(struct xfs_btree_cur *, union xfs_btree_rec *);

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

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

int xfs_btree_split(struct xfs_btree_cur *, int, union xfs_btree_ptr *,

		union xfs_btree_key *, struct xfs_btree_cur **, int *);



/*

 * Helpers.

fs/xfs/xfs_ialloc_btree.c

+49 −163

File changed.

Preview size limit exceeded, changes collapsed.

CRA Git | Maintained and supported by SUSTech CRA and CCSE