[XFS] implement generic xfs_btree_insert/insrec (4b22a571) · Commits · 戴 / test

fs/xfs/xfs_alloc.c

+5 −5

Original line number	Diff line number	Diff line
		@@ -408,7 +408,7 @@ xfs_alloc_fixup_trees(
		if ((error = xfs_alloc_lookup_eq(cnt_cur, nfbno1, nflen1, &i)))
		return error;
		XFS_WANT_CORRUPTED_RETURN(i == 0);
		if ((error = xfs_alloc_insert(cnt_cur, &i)))
		if ((error = xfs_btree_insert(cnt_cur, &i)))
		return error;
		XFS_WANT_CORRUPTED_RETURN(i == 1);
		}
		@@ -416,7 +416,7 @@ xfs_alloc_fixup_trees(
		if ((error = xfs_alloc_lookup_eq(cnt_cur, nfbno2, nflen2, &i)))
		return error;
		XFS_WANT_CORRUPTED_RETURN(i == 0);
		if ((error = xfs_alloc_insert(cnt_cur, &i)))
		if ((error = xfs_btree_insert(cnt_cur, &i)))
		return error;
		XFS_WANT_CORRUPTED_RETURN(i == 1);
		}
		@@ -444,7 +444,7 @@ xfs_alloc_fixup_trees(
		if ((error = xfs_alloc_lookup_eq(bno_cur, nfbno2, nflen2, &i)))
		return error;
		XFS_WANT_CORRUPTED_RETURN(i == 0);
		if ((error = xfs_alloc_insert(bno_cur, &i)))
		if ((error = xfs_btree_insert(bno_cur, &i)))
		return error;
		XFS_WANT_CORRUPTED_RETURN(i == 1);
		}
		@@ -1756,7 +1756,7 @@ xfs_free_ag_extent(
		else {
		nbno = bno;
		nlen = len;
		if ((error = xfs_alloc_insert(bno_cur, &i)))
		if ((error = xfs_btree_insert(bno_cur, &i)))
		goto error0;
		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
		}
		@@ -1768,7 +1768,7 @@ xfs_free_ag_extent(
		if ((error = xfs_alloc_lookup_eq(cnt_cur, nbno, nlen, &i)))
		goto error0;
		XFS_WANT_CORRUPTED_GOTO(i == 0, error0);
		if ((error = xfs_alloc_insert(cnt_cur, &i)))
		if ((error = xfs_btree_insert(cnt_cur, &i)))
		goto error0;
		XFS_WANT_CORRUPTED_GOTO(i == 1, error0);
		xfs_btree_del_cursor(cnt_cur, XFS_BTREE_NOERROR);

fs/xfs/xfs_alloc_btree.c

+30 −309

Original line number	Diff line number	Diff line
		@@ -582,256 +582,6 @@ error0:
		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_btree_new_root(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_btree_lshift(cur, level, &i)))
		return error;
		if (i)
		optr = ptr = cur->bc_ptrs[level];
		else {
		union xfs_btree_ptr bno = { .s = cpu_to_be32(nbno) };
		/*
		* Next, try splitting the current block in
		* half. If this works we have to re-set our
		* variables because we could be in a
		* different block now.
		*/
		if ((error = xfs_btree_split(cur, level, &bno,
		(union xfs_btree_key *)&nkey,
		&ncur, &i)))
		return error;
		nbno = be32_to_cpu(bno.s);
		if (i) {
		bp = cur->bc_bufs[level];
		block = XFS_BUF_TO_ALLOC_BLOCK(bp);
		#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.
		*/
		@@ -1019,65 +769,6 @@ xfs_alloc_get_rec(
		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(
		@@ -1170,6 +861,12 @@ xfs_allocbt_update_lastrec(
		return;
		len = rec->alloc.ar_blockcount;
		break;
		case LASTREC_INSREC:
		if (be32_to_cpu(rec->alloc.ar_blockcount) <=
		be32_to_cpu(agf->agf_longest))
		return;
		len = rec->alloc.ar_blockcount;
		break;
		default:
		ASSERT(0);
		return;
		@@ -1199,6 +896,28 @@ xfs_allocbt_init_key_from_rec(
		key->alloc.ar_blockcount = rec->alloc.ar_blockcount;
		}

		STATIC void
		xfs_allocbt_init_rec_from_key(
		union xfs_btree_key *key,
		union xfs_btree_rec *rec)
		{
		ASSERT(key->alloc.ar_startblock != 0);

		rec->alloc.ar_startblock = key->alloc.ar_startblock;
		rec->alloc.ar_blockcount = key->alloc.ar_blockcount;
		}

		STATIC void
		xfs_allocbt_init_rec_from_cur(
		struct xfs_btree_cur *cur,
		union xfs_btree_rec *rec)
		{
		ASSERT(cur->bc_rec.a.ar_startblock != 0);

		rec->alloc.ar_startblock = cpu_to_be32(cur->bc_rec.a.ar_startblock);
		rec->alloc.ar_blockcount = cpu_to_be32(cur->bc_rec.a.ar_blockcount);
		}

		STATIC void
		xfs_allocbt_init_ptr_from_cur(
		struct xfs_btree_cur *cur,
		@@ -1309,6 +1028,8 @@ static const struct xfs_btree_ops xfs_allocbt_ops = {
		.update_lastrec = xfs_allocbt_update_lastrec,
		.get_maxrecs = xfs_allocbt_get_maxrecs,
		.init_key_from_rec = xfs_allocbt_init_key_from_rec,
		.init_rec_from_key = xfs_allocbt_init_rec_from_key,
		.init_rec_from_cur = xfs_allocbt_init_rec_from_cur,
		.init_ptr_from_cur = xfs_allocbt_init_ptr_from_cur,
		.key_diff = xfs_allocbt_key_diff,

fs/xfs/xfs_alloc_btree.h

+0 −6

Original line number	Diff line number	Diff line
		@@ -107,12 +107,6 @@ extern int xfs_alloc_delete(struct xfs_btree_cur cur, int stat);
		extern int xfs_alloc_get_rec(struct xfs_btree_cur cur, xfs_agblock_t bno,
		xfs_extlen_t len, int stat);

		/*
		* Insert the current record at the point referenced by cur.
		* The cursor may be inconsistent on return if splits have been done.
		*/
		extern int xfs_alloc_insert(struct xfs_btree_cur cur, int stat);


		extern struct xfs_btree_cur xfs_allocbt_init_cursor(struct xfs_mount ,
		struct xfs_trans , struct xfs_buf ,

fs/xfs/xfs_bmap.c

+10 −10

Original line number	Diff line number	Diff line
		@@ -977,7 +977,7 @@ xfs_bmap_add_extent_delay_real(
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		cur->bc_rec.b.br_state = XFS_EXT_NORM;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -1053,7 +1053,7 @@ xfs_bmap_add_extent_delay_real(
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		cur->bc_rec.b.br_state = XFS_EXT_NORM;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -1143,7 +1143,7 @@ xfs_bmap_add_extent_delay_real(
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		cur->bc_rec.b.br_state = XFS_EXT_NORM;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -1198,7 +1198,7 @@ xfs_bmap_add_extent_delay_real(
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		cur->bc_rec.b.br_state = XFS_EXT_NORM;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -1651,7 +1651,7 @@ xfs_bmap_add_extent_unwritten_real(
		oldext)))
		goto done;
		cur->bc_rec.b = *new;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -1741,7 +1741,7 @@ xfs_bmap_add_extent_unwritten_real(
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		cur->bc_rec.b.br_state = XFS_EXT_NORM;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -1789,7 +1789,7 @@ xfs_bmap_add_extent_unwritten_real(
		cur->bc_rec.b = PREV;
		cur->bc_rec.b.br_blockcount =
		new->br_startoff - PREV.br_startoff;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		/*
		@@ -1804,7 +1804,7 @@ xfs_bmap_add_extent_unwritten_real(
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		/* new middle extent - newext */
		cur->bc_rec.b.br_state = new->br_state;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -2264,7 +2264,7 @@ xfs_bmap_add_extent_hole_real(
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 0, done);
		cur->bc_rec.b.br_state = new->br_state;
		if ((error = xfs_bmbt_insert(cur, &i)))
		if ((error = xfs_btree_insert(cur, &i)))
		goto done;
		XFS_WANT_CORRUPTED_GOTO(i == 1, done);
		}
		@@ -3303,7 +3303,7 @@ xfs_bmap_del_extent(
		if ((error = xfs_btree_increment(cur, 0, &i)))
		goto done;
		cur->bc_rec.b = new;
		error = xfs_bmbt_insert(cur, &i);
		error = xfs_btree_insert(cur, &i);
		if (error && error != ENOSPC)
		goto done;
		/*

fs/xfs/xfs_bmap_btree.c

+55 −253

Original line number	Diff line number	Diff line
		@@ -456,198 +456,6 @@ error0:
		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_btree_new_iroot(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_btree_lshift(cur, level, &i))) {
		XFS_BMBT_TRACE_CURSOR(cur, ERROR);
		return error;
		}
		if (i) {
		optr = ptr = cur->bc_ptrs[level];
		} else {
		union xfs_btree_ptr bno = { .l = cpu_to_be64(nbno) };
		union xfs_btree_key skey;
		if ((error = xfs_btree_split(cur, level,
		&bno, &skey, &ncur,
		&i))) {
		XFS_BMBT_TRACE_CURSOR(cur,
		ERROR);
		return error;
		}
		nbno = be64_to_cpu(bno.l);
		startoff = be64_to_cpu(skey.bmbt.br_startoff);
		if (i) {
		block = xfs_bmbt_get_block(
		cur, level, &bp);
		#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)
		@@ -1059,67 +867,6 @@ xfs_bmbt_disk_get_startoff(
		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.
		*/
		@@ -1450,6 +1197,21 @@ xfs_bmbt_dup_cursor(
		return new;
		}

		STATIC void
		xfs_bmbt_update_cursor(
		struct xfs_btree_cur *src,
		struct xfs_btree_cur *dst)
		{
		ASSERT((dst->bc_private.b.firstblock != NULLFSBLOCK) \|\|
		(dst->bc_private.b.ip->i_d.di_flags & XFS_DIFLAG_REALTIME));
		ASSERT(dst->bc_private.b.flist == src->bc_private.b.flist);

		dst->bc_private.b.allocated += src->bc_private.b.allocated;
		dst->bc_private.b.firstblock = src->bc_private.b.firstblock;

		src->bc_private.b.allocated = 0;
		}

		STATIC int
		xfs_bmbt_alloc_block(
		struct xfs_btree_cur *cur,
		@@ -1544,6 +1306,23 @@ xfs_bmbt_get_maxrecs(
		return XFS_BMAP_BLOCK_IMAXRECS(level, cur);
		}

		/*
		* Get the maximum records we could store in the on-disk format.
		*
		* For non-root nodes this is equivalent to xfs_bmbt_get_maxrecs, but
		* for the root node this checks the available space in the dinode fork
		* so that we can resize the in-memory buffer to match it. After a
		* resize to the maximum size this function returns the same value
		* as xfs_bmbt_get_maxrecs for the root node, too.
		*/
		STATIC int
		xfs_bmbt_get_dmaxrecs(
		struct xfs_btree_cur *cur,
		int level)
		{
		return XFS_BMAP_BLOCK_DMAXRECS(level, cur);
		}

		STATIC void
		xfs_bmbt_init_key_from_rec(
		union xfs_btree_key *key,
		@@ -1553,6 +1332,25 @@ xfs_bmbt_init_key_from_rec(
		cpu_to_be64(xfs_bmbt_disk_get_startoff(&rec->bmbt));
		}

		STATIC void
		xfs_bmbt_init_rec_from_key(
		union xfs_btree_key *key,
		union xfs_btree_rec *rec)
		{
		ASSERT(key->bmbt.br_startoff != 0);

		xfs_bmbt_disk_set_allf(&rec->bmbt, be64_to_cpu(key->bmbt.br_startoff),
		0, 0, XFS_EXT_NORM);
		}

		STATIC void
		xfs_bmbt_init_rec_from_cur(
		struct xfs_btree_cur *cur,
		union xfs_btree_rec *rec)
		{
		xfs_bmbt_disk_set_all(&rec->bmbt, &cur->bc_rec.b);
		}

		STATIC void
		xfs_bmbt_init_ptr_from_cur(
		struct xfs_btree_cur *cur,
		@@ -1660,9 +1458,13 @@ static const struct xfs_btree_ops xfs_bmbt_ops = {
		.key_len = sizeof(xfs_bmbt_key_t),

		.dup_cursor = xfs_bmbt_dup_cursor,
		.update_cursor = xfs_bmbt_update_cursor,
		.alloc_block = xfs_bmbt_alloc_block,
		.get_maxrecs = xfs_bmbt_get_maxrecs,
		.get_dmaxrecs = xfs_bmbt_get_dmaxrecs,
		.init_key_from_rec = xfs_bmbt_init_key_from_rec,
		.init_rec_from_key = xfs_bmbt_init_rec_from_key,
		.init_rec_from_cur = xfs_bmbt_init_rec_from_cur,
		.init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur,
		.key_diff = xfs_bmbt_key_diff,

Admin message