[XFS] add keys_inorder and recs_inorder btree methods

Add methods to check whether two keys/records are in the righ order. This replaces the xfs_btree_check_key and xfs_btree_check_rec methods. For the callers from xfs_bmap.c just opencode the bmbt-specific asserts. SGI-PV: 985583 SGI-Modid: xfs-linux-melb:xfs-kern:32208a 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>

[XFS] add keys_inorder and recs_inorder btree methods
Add methods to check whether two keys/records are in the righ order. This replaces the xfs_btree_check_key and xfs_btree_check_rec methods. For the callers from xfs_bmap.c just opencode the bmbt-specific asserts. SGI-PV: 985583 SGI-Modid: xfs-linux-melb:xfs-kern:32208a 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>
Christoph Hellwig · Lachlan McIlroy
1 parent fd6bcc5b63
Showing 6 changed files with 135 additions and 161 deletions Side-by-side Diff
fs/xfs/xfs_alloc_btree.c
fs/xfs/xfs_bmap.c
fs/xfs/xfs_bmap_btree.c
fs/xfs/xfs_btree.c
fs/xfs/xfs_btree.h
fs/xfs/xfs_ialloc_btree.c
@@ -311,6 +311,45 @@
 	return 0;
 }
  
+#ifdef DEBUG
+STATIC int
+xfs_allocbt_keys_inorder(
+	struct xfs_btree_cur	*cur,
+	union xfs_btree_key	*k1,
+	union xfs_btree_key	*k2)
+{
+	if (cur->bc_btnum == XFS_BTNUM_BNO) {
+		return be32_to_cpu(k1->alloc.ar_startblock) <
+		       be32_to_cpu(k2->alloc.ar_startblock);
+	} else {
+		return be32_to_cpu(k1->alloc.ar_blockcount) <
+			be32_to_cpu(k2->alloc.ar_blockcount) ||
+			(k1->alloc.ar_blockcount == k2->alloc.ar_blockcount &&
+			 be32_to_cpu(k1->alloc.ar_startblock) <
+			 be32_to_cpu(k2->alloc.ar_startblock));
+	}
+}
+
+STATIC int
+xfs_allocbt_recs_inorder(
+	struct xfs_btree_cur	*cur,
+	union xfs_btree_rec	*r1,
+	union xfs_btree_rec	*r2)
+{
+	if (cur->bc_btnum == XFS_BTNUM_BNO) {
+		return be32_to_cpu(r1->alloc.ar_startblock) +
+			be32_to_cpu(r1->alloc.ar_blockcount) <=
+			be32_to_cpu(r2->alloc.ar_startblock);
+	} else {
+		return be32_to_cpu(r1->alloc.ar_blockcount) <
+			be32_to_cpu(r2->alloc.ar_blockcount) ||
+			(r1->alloc.ar_blockcount == r2->alloc.ar_blockcount &&
+			 be32_to_cpu(r1->alloc.ar_startblock) <
+			 be32_to_cpu(r2->alloc.ar_startblock));
+	}
+}
+#endif	/* DEBUG */
+
 #ifdef XFS_BTREE_TRACE
 ktrace_t	*xfs_allocbt_trace_buf;
  
@@ -394,6 +433,11 @@
 	.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,
+
+#ifdef DEBUG
+	.keys_inorder		= xfs_allocbt_keys_inorder,
+	.recs_inorder		= xfs_allocbt_recs_inorder,
+#endif
  
 #ifdef XFS_BTREE_TRACE
 	.trace_enter		= xfs_allocbt_trace_enter,
@@ -6195,7 +6195,8 @@
 		}
  
 		if (prevp) {
-			xfs_btree_check_key(XFS_BTNUM_BMAP, prevp, keyp);
+			ASSERT(be64_to_cpu(prevp->br_startoff) <
+			       be64_to_cpu(keyp->br_startoff));
 		}
 		prevp = keyp;
  
  
@@ -6338,11 +6339,15 @@
  
 		ep = XFS_BTREE_REC_ADDR(xfs_bmbt, block, 1);
 		if (i) {
-			xfs_btree_check_rec(XFS_BTNUM_BMAP, &last, ep);
+			ASSERT(xfs_bmbt_disk_get_startoff(&last) +
+			       xfs_bmbt_disk_get_blockcount(&last) <=
+			       xfs_bmbt_disk_get_startoff(ep));
 		}
 		for (j = 1; j < num_recs; j++) {
 			nextp = XFS_BTREE_REC_ADDR(xfs_bmbt, block, j + 1);
-			xfs_btree_check_rec(XFS_BTNUM_BMAP, ep, nextp);
+			ASSERT(xfs_bmbt_disk_get_startoff(ep) +
+			       xfs_bmbt_disk_get_blockcount(ep) <=
+			       xfs_bmbt_disk_get_startoff(nextp));
 			ep = nextp;
 		}
  
@@ -699,6 +699,29 @@
 				      cur->bc_rec.b.br_startoff;
 }
  
+#ifdef DEBUG
+STATIC int
+xfs_bmbt_keys_inorder(
+	struct xfs_btree_cur	*cur,
+	union xfs_btree_key	*k1,
+	union xfs_btree_key	*k2)
+{
+	return be64_to_cpu(k1->bmbt.br_startoff) <
+		be64_to_cpu(k2->bmbt.br_startoff);
+}
+
+STATIC int
+xfs_bmbt_recs_inorder(
+	struct xfs_btree_cur	*cur,
+	union xfs_btree_rec	*r1,
+	union xfs_btree_rec	*r2)
+{
+	return xfs_bmbt_disk_get_startoff(&r1->bmbt) +
+		xfs_bmbt_disk_get_blockcount(&r1->bmbt) <=
+		xfs_bmbt_disk_get_startoff(&r2->bmbt);
+}
+#endif	/* DEBUG */
+
 #ifdef XFS_BTREE_TRACE
 ktrace_t	*xfs_bmbt_trace_buf;
  
@@ -800,6 +823,11 @@
 	.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,
+
+#ifdef DEBUG
+	.keys_inorder		= xfs_bmbt_keys_inorder,
+	.recs_inorder		= xfs_bmbt_recs_inorder,
+#endif
  
 #ifdef XFS_BTREE_TRACE
 	.trace_enter		= xfs_bmbt_trace_enter,
@@ -52,123 +52,7 @@
 	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 */
@@ -2032,9 +1916,8 @@
 		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);
+		ASSERT(cur->bc_ops->keys_inorder(cur,
+			xfs_btree_key_addr(cur, lrecs - 1, left), lkp));
 	} else {
 		/* It's a leaf.  Move records.  */
 		union xfs_btree_rec	*lrp;	/* left record pointer */
@@ -2045,9 +1928,8 @@
 		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);
+		ASSERT(cur->bc_ops->recs_inorder(cur,
+			xfs_btree_rec_addr(cur, lrecs - 1, left), lrp));
 	}
  
 	xfs_btree_set_numrecs(left, lrecs);
@@ -2222,8 +2104,8 @@
 		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));
+		ASSERT(cur->bc_ops->keys_inorder(cur, rkp,
+			xfs_btree_key_addr(cur, 2, right)));
 	} else {
 		/* It's a leaf. make a hole in the records */
 		union xfs_btree_rec	*lrp;
@@ -2241,8 +2123,8 @@
 		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));
+		ASSERT(cur->bc_ops->recs_inorder(cur, rrp,
+			xfs_btree_rec_addr(cur, 2, right)));
 	}
  
 	/*
  
@@ -2849,11 +2731,11 @@
 	/* Check that the new entry is being inserted in the right place. */
 	if (ptr <= numrecs) {
 		if (level == 0) {
-			xfs_btree_check_rec(cur->bc_btnum, recp,
-					xfs_btree_rec_addr(cur, ptr, block));
+			ASSERT(cur->bc_ops->recs_inorder(cur, recp,
+				xfs_btree_rec_addr(cur, ptr, block)));
 		} else {
-			xfs_btree_check_key(cur->bc_btnum, &key,
-					xfs_btree_key_addr(cur, ptr, block));
+			ASSERT(cur->bc_ops->keys_inorder(cur, &key,
+				xfs_btree_key_addr(cur, ptr, block)));
 		}
 	}
 #endif
@@ -2923,8 +2805,8 @@
 		xfs_btree_log_keys(cur, bp, ptr, numrecs);
 #ifdef DEBUG
 		if (ptr < numrecs) {
-			xfs_btree_check_key(cur->bc_btnum, kp,
-				xfs_btree_key_addr(cur, ptr + 1, block));
+			ASSERT(cur->bc_ops->keys_inorder(cur, kp,
+				xfs_btree_key_addr(cur, ptr + 1, block)));
 		}
 #endif
 	} else {
@@ -2941,8 +2823,8 @@
 		xfs_btree_log_recs(cur, bp, ptr, numrecs);
 #ifdef DEBUG
 		if (ptr < numrecs) {
-			xfs_btree_check_rec(cur->bc_btnum, rp,
-				xfs_btree_rec_addr(cur, ptr + 1, block));
+			ASSERT(cur->bc_ops->recs_inorder(cur, rp,
+				xfs_btree_rec_addr(cur, ptr + 1, block)));
 		}
 #endif
 	}
@@ -229,6 +229,18 @@
 	__int64_t (*key_diff)(struct xfs_btree_cur *cur,
 			      union xfs_btree_key *key);
  
+#ifdef DEBUG
+	/* check that k1 is lower than k2 */
+	int	(*keys_inorder)(struct xfs_btree_cur *cur,
+				union xfs_btree_key *k1,
+				union xfs_btree_key *k2);
+
+	/* check that r1 is lower than r2 */
+	int	(*recs_inorder)(struct xfs_btree_cur *cur,
+				union xfs_btree_rec *r1,
+				union xfs_btree_rec *r2);
+#endif
+
 	/* btree tracing */
 #ifdef XFS_BTREE_TRACE
 	void		(*trace_enter)(struct xfs_btree_cur *, const char *,
@@ -378,30 +390,6 @@
 	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.
@@ -219,6 +219,28 @@
 	return 0;
 }
  
+#ifdef DEBUG
+STATIC int
+xfs_inobt_keys_inorder(
+	struct xfs_btree_cur	*cur,
+	union xfs_btree_key	*k1,
+	union xfs_btree_key	*k2)
+{
+	return be32_to_cpu(k1->inobt.ir_startino) <
+		be32_to_cpu(k2->inobt.ir_startino);
+}
+
+STATIC int
+xfs_inobt_recs_inorder(
+	struct xfs_btree_cur	*cur,
+	union xfs_btree_rec	*r1,
+	union xfs_btree_rec	*r2)
+{
+	return be32_to_cpu(r1->inobt.ir_startino) + XFS_INODES_PER_CHUNK <=
+		be32_to_cpu(r2->inobt.ir_startino);
+}
+#endif	/* DEBUG */
+
 #ifdef XFS_BTREE_TRACE
 ktrace_t	*xfs_inobt_trace_buf;
  
@@ -301,6 +323,11 @@
 	.init_rec_from_cur	= xfs_inobt_init_rec_from_cur,
 	.init_ptr_from_cur	= xfs_inobt_init_ptr_from_cur,
 	.key_diff		= xfs_inobt_key_diff,
+
+#ifdef DEBUG
+	.keys_inorder		= xfs_inobt_keys_inorder,
+	.recs_inorder		= xfs_inobt_recs_inorder,
+#endif
  
 #ifdef XFS_BTREE_TRACE
 	.trace_enter		= xfs_inobt_trace_enter,
...	...	@@ -311,6 +311,45 @@
311	311	return 0;
312	312	}
313	313
	314	+#ifdef DEBUG
	315	+STATIC int
	316	+xfs_allocbt_keys_inorder(
	317	+ struct xfs_btree_cur *cur,
	318	+ union xfs_btree_key *k1,
	319	+ union xfs_btree_key *k2)
	320	+{
	321	+ if (cur->bc_btnum == XFS_BTNUM_BNO) {
	322	+ return be32_to_cpu(k1->alloc.ar_startblock) <
	323	+ be32_to_cpu(k2->alloc.ar_startblock);
	324	+ } else {
	325	+ return be32_to_cpu(k1->alloc.ar_blockcount) <
	326	+ be32_to_cpu(k2->alloc.ar_blockcount) \|\|
	327	+ (k1->alloc.ar_blockcount == k2->alloc.ar_blockcount &&
	328	+ be32_to_cpu(k1->alloc.ar_startblock) <
	329	+ be32_to_cpu(k2->alloc.ar_startblock));
	330	+ }
	331	+}
	332	+
	333	+STATIC int
	334	+xfs_allocbt_recs_inorder(
	335	+ struct xfs_btree_cur *cur,
	336	+ union xfs_btree_rec *r1,
	337	+ union xfs_btree_rec *r2)
	338	+{
	339	+ if (cur->bc_btnum == XFS_BTNUM_BNO) {
	340	+ return be32_to_cpu(r1->alloc.ar_startblock) +
	341	+ be32_to_cpu(r1->alloc.ar_blockcount) <=
	342	+ be32_to_cpu(r2->alloc.ar_startblock);
	343	+ } else {
	344	+ return be32_to_cpu(r1->alloc.ar_blockcount) <
	345	+ be32_to_cpu(r2->alloc.ar_blockcount) \|\|
	346	+ (r1->alloc.ar_blockcount == r2->alloc.ar_blockcount &&
	347	+ be32_to_cpu(r1->alloc.ar_startblock) <
	348	+ be32_to_cpu(r2->alloc.ar_startblock));
	349	+ }
	350	+}
	351	+#endif /* DEBUG */
	352	+
314	353	#ifdef XFS_BTREE_TRACE
315	354	ktrace_t *xfs_allocbt_trace_buf;
316	355
...	...	@@ -394,6 +433,11 @@
394	433	.init_rec_from_cur = xfs_allocbt_init_rec_from_cur,
395	434	.init_ptr_from_cur = xfs_allocbt_init_ptr_from_cur,
396	435	.key_diff = xfs_allocbt_key_diff,
	436	+
	437	+#ifdef DEBUG
	438	+ .keys_inorder = xfs_allocbt_keys_inorder,
	439	+ .recs_inorder = xfs_allocbt_recs_inorder,
	440	+#endif
397	441
398	442	#ifdef XFS_BTREE_TRACE
399	443	.trace_enter = xfs_allocbt_trace_enter,
...	...	@@ -6195,7 +6195,8 @@
6195	6195	}
6196	6196
6197	6197	if (prevp) {
6198		- xfs_btree_check_key(XFS_BTNUM_BMAP, prevp, keyp);
	6198	+ ASSERT(be64_to_cpu(prevp->br_startoff) <
	6199	+ be64_to_cpu(keyp->br_startoff));
6199	6200	}
6200	6201	prevp = keyp;
6201	6202
6202	6203
...	...	@@ -6338,11 +6339,15 @@
6338	6339
6339	6340	ep = XFS_BTREE_REC_ADDR(xfs_bmbt, block, 1);
6340	6341	if (i) {
6341		- xfs_btree_check_rec(XFS_BTNUM_BMAP, &last, ep);
	6342	+ ASSERT(xfs_bmbt_disk_get_startoff(&last) +
	6343	+ xfs_bmbt_disk_get_blockcount(&last) <=
	6344	+ xfs_bmbt_disk_get_startoff(ep));
6342	6345	}
6343	6346	for (j = 1; j < num_recs; j++) {
6344	6347	nextp = XFS_BTREE_REC_ADDR(xfs_bmbt, block, j + 1);
6345		- xfs_btree_check_rec(XFS_BTNUM_BMAP, ep, nextp);
	6348	+ ASSERT(xfs_bmbt_disk_get_startoff(ep) +
	6349	+ xfs_bmbt_disk_get_blockcount(ep) <=
	6350	+ xfs_bmbt_disk_get_startoff(nextp));
6346	6351	ep = nextp;
6347	6352	}
6348	6353
...	...	@@ -699,6 +699,29 @@
699	699	cur->bc_rec.b.br_startoff;
700	700	}
701	701
	702	+#ifdef DEBUG
	703	+STATIC int
	704	+xfs_bmbt_keys_inorder(
	705	+ struct xfs_btree_cur *cur,
	706	+ union xfs_btree_key *k1,
	707	+ union xfs_btree_key *k2)
	708	+{
	709	+ return be64_to_cpu(k1->bmbt.br_startoff) <
	710	+ be64_to_cpu(k2->bmbt.br_startoff);
	711	+}
	712	+
	713	+STATIC int
	714	+xfs_bmbt_recs_inorder(
	715	+ struct xfs_btree_cur *cur,
	716	+ union xfs_btree_rec *r1,
	717	+ union xfs_btree_rec *r2)
	718	+{
	719	+ return xfs_bmbt_disk_get_startoff(&r1->bmbt) +
	720	+ xfs_bmbt_disk_get_blockcount(&r1->bmbt) <=
	721	+ xfs_bmbt_disk_get_startoff(&r2->bmbt);
	722	+}
	723	+#endif /* DEBUG */
	724	+
702	725	#ifdef XFS_BTREE_TRACE
703	726	ktrace_t *xfs_bmbt_trace_buf;
704	727
...	...	@@ -800,6 +823,11 @@
800	823	.init_rec_from_cur = xfs_bmbt_init_rec_from_cur,
801	824	.init_ptr_from_cur = xfs_bmbt_init_ptr_from_cur,
802	825	.key_diff = xfs_bmbt_key_diff,
	826	+
	827	+#ifdef DEBUG
	828	+ .keys_inorder = xfs_bmbt_keys_inorder,
	829	+ .recs_inorder = xfs_bmbt_recs_inorder,
	830	+#endif
803	831
804	832	#ifdef XFS_BTREE_TRACE
805	833	.trace_enter = xfs_bmbt_trace_enter,
...	...	@@ -52,123 +52,7 @@
52	52	XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, XFS_BMAP_MAGIC, XFS_IBT_MAGIC
53	53	};
54	54
55		-/*
56		- * External routines.
57		- */
58	55
59		-#ifdef DEBUG
60		-/*
61		- * Debug routine: check that keys are in the right order.
62		- */
63		-void
64		-xfs_btree_check_key(
65		- xfs_btnum_t btnum, /* btree identifier */
66		- void ak1, / pointer to left (lower) key */
67		- void ak2) / pointer to right (higher) key */
68		-{
69		- switch (btnum) {
70		- case XFS_BTNUM_BNO: {
71		- xfs_alloc_key_t *k1;
72		- xfs_alloc_key_t *k2;
73		-
74		- k1 = ak1;
75		- k2 = ak2;
76		- ASSERT(be32_to_cpu(k1->ar_startblock) < be32_to_cpu(k2->ar_startblock));
77		- break;
78		- }
79		- case XFS_BTNUM_CNT: {
80		- xfs_alloc_key_t *k1;
81		- xfs_alloc_key_t *k2;
82		-
83		- k1 = ak1;
84		- k2 = ak2;
85		- ASSERT(be32_to_cpu(k1->ar_blockcount) < be32_to_cpu(k2->ar_blockcount) \|\|
86		- (k1->ar_blockcount == k2->ar_blockcount &&
87		- be32_to_cpu(k1->ar_startblock) < be32_to_cpu(k2->ar_startblock)));
88		- break;
89		- }
90		- case XFS_BTNUM_BMAP: {
91		- xfs_bmbt_key_t *k1;
92		- xfs_bmbt_key_t *k2;
93		-
94		- k1 = ak1;
95		- k2 = ak2;
96		- ASSERT(be64_to_cpu(k1->br_startoff) < be64_to_cpu(k2->br_startoff));
97		- break;
98		- }
99		- case XFS_BTNUM_INO: {
100		- xfs_inobt_key_t *k1;
101		- xfs_inobt_key_t *k2;
102		-
103		- k1 = ak1;
104		- k2 = ak2;
105		- ASSERT(be32_to_cpu(k1->ir_startino) < be32_to_cpu(k2->ir_startino));
106		- break;
107		- }
108		- default:
109		- ASSERT(0);
110		- }
111		-}
112		-
113		-/*
114		- * Debug routine: check that records are in the right order.
115		- */
116		-void
117		-xfs_btree_check_rec(
118		- xfs_btnum_t btnum, /* btree identifier */
119		- void ar1, / pointer to left (lower) record */
120		- void ar2) / pointer to right (higher) record */
121		-{
122		- switch (btnum) {
123		- case XFS_BTNUM_BNO: {
124		- xfs_alloc_rec_t *r1;
125		- xfs_alloc_rec_t *r2;
126		-
127		- r1 = ar1;
128		- r2 = ar2;
129		- ASSERT(be32_to_cpu(r1->ar_startblock) +
130		- be32_to_cpu(r1->ar_blockcount) <=
131		- be32_to_cpu(r2->ar_startblock));
132		- break;
133		- }
134		- case XFS_BTNUM_CNT: {
135		- xfs_alloc_rec_t *r1;
136		- xfs_alloc_rec_t *r2;
137		-
138		- r1 = ar1;
139		- r2 = ar2;
140		- ASSERT(be32_to_cpu(r1->ar_blockcount) < be32_to_cpu(r2->ar_blockcount) \|\|
141		- (r1->ar_blockcount == r2->ar_blockcount &&
142		- be32_to_cpu(r1->ar_startblock) < be32_to_cpu(r2->ar_startblock)));
143		- break;
144		- }
145		- case XFS_BTNUM_BMAP: {
146		- xfs_bmbt_rec_t *r1;
147		- xfs_bmbt_rec_t *r2;
148		-
149		- r1 = ar1;
150		- r2 = ar2;
151		- ASSERT(xfs_bmbt_disk_get_startoff(r1) +
152		- xfs_bmbt_disk_get_blockcount(r1) <=
153		- xfs_bmbt_disk_get_startoff(r2));
154		- break;
155		- }
156		- case XFS_BTNUM_INO: {
157		- xfs_inobt_rec_t *r1;
158		- xfs_inobt_rec_t *r2;
159		-
160		- r1 = ar1;
161		- r2 = ar2;
162		- ASSERT(be32_to_cpu(r1->ir_startino) + XFS_INODES_PER_CHUNK <=
163		- be32_to_cpu(r2->ir_startino));
164		- break;
165		- }
166		- default:
167		- ASSERT(0);
168		- }
169		-}
170		-#endif /* DEBUG */
171		-
172	56	int /* error (0 or EFSCORRUPTED) */
173	57	xfs_btree_check_lblock(
174	58	struct xfs_btree_cur cur, / btree cursor */
...	...	@@ -2032,9 +1916,8 @@
2032	1916	xfs_btree_log_keys(cur, lbp, lrecs, lrecs);
2033	1917	xfs_btree_log_ptrs(cur, lbp, lrecs, lrecs);
2034	1918
2035		- xfs_btree_check_key(cur->bc_btnum,
2036		- xfs_btree_key_addr(cur, lrecs - 1, left),
2037		- lkp);
	1919	+ ASSERT(cur->bc_ops->keys_inorder(cur,
	1920	+ xfs_btree_key_addr(cur, lrecs - 1, left), lkp));
2038	1921	} else {
2039	1922	/* It's a leaf. Move records. */
2040	1923	union xfs_btree_rec lrp; / left record pointer */
...	...	@@ -2045,9 +1928,8 @@
2045	1928	xfs_btree_copy_recs(cur, lrp, rrp, 1);
2046	1929	xfs_btree_log_recs(cur, lbp, lrecs, lrecs);
2047	1930
2048		- xfs_btree_check_rec(cur->bc_btnum,
2049		- xfs_btree_rec_addr(cur, lrecs - 1, left),
2050		- lrp);
	1931	+ ASSERT(cur->bc_ops->recs_inorder(cur,
	1932	+ xfs_btree_rec_addr(cur, lrecs - 1, left), lrp));
2051	1933	}
2052	1934
2053	1935	xfs_btree_set_numrecs(left, lrecs);
...	...	@@ -2222,8 +2104,8 @@
2222	2104	xfs_btree_log_keys(cur, rbp, 1, rrecs + 1);
2223	2105	xfs_btree_log_ptrs(cur, rbp, 1, rrecs + 1);
2224	2106
2225		- xfs_btree_check_key(cur->bc_btnum, rkp,
2226		- xfs_btree_key_addr(cur, 2, right));
	2107	+ ASSERT(cur->bc_ops->keys_inorder(cur, rkp,
	2108	+ xfs_btree_key_addr(cur, 2, right)));
2227	2109	} else {
2228	2110	/* It's a leaf. make a hole in the records */
2229	2111	union xfs_btree_rec *lrp;
...	...	@@ -2241,8 +2123,8 @@
2241	2123	cur->bc_ops->init_key_from_rec(&key, rrp);
2242	2124	rkp = &key;
2243	2125
2244		- xfs_btree_check_rec(cur->bc_btnum, rrp,
2245		- xfs_btree_rec_addr(cur, 2, right));
	2126	+ ASSERT(cur->bc_ops->recs_inorder(cur, rrp,
	2127	+ xfs_btree_rec_addr(cur, 2, right)));
2246	2128	}
2247	2129
2248	2130	/*
2249	2131
...	...	@@ -2849,11 +2731,11 @@
2849	2731	/* Check that the new entry is being inserted in the right place. */
2850	2732	if (ptr <= numrecs) {
2851	2733	if (level == 0) {
2852		- xfs_btree_check_rec(cur->bc_btnum, recp,
2853		- xfs_btree_rec_addr(cur, ptr, block));
	2734	+ ASSERT(cur->bc_ops->recs_inorder(cur, recp,
	2735	+ xfs_btree_rec_addr(cur, ptr, block)));
2854	2736	} else {
2855		- xfs_btree_check_key(cur->bc_btnum, &key,
2856		- xfs_btree_key_addr(cur, ptr, block));
	2737	+ ASSERT(cur->bc_ops->keys_inorder(cur, &key,
	2738	+ xfs_btree_key_addr(cur, ptr, block)));
2857	2739	}
2858	2740	}
2859	2741	#endif
...	...	@@ -2923,8 +2805,8 @@
2923	2805	xfs_btree_log_keys(cur, bp, ptr, numrecs);
2924	2806	#ifdef DEBUG
2925	2807	if (ptr < numrecs) {
2926		- xfs_btree_check_key(cur->bc_btnum, kp,
2927		- xfs_btree_key_addr(cur, ptr + 1, block));
	2808	+ ASSERT(cur->bc_ops->keys_inorder(cur, kp,
	2809	+ xfs_btree_key_addr(cur, ptr + 1, block)));
2928	2810	}
2929	2811	#endif
2930	2812	} else {
...	...	@@ -2941,8 +2823,8 @@
2941	2823	xfs_btree_log_recs(cur, bp, ptr, numrecs);
2942	2824	#ifdef DEBUG
2943	2825	if (ptr < numrecs) {
2944		- xfs_btree_check_rec(cur->bc_btnum, rp,
2945		- xfs_btree_rec_addr(cur, ptr + 1, block));
	2826	+ ASSERT(cur->bc_ops->recs_inorder(cur, rp,
	2827	+ xfs_btree_rec_addr(cur, ptr + 1, block)));
2946	2828	}
2947	2829	#endif
2948	2830	}
...	...	@@ -229,6 +229,18 @@
229	229	__int64_t (key_diff)(struct xfs_btree_cur cur,
230	230	union xfs_btree_key *key);
231	231
	232	+#ifdef DEBUG
	233	+ /* check that k1 is lower than k2 */
	234	+ int (keys_inorder)(struct xfs_btree_cur cur,
	235	+ union xfs_btree_key *k1,
	236	+ union xfs_btree_key *k2);
	237	+
	238	+ /* check that r1 is lower than r2 */
	239	+ int (recs_inorder)(struct xfs_btree_cur cur,
	240	+ union xfs_btree_rec *r1,
	241	+ union xfs_btree_rec *r2);
	242	+#endif
	243	+
232	244	/* btree tracing */
233	245	#ifdef XFS_BTREE_TRACE
234	246	void (trace_enter)(struct xfs_btree_cur , const char *,
...	...	@@ -378,30 +390,6 @@
378	390	union xfs_btree_ptr ptr, / btree block disk address */
379	391	int index, /* offset from ptr to check */
380	392	int level); /* btree block level */
381		-
382		-#ifdef DEBUG
383		-
384		-/*
385		- * Debug routine: check that keys are in the right order.
386		- */
387		-void
388		-xfs_btree_check_key(
389		- xfs_btnum_t btnum, /* btree identifier */
390		- void ak1, / pointer to left (lower) key */
391		- void ak2); / pointer to right (higher) key */
392		-
393		-/*
394		- * Debug routine: check that records are in the right order.
395		- */
396		-void
397		-xfs_btree_check_rec(
398		- xfs_btnum_t btnum, /* btree identifier */
399		- void ar1, / pointer to left (lower) record */
400		- void ar2); / pointer to right (higher) record */
401		-#else
402		-#define xfs_btree_check_key(a, b, c)
403		-#define xfs_btree_check_rec(a, b, c)
404		-#endif /* DEBUG */
405	393
406	394	/*
407	395	* Delete the btree cursor.
...	...	@@ -219,6 +219,28 @@
219	219	return 0;
220	220	}
221	221
	222	+#ifdef DEBUG
	223	+STATIC int
	224	+xfs_inobt_keys_inorder(
	225	+ struct xfs_btree_cur *cur,
	226	+ union xfs_btree_key *k1,
	227	+ union xfs_btree_key *k2)
	228	+{
	229	+ return be32_to_cpu(k1->inobt.ir_startino) <
	230	+ be32_to_cpu(k2->inobt.ir_startino);
	231	+}
	232	+
	233	+STATIC int
	234	+xfs_inobt_recs_inorder(
	235	+ struct xfs_btree_cur *cur,
	236	+ union xfs_btree_rec *r1,
	237	+ union xfs_btree_rec *r2)
	238	+{
	239	+ return be32_to_cpu(r1->inobt.ir_startino) + XFS_INODES_PER_CHUNK <=
	240	+ be32_to_cpu(r2->inobt.ir_startino);
	241	+}
	242	+#endif /* DEBUG */
	243	+
222	244	#ifdef XFS_BTREE_TRACE
223	245	ktrace_t *xfs_inobt_trace_buf;
224	246
...	...	@@ -301,6 +323,11 @@
301	323	.init_rec_from_cur = xfs_inobt_init_rec_from_cur,
302	324	.init_ptr_from_cur = xfs_inobt_init_ptr_from_cur,
303	325	.key_diff = xfs_inobt_key_diff,
	326	+
	327	+#ifdef DEBUG
	328	+ .keys_inorder = xfs_inobt_keys_inorder,
	329	+ .recs_inorder = xfs_inobt_recs_inorder,
	330	+#endif
304	331
305	332	#ifdef XFS_BTREE_TRACE
306	333	.trace_enter = xfs_inobt_trace_enter,