Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit 687b890a184fef263ebb773926e1f4aa69240d01

Authored by Christoph Hellwig 2008-10-30 13:56:53 +0800

Committed by Lachlan McIlroy 2008-10-30 13:56:53 +0800

[XFS] implement generic xfs_btree_lshift

Make the btree left shift 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:32197a

Signed-off-by: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Lachlan McIlroy <lachlan@sgi.com>
Signed-off-by: Bill O'Donnell <billodo@sgi.com>
Signed-off-by: David Chinner <david@fromorbit.com>

Showing 5 changed files with 192 additions and 425 deletions Inline Diff

fs/xfs/xfs_alloc_btree.c
fs/xfs/xfs_bmap_btree.c
fs/xfs/xfs_btree.c
fs/xfs/xfs_btree.h
fs/xfs/xfs_ialloc_btree.c

fs/xfs/xfs_alloc_btree.c

Diff comments View file @ 687b890

 /*
  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
 #include "xfs_bit.h"
 #include "xfs_log.h"
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
 #include "xfs_error.h"
 /*
  * Prototypes for internal functions.
  */
 STATIC void xfs_alloc_log_block(xfs_trans_t *, xfs_buf_t *, int);
 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_lshift(xfs_btree_cur_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.
  */
 /*
  * Single level of the xfs_alloc_delete record deletion routine.
  * Delete record pointed to by cur/level.
  * Remove the record from its block then rebalance the tree.
  * Return 0 for error, 1 for done, 2 to go on to the next level.
  */
 STATIC int				/* error */
 xfs_alloc_delrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level,	/* level removing record from */
 	int			*stat)	/* fail/done/go-on */
 {
 	xfs_agf_t		*agf;	/* allocation group freelist header */
 	xfs_alloc_block_t	*block;	/* btree block record/key lives in */
 	xfs_agblock_t		bno;	/* btree block number */
 	xfs_buf_t		*bp;	/* buffer for block */
 	int			error;	/* error return value */
 	int			i;	/* loop index */
 	xfs_alloc_key_t		key;	/* kp points here if block is level 0 */
 	xfs_agblock_t		lbno;	/* left block's block number */
 	xfs_buf_t		*lbp;	/* left block's buffer pointer */
 	xfs_alloc_block_t	*left;	/* left btree block */
 	xfs_alloc_key_t		*lkp=NULL;	/* left block key pointer */
 	xfs_alloc_ptr_t		*lpp=NULL;	/* left block address pointer */
 	int			lrecs=0;	/* number of records in left block */
 	xfs_alloc_rec_t		*lrp;	/* left block record pointer */
 	xfs_mount_t		*mp;	/* mount structure */
 	int			ptr;	/* index in btree block for this rec */
 	xfs_agblock_t		rbno;	/* right block's block number */
 	xfs_buf_t		*rbp;	/* right block's buffer pointer */
 	xfs_alloc_block_t	*right;	/* right btree block */
 	xfs_alloc_key_t		*rkp;	/* right block key pointer */
 	xfs_alloc_ptr_t		*rpp;	/* right block address pointer */
 	int			rrecs=0;	/* number of records in right block */
 	int			numrecs;
 	xfs_alloc_rec_t		*rrp;	/* right block record pointer */
 	xfs_btree_cur_t		*tcur;	/* temporary btree cursor */
 	/*
 	 * Get the index of the entry being deleted, check for nothing there.
 	 */
 	ptr = cur->bc_ptrs[level];
 	if (ptr == 0) {
 		*stat = 0;
 		return 0;
 	}
 	/*
 	 * Get the buffer & block containing the record or key/ptr.
 	 */
 	bp = cur->bc_bufs[level];
 	block = XFS_BUF_TO_ALLOC_BLOCK(bp);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, level, bp)))
 		return error;
 #endif
 	/*
 	 * Fail if we're off the end of the block.
 	 */
 	numrecs = be16_to_cpu(block->bb_numrecs);
 	if (ptr > numrecs) {
 		*stat = 0;
 		return 0;
 	}
 	XFS_STATS_INC(xs_abt_delrec);
 	/*
 	 * It's a nonleaf.  Excise the key and ptr being deleted, by
 	 * sliding the entries past them down one.
 	 * Log the changed areas of the block.
 	 */
 	if (level > 0) {
 		lkp = XFS_ALLOC_KEY_ADDR(block, 1, cur);
 		lpp = XFS_ALLOC_PTR_ADDR(block, 1, cur);
 #ifdef DEBUG
 		for (i = ptr; i < numrecs; i++) {
 			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(lpp[i]), level)))
 				return error;
 		}
 #endif
 		if (ptr < numrecs) {
 			memmove(&lkp[ptr - 1], &lkp[ptr],
 				(numrecs - ptr) * sizeof(*lkp));
 			memmove(&lpp[ptr - 1], &lpp[ptr],
 				(numrecs - ptr) * sizeof(*lpp));
 			xfs_alloc_log_ptrs(cur, bp, ptr, numrecs - 1);
 			xfs_alloc_log_keys(cur, bp, ptr, numrecs - 1);
 		}
 	}
 	/*
 	 * It's a leaf.  Excise the record being deleted, by sliding the
 	 * entries past it down one.  Log the changed areas of the block.
 	 */
 	else {
 		lrp = XFS_ALLOC_REC_ADDR(block, 1, cur);
 		if (ptr < numrecs) {
 			memmove(&lrp[ptr - 1], &lrp[ptr],
 				(numrecs - ptr) * sizeof(*lrp));
 			xfs_alloc_log_recs(cur, bp, ptr, numrecs - 1);
 		}
 		/*
 		 * If it's the first record in the block, we'll need a key
 		 * structure to pass up to the next level (updkey).
 		 */
 		if (ptr == 1) {
 			key.ar_startblock = lrp->ar_startblock;
 			key.ar_blockcount = lrp->ar_blockcount;
 			lkp = &key;
 		}
 	}
 	/*
 	 * Decrement and log the number of entries in the block.
 	 */
 	numrecs--;
 	block->bb_numrecs = cpu_to_be16(numrecs);
 	xfs_alloc_log_block(cur->bc_tp, bp, XFS_BB_NUMRECS);
 	/*
 	 * See if the longest free extent in the allocation group was
 	 * changed by this operation.  True if it's the by-size btree, and
 	 * this is the leaf level, and there is no right sibling block,
 	 * and this was the last record.
 	 */
 	agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
 	mp = cur->bc_mp;
 	if (level == 0 &&
 	    cur->bc_btnum == XFS_BTNUM_CNT &&
 	    be32_to_cpu(block->bb_rightsib) == NULLAGBLOCK &&
 	    ptr > numrecs) {
 		ASSERT(ptr == numrecs + 1);
 		/*
 		 * There are still records in the block.  Grab the size
 		 * from the last one.
 		 */
 		if (numrecs) {
 			rrp = XFS_ALLOC_REC_ADDR(block, numrecs, cur);
 			agf->agf_longest = rrp->ar_blockcount;
 		}
 		/*
 		 * No free extents left.
 		 */
 		else
 			agf->agf_longest = 0;
 		mp->m_perag[be32_to_cpu(agf->agf_seqno)].pagf_longest =
 			be32_to_cpu(agf->agf_longest);
 		xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp,
 			XFS_AGF_LONGEST);
 	}
 	/*
 	 * Is this the root level?  If so, we're almost done.
 	 */
 	if (level == cur->bc_nlevels - 1) {
 		/*
 		 * If this is the root level,
 		 * and there's only one entry left,
 		 * and it's NOT the leaf level,
 		 * then we can get rid of this level.
 		 */
 		if (numrecs == 1 && level > 0) {
 			/*
 			 * lpp is still set to the first pointer in the block.
 			 * Make it the new root of the btree.
 			 */
 			bno = be32_to_cpu(agf->agf_roots[cur->bc_btnum]);
 			agf->agf_roots[cur->bc_btnum] = *lpp;
 			be32_add_cpu(&agf->agf_levels[cur->bc_btnum], -1);
 			mp->m_perag[be32_to_cpu(agf->agf_seqno)].pagf_levels[cur->bc_btnum]--;
 			/*
 			 * Put this buffer/block on the ag's freelist.
 			 */
 			error = xfs_alloc_put_freelist(cur->bc_tp,
 					cur->bc_private.a.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);
 			xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp,
 				XFS_AGF_ROOTS | XFS_AGF_LEVELS);
 			/*
 			 * Update the cursor so there's one fewer level.
 			 */
 			xfs_btree_setbuf(cur, level, NULL);
 			cur->bc_nlevels--;
 		} else if (level > 0 &&
 			   (error = xfs_btree_decrement(cur, level, &i)))
 			return error;
 		*stat = 1;
 		return 0;
 	}
 	/*
 	 * If we deleted the leftmost entry in the block, update the
 	 * key values above us in the tree.
 	 */
 	if (ptr == 1 && (error = xfs_btree_updkey(cur, (union xfs_btree_key *)lkp, level + 1)))
 		return error;
 	/*
 	 * If the number of records remaining in the block is at least
 	 * the minimum, we're done.
 	 */
 	if (numrecs >= XFS_ALLOC_BLOCK_MINRECS(level, cur)) {
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &i)))
 			return error;
 		*stat = 1;
 		return 0;
 	}
 	/*
 	 * Otherwise, we have to move some records around to keep the
 	 * tree balanced.  Look at the left and right sibling blocks to
 	 * see if we can re-balance by moving only one record.
 	 */
 	rbno = be32_to_cpu(block->bb_rightsib);
 	lbno = be32_to_cpu(block->bb_leftsib);
 	bno = NULLAGBLOCK;
 	ASSERT(rbno != NULLAGBLOCK || lbno != NULLAGBLOCK);
 	/*
 	 * Duplicate the cursor so our btree manipulations here won't
 	 * disrupt the next level up.
 	 */
 	if ((error = xfs_btree_dup_cursor(cur, &tcur)))
 		return error;
 	/*
 	 * If there's a right sibling, see if it's ok to shift an entry
 	 * out of it.
 	 */
 	if (rbno != NULLAGBLOCK) {
 		/*
 		 * Move the temp cursor to the last entry in the next block.
 		 * Actually any entry but the first would suffice.
 		 */
 		i = xfs_btree_lastrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		if ((error = xfs_btree_increment(tcur, level, &i)))
 			goto error0;
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		i = xfs_btree_lastrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		/*
 		 * Grab a pointer to the block.
 		 */
 		rbp = tcur->bc_bufs[level];
 		right = XFS_BUF_TO_ALLOC_BLOCK(rbp);
 #ifdef DEBUG
 		if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
 			goto error0;
 #endif
 		/*
 		 * Grab the current block number, for future use.
 		 */
 		bno = be32_to_cpu(right->bb_leftsib);
 		/*
 		 * If right block is full enough so that removing one entry
 		 * won't make it too empty, and left-shifting an entry out
 		 * of right to us works, we're done.
 		 */
 		if (be16_to_cpu(right->bb_numrecs) - 1 >=
 		     XFS_ALLOC_BLOCK_MINRECS(level, cur)) {
-			if ((error = xfs_alloc_lshift(tcur, level, &i)))
+			if ((error = xfs_btree_lshift(tcur, level, &i)))
 				goto error0;
 			if (i) {
 				ASSERT(be16_to_cpu(block->bb_numrecs) >=
 				       XFS_ALLOC_BLOCK_MINRECS(level, cur));
 				xfs_btree_del_cursor(tcur,
 						     XFS_BTREE_NOERROR);
 				if (level > 0 &&
 				    (error = xfs_btree_decrement(cur, level,
 					    &i)))
 					return error;
 				*stat = 1;
 				return 0;
 			}
 		}
 		/*
 		 * Otherwise, grab the number of records in right for
 		 * future reference, and fix up the temp cursor to point
 		 * to our block again (last record).
 		 */
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		if (lbno != NULLAGBLOCK) {
 			i = xfs_btree_firstrec(tcur, level);
 			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 			if ((error = xfs_btree_decrement(tcur, level, &i)))
 				goto error0;
 			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		}
 	}
 	/*
 	 * If there's a left sibling, see if it's ok to shift an entry
 	 * out of it.
 	 */
 	if (lbno != NULLAGBLOCK) {
 		/*
 		 * Move the temp cursor to the first entry in the
 		 * previous block.
 		 */
 		i = xfs_btree_firstrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		if ((error = xfs_btree_decrement(tcur, level, &i)))
 			goto error0;
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		xfs_btree_firstrec(tcur, level);
 		/*
 		 * Grab a pointer to the block.
 		 */
 		lbp = tcur->bc_bufs[level];
 		left = XFS_BUF_TO_ALLOC_BLOCK(lbp);
 #ifdef DEBUG
 		if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
 			goto error0;
 #endif
 		/*
 		 * Grab the current block number, for future use.
 		 */
 		bno = be32_to_cpu(left->bb_rightsib);
 		/*
 		 * If left block is full enough so that removing one entry
 		 * won't make it too empty, and right-shifting an entry out
 		 * of left to us works, we're done.
 		 */
 		if (be16_to_cpu(left->bb_numrecs) - 1 >=
 		     XFS_ALLOC_BLOCK_MINRECS(level, cur)) {
 			if ((error = xfs_btree_rshift(tcur, level, &i)))
 				goto error0;
 			if (i) {
 				ASSERT(be16_to_cpu(block->bb_numrecs) >=
 				       XFS_ALLOC_BLOCK_MINRECS(level, cur));
 				xfs_btree_del_cursor(tcur,
 						     XFS_BTREE_NOERROR);
 				if (level == 0)
 					cur->bc_ptrs[0]++;
 				*stat = 1;
 				return 0;
 			}
 		}
 		/*
 		 * Otherwise, grab the number of records in right for
 		 * future reference.
 		 */
 		lrecs = be16_to_cpu(left->bb_numrecs);
 	}
 	/*
 	 * Delete the temp cursor, we're done with it.
 	 */
 	xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
 	/*
 	 * If here, we need to do a join to keep the tree balanced.
 	 */
 	ASSERT(bno != NULLAGBLOCK);
 	/*
 	 * See if we can join with the left neighbor block.
 	 */
 	if (lbno != NULLAGBLOCK &&
 	    lrecs + numrecs <= XFS_ALLOC_BLOCK_MAXRECS(level, cur)) {
 		/*
 		 * Set "right" to be the starting block,
 		 * "left" to be the left neighbor.
 		 */
 		rbno = bno;
 		right = block;
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		rbp = bp;
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, lbno, 0, &lbp,
 				XFS_ALLOC_BTREE_REF)))
 			return error;
 		left = XFS_BUF_TO_ALLOC_BLOCK(lbp);
 		lrecs = be16_to_cpu(left->bb_numrecs);
 		if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
 			return error;
 	}
 	/*
 	 * If that won't work, see if we can join with the right neighbor block.
 	 */
 	else if (rbno != NULLAGBLOCK &&
 		 rrecs + numrecs <= XFS_ALLOC_BLOCK_MAXRECS(level, cur)) {
 		/*
 		 * Set "left" to be the starting block,
 		 * "right" to be the right neighbor.
 		 */
 		lbno = bno;
 		left = block;
 		lrecs = be16_to_cpu(left->bb_numrecs);
 		lbp = bp;
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, rbno, 0, &rbp,
 				XFS_ALLOC_BTREE_REF)))
 			return error;
 		right = XFS_BUF_TO_ALLOC_BLOCK(rbp);
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
 			return error;
 	}
 	/*
 	 * Otherwise, we can't fix the imbalance.
 	 * Just return.  This is probably a logic error, but it's not fatal.
 	 */
 	else {
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &i)))
 			return error;
 		*stat = 1;
 		return 0;
 	}
 	/*
 	 * We're now going to join "left" and "right" by moving all the stuff
 	 * in "right" to "left" and deleting "right".
 	 */
 	if (level > 0) {
 		/*
 		 * It's a non-leaf.  Move keys and pointers.
 		 */
 		lkp = XFS_ALLOC_KEY_ADDR(left, lrecs + 1, cur);
 		lpp = XFS_ALLOC_PTR_ADDR(left, lrecs + 1, cur);
 		rkp = XFS_ALLOC_KEY_ADDR(right, 1, cur);
 		rpp = XFS_ALLOC_PTR_ADDR(right, 1, cur);
 #ifdef DEBUG
 		for (i = 0; i < rrecs; i++) {
 			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(rpp[i]), level)))
 				return error;
 		}
 #endif
 		memcpy(lkp, rkp, rrecs * sizeof(*lkp));
 		memcpy(lpp, rpp, rrecs * sizeof(*lpp));
 		xfs_alloc_log_keys(cur, lbp, lrecs + 1, lrecs + rrecs);
 		xfs_alloc_log_ptrs(cur, lbp, lrecs + 1, lrecs + rrecs);
 	} else {
 		/*
 		 * It's a leaf.  Move records.
 		 */
 		lrp = XFS_ALLOC_REC_ADDR(left, lrecs + 1, cur);
 		rrp = XFS_ALLOC_REC_ADDR(right, 1, cur);
 		memcpy(lrp, rrp, rrecs * sizeof(*lrp));
 		xfs_alloc_log_recs(cur, lbp, lrecs + 1, lrecs + rrecs);
 	}
 	/*
 	 * If we joined with the left neighbor, set the buffer in the
 	 * cursor to the left block, and fix up the index.
 	 */
 	if (bp != lbp) {
 		xfs_btree_setbuf(cur, level, lbp);
 		cur->bc_ptrs[level] += lrecs;
 	}
 	/*
 	 * If we joined with the right neighbor and there's a level above
 	 * us, increment the cursor at that level.
 	 */
 	else if (level + 1 < cur->bc_nlevels &&
 		 (error = xfs_btree_increment(cur, level + 1, &i)))
 		return error;
 	/*
 	 * Fix up the number of records in the surviving block.
 	 */
 	lrecs += rrecs;
 	left->bb_numrecs = cpu_to_be16(lrecs);
 	/*
 	 * Fix up the right block pointer in the surviving block, and log it.
 	 */
 	left->bb_rightsib = right->bb_rightsib;
 	xfs_alloc_log_block(cur->bc_tp, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
 	/*
 	 * If there is a right sibling now, make it point to the
 	 * remaining block.
 	 */
 	if (be32_to_cpu(left->bb_rightsib) != NULLAGBLOCK) {
 		xfs_alloc_block_t	*rrblock;
 		xfs_buf_t		*rrbp;
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, be32_to_cpu(left->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(lbno);
 		xfs_alloc_log_block(cur->bc_tp, rrbp, XFS_BB_LEFTSIB);
 	}
 	/*
 	 * Free the deleting block by putting it on the freelist.
 	 */
 	error = xfs_alloc_put_freelist(cur->bc_tp,
 					 cur->bc_private.a.agbp, NULL, rbno, 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);
 	/*
 	 * Adjust the current level's cursor so that we're left referring
 	 * to the right node, after we're done.
 	 * If this leaves the ptr value 0 our caller will fix it up.
 	 */
 	if (level > 0)
 		cur->bc_ptrs[level]--;
 	/*
 	 * Return value means the next level up has something to do.
 	 */
 	*stat = 2;
 	return 0;
 error0:
 	xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
 	return error;
 }
 /*
  * Insert one record/level.  Return information to the caller
  * allowing the next level up to proceed if necessary.
  */
 STATIC int				/* error */
 xfs_alloc_insrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level,	/* level to insert record at */
 	xfs_agblock_t		*bnop,	/* i/o: block number inserted */
 	xfs_alloc_rec_t		*recp,	/* i/o: record data inserted */
 	xfs_btree_cur_t		**curp,	/* output: new cursor replacing cur */
 	int			*stat)	/* output: success/failure */
 {
 	xfs_agf_t		*agf;	/* allocation group freelist header */
 	xfs_alloc_block_t	*block;	/* btree block record/key lives in */
 	xfs_buf_t		*bp;	/* buffer for block */
 	int			error;	/* error return value */
 	int			i;	/* loop index */
 	xfs_alloc_key_t		key;	/* key value being inserted */
 	xfs_alloc_key_t		*kp;	/* pointer to btree keys */
 	xfs_agblock_t		nbno;	/* block number of allocated block */
 	xfs_btree_cur_t		*ncur;	/* new cursor to be used at next lvl */
 	xfs_alloc_key_t		nkey;	/* new key value, from split */
 	xfs_alloc_rec_t		nrec;	/* new record value, for caller */
 	int			numrecs;
 	int			optr;	/* old ptr value */
 	xfs_alloc_ptr_t		*pp;	/* pointer to btree addresses */
 	int			ptr;	/* index in btree block for this rec */
 	xfs_alloc_rec_t		*rp;	/* pointer to btree records */
 	ASSERT(be32_to_cpu(recp->ar_blockcount) > 0);
 	/*
 	 * GCC doesn't understand the (arguably complex) control flow in
 	 * this function and complains about uninitialized structure fields
 	 * without this.
 	 */
 	memset(&nrec, 0, sizeof(nrec));
 	/*
 	 * If we made it to the root level, allocate a new root block
 	 * and we're done.
 	 */
 	if (level >= cur->bc_nlevels) {
 		XFS_STATS_INC(xs_abt_insrec);
 		if ((error = xfs_alloc_newroot(cur, &i)))
 			return error;
 		*bnop = NULLAGBLOCK;
 		*stat = i;
 		return 0;
 	}
 	/*
 	 * Make a key out of the record data to be inserted, and save it.
 	 */
 	key.ar_startblock = recp->ar_startblock;
 	key.ar_blockcount = recp->ar_blockcount;
 	optr = ptr = cur->bc_ptrs[level];
 	/*
 	 * If we're off the left edge, return failure.
 	 */
 	if (ptr == 0) {
 		*stat = 0;
 		return 0;
 	}
 	XFS_STATS_INC(xs_abt_insrec);
 	/*
 	 * Get pointers to the btree buffer and block.
 	 */
 	bp = cur->bc_bufs[level];
 	block = XFS_BUF_TO_ALLOC_BLOCK(bp);
 	numrecs = be16_to_cpu(block->bb_numrecs);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, level, bp)))
 		return error;
 	/*
 	 * Check that the new entry is being inserted in the right place.
 	 */
 	if (ptr <= numrecs) {
 		if (level == 0) {
 			rp = XFS_ALLOC_REC_ADDR(block, ptr, cur);
 			xfs_btree_check_rec(cur->bc_btnum, recp, rp);
 		} else {
 			kp = XFS_ALLOC_KEY_ADDR(block, ptr, cur);
 			xfs_btree_check_key(cur->bc_btnum, &key, kp);
 		}
 	}
 #endif
 	nbno = NULLAGBLOCK;
 	ncur = NULL;
 	/*
 	 * If the block is full, we can't insert the new entry until we
 	 * make the block un-full.
 	 */
 	if (numrecs == XFS_ALLOC_BLOCK_MAXRECS(level, cur)) {
 		/*
 		 * First, try shifting an entry to the right neighbor.
 		 */
 		if ((error = xfs_btree_rshift(cur, level, &i)))
 			return error;
 		if (i) {
 			/* nothing */
 		}
 		/*
 		 * Next, try shifting an entry to the left neighbor.
 		 */
 		else {
-			if ((error = xfs_alloc_lshift(cur, level, &i)))
+			if ((error = xfs_btree_lshift(cur, level, &i)))
 				return error;
 			if (i)
 				optr = ptr = cur->bc_ptrs[level];
 			else {
 				/*
 				 * 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)))
 					return error;
 				if (i) {
 					bp = cur->bc_bufs[level];
 					block = XFS_BUF_TO_ALLOC_BLOCK(bp);
 #ifdef DEBUG
 					if ((error =
 						xfs_btree_check_sblock(cur,
 							block, level, bp)))
 						return error;
 #endif
 					ptr = cur->bc_ptrs[level];
 					nrec.ar_startblock = nkey.ar_startblock;
 					nrec.ar_blockcount = nkey.ar_blockcount;
 				}
 				/*
 				 * Otherwise the insert fails.
 				 */
 				else {
 					*stat = 0;
 					return 0;
 				}
 			}
 		}
 	}
 	/*
 	 * At this point we know there's room for our new entry in the block
 	 * we're pointing at.
 	 */
 	numrecs = be16_to_cpu(block->bb_numrecs);
 	if (level > 0) {
 		/*
 		 * It's a non-leaf entry.  Make a hole for the new data
 		 * in the key and ptr regions of the block.
 		 */
 		kp = XFS_ALLOC_KEY_ADDR(block, 1, cur);
 		pp = XFS_ALLOC_PTR_ADDR(block, 1, cur);
 #ifdef DEBUG
 		for (i = numrecs; i >= ptr; i--) {
 			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(pp[i - 1]), level)))
 				return error;
 		}
 #endif
 		memmove(&kp[ptr], &kp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*kp));
 		memmove(&pp[ptr], &pp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*pp));
 #ifdef DEBUG
 		if ((error = xfs_btree_check_sptr(cur, *bnop, level)))
 			return error;
 #endif
 		/*
 		 * Now stuff the new data in, bump numrecs and log the new data.
 		 */
 		kp[ptr - 1] = key;
 		pp[ptr - 1] = cpu_to_be32(*bnop);
 		numrecs++;
 		block->bb_numrecs = cpu_to_be16(numrecs);
 		xfs_alloc_log_keys(cur, bp, ptr, numrecs);
 		xfs_alloc_log_ptrs(cur, bp, ptr, numrecs);
 #ifdef DEBUG
 		if (ptr < numrecs)
 			xfs_btree_check_key(cur->bc_btnum, kp + ptr - 1,
 				kp + ptr);
 #endif
 	} else {
 		/*
 		 * It's a leaf entry.  Make a hole for the new record.
 		 */
 		rp = XFS_ALLOC_REC_ADDR(block, 1, cur);
 		memmove(&rp[ptr], &rp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*rp));
 		/*
 		 * Now stuff the new record in, bump numrecs
 		 * and log the new data.
 		 */
 		rp[ptr - 1] = *recp;
 		numrecs++;
 		block->bb_numrecs = cpu_to_be16(numrecs);
 		xfs_alloc_log_recs(cur, bp, ptr, numrecs);
 #ifdef DEBUG
 		if (ptr < numrecs)
 			xfs_btree_check_rec(cur->bc_btnum, rp + ptr - 1,
 				rp + ptr);
 #endif
 	}
 	/*
 	 * Log the new number of records in the btree header.
 	 */
 	xfs_alloc_log_block(cur->bc_tp, bp, XFS_BB_NUMRECS);
 	/*
 	 * If we inserted at the start of a block, update the parents' keys.
 	 */
 	if (optr == 1 && (error = xfs_btree_updkey(cur, (union xfs_btree_key *)&key, level + 1)))
 		return error;
 	/*
 	 * Look to see if the longest extent in the allocation group
 	 * needs to be updated.
 	 */
 	agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
 	if (level == 0 &&
 	    cur->bc_btnum == XFS_BTNUM_CNT &&
 	    be32_to_cpu(block->bb_rightsib) == NULLAGBLOCK &&
 	    be32_to_cpu(recp->ar_blockcount) > be32_to_cpu(agf->agf_longest)) {
 		/*
 		 * If this is a leaf in the by-size btree and there
 		 * is no right sibling block and this block is bigger
 		 * than the previous longest block, update it.
 		 */
 		agf->agf_longest = recp->ar_blockcount;
 		cur->bc_mp->m_perag[be32_to_cpu(agf->agf_seqno)].pagf_longest
 			= be32_to_cpu(recp->ar_blockcount);
 		xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp,
 			XFS_AGF_LONGEST);
 	}
 	/*
 	 * Return the new block number, if any.
 	 * If there is one, give back a record value and a cursor too.
 	 */
 	*bnop = nbno;
 	if (nbno != NULLAGBLOCK) {
 		*recp = nrec;
 		*curp = ncur;
 	}
 	*stat = 1;
 	return 0;
 }
 /*
  * Log header fields from a btree block.
  */
 STATIC void
 xfs_alloc_log_block(
 	xfs_trans_t		*tp,	/* transaction pointer */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			fields)	/* mask of fields: XFS_BB_... */
 {
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	static const short	offsets[] = {	/* table of offsets */
 		offsetof(xfs_alloc_block_t, bb_magic),
 		offsetof(xfs_alloc_block_t, bb_level),
 		offsetof(xfs_alloc_block_t, bb_numrecs),
 		offsetof(xfs_alloc_block_t, bb_leftsib),
 		offsetof(xfs_alloc_block_t, bb_rightsib),
 		sizeof(xfs_alloc_block_t)
 	};
 	xfs_btree_offsets(fields, offsets, XFS_BB_NUM_BITS, &first, &last);
 	xfs_trans_log_buf(tp, bp, first, last);
 }
 /*
  * Log keys from a btree block (nonleaf).
  */
 STATIC void
 xfs_alloc_log_keys(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			kfirst,	/* index of first key to log */
 	int			klast)	/* index of last key to log */
 {
 	xfs_alloc_block_t	*block;	/* btree block to log from */
 	int			first;	/* first byte offset logged */
 	xfs_alloc_key_t		*kp;	/* key pointer in btree block */
 	int			last;	/* last byte offset logged */
 	block = XFS_BUF_TO_ALLOC_BLOCK(bp);
 	kp = XFS_ALLOC_KEY_ADDR(block, 1, cur);
 	first = (int)((xfs_caddr_t)&kp[kfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&kp[klast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(cur->bc_tp, bp, first, last);
 }
 /*
  * Log block pointer fields from a btree block (nonleaf).
  */
 STATIC void
 xfs_alloc_log_ptrs(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			pfirst,	/* index of first pointer to log */
 	int			plast)	/* index of last pointer to log */
 {
 	xfs_alloc_block_t	*block;	/* btree block to log from */
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	xfs_alloc_ptr_t		*pp;	/* block-pointer pointer in btree blk */
 	block = XFS_BUF_TO_ALLOC_BLOCK(bp);
 	pp = XFS_ALLOC_PTR_ADDR(block, 1, cur);
 	first = (int)((xfs_caddr_t)&pp[pfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&pp[plast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(cur->bc_tp, bp, first, last);
 }
 /*
  * Log records from a btree block (leaf).
  */
 STATIC void
 xfs_alloc_log_recs(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			rfirst,	/* index of first record to log */
 	int			rlast)	/* index of last record to log */
 {
 	xfs_alloc_block_t	*block;	/* btree block to log from */
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	xfs_alloc_rec_t		*rp;	/* record pointer for btree block */
 	block = XFS_BUF_TO_ALLOC_BLOCK(bp);
 	rp = XFS_ALLOC_REC_ADDR(block, 1, cur);
 #ifdef DEBUG
 	{
 		xfs_agf_t	*agf;
 		xfs_alloc_rec_t	*p;
 		agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
 		for (p = &rp[rfirst - 1]; p <= &rp[rlast - 1]; p++)
 			ASSERT(be32_to_cpu(p->ar_startblock) +
 			       be32_to_cpu(p->ar_blockcount) <=
 			       be32_to_cpu(agf->agf_length));
 	}
 #endif
 	first = (int)((xfs_caddr_t)&rp[rfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&rp[rlast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(cur->bc_tp, bp, first, last);
-}
-/*
- * Move 1 record left from cur/level if possible.
- * Update cur to reflect the new path.
- */
-STATIC int				/* error */
-xfs_alloc_lshift(
-	xfs_btree_cur_t		*cur,	/* btree cursor */
-	int			level,	/* level to shift record on */
-	int			*stat)	/* success/failure */
-{
-	int			error;	/* error return value */
-#ifdef DEBUG
-	int			i;	/* loop index */
-#endif
-	xfs_alloc_key_t		key;	/* key value for leaf level upward */
-	xfs_buf_t		*lbp;	/* buffer for left neighbor block */
-	xfs_alloc_block_t	*left;	/* left neighbor btree block */
-	int			nrec;	/* new number of left block entries */
-	xfs_buf_t		*rbp;	/* buffer for right (current) block */
-	xfs_alloc_block_t	*right;	/* right (current) btree block */
-	xfs_alloc_key_t		*rkp=NULL;	/* key pointer for right block */
-	xfs_alloc_ptr_t		*rpp=NULL;	/* address pointer for right block */
-	xfs_alloc_rec_t		*rrp=NULL;	/* record pointer for right block */
-	/*
-	 * Set up variables for this block as "right".
-	 */
-	rbp = cur->bc_bufs[level];
-	right = XFS_BUF_TO_ALLOC_BLOCK(rbp);
-#ifdef DEBUG
-	if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
-		return error;
-#endif
-	/*
-	 * If we've got no left sibling then we can't shift an entry left.
-	 */
-	if (be32_to_cpu(right->bb_leftsib) == NULLAGBLOCK) {
-		*stat = 0;
-		return 0;
-	}
-	/*
-	 * If the cursor entry is the one that would be moved, don't
-	 * do it... it's too complicated.
-	 */
-	if (cur->bc_ptrs[level] <= 1) {
-		*stat = 0;
-		return 0;
-	}
-	/*
-	 * Set up the left neighbor as "left".
-	 */
-	if ((error = xfs_btree_read_bufs(cur->bc_mp, cur->bc_tp,
-			cur->bc_private.a.agno, be32_to_cpu(right->bb_leftsib),
-			0, &lbp, XFS_ALLOC_BTREE_REF)))
-		return error;
-	left = XFS_BUF_TO_ALLOC_BLOCK(lbp);
-	if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
-		return error;
-	/*
-	 * If it's full, it can't take another entry.
-	 */
-	if (be16_to_cpu(left->bb_numrecs) == XFS_ALLOC_BLOCK_MAXRECS(level, cur)) {
-		*stat = 0;
-		return 0;
-	}
-	nrec = be16_to_cpu(left->bb_numrecs) + 1;
-	/*
-	 * If non-leaf, copy a key and a ptr to the left block.
-	 */
-	if (level > 0) {
-		xfs_alloc_key_t	*lkp;	/* key pointer for left block */
-		xfs_alloc_ptr_t	*lpp;	/* address pointer for left block */
-		lkp = XFS_ALLOC_KEY_ADDR(left, nrec, cur);
-		rkp = XFS_ALLOC_KEY_ADDR(right, 1, cur);
-		*lkp = *rkp;
-		xfs_alloc_log_keys(cur, lbp, nrec, nrec);
-		lpp = XFS_ALLOC_PTR_ADDR(left, nrec, cur);
-		rpp = XFS_ALLOC_PTR_ADDR(right, 1, cur);
-#ifdef DEBUG
-		if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(*rpp), level)))
-			return error;
-#endif
-		*lpp = *rpp;
-		xfs_alloc_log_ptrs(cur, lbp, nrec, nrec);
-		xfs_btree_check_key(cur->bc_btnum, lkp - 1, lkp);
-	}
-	/*
-	 * If leaf, copy a record to the left block.
-	 */
-	else {
-		xfs_alloc_rec_t	*lrp;	/* record pointer for left block */
-		lrp = XFS_ALLOC_REC_ADDR(left, nrec, cur);
-		rrp = XFS_ALLOC_REC_ADDR(right, 1, cur);
-		*lrp = *rrp;
-		xfs_alloc_log_recs(cur, lbp, nrec, nrec);
-		xfs_btree_check_rec(cur->bc_btnum, lrp - 1, lrp);
-	}
-	/*
-	 * Bump and log left's numrecs, decrement and log right's numrecs.
-	 */
-	be16_add_cpu(&left->bb_numrecs, 1);
-	xfs_alloc_log_block(cur->bc_tp, lbp, XFS_BB_NUMRECS);
-	be16_add_cpu(&right->bb_numrecs, -1);
-	xfs_alloc_log_block(cur->bc_tp, rbp, XFS_BB_NUMRECS);
-	/*
-	 * Slide the contents of right down one entry.
-	 */
-	if (level > 0) {
-#ifdef DEBUG
-		for (i = 0; i < be16_to_cpu(right->bb_numrecs); i++) {
-			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(rpp[i + 1]),
-					level)))
-				return error;
-		}
-#endif
-		memmove(rkp, rkp + 1, be16_to_cpu(right->bb_numrecs) * sizeof(*rkp));
-		memmove(rpp, rpp + 1, 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));
-	} else {
-		memmove(rrp, rrp + 1, be16_to_cpu(right->bb_numrecs) * sizeof(*rrp));
-		xfs_alloc_log_recs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
-		key.ar_startblock = rrp->ar_startblock;
-		key.ar_blockcount = rrp->ar_blockcount;
-		rkp = &key;
-	}
-	/*
-	 * Update the parent key values of right.
-	 */
-	if ((error = xfs_btree_updkey(cur, (union xfs_btree_key *)rkp, level + 1)))
-		return error;
-	/*
-	 * Slide the cursor value left one.
-	 */
-	cur->bc_ptrs[level]--;
-	*stat = 1;
-	return 0;
 }
 /*
  * Allocate a new root block, fill it in.
  */
 STATIC int				/* error */
 xfs_alloc_newroot(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			*stat)	/* success/failure */
 {
 	int			error;	/* error return value */
 	xfs_agblock_t		lbno;	/* left block number */
 	xfs_buf_t		*lbp;	/* left btree buffer */
 	xfs_alloc_block_t	*left;	/* left btree block */
 	xfs_mount_t		*mp;	/* mount structure */
 	xfs_agblock_t		nbno;	/* new block number */
 	xfs_buf_t		*nbp;	/* new (root) buffer */
 	xfs_alloc_block_t	*new;	/* new (root) btree block */
 	int			nptr;	/* new value for key index, 1 or 2 */
 	xfs_agblock_t		rbno;	/* right block number */
 	xfs_buf_t		*rbp;	/* right btree buffer */
 	xfs_alloc_block_t	*right;	/* right btree block */
 	mp = cur->bc_mp;
 	ASSERT(cur->bc_nlevels < XFS_AG_MAXLEVELS(mp));
 	/*
 	 * Get a buffer from the freelist blocks, for the new root.
 	 */
 	error = xfs_alloc_get_freelist(cur->bc_tp,
 					cur->bc_private.a.agbp, &nbno, 1);
 	if (error)
 		return error;
 	/*
 	 * None available, we fail.
 	 */
 	if (nbno == NULLAGBLOCK) {
 		*stat = 0;
 		return 0;
 	}
 	xfs_trans_agbtree_delta(cur->bc_tp, 1);
 	nbp = xfs_btree_get_bufs(mp, cur->bc_tp, cur->bc_private.a.agno, nbno,
 		0);
 	new = XFS_BUF_TO_ALLOC_BLOCK(nbp);
 	/*
 	 * Set the root data in the a.g. freespace structure.
 	 */
 	{
 		xfs_agf_t	*agf;	/* a.g. freespace header */
 		xfs_agnumber_t	seqno;
 		agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
 		agf->agf_roots[cur->bc_btnum] = cpu_to_be32(nbno);
 		be32_add_cpu(&agf->agf_levels[cur->bc_btnum], 1);
 		seqno = be32_to_cpu(agf->agf_seqno);
 		mp->m_perag[seqno].pagf_levels[cur->bc_btnum]++;
 		xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp,
 			XFS_AGF_ROOTS | XFS_AGF_LEVELS);
 	}
 	/*
 	 * At the previous root level there are now two blocks: the old
 	 * root, and the new block generated when it was split.
 	 * We don't know which one the cursor is pointing at, so we
 	 * set up variables "left" and "right" for each case.
 	 */
 	lbp = cur->bc_bufs[cur->bc_nlevels - 1];
 	left = XFS_BUF_TO_ALLOC_BLOCK(lbp);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, left, cur->bc_nlevels - 1, lbp)))
 		return error;
 #endif
 	if (be32_to_cpu(left->bb_rightsib) != NULLAGBLOCK) {
 		/*
 		 * Our block is left, pick up the right block.
 		 */
 		lbno = XFS_DADDR_TO_AGBNO(mp, XFS_BUF_ADDR(lbp));
 		rbno = be32_to_cpu(left->bb_rightsib);
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, rbno, 0, &rbp,
 				XFS_ALLOC_BTREE_REF)))
 			return error;
 		right = XFS_BUF_TO_ALLOC_BLOCK(rbp);
 		if ((error = xfs_btree_check_sblock(cur, right,
 				cur->bc_nlevels - 1, rbp)))
 			return error;
 		nptr = 1;
 	} else {
 		/*
 		 * Our block is right, pick up the left block.
 		 */
 		rbp = lbp;
 		right = left;
 		rbno = XFS_DADDR_TO_AGBNO(mp, XFS_BUF_ADDR(rbp));
 		lbno = be32_to_cpu(right->bb_leftsib);
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, lbno, 0, &lbp,
 				XFS_ALLOC_BTREE_REF)))
 			return error;
 		left = XFS_BUF_TO_ALLOC_BLOCK(lbp);
 		if ((error = xfs_btree_check_sblock(cur, left,
 				cur->bc_nlevels - 1, lbp)))
 			return error;
 		nptr = 2;
 	}
 	/*
 	 * Fill in the new block's btree header and log it.
 	 */
 	new->bb_magic = cpu_to_be32(xfs_magics[cur->bc_btnum]);
 	new->bb_level = cpu_to_be16(cur->bc_nlevels);
 	new->bb_numrecs = cpu_to_be16(2);
 	new->bb_leftsib = cpu_to_be32(NULLAGBLOCK);
 	new->bb_rightsib = cpu_to_be32(NULLAGBLOCK);
 	xfs_alloc_log_block(cur->bc_tp, nbp, XFS_BB_ALL_BITS);
 	ASSERT(lbno != NULLAGBLOCK && rbno != NULLAGBLOCK);
 	/*
 	 * Fill in the key data in the new root.
 	 */
 	{
 		xfs_alloc_key_t		*kp;	/* btree key pointer */
 		kp = XFS_ALLOC_KEY_ADDR(new, 1, cur);
 		if (be16_to_cpu(left->bb_level) > 0) {
 			kp[0] = *XFS_ALLOC_KEY_ADDR(left, 1, cur);
 			kp[1] = *XFS_ALLOC_KEY_ADDR(right, 1, cur);
 		} else {
 			xfs_alloc_rec_t	*rp;	/* btree record pointer */
 			rp = XFS_ALLOC_REC_ADDR(left, 1, cur);
 			kp[0].ar_startblock = rp->ar_startblock;
 			kp[0].ar_blockcount = rp->ar_blockcount;
 			rp = XFS_ALLOC_REC_ADDR(right, 1, cur);
 			kp[1].ar_startblock = rp->ar_startblock;
 			kp[1].ar_blockcount = rp->ar_blockcount;
 		}
 	}
 	xfs_alloc_log_keys(cur, nbp, 1, 2);
 	/*
 	 * Fill in the pointer data in the new root.
 	 */
 	{
 		xfs_alloc_ptr_t		*pp;	/* btree address pointer */
 		pp = XFS_ALLOC_PTR_ADDR(new, 1, cur);
 		pp[0] = cpu_to_be32(lbno);
 		pp[1] = cpu_to_be32(rbno);
 	}
 	xfs_alloc_log_ptrs(cur, nbp, 1, 2);
 	/*
 	 * Fix up the cursor.
 	 */
 	xfs_btree_setbuf(cur, cur->bc_nlevels, nbp);
 	cur->bc_ptrs[cur->bc_nlevels] = nptr;
 	cur->bc_nlevels++;
 	*stat = 1;
 	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.
  */
 /*
  * Delete the record pointed to by cur.
  * The cursor refers to the place where the record was (could be inserted)
  * when the operation returns.
  */
 int					/* error */
 xfs_alloc_delete(
 	xfs_btree_cur_t	*cur,		/* btree cursor */
 	int		*stat)		/* success/failure */
 {
 	int		error;		/* error return value */
 	int		i;		/* result code */
 	int		level;		/* btree level */
 	/*
 	 * Go up the tree, starting at leaf level.
 	 * If 2 is returned then a join was done; go to the next level.
 	 * Otherwise we are done.
 	 */
 	for (level = 0, i = 2; i == 2; level++) {
 		if ((error = xfs_alloc_delrec(cur, level, &i)))
 			return error;
 	}
 	if (i == 0) {
 		for (level = 1; level < cur->bc_nlevels; level++) {
 			if (cur->bc_ptrs[level] == 0) {
 				if ((error = xfs_btree_decrement(cur, level, &i)))
 					return error;
 				break;
 			}
 		}
 	}
 	*stat = i;
 	return 0;
 }
 /*
  * Get the data from the pointed-to record.
  */
 int					/* error */
 xfs_alloc_get_rec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_agblock_t		*bno,	/* output: starting block of extent */
 	xfs_extlen_t		*len,	/* output: length of extent */
 	int			*stat)	/* output: success/failure */
 {
 	xfs_alloc_block_t	*block;	/* btree block */
 #ifdef DEBUG
 	int			error;	/* error return value */
 #endif
 	int			ptr;	/* record number */
 	ptr = cur->bc_ptrs[0];
 	block = XFS_BUF_TO_ALLOC_BLOCK(cur->bc_bufs[0]);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, 0, cur->bc_bufs[0])))
 		return error;
 #endif
 	/*
 	 * Off the right end or left end, return failure.
 	 */
 	if (ptr > be16_to_cpu(block->bb_numrecs) || ptr <= 0) {
 		*stat = 0;
 		return 0;
 	}
 	/*
 	 * Point to the record and extract its data.
 	 */
 	{
 		xfs_alloc_rec_t		*rec;	/* record data */
 		rec = XFS_ALLOC_REC_ADDR(block, ptr, cur);
 		*bno = be32_to_cpu(rec->ar_startblock);
 		*len = be32_to_cpu(rec->ar_blockcount);
 	}
 	*stat = 1;
 	return 0;
 }
 /*
  * Insert the current record at the point referenced by cur.
  * The cursor may be inconsistent on return if splits have been done.
  */
 int					/* error */
 xfs_alloc_insert(
 	xfs_btree_cur_t	*cur,		/* btree cursor */
 	int		*stat)		/* success/failure */
 {
 	int		error;		/* error return value */
 	int		i;		/* result value, 0 for failure */
 	int		level;		/* current level number in btree */
 	xfs_agblock_t	nbno;		/* new block number (split result) */
 	xfs_btree_cur_t	*ncur;		/* new cursor (split result) */
 	xfs_alloc_rec_t	nrec;		/* record being inserted this level */
 	xfs_btree_cur_t	*pcur;		/* previous level's cursor */
 	level = 0;
 	nbno = NULLAGBLOCK;
 	nrec.ar_startblock = cpu_to_be32(cur->bc_rec.a.ar_startblock);
 	nrec.ar_blockcount = cpu_to_be32(cur->bc_rec.a.ar_blockcount);
 	ncur = NULL;
 	pcur = cur;
 	/*
 	 * Loop going up the tree, starting at the leaf level.
 	 * Stop when we don't get a split block, that must mean that
 	 * the insert is finished with this level.
 	 */
 	do {
 		/*
 		 * Insert nrec/nbno into this level of the tree.
 		 * Note if we fail, nbno will be null.
 		 */
 		if ((error = xfs_alloc_insrec(pcur, level++, &nbno, &nrec, &ncur,
 				&i))) {
 			if (pcur != cur)
 				xfs_btree_del_cursor(pcur, XFS_BTREE_ERROR);
 			return error;
 		}
 		/*
 		 * See if the cursor we just used is trash.
 		 * Can't trash the caller's cursor, but otherwise we should
 		 * if ncur is a new cursor or we're about to be done.
 		 */
 		if (pcur != cur && (ncur || nbno == NULLAGBLOCK)) {
 			cur->bc_nlevels = pcur->bc_nlevels;
 			xfs_btree_del_cursor(pcur, XFS_BTREE_NOERROR);
 		}
 		/*
 		 * If we got a new cursor, switch to it.
 		 */
 		if (ncur) {
 			pcur = ncur;
 			ncur = NULL;
 		}
 	} while (nbno != NULLAGBLOCK);
 	*stat = i;
 	return 0;
 }
 STATIC struct xfs_btree_cur *
 xfs_allocbt_dup_cursor(
 	struct xfs_btree_cur	*cur)
 {
 	return xfs_allocbt_init_cursor(cur->bc_mp, cur->bc_tp,
 			cur->bc_private.a.agbp, cur->bc_private.a.agno,
 			cur->bc_btnum);
 }
 /*
  * Update the longest extent in the AGF
  */
 STATIC void
 xfs_allocbt_update_lastrec(
 	struct xfs_btree_cur	*cur,
 	struct xfs_btree_block	*block,
 	union xfs_btree_rec	*rec,
 	int			ptr,
 	int			reason)
 {
 	struct xfs_agf		*agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
 	xfs_agnumber_t		seqno = be32_to_cpu(agf->agf_seqno);
 	__be32			len;
 	ASSERT(cur->bc_btnum == XFS_BTNUM_CNT);
 	switch (reason) {
 	case LASTREC_UPDATE:
 		/*
 		 * If this is the last leaf block and it's the last record,
 		 * then update the size of the longest extent in the AG.
 		 */
 		if (ptr != xfs_btree_get_numrecs(block))
 			return;
 		len = rec->alloc.ar_blockcount;
 		break;
 	default:
 		ASSERT(0);
 		return;
 	}
 	agf->agf_longest = len;
 	cur->bc_mp->m_perag[seqno].pagf_longest = be32_to_cpu(len);
 	xfs_alloc_log_agf(cur->bc_tp, cur->bc_private.a.agbp, XFS_AGF_LONGEST);
 }
 STATIC int
 xfs_allocbt_get_maxrecs(
 	struct xfs_btree_cur	*cur,
 	int			level)
 {
 	return cur->bc_mp->m_alloc_mxr[level != 0];
 }
 STATIC void
 xfs_allocbt_init_key_from_rec(
 	union xfs_btree_key	*key,
 	union xfs_btree_rec	*rec)
 {
 	ASSERT(rec->alloc.ar_startblock != 0);
 	key->alloc.ar_startblock = rec->alloc.ar_startblock;
 	key->alloc.ar_blockcount = rec->alloc.ar_blockcount;
 }
 STATIC void
 xfs_allocbt_init_ptr_from_cur(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr)
 {
 	struct xfs_agf		*agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
 	ASSERT(cur->bc_private.a.agno == be32_to_cpu(agf->agf_seqno));
 	ASSERT(agf->agf_roots[cur->bc_btnum] != 0);
 	ptr->s = agf->agf_roots[cur->bc_btnum];
 }
 STATIC __int64_t
 xfs_allocbt_key_diff(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key)
 {
 	xfs_alloc_rec_incore_t	*rec = &cur->bc_rec.a;
 	xfs_alloc_key_t		*kp = &key->alloc;
 	__int64_t		diff;
 	if (cur->bc_btnum == XFS_BTNUM_BNO) {
 		return (__int64_t)be32_to_cpu(kp->ar_startblock) -
 				rec->ar_startblock;
 	}
 	diff = (__int64_t)be32_to_cpu(kp->ar_blockcount) - rec->ar_blockcount;
 	if (diff)
 		return diff;
 	return (__int64_t)be32_to_cpu(kp->ar_startblock) - rec->ar_startblock;
 }
 #ifdef XFS_BTREE_TRACE
 ktrace_t	*xfs_allocbt_trace_buf;
 STATIC void
 xfs_allocbt_trace_enter(
 	struct xfs_btree_cur	*cur,
 	const char		*func,
 	char			*s,
 	int			type,
 	int			line,
 	__psunsigned_t		a0,
 	__psunsigned_t		a1,
 	__psunsigned_t		a2,
 	__psunsigned_t		a3,
 	__psunsigned_t		a4,
 	__psunsigned_t		a5,
 	__psunsigned_t		a6,
 	__psunsigned_t		a7,
 	__psunsigned_t		a8,
 	__psunsigned_t		a9,
 	__psunsigned_t		a10)
 {
 	ktrace_enter(xfs_allocbt_trace_buf, (void *)(__psint_t)type,
 		(void *)func, (void *)s, NULL, (void *)cur,
 		(void *)a0, (void *)a1, (void *)a2, (void *)a3,
 		(void *)a4, (void *)a5, (void *)a6, (void *)a7,
 		(void *)a8, (void *)a9, (void *)a10);
 }
 STATIC void
 xfs_allocbt_trace_cursor(
 	struct xfs_btree_cur	*cur,
 	__uint32_t		*s0,
 	__uint64_t		*l0,
 	__uint64_t		*l1)
 {
 	*s0 = cur->bc_private.a.agno;
 	*l0 = cur->bc_rec.a.ar_startblock;
 	*l1 = cur->bc_rec.a.ar_blockcount;
 }
 STATIC void
 xfs_allocbt_trace_key(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key,
 	__uint64_t		*l0,
 	__uint64_t		*l1)
 {
 	*l0 = be32_to_cpu(key->alloc.ar_startblock);
 	*l1 = be32_to_cpu(key->alloc.ar_blockcount);
 }
 STATIC void
 xfs_allocbt_trace_record(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_rec	*rec,
 	__uint64_t		*l0,
 	__uint64_t		*l1,
 	__uint64_t		*l2)
 {
 	*l0 = be32_to_cpu(rec->alloc.ar_startblock);
 	*l1 = be32_to_cpu(rec->alloc.ar_blockcount);
 	*l2 = 0;
 }
 #endif /* XFS_BTREE_TRACE */
 static const struct xfs_btree_ops xfs_allocbt_ops = {
 	.rec_len		= sizeof(xfs_alloc_rec_t),
 	.key_len		= sizeof(xfs_alloc_key_t),
 	.dup_cursor		= xfs_allocbt_dup_cursor,
 	.update_lastrec		= xfs_allocbt_update_lastrec,
 	.get_maxrecs		= xfs_allocbt_get_maxrecs,
 	.init_key_from_rec	= xfs_allocbt_init_key_from_rec,
 	.init_ptr_from_cur	= xfs_allocbt_init_ptr_from_cur,
 	.key_diff		= xfs_allocbt_key_diff,
 #ifdef XFS_BTREE_TRACE
 	.trace_enter		= xfs_allocbt_trace_enter,
 	.trace_cursor		= xfs_allocbt_trace_cursor,
 	.trace_key		= xfs_allocbt_trace_key,
 	.trace_record		= xfs_allocbt_trace_record,
 #endif
 };
 /*
  * Allocate a new allocation btree cursor.
  */
 struct xfs_btree_cur *			/* new alloc btree cursor */
 xfs_allocbt_init_cursor(
 	struct xfs_mount	*mp,		/* file system mount point */
 	struct xfs_trans	*tp,		/* transaction pointer */
 	struct xfs_buf		*agbp,		/* buffer for agf structure */
 	xfs_agnumber_t		agno,		/* allocation group number */
 	xfs_btnum_t		btnum)		/* btree identifier */
 {
 	struct xfs_agf		*agf = XFS_BUF_TO_AGF(agbp);
 	struct xfs_btree_cur	*cur;
 	ASSERT(btnum == XFS_BTNUM_BNO || btnum == XFS_BTNUM_CNT);
 	cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
 	cur->bc_tp = tp;
 	cur->bc_mp = mp;
 	cur->bc_nlevels = be32_to_cpu(agf->agf_levels[btnum]);
 	cur->bc_btnum = btnum;
 	cur->bc_blocklog = mp->m_sb.sb_blocklog;
 	cur->bc_ops = &xfs_allocbt_ops;
 	if (btnum == XFS_BTNUM_CNT)
 		cur->bc_flags = XFS_BTREE_LASTREC_UPDATE;
 	cur->bc_private.a.agbp = agbp;
 	cur->bc_private.a.agno = agno;
 	return cur;
 }

fs/xfs/xfs_bmap_btree.c

Diff comments View file @ 687b890

 /*
  * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
 #include "xfs_bit.h"
 #include "xfs_log.h"
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
 #include "xfs_alloc.h"
 #include "xfs_btree.h"
 #include "xfs_btree_trace.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 /*
  * Prototypes for internal btree functions.
  */
 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_lshift(xfs_btree_cur_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
 #define ENTRY	XBT_ENTRY
 #define ERROR	XBT_ERROR
 #define EXIT	XBT_EXIT
 /*
  * Keep the XFS_BMBT_TRACE_ names around for now until all code using them
  * is converted to be generic and thus switches to the XFS_BTREE_TRACE_ names.
  */
 #define	XFS_BMBT_TRACE_ARGBI(c,b,i) \
 	XFS_BTREE_TRACE_ARGBI(c,b,i)
 #define	XFS_BMBT_TRACE_ARGBII(c,b,i,j) \
 	XFS_BTREE_TRACE_ARGBII(c,b,i,j)
 #define	XFS_BMBT_TRACE_ARGFFFI(c,o,b,i,j) \
 	XFS_BTREE_TRACE_ARGFFFI(c,o,b,i,j)
 #define	XFS_BMBT_TRACE_ARGI(c,i) \
 	XFS_BTREE_TRACE_ARGI(c,i)
 #define	XFS_BMBT_TRACE_ARGIFK(c,i,f,s) \
 	XFS_BTREE_TRACE_ARGIPK(c,i,(union xfs_btree_ptr)f,s)
 #define	XFS_BMBT_TRACE_ARGIFR(c,i,f,r) \
 	XFS_BTREE_TRACE_ARGIPR(c,i, \
 		(union xfs_btree_ptr)f, (union xfs_btree_rec *)r)
 #define	XFS_BMBT_TRACE_ARGIK(c,i,k) \
 	XFS_BTREE_TRACE_ARGIK(c,i,(union xfs_btree_key *)k)
 #define	XFS_BMBT_TRACE_CURSOR(c,s) \
 	XFS_BTREE_TRACE_CURSOR(c,s)
 /*
  * Internal functions.
  */
 /*
  * Delete record pointed to by cur/level.
  */
 STATIC int					/* error */
 xfs_bmbt_delrec(
 	xfs_btree_cur_t		*cur,
 	int			level,
 	int			*stat)		/* success/failure */
 {
 	xfs_bmbt_block_t	*block;		/* bmap btree block */
 	xfs_fsblock_t		bno;		/* fs-relative block number */
 	xfs_buf_t		*bp;		/* buffer for block */
 	int			error;		/* error return value */
 	int			i;		/* loop counter */
 	int			j;		/* temp state */
 	xfs_bmbt_key_t		key;		/* bmap btree key */
 	xfs_bmbt_key_t		*kp=NULL;	/* pointer to bmap btree key */
 	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 */
 	int			lrecs=0;	/* left record count */
 	xfs_bmbt_rec_t		*lrp;		/* left record pointer */
 	xfs_mount_t		*mp;		/* file system mount point */
 	xfs_bmbt_ptr_t		*pp;		/* pointer to bmap block addr */
 	int			ptr;		/* key/record index */
 	xfs_fsblock_t		rbno;		/* right sibling block number */
 	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_rec_t		*rp;		/* pointer to bmap btree rec */
 	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 */
 	int			rrecs=0;	/* right record count */
 	xfs_bmbt_rec_t		*rrp;		/* right record pointer */
 	xfs_btree_cur_t		*tcur;		/* temporary btree cursor */
 	int			numrecs;	/* temporary numrec count */
 	int			numlrecs, numrrecs;
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGI(cur, level);
 	ptr = cur->bc_ptrs[level];
 	tcur = NULL;
 	if (ptr == 0) {
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 0;
 		return 0;
 	}
 	block = xfs_bmbt_get_block(cur, level, &bp);
 	numrecs = be16_to_cpu(block->bb_numrecs);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_lblock(cur, block, level, bp))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		goto error0;
 	}
 #endif
 	if (ptr > numrecs) {
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 0;
 		return 0;
 	}
 	XFS_STATS_INC(xs_bmbt_delrec);
 	if (level > 0) {
 		kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
 		pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
 #ifdef DEBUG
 		for (i = ptr; i < numrecs; i++) {
 			if ((error = xfs_btree_check_lptr_disk(cur, pp[i], level))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				goto error0;
 			}
 		}
 #endif
 		if (ptr < numrecs) {
 			memmove(&kp[ptr - 1], &kp[ptr],
 				(numrecs - ptr) * sizeof(*kp));
 			memmove(&pp[ptr - 1], &pp[ptr],
 				(numrecs - ptr) * sizeof(*pp));
 			xfs_bmbt_log_ptrs(cur, bp, ptr, numrecs - 1);
 			xfs_bmbt_log_keys(cur, bp, ptr, numrecs - 1);
 		}
 	} else {
 		rp = XFS_BMAP_REC_IADDR(block, 1, cur);
 		if (ptr < numrecs) {
 			memmove(&rp[ptr - 1], &rp[ptr],
 				(numrecs - ptr) * sizeof(*rp));
 			xfs_bmbt_log_recs(cur, bp, ptr, numrecs - 1);
 		}
 		if (ptr == 1) {
 			key.br_startoff =
 				cpu_to_be64(xfs_bmbt_disk_get_startoff(rp));
 			kp = &key;
 		}
 	}
 	numrecs--;
 	block->bb_numrecs = cpu_to_be16(numrecs);
 	xfs_bmbt_log_block(cur, bp, XFS_BB_NUMRECS);
 	/*
 	 * We're at the root level.
 	 * First, shrink the root block in-memory.
 	 * Try to get rid of the next level down.
 	 * If we can't then there's nothing left to do.
 	 */
 	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))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &j))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 1;
 		return 0;
 	}
 	if (ptr == 1 && (error = xfs_btree_updkey(cur, (union xfs_btree_key *)kp, level + 1))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		goto error0;
 	}
 	if (numrecs >= XFS_BMAP_BLOCK_IMINRECS(level, cur)) {
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &j))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 1;
 		return 0;
 	}
 	rbno = be64_to_cpu(block->bb_rightsib);
 	lbno = be64_to_cpu(block->bb_leftsib);
 	/*
 	 * One child of root, need to get a chance to copy its contents
 	 * into the root and delete it. Can't go up to next level,
 	 * there's nothing to delete there.
 	 */
 	if (lbno == NULLFSBLOCK && rbno == NULLFSBLOCK &&
 	    level == cur->bc_nlevels - 2) {
 		if ((error = xfs_bmbt_killroot(cur))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &i))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 1;
 		return 0;
 	}
 	ASSERT(rbno != NULLFSBLOCK || lbno != NULLFSBLOCK);
 	if ((error = xfs_btree_dup_cursor(cur, &tcur))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		goto error0;
 	}
 	bno = NULLFSBLOCK;
 	if (rbno != NULLFSBLOCK) {
 		i = xfs_btree_lastrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		if ((error = xfs_btree_increment(tcur, level, &i))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		i = xfs_btree_lastrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		rbp = tcur->bc_bufs[level];
 		right = XFS_BUF_TO_BMBT_BLOCK(rbp);
 #ifdef DEBUG
 		if ((error = xfs_btree_check_lblock(cur, right, level, rbp))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 #endif
 		bno = be64_to_cpu(right->bb_leftsib);
 		if (be16_to_cpu(right->bb_numrecs) - 1 >=
 		    XFS_BMAP_BLOCK_IMINRECS(level, cur)) {
-			if ((error = xfs_bmbt_lshift(tcur, level, &i))) {
+			if ((error = xfs_btree_lshift(tcur, level, &i))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				goto error0;
 			}
 			if (i) {
 				ASSERT(be16_to_cpu(block->bb_numrecs) >=
 				       XFS_BMAP_BLOCK_IMINRECS(level, tcur));
 				xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
 				tcur = NULL;
 				if (level > 0) {
 					if ((error = xfs_btree_decrement(cur,
 							level, &i))) {
 						XFS_BMBT_TRACE_CURSOR(cur,
 							ERROR);
 						goto error0;
 					}
 				}
 				XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 				*stat = 1;
 				return 0;
 			}
 		}
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		if (lbno != NULLFSBLOCK) {
 			i = xfs_btree_firstrec(tcur, level);
 			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 			if ((error = xfs_btree_decrement(tcur, level, &i))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				goto error0;
 			}
 			XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		}
 	}
 	if (lbno != NULLFSBLOCK) {
 		i = xfs_btree_firstrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		/*
 		 * decrement to last in block
 		 */
 		if ((error = xfs_btree_decrement(tcur, level, &i))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		i = xfs_btree_firstrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		lbp = tcur->bc_bufs[level];
 		left = XFS_BUF_TO_BMBT_BLOCK(lbp);
 #ifdef DEBUG
 		if ((error = xfs_btree_check_lblock(cur, left, level, lbp))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 #endif
 		bno = be64_to_cpu(left->bb_rightsib);
 		if (be16_to_cpu(left->bb_numrecs) - 1 >=
 		    XFS_BMAP_BLOCK_IMINRECS(level, cur)) {
 			if ((error = xfs_btree_rshift(tcur, level, &i))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				goto error0;
 			}
 			if (i) {
 				ASSERT(be16_to_cpu(block->bb_numrecs) >=
 				       XFS_BMAP_BLOCK_IMINRECS(level, tcur));
 				xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
 				tcur = NULL;
 				if (level == 0)
 					cur->bc_ptrs[0]++;
 				XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 				*stat = 1;
 				return 0;
 			}
 		}
 		lrecs = be16_to_cpu(left->bb_numrecs);
 	}
 	xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
 	tcur = NULL;
 	mp = cur->bc_mp;
 	ASSERT(bno != NULLFSBLOCK);
 	if (lbno != NULLFSBLOCK &&
 	    lrecs + be16_to_cpu(block->bb_numrecs) <= XFS_BMAP_BLOCK_IMAXRECS(level, cur)) {
 		rbno = bno;
 		right = block;
 		rbp = bp;
 		if ((error = xfs_btree_read_bufl(mp, cur->bc_tp, lbno, 0, &lbp,
 				XFS_BMAP_BTREE_REF))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		left = XFS_BUF_TO_BMBT_BLOCK(lbp);
 		if ((error = xfs_btree_check_lblock(cur, left, level, lbp))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 	} else if (rbno != NULLFSBLOCK &&
 		   rrecs + be16_to_cpu(block->bb_numrecs) <=
 		   XFS_BMAP_BLOCK_IMAXRECS(level, cur)) {
 		lbno = bno;
 		left = block;
 		lbp = bp;
 		if ((error = xfs_btree_read_bufl(mp, cur->bc_tp, rbno, 0, &rbp,
 				XFS_BMAP_BTREE_REF))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		right = XFS_BUF_TO_BMBT_BLOCK(rbp);
 		if ((error = xfs_btree_check_lblock(cur, right, level, rbp))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		lrecs = be16_to_cpu(left->bb_numrecs);
 	} else {
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &i))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 1;
 		return 0;
 	}
 	numlrecs = be16_to_cpu(left->bb_numrecs);
 	numrrecs = be16_to_cpu(right->bb_numrecs);
 	if (level > 0) {
 		lkp = XFS_BMAP_KEY_IADDR(left, numlrecs + 1, cur);
 		lpp = XFS_BMAP_PTR_IADDR(left, numlrecs + 1, cur);
 		rkp = XFS_BMAP_KEY_IADDR(right, 1, cur);
 		rpp = XFS_BMAP_PTR_IADDR(right, 1, cur);
 #ifdef DEBUG
 		for (i = 0; i < numrrecs; i++) {
 			if ((error = xfs_btree_check_lptr_disk(cur, rpp[i], level))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				goto error0;
 			}
 		}
 #endif
 		memcpy(lkp, rkp, numrrecs * sizeof(*lkp));
 		memcpy(lpp, rpp, numrrecs * sizeof(*lpp));
 		xfs_bmbt_log_keys(cur, lbp, numlrecs + 1, numlrecs + numrrecs);
 		xfs_bmbt_log_ptrs(cur, lbp, numlrecs + 1, numlrecs + numrrecs);
 	} else {
 		lrp = XFS_BMAP_REC_IADDR(left, numlrecs + 1, cur);
 		rrp = XFS_BMAP_REC_IADDR(right, 1, cur);
 		memcpy(lrp, rrp, numrrecs * sizeof(*lrp));
 		xfs_bmbt_log_recs(cur, lbp, numlrecs + 1, numlrecs + numrrecs);
 	}
 	be16_add_cpu(&left->bb_numrecs, numrrecs);
 	left->bb_rightsib = right->bb_rightsib;
 	xfs_bmbt_log_block(cur, lbp, XFS_BB_RIGHTSIB | XFS_BB_NUMRECS);
 	if (be64_to_cpu(left->bb_rightsib) != NULLDFSBNO) {
 		if ((error = xfs_btree_read_bufl(mp, cur->bc_tp,
 				be64_to_cpu(left->bb_rightsib),
 				0, &rrbp, XFS_BMAP_BTREE_REF))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		rrblock = XFS_BUF_TO_BMBT_BLOCK(rrbp);
 		if ((error = xfs_btree_check_lblock(cur, rrblock, level, rrbp))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			goto error0;
 		}
 		rrblock->bb_leftsib = cpu_to_be64(lbno);
 		xfs_bmbt_log_block(cur, rrbp, XFS_BB_LEFTSIB);
 	}
 	xfs_bmap_add_free(XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(rbp)), 1,
 		cur->bc_private.b.flist, mp);
 	cur->bc_private.b.ip->i_d.di_nblocks--;
 	xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip, XFS_ILOG_CORE);
 	XFS_TRANS_MOD_DQUOT_BYINO(mp, cur->bc_tp, cur->bc_private.b.ip,
 			XFS_TRANS_DQ_BCOUNT, -1L);
 	xfs_trans_binval(cur->bc_tp, rbp);
 	if (bp != lbp) {
 		cur->bc_bufs[level] = lbp;
 		cur->bc_ptrs[level] += lrecs;
 		cur->bc_ra[level] = 0;
 	} else if ((error = xfs_btree_increment(cur, level + 1, &i))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		goto error0;
 	}
 	if (level > 0)
 		cur->bc_ptrs[level]--;
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 	*stat = 2;
 	return 0;
 error0:
 	if (tcur)
 		xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
 	return error;
 }
 /*
  * Insert one record/level.  Return information to the caller
  * allowing the next level up to proceed if necessary.
  */
 STATIC int					/* error */
 xfs_bmbt_insrec(
 	xfs_btree_cur_t		*cur,
 	int			level,
 	xfs_fsblock_t		*bnop,
 	xfs_bmbt_rec_t		*recp,
 	xfs_btree_cur_t		**curp,
 	int			*stat)		/* no-go/done/continue */
 {
 	xfs_bmbt_block_t	*block;		/* bmap btree block */
 	xfs_buf_t		*bp;		/* buffer for block */
 	int			error;		/* error return value */
 	int			i;		/* loop index */
 	xfs_bmbt_key_t		key;		/* bmap btree key */
 	xfs_bmbt_key_t		*kp=NULL;	/* pointer to bmap btree key */
 	int			logflags;	/* inode logging flags */
 	xfs_fsblock_t		nbno;		/* new block number */
 	struct xfs_btree_cur	*ncur;		/* new btree cursor */
 	__uint64_t		startoff;	/* new btree key value */
 	xfs_bmbt_rec_t		nrec;		/* new record count */
 	int			optr;		/* old key/record index */
 	xfs_bmbt_ptr_t		*pp;		/* pointer to bmap block addr */
 	int			ptr;		/* key/record index */
 	xfs_bmbt_rec_t		*rp=NULL;	/* pointer to bmap btree rec */
 	int			numrecs;
 	ASSERT(level < cur->bc_nlevels);
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGIFR(cur, level, *bnop, recp);
 	ncur = NULL;
 	key.br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(recp));
 	optr = ptr = cur->bc_ptrs[level];
 	if (ptr == 0) {
 		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 		*stat = 0;
 		return 0;
 	}
 	XFS_STATS_INC(xs_bmbt_insrec);
 	block = xfs_bmbt_get_block(cur, level, &bp);
 	numrecs = be16_to_cpu(block->bb_numrecs);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_lblock(cur, block, level, bp))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		return error;
 	}
 	if (ptr <= numrecs) {
 		if (level == 0) {
 			rp = XFS_BMAP_REC_IADDR(block, ptr, cur);
 			xfs_btree_check_rec(XFS_BTNUM_BMAP, recp, rp);
 		} else {
 			kp = XFS_BMAP_KEY_IADDR(block, ptr, cur);
 			xfs_btree_check_key(XFS_BTNUM_BMAP, &key, kp);
 		}
 	}
 #endif
 	nbno = NULLFSBLOCK;
 	if (numrecs == XFS_BMAP_BLOCK_IMAXRECS(level, cur)) {
 		if (numrecs < XFS_BMAP_BLOCK_DMAXRECS(level, cur)) {
 			/*
 			 * A root block, that can be made bigger.
 			 */
 			xfs_iroot_realloc(cur->bc_private.b.ip, 1,
 				cur->bc_private.b.whichfork);
 			block = xfs_bmbt_get_block(cur, level, &bp);
 		} else if (level == cur->bc_nlevels - 1) {
 			if ((error = xfs_bmbt_newroot(cur, &logflags, stat)) ||
 			    *stat == 0) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				return error;
 			}
 			xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
 				logflags);
 			block = xfs_bmbt_get_block(cur, level, &bp);
 		} else {
 			if ((error = xfs_btree_rshift(cur, level, &i))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				return error;
 			}
 			if (i) {
 				/* nothing */
 			} else {
-				if ((error = xfs_bmbt_lshift(cur, level, &i))) {
+				if ((error = xfs_btree_lshift(cur, level, &i))) {
 					XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 					return error;
 				}
 				if (i) {
 					optr = ptr = cur->bc_ptrs[level];
 				} else {
 					if ((error = xfs_bmbt_split(cur, level,
 							&nbno, &startoff, &ncur,
 							&i))) {
 						XFS_BMBT_TRACE_CURSOR(cur,
 							ERROR);
 						return error;
 					}
 					if (i) {
 						block = xfs_bmbt_get_block(
 							    cur, level, &bp);
 #ifdef DEBUG
 						if ((error =
 						    xfs_btree_check_lblock(cur,
 							    block, level, bp))) {
 							XFS_BMBT_TRACE_CURSOR(
 								cur, ERROR);
 							return error;
 						}
 #endif
 						ptr = cur->bc_ptrs[level];
 						xfs_bmbt_disk_set_allf(&nrec,
 							startoff, 0, 0,
 							XFS_EXT_NORM);
 					} else {
 						XFS_BMBT_TRACE_CURSOR(cur,
 							EXIT);
 						*stat = 0;
 						return 0;
 					}
 				}
 			}
 		}
 	}
 	numrecs = be16_to_cpu(block->bb_numrecs);
 	if (level > 0) {
 		kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
 		pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
 #ifdef DEBUG
 		for (i = numrecs; i >= ptr; i--) {
 			if ((error = xfs_btree_check_lptr_disk(cur, pp[i - 1],
 					level))) {
 				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 				return error;
 			}
 		}
 #endif
 		memmove(&kp[ptr], &kp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*kp));
 		memmove(&pp[ptr], &pp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*pp));
 #ifdef DEBUG
 		if ((error = xfs_btree_check_lptr(cur, *bnop, level))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			return error;
 		}
 #endif
 		kp[ptr - 1] = key;
 		pp[ptr - 1] = cpu_to_be64(*bnop);
 		numrecs++;
 		block->bb_numrecs = cpu_to_be16(numrecs);
 		xfs_bmbt_log_keys(cur, bp, ptr, numrecs);
 		xfs_bmbt_log_ptrs(cur, bp, ptr, numrecs);
 	} else {
 		rp = XFS_BMAP_REC_IADDR(block, 1, cur);
 		memmove(&rp[ptr], &rp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*rp));
 		rp[ptr - 1] = *recp;
 		numrecs++;
 		block->bb_numrecs = cpu_to_be16(numrecs);
 		xfs_bmbt_log_recs(cur, bp, ptr, numrecs);
 	}
 	xfs_bmbt_log_block(cur, bp, XFS_BB_NUMRECS);
 #ifdef DEBUG
 	if (ptr < numrecs) {
 		if (level == 0)
 			xfs_btree_check_rec(XFS_BTNUM_BMAP, rp + ptr - 1,
 				rp + ptr);
 		else
 			xfs_btree_check_key(XFS_BTNUM_BMAP, kp + ptr - 1,
 				kp + ptr);
 	}
 #endif
 	if (optr == 1 && (error = xfs_btree_updkey(cur, (union xfs_btree_key *)&key, level + 1))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		return error;
 	}
 	*bnop = nbno;
 	if (nbno != NULLFSBLOCK) {
 		*recp = nrec;
 		*curp = ncur;
 	}
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 	*stat = 1;
 	return 0;
 }
 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.
  */
 STATIC void
 xfs_bmbt_log_keys(
 	xfs_btree_cur_t	*cur,
 	xfs_buf_t	*bp,
 	int		kfirst,
 	int		klast)
 {
 	xfs_trans_t	*tp;
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGBII(cur, bp, kfirst, klast);
 	tp = cur->bc_tp;
 	if (bp) {
 		xfs_bmbt_block_t	*block;
 		int			first;
 		xfs_bmbt_key_t		*kp;
 		int			last;
 		block = XFS_BUF_TO_BMBT_BLOCK(bp);
 		kp = XFS_BMAP_KEY_DADDR(block, 1, cur);
 		first = (int)((xfs_caddr_t)&kp[kfirst - 1] - (xfs_caddr_t)block);
 		last = (int)(((xfs_caddr_t)&kp[klast] - 1) - (xfs_caddr_t)block);
 		xfs_trans_log_buf(tp, bp, first, last);
 	} else {
 		xfs_inode_t		 *ip;
 		ip = cur->bc_private.b.ip;
 		xfs_trans_log_inode(tp, ip,
 			XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
 	}
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 }
 /*
  * Log pointer values from the btree block.
  */
 STATIC void
 xfs_bmbt_log_ptrs(
 	xfs_btree_cur_t	*cur,
 	xfs_buf_t	*bp,
 	int		pfirst,
 	int		plast)
 {
 	xfs_trans_t	*tp;
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGBII(cur, bp, pfirst, plast);
 	tp = cur->bc_tp;
 	if (bp) {
 		xfs_bmbt_block_t	*block;
 		int			first;
 		int			last;
 		xfs_bmbt_ptr_t		*pp;
 		block = XFS_BUF_TO_BMBT_BLOCK(bp);
 		pp = XFS_BMAP_PTR_DADDR(block, 1, cur);
 		first = (int)((xfs_caddr_t)&pp[pfirst - 1] - (xfs_caddr_t)block);
 		last = (int)(((xfs_caddr_t)&pp[plast] - 1) - (xfs_caddr_t)block);
 		xfs_trans_log_buf(tp, bp, first, last);
 	} else {
 		xfs_inode_t		*ip;
 		ip = cur->bc_private.b.ip;
 		xfs_trans_log_inode(tp, ip,
 			XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
 	}
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-}
-/*
- * Move 1 record left from cur/level if possible.
- * Update cur to reflect the new path.
- */
-STATIC int					/* error */
-xfs_bmbt_lshift(
-	xfs_btree_cur_t		*cur,
-	int			level,
-	int			*stat)		/* success/failure */
-{
-	int			error;		/* error return value */
-#ifdef DEBUG
-	int			i;		/* loop counter */
-#endif
-	xfs_bmbt_key_t		key;		/* bmap btree key */
-	xfs_buf_t		*lbp;		/* left buffer pointer */
-	xfs_bmbt_block_t	*left;		/* left btree block */
-	xfs_bmbt_key_t		*lkp=NULL;	/* left btree key */
-	xfs_bmbt_ptr_t		*lpp;		/* left address pointer */
-	int			lrecs;		/* left record count */
-	xfs_bmbt_rec_t		*lrp=NULL;	/* left record pointer */
-	xfs_mount_t		*mp;		/* file system mount point */
-	xfs_buf_t		*rbp;		/* right buffer pointer */
-	xfs_bmbt_block_t	*right;		/* right btree block */
-	xfs_bmbt_key_t		*rkp=NULL;	/* right btree key */
-	xfs_bmbt_ptr_t		*rpp=NULL;	/* right address pointer */
-	xfs_bmbt_rec_t		*rrp=NULL;	/* right record pointer */
-	int			rrecs;		/* right record count */
-	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
-	XFS_BMBT_TRACE_ARGI(cur, level);
-	if (level == cur->bc_nlevels - 1) {
-		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-		*stat = 0;
-		return 0;
-	}
-	rbp = cur->bc_bufs[level];
-	right = XFS_BUF_TO_BMBT_BLOCK(rbp);
-#ifdef DEBUG
-	if ((error = xfs_btree_check_lblock(cur, right, level, rbp))) {
-		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-		return error;
-	}
-#endif
-	if (be64_to_cpu(right->bb_leftsib) == NULLDFSBNO) {
-		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-		*stat = 0;
-		return 0;
-	}
-	if (cur->bc_ptrs[level] <= 1) {
-		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-		*stat = 0;
-		return 0;
-	}
-	mp = cur->bc_mp;
-	if ((error = xfs_btree_read_bufl(mp, cur->bc_tp, be64_to_cpu(right->bb_leftsib), 0,
-			&lbp, XFS_BMAP_BTREE_REF))) {
-		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-		return error;
-	}
-	left = XFS_BUF_TO_BMBT_BLOCK(lbp);
-	if ((error = xfs_btree_check_lblock(cur, left, level, lbp))) {
-		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-		return error;
-	}
-	if (be16_to_cpu(left->bb_numrecs) == XFS_BMAP_BLOCK_IMAXRECS(level, cur)) {
-		XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-		*stat = 0;
-		return 0;
-	}
-	lrecs = be16_to_cpu(left->bb_numrecs) + 1;
-	if (level > 0) {
-		lkp = XFS_BMAP_KEY_IADDR(left, lrecs, cur);
-		rkp = XFS_BMAP_KEY_IADDR(right, 1, cur);
-		*lkp = *rkp;
-		xfs_bmbt_log_keys(cur, lbp, lrecs, lrecs);
-		lpp = XFS_BMAP_PTR_IADDR(left, lrecs, cur);
-		rpp = XFS_BMAP_PTR_IADDR(right, 1, cur);
-#ifdef DEBUG
-		if ((error = xfs_btree_check_lptr_disk(cur, *rpp, level))) {
-			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-			return error;
-		}
-#endif
-		*lpp = *rpp;
-		xfs_bmbt_log_ptrs(cur, lbp, lrecs, lrecs);
-	} else {
-		lrp = XFS_BMAP_REC_IADDR(left, lrecs, cur);
-		rrp = XFS_BMAP_REC_IADDR(right, 1, cur);
-		*lrp = *rrp;
-		xfs_bmbt_log_recs(cur, lbp, lrecs, lrecs);
-	}
-	left->bb_numrecs = cpu_to_be16(lrecs);
-	xfs_bmbt_log_block(cur, lbp, XFS_BB_NUMRECS);
-#ifdef DEBUG
-	if (level > 0)
-		xfs_btree_check_key(XFS_BTNUM_BMAP, lkp - 1, lkp);
-	else
-		xfs_btree_check_rec(XFS_BTNUM_BMAP, lrp - 1, lrp);
-#endif
-	rrecs = be16_to_cpu(right->bb_numrecs) - 1;
-	right->bb_numrecs = cpu_to_be16(rrecs);
-	xfs_bmbt_log_block(cur, rbp, XFS_BB_NUMRECS);
-	if (level > 0) {
-#ifdef DEBUG
-		for (i = 0; i < rrecs; i++) {
-			if ((error = xfs_btree_check_lptr_disk(cur, rpp[i + 1],
-					level))) {
-				XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-				return error;
-			}
-		}
-#endif
-		memmove(rkp, rkp + 1, rrecs * sizeof(*rkp));
-		memmove(rpp, rpp + 1, rrecs * sizeof(*rpp));
-		xfs_bmbt_log_keys(cur, rbp, 1, rrecs);
-		xfs_bmbt_log_ptrs(cur, rbp, 1, rrecs);
-	} else {
-		memmove(rrp, rrp + 1, rrecs * sizeof(*rrp));
-		xfs_bmbt_log_recs(cur, rbp, 1, rrecs);
-		key.br_startoff = cpu_to_be64(xfs_bmbt_disk_get_startoff(rrp));
-		rkp = &key;
-	}
-	if ((error = xfs_btree_updkey(cur, (union xfs_btree_key *)rkp, level + 1))) {
-		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
-		return error;
-	}
-	cur->bc_ptrs[level]--;
-	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
-	*stat = 1;
-	return 0;
 }
 /*
  * Determine the extent state.
  */
 /* ARGSUSED */
 STATIC xfs_exntst_t
 xfs_extent_state(
 	xfs_filblks_t		blks,
 	int			extent_flag)
 {
 	if (extent_flag) {
 		ASSERT(blks != 0);	/* saved for DMIG */
 		return XFS_EXT_UNWRITTEN;
 	}
 	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.
  */
 void
 xfs_bmdr_to_bmbt(
 	xfs_bmdr_block_t	*dblock,
 	int			dblocklen,
 	xfs_bmbt_block_t	*rblock,
 	int			rblocklen)
 {
 	int			dmxr;
 	xfs_bmbt_key_t		*fkp;
 	__be64			*fpp;
 	xfs_bmbt_key_t		*tkp;
 	__be64			*tpp;
 	rblock->bb_magic = cpu_to_be32(XFS_BMAP_MAGIC);
 	rblock->bb_level = dblock->bb_level;
 	ASSERT(be16_to_cpu(rblock->bb_level) > 0);
 	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);
 	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);
 	dmxr = be16_to_cpu(dblock->bb_numrecs);
 	memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
 	memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
 }
 /*
  * Delete the record pointed to by cur.
  */
 int					/* error */
 xfs_bmbt_delete(
 	xfs_btree_cur_t	*cur,
 	int		*stat)		/* success/failure */
 {
 	int		error;		/* error return value */
 	int		i;
 	int		level;
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	for (level = 0, i = 2; i == 2; level++) {
 		if ((error = xfs_bmbt_delrec(cur, level, &i))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			return error;
 		}
 	}
 	if (i == 0) {
 		for (level = 1; level < cur->bc_nlevels; level++) {
 			if (cur->bc_ptrs[level] == 0) {
 				if ((error = xfs_btree_decrement(cur, level,
 						&i))) {
 					XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 					return error;
 				}
 				break;
 			}
 		}
 	}
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 	*stat = i;
 	return 0;
 }
 /*
  * Convert a compressed bmap extent record to an uncompressed form.
  * This code must be in sync with the routines xfs_bmbt_get_startoff,
  * xfs_bmbt_get_startblock, xfs_bmbt_get_blockcount and xfs_bmbt_get_state.
  */
 STATIC_INLINE void
 __xfs_bmbt_get_all(
 		__uint64_t l0,
 		__uint64_t l1,
 		xfs_bmbt_irec_t *s)
 {
 	int	ext_flag;
 	xfs_exntst_t st;
 	ext_flag = (int)(l0 >> (64 - BMBT_EXNTFLAG_BITLEN));
 	s->br_startoff = ((xfs_fileoff_t)l0 &
 			   XFS_MASK64LO(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
 #if XFS_BIG_BLKNOS
 	s->br_startblock = (((xfs_fsblock_t)l0 & XFS_MASK64LO(9)) << 43) |
 			   (((xfs_fsblock_t)l1) >> 21);
 #else
 #ifdef DEBUG
 	{
 		xfs_dfsbno_t	b;
 		b = (((xfs_dfsbno_t)l0 & XFS_MASK64LO(9)) << 43) |
 		    (((xfs_dfsbno_t)l1) >> 21);
 		ASSERT((b >> 32) == 0 || ISNULLDSTARTBLOCK(b));
 		s->br_startblock = (xfs_fsblock_t)b;
 	}
 #else	/* !DEBUG */
 	s->br_startblock = (xfs_fsblock_t)(((xfs_dfsbno_t)l1) >> 21);
 #endif	/* DEBUG */
 #endif	/* XFS_BIG_BLKNOS */
 	s->br_blockcount = (xfs_filblks_t)(l1 & XFS_MASK64LO(21));
 	/* This is xfs_extent_state() in-line */
 	if (ext_flag) {
 		ASSERT(s->br_blockcount != 0);	/* saved for DMIG */
 		st = XFS_EXT_UNWRITTEN;
 	} else
 		st = XFS_EXT_NORM;
 	s->br_state = st;
 }
 void
 xfs_bmbt_get_all(
 	xfs_bmbt_rec_host_t *r,
 	xfs_bmbt_irec_t *s)
 {
 	__xfs_bmbt_get_all(r->l0, r->l1, s);
 }
 /*
  * Get the block pointer for the given level of the cursor.
  * Fill in the buffer pointer, if applicable.
  */
 xfs_bmbt_block_t *
 xfs_bmbt_get_block(
 	xfs_btree_cur_t		*cur,
 	int			level,
 	xfs_buf_t		**bpp)
 {
 	xfs_ifork_t		*ifp;
 	xfs_bmbt_block_t	*rval;
 	if (level < cur->bc_nlevels - 1) {
 		*bpp = cur->bc_bufs[level];
 		rval = XFS_BUF_TO_BMBT_BLOCK(*bpp);
 	} else {
 		*bpp = NULL;
 		ifp = XFS_IFORK_PTR(cur->bc_private.b.ip,
 			cur->bc_private.b.whichfork);
 		rval = ifp->if_broot;
 	}
 	return rval;
 }
 /*
  * Extract the blockcount field from an in memory bmap extent record.
  */
 xfs_filblks_t
 xfs_bmbt_get_blockcount(
 	xfs_bmbt_rec_host_t	*r)
 {
 	return (xfs_filblks_t)(r->l1 & XFS_MASK64LO(21));
 }
 /*
  * Extract the startblock field from an in memory bmap extent record.
  */
 xfs_fsblock_t
 xfs_bmbt_get_startblock(
 	xfs_bmbt_rec_host_t	*r)
 {
 #if XFS_BIG_BLKNOS
 	return (((xfs_fsblock_t)r->l0 & XFS_MASK64LO(9)) << 43) |
 	       (((xfs_fsblock_t)r->l1) >> 21);
 #else
 #ifdef DEBUG
 	xfs_dfsbno_t	b;
 	b = (((xfs_dfsbno_t)r->l0 & XFS_MASK64LO(9)) << 43) |
 	    (((xfs_dfsbno_t)r->l1) >> 21);
 	ASSERT((b >> 32) == 0 || ISNULLDSTARTBLOCK(b));
 	return (xfs_fsblock_t)b;
 #else	/* !DEBUG */
 	return (xfs_fsblock_t)(((xfs_dfsbno_t)r->l1) >> 21);
 #endif	/* DEBUG */
 #endif	/* XFS_BIG_BLKNOS */
 }
 /*
  * Extract the startoff field from an in memory bmap extent record.
  */
 xfs_fileoff_t
 xfs_bmbt_get_startoff(
 	xfs_bmbt_rec_host_t	*r)
 {
 	return ((xfs_fileoff_t)r->l0 &
 		 XFS_MASK64LO(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
 }
 xfs_exntst_t
 xfs_bmbt_get_state(
 	xfs_bmbt_rec_host_t	*r)
 {
 	int	ext_flag;
 	ext_flag = (int)((r->l0) >> (64 - BMBT_EXNTFLAG_BITLEN));
 	return xfs_extent_state(xfs_bmbt_get_blockcount(r),
 				ext_flag);
 }
 /* Endian flipping versions of the bmbt extraction functions */
 void
 xfs_bmbt_disk_get_all(
 	xfs_bmbt_rec_t	*r,
 	xfs_bmbt_irec_t *s)
 {
 	__xfs_bmbt_get_all(be64_to_cpu(r->l0), be64_to_cpu(r->l1), s);
 }
 /*
  * Extract the blockcount field from an on disk bmap extent record.
  */
 xfs_filblks_t
 xfs_bmbt_disk_get_blockcount(
 	xfs_bmbt_rec_t	*r)
 {
 	return (xfs_filblks_t)(be64_to_cpu(r->l1) & XFS_MASK64LO(21));
 }
 /*
  * Extract the startoff field from a disk format bmap extent record.
  */
 xfs_fileoff_t
 xfs_bmbt_disk_get_startoff(
 	xfs_bmbt_rec_t	*r)
 {
 	return ((xfs_fileoff_t)be64_to_cpu(r->l0) &
 		 XFS_MASK64LO(64 - BMBT_EXNTFLAG_BITLEN)) >> 9;
 }
 /*
  * Insert the current record at the point referenced by cur.
  *
  * A multi-level split of the tree on insert will invalidate the original
  * cursor.  All callers of this function should assume that the cursor is
  * no longer valid and revalidate it.
  */
 int					/* error */
 xfs_bmbt_insert(
 	xfs_btree_cur_t	*cur,
 	int		*stat)		/* success/failure */
 {
 	int		error;		/* error return value */
 	int		i;
 	int		level;
 	xfs_fsblock_t	nbno;
 	xfs_btree_cur_t	*ncur;
 	xfs_bmbt_rec_t	nrec;
 	xfs_btree_cur_t	*pcur;
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	level = 0;
 	nbno = NULLFSBLOCK;
 	xfs_bmbt_disk_set_all(&nrec, &cur->bc_rec.b);
 	ncur = NULL;
 	pcur = cur;
 	do {
 		if ((error = xfs_bmbt_insrec(pcur, level++, &nbno, &nrec, &ncur,
 				&i))) {
 			if (pcur != cur)
 				xfs_btree_del_cursor(pcur, XFS_BTREE_ERROR);
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			return error;
 		}
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		if (pcur != cur && (ncur || nbno == NULLFSBLOCK)) {
 			cur->bc_nlevels = pcur->bc_nlevels;
 			cur->bc_private.b.allocated +=
 				pcur->bc_private.b.allocated;
 			pcur->bc_private.b.allocated = 0;
 			ASSERT((cur->bc_private.b.firstblock != NULLFSBLOCK) ||
 			       XFS_IS_REALTIME_INODE(cur->bc_private.b.ip));
 			cur->bc_private.b.firstblock =
 				pcur->bc_private.b.firstblock;
 			ASSERT(cur->bc_private.b.flist ==
 			       pcur->bc_private.b.flist);
 			xfs_btree_del_cursor(pcur, XFS_BTREE_NOERROR);
 		}
 		if (ncur) {
 			pcur = ncur;
 			ncur = NULL;
 		}
 	} while (nbno != NULLFSBLOCK);
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 	*stat = i;
 	return 0;
 error0:
 	XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 	return error;
 }
 /*
  * Log fields from the btree block header.
  */
 void
 xfs_bmbt_log_block(
 	xfs_btree_cur_t		*cur,
 	xfs_buf_t		*bp,
 	int			fields)
 {
 	int			first;
 	int			last;
 	xfs_trans_t		*tp;
 	static const short	offsets[] = {
 		offsetof(xfs_bmbt_block_t, bb_magic),
 		offsetof(xfs_bmbt_block_t, bb_level),
 		offsetof(xfs_bmbt_block_t, bb_numrecs),
 		offsetof(xfs_bmbt_block_t, bb_leftsib),
 		offsetof(xfs_bmbt_block_t, bb_rightsib),
 		sizeof(xfs_bmbt_block_t)
 	};
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGBI(cur, bp, fields);
 	tp = cur->bc_tp;
 	if (bp) {
 		xfs_btree_offsets(fields, offsets, XFS_BB_NUM_BITS, &first,
 				  &last);
 		xfs_trans_log_buf(tp, bp, first, last);
 	} else
 		xfs_trans_log_inode(tp, cur->bc_private.b.ip,
 			XFS_ILOG_FBROOT(cur->bc_private.b.whichfork));
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 }
 /*
  * Log record values from the btree block.
  */
 void
 xfs_bmbt_log_recs(
 	xfs_btree_cur_t		*cur,
 	xfs_buf_t		*bp,
 	int			rfirst,
 	int			rlast)
 {
 	xfs_bmbt_block_t	*block;
 	int			first;
 	int			last;
 	xfs_bmbt_rec_t		*rp;
 	xfs_trans_t		*tp;
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	XFS_BMBT_TRACE_ARGBII(cur, bp, rfirst, rlast);
 	ASSERT(bp);
 	tp = cur->bc_tp;
 	block = XFS_BUF_TO_BMBT_BLOCK(bp);
 	rp = XFS_BMAP_REC_DADDR(block, 1, cur);
 	first = (int)((xfs_caddr_t)&rp[rfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&rp[rlast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(tp, bp, first, last);
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 }
 /*
  * Give the bmap btree a new root block.  Copy the old broot contents
  * down into a real block and make the broot point to it.
  */
 int						/* error */
 xfs_bmbt_newroot(
 	xfs_btree_cur_t		*cur,		/* btree cursor */
 	int			*logflags,	/* logging flags for inode */
 	int			*stat)		/* return status - 0 fail */
 {
 	xfs_alloc_arg_t		args;		/* allocation arguments */
 	xfs_bmbt_block_t	*block;		/* bmap btree block */
 	xfs_buf_t		*bp;		/* buffer for block */
 	xfs_bmbt_block_t	*cblock;	/* child btree block */
 	xfs_bmbt_key_t		*ckp;		/* child key pointer */
 	xfs_bmbt_ptr_t		*cpp;		/* child ptr pointer */
 	int			error;		/* error return code */
 #ifdef DEBUG
 	int			i;		/* loop counter */
 #endif
 	xfs_bmbt_key_t		*kp;		/* pointer to bmap btree key */
 	int			level;		/* btree level */
 	xfs_bmbt_ptr_t		*pp;		/* pointer to bmap block addr */
 	XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
 	level = cur->bc_nlevels - 1;
 	block = xfs_bmbt_get_block(cur, level, &bp);
 	/*
 	 * Copy the root into a real block.
 	 */
 	args.mp = cur->bc_mp;
 	pp = XFS_BMAP_PTR_IADDR(block, 1, cur);
 	args.tp = cur->bc_tp;
 	args.fsbno = cur->bc_private.b.firstblock;
 	args.mod = args.minleft = 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;
 	args.firstblock = args.fsbno;
 	if (args.fsbno == NULLFSBLOCK) {
 #ifdef DEBUG
 		if ((error = xfs_btree_check_lptr_disk(cur, *pp, level))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			return error;
 		}
 #endif
 		args.fsbno = be64_to_cpu(*pp);
 		args.type = XFS_ALLOCTYPE_START_BNO;
 	} else if (cur->bc_private.b.flist->xbf_low)
 		args.type = XFS_ALLOCTYPE_START_BNO;
 	else
 		args.type = XFS_ALLOCTYPE_NEAR_BNO;
 	if ((error = xfs_alloc_vextent(&args))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		return error;
 	}
 	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_MOD_DQUOT_BYINO(args.mp, args.tp, cur->bc_private.b.ip,
 			  XFS_TRANS_DQ_BCOUNT, 1L);
 	bp = xfs_btree_get_bufl(args.mp, cur->bc_tp, args.fsbno, 0);
 	cblock = XFS_BUF_TO_BMBT_BLOCK(bp);
 	*cblock = *block;
 	be16_add_cpu(&block->bb_level, 1);
 	block->bb_numrecs = cpu_to_be16(1);
 	cur->bc_nlevels++;
 	cur->bc_ptrs[level + 1] = 1;
 	kp = XFS_BMAP_KEY_IADDR(block, 1, cur);
 	ckp = XFS_BMAP_KEY_IADDR(cblock, 1, cur);
 	memcpy(ckp, kp, be16_to_cpu(cblock->bb_numrecs) * sizeof(*kp));
 	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, pp[i], level))) {
 			XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 			return error;
 		}
 	}
 #endif
 	memcpy(cpp, pp, be16_to_cpu(cblock->bb_numrecs) * sizeof(*pp));
 #ifdef DEBUG
 	if ((error = xfs_btree_check_lptr(cur, args.fsbno, level))) {
 		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
 		return error;
 	}
 #endif
 	*pp = cpu_to_be64(args.fsbno);
 	xfs_iroot_realloc(cur->bc_private.b.ip, 1 - be16_to_cpu(cblock->bb_numrecs),
 		cur->bc_private.b.whichfork);
 	xfs_btree_setbuf(cur, level, bp);
 	/*
 	 * Do all this logging at the end so that
 	 * the root is at the right level.
 	 */
 	xfs_bmbt_log_block(cur, bp, XFS_BB_ALL_BITS);
 	xfs_bmbt_log_keys(cur, bp, 1, be16_to_cpu(cblock->bb_numrecs));
 	xfs_bmbt_log_ptrs(cur, bp, 1, be16_to_cpu(cblock->bb_numrecs));
 	XFS_BMBT_TRACE_CURSOR(cur, EXIT);
 	*logflags |=
 		XFS_ILOG_CORE | XFS_ILOG_FBROOT(cur->bc_private.b.whichfork);
 	*stat = 1;
 	return 0;
 }
 /*
  * Set all the fields in a bmap extent record from the arguments.
  */
 void
 xfs_bmbt_set_allf(
 	xfs_bmbt_rec_host_t	*r,
 	xfs_fileoff_t		startoff,
 	xfs_fsblock_t		startblock,
 	xfs_filblks_t		blockcount,
 	xfs_exntst_t		state)
 {
 	int		extent_flag = (state == XFS_EXT_NORM) ? 0 : 1;
 	ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN);
 	ASSERT((startoff & XFS_MASK64HI(64-BMBT_STARTOFF_BITLEN)) == 0);
 	ASSERT((blockcount & XFS_MASK64HI(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
 #if XFS_BIG_BLKNOS
 	ASSERT((startblock & XFS_MASK64HI(64-BMBT_STARTBLOCK_BITLEN)) == 0);
 	r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
 		((xfs_bmbt_rec_base_t)startoff << 9) |
 		((xfs_bmbt_rec_base_t)startblock >> 43);
 	r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
 		((xfs_bmbt_rec_base_t)blockcount &
 		(xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
 #else	/* !XFS_BIG_BLKNOS */
 	if (ISNULLSTARTBLOCK(startblock)) {
 		r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
 			((xfs_bmbt_rec_base_t)startoff << 9) |
 			 (xfs_bmbt_rec_base_t)XFS_MASK64LO(9);
 		r->l1 = XFS_MASK64HI(11) |
 			  ((xfs_bmbt_rec_base_t)startblock << 21) |
 			  ((xfs_bmbt_rec_base_t)blockcount &
 			   (xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
 	} else {
 		r->l0 = ((xfs_bmbt_rec_base_t)extent_flag << 63) |
 			((xfs_bmbt_rec_base_t)startoff << 9);
 		r->l1 = ((xfs_bmbt_rec_base_t)startblock << 21) |
 			 ((xfs_bmbt_rec_base_t)blockcount &
 			 (xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
 	}
 #endif	/* XFS_BIG_BLKNOS */
 }
 /*
  * Set all the fields in a bmap extent record from the uncompressed form.
  */
 void
 xfs_bmbt_set_all(
 	xfs_bmbt_rec_host_t *r,
 	xfs_bmbt_irec_t	*s)
 {
 	xfs_bmbt_set_allf(r, s->br_startoff, s->br_startblock,
 			     s->br_blockcount, s->br_state);
 }
 /*
  * Set all the fields in a disk format bmap extent record from the arguments.
  */
 void
 xfs_bmbt_disk_set_allf(
 	xfs_bmbt_rec_t		*r,
 	xfs_fileoff_t		startoff,
 	xfs_fsblock_t		startblock,
 	xfs_filblks_t		blockcount,
 	xfs_exntst_t		state)
 {
 	int			extent_flag = (state == XFS_EXT_NORM) ? 0 : 1;
 	ASSERT(state == XFS_EXT_NORM || state == XFS_EXT_UNWRITTEN);
 	ASSERT((startoff & XFS_MASK64HI(64-BMBT_STARTOFF_BITLEN)) == 0);
 	ASSERT((blockcount & XFS_MASK64HI(64-BMBT_BLOCKCOUNT_BITLEN)) == 0);
 #if XFS_BIG_BLKNOS
 	ASSERT((startblock & XFS_MASK64HI(64-BMBT_STARTBLOCK_BITLEN)) == 0);
 	r->l0 = cpu_to_be64(
 		((xfs_bmbt_rec_base_t)extent_flag << 63) |
 		 ((xfs_bmbt_rec_base_t)startoff << 9) |
 		 ((xfs_bmbt_rec_base_t)startblock >> 43));
 	r->l1 = cpu_to_be64(
 		((xfs_bmbt_rec_base_t)startblock << 21) |
 		 ((xfs_bmbt_rec_base_t)blockcount &
 		  (xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
 #else	/* !XFS_BIG_BLKNOS */
 	if (ISNULLSTARTBLOCK(startblock)) {
 		r->l0 = cpu_to_be64(
 			((xfs_bmbt_rec_base_t)extent_flag << 63) |
 			 ((xfs_bmbt_rec_base_t)startoff << 9) |
 			  (xfs_bmbt_rec_base_t)XFS_MASK64LO(9));
 		r->l1 = cpu_to_be64(XFS_MASK64HI(11) |
 			  ((xfs_bmbt_rec_base_t)startblock << 21) |
 			  ((xfs_bmbt_rec_base_t)blockcount &
 			   (xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
 	} else {
 		r->l0 = cpu_to_be64(
 			((xfs_bmbt_rec_base_t)extent_flag << 63) |
 			 ((xfs_bmbt_rec_base_t)startoff << 9));
 		r->l1 = cpu_to_be64(
 			((xfs_bmbt_rec_base_t)startblock << 21) |
 			 ((xfs_bmbt_rec_base_t)blockcount &
 			  (xfs_bmbt_rec_base_t)XFS_MASK64LO(21)));
 	}
 #endif	/* XFS_BIG_BLKNOS */
 }
 /*
  * Set all the fields in a bmap extent record from the uncompressed form.
  */
 void
 xfs_bmbt_disk_set_all(
 	xfs_bmbt_rec_t	*r,
 	xfs_bmbt_irec_t *s)
 {
 	xfs_bmbt_disk_set_allf(r, s->br_startoff, s->br_startblock,
 				  s->br_blockcount, s->br_state);
 }
 /*
  * Set the blockcount field in a bmap extent record.
  */
 void
 xfs_bmbt_set_blockcount(
 	xfs_bmbt_rec_host_t *r,
 	xfs_filblks_t	v)
 {
 	ASSERT((v & XFS_MASK64HI(43)) == 0);
 	r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)XFS_MASK64HI(43)) |
 		  (xfs_bmbt_rec_base_t)(v & XFS_MASK64LO(21));
 }
 /*
  * Set the startblock field in a bmap extent record.
  */
 void
 xfs_bmbt_set_startblock(
 	xfs_bmbt_rec_host_t *r,
 	xfs_fsblock_t	v)
 {
 #if XFS_BIG_BLKNOS
 	ASSERT((v & XFS_MASK64HI(12)) == 0);
 	r->l0 = (r->l0 & (xfs_bmbt_rec_base_t)XFS_MASK64HI(55)) |
 		  (xfs_bmbt_rec_base_t)(v >> 43);
 	r->l1 = (r->l1 & (xfs_bmbt_rec_base_t)XFS_MASK64LO(21)) |
 		  (xfs_bmbt_rec_base_t)(v << 21);
 #else	/* !XFS_BIG_BLKNOS */
 	if (ISNULLSTARTBLOCK(v)) {
 		r->l0 |= (xfs_bmbt_rec_base_t)XFS_MASK64LO(9);
 		r->l1 = (xfs_bmbt_rec_base_t)XFS_MASK64HI(11) |
 			  ((xfs_bmbt_rec_base_t)v << 21) |
 			  (r->l1 & (xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
 	} else {
 		r->l0 &= ~(xfs_bmbt_rec_base_t)XFS_MASK64LO(9);
 		r->l1 = ((xfs_bmbt_rec_base_t)v << 21) |
 			  (r->l1 & (xfs_bmbt_rec_base_t)XFS_MASK64LO(21));
 	}
 #endif	/* XFS_BIG_BLKNOS */
 }
 /*
  * Set the startoff field in a bmap extent record.
  */
 void
 xfs_bmbt_set_startoff(
 	xfs_bmbt_rec_host_t *r,
 	xfs_fileoff_t	v)
 {
 	ASSERT((v & XFS_MASK64HI(9)) == 0);
 	r->l0 = (r->l0 & (xfs_bmbt_rec_base_t) XFS_MASK64HI(1)) |
 		((xfs_bmbt_rec_base_t)v << 9) |
 		  (r->l0 & (xfs_bmbt_rec_base_t)XFS_MASK64LO(9));
 }
 /*
  * Set the extent state field in a bmap extent record.
  */
 void
 xfs_bmbt_set_state(
 	xfs_bmbt_rec_host_t *r,
 	xfs_exntst_t	v)
 {
 	ASSERT(v == XFS_EXT_NORM || v == XFS_EXT_UNWRITTEN);
 	if (v == XFS_EXT_NORM)
 		r->l0 &= XFS_MASK64LO(64 - BMBT_EXNTFLAG_BITLEN);
 	else
 		r->l0 |= XFS_MASK64HI(BMBT_EXNTFLAG_BITLEN);
 }
 /*
  * Convert in-memory form of btree root to on-disk form.
  */
 void
 xfs_bmbt_to_bmdr(
 	xfs_bmbt_block_t	*rblock,
 	int			rblocklen,
 	xfs_bmdr_block_t	*dblock,
 	int			dblocklen)
 {
 	int			dmxr;
 	xfs_bmbt_key_t		*fkp;
 	__be64			*fpp;
 	xfs_bmbt_key_t		*tkp;
 	__be64			*tpp;
 	ASSERT(be32_to_cpu(rblock->bb_magic) == XFS_BMAP_MAGIC);
 	ASSERT(be64_to_cpu(rblock->bb_leftsib) == NULLDFSBNO);
 	ASSERT(be64_to_cpu(rblock->bb_rightsib) == NULLDFSBNO);
 	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);
 	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);
 	tpp = XFS_BTREE_PTR_ADDR(xfs_bmdr, dblock, 1, dmxr);
 	dmxr = be16_to_cpu(dblock->bb_numrecs);
 	memcpy(tkp, fkp, sizeof(*fkp) * dmxr);
 	memcpy(tpp, fpp, sizeof(*fpp) * dmxr);
 }
 /*
  * Check extent records, which have just been read, for
  * any bit in the extent flag field. ASSERT on debug
  * kernels, as this condition should not occur.
  * Return an error condition (1) if any flags found,
  * otherwise return 0.
  */
 int
 xfs_check_nostate_extents(
 	xfs_ifork_t		*ifp,
 	xfs_extnum_t		idx,
 	xfs_extnum_t		num)
 {
 	for (; num > 0; num--, idx++) {
 		xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, idx);
 		if ((ep->l0 >>
 		     (64 - BMBT_EXNTFLAG_BITLEN)) != 0) {
 			ASSERT(0);
 			return 1;
 		}
 	}
 	return 0;
 }
 STATIC struct xfs_btree_cur *
 xfs_bmbt_dup_cursor(
 	struct xfs_btree_cur	*cur)
 {
 	struct xfs_btree_cur	*new;
 	new = xfs_bmbt_init_cursor(cur->bc_mp, cur->bc_tp,
 			cur->bc_private.b.ip, cur->bc_private.b.whichfork);
 	/*
 	 * Copy the firstblock, flist, and flags values,
 	 * since init cursor doesn't get them.
 	 */
 	new->bc_private.b.firstblock = cur->bc_private.b.firstblock;
 	new->bc_private.b.flist = cur->bc_private.b.flist;
 	new->bc_private.b.flags = cur->bc_private.b.flags;
 	return new;
 }
 STATIC int
 xfs_bmbt_get_maxrecs(
 	struct xfs_btree_cur	*cur,
 	int			level)
 {
 	return XFS_BMAP_BLOCK_IMAXRECS(level, cur);
 }
 STATIC void
 xfs_bmbt_init_key_from_rec(
 	union xfs_btree_key	*key,
 	union xfs_btree_rec	*rec)
 {
 	key->bmbt.br_startoff =
 		cpu_to_be64(xfs_bmbt_disk_get_startoff(&rec->bmbt));
 }
 STATIC void
 xfs_bmbt_init_ptr_from_cur(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr)
 {
 	ptr->l = 0;
 }
 STATIC __int64_t
 xfs_bmbt_key_diff(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key)
 {
 	return (__int64_t)be64_to_cpu(key->bmbt.br_startoff) -
 				      cur->bc_rec.b.br_startoff;
 }
 #ifdef XFS_BTREE_TRACE
 ktrace_t	*xfs_bmbt_trace_buf;
 STATIC void
 xfs_bmbt_trace_enter(
 	struct xfs_btree_cur	*cur,
 	const char		*func,
 	char			*s,
 	int			type,
 	int			line,
 	__psunsigned_t		a0,
 	__psunsigned_t		a1,
 	__psunsigned_t		a2,
 	__psunsigned_t		a3,
 	__psunsigned_t		a4,
 	__psunsigned_t		a5,
 	__psunsigned_t		a6,
 	__psunsigned_t		a7,
 	__psunsigned_t		a8,
 	__psunsigned_t		a9,
 	__psunsigned_t		a10)
 {
 	struct xfs_inode	*ip = cur->bc_private.b.ip;
 	int			whichfork = cur->bc_private.b.whichfork;
 	ktrace_enter(xfs_bmbt_trace_buf,
 		(void *)((__psint_t)type | (whichfork << 8) | (line << 16)),
 		(void *)func, (void *)s, (void *)ip, (void *)cur,
 		(void *)a0, (void *)a1, (void *)a2, (void *)a3,
 		(void *)a4, (void *)a5, (void *)a6, (void *)a7,
 		(void *)a8, (void *)a9, (void *)a10);
 	ktrace_enter(ip->i_btrace,
 		(void *)((__psint_t)type | (whichfork << 8) | (line << 16)),
 		(void *)func, (void *)s, (void *)ip, (void *)cur,
 		(void *)a0, (void *)a1, (void *)a2, (void *)a3,
 		(void *)a4, (void *)a5, (void *)a6, (void *)a7,
 		(void *)a8, (void *)a9, (void *)a10);
 }
 STATIC void
 xfs_bmbt_trace_cursor(
 	struct xfs_btree_cur	*cur,
 	__uint32_t		*s0,
 	__uint64_t		*l0,
 	__uint64_t		*l1)
 {
 	struct xfs_bmbt_rec_host r;
 	xfs_bmbt_set_all(&r, &cur->bc_rec.b);
 	*s0 = (cur->bc_nlevels << 24) |
 	      (cur->bc_private.b.flags << 16) |
 	       cur->bc_private.b.allocated;
 	*l0 = r.l0;
 	*l1 = r.l1;
 }
 STATIC void
 xfs_bmbt_trace_key(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key,
 	__uint64_t		*l0,
 	__uint64_t		*l1)
 {
 	*l0 = be64_to_cpu(key->bmbt.br_startoff);
 	*l1 = 0;
 }
 STATIC void
 xfs_bmbt_trace_record(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_rec	*rec,
 	__uint64_t		*l0,
 	__uint64_t		*l1,
 	__uint64_t		*l2)
 {
 	struct xfs_bmbt_irec	irec;
 	xfs_bmbt_disk_get_all(&rec->bmbt, &irec);
 	*l0 = irec.br_startoff;
 	*l1 = irec.br_startblock;
 	*l2 = irec.br_blockcount;
 }
 #endif /* XFS_BTREE_TRACE */
 static const struct xfs_btree_ops xfs_bmbt_ops = {
 	.rec_len		= sizeof(xfs_bmbt_rec_t),
 	.key_len		= sizeof(xfs_bmbt_key_t),
 	.dup_cursor		= xfs_bmbt_dup_cursor,
 	.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,
 	.key_diff		= xfs_bmbt_key_diff,
 #ifdef XFS_BTREE_TRACE
 	.trace_enter		= xfs_bmbt_trace_enter,
 	.trace_cursor		= xfs_bmbt_trace_cursor,
 	.trace_key		= xfs_bmbt_trace_key,
 	.trace_record		= xfs_bmbt_trace_record,
 #endif
 };
 /*
  * Allocate a new bmap btree cursor.
  */
 struct xfs_btree_cur *				/* new bmap btree cursor */
 xfs_bmbt_init_cursor(
 	struct xfs_mount	*mp,		/* file system mount point */
 	struct xfs_trans	*tp,		/* transaction pointer */
 	struct xfs_inode	*ip,		/* inode owning the btree */
 	int			whichfork)	/* data or attr fork */
 {
 	struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, whichfork);
 	struct xfs_btree_cur	*cur;
 	cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
 	cur->bc_tp = tp;
 	cur->bc_mp = mp;
 	cur->bc_nlevels = be16_to_cpu(ifp->if_broot->bb_level) + 1;
 	cur->bc_btnum = XFS_BTNUM_BMAP;
 	cur->bc_blocklog = mp->m_sb.sb_blocklog;
 	cur->bc_ops = &xfs_bmbt_ops;
 	cur->bc_flags = XFS_BTREE_LONG_PTRS | XFS_BTREE_ROOT_IN_INODE;
 	cur->bc_private.b.forksize = XFS_IFORK_SIZE(ip, whichfork);
 	cur->bc_private.b.ip = ip;
 	cur->bc_private.b.firstblock = NULLFSBLOCK;
 	cur->bc_private.b.flist = NULL;
 	cur->bc_private.b.allocated = 0;
 	cur->bc_private.b.flags = 0;
 	cur->bc_private.b.whichfork = whichfork;
 	return cur;
 }

fs/xfs/xfs_btree.c

Diff comments View file @ 687b890

 /*
  * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
 #include "xfs_bit.h"
 #include "xfs_log.h"
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
 #include "xfs_btree.h"
 #include "xfs_btree_trace.h"
 #include "xfs_ialloc.h"
 #include "xfs_error.h"
 /*
  * Cursor allocation zone.
  */
 kmem_zone_t	*xfs_btree_cur_zone;
 /*
  * Btree magic numbers.
  */
 const __uint32_t xfs_magics[XFS_BTNUM_MAX] = {
 	XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, XFS_BMAP_MAGIC, XFS_IBT_MAGIC
 };
 /*
  * External routines.
  */
 #ifdef DEBUG
 /*
  * Debug routine: check that keys are in the right order.
  */
 void
 xfs_btree_check_key(
 	xfs_btnum_t	btnum,		/* btree identifier */
 	void		*ak1,		/* pointer to left (lower) key */
 	void		*ak2)		/* pointer to right (higher) key */
 {
 	switch (btnum) {
 	case XFS_BTNUM_BNO: {
 		xfs_alloc_key_t	*k1;
 		xfs_alloc_key_t	*k2;
 		k1 = ak1;
 		k2 = ak2;
 		ASSERT(be32_to_cpu(k1->ar_startblock) < be32_to_cpu(k2->ar_startblock));
 		break;
 	    }
 	case XFS_BTNUM_CNT: {
 		xfs_alloc_key_t	*k1;
 		xfs_alloc_key_t	*k2;
 		k1 = ak1;
 		k2 = ak2;
 		ASSERT(be32_to_cpu(k1->ar_blockcount) < be32_to_cpu(k2->ar_blockcount) ||
 		       (k1->ar_blockcount == k2->ar_blockcount &&
 			be32_to_cpu(k1->ar_startblock) < be32_to_cpu(k2->ar_startblock)));
 		break;
 	    }
 	case XFS_BTNUM_BMAP: {
 		xfs_bmbt_key_t	*k1;
 		xfs_bmbt_key_t	*k2;
 		k1 = ak1;
 		k2 = ak2;
 		ASSERT(be64_to_cpu(k1->br_startoff) < be64_to_cpu(k2->br_startoff));
 		break;
 	    }
 	case XFS_BTNUM_INO: {
 		xfs_inobt_key_t	*k1;
 		xfs_inobt_key_t	*k2;
 		k1 = ak1;
 		k2 = ak2;
 		ASSERT(be32_to_cpu(k1->ir_startino) < be32_to_cpu(k2->ir_startino));
 		break;
 	    }
 	default:
 		ASSERT(0);
 	}
 }
 /*
  * Debug routine: check that records are in the right order.
  */
 void
 xfs_btree_check_rec(
 	xfs_btnum_t	btnum,		/* btree identifier */
 	void		*ar1,		/* pointer to left (lower) record */
 	void		*ar2)		/* pointer to right (higher) record */
 {
 	switch (btnum) {
 	case XFS_BTNUM_BNO: {
 		xfs_alloc_rec_t	*r1;
 		xfs_alloc_rec_t	*r2;
 		r1 = ar1;
 		r2 = ar2;
 		ASSERT(be32_to_cpu(r1->ar_startblock) +
 		       be32_to_cpu(r1->ar_blockcount) <=
 		       be32_to_cpu(r2->ar_startblock));
 		break;
 	    }
 	case XFS_BTNUM_CNT: {
 		xfs_alloc_rec_t	*r1;
 		xfs_alloc_rec_t	*r2;
 		r1 = ar1;
 		r2 = ar2;
 		ASSERT(be32_to_cpu(r1->ar_blockcount) < be32_to_cpu(r2->ar_blockcount) ||
 		       (r1->ar_blockcount == r2->ar_blockcount &&
 			be32_to_cpu(r1->ar_startblock) < be32_to_cpu(r2->ar_startblock)));
 		break;
 	    }
 	case XFS_BTNUM_BMAP: {
 		xfs_bmbt_rec_t	*r1;
 		xfs_bmbt_rec_t	*r2;
 		r1 = ar1;
 		r2 = ar2;
 		ASSERT(xfs_bmbt_disk_get_startoff(r1) +
 		       xfs_bmbt_disk_get_blockcount(r1) <=
 		       xfs_bmbt_disk_get_startoff(r2));
 		break;
 	    }
 	case XFS_BTNUM_INO: {
 		xfs_inobt_rec_t	*r1;
 		xfs_inobt_rec_t	*r2;
 		r1 = ar1;
 		r2 = ar2;
 		ASSERT(be32_to_cpu(r1->ir_startino) + XFS_INODES_PER_CHUNK <=
 		       be32_to_cpu(r2->ir_startino));
 		break;
 	    }
 	default:
 		ASSERT(0);
 	}
 }
 #endif	/* DEBUG */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lblock(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_lblock	*block,	/* btree long form block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp)	/* buffer for block, if any */
 {
 	int			lblock_ok; /* block passes checks */
 	struct xfs_mount	*mp;	/* file system mount point */
 	mp = cur->bc_mp;
 	lblock_ok =
 		be32_to_cpu(block->bb_magic) == xfs_magics[cur->bc_btnum] &&
 		be16_to_cpu(block->bb_level) == level &&
 		be16_to_cpu(block->bb_numrecs) <=
 			cur->bc_ops->get_maxrecs(cur, level) &&
 		block->bb_leftsib &&
 		(be64_to_cpu(block->bb_leftsib) == NULLDFSBNO ||
 		 XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_leftsib))) &&
 		block->bb_rightsib &&
 		(be64_to_cpu(block->bb_rightsib) == NULLDFSBNO ||
 		 XFS_FSB_SANITY_CHECK(mp, be64_to_cpu(block->bb_rightsib)));
 	if (unlikely(XFS_TEST_ERROR(!lblock_ok, mp,
 			XFS_ERRTAG_BTREE_CHECK_LBLOCK,
 			XFS_RANDOM_BTREE_CHECK_LBLOCK))) {
 		if (bp)
 			xfs_buftrace("LBTREE ERROR", bp);
 		XFS_ERROR_REPORT("xfs_btree_check_lblock", XFS_ERRLEVEL_LOW,
 				 mp);
 		return XFS_ERROR(EFSCORRUPTED);
 	}
 	return 0;
 }
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_sblock(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_sblock	*block,	/* btree short form block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp)	/* buffer containing block */
 {
 	struct xfs_buf		*agbp;	/* buffer for ag. freespace struct */
 	struct xfs_agf		*agf;	/* ag. freespace structure */
 	xfs_agblock_t		agflen;	/* native ag. freespace length */
 	int			sblock_ok; /* block passes checks */
 	agbp = cur->bc_private.a.agbp;
 	agf = XFS_BUF_TO_AGF(agbp);
 	agflen = be32_to_cpu(agf->agf_length);
 	sblock_ok =
 		be32_to_cpu(block->bb_magic) == xfs_magics[cur->bc_btnum] &&
 		be16_to_cpu(block->bb_level) == level &&
 		be16_to_cpu(block->bb_numrecs) <=
 			cur->bc_ops->get_maxrecs(cur, level) &&
 		(be32_to_cpu(block->bb_leftsib) == NULLAGBLOCK ||
 		 be32_to_cpu(block->bb_leftsib) < agflen) &&
 		block->bb_leftsib &&
 		(be32_to_cpu(block->bb_rightsib) == NULLAGBLOCK ||
 		 be32_to_cpu(block->bb_rightsib) < agflen) &&
 		block->bb_rightsib;
 	if (unlikely(XFS_TEST_ERROR(!sblock_ok, cur->bc_mp,
 			XFS_ERRTAG_BTREE_CHECK_SBLOCK,
 			XFS_RANDOM_BTREE_CHECK_SBLOCK))) {
 		if (bp)
 			xfs_buftrace("SBTREE ERROR", bp);
 		XFS_ERROR_REPORT("xfs_btree_check_sblock", XFS_ERRLEVEL_LOW,
 				 cur->bc_mp);
 		return XFS_ERROR(EFSCORRUPTED);
 	}
 	return 0;
 }
 /*
  * Debug routine: check that block header is ok.
  */
 int
 xfs_btree_check_block(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_block	*block,	/* generic btree block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp)	/* buffer containing block, if any */
 {
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
 		return xfs_btree_check_lblock(cur,
 				(struct xfs_btree_lblock *)block, level, bp);
 	} else {
 		return xfs_btree_check_sblock(cur,
 				(struct xfs_btree_sblock *)block, level, bp);
 	}
 }
 /*
  * Check that (long) pointer is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	xfs_dfsbno_t		bno,	/* btree block disk address */
 	int			level)	/* btree block level */
 {
 	XFS_WANT_CORRUPTED_RETURN(
 		level > 0 &&
 		bno != NULLDFSBNO &&
 		XFS_FSB_SANITY_CHECK(cur->bc_mp, bno));
 	return 0;
 }
 /*
  * Check that (short) pointer is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_sptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	xfs_agblock_t		bno,	/* btree block disk address */
 	int			level)	/* btree block level */
 {
 	xfs_agblock_t		agblocks = cur->bc_mp->m_sb.sb_agblocks;
 	XFS_WANT_CORRUPTED_RETURN(
 		level > 0 &&
 		bno != NULLAGBLOCK &&
 		bno != 0 &&
 		bno < agblocks);
 	return 0;
 }
 /*
  * Check that block ptr is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_ptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	union xfs_btree_ptr	*ptr,	/* btree block disk address */
 	int			index,	/* offset from ptr to check */
 	int			level)	/* btree block level */
 {
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
 		return xfs_btree_check_lptr(cur,
 				be64_to_cpu((&ptr->l)[index]), level);
 	} else {
 		return xfs_btree_check_sptr(cur,
 				be32_to_cpu((&ptr->s)[index]), level);
 	}
 }
 /*
  * Delete the btree cursor.
  */
 void
 xfs_btree_del_cursor(
 	xfs_btree_cur_t	*cur,		/* btree cursor */
 	int		error)		/* del because of error */
 {
 	int		i;		/* btree level */
 	/*
 	 * Clear the buffer pointers, and release the buffers.
 	 * If we're doing this in the face of an error, we
 	 * need to make sure to inspect all of the entries
 	 * in the bc_bufs array for buffers to be unlocked.
 	 * This is because some of the btree code works from
 	 * level n down to 0, and if we get an error along
 	 * the way we won't have initialized all the entries
 	 * down to 0.
 	 */
 	for (i = 0; i < cur->bc_nlevels; i++) {
 		if (cur->bc_bufs[i])
 			xfs_btree_setbuf(cur, i, NULL);
 		else if (!error)
 			break;
 	}
 	/*
 	 * Can't free a bmap cursor without having dealt with the
 	 * allocated indirect blocks' accounting.
 	 */
 	ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP ||
 	       cur->bc_private.b.allocated == 0);
 	/*
 	 * Free the cursor.
 	 */
 	kmem_zone_free(xfs_btree_cur_zone, cur);
 }
 /*
  * Duplicate the btree cursor.
  * Allocate a new one, copy the record, re-get the buffers.
  */
 int					/* error */
 xfs_btree_dup_cursor(
 	xfs_btree_cur_t	*cur,		/* input cursor */
 	xfs_btree_cur_t	**ncur)		/* output cursor */
 {
 	xfs_buf_t	*bp;		/* btree block's buffer pointer */
 	int		error;		/* error return value */
 	int		i;		/* level number of btree block */
 	xfs_mount_t	*mp;		/* mount structure for filesystem */
 	xfs_btree_cur_t	*new;		/* new cursor value */
 	xfs_trans_t	*tp;		/* transaction pointer, can be NULL */
 	tp = cur->bc_tp;
 	mp = cur->bc_mp;
 	/*
 	 * Allocate a new cursor like the old one.
 	 */
 	new = cur->bc_ops->dup_cursor(cur);
 	/*
 	 * Copy the record currently in the cursor.
 	 */
 	new->bc_rec = cur->bc_rec;
 	/*
 	 * For each level current, re-get the buffer and copy the ptr value.
 	 */
 	for (i = 0; i < new->bc_nlevels; i++) {
 		new->bc_ptrs[i] = cur->bc_ptrs[i];
 		new->bc_ra[i] = cur->bc_ra[i];
 		if ((bp = cur->bc_bufs[i])) {
 			if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
 				XFS_BUF_ADDR(bp), mp->m_bsize, 0, &bp))) {
 				xfs_btree_del_cursor(new, error);
 				*ncur = NULL;
 				return error;
 			}
 			new->bc_bufs[i] = bp;
 			ASSERT(bp);
 			ASSERT(!XFS_BUF_GETERROR(bp));
 		} else
 			new->bc_bufs[i] = NULL;
 	}
 	*ncur = new;
 	return 0;
 }
 /*
  * XFS btree block layout and addressing:
  *
  * There are two types of blocks in the btree: leaf and non-leaf blocks.
  *
  * The leaf record start with a header then followed by records containing
  * the values.  A non-leaf block also starts with the same header, and
  * then first contains lookup keys followed by an equal number of pointers
  * to the btree blocks at the previous level.
  *
  *		+--------+-------+-------+-------+-------+-------+-------+
  * Leaf:	| header | rec 1 | rec 2 | rec 3 | rec 4 | rec 5 | rec N |
  *		+--------+-------+-------+-------+-------+-------+-------+
  *
  *		+--------+-------+-------+-------+-------+-------+-------+
  * Non-Leaf:	| header | key 1 | key 2 | key N | ptr 1 | ptr 2 | ptr N |
  *		+--------+-------+-------+-------+-------+-------+-------+
  *
  * The header is called struct xfs_btree_block for reasons better left unknown
  * and comes in different versions for short (32bit) and long (64bit) block
  * pointers.  The record and key structures are defined by the btree instances
  * and opaque to the btree core.  The block pointers are simple disk endian
  * integers, available in a short (32bit) and long (64bit) variant.
  *
  * The helpers below calculate the offset of a given record, key or pointer
  * into a btree block (xfs_btree_*_offset) or return a pointer to the given
  * record, key or pointer (xfs_btree_*_addr).  Note that all addressing
  * inside the btree block is done using indices starting at one, not zero!
  */
 /*
  * Return size of the btree block header for this btree instance.
  */
 static inline size_t xfs_btree_block_len(struct xfs_btree_cur *cur)
 {
 	return (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
 		sizeof(struct xfs_btree_lblock) :
 		sizeof(struct xfs_btree_sblock);
 }
 /*
  * Return size of btree block pointers for this btree instance.
  */
 static inline size_t xfs_btree_ptr_len(struct xfs_btree_cur *cur)
 {
 	return (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
 		sizeof(__be64) : sizeof(__be32);
 }
 /*
  * Calculate offset of the n-th record in a btree block.
  */
 STATIC size_t
 xfs_btree_rec_offset(
 	struct xfs_btree_cur	*cur,
 	int			n)
 {
 	return xfs_btree_block_len(cur) +
 		(n - 1) * cur->bc_ops->rec_len;
 }
 /*
  * Calculate offset of the n-th key in a btree block.
  */
 STATIC size_t
 xfs_btree_key_offset(
 	struct xfs_btree_cur	*cur,
 	int			n)
 {
 	return xfs_btree_block_len(cur) +
 		(n - 1) * cur->bc_ops->key_len;
 }
 /*
  * Calculate offset of the n-th block pointer in a btree block.
  */
 STATIC size_t
 xfs_btree_ptr_offset(
 	struct xfs_btree_cur	*cur,
 	int			n,
 	int			level)
 {
 	return xfs_btree_block_len(cur) +
 		cur->bc_ops->get_maxrecs(cur, level) * cur->bc_ops->key_len +
 		(n - 1) * xfs_btree_ptr_len(cur);
 }
 /*
  * Return a pointer to the n-th record in the btree block.
  */
 STATIC union xfs_btree_rec *
 xfs_btree_rec_addr(
 	struct xfs_btree_cur	*cur,
 	int			n,
 	struct xfs_btree_block	*block)
 {
 	return (union xfs_btree_rec *)
 		((char *)block + xfs_btree_rec_offset(cur, n));
 }
 /*
  * Return a pointer to the n-th key in the btree block.
  */
 STATIC union xfs_btree_key *
 xfs_btree_key_addr(
 	struct xfs_btree_cur	*cur,
 	int			n,
 	struct xfs_btree_block	*block)
 {
 	return (union xfs_btree_key *)
 		((char *)block + xfs_btree_key_offset(cur, n));
 }
 /*
  * Return a pointer to the n-th block pointer in the btree block.
  */
 STATIC union xfs_btree_ptr *
 xfs_btree_ptr_addr(
 	struct xfs_btree_cur	*cur,
 	int			n,
 	struct xfs_btree_block	*block)
 {
 	int			level = xfs_btree_get_level(block);
 	ASSERT(block->bb_level != 0);
 	return (union xfs_btree_ptr *)
 		((char *)block + xfs_btree_ptr_offset(cur, n, level));
 }
 /*
  * Get a the root block which is stored in the inode.
  *
  * For now this btree implementation assumes the btree root is always
  * stored in the if_broot field of an inode fork.
  */
 STATIC struct xfs_btree_block *
 xfs_btree_get_iroot(
        struct xfs_btree_cur    *cur)
 {
        struct xfs_ifork        *ifp;
        ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, cur->bc_private.b.whichfork);
        return (struct xfs_btree_block *)ifp->if_broot;
 }
 /*
  * Retrieve the block pointer from the cursor at the given level.
  * This may be an inode btree root or from a buffer.
  */
 STATIC struct xfs_btree_block *		/* generic btree block pointer */
 xfs_btree_get_block(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	int			level,	/* level in btree */
 	struct xfs_buf		**bpp)	/* buffer containing the block */
 {
 	if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
 	    (level == cur->bc_nlevels - 1)) {
 		*bpp = NULL;
 		return xfs_btree_get_iroot(cur);
 	}
 	*bpp = cur->bc_bufs[level];
 	return XFS_BUF_TO_BLOCK(*bpp);
 }
 /*
  * Get a buffer for the block, return it with no data read.
  * Long-form addressing.
  */
 xfs_buf_t *				/* buffer for fsbno */
 xfs_btree_get_bufl(
 	xfs_mount_t	*mp,		/* file system mount point */
 	xfs_trans_t	*tp,		/* transaction pointer */
 	xfs_fsblock_t	fsbno,		/* file system block number */
 	uint		lock)		/* lock flags for get_buf */
 {
 	xfs_buf_t	*bp;		/* buffer pointer (return value) */
 	xfs_daddr_t		d;		/* real disk block address */
 	ASSERT(fsbno != NULLFSBLOCK);
 	d = XFS_FSB_TO_DADDR(mp, fsbno);
 	bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
 	ASSERT(bp);
 	ASSERT(!XFS_BUF_GETERROR(bp));
 	return bp;
 }
 /*
  * Get a buffer for the block, return it with no data read.
  * Short-form addressing.
  */
 xfs_buf_t *				/* buffer for agno/agbno */
 xfs_btree_get_bufs(
 	xfs_mount_t	*mp,		/* file system mount point */
 	xfs_trans_t	*tp,		/* transaction pointer */
 	xfs_agnumber_t	agno,		/* allocation group number */
 	xfs_agblock_t	agbno,		/* allocation group block number */
 	uint		lock)		/* lock flags for get_buf */
 {
 	xfs_buf_t	*bp;		/* buffer pointer (return value) */
 	xfs_daddr_t		d;		/* real disk block address */
 	ASSERT(agno != NULLAGNUMBER);
 	ASSERT(agbno != NULLAGBLOCK);
 	d = XFS_AGB_TO_DADDR(mp, agno, agbno);
 	bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d, mp->m_bsize, lock);
 	ASSERT(bp);
 	ASSERT(!XFS_BUF_GETERROR(bp));
 	return bp;
 }
 /*
  * Check for the cursor referring to the last block at the given level.
  */
 int					/* 1=is last block, 0=not last block */
 xfs_btree_islastblock(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level)	/* level to check */
 {
 	xfs_btree_block_t	*block;	/* generic btree block pointer */
 	xfs_buf_t		*bp;	/* buffer containing block */
 	block = xfs_btree_get_block(cur, level, &bp);
 	xfs_btree_check_block(cur, block, level, bp);
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
 		return be64_to_cpu(block->bb_u.l.bb_rightsib) == NULLDFSBNO;
 	else
 		return be32_to_cpu(block->bb_u.s.bb_rightsib) == NULLAGBLOCK;
 }
 /*
  * Change the cursor to point to the first record at the given level.
  * Other levels are unaffected.
  */
 int					/* success=1, failure=0 */
 xfs_btree_firstrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level)	/* level to change */
 {
 	xfs_btree_block_t	*block;	/* generic btree block pointer */
 	xfs_buf_t		*bp;	/* buffer containing block */
 	/*
 	 * Get the block pointer for this level.
 	 */
 	block = xfs_btree_get_block(cur, level, &bp);
 	xfs_btree_check_block(cur, block, level, bp);
 	/*
 	 * It's empty, there is no such record.
 	 */
 	if (!block->bb_numrecs)
 		return 0;
 	/*
 	 * Set the ptr value to 1, that's the first record/key.
 	 */
 	cur->bc_ptrs[level] = 1;
 	return 1;
 }
 /*
  * Change the cursor to point to the last record in the current block
  * at the given level.  Other levels are unaffected.
  */
 int					/* success=1, failure=0 */
 xfs_btree_lastrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level)	/* level to change */
 {
 	xfs_btree_block_t	*block;	/* generic btree block pointer */
 	xfs_buf_t		*bp;	/* buffer containing block */
 	/*
 	 * Get the block pointer for this level.
 	 */
 	block = xfs_btree_get_block(cur, level, &bp);
 	xfs_btree_check_block(cur, block, level, bp);
 	/*
 	 * It's empty, there is no such record.
 	 */
 	if (!block->bb_numrecs)
 		return 0;
 	/*
 	 * Set the ptr value to numrecs, that's the last record/key.
 	 */
 	cur->bc_ptrs[level] = be16_to_cpu(block->bb_numrecs);
 	return 1;
 }
 /*
  * Compute first and last byte offsets for the fields given.
  * Interprets the offsets table, which contains struct field offsets.
  */
 void
 xfs_btree_offsets(
 	__int64_t	fields,		/* bitmask of fields */
 	const short	*offsets,	/* table of field offsets */
 	int		nbits,		/* number of bits to inspect */
 	int		*first,		/* output: first byte offset */
 	int		*last)		/* output: last byte offset */
 {
 	int		i;		/* current bit number */
 	__int64_t	imask;		/* mask for current bit number */
 	ASSERT(fields != 0);
 	/*
 	 * Find the lowest bit, so the first byte offset.
 	 */
 	for (i = 0, imask = 1LL; ; i++, imask <<= 1) {
 		if (imask & fields) {
 			*first = offsets[i];
 			break;
 		}
 	}
 	/*
 	 * Find the highest bit, so the last byte offset.
 	 */
 	for (i = nbits - 1, imask = 1LL << i; ; i--, imask >>= 1) {
 		if (imask & fields) {
 			*last = offsets[i + 1] - 1;
 			break;
 		}
 	}
 }
 /*
  * Get a buffer for the block, return it read in.
  * Long-form addressing.
  */
 int					/* error */
 xfs_btree_read_bufl(
 	xfs_mount_t	*mp,		/* file system mount point */
 	xfs_trans_t	*tp,		/* transaction pointer */
 	xfs_fsblock_t	fsbno,		/* file system block number */
 	uint		lock,		/* lock flags for read_buf */
 	xfs_buf_t	**bpp,		/* buffer for fsbno */
 	int		refval)		/* ref count value for buffer */
 {
 	xfs_buf_t	*bp;		/* return value */
 	xfs_daddr_t		d;		/* real disk block address */
 	int		error;
 	ASSERT(fsbno != NULLFSBLOCK);
 	d = XFS_FSB_TO_DADDR(mp, fsbno);
 	if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
 			mp->m_bsize, lock, &bp))) {
 		return error;
 	}
 	ASSERT(!bp || !XFS_BUF_GETERROR(bp));
 	if (bp != NULL) {
 		XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
 	}
 	*bpp = bp;
 	return 0;
 }
 /*
  * Get a buffer for the block, return it read in.
  * Short-form addressing.
  */
 int					/* error */
 xfs_btree_read_bufs(
 	xfs_mount_t	*mp,		/* file system mount point */
 	xfs_trans_t	*tp,		/* transaction pointer */
 	xfs_agnumber_t	agno,		/* allocation group number */
 	xfs_agblock_t	agbno,		/* allocation group block number */
 	uint		lock,		/* lock flags for read_buf */
 	xfs_buf_t	**bpp,		/* buffer for agno/agbno */
 	int		refval)		/* ref count value for buffer */
 {
 	xfs_buf_t	*bp;		/* return value */
 	xfs_daddr_t	d;		/* real disk block address */
 	int		error;
 	ASSERT(agno != NULLAGNUMBER);
 	ASSERT(agbno != NULLAGBLOCK);
 	d = XFS_AGB_TO_DADDR(mp, agno, agbno);
 	if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, d,
 					mp->m_bsize, lock, &bp))) {
 		return error;
 	}
 	ASSERT(!bp || !XFS_BUF_GETERROR(bp));
 	if (bp != NULL) {
 		switch (refval) {
 		case XFS_ALLOC_BTREE_REF:
 			XFS_BUF_SET_VTYPE_REF(bp, B_FS_MAP, refval);
 			break;
 		case XFS_INO_BTREE_REF:
 			XFS_BUF_SET_VTYPE_REF(bp, B_FS_INOMAP, refval);
 			break;
 		}
 	}
 	*bpp = bp;
 	return 0;
 }
 /*
  * Read-ahead the block, don't wait for it, don't return a buffer.
  * Long-form addressing.
  */
 /* ARGSUSED */
 void
 xfs_btree_reada_bufl(
 	xfs_mount_t	*mp,		/* file system mount point */
 	xfs_fsblock_t	fsbno,		/* file system block number */
 	xfs_extlen_t	count)		/* count of filesystem blocks */
 {
 	xfs_daddr_t		d;
 	ASSERT(fsbno != NULLFSBLOCK);
 	d = XFS_FSB_TO_DADDR(mp, fsbno);
 	xfs_baread(mp->m_ddev_targp, d, mp->m_bsize * count);
 }
 /*
  * Read-ahead the block, don't wait for it, don't return a buffer.
  * Short-form addressing.
  */
 /* ARGSUSED */
 void
 xfs_btree_reada_bufs(
 	xfs_mount_t	*mp,		/* file system mount point */
 	xfs_agnumber_t	agno,		/* allocation group number */
 	xfs_agblock_t	agbno,		/* allocation group block number */
 	xfs_extlen_t	count)		/* count of filesystem blocks */
 {
 	xfs_daddr_t		d;
 	ASSERT(agno != NULLAGNUMBER);
 	ASSERT(agbno != NULLAGBLOCK);
 	d = XFS_AGB_TO_DADDR(mp, agno, agbno);
 	xfs_baread(mp->m_ddev_targp, d, mp->m_bsize * count);
 }
 STATIC int
 xfs_btree_readahead_lblock(
 	struct xfs_btree_cur	*cur,
 	int			lr,
 	struct xfs_btree_block	*block)
 {
 	int			rval = 0;
 	xfs_fsblock_t		left = be64_to_cpu(block->bb_u.l.bb_leftsib);
 	xfs_fsblock_t		right = be64_to_cpu(block->bb_u.l.bb_rightsib);
 	if ((lr & XFS_BTCUR_LEFTRA) && left != NULLDFSBNO) {
 		xfs_btree_reada_bufl(cur->bc_mp, left, 1);
 		rval++;
 	}
 	if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLDFSBNO) {
 		xfs_btree_reada_bufl(cur->bc_mp, right, 1);
 		rval++;
 	}
 	return rval;
 }
 STATIC int
 xfs_btree_readahead_sblock(
 	struct xfs_btree_cur	*cur,
 	int			lr,
 	struct xfs_btree_block *block)
 {
 	int			rval = 0;
 	xfs_agblock_t		left = be32_to_cpu(block->bb_u.s.bb_leftsib);
 	xfs_agblock_t		right = be32_to_cpu(block->bb_u.s.bb_rightsib);
 	if ((lr & XFS_BTCUR_LEFTRA) && left != NULLAGBLOCK) {
 		xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
 				     left, 1);
 		rval++;
 	}
 	if ((lr & XFS_BTCUR_RIGHTRA) && right != NULLAGBLOCK) {
 		xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
 				     right, 1);
 		rval++;
 	}
 	return rval;
 }
 /*
  * Read-ahead btree blocks, at the given level.
  * Bits in lr are set from XFS_BTCUR_{LEFT,RIGHT}RA.
  */
 int
 xfs_btree_readahead(
 	struct xfs_btree_cur	*cur,		/* btree cursor */
 	int			lev,		/* level in btree */
 	int			lr)		/* left/right bits */
 {
 	struct xfs_btree_block	*block;
 	/*
 	 * No readahead needed if we are at the root level and the
 	 * btree root is stored in the inode.
 	 */
 	if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
 	    (lev == cur->bc_nlevels - 1))
 		return 0;
 	if ((cur->bc_ra[lev] | lr) == cur->bc_ra[lev])
 		return 0;
 	cur->bc_ra[lev] |= lr;
 	block = XFS_BUF_TO_BLOCK(cur->bc_bufs[lev]);
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
 		return xfs_btree_readahead_lblock(cur, lr, block);
 	return xfs_btree_readahead_sblock(cur, lr, block);
 }
 /*
  * Set the buffer for level "lev" in the cursor to bp, releasing
  * any previous buffer.
  */
 void
 xfs_btree_setbuf(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			lev,	/* level in btree */
 	xfs_buf_t		*bp)	/* new buffer to set */
 {
 	xfs_btree_block_t	*b;	/* btree block */
 	xfs_buf_t		*obp;	/* old buffer pointer */
 	obp = cur->bc_bufs[lev];
 	if (obp)
 		xfs_trans_brelse(cur->bc_tp, obp);
 	cur->bc_bufs[lev] = bp;
 	cur->bc_ra[lev] = 0;
 	if (!bp)
 		return;
 	b = XFS_BUF_TO_BLOCK(bp);
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
 		if (be64_to_cpu(b->bb_u.l.bb_leftsib) == NULLDFSBNO)
 			cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
 		if (be64_to_cpu(b->bb_u.l.bb_rightsib) == NULLDFSBNO)
 			cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
 	} else {
 		if (be32_to_cpu(b->bb_u.s.bb_leftsib) == NULLAGBLOCK)
 			cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
 		if (be32_to_cpu(b->bb_u.s.bb_rightsib) == NULLAGBLOCK)
 			cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
 	}
 }
 STATIC int
 xfs_btree_ptr_is_null(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr)
 {
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
 		return be64_to_cpu(ptr->l) == NULLFSBLOCK;
 	else
 		return be32_to_cpu(ptr->s) == NULLAGBLOCK;
 }
 /*
  * Get/set/init sibling pointers
  */
 STATIC void
 xfs_btree_get_sibling(
 	struct xfs_btree_cur	*cur,
 	struct xfs_btree_block	*block,
 	union xfs_btree_ptr	*ptr,
 	int			lr)
 {
 	ASSERT(lr == XFS_BB_LEFTSIB || lr == XFS_BB_RIGHTSIB);
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
 		if (lr == XFS_BB_RIGHTSIB)
 			ptr->l = block->bb_u.l.bb_rightsib;
 		else
 			ptr->l = block->bb_u.l.bb_leftsib;
 	} else {
 		if (lr == XFS_BB_RIGHTSIB)
 			ptr->s = block->bb_u.s.bb_rightsib;
 		else
 			ptr->s = block->bb_u.s.bb_leftsib;
 	}
 }
 /*
  * Return true if ptr is the last record in the btree and
  * we need to track updateѕ to this record.  The decision
  * will be further refined in the update_lastrec method.
  */
 STATIC int
 xfs_btree_is_lastrec(
 	struct xfs_btree_cur	*cur,
 	struct xfs_btree_block	*block,
 	int			level)
 {
 	union xfs_btree_ptr	ptr;
 	if (level > 0)
 		return 0;
 	if (!(cur->bc_flags & XFS_BTREE_LASTREC_UPDATE))
 		return 0;
 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
 	if (!xfs_btree_ptr_is_null(cur, &ptr))
 		return 0;
 	return 1;
 }
 STATIC xfs_daddr_t
 xfs_btree_ptr_to_daddr(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr)
 {
 	if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
 		ASSERT(be64_to_cpu(ptr->l) != NULLFSBLOCK);
 		return XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l));
 	} else {
 		ASSERT(cur->bc_private.a.agno != NULLAGNUMBER);
 		ASSERT(be32_to_cpu(ptr->s) != NULLAGBLOCK);
 		return XFS_AGB_TO_DADDR(cur->bc_mp, cur->bc_private.a.agno,
 					be32_to_cpu(ptr->s));
 	}
 }
 STATIC void
 xfs_btree_set_refs(
 	struct xfs_btree_cur	*cur,
 	struct xfs_buf		*bp)
 {
 	switch (cur->bc_btnum) {
 	case XFS_BTNUM_BNO:
 	case XFS_BTNUM_CNT:
 		XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_MAP, XFS_ALLOC_BTREE_REF);
 		break;
 	case XFS_BTNUM_INO:
 		XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_INOMAP, XFS_INO_BTREE_REF);
 		break;
 	case XFS_BTNUM_BMAP:
 		XFS_BUF_SET_VTYPE_REF(*bpp, B_FS_MAP, XFS_BMAP_BTREE_REF);
 		break;
 	default:
 		ASSERT(0);
 	}
 }
 /*
  * Read in the buffer at the given ptr and return the buffer and
  * the block pointer within the buffer.
  */
 STATIC int
 xfs_btree_read_buf_block(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr,
 	int			level,
 	int			flags,
 	struct xfs_btree_block	**block,
 	struct xfs_buf		**bpp)
 {
 	struct xfs_mount	*mp = cur->bc_mp;
 	xfs_daddr_t		d;
 	int			error;
 	/* need to sort out how callers deal with failures first */
 	ASSERT(!(flags & XFS_BUF_TRYLOCK));
 	d = xfs_btree_ptr_to_daddr(cur, ptr);
 	error = xfs_trans_read_buf(mp, cur->bc_tp, mp->m_ddev_targp, d,
 				   mp->m_bsize, flags, bpp);
 	if (error)
 		return error;
 	ASSERT(*bpp != NULL);
 	ASSERT(!XFS_BUF_GETERROR(*bpp));
 	xfs_btree_set_refs(cur, *bpp);
 	*block = XFS_BUF_TO_BLOCK(*bpp);
 	error = xfs_btree_check_block(cur, *block, level, *bpp);
 	if (error)
 		xfs_trans_brelse(cur->bc_tp, *bpp);
 	return error;
 }
 /*
  * Copy keys from one btree block to another.
  */
 STATIC void
 xfs_btree_copy_keys(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*dst_key,
 	union xfs_btree_key	*src_key,
 	int			numkeys)
 {
 	ASSERT(numkeys >= 0);
 	memcpy(dst_key, src_key, numkeys * cur->bc_ops->key_len);
 }
 /*
  * Copy records from one btree block to another.
  */
 STATIC void
 xfs_btree_copy_recs(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_rec	*dst_rec,
 	union xfs_btree_rec	*src_rec,
 	int			numrecs)
 {
 	ASSERT(numrecs >= 0);
 	memcpy(dst_rec, src_rec, numrecs * cur->bc_ops->rec_len);
 }
 /*
  * Copy block pointers from one btree block to another.
  */
 STATIC void
 xfs_btree_copy_ptrs(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*dst_ptr,
 	union xfs_btree_ptr	*src_ptr,
 	int			numptrs)
 {
 	ASSERT(numptrs >= 0);
 	memcpy(dst_ptr, src_ptr, numptrs * xfs_btree_ptr_len(cur));
 }
 /*
  * Shift keys one index left/right inside a single btree block.
  */
 STATIC void
 xfs_btree_shift_keys(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key,
 	int			dir,
 	int			numkeys)
 {
 	char			*dst_key;
 	ASSERT(numkeys >= 0);
 	ASSERT(dir == 1 || dir == -1);
 	dst_key = (char *)key + (dir * cur->bc_ops->key_len);
 	memmove(dst_key, key, numkeys * cur->bc_ops->key_len);
 }
 /*
  * Shift records one index left/right inside a single btree block.
  */
 STATIC void
 xfs_btree_shift_recs(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_rec	*rec,
 	int			dir,
 	int			numrecs)
 {
 	char			*dst_rec;
 	ASSERT(numrecs >= 0);
 	ASSERT(dir == 1 || dir == -1);
 	dst_rec = (char *)rec + (dir * cur->bc_ops->rec_len);
 	memmove(dst_rec, rec, numrecs * cur->bc_ops->rec_len);
 }
 /*
  * Shift block pointers one index left/right inside a single btree block.
  */
 STATIC void
 xfs_btree_shift_ptrs(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr,
 	int			dir,
 	int			numptrs)
 {
 	char			*dst_ptr;
 	ASSERT(numptrs >= 0);
 	ASSERT(dir == 1 || dir == -1);
 	dst_ptr = (char *)ptr + (dir * xfs_btree_ptr_len(cur));
 	memmove(dst_ptr, ptr, numptrs * xfs_btree_ptr_len(cur));
 }
 /*
  * Log key values from the btree block.
  */
 STATIC void
 xfs_btree_log_keys(
 	struct xfs_btree_cur	*cur,
 	struct xfs_buf		*bp,
 	int			first,
 	int			last)
 {
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGBII(cur, bp, first, last);
 	if (bp) {
 		xfs_trans_log_buf(cur->bc_tp, bp,
 				  xfs_btree_key_offset(cur, first),
 				  xfs_btree_key_offset(cur, last + 1) - 1);
 	} else {
 		xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
 				xfs_ilog_fbroot(cur->bc_private.b.whichfork));
 	}
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 }
 /*
  * Log record values from the btree block.
  */
 STATIC void
 xfs_btree_log_recs(
 	struct xfs_btree_cur	*cur,
 	struct xfs_buf		*bp,
 	int			first,
 	int			last)
 {
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGBII(cur, bp, first, last);
 	xfs_trans_log_buf(cur->bc_tp, bp,
 			  xfs_btree_rec_offset(cur, first),
 			  xfs_btree_rec_offset(cur, last + 1) - 1);
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 }
 /*
  * Log block pointer fields from a btree block (nonleaf).
  */
 STATIC void
 xfs_btree_log_ptrs(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_buf		*bp,	/* buffer containing btree block */
 	int			first,	/* index of first pointer to log */
 	int			last)	/* index of last pointer to log */
 {
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGBII(cur, bp, first, last);
 	if (bp) {
 		struct xfs_btree_block	*block = XFS_BUF_TO_BLOCK(bp);
 		int			level = xfs_btree_get_level(block);
 		xfs_trans_log_buf(cur->bc_tp, bp,
 				xfs_btree_ptr_offset(cur, first, level),
 				xfs_btree_ptr_offset(cur, last + 1, level) - 1);
 	} else {
 		xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
 			xfs_ilog_fbroot(cur->bc_private.b.whichfork));
 	}
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 }
 /*
  * Log fields from a btree block header.
  */
 STATIC void
 xfs_btree_log_block(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_buf		*bp,	/* buffer containing btree block */
 	int			fields)	/* mask of fields: XFS_BB_... */
 {
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	static const short	soffsets[] = {	/* table of offsets (short) */
 		offsetof(struct xfs_btree_sblock, bb_magic),
 		offsetof(struct xfs_btree_sblock, bb_level),
 		offsetof(struct xfs_btree_sblock, bb_numrecs),
 		offsetof(struct xfs_btree_sblock, bb_leftsib),
 		offsetof(struct xfs_btree_sblock, bb_rightsib),
 		sizeof(struct xfs_btree_sblock)
 	};
 	static const short	loffsets[] = {	/* table of offsets (long) */
 		offsetof(struct xfs_btree_lblock, bb_magic),
 		offsetof(struct xfs_btree_lblock, bb_level),
 		offsetof(struct xfs_btree_lblock, bb_numrecs),
 		offsetof(struct xfs_btree_lblock, bb_leftsib),
 		offsetof(struct xfs_btree_lblock, bb_rightsib),
 		sizeof(struct xfs_btree_lblock)
 	};
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGBI(cur, bp, fields);
 	if (bp) {
 		xfs_btree_offsets(fields,
 				  (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
 					loffsets : soffsets,
 				  XFS_BB_NUM_BITS, &first, &last);
 		xfs_trans_log_buf(cur->bc_tp, bp, first, last);
 	} else {
 		xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
 			xfs_ilog_fbroot(cur->bc_private.b.whichfork));
 	}
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 }
 /*
  * Increment cursor by one record at the level.
  * For nonzero levels the leaf-ward information is untouched.
  */
 int						/* error */
 xfs_btree_increment(
 	struct xfs_btree_cur	*cur,
 	int			level,
 	int			*stat)		/* success/failure */
 {
 	struct xfs_btree_block	*block;
 	union xfs_btree_ptr	ptr;
 	struct xfs_buf		*bp;
 	int			error;		/* error return value */
 	int			lev;
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGI(cur, level);
 	ASSERT(level < cur->bc_nlevels);
 	/* Read-ahead to the right at this level. */
 	xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
 	/* Get a pointer to the btree block. */
 	block = xfs_btree_get_block(cur, level, &bp);
 #ifdef DEBUG
 	error = xfs_btree_check_block(cur, block, level, bp);
 	if (error)
 		goto error0;
 #endif
 	/* We're done if we remain in the block after the increment. */
 	if (++cur->bc_ptrs[level] <= xfs_btree_get_numrecs(block))
 		goto out1;
 	/* Fail if we just went off the right edge of the tree. */
 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
 	if (xfs_btree_ptr_is_null(cur, &ptr))
 		goto out0;
 	XFS_BTREE_STATS_INC(cur, increment);
 	/*
 	 * March up the tree incrementing pointers.
 	 * Stop when we don't go off the right edge of a block.
 	 */
 	for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
 		block = xfs_btree_get_block(cur, lev, &bp);
 #ifdef DEBUG
 		error = xfs_btree_check_block(cur, block, lev, bp);
 		if (error)
 			goto error0;
 #endif
 		if (++cur->bc_ptrs[lev] <= xfs_btree_get_numrecs(block))
 			break;
 		/* Read-ahead the right block for the next loop. */
 		xfs_btree_readahead(cur, lev, XFS_BTCUR_RIGHTRA);
 	}
 	/*
 	 * If we went off the root then we are either seriously
 	 * confused or have the tree root in an inode.
 	 */
 	if (lev == cur->bc_nlevels) {
 		if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
 			goto out0;
 		ASSERT(0);
 		error = EFSCORRUPTED;
 		goto error0;
 	}
 	ASSERT(lev < cur->bc_nlevels);
 	/*
 	 * Now walk back down the tree, fixing up the cursor's buffer
 	 * pointers and key numbers.
 	 */
 	for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
 		union xfs_btree_ptr	*ptrp;
 		ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
 		error = xfs_btree_read_buf_block(cur, ptrp, --lev,
 							0, &block, &bp);
 		if (error)
 			goto error0;
 		xfs_btree_setbuf(cur, lev, bp);
 		cur->bc_ptrs[lev] = 1;
 	}
 out1:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	*stat = 1;
 	return 0;
 out0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	*stat = 0;
 	return 0;
 error0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
 	return error;
 }
 /*
  * Decrement cursor by one record at the level.
  * For nonzero levels the leaf-ward information is untouched.
  */
 int						/* error */
 xfs_btree_decrement(
 	struct xfs_btree_cur	*cur,
 	int			level,
 	int			*stat)		/* success/failure */
 {
 	struct xfs_btree_block	*block;
 	xfs_buf_t		*bp;
 	int			error;		/* error return value */
 	int			lev;
 	union xfs_btree_ptr	ptr;
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGI(cur, level);
 	ASSERT(level < cur->bc_nlevels);
 	/* Read-ahead to the left at this level. */
 	xfs_btree_readahead(cur, level, XFS_BTCUR_LEFTRA);
 	/* We're done if we remain in the block after the decrement. */
 	if (--cur->bc_ptrs[level] > 0)
 		goto out1;
 	/* Get a pointer to the btree block. */
 	block = xfs_btree_get_block(cur, level, &bp);
 #ifdef DEBUG
 	error = xfs_btree_check_block(cur, block, level, bp);
 	if (error)
 		goto error0;
 #endif
 	/* Fail if we just went off the left edge of the tree. */
 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
 	if (xfs_btree_ptr_is_null(cur, &ptr))
 		goto out0;
 	XFS_BTREE_STATS_INC(cur, decrement);
 	/*
 	 * March up the tree decrementing pointers.
 	 * Stop when we don't go off the left edge of a block.
 	 */
 	for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
 		if (--cur->bc_ptrs[lev] > 0)
 			break;
 		/* Read-ahead the left block for the next loop. */
 		xfs_btree_readahead(cur, lev, XFS_BTCUR_LEFTRA);
 	}
 	/*
 	 * If we went off the root then we are seriously confused.
 	 * or the root of the tree is in an inode.
 	 */
 	if (lev == cur->bc_nlevels) {
 		if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
 			goto out0;
 		ASSERT(0);
 		error = EFSCORRUPTED;
 		goto error0;
 	}
 	ASSERT(lev < cur->bc_nlevels);
 	/*
 	 * Now walk back down the tree, fixing up the cursor's buffer
 	 * pointers and key numbers.
 	 */
 	for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
 		union xfs_btree_ptr	*ptrp;
 		ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
 		error = xfs_btree_read_buf_block(cur, ptrp, --lev,
 							0, &block, &bp);
 		if (error)
 			goto error0;
 		xfs_btree_setbuf(cur, lev, bp);
 		cur->bc_ptrs[lev] = xfs_btree_get_numrecs(block);
 	}
 out1:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	*stat = 1;
 	return 0;
 out0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	*stat = 0;
 	return 0;
 error0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
 	return error;
 }
 STATIC int
 xfs_btree_lookup_get_block(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	int			level,	/* level in the btree */
 	union xfs_btree_ptr	*pp,	/* ptr to btree block */
 	struct xfs_btree_block	**blkp) /* return btree block */
 {
 	struct xfs_buf		*bp;	/* buffer pointer for btree block */
 	int			error = 0;
 	/* special case the root block if in an inode */
 	if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
 	    (level == cur->bc_nlevels - 1)) {
 		*blkp = xfs_btree_get_iroot(cur);
 		return 0;
 	}
 	/*
 	 * If the old buffer at this level for the disk address we are
 	 * looking for re-use it.
 	 *
 	 * Otherwise throw it away and get a new one.
 	 */
 	bp = cur->bc_bufs[level];
 	if (bp && XFS_BUF_ADDR(bp) == xfs_btree_ptr_to_daddr(cur, pp)) {
 		*blkp = XFS_BUF_TO_BLOCK(bp);
 		return 0;
 	}
 	error = xfs_btree_read_buf_block(cur, pp, level, 0, blkp, &bp);
 	if (error)
 		return error;
 	xfs_btree_setbuf(cur, level, bp);
 	return 0;
 }
 /*
  * Get current search key.  For level 0 we don't actually have a key
  * structure so we make one up from the record.  For all other levels
  * we just return the right key.
  */
 STATIC union xfs_btree_key *
 xfs_lookup_get_search_key(
 	struct xfs_btree_cur	*cur,
 	int			level,
 	int			keyno,
 	struct xfs_btree_block	*block,
 	union xfs_btree_key	*kp)
 {
 	if (level == 0) {
 		cur->bc_ops->init_key_from_rec(kp,
 				xfs_btree_rec_addr(cur, keyno, block));
 		return kp;
 	}
 	return xfs_btree_key_addr(cur, keyno, block);
 }
 /*
  * Lookup the record.  The cursor is made to point to it, based on dir.
  * Return 0 if can't find any such record, 1 for success.
  */
 int					/* error */
 xfs_btree_lookup(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	xfs_lookup_t		dir,	/* <=, ==, or >= */
 	int			*stat)	/* success/failure */
 {
 	struct xfs_btree_block	*block;	/* current btree block */
 	__int64_t		diff;	/* difference for the current key */
 	int			error;	/* error return value */
 	int			keyno;	/* current key number */
 	int			level;	/* level in the btree */
 	union xfs_btree_ptr	*pp;	/* ptr to btree block */
 	union xfs_btree_ptr	ptr;	/* ptr to btree block */
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGI(cur, dir);
 	XFS_BTREE_STATS_INC(cur, lookup);
 	block = NULL;
 	keyno = 0;
 	/* initialise start pointer from cursor */
 	cur->bc_ops->init_ptr_from_cur(cur, &ptr);
 	pp = &ptr;
 	/*
 	 * Iterate over each level in the btree, starting at the root.
 	 * For each level above the leaves, find the key we need, based
 	 * on the lookup record, then follow the corresponding block
 	 * pointer down to the next level.
 	 */
 	for (level = cur->bc_nlevels - 1, diff = 1; level >= 0; level--) {
 		/* Get the block we need to do the lookup on. */
 		error = xfs_btree_lookup_get_block(cur, level, pp, &block);
 		if (error)
 			goto error0;
 		if (diff == 0) {
 			/*
 			 * If we already had a key match at a higher level, we
 			 * know we need to use the first entry in this block.
 			 */
 			keyno = 1;
 		} else {
 			/* Otherwise search this block. Do a binary search. */
 			int	high;	/* high entry number */
 			int	low;	/* low entry number */
 			/* Set low and high entry numbers, 1-based. */
 			low = 1;
 			high = xfs_btree_get_numrecs(block);
 			if (!high) {
 				/* Block is empty, must be an empty leaf. */
 				ASSERT(level == 0 && cur->bc_nlevels == 1);
 				cur->bc_ptrs[0] = dir != XFS_LOOKUP_LE;
 				XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 				*stat = 0;
 				return 0;
 			}
 			/* Binary search the block. */
 			while (low <= high) {
 				union xfs_btree_key	key;
 				union xfs_btree_key	*kp;
 				XFS_BTREE_STATS_INC(cur, compare);
 				/* keyno is average of low and high. */
 				keyno = (low + high) >> 1;
 				/* Get current search key */
 				kp = xfs_lookup_get_search_key(cur, level,
 						keyno, block, &key);
 				/*
 				 * Compute difference to get next direction:
 				 *  - less than, move right
 				 *  - greater than, move left
 				 *  - equal, we're done
 				 */
 				diff = cur->bc_ops->key_diff(cur, kp);
 				if (diff < 0)
 					low = keyno + 1;
 				else if (diff > 0)
 					high = keyno - 1;
 				else
 					break;
 			}
 		}
 		/*
 		 * If there are more levels, set up for the next level
 		 * by getting the block number and filling in the cursor.
 		 */
 		if (level > 0) {
 			/*
 			 * If we moved left, need the previous key number,
 			 * unless there isn't one.
 			 */
 			if (diff > 0 && --keyno < 1)
 				keyno = 1;
 			pp = xfs_btree_ptr_addr(cur, keyno, block);
 #ifdef DEBUG
 			error = xfs_btree_check_ptr(cur, pp, 0, level);
 			if (error)
 				goto error0;
 #endif
 			cur->bc_ptrs[level] = keyno;
 		}
 	}
 	/* Done with the search. See if we need to adjust the results. */
 	if (dir != XFS_LOOKUP_LE && diff < 0) {
 		keyno++;
 		/*
 		 * If ge search and we went off the end of the block, but it's
 		 * not the last block, we're in the wrong block.
 		 */
 		xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
 		if (dir == XFS_LOOKUP_GE &&
 		    keyno > xfs_btree_get_numrecs(block) &&
 		    !xfs_btree_ptr_is_null(cur, &ptr)) {
 			int	i;
 			cur->bc_ptrs[0] = keyno;
 			error = xfs_btree_increment(cur, 0, &i);
 			if (error)
 				goto error0;
 			XFS_WANT_CORRUPTED_RETURN(i == 1);
 			XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 			*stat = 1;
 			return 0;
 		}
 	} else if (dir == XFS_LOOKUP_LE && diff > 0)
 		keyno--;
 	cur->bc_ptrs[0] = keyno;
 	/* Return if we succeeded or not. */
 	if (keyno == 0 || keyno > xfs_btree_get_numrecs(block))
 		*stat = 0;
 	else if (dir != XFS_LOOKUP_EQ || diff == 0)
 		*stat = 1;
 	else
 		*stat = 0;
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	return 0;
 error0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
 	return error;
 }
 /*
  * Update keys at all levels from here to the root along the cursor's path.
  */
 int
 xfs_btree_updkey(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*keyp,
 	int			level)
 {
 	struct xfs_btree_block	*block;
 	struct xfs_buf		*bp;
 	union xfs_btree_key	*kp;
 	int			ptr;
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGIK(cur, level, keyp);
 	ASSERT(!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) || level >= 1);
 	/*
 	 * Go up the tree from this level toward the root.
 	 * At each level, update the key value to the value input.
 	 * Stop when we reach a level where the cursor isn't pointing
 	 * at the first entry in the block.
 	 */
 	for (ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
 #ifdef DEBUG
 		int		error;
 #endif
 		block = xfs_btree_get_block(cur, level, &bp);
 #ifdef DEBUG
 		error = xfs_btree_check_block(cur, block, level, bp);
 		if (error) {
 			XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
 			return error;
 		}
 #endif
 		ptr = cur->bc_ptrs[level];
 		kp = xfs_btree_key_addr(cur, ptr, block);
 		xfs_btree_copy_keys(cur, kp, keyp, 1);
 		xfs_btree_log_keys(cur, bp, ptr, ptr);
 	}
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	return 0;
 }
 /*
  * Update the record referred to by cur to the value in the
  * given record. This either works (return 0) or gets an
  * EFSCORRUPTED error.
  */
 int
 xfs_btree_update(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_rec	*rec)
 {
 	struct xfs_btree_block	*block;
 	struct xfs_buf		*bp;
 	int			error;
 	int			ptr;
 	union xfs_btree_rec	*rp;
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGR(cur, rec);
 	/* Pick up the current block. */
 	block = xfs_btree_get_block(cur, 0, &bp);
 #ifdef DEBUG
 	error = xfs_btree_check_block(cur, block, 0, bp);
 	if (error)
 		goto error0;
 #endif
 	/* Get the address of the rec to be updated. */
 	ptr = cur->bc_ptrs[0];
 	rp = xfs_btree_rec_addr(cur, ptr, block);
 	/* Fill in the new contents and log them. */
 	xfs_btree_copy_recs(cur, rp, rec, 1);
 	xfs_btree_log_recs(cur, bp, ptr, ptr);
 	/*
 	 * If we are tracking the last record in the tree and
 	 * we are at the far right edge of the tree, update it.
 	 */
 	if (xfs_btree_is_lastrec(cur, block, 0)) {
 		cur->bc_ops->update_lastrec(cur, block, rec,
 					    ptr, LASTREC_UPDATE);
 	}
 	/* Updating first rec in leaf. Pass new key value up to our parent. */
 	if (ptr == 1) {
 		union xfs_btree_key	key;
 		cur->bc_ops->init_key_from_rec(&key, rec);
 		error = xfs_btree_updkey(cur, &key, 1);
 		if (error)
 			goto error0;
 	}
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	return 0;
 error0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
 	return error;
 }
 /*
+ * Move 1 record left from cur/level if possible.
+ * Update cur to reflect the new path.
+ */
+int					/* error */
+xfs_btree_lshift(
+	struct xfs_btree_cur	*cur,
+	int			level,
+	int			*stat)		/* success/failure */
+{
+	union xfs_btree_key	key;		/* btree key */
+	struct xfs_buf		*lbp;		/* left buffer pointer */
+	struct xfs_btree_block	*left;		/* left btree block */
+	int			lrecs;		/* left record count */
+	struct xfs_buf		*rbp;		/* right buffer pointer */
+	struct xfs_btree_block	*right;		/* right btree block */
+	int			rrecs;		/* right record count */
+	union xfs_btree_ptr	lptr;		/* left btree pointer */
+	union xfs_btree_key	*rkp = NULL;	/* right btree key */
+	union xfs_btree_ptr	*rpp = NULL;	/* right address pointer */
+	union xfs_btree_rec	*rrp = NULL;	/* right record pointer */
+	int			error;		/* error return value */
+	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
+	XFS_BTREE_TRACE_ARGI(cur, level);
+	if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
+	    level == cur->bc_nlevels - 1)
+		goto out0;
+	/* Set up variables for this block as "right". */
+	right = xfs_btree_get_block(cur, level, &rbp);
+#ifdef DEBUG
+	error = xfs_btree_check_block(cur, right, level, rbp);
+	if (error)
+		goto error0;
+#endif
+	/* If we've got no left sibling then we can't shift an entry left. */
+	xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
+	if (xfs_btree_ptr_is_null(cur, &lptr))
+		goto out0;
+	/*
+	 * If the cursor entry is the one that would be moved, don't
+	 * do it... it's too complicated.
+	 */
+	if (cur->bc_ptrs[level] <= 1)
+		goto out0;
+	/* Set up the left neighbor as "left". */
+	error = xfs_btree_read_buf_block(cur, &lptr, level, 0, &left, &lbp);
+	if (error)
+		goto error0;
+	/* If it's full, it can't take another entry. */
+	lrecs = xfs_btree_get_numrecs(left);
+	if (lrecs == cur->bc_ops->get_maxrecs(cur, level))
+		goto out0;
+	rrecs = xfs_btree_get_numrecs(right);
+	/*
+	 * We add one entry to the left side and remove one for the right side.
+	 * Accout for it here, the changes will be updated on disk and logged
+	 * later.
+	 */
+	lrecs++;
+	rrecs--;
+	XFS_BTREE_STATS_INC(cur, lshift);
+	XFS_BTREE_STATS_ADD(cur, moves, 1);
+	/*
+	 * If non-leaf, copy a key and a ptr to the left block.
+	 * Log the changes to the left block.
+	 */
+	if (level > 0) {
+		/* It's a non-leaf.  Move keys and pointers. */
+		union xfs_btree_key	*lkp;	/* left btree key */
+		union xfs_btree_ptr	*lpp;	/* left address pointer */
+		lkp = xfs_btree_key_addr(cur, lrecs, left);
+		rkp = xfs_btree_key_addr(cur, 1, right);
+		lpp = xfs_btree_ptr_addr(cur, lrecs, left);
+		rpp = xfs_btree_ptr_addr(cur, 1, right);
+#ifdef DEBUG
+		error = xfs_btree_check_ptr(cur, rpp, 0, level);
+		if (error)
+			goto error0;
+#endif
+		xfs_btree_copy_keys(cur, lkp, rkp, 1);
+		xfs_btree_copy_ptrs(cur, lpp, rpp, 1);
+		xfs_btree_log_keys(cur, lbp, lrecs, lrecs);
+		xfs_btree_log_ptrs(cur, lbp, lrecs, lrecs);
+		xfs_btree_check_key(cur->bc_btnum,
+				    xfs_btree_key_addr(cur, lrecs - 1, left),
+				    lkp);
+	} else {
+		/* It's a leaf.  Move records.  */
+		union xfs_btree_rec	*lrp;	/* left record pointer */
+		lrp = xfs_btree_rec_addr(cur, lrecs, left);
+		rrp = xfs_btree_rec_addr(cur, 1, right);
+		xfs_btree_copy_recs(cur, lrp, rrp, 1);
+		xfs_btree_log_recs(cur, lbp, lrecs, lrecs);
+		xfs_btree_check_rec(cur->bc_btnum,
+				    xfs_btree_rec_addr(cur, lrecs - 1, left),
+				    lrp);
+	}
+	xfs_btree_set_numrecs(left, lrecs);
+	xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
+	xfs_btree_set_numrecs(right, rrecs);
+	xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
+	/*
+	 * Slide the contents of right down one entry.
+	 */
+	XFS_BTREE_STATS_ADD(cur, moves, rrecs - 1);
+	if (level > 0) {
+		/* It's a nonleaf. operate on keys and ptrs */
+#ifdef DEBUG
+		int			i;		/* loop index */
+		for (i = 0; i < rrecs; i++) {
+			error = xfs_btree_check_ptr(cur, rpp, i + 1, level);
+			if (error)
+				goto error0;
+		}
+#endif
+		xfs_btree_shift_keys(cur,
+				xfs_btree_key_addr(cur, 2, right),
+				-1, rrecs);
+		xfs_btree_shift_ptrs(cur,
+				xfs_btree_ptr_addr(cur, 2, right),
+				-1, rrecs);
+		xfs_btree_log_keys(cur, rbp, 1, rrecs);
+		xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
+	} else {
+		/* It's a leaf. operate on records */
+		xfs_btree_shift_recs(cur,
+			xfs_btree_rec_addr(cur, 2, right),
+			-1, rrecs);
+		xfs_btree_log_recs(cur, rbp, 1, rrecs);
+		/*
+		 * If it's the first record in the block, we'll need a key
+		 * structure to pass up to the next level (updkey).
+		 */
+		cur->bc_ops->init_key_from_rec(&key,
+			xfs_btree_rec_addr(cur, 1, right));
+		rkp = &key;
+	}
+	/* Update the parent key values of right. */
+	error = xfs_btree_updkey(cur, rkp, level + 1);
+	if (error)
+		goto error0;
+	/* Slide the cursor value left one. */
+	cur->bc_ptrs[level]--;
+	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+	*stat = 1;
+	return 0;
+out0:
+	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+	*stat = 0;
+	return 0;
+error0:
+	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
+	return error;
+}
+/*
  * Move 1 record right from cur/level if possible.
  * Update cur to reflect the new path.
  */
 int					/* error */
 xfs_btree_rshift(
 	struct xfs_btree_cur	*cur,
 	int			level,
 	int			*stat)		/* success/failure */
 {
 	union xfs_btree_key	key;		/* btree key */
 	struct xfs_buf		*lbp;		/* left buffer pointer */
 	struct xfs_btree_block	*left;		/* left btree block */
 	struct xfs_buf		*rbp;		/* right buffer pointer */
 	struct xfs_btree_block	*right;		/* right btree block */
 	struct xfs_btree_cur	*tcur;		/* temporary btree cursor */
 	union xfs_btree_ptr	rptr;		/* right block pointer */
 	union xfs_btree_key	*rkp;		/* right btree key */
 	int			rrecs;		/* right record count */
 	int			lrecs;		/* left record count */
 	int			error;		/* error return value */
 	int			i;		/* loop counter */
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 	XFS_BTREE_TRACE_ARGI(cur, level);
 	if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
 	    (level == cur->bc_nlevels - 1))
 		goto out0;
 	/* Set up variables for this block as "left". */
 	left = xfs_btree_get_block(cur, level, &lbp);
 #ifdef DEBUG
 	error = xfs_btree_check_block(cur, left, level, lbp);
 	if (error)
 		goto error0;
 #endif
 	/* If we've got no right sibling then we can't shift an entry right. */
 	xfs_btree_get_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
 	if (xfs_btree_ptr_is_null(cur, &rptr))
 		goto out0;
 	/*
 	 * If the cursor entry is the one that would be moved, don't
 	 * do it... it's too complicated.
 	 */
 	lrecs = xfs_btree_get_numrecs(left);
 	if (cur->bc_ptrs[level] >= lrecs)
 		goto out0;
 	/* Set up the right neighbor as "right". */
 	error = xfs_btree_read_buf_block(cur, &rptr, level, 0, &right, &rbp);
 	if (error)
 		goto error0;
 	/* If it's full, it can't take another entry. */
 	rrecs = xfs_btree_get_numrecs(right);
 	if (rrecs == cur->bc_ops->get_maxrecs(cur, level))
 		goto out0;
 	XFS_BTREE_STATS_INC(cur, rshift);
 	XFS_BTREE_STATS_ADD(cur, moves, rrecs);
 	/*
 	 * Make a hole at the start of the right neighbor block, then
 	 * copy the last left block entry to the hole.
 	 */
 	if (level > 0) {
 		/* It's a nonleaf. make a hole in the keys and ptrs */
 		union xfs_btree_key	*lkp;
 		union xfs_btree_ptr	*lpp;
 		union xfs_btree_ptr	*rpp;
 		lkp = xfs_btree_key_addr(cur, lrecs, left);
 		lpp = xfs_btree_ptr_addr(cur, lrecs, left);
 		rkp = xfs_btree_key_addr(cur, 1, right);
 		rpp = xfs_btree_ptr_addr(cur, 1, right);
 #ifdef DEBUG
 		for (i = rrecs - 1; i >= 0; i--) {
 			error = xfs_btree_check_ptr(cur, rpp, i, level);
 			if (error)
 				goto error0;
 		}
 #endif
 		xfs_btree_shift_keys(cur, rkp, 1, rrecs);
 		xfs_btree_shift_ptrs(cur, rpp, 1, rrecs);
 #ifdef DEBUG
 		error = xfs_btree_check_ptr(cur, lpp, 0, level);
 		if (error)
 			goto error0;
 #endif
 		/* Now put the new data in, and log it. */
 		xfs_btree_copy_keys(cur, rkp, lkp, 1);
 		xfs_btree_copy_ptrs(cur, rpp, lpp, 1);
 		xfs_btree_log_keys(cur, rbp, 1, rrecs + 1);
 		xfs_btree_log_ptrs(cur, rbp, 1, rrecs + 1);
 		xfs_btree_check_key(cur->bc_btnum, rkp,
 				    xfs_btree_key_addr(cur, 2, right));
 	} else {
 		/* It's a leaf. make a hole in the records */
 		union xfs_btree_rec	*lrp;
 		union xfs_btree_rec	*rrp;
 		lrp = xfs_btree_rec_addr(cur, lrecs, left);
 		rrp = xfs_btree_rec_addr(cur, 1, right);
 		xfs_btree_shift_recs(cur, rrp, 1, rrecs);
 		/* Now put the new data in, and log it. */
 		xfs_btree_copy_recs(cur, rrp, lrp, 1);
 		xfs_btree_log_recs(cur, rbp, 1, rrecs + 1);
 		cur->bc_ops->init_key_from_rec(&key, rrp);
 		rkp = &key;
 		xfs_btree_check_rec(cur->bc_btnum, rrp,
 				    xfs_btree_rec_addr(cur, 2, right));
 	}
 	/*
 	 * Decrement and log left's numrecs, bump and log right's numrecs.
 	 */
 	xfs_btree_set_numrecs(left, --lrecs);
 	xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
 	xfs_btree_set_numrecs(right, ++rrecs);
 	xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
 	/*
 	 * Using a temporary cursor, update the parent key values of the
 	 * block on the right.
 	 */
 	error = xfs_btree_dup_cursor(cur, &tcur);
 	if (error)
 		goto error0;
 	i = xfs_btree_lastrec(tcur, level);
 	XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 	error = xfs_btree_increment(tcur, level, &i);
 	if (error)
 		goto error1;
 	error = xfs_btree_updkey(tcur, rkp, level + 1);
 	if (error)
 		goto error1;
 	xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	*stat = 1;
 	return 0;
 out0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
 	*stat = 0;
 	return 0;
 error0:
 	XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
 	return error;
 error1:
 	XFS_BTREE_TRACE_CURSOR(tcur, XBT_ERROR);
 	xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
 	return error;
 }

fs/xfs/xfs_btree.h

Diff comments View file @ 687b890

 /*
  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef __XFS_BTREE_H__
 #define	__XFS_BTREE_H__
 struct xfs_buf;
 struct xfs_bmap_free;
 struct xfs_inode;
 struct xfs_mount;
 struct xfs_trans;
 extern kmem_zone_t	*xfs_btree_cur_zone;
 /*
  * This nonsense is to make -wlint happy.
  */
 #define	XFS_LOOKUP_EQ	((xfs_lookup_t)XFS_LOOKUP_EQi)
 #define	XFS_LOOKUP_LE	((xfs_lookup_t)XFS_LOOKUP_LEi)
 #define	XFS_LOOKUP_GE	((xfs_lookup_t)XFS_LOOKUP_GEi)
 #define	XFS_BTNUM_BNO	((xfs_btnum_t)XFS_BTNUM_BNOi)
 #define	XFS_BTNUM_CNT	((xfs_btnum_t)XFS_BTNUM_CNTi)
 #define	XFS_BTNUM_BMAP	((xfs_btnum_t)XFS_BTNUM_BMAPi)
 #define	XFS_BTNUM_INO	((xfs_btnum_t)XFS_BTNUM_INOi)
 /*
  * Short form header: space allocation btrees.
  */
 typedef struct xfs_btree_sblock {
 	__be32		bb_magic;	/* magic number for block type */
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 	__be32		bb_leftsib;	/* left sibling block or NULLAGBLOCK */
 	__be32		bb_rightsib;	/* right sibling block or NULLAGBLOCK */
 } xfs_btree_sblock_t;
 /*
  * Long form header: bmap btrees.
  */
 typedef struct xfs_btree_lblock {
 	__be32		bb_magic;	/* magic number for block type */
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 	__be64		bb_leftsib;	/* left sibling block or NULLDFSBNO */
 	__be64		bb_rightsib;	/* right sibling block or NULLDFSBNO */
 } xfs_btree_lblock_t;
 /*
  * Combined header and structure, used by common code.
  */
 typedef struct xfs_btree_block {
 	__be32		bb_magic;	/* magic number for block type */
 	__be16		bb_level;	/* 0 is a leaf */
 	__be16		bb_numrecs;	/* current # of data records */
 	union {
 		struct {
 			__be32		bb_leftsib;
 			__be32		bb_rightsib;
 		} s;			/* short form pointers */
 		struct	{
 			__be64		bb_leftsib;
 			__be64		bb_rightsib;
 		} l;			/* long form pointers */
 	} bb_u;				/* rest */
 } xfs_btree_block_t;
 /*
  * Generic key, ptr and record wrapper structures.
  *
  * These are disk format structures, and are converted where necessary
  * by the btree specific code that needs to interpret them.
  */
 union xfs_btree_ptr {
 	__be32			s;	/* short form ptr */
 	__be64			l;	/* long form ptr */
 };
 union xfs_btree_key {
 	xfs_bmbt_key_t		bmbt;
 	xfs_bmdr_key_t		bmbr;	/* bmbt root block */
 	xfs_alloc_key_t		alloc;
 	xfs_inobt_key_t		inobt;
 };
 union xfs_btree_rec {
 	xfs_bmbt_rec_t		bmbt;
 	xfs_bmdr_rec_t		bmbr;	/* bmbt root block */
 	xfs_alloc_rec_t		alloc;
 	xfs_inobt_rec_t		inobt;
 };
 /*
  * For logging record fields.
  */
 #define	XFS_BB_MAGIC		0x01
 #define	XFS_BB_LEVEL		0x02
 #define	XFS_BB_NUMRECS		0x04
 #define	XFS_BB_LEFTSIB		0x08
 #define	XFS_BB_RIGHTSIB		0x10
 #define	XFS_BB_NUM_BITS		5
 #define	XFS_BB_ALL_BITS		((1 << XFS_BB_NUM_BITS) - 1)
 /*
  * Magic numbers for btree blocks.
  */
 extern const __uint32_t	xfs_magics[];
 /*
  * Generic stats interface
  */
 #define __XFS_BTREE_STATS_INC(type, stat) \
 	XFS_STATS_INC(xs_ ## type ## _2_ ## stat)
 #define XFS_BTREE_STATS_INC(cur, stat)  \
 do {    \
 	switch (cur->bc_btnum) {  \
 	case XFS_BTNUM_BNO: __XFS_BTREE_STATS_INC(abtb, stat); break;	\
 	case XFS_BTNUM_CNT: __XFS_BTREE_STATS_INC(abtc, stat); break;	\
 	case XFS_BTNUM_BMAP: __XFS_BTREE_STATS_INC(bmbt, stat); break;	\
 	case XFS_BTNUM_INO: __XFS_BTREE_STATS_INC(ibt, stat); break;	\
 	case XFS_BTNUM_MAX: ASSERT(0); /* fucking gcc */ ; break;	\
 	}       \
 } while (0)
 #define __XFS_BTREE_STATS_ADD(type, stat, val) \
 	XFS_STATS_ADD(xs_ ## type ## _2_ ## stat, val)
 #define XFS_BTREE_STATS_ADD(cur, stat, val)  \
 do {    \
 	switch (cur->bc_btnum) {  \
 	case XFS_BTNUM_BNO: __XFS_BTREE_STATS_ADD(abtb, stat, val); break; \
 	case XFS_BTNUM_CNT: __XFS_BTREE_STATS_ADD(abtc, stat, val); break; \
 	case XFS_BTNUM_BMAP: __XFS_BTREE_STATS_ADD(bmbt, stat, val); break; \
 	case XFS_BTNUM_INO: __XFS_BTREE_STATS_ADD(ibt, stat, val); break; \
 	case XFS_BTNUM_MAX: ASSERT(0); /* fucking gcc */ ; break;	\
 	}       \
 } while (0)
 /*
  * Maximum and minimum records in a btree block.
  * Given block size, type prefix, and leaf flag (0 or 1).
  * The divisor below is equivalent to lf ? (e1) : (e2) but that produces
  * compiler warnings.
  */
 #define	XFS_BTREE_BLOCK_MAXRECS(bsz,t,lf)	\
 	((int)(((bsz) - (uint)sizeof(t ## _block_t)) / \
 	 (((lf) * (uint)sizeof(t ## _rec_t)) + \
 	  ((1 - (lf)) * \
 	   ((uint)sizeof(t ## _key_t) + (uint)sizeof(t ## _ptr_t))))))
 #define	XFS_BTREE_BLOCK_MINRECS(bsz,t,lf)	\
 	(XFS_BTREE_BLOCK_MAXRECS(bsz,t,lf) / 2)
 /*
  * Record, key, and pointer address calculation macros.
  * Given block size, type prefix, block pointer, and index of requested entry
  * (first entry numbered 1).
  */
 #define	XFS_BTREE_REC_ADDR(t,bb,i)	\
 	((t ## _rec_t *)((char *)(bb) + sizeof(t ## _block_t) + \
 	 ((i) - 1) * sizeof(t ## _rec_t)))
 #define	XFS_BTREE_KEY_ADDR(t,bb,i)	\
 	((t ## _key_t *)((char *)(bb) + sizeof(t ## _block_t) + \
 	 ((i) - 1) * sizeof(t ## _key_t)))
 #define	XFS_BTREE_PTR_ADDR(t,bb,i,mxr)	\
 	((t ## _ptr_t *)((char *)(bb) + sizeof(t ## _block_t) + \
 	 (mxr) * sizeof(t ## _key_t) + ((i) - 1) * sizeof(t ## _ptr_t)))
 #define	XFS_BTREE_MAXLEVELS	8	/* max of all btrees */
 struct xfs_btree_ops {
 	/* size of the key and record structures */
 	size_t	key_len;
 	size_t	rec_len;
 	/* cursor operations */
 	struct xfs_btree_cur *(*dup_cursor)(struct xfs_btree_cur *);
 	/* update last record information */
 	void	(*update_lastrec)(struct xfs_btree_cur *cur,
 				  struct xfs_btree_block *block,
 				  union xfs_btree_rec *rec,
 				  int ptr, int reason);
 	/* records in block/level */
 	int	(*get_maxrecs)(struct xfs_btree_cur *cur, int level);
 	/* init values of btree structures */
 	void	(*init_key_from_rec)(union xfs_btree_key *key,
 				     union xfs_btree_rec *rec);
 	void	(*init_ptr_from_cur)(struct xfs_btree_cur *cur,
 				     union xfs_btree_ptr *ptr);
 	/* difference between key value and cursor value */
 	__int64_t (*key_diff)(struct xfs_btree_cur *cur,
 			      union xfs_btree_key *key);
 	/* btree tracing */
 #ifdef XFS_BTREE_TRACE
 	void		(*trace_enter)(struct xfs_btree_cur *, const char *,
 				       char *, int, int, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t,
 				       __psunsigned_t, __psunsigned_t);
 	void		(*trace_cursor)(struct xfs_btree_cur *, __uint32_t *,
 					__uint64_t *, __uint64_t *);
 	void		(*trace_key)(struct xfs_btree_cur *,
 				     union xfs_btree_key *, __uint64_t *,
 				     __uint64_t *);
 	void		(*trace_record)(struct xfs_btree_cur *,
 					union xfs_btree_rec *, __uint64_t *,
 					__uint64_t *, __uint64_t *);
 #endif
 };
 /*
  * Reasons for the update_lastrec method to be called.
  */
 #define LASTREC_UPDATE	0
 /*
  * Btree cursor structure.
  * This collects all information needed by the btree code in one place.
  */
 typedef struct xfs_btree_cur
 {
 	struct xfs_trans	*bc_tp;	/* transaction we're in, if any */
 	struct xfs_mount	*bc_mp;	/* file system mount struct */
 	const struct xfs_btree_ops *bc_ops;
 	uint			bc_flags; /* btree features - below */
 	union {
 		xfs_alloc_rec_incore_t	a;
 		xfs_bmbt_irec_t		b;
 		xfs_inobt_rec_incore_t	i;
 	}		bc_rec;		/* current insert/search record value */
 	struct xfs_buf	*bc_bufs[XFS_BTREE_MAXLEVELS];	/* buf ptr per level */
 	int		bc_ptrs[XFS_BTREE_MAXLEVELS];	/* key/record # */
 	__uint8_t	bc_ra[XFS_BTREE_MAXLEVELS];	/* readahead bits */
 #define	XFS_BTCUR_LEFTRA	1	/* left sibling has been read-ahead */
 #define	XFS_BTCUR_RIGHTRA	2	/* right sibling has been read-ahead */
 	__uint8_t	bc_nlevels;	/* number of levels in the tree */
 	__uint8_t	bc_blocklog;	/* log2(blocksize) of btree blocks */
 	xfs_btnum_t	bc_btnum;	/* identifies which btree type */
 	union {
 		struct {			/* needed for BNO, CNT, INO */
 			struct xfs_buf	*agbp;	/* agf/agi buffer pointer */
 			xfs_agnumber_t	agno;	/* ag number */
 		} a;
 		struct {			/* needed for BMAP */
 			struct xfs_inode *ip;	/* pointer to our inode */
 			struct xfs_bmap_free *flist;	/* list to free after */
 			xfs_fsblock_t	firstblock;	/* 1st blk allocated */
 			int		allocated;	/* count of alloced */
 			short		forksize;	/* fork's inode space */
 			char		whichfork;	/* data or attr fork */
 			char		flags;		/* flags */
 #define	XFS_BTCUR_BPRV_WASDEL	1			/* was delayed */
 		} b;
 	}		bc_private;	/* per-btree type data */
 } xfs_btree_cur_t;
 /* cursor flags */
 #define XFS_BTREE_LONG_PTRS		(1<<0)	/* pointers are 64bits long */
 #define XFS_BTREE_ROOT_IN_INODE		(1<<1)	/* root may be variable size */
 #define XFS_BTREE_LASTREC_UPDATE	(1<<2)	/* track last rec externally */
 #define	XFS_BTREE_NOERROR	0
 #define	XFS_BTREE_ERROR		1
 /*
  * Convert from buffer to btree block header.
  */
 #define	XFS_BUF_TO_BLOCK(bp)	((xfs_btree_block_t *)XFS_BUF_PTR(bp))
 #define	XFS_BUF_TO_LBLOCK(bp)	((xfs_btree_lblock_t *)XFS_BUF_PTR(bp))
 #define	XFS_BUF_TO_SBLOCK(bp)	((xfs_btree_sblock_t *)XFS_BUF_PTR(bp))
 #ifdef __KERNEL__
 /*
  * Check that long form block header is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lblock(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_lblock	*block,	/* btree long form block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp);	/* buffer containing block, if any */
 /*
  * Check that short form block header is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_sblock(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_sblock	*block,	/* btree short form block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp);	/* buffer containing block */
 /*
  * Check that block header is ok.
  */
 int
 xfs_btree_check_block(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	struct xfs_btree_block	*block,	/* generic btree block pointer */
 	int			level,	/* level of the btree block */
 	struct xfs_buf		*bp);	/* buffer containing block, if any */
 /*
  * Check that (long) pointer is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	xfs_dfsbno_t		ptr,	/* btree block disk address */
 	int			level);	/* btree block level */
 #define xfs_btree_check_lptr_disk(cur, ptr, level) \
 	xfs_btree_check_lptr(cur, be64_to_cpu(ptr), level)
 /*
  * Check that (short) pointer is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_sptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	xfs_agblock_t		ptr,	/* btree block disk address */
 	int			level);	/* btree block level */
 /*
  * Check that (short) pointer is ok.
  */
 int					/* error (0 or EFSCORRUPTED) */
 xfs_btree_check_ptr(
 	struct xfs_btree_cur	*cur,	/* btree cursor */
 	union xfs_btree_ptr	*ptr,	/* btree block disk address */
 	int			index,	/* offset from ptr to check */
 	int			level);	/* btree block level */
 #ifdef DEBUG
 /*
  * Debug routine: check that keys are in the right order.
  */
 void
 xfs_btree_check_key(
 	xfs_btnum_t		btnum,	/* btree identifier */
 	void			*ak1,	/* pointer to left (lower) key */
 	void			*ak2);	/* pointer to right (higher) key */
 /*
  * Debug routine: check that records are in the right order.
  */
 void
 xfs_btree_check_rec(
 	xfs_btnum_t		btnum,	/* btree identifier */
 	void			*ar1,	/* pointer to left (lower) record */
 	void			*ar2);	/* pointer to right (higher) record */
 #else
 #define	xfs_btree_check_key(a, b, c)
 #define	xfs_btree_check_rec(a, b, c)
 #endif	/* DEBUG */
 /*
  * Delete the btree cursor.
  */
 void
 xfs_btree_del_cursor(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			error);	/* del because of error */
 /*
  * Duplicate the btree cursor.
  * Allocate a new one, copy the record, re-get the buffers.
  */
 int					/* error */
 xfs_btree_dup_cursor(
 	xfs_btree_cur_t		*cur,	/* input cursor */
 	xfs_btree_cur_t		**ncur);/* output cursor */
 /*
  * Change the cursor to point to the first record in the current block
  * at the given level.  Other levels are unaffected.
  */
 int					/* success=1, failure=0 */
 xfs_btree_firstrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level);	/* level to change */
 /*
  * Get a buffer for the block, return it with no data read.
  * Long-form addressing.
  */
 struct xfs_buf *				/* buffer for fsbno */
 xfs_btree_get_bufl(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_fsblock_t		fsbno,	/* file system block number */
 	uint			lock);	/* lock flags for get_buf */
 /*
  * Get a buffer for the block, return it with no data read.
  * Short-form addressing.
  */
 struct xfs_buf *				/* buffer for agno/agbno */
 xfs_btree_get_bufs(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_agnumber_t		agno,	/* allocation group number */
 	xfs_agblock_t		agbno,	/* allocation group block number */
 	uint			lock);	/* lock flags for get_buf */
 /*
  * Check for the cursor referring to the last block at the given level.
  */
 int					/* 1=is last block, 0=not last block */
 xfs_btree_islastblock(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level);	/* level to check */
 /*
  * Change the cursor to point to the last record in the current block
  * at the given level.  Other levels are unaffected.
  */
 int					/* success=1, failure=0 */
 xfs_btree_lastrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level);	/* level to change */
 /*
  * Compute first and last byte offsets for the fields given.
  * Interprets the offsets table, which contains struct field offsets.
  */
 void
 xfs_btree_offsets(
 	__int64_t		fields,	/* bitmask of fields */
 	const short		*offsets,/* table of field offsets */
 	int			nbits,	/* number of bits to inspect */
 	int			*first,	/* output: first byte offset */
 	int			*last);	/* output: last byte offset */
 /*
  * Get a buffer for the block, return it read in.
  * Long-form addressing.
  */
 int					/* error */
 xfs_btree_read_bufl(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_fsblock_t		fsbno,	/* file system block number */
 	uint			lock,	/* lock flags for read_buf */
 	struct xfs_buf		**bpp,	/* buffer for fsbno */
 	int			refval);/* ref count value for buffer */
 /*
  * Get a buffer for the block, return it read in.
  * Short-form addressing.
  */
 int					/* error */
 xfs_btree_read_bufs(
 	struct xfs_mount	*mp,	/* file system mount point */
 	struct xfs_trans	*tp,	/* transaction pointer */
 	xfs_agnumber_t		agno,	/* allocation group number */
 	xfs_agblock_t		agbno,	/* allocation group block number */
 	uint			lock,	/* lock flags for read_buf */
 	struct xfs_buf		**bpp,	/* buffer for agno/agbno */
 	int			refval);/* ref count value for buffer */
 /*
  * Read-ahead the block, don't wait for it, don't return a buffer.
  * Long-form addressing.
  */
 void					/* error */
 xfs_btree_reada_bufl(
 	struct xfs_mount	*mp,	/* file system mount point */
 	xfs_fsblock_t		fsbno,	/* file system block number */
 	xfs_extlen_t		count);	/* count of filesystem blocks */
 /*
  * Read-ahead the block, don't wait for it, don't return a buffer.
  * Short-form addressing.
  */
 void					/* error */
 xfs_btree_reada_bufs(
 	struct xfs_mount	*mp,	/* file system mount point */
 	xfs_agnumber_t		agno,	/* allocation group number */
 	xfs_agblock_t		agbno,	/* allocation group block number */
 	xfs_extlen_t		count);	/* count of filesystem blocks */
 /*
  * Read-ahead btree blocks, at the given level.
  * Bits in lr are set from XFS_BTCUR_{LEFT,RIGHT}RA.
  */
 int					/* readahead block count */
 xfs_btree_readahead(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			lev,	/* level in btree */
 	int			lr);	/* left/right bits */
 /*
  * Set the buffer for level "lev" in the cursor to bp, releasing
  * any previous buffer.
  */
 void
 xfs_btree_setbuf(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			lev,	/* level in btree */
 	struct xfs_buf		*bp);	/* new buffer to set */
 /*
  * Common btree core entry points.
  */
 int xfs_btree_increment(struct xfs_btree_cur *, int, int *);
 int xfs_btree_decrement(struct xfs_btree_cur *, int, int *);
 int xfs_btree_lookup(struct xfs_btree_cur *, xfs_lookup_t, int *);
 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 *);
 /*
  * Helpers.
  */
 static inline int xfs_btree_get_numrecs(struct xfs_btree_block *block)
 {
 	return be16_to_cpu(block->bb_numrecs);
 }
 static inline void xfs_btree_set_numrecs(struct xfs_btree_block *block,
 		__uint16_t numrecs)
 {
 	block->bb_numrecs = cpu_to_be16(numrecs);
 }
 static inline int xfs_btree_get_level(struct xfs_btree_block *block)
 {
 	return be16_to_cpu(block->bb_level);
 }
 #endif	/* __KERNEL__ */
 /*
  * Min and max functions for extlen, agblock, fileoff, and filblks types.
  */
 #define	XFS_EXTLEN_MIN(a,b)	min_t(xfs_extlen_t, (a), (b))
 #define	XFS_EXTLEN_MAX(a,b)	max_t(xfs_extlen_t, (a), (b))
 #define	XFS_AGBLOCK_MIN(a,b)	min_t(xfs_agblock_t, (a), (b))
 #define	XFS_AGBLOCK_MAX(a,b)	max_t(xfs_agblock_t, (a), (b))
 #define	XFS_FILEOFF_MIN(a,b)	min_t(xfs_fileoff_t, (a), (b))
 #define	XFS_FILEOFF_MAX(a,b)	max_t(xfs_fileoff_t, (a), (b))
 #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))
 #define	XFS_FSB_SANITY_CHECK(mp,fsb)	\
 	(XFS_FSB_TO_AGNO(mp, fsb) < mp->m_sb.sb_agcount && \
 		XFS_FSB_TO_AGBNO(mp, fsb) < mp->m_sb.sb_agblocks)
 #endif	/* __XFS_BTREE_H__ */

fs/xfs/xfs_ialloc_btree.c

Diff comments View file @ 687b890

 /*
  * Copyright (c) 2000-2001,2005 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
 #include "xfs_bit.h"
 #include "xfs_log.h"
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
 #include "xfs_error.h"
 STATIC void xfs_inobt_log_block(xfs_trans_t *, xfs_buf_t *, int);
 STATIC void xfs_inobt_log_keys(xfs_btree_cur_t *, xfs_buf_t *, int, int);
 STATIC void xfs_inobt_log_ptrs(xfs_btree_cur_t *, xfs_buf_t *, int, int);
 STATIC void xfs_inobt_log_recs(xfs_btree_cur_t *, xfs_buf_t *, int, int);
-STATIC int xfs_inobt_lshift(xfs_btree_cur_t *, int, int *);
 STATIC int xfs_inobt_newroot(xfs_btree_cur_t *, int *);
 STATIC int xfs_inobt_split(xfs_btree_cur_t *, int, xfs_agblock_t *,
 		xfs_inobt_key_t *, xfs_btree_cur_t **, int *);
 /*
  * Single level of the xfs_inobt_delete record deletion routine.
  * Delete record pointed to by cur/level.
  * Remove the record from its block then rebalance the tree.
  * Return 0 for error, 1 for done, 2 to go on to the next level.
  */
 STATIC int				/* error */
 xfs_inobt_delrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level,	/* level removing record from */
 	int			*stat)	/* fail/done/go-on */
 {
 	xfs_buf_t		*agbp;	/* buffer for a.g. inode header */
 	xfs_mount_t		*mp;	/* mount structure */
 	xfs_agi_t		*agi;	/* allocation group inode header */
 	xfs_inobt_block_t	*block;	/* btree block record/key lives in */
 	xfs_agblock_t		bno;	/* btree block number */
 	xfs_buf_t		*bp;	/* buffer for block */
 	int			error;	/* error return value */
 	int			i;	/* loop index */
 	xfs_inobt_key_t		key;	/* kp points here if block is level 0 */
 	xfs_inobt_key_t		*kp = NULL;	/* pointer to btree keys */
 	xfs_agblock_t		lbno;	/* left block's block number */
 	xfs_buf_t		*lbp;	/* left block's buffer pointer */
 	xfs_inobt_block_t	*left;	/* left btree block */
 	xfs_inobt_key_t		*lkp;	/* left block key pointer */
 	xfs_inobt_ptr_t		*lpp;	/* left block address pointer */
 	int			lrecs = 0;	/* number of records in left block */
 	xfs_inobt_rec_t		*lrp;	/* left block record pointer */
 	xfs_inobt_ptr_t		*pp = NULL;	/* pointer to btree addresses */
 	int			ptr;	/* index in btree block for this rec */
 	xfs_agblock_t		rbno;	/* right block's block number */
 	xfs_buf_t		*rbp;	/* right block's buffer pointer */
 	xfs_inobt_block_t	*right;	/* right btree block */
 	xfs_inobt_key_t		*rkp;	/* right block key pointer */
 	xfs_inobt_rec_t		*rp;	/* pointer to btree records */
 	xfs_inobt_ptr_t		*rpp;	/* right block address pointer */
 	int			rrecs = 0;	/* number of records in right block */
 	int			numrecs;
 	xfs_inobt_rec_t		*rrp;	/* right block record pointer */
 	xfs_btree_cur_t		*tcur;	/* temporary btree cursor */
 	mp = cur->bc_mp;
 	/*
 	 * Get the index of the entry being deleted, check for nothing there.
 	 */
 	ptr = cur->bc_ptrs[level];
 	if (ptr == 0) {
 		*stat = 0;
 		return 0;
 	}
 	/*
 	 * Get the buffer & block containing the record or key/ptr.
 	 */
 	bp = cur->bc_bufs[level];
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, level, bp)))
 		return error;
 #endif
 	/*
 	 * Fail if we're off the end of the block.
 	 */
 	numrecs = be16_to_cpu(block->bb_numrecs);
 	if (ptr > numrecs) {
 		*stat = 0;
 		return 0;
 	}
 	/*
 	 * It's a nonleaf.  Excise the key and ptr being deleted, by
 	 * sliding the entries past them down one.
 	 * Log the changed areas of the block.
 	 */
 	if (level > 0) {
 		kp = XFS_INOBT_KEY_ADDR(block, 1, cur);
 		pp = XFS_INOBT_PTR_ADDR(block, 1, cur);
 #ifdef DEBUG
 		for (i = ptr; i < numrecs; i++) {
 			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(pp[i]), level)))
 				return error;
 		}
 #endif
 		if (ptr < numrecs) {
 			memmove(&kp[ptr - 1], &kp[ptr],
 				(numrecs - ptr) * sizeof(*kp));
 			memmove(&pp[ptr - 1], &pp[ptr],
 				(numrecs - ptr) * sizeof(*kp));
 			xfs_inobt_log_keys(cur, bp, ptr, numrecs - 1);
 			xfs_inobt_log_ptrs(cur, bp, ptr, numrecs - 1);
 		}
 	}
 	/*
 	 * It's a leaf.  Excise the record being deleted, by sliding the
 	 * entries past it down one.  Log the changed areas of the block.
 	 */
 	else {
 		rp = XFS_INOBT_REC_ADDR(block, 1, cur);
 		if (ptr < numrecs) {
 			memmove(&rp[ptr - 1], &rp[ptr],
 				(numrecs - ptr) * sizeof(*rp));
 			xfs_inobt_log_recs(cur, bp, ptr, numrecs - 1);
 		}
 		/*
 		 * If it's the first record in the block, we'll need a key
 		 * structure to pass up to the next level (updkey).
 		 */
 		if (ptr == 1) {
 			key.ir_startino = rp->ir_startino;
 			kp = &key;
 		}
 	}
 	/*
 	 * Decrement and log the number of entries in the block.
 	 */
 	numrecs--;
 	block->bb_numrecs = cpu_to_be16(numrecs);
 	xfs_inobt_log_block(cur->bc_tp, bp, XFS_BB_NUMRECS);
 	/*
 	 * Is this the root level?  If so, we're almost done.
 	 */
 	if (level == cur->bc_nlevels - 1) {
 		/*
 		 * If this is the root level,
 		 * and there's only one entry left,
 		 * and it's NOT the leaf level,
 		 * then we can get rid of this level.
 		 */
 		if (numrecs == 1 && level > 0) {
 			agbp = cur->bc_private.a.agbp;
 			agi = XFS_BUF_TO_AGI(agbp);
 			/*
 			 * pp is still set to the first pointer in the block.
 			 * Make it the new root of the btree.
 			 */
 			bno = be32_to_cpu(agi->agi_root);
 			agi->agi_root = *pp;
 			be32_add_cpu(&agi->agi_level, -1);
 			/*
 			 * Free the block.
 			 */
 			if ((error = xfs_free_extent(cur->bc_tp,
 				XFS_AGB_TO_FSB(mp, cur->bc_private.a.agno, bno), 1)))
 				return error;
 			xfs_trans_binval(cur->bc_tp, bp);
 			xfs_ialloc_log_agi(cur->bc_tp, agbp,
 				XFS_AGI_ROOT | XFS_AGI_LEVEL);
 			/*
 			 * Update the cursor so there's one fewer level.
 			 */
 			cur->bc_bufs[level] = NULL;
 			cur->bc_nlevels--;
 		} else if (level > 0 &&
 			   (error = xfs_btree_decrement(cur, level, &i)))
 			return error;
 		*stat = 1;
 		return 0;
 	}
 	/*
 	 * If we deleted the leftmost entry in the block, update the
 	 * key values above us in the tree.
 	 */
 	if (ptr == 1 && (error = xfs_btree_updkey(cur, (union xfs_btree_key *)kp, level + 1)))
 		return error;
 	/*
 	 * If the number of records remaining in the block is at least
 	 * the minimum, we're done.
 	 */
 	if (numrecs >= XFS_INOBT_BLOCK_MINRECS(level, cur)) {
 		if (level > 0 &&
 		    (error = xfs_btree_decrement(cur, level, &i)))
 			return error;
 		*stat = 1;
 		return 0;
 	}
 	/*
 	 * Otherwise, we have to move some records around to keep the
 	 * tree balanced.  Look at the left and right sibling blocks to
 	 * see if we can re-balance by moving only one record.
 	 */
 	rbno = be32_to_cpu(block->bb_rightsib);
 	lbno = be32_to_cpu(block->bb_leftsib);
 	bno = NULLAGBLOCK;
 	ASSERT(rbno != NULLAGBLOCK || lbno != NULLAGBLOCK);
 	/*
 	 * Duplicate the cursor so our btree manipulations here won't
 	 * disrupt the next level up.
 	 */
 	if ((error = xfs_btree_dup_cursor(cur, &tcur)))
 		return error;
 	/*
 	 * If there's a right sibling, see if it's ok to shift an entry
 	 * out of it.
 	 */
 	if (rbno != NULLAGBLOCK) {
 		/*
 		 * Move the temp cursor to the last entry in the next block.
 		 * Actually any entry but the first would suffice.
 		 */
 		i = xfs_btree_lastrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		if ((error = xfs_btree_increment(tcur, level, &i)))
 			goto error0;
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		i = xfs_btree_lastrec(tcur, level);
 		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
 		/*
 		 * Grab a pointer to the block.
 		 */
 		rbp = tcur->bc_bufs[level];
 		right = XFS_BUF_TO_INOBT_BLOCK(rbp);
 #ifdef DEBUG
 		if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
 			goto error0;
 #endif
 		/*
 		 * Grab the current block number, for future use.
 		 */
 		bno = be32_to_cpu(right->bb_leftsib);
 		/*
 		 * If right block is full enough so that removing one entry
 		 * won't make it too empty, and left-shifting an entry out
 		 * of right to us works, we're done.
 		 */
 		if (be16_to_cpu(right->bb_numrecs) - 1 >=
 		     XFS_INOBT_BLOCK_MINRECS(level, cur)) {
-			if ((error = xfs_inobt_lshift(tcur, level, &i)))
+			if ((error = xfs_btree_lshift(tcur, level, &i)))
 				goto error0;
 			if (i) {
 				ASSERT(be16_to_cpu(block->bb_numrecs) >=
 				       XFS_INOBT_BLOCK_MINRECS(level, cur));
 				xfs_btree_del_cursor(tcur,
 						     XFS_BTREE_NOERROR);
 				if (level > 0 &&
 				    (error = xfs_btree_decrement(cur, level,
 						&i)))
 					return error;
 				*stat = 1;
 				return 0;
 			}
 		}
 		/*
 		 * Otherwise, grab the number of records in right for
 		 * future reference, and fix up the temp cursor to point
 		 * to our block again (last record).
 		 */
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		if (lbno != NULLAGBLOCK) {
 			xfs_btree_firstrec(tcur, level);
 			if ((error = xfs_btree_decrement(tcur, level, &i)))
 				goto error0;
 		}
 	}
 	/*
 	 * If there's a left sibling, see if it's ok to shift an entry
 	 * out of it.
 	 */
 	if (lbno != NULLAGBLOCK) {
 		/*
 		 * Move the temp cursor to the first entry in the
 		 * previous block.
 		 */
 		xfs_btree_firstrec(tcur, level);
 		if ((error = xfs_btree_decrement(tcur, level, &i)))
 			goto error0;
 		xfs_btree_firstrec(tcur, level);
 		/*
 		 * Grab a pointer to the block.
 		 */
 		lbp = tcur->bc_bufs[level];
 		left = XFS_BUF_TO_INOBT_BLOCK(lbp);
 #ifdef DEBUG
 		if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
 			goto error0;
 #endif
 		/*
 		 * Grab the current block number, for future use.
 		 */
 		bno = be32_to_cpu(left->bb_rightsib);
 		/*
 		 * If left block is full enough so that removing one entry
 		 * won't make it too empty, and right-shifting an entry out
 		 * of left to us works, we're done.
 		 */
 		if (be16_to_cpu(left->bb_numrecs) - 1 >=
 		     XFS_INOBT_BLOCK_MINRECS(level, cur)) {
 			if ((error = xfs_btree_rshift(tcur, level, &i)))
 				goto error0;
 			if (i) {
 				ASSERT(be16_to_cpu(block->bb_numrecs) >=
 				       XFS_INOBT_BLOCK_MINRECS(level, cur));
 				xfs_btree_del_cursor(tcur,
 						     XFS_BTREE_NOERROR);
 				if (level == 0)
 					cur->bc_ptrs[0]++;
 				*stat = 1;
 				return 0;
 			}
 		}
 		/*
 		 * Otherwise, grab the number of records in right for
 		 * future reference.
 		 */
 		lrecs = be16_to_cpu(left->bb_numrecs);
 	}
 	/*
 	 * Delete the temp cursor, we're done with it.
 	 */
 	xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
 	/*
 	 * If here, we need to do a join to keep the tree balanced.
 	 */
 	ASSERT(bno != NULLAGBLOCK);
 	/*
 	 * See if we can join with the left neighbor block.
 	 */
 	if (lbno != NULLAGBLOCK &&
 	    lrecs + numrecs <= XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
 		/*
 		 * Set "right" to be the starting block,
 		 * "left" to be the left neighbor.
 		 */
 		rbno = bno;
 		right = block;
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		rbp = bp;
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, lbno, 0, &lbp,
 				XFS_INO_BTREE_REF)))
 			return error;
 		left = XFS_BUF_TO_INOBT_BLOCK(lbp);
 		lrecs = be16_to_cpu(left->bb_numrecs);
 		if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
 			return error;
 	}
 	/*
 	 * If that won't work, see if we can join with the right neighbor block.
 	 */
 	else if (rbno != NULLAGBLOCK &&
 		 rrecs + numrecs <= XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
 		/*
 		 * Set "left" to be the starting block,
 		 * "right" to be the right neighbor.
 		 */
 		lbno = bno;
 		left = block;
 		lrecs = be16_to_cpu(left->bb_numrecs);
 		lbp = bp;
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, rbno, 0, &rbp,
 				XFS_INO_BTREE_REF)))
 			return error;
 		right = XFS_BUF_TO_INOBT_BLOCK(rbp);
 		rrecs = be16_to_cpu(right->bb_numrecs);
 		if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
 			return error;
 	}
 	/*
 	 * Otherwise, we can't fix the imbalance.
 	 * Just return.  This is probably a logic error, but it's not fatal.
 	 */
 	else {
 		if (level > 0 && (error = xfs_btree_decrement(cur, level, &i)))
 			return error;
 		*stat = 1;
 		return 0;
 	}
 	/*
 	 * We're now going to join "left" and "right" by moving all the stuff
 	 * in "right" to "left" and deleting "right".
 	 */
 	if (level > 0) {
 		/*
 		 * It's a non-leaf.  Move keys and pointers.
 		 */
 		lkp = XFS_INOBT_KEY_ADDR(left, lrecs + 1, cur);
 		lpp = XFS_INOBT_PTR_ADDR(left, lrecs + 1, cur);
 		rkp = XFS_INOBT_KEY_ADDR(right, 1, cur);
 		rpp = XFS_INOBT_PTR_ADDR(right, 1, cur);
 #ifdef DEBUG
 		for (i = 0; i < rrecs; i++) {
 			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(rpp[i]), level)))
 				return error;
 		}
 #endif
 		memcpy(lkp, rkp, rrecs * sizeof(*lkp));
 		memcpy(lpp, rpp, rrecs * sizeof(*lpp));
 		xfs_inobt_log_keys(cur, lbp, lrecs + 1, lrecs + rrecs);
 		xfs_inobt_log_ptrs(cur, lbp, lrecs + 1, lrecs + rrecs);
 	} else {
 		/*
 		 * It's a leaf.  Move records.
 		 */
 		lrp = XFS_INOBT_REC_ADDR(left, lrecs + 1, cur);
 		rrp = XFS_INOBT_REC_ADDR(right, 1, cur);
 		memcpy(lrp, rrp, rrecs * sizeof(*lrp));
 		xfs_inobt_log_recs(cur, lbp, lrecs + 1, lrecs + rrecs);
 	}
 	/*
 	 * If we joined with the left neighbor, set the buffer in the
 	 * cursor to the left block, and fix up the index.
 	 */
 	if (bp != lbp) {
 		xfs_btree_setbuf(cur, level, lbp);
 		cur->bc_ptrs[level] += lrecs;
 	}
 	/*
 	 * If we joined with the right neighbor and there's a level above
 	 * us, increment the cursor at that level.
 	 */
 	else if (level + 1 < cur->bc_nlevels &&
 		 (error = xfs_btree_increment(cur, level + 1, &i)))
 		return error;
 	/*
 	 * Fix up the number of records in the surviving block.
 	 */
 	lrecs += rrecs;
 	left->bb_numrecs = cpu_to_be16(lrecs);
 	/*
 	 * Fix up the right block pointer in the surviving block, and log it.
 	 */
 	left->bb_rightsib = right->bb_rightsib;
 	xfs_inobt_log_block(cur->bc_tp, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
 	/*
 	 * If there is a right sibling now, make it point to the
 	 * remaining block.
 	 */
 	if (be32_to_cpu(left->bb_rightsib) != NULLAGBLOCK) {
 		xfs_inobt_block_t	*rrblock;
 		xfs_buf_t		*rrbp;
 		if ((error = xfs_btree_read_bufs(mp, cur->bc_tp,
 				cur->bc_private.a.agno, be32_to_cpu(left->bb_rightsib), 0,
 				&rrbp, XFS_INO_BTREE_REF)))
 			return error;
 		rrblock = XFS_BUF_TO_INOBT_BLOCK(rrbp);
 		if ((error = xfs_btree_check_sblock(cur, rrblock, level, rrbp)))
 			return error;
 		rrblock->bb_leftsib = cpu_to_be32(lbno);
 		xfs_inobt_log_block(cur->bc_tp, rrbp, XFS_BB_LEFTSIB);
 	}
 	/*
 	 * Free the deleting block.
 	 */
 	if ((error = xfs_free_extent(cur->bc_tp, XFS_AGB_TO_FSB(mp,
 				     cur->bc_private.a.agno, rbno), 1)))
 		return error;
 	xfs_trans_binval(cur->bc_tp, rbp);
 	/*
 	 * Readjust the ptr at this level if it's not a leaf, since it's
 	 * still pointing at the deletion point, which makes the cursor
 	 * inconsistent.  If this makes the ptr 0, the caller fixes it up.
 	 * We can't use decrement because it would change the next level up.
 	 */
 	if (level > 0)
 		cur->bc_ptrs[level]--;
 	/*
 	 * Return value means the next level up has something to do.
 	 */
 	*stat = 2;
 	return 0;
 error0:
 	xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
 	return error;
 }
 /*
  * Insert one record/level.  Return information to the caller
  * allowing the next level up to proceed if necessary.
  */
 STATIC int				/* error */
 xfs_inobt_insrec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level,	/* level to insert record at */
 	xfs_agblock_t		*bnop,	/* i/o: block number inserted */
 	xfs_inobt_rec_t		*recp,	/* i/o: record data inserted */
 	xfs_btree_cur_t		**curp,	/* output: new cursor replacing cur */
 	int			*stat)	/* success/failure */
 {
 	xfs_inobt_block_t	*block;	/* btree block record/key lives in */
 	xfs_buf_t		*bp;	/* buffer for block */
 	int			error;	/* error return value */
 	int			i;	/* loop index */
 	xfs_inobt_key_t		key;	/* key value being inserted */
 	xfs_inobt_key_t		*kp=NULL;	/* pointer to btree keys */
 	xfs_agblock_t		nbno;	/* block number of allocated block */
 	xfs_btree_cur_t		*ncur;	/* new cursor to be used at next lvl */
 	xfs_inobt_key_t		nkey;	/* new key value, from split */
 	xfs_inobt_rec_t		nrec;	/* new record value, for caller */
 	int			numrecs;
 	int			optr;	/* old ptr value */
 	xfs_inobt_ptr_t		*pp;	/* pointer to btree addresses */
 	int			ptr;	/* index in btree block for this rec */
 	xfs_inobt_rec_t		*rp=NULL;	/* pointer to btree records */
 	/*
 	 * GCC doesn't understand the (arguably complex) control flow in
 	 * this function and complains about uninitialized structure fields
 	 * without this.
 	 */
 	memset(&nrec, 0, sizeof(nrec));
 	/*
 	 * If we made it to the root level, allocate a new root block
 	 * and we're done.
 	 */
 	if (level >= cur->bc_nlevels) {
 		error = xfs_inobt_newroot(cur, &i);
 		*bnop = NULLAGBLOCK;
 		*stat = i;
 		return error;
 	}
 	/*
 	 * Make a key out of the record data to be inserted, and save it.
 	 */
 	key.ir_startino = recp->ir_startino;
 	optr = ptr = cur->bc_ptrs[level];
 	/*
 	 * If we're off the left edge, return failure.
 	 */
 	if (ptr == 0) {
 		*stat = 0;
 		return 0;
 	}
 	/*
 	 * Get pointers to the btree buffer and block.
 	 */
 	bp = cur->bc_bufs[level];
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 	numrecs = be16_to_cpu(block->bb_numrecs);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, level, bp)))
 		return error;
 	/*
 	 * Check that the new entry is being inserted in the right place.
 	 */
 	if (ptr <= numrecs) {
 		if (level == 0) {
 			rp = XFS_INOBT_REC_ADDR(block, ptr, cur);
 			xfs_btree_check_rec(cur->bc_btnum, recp, rp);
 		} else {
 			kp = XFS_INOBT_KEY_ADDR(block, ptr, cur);
 			xfs_btree_check_key(cur->bc_btnum, &key, kp);
 		}
 	}
 #endif
 	nbno = NULLAGBLOCK;
 	ncur = NULL;
 	/*
 	 * If the block is full, we can't insert the new entry until we
 	 * make the block un-full.
 	 */
 	if (numrecs == XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
 		/*
 		 * First, try shifting an entry to the right neighbor.
 		 */
 		if ((error = xfs_btree_rshift(cur, level, &i)))
 			return error;
 		if (i) {
 			/* nothing */
 		}
 		/*
 		 * Next, try shifting an entry to the left neighbor.
 		 */
 		else {
-			if ((error = xfs_inobt_lshift(cur, level, &i)))
+			if ((error = xfs_btree_lshift(cur, level, &i)))
 				return error;
 			if (i) {
 				optr = ptr = cur->bc_ptrs[level];
 			} else {
 				/*
 				 * 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_inobt_split(cur, level, &nbno,
 						&nkey, &ncur, &i)))
 					return error;
 				if (i) {
 					bp = cur->bc_bufs[level];
 					block = XFS_BUF_TO_INOBT_BLOCK(bp);
 #ifdef DEBUG
 					if ((error = xfs_btree_check_sblock(cur,
 							block, level, bp)))
 						return error;
 #endif
 					ptr = cur->bc_ptrs[level];
 					nrec.ir_startino = nkey.ir_startino;
 				} else {
 					/*
 					 * Otherwise the insert fails.
 					 */
 					*stat = 0;
 					return 0;
 				}
 			}
 		}
 	}
 	/*
 	 * At this point we know there's room for our new entry in the block
 	 * we're pointing at.
 	 */
 	numrecs = be16_to_cpu(block->bb_numrecs);
 	if (level > 0) {
 		/*
 		 * It's a non-leaf entry.  Make a hole for the new data
 		 * in the key and ptr regions of the block.
 		 */
 		kp = XFS_INOBT_KEY_ADDR(block, 1, cur);
 		pp = XFS_INOBT_PTR_ADDR(block, 1, cur);
 #ifdef DEBUG
 		for (i = numrecs; i >= ptr; i--) {
 			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(pp[i - 1]), level)))
 				return error;
 		}
 #endif
 		memmove(&kp[ptr], &kp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*kp));
 		memmove(&pp[ptr], &pp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*pp));
 		/*
 		 * Now stuff the new data in, bump numrecs and log the new data.
 		 */
 #ifdef DEBUG
 		if ((error = xfs_btree_check_sptr(cur, *bnop, level)))
 			return error;
 #endif
 		kp[ptr - 1] = key;
 		pp[ptr - 1] = cpu_to_be32(*bnop);
 		numrecs++;
 		block->bb_numrecs = cpu_to_be16(numrecs);
 		xfs_inobt_log_keys(cur, bp, ptr, numrecs);
 		xfs_inobt_log_ptrs(cur, bp, ptr, numrecs);
 	} else {
 		/*
 		 * It's a leaf entry.  Make a hole for the new record.
 		 */
 		rp = XFS_INOBT_REC_ADDR(block, 1, cur);
 		memmove(&rp[ptr], &rp[ptr - 1],
 			(numrecs - ptr + 1) * sizeof(*rp));
 		/*
 		 * Now stuff the new record in, bump numrecs
 		 * and log the new data.
 		 */
 		rp[ptr - 1] = *recp;
 		numrecs++;
 		block->bb_numrecs = cpu_to_be16(numrecs);
 		xfs_inobt_log_recs(cur, bp, ptr, numrecs);
 	}
 	/*
 	 * Log the new number of records in the btree header.
 	 */
 	xfs_inobt_log_block(cur->bc_tp, bp, XFS_BB_NUMRECS);
 #ifdef DEBUG
 	/*
 	 * Check that the key/record is in the right place, now.
 	 */
 	if (ptr < numrecs) {
 		if (level == 0)
 			xfs_btree_check_rec(cur->bc_btnum, rp + ptr - 1,
 				rp + ptr);
 		else
 			xfs_btree_check_key(cur->bc_btnum, kp + ptr - 1,
 				kp + ptr);
 	}
 #endif
 	/*
 	 * If we inserted at the start of a block, update the parents' keys.
 	 */
 	if (optr == 1 && (error = xfs_btree_updkey(cur, (union xfs_btree_key *)&key, level + 1)))
 		return error;
 	/*
 	 * Return the new block number, if any.
 	 * If there is one, give back a record value and a cursor too.
 	 */
 	*bnop = nbno;
 	if (nbno != NULLAGBLOCK) {
 		*recp = nrec;
 		*curp = ncur;
 	}
 	*stat = 1;
 	return 0;
 }
 /*
  * Log header fields from a btree block.
  */
 STATIC void
 xfs_inobt_log_block(
 	xfs_trans_t		*tp,	/* transaction pointer */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			fields)	/* mask of fields: XFS_BB_... */
 {
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	static const short	offsets[] = {	/* table of offsets */
 		offsetof(xfs_inobt_block_t, bb_magic),
 		offsetof(xfs_inobt_block_t, bb_level),
 		offsetof(xfs_inobt_block_t, bb_numrecs),
 		offsetof(xfs_inobt_block_t, bb_leftsib),
 		offsetof(xfs_inobt_block_t, bb_rightsib),
 		sizeof(xfs_inobt_block_t)
 	};
 	xfs_btree_offsets(fields, offsets, XFS_BB_NUM_BITS, &first, &last);
 	xfs_trans_log_buf(tp, bp, first, last);
 }
 /*
  * Log keys from a btree block (nonleaf).
  */
 STATIC void
 xfs_inobt_log_keys(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			kfirst,	/* index of first key to log */
 	int			klast)	/* index of last key to log */
 {
 	xfs_inobt_block_t	*block;	/* btree block to log from */
 	int			first;	/* first byte offset logged */
 	xfs_inobt_key_t		*kp;	/* key pointer in btree block */
 	int			last;	/* last byte offset logged */
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 	kp = XFS_INOBT_KEY_ADDR(block, 1, cur);
 	first = (int)((xfs_caddr_t)&kp[kfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&kp[klast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(cur->bc_tp, bp, first, last);
 }
 /*
  * Log block pointer fields from a btree block (nonleaf).
  */
 STATIC void
 xfs_inobt_log_ptrs(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			pfirst,	/* index of first pointer to log */
 	int			plast)	/* index of last pointer to log */
 {
 	xfs_inobt_block_t	*block;	/* btree block to log from */
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	xfs_inobt_ptr_t		*pp;	/* block-pointer pointer in btree blk */
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 	pp = XFS_INOBT_PTR_ADDR(block, 1, cur);
 	first = (int)((xfs_caddr_t)&pp[pfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&pp[plast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(cur->bc_tp, bp, first, last);
 }
 /*
  * Log records from a btree block (leaf).
  */
 STATIC void
 xfs_inobt_log_recs(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_buf_t		*bp,	/* buffer containing btree block */
 	int			rfirst,	/* index of first record to log */
 	int			rlast)	/* index of last record to log */
 {
 	xfs_inobt_block_t	*block;	/* btree block to log from */
 	int			first;	/* first byte offset logged */
 	int			last;	/* last byte offset logged */
 	xfs_inobt_rec_t		*rp;	/* record pointer for btree block */
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 	rp = XFS_INOBT_REC_ADDR(block, 1, cur);
 	first = (int)((xfs_caddr_t)&rp[rfirst - 1] - (xfs_caddr_t)block);
 	last = (int)(((xfs_caddr_t)&rp[rlast] - 1) - (xfs_caddr_t)block);
 	xfs_trans_log_buf(cur->bc_tp, bp, first, last);
-}
-/*
- * Move 1 record left from cur/level if possible.
- * Update cur to reflect the new path.
- */
-STATIC int				/* error */
-xfs_inobt_lshift(
-	xfs_btree_cur_t		*cur,	/* btree cursor */
-	int			level,	/* level to shift record on */
-	int			*stat)	/* success/failure */
-{
-	int			error;	/* error return value */
-#ifdef DEBUG
-	int			i;	/* loop index */
-#endif
-	xfs_inobt_key_t		key;	/* key value for leaf level upward */
-	xfs_buf_t		*lbp;	/* buffer for left neighbor block */
-	xfs_inobt_block_t	*left;	/* left neighbor btree block */
-	xfs_inobt_key_t		*lkp=NULL;	/* key pointer for left block */
-	xfs_inobt_ptr_t		*lpp;	/* address pointer for left block */
-	xfs_inobt_rec_t		*lrp=NULL;	/* record pointer for left block */
-	int			nrec;	/* new number of left block entries */
-	xfs_buf_t		*rbp;	/* buffer for right (current) block */
-	xfs_inobt_block_t	*right;	/* right (current) btree block */
-	xfs_inobt_key_t		*rkp=NULL;	/* key pointer for right block */
-	xfs_inobt_ptr_t		*rpp=NULL;	/* address pointer for right block */
-	xfs_inobt_rec_t		*rrp=NULL;	/* record pointer for right block */
-	/*
-	 * Set up variables for this block as "right".
-	 */
-	rbp = cur->bc_bufs[level];
-	right = XFS_BUF_TO_INOBT_BLOCK(rbp);
-#ifdef DEBUG
-	if ((error = xfs_btree_check_sblock(cur, right, level, rbp)))
-		return error;
-#endif
-	/*
-	 * If we've got no left sibling then we can't shift an entry left.
-	 */
-	if (be32_to_cpu(right->bb_leftsib) == NULLAGBLOCK) {
-		*stat = 0;
-		return 0;
-	}
-	/*
-	 * If the cursor entry is the one that would be moved, don't
-	 * do it... it's too complicated.
-	 */
-	if (cur->bc_ptrs[level] <= 1) {
-		*stat = 0;
-		return 0;
-	}
-	/*
-	 * Set up the left neighbor as "left".
-	 */
-	if ((error = xfs_btree_read_bufs(cur->bc_mp, cur->bc_tp,
-			cur->bc_private.a.agno, be32_to_cpu(right->bb_leftsib),
-			0, &lbp, XFS_INO_BTREE_REF)))
-		return error;
-	left = XFS_BUF_TO_INOBT_BLOCK(lbp);
-	if ((error = xfs_btree_check_sblock(cur, left, level, lbp)))
-		return error;
-	/*
-	 * If it's full, it can't take another entry.
-	 */
-	if (be16_to_cpu(left->bb_numrecs) == XFS_INOBT_BLOCK_MAXRECS(level, cur)) {
-		*stat = 0;
-		return 0;
-	}
-	nrec = be16_to_cpu(left->bb_numrecs) + 1;
-	/*
-	 * If non-leaf, copy a key and a ptr to the left block.
-	 */
-	if (level > 0) {
-		lkp = XFS_INOBT_KEY_ADDR(left, nrec, cur);
-		rkp = XFS_INOBT_KEY_ADDR(right, 1, cur);
-		*lkp = *rkp;
-		xfs_inobt_log_keys(cur, lbp, nrec, nrec);
-		lpp = XFS_INOBT_PTR_ADDR(left, nrec, cur);
-		rpp = XFS_INOBT_PTR_ADDR(right, 1, cur);
-#ifdef DEBUG
-		if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(*rpp), level)))
-			return error;
-#endif
-		*lpp = *rpp;
-		xfs_inobt_log_ptrs(cur, lbp, nrec, nrec);
-	}
-	/*
-	 * If leaf, copy a record to the left block.
-	 */
-	else {
-		lrp = XFS_INOBT_REC_ADDR(left, nrec, cur);
-		rrp = XFS_INOBT_REC_ADDR(right, 1, cur);
-		*lrp = *rrp;
-		xfs_inobt_log_recs(cur, lbp, nrec, nrec);
-	}
-	/*
-	 * Bump and log left's numrecs, decrement and log right's numrecs.
-	 */
-	be16_add_cpu(&left->bb_numrecs, 1);
-	xfs_inobt_log_block(cur->bc_tp, lbp, XFS_BB_NUMRECS);
-#ifdef DEBUG
-	if (level > 0)
-		xfs_btree_check_key(cur->bc_btnum, lkp - 1, lkp);
-	else
-		xfs_btree_check_rec(cur->bc_btnum, lrp - 1, lrp);
-#endif
-	be16_add_cpu(&right->bb_numrecs, -1);
-	xfs_inobt_log_block(cur->bc_tp, rbp, XFS_BB_NUMRECS);
-	/*
-	 * Slide the contents of right down one entry.
-	 */
-	if (level > 0) {
-#ifdef DEBUG
-		for (i = 0; i < be16_to_cpu(right->bb_numrecs); i++) {
-			if ((error = xfs_btree_check_sptr(cur, be32_to_cpu(rpp[i + 1]),
-					level)))
-				return error;
-		}
-#endif
-		memmove(rkp, rkp + 1, be16_to_cpu(right->bb_numrecs) * sizeof(*rkp));
-		memmove(rpp, rpp + 1, be16_to_cpu(right->bb_numrecs) * sizeof(*rpp));
-		xfs_inobt_log_keys(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
-		xfs_inobt_log_ptrs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
-	} else {
-		memmove(rrp, rrp + 1, be16_to_cpu(right->bb_numrecs) * sizeof(*rrp));
-		xfs_inobt_log_recs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
-		key.ir_startino = rrp->ir_startino;
-		rkp = &key;
-	}
-	/*
-	 * Update the parent key values of right.
-	 */
-	if ((error = xfs_btree_updkey(cur, (union xfs_btree_key *)rkp, level + 1)))
-		return error;
-	/*
-	 * Slide the cursor value left one.
-	 */
-	cur->bc_ptrs[level]--;
-	*stat = 1;
-	return 0;
 }
 /*
  * Allocate a new root block, fill it in.
  */
 STATIC int				/* error */
 xfs_inobt_newroot(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			*stat)	/* success/failure */
 {
 	xfs_agi_t		*agi;	/* a.g. inode header */
 	xfs_alloc_arg_t		args;	/* allocation argument structure */
 	xfs_inobt_block_t	*block;	/* one half of the old root block */
 	xfs_buf_t		*bp;	/* buffer containing block */
 	int			error;	/* error return value */
 	xfs_inobt_key_t		*kp;	/* btree key pointer */
 	xfs_agblock_t		lbno;	/* left block number */
 	xfs_buf_t		*lbp;	/* left buffer pointer */
 	xfs_inobt_block_t	*left;	/* left btree block */
 	xfs_buf_t		*nbp;	/* new (root) buffer */
 	xfs_inobt_block_t	*new;	/* new (root) btree block */
 	int			nptr;	/* new value for key index, 1 or 2 */
 	xfs_inobt_ptr_t		*pp;	/* btree address pointer */
 	xfs_agblock_t		rbno;	/* right block number */
 	xfs_buf_t		*rbp;	/* right buffer pointer */
 	xfs_inobt_block_t	*right;	/* right btree block */
 	xfs_inobt_rec_t		*rp;	/* btree record pointer */
 	ASSERT(cur->bc_nlevels < XFS_IN_MAXLEVELS(cur->bc_mp));
 	/*
 	 * Get a block & a buffer.
 	 */
 	agi = XFS_BUF_TO_AGI(cur->bc_private.a.agbp);
 	args.tp = cur->bc_tp;
 	args.mp = cur->bc_mp;
 	args.fsbno = XFS_AGB_TO_FSB(args.mp, cur->bc_private.a.agno,
 		be32_to_cpu(agi->agi_root));
 	args.mod = args.minleft = args.alignment = args.total = args.wasdel =
 		args.isfl = args.userdata = args.minalignslop = 0;
 	args.minlen = args.maxlen = args.prod = 1;
 	args.type = XFS_ALLOCTYPE_NEAR_BNO;
 	if ((error = xfs_alloc_vextent(&args)))
 		return error;
 	/*
 	 * None available, we fail.
 	 */
 	if (args.fsbno == NULLFSBLOCK) {
 		*stat = 0;
 		return 0;
 	}
 	ASSERT(args.len == 1);
 	nbp = xfs_btree_get_bufs(args.mp, args.tp, args.agno, args.agbno, 0);
 	new = XFS_BUF_TO_INOBT_BLOCK(nbp);
 	/*
 	 * Set the root data in the a.g. inode structure.
 	 */
 	agi->agi_root = cpu_to_be32(args.agbno);
 	be32_add_cpu(&agi->agi_level, 1);
 	xfs_ialloc_log_agi(args.tp, cur->bc_private.a.agbp,
 		XFS_AGI_ROOT | XFS_AGI_LEVEL);
 	/*
 	 * At the previous root level there are now two blocks: the old
 	 * root, and the new block generated when it was split.
 	 * We don't know which one the cursor is pointing at, so we
 	 * set up variables "left" and "right" for each case.
 	 */
 	bp = cur->bc_bufs[cur->bc_nlevels - 1];
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, cur->bc_nlevels - 1, bp)))
 		return error;
 #endif
 	if (be32_to_cpu(block->bb_rightsib) != NULLAGBLOCK) {
 		/*
 		 * Our block is left, pick up the right block.
 		 */
 		lbp = bp;
 		lbno = XFS_DADDR_TO_AGBNO(args.mp, XFS_BUF_ADDR(lbp));
 		left = block;
 		rbno = be32_to_cpu(left->bb_rightsib);
 		if ((error = xfs_btree_read_bufs(args.mp, args.tp, args.agno,
 				rbno, 0, &rbp, XFS_INO_BTREE_REF)))
 			return error;
 		bp = rbp;
 		right = XFS_BUF_TO_INOBT_BLOCK(rbp);
 		if ((error = xfs_btree_check_sblock(cur, right,
 				cur->bc_nlevels - 1, rbp)))
 			return error;
 		nptr = 1;
 	} else {
 		/*
 		 * Our block is right, pick up the left block.
 		 */
 		rbp = bp;
 		rbno = XFS_DADDR_TO_AGBNO(args.mp, XFS_BUF_ADDR(rbp));
 		right = block;
 		lbno = be32_to_cpu(right->bb_leftsib);
 		if ((error = xfs_btree_read_bufs(args.mp, args.tp, args.agno,
 				lbno, 0, &lbp, XFS_INO_BTREE_REF)))
 			return error;
 		bp = lbp;
 		left = XFS_BUF_TO_INOBT_BLOCK(lbp);
 		if ((error = xfs_btree_check_sblock(cur, left,
 				cur->bc_nlevels - 1, lbp)))
 			return error;
 		nptr = 2;
 	}
 	/*
 	 * Fill in the new block's btree header and log it.
 	 */
 	new->bb_magic = cpu_to_be32(xfs_magics[cur->bc_btnum]);
 	new->bb_level = cpu_to_be16(cur->bc_nlevels);
 	new->bb_numrecs = cpu_to_be16(2);
 	new->bb_leftsib = cpu_to_be32(NULLAGBLOCK);
 	new->bb_rightsib = cpu_to_be32(NULLAGBLOCK);
 	xfs_inobt_log_block(args.tp, nbp, XFS_BB_ALL_BITS);
 	ASSERT(lbno != NULLAGBLOCK && rbno != NULLAGBLOCK);
 	/*
 	 * Fill in the key data in the new root.
 	 */
 	kp = XFS_INOBT_KEY_ADDR(new, 1, cur);
 	if (be16_to_cpu(left->bb_level) > 0) {
 		kp[0] = *XFS_INOBT_KEY_ADDR(left, 1, cur);
 		kp[1] = *XFS_INOBT_KEY_ADDR(right, 1, cur);
 	} else {
 		rp = XFS_INOBT_REC_ADDR(left, 1, cur);
 		kp[0].ir_startino = rp->ir_startino;
 		rp = XFS_INOBT_REC_ADDR(right, 1, cur);
 		kp[1].ir_startino = rp->ir_startino;
 	}
 	xfs_inobt_log_keys(cur, nbp, 1, 2);
 	/*
 	 * Fill in the pointer data in the new root.
 	 */
 	pp = XFS_INOBT_PTR_ADDR(new, 1, cur);
 	pp[0] = cpu_to_be32(lbno);
 	pp[1] = cpu_to_be32(rbno);
 	xfs_inobt_log_ptrs(cur, nbp, 1, 2);
 	/*
 	 * Fix up the cursor.
 	 */
 	xfs_btree_setbuf(cur, cur->bc_nlevels, nbp);
 	cur->bc_ptrs[cur->bc_nlevels] = nptr;
 	cur->bc_nlevels++;
 	*stat = 1;
 	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_inobt_split(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	int			level,	/* level to split */
 	xfs_agblock_t		*bnop,	/* output: block number allocated */
 	xfs_inobt_key_t		*keyp,	/* output: first key of new block */
 	xfs_btree_cur_t		**curp,	/* output: new cursor */
 	int			*stat)	/* success/failure */
 {
 	xfs_alloc_arg_t		args;	/* allocation argument structure */
 	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_inobt_block_t	*left;	/* left (current) btree block */
 	xfs_inobt_key_t		*lkp;	/* left btree key pointer */
 	xfs_inobt_ptr_t		*lpp;	/* left btree address pointer */
 	xfs_inobt_rec_t		*lrp;	/* left btree record pointer */
 	xfs_buf_t		*rbp;	/* buffer for right block */
 	xfs_inobt_block_t	*right;	/* right (new) btree block */
 	xfs_inobt_key_t		*rkp;	/* right btree key pointer */
 	xfs_inobt_ptr_t		*rpp;	/* right btree address pointer */
 	xfs_inobt_rec_t		*rrp;	/* right btree record pointer */
 	/*
 	 * Set up left block (current one).
 	 */
 	lbp = cur->bc_bufs[level];
 	args.tp = cur->bc_tp;
 	args.mp = cur->bc_mp;
 	lbno = XFS_DADDR_TO_AGBNO(args.mp, XFS_BUF_ADDR(lbp));
 	/*
 	 * Allocate the new block.
 	 * If we can't do it, we're toast.  Give up.
 	 */
 	args.fsbno = XFS_AGB_TO_FSB(args.mp, cur->bc_private.a.agno, lbno);
 	args.mod = args.minleft = args.alignment = args.total = args.wasdel =
 		args.isfl = args.userdata = args.minalignslop = 0;
 	args.minlen = args.maxlen = args.prod = 1;
 	args.type = XFS_ALLOCTYPE_NEAR_BNO;
 	if ((error = xfs_alloc_vextent(&args)))
 		return error;
 	if (args.fsbno == NULLFSBLOCK) {
 		*stat = 0;
 		return 0;
 	}
 	ASSERT(args.len == 1);
 	rbp = xfs_btree_get_bufs(args.mp, args.tp, args.agno, args.agbno, 0);
 	/*
 	 * Set up the new block as "right".
 	 */
 	right = XFS_BUF_TO_INOBT_BLOCK(rbp);
 	/*
 	 * "Left" is the current (according to the cursor) block.
 	 */
 	left = XFS_BUF_TO_INOBT_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) {
 		lkp = XFS_INOBT_KEY_ADDR(left, i, cur);
 		lpp = XFS_INOBT_PTR_ADDR(left, i, cur);
 		rkp = XFS_INOBT_KEY_ADDR(right, 1, cur);
 		rpp = XFS_INOBT_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_inobt_log_keys(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
 		xfs_inobt_log_ptrs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
 		*keyp = *rkp;
 	}
 	/*
 	 * For leaf blocks, copy records over to the new block.
 	 */
 	else {
 		lrp = XFS_INOBT_REC_ADDR(left, i, cur);
 		rrp = XFS_INOBT_REC_ADDR(right, 1, cur);
 		memcpy(rrp, lrp, be16_to_cpu(right->bb_numrecs) * sizeof(*rrp));
 		xfs_inobt_log_recs(cur, rbp, 1, be16_to_cpu(right->bb_numrecs));
 		keyp->ir_startino = rrp->ir_startino;
 	}
 	/*
 	 * Find the left block number by looking in the buffer.
 	 * Adjust numrecs, sibling pointers.
 	 */
 	be16_add_cpu(&left->bb_numrecs, -(be16_to_cpu(right->bb_numrecs)));
 	right->bb_rightsib = left->bb_rightsib;
 	left->bb_rightsib = cpu_to_be32(args.agbno);
 	right->bb_leftsib = cpu_to_be32(lbno);
 	xfs_inobt_log_block(args.tp, rbp, XFS_BB_ALL_BITS);
 	xfs_inobt_log_block(args.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_inobt_block_t	*rrblock;	/* rr btree block */
 		xfs_buf_t		*rrbp;		/* buffer for rrblock */
 		if ((error = xfs_btree_read_bufs(args.mp, args.tp, args.agno,
 				be32_to_cpu(right->bb_rightsib), 0, &rrbp,
 				XFS_INO_BTREE_REF)))
 			return error;
 		rrblock = XFS_BUF_TO_INOBT_BLOCK(rrbp);
 		if ((error = xfs_btree_check_sblock(cur, rrblock, level, rrbp)))
 			return error;
 		rrblock->bb_leftsib = cpu_to_be32(args.agbno);
 		xfs_inobt_log_block(args.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
 	 * 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 = args.agbno;
 	*stat = 1;
 	return 0;
 }
 /*
  * Externally visible routines.
  */
 /*
  * Delete the record pointed to by cur.
  * The cursor refers to the place where the record was (could be inserted)
  * when the operation returns.
  */
 int					/* error */
 xfs_inobt_delete(
 	xfs_btree_cur_t	*cur,		/* btree cursor */
 	int		*stat)		/* success/failure */
 {
 	int		error;
 	int		i;		/* result code */
 	int		level;		/* btree level */
 	/*
 	 * Go up the tree, starting at leaf level.
 	 * If 2 is returned then a join was done; go to the next level.
 	 * Otherwise we are done.
 	 */
 	for (level = 0, i = 2; i == 2; level++) {
 		if ((error = xfs_inobt_delrec(cur, level, &i)))
 			return error;
 	}
 	if (i == 0) {
 		for (level = 1; level < cur->bc_nlevels; level++) {
 			if (cur->bc_ptrs[level] == 0) {
 				if ((error = xfs_btree_decrement(cur, level, &i)))
 					return error;
 				break;
 			}
 		}
 	}
 	*stat = i;
 	return 0;
 }
 /*
  * Get the data from the pointed-to record.
  */
 int					/* error */
 xfs_inobt_get_rec(
 	xfs_btree_cur_t		*cur,	/* btree cursor */
 	xfs_agino_t		*ino,	/* output: starting inode of chunk */
 	__int32_t		*fcnt,	/* output: number of free inodes */
 	xfs_inofree_t		*free,	/* output: free inode mask */
 	int			*stat)	/* output: success/failure */
 {
 	xfs_inobt_block_t	*block;	/* btree block */
 	xfs_buf_t		*bp;	/* buffer containing btree block */
 #ifdef DEBUG
 	int			error;	/* error return value */
 #endif
 	int			ptr;	/* record number */
 	xfs_inobt_rec_t		*rec;	/* record data */
 	bp = cur->bc_bufs[0];
 	ptr = cur->bc_ptrs[0];
 	block = XFS_BUF_TO_INOBT_BLOCK(bp);
 #ifdef DEBUG
 	if ((error = xfs_btree_check_sblock(cur, block, 0, bp)))
 		return error;
 #endif
 	/*
 	 * Off the right end or left end, return failure.
 	 */
 	if (ptr > be16_to_cpu(block->bb_numrecs) || ptr <= 0) {
 		*stat = 0;
 		return 0;
 	}
 	/*
 	 * Point to the record and extract its data.
 	 */
 	rec = XFS_INOBT_REC_ADDR(block, ptr, cur);
 	*ino = be32_to_cpu(rec->ir_startino);
 	*fcnt = be32_to_cpu(rec->ir_freecount);
 	*free = be64_to_cpu(rec->ir_free);
 	*stat = 1;
 	return 0;
 }
 /*
  * Insert the current record at the point referenced by cur.
  * The cursor may be inconsistent on return if splits have been done.
  */
 int					/* error */
 xfs_inobt_insert(
 	xfs_btree_cur_t	*cur,		/* btree cursor */
 	int		*stat)		/* success/failure */
 {
 	int		error;		/* error return value */
 	int		i;		/* result value, 0 for failure */
 	int		level;		/* current level number in btree */
 	xfs_agblock_t	nbno;		/* new block number (split result) */
 	xfs_btree_cur_t	*ncur;		/* new cursor (split result) */
 	xfs_inobt_rec_t	nrec;		/* record being inserted this level */
 	xfs_btree_cur_t	*pcur;		/* previous level's cursor */
 	level = 0;
 	nbno = NULLAGBLOCK;
 	nrec.ir_startino = cpu_to_be32(cur->bc_rec.i.ir_startino);
 	nrec.ir_freecount = cpu_to_be32(cur->bc_rec.i.ir_freecount);
 	nrec.ir_free = cpu_to_be64(cur->bc_rec.i.ir_free);
 	ncur = NULL;
 	pcur = cur;
 	/*
 	 * Loop going up the tree, starting at the leaf level.
 	 * Stop when we don't get a split block, that must mean that
 	 * the insert is finished with this level.
 	 */
 	do {
 		/*
 		 * Insert nrec/nbno into this level of the tree.
 		 * Note if we fail, nbno will be null.
 		 */
 		if ((error = xfs_inobt_insrec(pcur, level++, &nbno, &nrec, &ncur,
 				&i))) {
 			if (pcur != cur)
 				xfs_btree_del_cursor(pcur, XFS_BTREE_ERROR);
 			return error;
 		}
 		/*
 		 * See if the cursor we just used is trash.
 		 * Can't trash the caller's cursor, but otherwise we should
 		 * if ncur is a new cursor or we're about to be done.
 		 */
 		if (pcur != cur && (ncur || nbno == NULLAGBLOCK)) {
 			cur->bc_nlevels = pcur->bc_nlevels;
 			xfs_btree_del_cursor(pcur, XFS_BTREE_NOERROR);
 		}
 		/*
 		 * If we got a new cursor, switch to it.
 		 */
 		if (ncur) {
 			pcur = ncur;
 			ncur = NULL;
 		}
 	} while (nbno != NULLAGBLOCK);
 	*stat = i;
 	return 0;
 }
 STATIC struct xfs_btree_cur *
 xfs_inobt_dup_cursor(
 	struct xfs_btree_cur	*cur)
 {
 	return xfs_inobt_init_cursor(cur->bc_mp, cur->bc_tp,
 			cur->bc_private.a.agbp, cur->bc_private.a.agno);
 }
 STATIC int
 xfs_inobt_get_maxrecs(
 	struct xfs_btree_cur	*cur,
 	int			level)
 {
 	return cur->bc_mp->m_inobt_mxr[level != 0];
 }
 STATIC void
 xfs_inobt_init_key_from_rec(
 	union xfs_btree_key	*key,
 	union xfs_btree_rec	*rec)
 {
 	key->inobt.ir_startino = rec->inobt.ir_startino;
 }
 /*
  * intial value of ptr for lookup
  */
 STATIC void
 xfs_inobt_init_ptr_from_cur(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_ptr	*ptr)
 {
 	struct xfs_agi		*agi = XFS_BUF_TO_AGI(cur->bc_private.a.agbp);
 	ASSERT(cur->bc_private.a.agno == be32_to_cpu(agi->agi_seqno));
 	ptr->s = agi->agi_root;
 }
 STATIC __int64_t
 xfs_inobt_key_diff(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key)
 {
 	return (__int64_t)be32_to_cpu(key->inobt.ir_startino) -
 			  cur->bc_rec.i.ir_startino;
 }
 #ifdef XFS_BTREE_TRACE
 ktrace_t	*xfs_inobt_trace_buf;
 STATIC void
 xfs_inobt_trace_enter(
 	struct xfs_btree_cur	*cur,
 	const char		*func,
 	char			*s,
 	int			type,
 	int			line,
 	__psunsigned_t		a0,
 	__psunsigned_t		a1,
 	__psunsigned_t		a2,
 	__psunsigned_t		a3,
 	__psunsigned_t		a4,
 	__psunsigned_t		a5,
 	__psunsigned_t		a6,
 	__psunsigned_t		a7,
 	__psunsigned_t		a8,
 	__psunsigned_t		a9,
 	__psunsigned_t		a10)
 {
 	ktrace_enter(xfs_inobt_trace_buf, (void *)(__psint_t)type,
 		(void *)func, (void *)s, NULL, (void *)cur,
 		(void *)a0, (void *)a1, (void *)a2, (void *)a3,
 		(void *)a4, (void *)a5, (void *)a6, (void *)a7,
 		(void *)a8, (void *)a9, (void *)a10);
 }
 STATIC void
 xfs_inobt_trace_cursor(
 	struct xfs_btree_cur	*cur,
 	__uint32_t		*s0,
 	__uint64_t		*l0,
 	__uint64_t		*l1)
 {
 	*s0 = cur->bc_private.a.agno;
 	*l0 = cur->bc_rec.i.ir_startino;
 	*l1 = cur->bc_rec.i.ir_free;
 }
 STATIC void
 xfs_inobt_trace_key(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_key	*key,
 	__uint64_t		*l0,
 	__uint64_t		*l1)
 {
 	*l0 = be32_to_cpu(key->inobt.ir_startino);
 	*l1 = 0;
 }
 STATIC void
 xfs_inobt_trace_record(
 	struct xfs_btree_cur	*cur,
 	union xfs_btree_rec	*rec,
 	__uint64_t		*l0,
 	__uint64_t		*l1,
 	__uint64_t		*l2)
 {
 	*l0 = be32_to_cpu(rec->inobt.ir_startino);
 	*l1 = be32_to_cpu(rec->inobt.ir_freecount);
 	*l2 = be64_to_cpu(rec->inobt.ir_free);
 }
 #endif /* XFS_BTREE_TRACE */
 static const struct xfs_btree_ops xfs_inobt_ops = {
 	.rec_len		= sizeof(xfs_inobt_rec_t),
 	.key_len		= sizeof(xfs_inobt_key_t),
 	.dup_cursor		= xfs_inobt_dup_cursor,
 	.get_maxrecs		= xfs_inobt_get_maxrecs,
 	.init_key_from_rec	= xfs_inobt_init_key_from_rec,
 	.init_ptr_from_cur	= xfs_inobt_init_ptr_from_cur,
 	.key_diff		= xfs_inobt_key_diff,
 #ifdef XFS_BTREE_TRACE
 	.trace_enter		= xfs_inobt_trace_enter,
 	.trace_cursor		= xfs_inobt_trace_cursor,
 	.trace_key		= xfs_inobt_trace_key,
 	.trace_record		= xfs_inobt_trace_record,
 #endif
 };
 /*
  * Allocate a new inode btree cursor.
  */
 struct xfs_btree_cur *				/* new inode btree cursor */
 xfs_inobt_init_cursor(
 	struct xfs_mount	*mp,		/* file system mount point */
 	struct xfs_trans	*tp,		/* transaction pointer */
 	struct xfs_buf		*agbp,		/* buffer for agi structure */
 	xfs_agnumber_t		agno)		/* allocation group number */
 {
 	struct xfs_agi		*agi = XFS_BUF_TO_AGI(agbp);
 	struct xfs_btree_cur	*cur;
 	cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_SLEEP);
 	cur->bc_tp = tp;
 	cur->bc_mp = mp;
 	cur->bc_nlevels = be32_to_cpu(agi->agi_level);
 	cur->bc_btnum = XFS_BTNUM_INO;
 	cur->bc_blocklog = mp->m_sb.sb_blocklog;
 	cur->bc_ops = &xfs_inobt_ops;
 	cur->bc_private.a.agbp = agbp;
 	cur->bc_private.a.agno = agno;
 	return cur;
 }