xfs/libxfs/xfs_btree.c

321 	const union xfs_btree_ptr	*ptr,
331 				be64_to_cpu((&ptr->l)[index])))
336 				be64_to_cpu((&ptr->l)[index])))
341 				be32_to_cpu((&ptr->s)[index])))
356 	const union xfs_btree_ptr	*ptr,
362 	error = __xfs_btree_check_ptr(cur, ptr, index, level);
593 	 * For each level current, re-get the buffer and copy the ptr value.
596 		new->bc_levels[i].ptr = cur->bc_levels[i].ptr;
634  * Non-Leaf:	| header | key 1 | key 2 | key N | ptr 1 | ptr 2 | ptr N |
661  * Non-Leaf:	| header | lo1 | hi1 | lo2 | hi2 | ... | ptr 1 | ptr 2 | ... |
883 	 * Set the ptr value to 1, that's the first record/key.
885 	cur->bc_levels[level].ptr = 1;
913 	 * Set the ptr value to numrecs, that's the last record/key.
915 	cur->bc_levels[level].ptr = be16_to_cpu(block->bb_numrecs);
1077 	const union xfs_btree_ptr	*ptr,
1082 	error = xfs_btree_check_ptr(cur, ptr, 0, 1);
1089 				be32_to_cpu(ptr->s));
1092 		*daddr = XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l));
1095 		*daddr = xfbno_to_daddr(be64_to_cpu(ptr->l));
1102  * Readahead @count btree blocks at the given @ptr location.
1105  * method of converting the ptr directly to a daddr available to us.
1110 	union xfs_btree_ptr	*ptr,
1115 	if (xfs_btree_ptr_to_daddr(cur, ptr, &daddr))
1156 	const union xfs_btree_ptr	*ptr)
1159 		return ptr->l == cpu_to_be64(NULLFSBLOCK);
1161 		return ptr->s == cpu_to_be32(NULLAGBLOCK);
1167 	union xfs_btree_ptr	*ptr)
1170 		ptr->l = cpu_to_be64(NULLFSBLOCK);
1172 		ptr->s = cpu_to_be32(NULLAGBLOCK);
1193 	union xfs_btree_ptr	*ptr,
1200 			ptr->l = block->bb_u.l.bb_rightsib;
1202 			ptr->l = block->bb_u.l.bb_leftsib;
1205 			ptr->s = block->bb_u.s.bb_rightsib;
1207 			ptr->s = block->bb_u.s.bb_leftsib;
1215 	const union xfs_btree_ptr	*ptr,
1222 			block->bb_u.l.bb_rightsib = ptr->l;
1224 			block->bb_u.l.bb_leftsib = ptr->l;
1227 			block->bb_u.s.bb_rightsib = ptr->s;
1229 			block->bb_u.s.bb_leftsib = ptr->s;
1332 	union xfs_btree_ptr	*ptr)
1336 		ptr->s = cpu_to_be32(xfs_daddr_to_agbno(cur->bc_mp,
1340 		ptr->l = cpu_to_be64(XFS_DADDR_TO_FSB(cur->bc_mp,
1344 		ptr->l = cpu_to_be64(xfs_daddr_to_xfbno(xfs_buf_daddr(bp)));
1360 	const union xfs_btree_ptr	*ptr,
1367 	error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
1381  * Read in the buffer at the given ptr and return the buffer and
1387 	const union xfs_btree_ptr	*ptr,
1399 	error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
1501 	union xfs_btree_ptr	*ptr,
1510 	dst_ptr = (char *)ptr + (dir * cur->bc_ops->ptr_len);
1511 	memmove(dst_ptr, ptr, numptrs * cur->bc_ops->ptr_len);
1663 	union xfs_btree_ptr	ptr;
1683 	if (++cur->bc_levels[level].ptr <= xfs_btree_get_numrecs(block))
1687 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1688 	if (xfs_btree_ptr_is_null(cur, &ptr))
1706 		if (++cur->bc_levels[lev].ptr <= xfs_btree_get_numrecs(block))
1734 		ptrp = xfs_btree_ptr_addr(cur, cur->bc_levels[lev].ptr, block);
1741 		cur->bc_levels[lev].ptr = 1;
1769 	union xfs_btree_ptr	ptr;
1777 	if (--cur->bc_levels[level].ptr > 0)
1790 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
1791 	if (xfs_btree_ptr_is_null(cur, &ptr))
1801 		if (--cur->bc_levels[lev].ptr > 0)
1828 		ptrp = xfs_btree_ptr_addr(cur, cur->bc_levels[lev].ptr, block);
1834 		cur->bc_levels[lev].ptr = xfs_btree_get_numrecs(block);
1879 	const union xfs_btree_ptr	*pp,	/* ptr to btree block */
1962 	union xfs_btree_ptr	*ptr)
1969 		ptr->l = 0;
1971 		ptr->s = cpu_to_be32(cur->bc_ag.afake->af_root);
1973 		cur->bc_ops->init_ptr_from_cur(cur, ptr);
1992 	union xfs_btree_ptr	*pp;	/* ptr to btree block */
1993 	union xfs_btree_ptr	ptr;	/* ptr to btree block */
2007 	xfs_btree_init_ptr_from_cur(cur, &ptr);
2008 	pp = &ptr;
2048 				cur->bc_levels[0].ptr = dir != XFS_LOOKUP_LE;
2101 			cur->bc_levels[level].ptr = keyno;
2112 		xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
2115 		    !xfs_btree_ptr_is_null(cur, &ptr)) {
2118 			cur->bc_levels[0].ptr = keyno;
2131 	cur->bc_levels[0].ptr = keyno;
2242 	int			ptr)
2244 	return (cur->bc_ops->geom_flags & XFS_BTGEO_OVERLAPPING) || ptr == 1;
2266 	int			ptr;
2290 		ptr = cur->bc_levels[level].ptr;
2291 		nlkey = xfs_btree_key_addr(cur, ptr, block);
2292 		nhkey = xfs_btree_high_key_addr(cur, ptr, block);
2298 		xfs_btree_log_keys(cur, bp, ptr, ptr);
2332 	int			ptr;
2347 	for (level++, ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
2357 		ptr = cur->bc_levels[level].ptr;
2358 		kp = xfs_btree_key_addr(cur, ptr, block);
2360 		xfs_btree_log_keys(cur, bp, ptr, ptr);
2379 	int			ptr;
2391 	ptr = cur->bc_levels[0].ptr;
2392 	rp = xfs_btree_rec_addr(cur, ptr, block);
2396 	xfs_btree_log_recs(cur, bp, ptr, ptr);
2399 	if (xfs_btree_needs_key_update(cur, ptr)) {
2456 	if (cur->bc_levels[level].ptr <= 1)
2483 	 * If non-leaf, copy a key and a ptr to the left block.
2591 	cur->bc_levels[level].ptr--;
2652 	if (cur->bc_levels[level].ptr >= lrecs)
2816 	union xfs_btree_ptr	lptr;		/* left sibling block ptr */
2819 	union xfs_btree_ptr	rptr;		/* right sibling block ptr */
2822 	union xfs_btree_ptr	rrptr;		/* right-right sibling ptr */
2867 	if ((lrecs & 1) && cur->bc_levels[level].ptr <= rrecs + 1)
2963 	if (cur->bc_levels[level].ptr > lrecs + 1) {
2965 		cur->bc_levels[level].ptr -= lrecs;
2975 		(*curp)->bc_levels[level + 1].ptr++;
3124 	cur->bc_levels[1].ptr = 1;
3176 	cur->bc_levels[level + 1].ptr = 1;
3295 	const union xfs_btree_ptr	*ptr,
3300 		cur->bc_ag.afake->af_root = be32_to_cpu(ptr->s);
3303 		cur->bc_ops->set_root(cur, ptr, inc);
3425 	cur->bc_levels[cur->bc_nlevels].ptr = nptr;
3444 	union xfs_btree_ptr	*nptr,	/* new btree ptr */
3483 		*oindex = *index = cur->bc_levels[level].ptr;
3498 	*index = cur->bc_levels[level].ptr;
3518 	union xfs_btree_ptr	nptr;	/* new block ptr */
3523 	int			ptr;	/* key/record index */
3545 	ptr = cur->bc_levels[level].ptr;
3546 	if (ptr == 0) {
3551 	optr = ptr;
3566 	if (ptr <= numrecs) {
3569 				xfs_btree_rec_addr(cur, ptr, block)));
3572 				xfs_btree_key_addr(cur, ptr, block)));
3584 					&optr, &ptr, &nptr, &ncur, lkey, stat);
3606 	XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr + 1);
3613 		kp = xfs_btree_key_addr(cur, ptr, block);
3614 		pp = xfs_btree_ptr_addr(cur, ptr, block);
3616 		for (i = numrecs - ptr; i >= 0; i--) {
3622 		xfs_btree_shift_keys(cur, kp, 1, numrecs - ptr + 1);
3623 		xfs_btree_shift_ptrs(cur, pp, 1, numrecs - ptr + 1);
3634 		xfs_btree_log_ptrs(cur, bp, ptr, numrecs);
3635 		xfs_btree_log_keys(cur, bp, ptr, numrecs);
3637 		if (ptr < numrecs) {
3639 				xfs_btree_key_addr(cur, ptr + 1, block)));
3646 		rp = xfs_btree_rec_addr(cur, ptr, block);
3648 		xfs_btree_shift_recs(cur, rp, 1, numrecs - ptr + 1);
3653 		xfs_btree_log_recs(cur, bp, ptr, numrecs);
3655 		if (ptr < numrecs) {
3657 				xfs_btree_rec_addr(cur, ptr + 1, block)));
3913 	union xfs_btree_ptr	ptr;
3953 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
3954 	ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
3955 	xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
3956 	ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
4040 	union xfs_btree_ptr	cptr;		/* current block ptr */
4044 	union xfs_btree_ptr	lptr;		/* left sibling block ptr */
4048 	int			ptr;		/* key/record index */
4049 	union xfs_btree_ptr	rptr;		/* right sibling block ptr */
4061 	ptr = cur->bc_levels[level].ptr;
4062 	if (ptr == 0) {
4067 	/* Get the buffer & block containing the record or key/ptr. */
4078 	if (ptr > numrecs) {
4084 	XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr);
4092 		lkp = xfs_btree_key_addr(cur, ptr + 1, block);
4093 		lpp = xfs_btree_ptr_addr(cur, ptr + 1, block);
4095 		for (i = 0; i < numrecs - ptr; i++) {
4101 		if (ptr < numrecs) {
4102 			xfs_btree_shift_keys(cur, lkp, -1, numrecs - ptr);
4103 			xfs_btree_shift_ptrs(cur, lpp, -1, numrecs - ptr);
4104 			xfs_btree_log_keys(cur, bp, ptr, numrecs - 1);
4105 			xfs_btree_log_ptrs(cur, bp, ptr, numrecs - 1);
4109 		if (ptr < numrecs) {
4111 				xfs_btree_rec_addr(cur, ptr + 1, block),
4112 				-1, numrecs - ptr);
4113 			xfs_btree_log_recs(cur, bp, ptr, numrecs - 1);
4170 	if (xfs_btree_needs_key_update(cur, ptr)) {
4367 					cur->bc_levels[0].ptr++;
4505 		cur->bc_levels[level].ptr += lrecs;
4520 	 * Readjust the ptr at this level if it's not a leaf, since it's
4522 	 * inconsistent.  If this makes the ptr 0, the caller fixes it up.
4526 		cur->bc_levels[level].ptr--;
4531 	 * bc_levels[level + 1].ptr points to the old block so that the caller
4589 			if (cur->bc_levels[level].ptr == 0) {
4615 	int			ptr;	/* record number */
4620 	ptr = cur->bc_levels[0].ptr;
4632 	if (ptr > xfs_btree_get_numrecs(block) || ptr <= 0) {
4640 	*recp = xfs_btree_rec_addr(cur, ptr, block);
4712 			union xfs_btree_ptr     *ptr;
4714 			ptr = xfs_btree_ptr_addr(cur, 1, block);
4715 			xfs_btree_readahead_ptr(cur, ptr, 1);
4718 			xfs_btree_copy_ptrs(cur, &lptr, ptr, 1);
5142 	union xfs_btree_ptr		ptr;
5157 	xfs_btree_init_ptr_from_cur(cur, &ptr);
5158 	error = xfs_btree_lookup_get_block(cur, level, &ptr, &block);
5168 	cur->bc_levels[level].ptr = 1;
5174 		if (cur->bc_levels[level].ptr >
5178 				cur->bc_levels[level + 1].ptr++;
5185 			recp = xfs_btree_rec_addr(cur, cur->bc_levels[0].ptr,
5207 			cur->bc_levels[level].ptr++;
5212 		lkp = xfs_btree_key_addr(cur, cur->bc_levels[level].ptr, block);
5213 		hkp = xfs_btree_high_key_addr(cur, cur->bc_levels[level].ptr,
5215 		pp = xfs_btree_ptr_addr(cur, cur->bc_levels[level].ptr, block);
5241 			cur->bc_levels[level].ptr = 1;
5244 		cur->bc_levels[level].ptr++;
5261 				cur->bc_levels[i].ptr = 0;
5506 	if (cur->bc_levels[0].ptr < xfs_btree_get_numrecs(block))