Lines Matching refs:cur
68 struct xfs_btree_cur *cur,
82 if (!xfs_btree_check_lptr(cur, sibling, level + 1))
95 struct xfs_btree_cur *cur,
109 if (!xfs_btree_check_sptr(cur, sibling, level + 1))
124 struct xfs_btree_cur *cur,
129 struct xfs_mount *mp = cur->bc_mp;
130 xfs_btnum_t btnum = cur->bc_btnum;
150 cur->bc_ops->get_maxrecs(cur, level))
156 fa = xfs_btree_check_lblock_siblings(mp, cur, level, fsb,
159 fa = xfs_btree_check_lblock_siblings(mp, cur, level, fsb,
167 struct xfs_btree_cur *cur,
172 struct xfs_mount *mp = cur->bc_mp;
175 fa = __xfs_btree_check_lblock(cur, block, level, bp);
191 struct xfs_btree_cur *cur,
196 struct xfs_mount *mp = cur->bc_mp;
197 struct xfs_perag *pag = cur->bc_ag.pag;
198 xfs_btnum_t btnum = cur->bc_btnum;
216 cur->bc_ops->get_maxrecs(cur, level))
222 fa = xfs_btree_check_sblock_siblings(pag, cur, level, agbno,
225 fa = xfs_btree_check_sblock_siblings(pag, cur, level, agbno,
233 struct xfs_btree_cur *cur,
238 struct xfs_mount *mp = cur->bc_mp;
241 fa = __xfs_btree_check_sblock(cur, block, level, bp);
256 struct xfs_btree_cur *cur, /* btree cursor */
261 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
262 return xfs_btree_check_lblock(cur, block, level, bp);
264 return xfs_btree_check_sblock(cur, block, level, bp);
270 struct xfs_btree_cur *cur,
276 return xfs_verify_fsbno(cur->bc_mp, fsbno);
282 struct xfs_btree_cur *cur,
288 return xfs_verify_agbno(cur->bc_ag.pag, agbno);
297 struct xfs_btree_cur *cur,
302 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
303 if (xfs_btree_check_lptr(cur, be64_to_cpu((&ptr->l)[index]),
306 xfs_err(cur->bc_mp,
308 cur->bc_ino.ip->i_ino,
309 cur->bc_ino.whichfork, cur->bc_btnum,
312 if (xfs_btree_check_sptr(cur, be32_to_cpu((&ptr->s)[index]),
315 xfs_err(cur->bc_mp,
317 cur->bc_ag.pag->pag_agno, cur->bc_btnum,
408 struct xfs_btree_cur *cur,
413 error = cur->bc_ops->free_block(cur, bp);
415 xfs_trans_binval(cur->bc_tp, bp);
416 XFS_BTREE_STATS_INC(cur, free);
426 struct xfs_btree_cur *cur, /* btree cursor */
438 for (i = 0; i < cur->bc_nlevels; i++) {
439 if (cur->bc_levels[i].bp)
440 xfs_trans_brelse(cur->bc_tp, cur->bc_levels[i].bp);
451 ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP || cur->bc_ino.allocated == 0 ||
452 xfs_is_shutdown(cur->bc_mp) || error != 0);
453 if (unlikely(cur->bc_flags & XFS_BTREE_STAGING))
454 kmem_free(cur->bc_ops);
455 if (!(cur->bc_flags & XFS_BTREE_LONG_PTRS) && cur->bc_ag.pag)
456 xfs_perag_put(cur->bc_ag.pag);
457 kmem_cache_free(cur->bc_cache, cur);
466 struct xfs_btree_cur *cur, /* input cursor */
476 tp = cur->bc_tp;
477 mp = cur->bc_mp;
482 new = cur->bc_ops->dup_cursor(cur);
487 new->bc_rec = cur->bc_rec;
493 new->bc_levels[i].ptr = cur->bc_levels[i].ptr;
494 new->bc_levels[i].ra = cur->bc_levels[i].ra;
495 bp = cur->bc_levels[i].bp;
500 cur->bc_ops->buf_ops);
590 static inline size_t xfs_btree_block_len(struct xfs_btree_cur *cur)
592 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
593 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS)
597 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS)
605 static inline size_t xfs_btree_ptr_len(struct xfs_btree_cur *cur)
607 return (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
616 struct xfs_btree_cur *cur,
619 return xfs_btree_block_len(cur) +
620 (n - 1) * cur->bc_ops->rec_len;
628 struct xfs_btree_cur *cur,
631 return xfs_btree_block_len(cur) +
632 (n - 1) * cur->bc_ops->key_len;
640 struct xfs_btree_cur *cur,
643 return xfs_btree_block_len(cur) +
644 (n - 1) * cur->bc_ops->key_len + (cur->bc_ops->key_len / 2);
652 struct xfs_btree_cur *cur,
656 return xfs_btree_block_len(cur) +
657 cur->bc_ops->get_maxrecs(cur, level) * cur->bc_ops->key_len +
658 (n - 1) * xfs_btree_ptr_len(cur);
666 struct xfs_btree_cur *cur,
671 ((char *)block + xfs_btree_rec_offset(cur, n));
679 struct xfs_btree_cur *cur,
684 ((char *)block + xfs_btree_key_offset(cur, n));
692 struct xfs_btree_cur *cur,
697 ((char *)block + xfs_btree_high_key_offset(cur, n));
705 struct xfs_btree_cur *cur,
714 ((char *)block + xfs_btree_ptr_offset(cur, n, level));
719 struct xfs_btree_cur *cur)
721 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
723 if (cur->bc_flags & XFS_BTREE_STAGING)
724 return cur->bc_ino.ifake->if_fork;
725 return xfs_ifork_ptr(cur->bc_ino.ip, cur->bc_ino.whichfork);
736 struct xfs_btree_cur *cur)
738 struct xfs_ifork *ifp = xfs_btree_ifork_ptr(cur);
749 struct xfs_btree_cur *cur, /* btree cursor */
753 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
754 (level == cur->bc_nlevels - 1)) {
756 return xfs_btree_get_iroot(cur);
759 *bpp = cur->bc_levels[level].bp;
769 struct xfs_btree_cur *cur, /* btree cursor */
778 block = xfs_btree_get_block(cur, level, &bp);
779 if (xfs_btree_check_block(cur, block, level, bp))
789 cur->bc_levels[level].ptr = 1;
799 struct xfs_btree_cur *cur, /* btree cursor */
808 block = xfs_btree_get_block(cur, level, &bp);
809 if (xfs_btree_check_block(cur, block, level, bp))
819 cur->bc_levels[level].ptr = be16_to_cpu(block->bb_numrecs);
931 struct xfs_btree_cur *cur,
940 xfs_btree_reada_bufl(cur->bc_mp, left, 1,
941 cur->bc_ops->buf_ops);
946 xfs_btree_reada_bufl(cur->bc_mp, right, 1,
947 cur->bc_ops->buf_ops);
956 struct xfs_btree_cur *cur,
966 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_ag.pag->pag_agno,
967 left, 1, cur->bc_ops->buf_ops);
972 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_ag.pag->pag_agno,
973 right, 1, cur->bc_ops->buf_ops);
986 struct xfs_btree_cur *cur, /* btree cursor */
996 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
997 (lev == cur->bc_nlevels - 1))
1000 if ((cur->bc_levels[lev].ra | lr) == cur->bc_levels[lev].ra)
1003 cur->bc_levels[lev].ra |= lr;
1004 block = XFS_BUF_TO_BLOCK(cur->bc_levels[lev].bp);
1006 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1007 return xfs_btree_readahead_lblock(cur, lr, block);
1008 return xfs_btree_readahead_sblock(cur, lr, block);
1013 struct xfs_btree_cur *cur,
1021 error = xfs_btree_check_ptr(cur, ptr, 0, 1);
1025 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1027 *daddr = XFS_FSB_TO_DADDR(cur->bc_mp, fsbno);
1030 *daddr = XFS_AGB_TO_DADDR(cur->bc_mp, cur->bc_ag.pag->pag_agno,
1045 struct xfs_btree_cur *cur,
1051 if (xfs_btree_ptr_to_daddr(cur, ptr, &daddr))
1053 xfs_buf_readahead(cur->bc_mp->m_ddev_targp, daddr,
1054 cur->bc_mp->m_bsize * count, cur->bc_ops->buf_ops);
1063 struct xfs_btree_cur *cur, /* btree cursor */
1069 if (cur->bc_levels[lev].bp)
1070 xfs_trans_brelse(cur->bc_tp, cur->bc_levels[lev].bp);
1071 cur->bc_levels[lev].bp = bp;
1072 cur->bc_levels[lev].ra = 0;
1075 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1077 cur->bc_levels[lev].ra |= XFS_BTCUR_LEFTRA;
1079 cur->bc_levels[lev].ra |= XFS_BTCUR_RIGHTRA;
1082 cur->bc_levels[lev].ra |= XFS_BTCUR_LEFTRA;
1084 cur->bc_levels[lev].ra |= XFS_BTCUR_RIGHTRA;
1090 struct xfs_btree_cur *cur,
1093 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1101 struct xfs_btree_cur *cur,
1104 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1115 struct xfs_btree_cur *cur,
1122 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1137 struct xfs_btree_cur *cur,
1144 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1215 struct xfs_btree_cur *cur,
1228 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1229 owner = cur->bc_ino.ip->i_ino;
1231 owner = cur->bc_ag.pag->pag_agno;
1233 xfs_btree_init_block_int(cur->bc_mp, XFS_BUF_TO_BLOCK(bp),
1234 xfs_buf_daddr(bp), cur->bc_btnum, level,
1235 numrecs, owner, cur->bc_flags);
1245 struct xfs_btree_cur *cur,
1253 if (!(cur->bc_flags & XFS_BTREE_LASTREC_UPDATE))
1256 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1257 if (!xfs_btree_ptr_is_null(cur, &ptr))
1264 struct xfs_btree_cur *cur,
1268 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1269 ptr->l = cpu_to_be64(XFS_DADDR_TO_FSB(cur->bc_mp,
1272 ptr->s = cpu_to_be32(xfs_daddr_to_agbno(cur->bc_mp,
1279 struct xfs_btree_cur *cur,
1282 switch (cur->bc_btnum) {
1307 struct xfs_btree_cur *cur,
1312 struct xfs_mount *mp = cur->bc_mp;
1316 error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
1319 error = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d, mp->m_bsize,
1324 (*bpp)->b_ops = cur->bc_ops->buf_ops;
1335 struct xfs_btree_cur *cur,
1341 struct xfs_mount *mp = cur->bc_mp;
1348 error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
1351 error = xfs_trans_read_buf(mp, cur->bc_tp, mp->m_ddev_targp, d,
1353 cur->bc_ops->buf_ops);
1357 xfs_btree_set_refs(cur, *bpp);
1367 struct xfs_btree_cur *cur,
1373 memcpy(dst_key, src_key, numkeys * cur->bc_ops->key_len);
1381 struct xfs_btree_cur *cur,
1387 memcpy(dst_rec, src_rec, numrecs * cur->bc_ops->rec_len);
1395 struct xfs_btree_cur *cur,
1401 memcpy(dst_ptr, src_ptr, numptrs * xfs_btree_ptr_len(cur));
1409 struct xfs_btree_cur *cur,
1419 dst_key = (char *)key + (dir * cur->bc_ops->key_len);
1420 memmove(dst_key, key, numkeys * cur->bc_ops->key_len);
1428 struct xfs_btree_cur *cur,
1438 dst_rec = (char *)rec + (dir * cur->bc_ops->rec_len);
1439 memmove(dst_rec, rec, numrecs * cur->bc_ops->rec_len);
1447 struct xfs_btree_cur *cur,
1457 dst_ptr = (char *)ptr + (dir * xfs_btree_ptr_len(cur));
1458 memmove(dst_ptr, ptr, numptrs * xfs_btree_ptr_len(cur));
1466 struct xfs_btree_cur *cur,
1473 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1474 xfs_trans_log_buf(cur->bc_tp, bp,
1475 xfs_btree_key_offset(cur, first),
1476 xfs_btree_key_offset(cur, last + 1) - 1);
1478 xfs_trans_log_inode(cur->bc_tp, cur->bc_ino.ip,
1479 xfs_ilog_fbroot(cur->bc_ino.whichfork));
1488 struct xfs_btree_cur *cur,
1494 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1495 xfs_trans_log_buf(cur->bc_tp, bp,
1496 xfs_btree_rec_offset(cur, first),
1497 xfs_btree_rec_offset(cur, last + 1) - 1);
1506 struct xfs_btree_cur *cur, /* btree cursor */
1516 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1517 xfs_trans_log_buf(cur->bc_tp, bp,
1518 xfs_btree_ptr_offset(cur, first, level),
1519 xfs_btree_ptr_offset(cur, last + 1, level) - 1);
1521 xfs_trans_log_inode(cur->bc_tp, cur->bc_ino.ip,
1522 xfs_ilog_fbroot(cur->bc_ino.whichfork));
1532 struct xfs_btree_cur *cur, /* btree cursor */
1569 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS) {
1584 (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
1587 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1588 xfs_trans_log_buf(cur->bc_tp, bp, first, last);
1590 xfs_trans_log_inode(cur->bc_tp, cur->bc_ino.ip,
1591 xfs_ilog_fbroot(cur->bc_ino.whichfork));
1601 struct xfs_btree_cur *cur,
1611 ASSERT(level < cur->bc_nlevels);
1614 xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
1617 block = xfs_btree_get_block(cur, level, &bp);
1620 error = xfs_btree_check_block(cur, block, level, bp);
1626 if (++cur->bc_levels[level].ptr <= xfs_btree_get_numrecs(block))
1630 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1631 if (xfs_btree_ptr_is_null(cur, &ptr))
1634 XFS_BTREE_STATS_INC(cur, increment);
1640 for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
1641 block = xfs_btree_get_block(cur, lev, &bp);
1644 error = xfs_btree_check_block(cur, block, lev, bp);
1649 if (++cur->bc_levels[lev].ptr <= xfs_btree_get_numrecs(block))
1653 xfs_btree_readahead(cur, lev, XFS_BTCUR_RIGHTRA);
1660 if (lev == cur->bc_nlevels) {
1661 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
1667 ASSERT(lev < cur->bc_nlevels);
1673 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
1676 ptrp = xfs_btree_ptr_addr(cur, cur->bc_levels[lev].ptr, block);
1678 error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp);
1682 xfs_btree_setbuf(cur, lev, bp);
1683 cur->bc_levels[lev].ptr = 1;
1703 struct xfs_btree_cur *cur,
1713 ASSERT(level < cur->bc_nlevels);
1716 xfs_btree_readahead(cur, level, XFS_BTCUR_LEFTRA);
1719 if (--cur->bc_levels[level].ptr > 0)
1723 block = xfs_btree_get_block(cur, level, &bp);
1726 error = xfs_btree_check_block(cur, block, level, bp);
1732 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
1733 if (xfs_btree_ptr_is_null(cur, &ptr))
1736 XFS_BTREE_STATS_INC(cur, decrement);
1742 for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
1743 if (--cur->bc_levels[lev].ptr > 0)
1746 xfs_btree_readahead(cur, lev, XFS_BTCUR_LEFTRA);
1753 if (lev == cur->bc_nlevels) {
1754 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
1760 ASSERT(lev < cur->bc_nlevels);
1766 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
1769 ptrp = xfs_btree_ptr_addr(cur, cur->bc_levels[lev].ptr, block);
1771 error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp);
1774 xfs_btree_setbuf(cur, lev, bp);
1775 cur->bc_levels[lev].ptr = xfs_btree_get_numrecs(block);
1791 struct xfs_btree_cur *cur, /* btree cursor */
1801 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
1802 (level == cur->bc_nlevels - 1)) {
1803 *blkp = xfs_btree_get_iroot(cur);
1813 bp = cur->bc_levels[level].bp;
1814 error = xfs_btree_ptr_to_daddr(cur, pp, &daddr);
1822 error = xfs_btree_read_buf_block(cur, pp, 0, blkp, &bp);
1827 if (xfs_has_crc(cur->bc_mp) &&
1828 !(cur->bc_ino.flags & XFS_BTCUR_BMBT_INVALID_OWNER) &&
1829 (cur->bc_flags & XFS_BTREE_LONG_PTRS) &&
1831 cur->bc_ino.ip->i_ino)
1842 xfs_btree_setbuf(cur, level, bp);
1848 xfs_trans_brelse(cur->bc_tp, bp);
1859 struct xfs_btree_cur *cur,
1866 cur->bc_ops->init_key_from_rec(kp,
1867 xfs_btree_rec_addr(cur, keyno, block));
1871 return xfs_btree_key_addr(cur, keyno, block);
1880 struct xfs_btree_cur *cur, /* btree cursor */
1892 XFS_BTREE_STATS_INC(cur, lookup);
1895 if (XFS_IS_CORRUPT(cur->bc_mp, cur->bc_nlevels == 0))
1902 cur->bc_ops->init_ptr_from_cur(cur, &ptr);
1911 for (level = cur->bc_nlevels - 1, diff = 1; level >= 0; level--) {
1913 error = xfs_btree_lookup_get_block(cur, level, pp, &block);
1934 if (level != 0 || cur->bc_nlevels != 1) {
1937 cur->bc_mp, block,
1942 cur->bc_levels[0].ptr = dir != XFS_LOOKUP_LE;
1952 XFS_BTREE_STATS_INC(cur, compare);
1958 kp = xfs_lookup_get_search_key(cur, level,
1967 diff = cur->bc_ops->key_diff(cur, kp);
1988 pp = xfs_btree_ptr_addr(cur, keyno, block);
1990 error = xfs_btree_debug_check_ptr(cur, pp, 0, level);
1994 cur->bc_levels[level].ptr = keyno;
2005 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
2008 !xfs_btree_ptr_is_null(cur, &ptr)) {
2011 cur->bc_levels[0].ptr = keyno;
2012 error = xfs_btree_increment(cur, 0, &i);
2015 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1))
2022 cur->bc_levels[0].ptr = keyno;
2040 struct xfs_btree_cur *cur,
2043 ASSERT(cur->bc_flags & XFS_BTREE_OVERLAPPING);
2045 (cur->bc_ops->key_len / 2));
2051 struct xfs_btree_cur *cur,
2061 rec = xfs_btree_rec_addr(cur, 1, block);
2062 cur->bc_ops->init_key_from_rec(key, rec);
2064 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2066 cur->bc_ops->init_high_key_from_rec(&max_hkey, rec);
2068 rec = xfs_btree_rec_addr(cur, n, block);
2069 cur->bc_ops->init_high_key_from_rec(&hkey, rec);
2070 if (xfs_btree_keycmp_gt(cur, &hkey, &max_hkey))
2074 high = xfs_btree_high_key_from_key(cur, key);
2075 memcpy(high, &max_hkey, cur->bc_ops->key_len / 2);
2082 struct xfs_btree_cur *cur,
2091 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2092 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2093 cur->bc_ops->key_len / 2);
2095 max_hkey = xfs_btree_high_key_addr(cur, 1, block);
2097 hkey = xfs_btree_high_key_addr(cur, n, block);
2098 if (xfs_btree_keycmp_gt(cur, hkey, max_hkey))
2102 high = xfs_btree_high_key_from_key(cur, key);
2103 memcpy(high, max_hkey, cur->bc_ops->key_len / 2);
2105 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2106 cur->bc_ops->key_len);
2113 struct xfs_btree_cur *cur,
2118 xfs_btree_get_leaf_keys(cur, block, key);
2120 xfs_btree_get_node_keys(cur, block, key);
2132 struct xfs_btree_cur *cur,
2135 return (cur->bc_flags & XFS_BTREE_OVERLAPPING) || ptr == 1;
2145 struct xfs_btree_cur *cur,
2159 ASSERT(cur->bc_flags & XFS_BTREE_OVERLAPPING);
2162 if (level + 1 >= cur->bc_nlevels)
2165 trace_xfs_btree_updkeys(cur, level, bp0);
2168 hkey = xfs_btree_high_key_from_key(cur, lkey);
2169 xfs_btree_get_keys(cur, block, lkey);
2170 for (level++; level < cur->bc_nlevels; level++) {
2174 block = xfs_btree_get_block(cur, level, &bp);
2175 trace_xfs_btree_updkeys(cur, level, bp);
2177 error = xfs_btree_check_block(cur, block, level, bp);
2181 ptr = cur->bc_levels[level].ptr;
2182 nlkey = xfs_btree_key_addr(cur, ptr, block);
2183 nhkey = xfs_btree_high_key_addr(cur, ptr, block);
2185 xfs_btree_keycmp_eq(cur, nlkey, lkey) &&
2186 xfs_btree_keycmp_eq(cur, nhkey, hkey))
2188 xfs_btree_copy_keys(cur, nlkey, lkey, 1);
2189 xfs_btree_log_keys(cur, bp, ptr, ptr);
2190 if (level + 1 >= cur->bc_nlevels)
2192 xfs_btree_get_node_keys(cur, block, lkey);
2201 struct xfs_btree_cur *cur,
2207 block = xfs_btree_get_block(cur, level, &bp);
2208 return __xfs_btree_updkeys(cur, level, block, bp, true);
2216 struct xfs_btree_cur *cur,
2227 block = xfs_btree_get_block(cur, level, &bp);
2228 if (cur->bc_flags & XFS_BTREE_OVERLAPPING)
2229 return __xfs_btree_updkeys(cur, level, block, bp, false);
2237 xfs_btree_get_keys(cur, block, &key);
2238 for (level++, ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
2242 block = xfs_btree_get_block(cur, level, &bp);
2244 error = xfs_btree_check_block(cur, block, level, bp);
2248 ptr = cur->bc_levels[level].ptr;
2249 kp = xfs_btree_key_addr(cur, ptr, block);
2250 xfs_btree_copy_keys(cur, kp, &key, 1);
2251 xfs_btree_log_keys(cur, bp, ptr, ptr);
2258 * Update the record referred to by cur to the value in the
2264 struct xfs_btree_cur *cur,
2274 block = xfs_btree_get_block(cur, 0, &bp);
2277 error = xfs_btree_check_block(cur, block, 0, bp);
2282 ptr = cur->bc_levels[0].ptr;
2283 rp = xfs_btree_rec_addr(cur, ptr, block);
2286 xfs_btree_copy_recs(cur, rp, rec, 1);
2287 xfs_btree_log_recs(cur, bp, ptr, ptr);
2293 if (xfs_btree_is_lastrec(cur, block, 0)) {
2294 cur->bc_ops->update_lastrec(cur, block, rec,
2299 if (xfs_btree_needs_key_update(cur, ptr)) {
2300 error = xfs_btree_update_keys(cur, 0);
2312 * Move 1 record left from cur/level if possible.
2313 * Update cur to reflect the new path.
2317 struct xfs_btree_cur *cur,
2335 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
2336 level == cur->bc_nlevels - 1)
2340 right = xfs_btree_get_block(cur, level, &rbp);
2343 error = xfs_btree_check_block(cur, right, level, rbp);
2349 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
2350 if (xfs_btree_ptr_is_null(cur, &lptr))
2357 if (cur->bc_levels[level].ptr <= 1)
2361 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
2367 if (lrecs == cur->bc_ops->get_maxrecs(cur, level))
2380 XFS_BTREE_STATS_INC(cur, lshift);
2381 XFS_BTREE_STATS_ADD(cur, moves, 1);
2392 lkp = xfs_btree_key_addr(cur, lrecs, left);
2393 rkp = xfs_btree_key_addr(cur, 1, right);
2395 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2396 rpp = xfs_btree_ptr_addr(cur, 1, right);
2398 error = xfs_btree_debug_check_ptr(cur, rpp, 0, level);
2402 xfs_btree_copy_keys(cur, lkp, rkp, 1);
2403 xfs_btree_copy_ptrs(cur, lpp, rpp, 1);
2405 xfs_btree_log_keys(cur, lbp, lrecs, lrecs);
2406 xfs_btree_log_ptrs(cur, lbp, lrecs, lrecs);
2408 ASSERT(cur->bc_ops->keys_inorder(cur,
2409 xfs_btree_key_addr(cur, lrecs - 1, left), lkp));
2414 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2415 rrp = xfs_btree_rec_addr(cur, 1, right);
2417 xfs_btree_copy_recs(cur, lrp, rrp, 1);
2418 xfs_btree_log_recs(cur, lbp, lrecs, lrecs);
2420 ASSERT(cur->bc_ops->recs_inorder(cur,
2421 xfs_btree_rec_addr(cur, lrecs - 1, left), lrp));
2425 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
2428 xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
2433 XFS_BTREE_STATS_ADD(cur, moves, rrecs - 1);
2437 error = xfs_btree_debug_check_ptr(cur, rpp, i + 1, level);
2442 xfs_btree_shift_keys(cur,
2443 xfs_btree_key_addr(cur, 2, right),
2445 xfs_btree_shift_ptrs(cur,
2446 xfs_btree_ptr_addr(cur, 2, right),
2449 xfs_btree_log_keys(cur, rbp, 1, rrecs);
2450 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
2453 xfs_btree_shift_recs(cur,
2454 xfs_btree_rec_addr(cur, 2, right),
2456 xfs_btree_log_recs(cur, rbp, 1, rrecs);
2463 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2464 error = xfs_btree_dup_cursor(cur, &tcur);
2486 error = xfs_btree_update_keys(cur, level);
2491 cur->bc_levels[level].ptr--;
2509 * Move 1 record right from cur/level if possible.
2510 * Update cur to reflect the new path.
2514 struct xfs_btree_cur *cur,
2530 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
2531 (level == cur->bc_nlevels - 1))
2535 left = xfs_btree_get_block(cur, level, &lbp);
2538 error = xfs_btree_check_block(cur, left, level, lbp);
2544 xfs_btree_get_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2545 if (xfs_btree_ptr_is_null(cur, &rptr))
2553 if (cur->bc_levels[level].ptr >= lrecs)
2557 error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
2563 if (rrecs == cur->bc_ops->get_maxrecs(cur, level))
2566 XFS_BTREE_STATS_INC(cur, rshift);
2567 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
2579 lkp = xfs_btree_key_addr(cur, lrecs, left);
2580 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2581 rkp = xfs_btree_key_addr(cur, 1, right);
2582 rpp = xfs_btree_ptr_addr(cur, 1, right);
2585 error = xfs_btree_debug_check_ptr(cur, rpp, i, level);
2590 xfs_btree_shift_keys(cur, rkp, 1, rrecs);
2591 xfs_btree_shift_ptrs(cur, rpp, 1, rrecs);
2593 error = xfs_btree_debug_check_ptr(cur, lpp, 0, level);
2598 xfs_btree_copy_keys(cur, rkp, lkp, 1);
2599 xfs_btree_copy_ptrs(cur, rpp, lpp, 1);
2601 xfs_btree_log_keys(cur, rbp, 1, rrecs + 1);
2602 xfs_btree_log_ptrs(cur, rbp, 1, rrecs + 1);
2604 ASSERT(cur->bc_ops->keys_inorder(cur, rkp,
2605 xfs_btree_key_addr(cur, 2, right)));
2611 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2612 rrp = xfs_btree_rec_addr(cur, 1, right);
2614 xfs_btree_shift_recs(cur, rrp, 1, rrecs);
2617 xfs_btree_copy_recs(cur, rrp, lrp, 1);
2618 xfs_btree_log_recs(cur, rbp, 1, rrecs + 1);
2625 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
2628 xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
2634 error = xfs_btree_dup_cursor(cur, &tcur);
2648 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2649 error = xfs_btree_update_keys(cur, level);
2677 * Split cur/level block in half.
2683 struct xfs_btree_cur *cur,
2705 XFS_BTREE_STATS_INC(cur, split);
2708 left = xfs_btree_get_block(cur, level, &lbp);
2711 error = xfs_btree_check_block(cur, left, level, lbp);
2716 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
2719 error = cur->bc_ops->alloc_block(cur, &lptr, &rptr, stat);
2724 XFS_BTREE_STATS_INC(cur, alloc);
2727 error = xfs_btree_get_buf_block(cur, &rptr, &right, &rbp);
2732 xfs_btree_init_block_cur(cur, rbp, xfs_btree_get_level(left), 0);
2741 if ((lrecs & 1) && cur->bc_levels[level].ptr <= rrecs + 1)
2745 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
2764 lkp = xfs_btree_key_addr(cur, src_index, left);
2765 lpp = xfs_btree_ptr_addr(cur, src_index, left);
2766 rkp = xfs_btree_key_addr(cur, 1, right);
2767 rpp = xfs_btree_ptr_addr(cur, 1, right);
2770 error = xfs_btree_debug_check_ptr(cur, lpp, i, level);
2776 xfs_btree_copy_keys(cur, rkp, lkp, rrecs);
2777 xfs_btree_copy_ptrs(cur, rpp, lpp, rrecs);
2779 xfs_btree_log_keys(cur, rbp, 1, rrecs);
2780 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
2783 xfs_btree_get_node_keys(cur, right, key);
2789 lrp = xfs_btree_rec_addr(cur, src_index, left);
2790 rrp = xfs_btree_rec_addr(cur, 1, right);
2793 xfs_btree_copy_recs(cur, rrp, lrp, rrecs);
2794 xfs_btree_log_recs(cur, rbp, 1, rrecs);
2797 xfs_btree_get_leaf_keys(cur, right, key);
2804 xfs_btree_get_sibling(cur, left, &rrptr, XFS_BB_RIGHTSIB);
2805 xfs_btree_set_sibling(cur, right, &rrptr, XFS_BB_RIGHTSIB);
2806 xfs_btree_set_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
2807 xfs_btree_set_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2809 xfs_btree_log_block(cur, rbp, XFS_BB_ALL_BITS);
2810 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
2816 if (!xfs_btree_ptr_is_null(cur, &rrptr)) {
2817 error = xfs_btree_read_buf_block(cur, &rrptr,
2821 xfs_btree_set_sibling(cur, rrblock, &rptr, XFS_BB_LEFTSIB);
2822 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
2826 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2827 error = xfs_btree_update_keys(cur, level);
2837 if (cur->bc_levels[level].ptr > lrecs + 1) {
2838 xfs_btree_setbuf(cur, level, rbp);
2839 cur->bc_levels[level].ptr -= lrecs;
2845 if (level + 1 < cur->bc_nlevels) {
2846 error = xfs_btree_dup_cursor(cur, curp);
2864 struct xfs_btree_cur *cur;
2898 xfs_trans_set_context(args->cur->bc_tp);
2900 args->result = __xfs_btree_split(args->cur, args->level, args->ptrp,
2903 xfs_trans_clear_context(args->cur->bc_tp);
2934 struct xfs_btree_cur *cur,
2944 if (cur->bc_btnum != XFS_BTNUM_BMAP ||
2945 cur->bc_tp->t_highest_agno == NULLAGNUMBER)
2946 return __xfs_btree_split(cur, level, ptrp, key, curp, stat);
2948 args.cur = cur;
2973 struct xfs_btree_cur *cur, /* btree cursor */
2989 XFS_BTREE_STATS_INC(cur, newroot);
2991 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
2993 level = cur->bc_nlevels - 1;
2995 block = xfs_btree_get_iroot(cur);
2996 pp = xfs_btree_ptr_addr(cur, 1, block);
2999 error = cur->bc_ops->alloc_block(cur, pp, &nptr, stat);
3005 XFS_BTREE_STATS_INC(cur, alloc);
3008 error = xfs_btree_get_buf_block(cur, &nptr, &cblock, &cbp);
3016 memcpy(cblock, block, xfs_btree_block_len(cur));
3017 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS) {
3019 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
3027 cur->bc_nlevels++;
3028 ASSERT(cur->bc_nlevels <= cur->bc_maxlevels);
3029 cur->bc_levels[level + 1].ptr = 1;
3031 kp = xfs_btree_key_addr(cur, 1, block);
3032 ckp = xfs_btree_key_addr(cur, 1, cblock);
3033 xfs_btree_copy_keys(cur, ckp, kp, xfs_btree_get_numrecs(cblock));
3035 cpp = xfs_btree_ptr_addr(cur, 1, cblock);
3037 error = xfs_btree_debug_check_ptr(cur, pp, i, level);
3042 xfs_btree_copy_ptrs(cur, cpp, pp, xfs_btree_get_numrecs(cblock));
3044 error = xfs_btree_debug_check_ptr(cur, &nptr, 0, level);
3048 xfs_btree_copy_ptrs(cur, pp, &nptr, 1);
3050 xfs_iroot_realloc(cur->bc_ino.ip,
3052 cur->bc_ino.whichfork);
3054 xfs_btree_setbuf(cur, level, cbp);
3060 xfs_btree_log_block(cur, cbp, XFS_BB_ALL_BITS);
3061 xfs_btree_log_keys(cur, cbp, 1, be16_to_cpu(cblock->bb_numrecs));
3062 xfs_btree_log_ptrs(cur, cbp, 1, be16_to_cpu(cblock->bb_numrecs));
3065 XFS_ILOG_CORE | xfs_ilog_fbroot(cur->bc_ino.whichfork);
3077 struct xfs_btree_cur *cur, /* btree cursor */
3093 XFS_BTREE_STATS_INC(cur, newroot);
3096 cur->bc_ops->init_ptr_from_cur(cur, &rptr);
3099 error = cur->bc_ops->alloc_block(cur, &rptr, &lptr, stat);
3104 XFS_BTREE_STATS_INC(cur, alloc);
3107 error = xfs_btree_get_buf_block(cur, &lptr, &new, &nbp);
3112 cur->bc_ops->set_root(cur, &lptr, 1);
3120 block = xfs_btree_get_block(cur, cur->bc_nlevels - 1, &bp);
3123 error = xfs_btree_check_block(cur, block, cur->bc_nlevels - 1, bp);
3128 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
3129 if (!xfs_btree_ptr_is_null(cur, &rptr)) {
3132 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
3134 error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
3142 xfs_btree_buf_to_ptr(cur, rbp, &rptr);
3144 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
3145 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
3153 xfs_btree_init_block_cur(cur, nbp, cur->bc_nlevels, 2);
3154 xfs_btree_log_block(cur, nbp, XFS_BB_ALL_BITS);
3155 ASSERT(!xfs_btree_ptr_is_null(cur, &lptr) &&
3156 !xfs_btree_ptr_is_null(cur, &rptr));
3164 xfs_btree_get_node_keys(cur, left,
3165 xfs_btree_key_addr(cur, 1, new));
3166 xfs_btree_get_node_keys(cur, right,
3167 xfs_btree_key_addr(cur, 2, new));
3174 xfs_btree_get_leaf_keys(cur, left,
3175 xfs_btree_key_addr(cur, 1, new));
3176 xfs_btree_get_leaf_keys(cur, right,
3177 xfs_btree_key_addr(cur, 2, new));
3179 xfs_btree_log_keys(cur, nbp, 1, 2);
3182 xfs_btree_copy_ptrs(cur,
3183 xfs_btree_ptr_addr(cur, 1, new), &lptr, 1);
3184 xfs_btree_copy_ptrs(cur,
3185 xfs_btree_ptr_addr(cur, 2, new), &rptr, 1);
3186 xfs_btree_log_ptrs(cur, nbp, 1, 2);
3189 xfs_btree_setbuf(cur, cur->bc_nlevels, nbp);
3190 cur->bc_levels[cur->bc_nlevels].ptr = nptr;
3191 cur->bc_nlevels++;
3192 ASSERT(cur->bc_nlevels <= cur->bc_maxlevels);
3204 struct xfs_btree_cur *cur, /* btree cursor */
3216 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
3217 level == cur->bc_nlevels - 1) {
3218 struct xfs_inode *ip = cur->bc_ino.ip;
3220 if (numrecs < cur->bc_ops->get_dmaxrecs(cur, level)) {
3222 xfs_iroot_realloc(ip, 1, cur->bc_ino.whichfork);
3228 error = xfs_btree_new_iroot(cur, &logflags, stat);
3232 xfs_trans_log_inode(cur->bc_tp, ip, logflags);
3239 error = xfs_btree_rshift(cur, level, stat);
3244 error = xfs_btree_lshift(cur, level, stat);
3249 *oindex = *index = cur->bc_levels[level].ptr;
3259 error = xfs_btree_split(cur, level, nptr, key, ncur, stat);
3264 *index = cur->bc_levels[level].ptr;
3274 struct xfs_btree_cur *cur, /* btree cursor */
3279 struct xfs_btree_cur **curp, /* output: new cursor replacing cur */
3302 if (!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
3303 (level >= cur->bc_nlevels)) {
3304 error = xfs_btree_new_root(cur, stat);
3305 xfs_btree_set_ptr_null(cur, ptrp);
3311 ptr = cur->bc_levels[level].ptr;
3319 XFS_BTREE_STATS_INC(cur, insrec);
3322 block = xfs_btree_get_block(cur, level, &bp);
3327 error = xfs_btree_check_block(cur, block, level, bp);
3334 ASSERT(cur->bc_ops->recs_inorder(cur, rec,
3335 xfs_btree_rec_addr(cur, ptr, block)));
3337 ASSERT(cur->bc_ops->keys_inorder(cur, key,
3338 xfs_btree_key_addr(cur, ptr, block)));
3347 xfs_btree_set_ptr_null(cur, &nptr);
3348 if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
3349 error = xfs_btree_make_block_unfull(cur, level, numrecs,
3359 block = xfs_btree_get_block(cur, level, &bp);
3363 error = xfs_btree_check_block(cur, block, level, bp);
3372 XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr + 1);
3379 kp = xfs_btree_key_addr(cur, ptr, block);
3380 pp = xfs_btree_ptr_addr(cur, ptr, block);
3383 error = xfs_btree_debug_check_ptr(cur, pp, i, level);
3388 xfs_btree_shift_keys(cur, kp, 1, numrecs - ptr + 1);
3389 xfs_btree_shift_ptrs(cur, pp, 1, numrecs - ptr + 1);
3391 error = xfs_btree_debug_check_ptr(cur, ptrp, 0, level);
3396 xfs_btree_copy_keys(cur, kp, key, 1);
3397 xfs_btree_copy_ptrs(cur, pp, ptrp, 1);
3400 xfs_btree_log_ptrs(cur, bp, ptr, numrecs);
3401 xfs_btree_log_keys(cur, bp, ptr, numrecs);
3404 ASSERT(cur->bc_ops->keys_inorder(cur, kp,
3405 xfs_btree_key_addr(cur, ptr + 1, block)));
3412 rp = xfs_btree_rec_addr(cur, ptr, block);
3414 xfs_btree_shift_recs(cur, rp, 1, numrecs - ptr + 1);
3417 xfs_btree_copy_recs(cur, rp, rec, 1);
3419 xfs_btree_log_recs(cur, bp, ptr, numrecs);
3422 ASSERT(cur->bc_ops->recs_inorder(cur, rp,
3423 xfs_btree_rec_addr(cur, ptr + 1, block)));
3429 xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
3440 xfs_btree_get_keys(cur, block, lkey);
3441 } else if (xfs_btree_needs_key_update(cur, optr)) {
3442 error = xfs_btree_update_keys(cur, level);
3451 if (xfs_btree_is_lastrec(cur, block, level)) {
3452 cur->bc_ops->update_lastrec(cur, block, rec,
3461 if (!xfs_btree_ptr_is_null(cur, &nptr)) {
3462 xfs_btree_copy_keys(cur, key, lkey, 1);
3476 * Insert the record at the point referenced by cur.
3484 struct xfs_btree_cur *cur,
3499 pcur = cur;
3502 xfs_btree_set_ptr_null(cur, &nptr);
3505 cur->bc_ops->init_rec_from_cur(cur, &rec);
3506 cur->bc_ops->init_key_from_rec(key, &rec);
3521 if (pcur != cur)
3526 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3537 if (pcur != cur &&
3538 (ncur || xfs_btree_ptr_is_null(cur, &nptr))) {
3540 if (cur->bc_ops->update_cursor)
3541 cur->bc_ops->update_cursor(pcur, cur);
3542 cur->bc_nlevels = pcur->bc_nlevels;
3550 } while (!xfs_btree_ptr_is_null(cur, &nptr));
3568 struct xfs_btree_cur *cur)
3570 int whichfork = cur->bc_ino.whichfork;
3571 struct xfs_inode *ip = cur->bc_ino.ip;
3589 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
3590 ASSERT(cur->bc_nlevels > 1);
3596 level = cur->bc_nlevels - 1;
3603 block = xfs_btree_get_iroot(cur);
3607 cblock = xfs_btree_get_block(cur, level - 1, &cbp);
3615 if (numrecs > cur->bc_ops->get_dmaxrecs(cur, level))
3618 XFS_BTREE_STATS_INC(cur, killroot);
3621 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
3622 ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
3623 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
3624 ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
3627 index = numrecs - cur->bc_ops->get_maxrecs(cur, level);
3629 xfs_iroot_realloc(cur->bc_ino.ip, index,
3630 cur->bc_ino.whichfork);
3637 kp = xfs_btree_key_addr(cur, 1, block);
3638 ckp = xfs_btree_key_addr(cur, 1, cblock);
3639 xfs_btree_copy_keys(cur, kp, ckp, numrecs);
3641 pp = xfs_btree_ptr_addr(cur, 1, block);
3642 cpp = xfs_btree_ptr_addr(cur, 1, cblock);
3645 error = xfs_btree_debug_check_ptr(cur, cpp, i, level - 1);
3650 xfs_btree_copy_ptrs(cur, pp, cpp, numrecs);
3652 error = xfs_btree_free_block(cur, cbp);
3656 cur->bc_levels[level - 1].bp = NULL;
3658 xfs_trans_log_inode(cur->bc_tp, ip,
3659 XFS_ILOG_CORE | xfs_ilog_fbroot(cur->bc_ino.whichfork));
3660 cur->bc_nlevels--;
3670 struct xfs_btree_cur *cur,
3677 XFS_BTREE_STATS_INC(cur, killroot);
3683 cur->bc_ops->set_root(cur, newroot, -1);
3685 error = xfs_btree_free_block(cur, bp);
3689 cur->bc_levels[level].bp = NULL;
3690 cur->bc_levels[level].ra = 0;
3691 cur->bc_nlevels--;
3698 struct xfs_btree_cur *cur,
3706 error = xfs_btree_decrement(cur, level, &i);
3717 * Delete record pointed to by cur/level.
3723 struct xfs_btree_cur *cur, /* btree cursor */
3749 ptr = cur->bc_levels[level].ptr;
3756 block = xfs_btree_get_block(cur, level, &bp);
3760 error = xfs_btree_check_block(cur, block, level, bp);
3771 XFS_BTREE_STATS_INC(cur, delrec);
3772 XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr);
3780 lkp = xfs_btree_key_addr(cur, ptr + 1, block);
3781 lpp = xfs_btree_ptr_addr(cur, ptr + 1, block);
3784 error = xfs_btree_debug_check_ptr(cur, lpp, i, level);
3790 xfs_btree_shift_keys(cur, lkp, -1, numrecs - ptr);
3791 xfs_btree_shift_ptrs(cur, lpp, -1, numrecs - ptr);
3792 xfs_btree_log_keys(cur, bp, ptr, numrecs - 1);
3793 xfs_btree_log_ptrs(cur, bp, ptr, numrecs - 1);
3798 xfs_btree_shift_recs(cur,
3799 xfs_btree_rec_addr(cur, ptr + 1, block),
3801 xfs_btree_log_recs(cur, bp, ptr, numrecs - 1);
3809 xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
3815 if (xfs_btree_is_lastrec(cur, block, level)) {
3816 cur->bc_ops->update_lastrec(cur, block, NULL,
3825 if (level == cur->bc_nlevels - 1) {
3826 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
3827 xfs_iroot_realloc(cur->bc_ino.ip, -1,
3828 cur->bc_ino.whichfork);
3830 error = xfs_btree_kill_iroot(cur);
3834 error = xfs_btree_dec_cursor(cur, level, stat);
3852 pp = xfs_btree_ptr_addr(cur, 1, block);
3853 error = xfs_btree_kill_root(cur, bp, level, pp);
3857 error = xfs_btree_dec_cursor(cur, level, stat);
3869 if (xfs_btree_needs_key_update(cur, ptr)) {
3870 error = xfs_btree_update_keys(cur, level);
3879 if (numrecs >= cur->bc_ops->get_minrecs(cur, level)) {
3880 error = xfs_btree_dec_cursor(cur, level, stat);
3891 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
3892 xfs_btree_get_sibling(cur, block, &lptr, XFS_BB_LEFTSIB);
3894 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
3900 if (xfs_btree_ptr_is_null(cur, &rptr) &&
3901 xfs_btree_ptr_is_null(cur, &lptr) &&
3902 level == cur->bc_nlevels - 2) {
3903 error = xfs_btree_kill_iroot(cur);
3905 error = xfs_btree_dec_cursor(cur, level, stat);
3912 ASSERT(!xfs_btree_ptr_is_null(cur, &rptr) ||
3913 !xfs_btree_ptr_is_null(cur, &lptr));
3919 error = xfs_btree_dup_cursor(cur, &tcur);
3927 if (!xfs_btree_ptr_is_null(cur, &rptr)) {
3933 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3941 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3947 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3968 cur->bc_ops->get_minrecs(tcur, level)) {
3974 cur->bc_ops->get_minrecs(tcur, level));
3979 error = xfs_btree_dec_cursor(cur, level, stat);
3992 if (!xfs_btree_ptr_is_null(cur, &lptr)) {
3994 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
4002 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
4013 if (!xfs_btree_ptr_is_null(cur, &lptr)) {
4019 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
4028 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
4036 error = xfs_btree_check_block(cur, left, level, lbp);
4049 cur->bc_ops->get_minrecs(tcur, level)) {
4055 cur->bc_ops->get_minrecs(tcur, level));
4059 cur->bc_levels[0].ptr++;
4078 ASSERT(!xfs_btree_ptr_is_null(cur, &cptr));
4080 if (!xfs_btree_ptr_is_null(cur, &lptr) &&
4082 cur->bc_ops->get_maxrecs(cur, level)) {
4090 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
4097 } else if (!xfs_btree_ptr_is_null(cur, &rptr) &&
4099 cur->bc_ops->get_maxrecs(cur, level)) {
4107 error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
4116 error = xfs_btree_dec_cursor(cur, level, stat);
4129 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
4137 lkp = xfs_btree_key_addr(cur, lrecs + 1, left);
4138 lpp = xfs_btree_ptr_addr(cur, lrecs + 1, left);
4139 rkp = xfs_btree_key_addr(cur, 1, right);
4140 rpp = xfs_btree_ptr_addr(cur, 1, right);
4143 error = xfs_btree_debug_check_ptr(cur, rpp, i, level);
4148 xfs_btree_copy_keys(cur, lkp, rkp, rrecs);
4149 xfs_btree_copy_ptrs(cur, lpp, rpp, rrecs);
4151 xfs_btree_log_keys(cur, lbp, lrecs + 1, lrecs + rrecs);
4152 xfs_btree_log_ptrs(cur, lbp, lrecs + 1, lrecs + rrecs);
4158 lrp = xfs_btree_rec_addr(cur, lrecs + 1, left);
4159 rrp = xfs_btree_rec_addr(cur, 1, right);
4161 xfs_btree_copy_recs(cur, lrp, rrp, rrecs);
4162 xfs_btree_log_recs(cur, lbp, lrecs + 1, lrecs + rrecs);
4165 XFS_BTREE_STATS_INC(cur, join);
4172 xfs_btree_get_sibling(cur, right, &cptr, XFS_BB_RIGHTSIB);
4173 xfs_btree_set_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
4174 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
4177 xfs_btree_get_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
4178 if (!xfs_btree_ptr_is_null(cur, &cptr)) {
4179 error = xfs_btree_read_buf_block(cur, &cptr, 0, &rrblock, &rrbp);
4182 xfs_btree_set_sibling(cur, rrblock, &lptr, XFS_BB_LEFTSIB);
4183 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
4187 error = xfs_btree_free_block(cur, rbp);
4196 cur->bc_levels[level].bp = lbp;
4197 cur->bc_levels[level].ptr += lrecs;
4198 cur->bc_levels[level].ra = 0;
4204 else if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) ||
4205 (level + 1 < cur->bc_nlevels)) {
4206 error = xfs_btree_increment(cur, level + 1, &i);
4218 cur->bc_levels[level].ptr--;
4241 * Delete the record pointed to by cur.
4247 struct xfs_btree_cur *cur,
4262 error = xfs_btree_delrec(cur, level, &i);
4273 if (joined && (cur->bc_flags & XFS_BTREE_OVERLAPPING)) {
4274 error = xfs_btree_updkeys_force(cur, 0);
4280 for (level = 1; level < cur->bc_nlevels; level++) {
4281 if (cur->bc_levels[level].ptr == 0) {
4282 error = xfs_btree_decrement(cur, level, &i);
4301 struct xfs_btree_cur *cur, /* btree cursor */
4312 ptr = cur->bc_levels[0].ptr;
4313 block = xfs_btree_get_block(cur, 0, &bp);
4316 error = xfs_btree_check_block(cur, block, 0, bp);
4332 *recp = xfs_btree_rec_addr(cur, ptr, block);
4340 struct xfs_btree_cur *cur,
4351 xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
4352 block = xfs_btree_get_block(cur, level, &bp);
4355 error = fn(cur, level, data);
4360 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
4361 if (xfs_btree_ptr_is_null(cur, &rptr))
4370 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
4371 if (be64_to_cpu(rptr.l) == XFS_DADDR_TO_FSB(cur->bc_mp,
4375 if (be32_to_cpu(rptr.s) == xfs_daddr_to_agbno(cur->bc_mp,
4379 return xfs_btree_lookup_get_block(cur, level, &rptr, &block);
4386 struct xfs_btree_cur *cur,
4396 cur->bc_ops->init_ptr_from_cur(cur, &lptr);
4399 for (level = cur->bc_nlevels - 1; level >= 0; level--) {
4401 error = xfs_btree_lookup_get_block(cur, level, &lptr, &block);
4409 ptr = xfs_btree_ptr_addr(cur, 1, block);
4410 xfs_btree_readahead_ptr(cur, ptr, 1);
4413 xfs_btree_copy_ptrs(cur, &lptr, ptr, 1);
4423 error = xfs_btree_visit_block(cur, level, fn, data);
4464 struct xfs_btree_cur *cur,
4473 block = xfs_btree_get_block(cur, level, &bp);
4474 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
4492 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
4493 ASSERT(level == cur->bc_nlevels - 1);
4497 if (cur->bc_tp) {
4498 if (!xfs_trans_ordered_buf(cur->bc_tp, bp)) {
4499 xfs_btree_log_block(cur, bp, XFS_BB_OWNER);
4511 struct xfs_btree_cur *cur,
4520 return xfs_btree_visit_blocks(cur, xfs_btree_block_change_owner,
4710 struct xfs_btree_cur *cur,
4722 ASSERT(cur->bc_ops->init_high_key_from_rec);
4723 ASSERT(cur->bc_ops->diff_two_keys);
4730 error = xfs_btree_lookup(cur, XFS_LOOKUP_LE, &stat);
4736 error = xfs_btree_increment(cur, 0, &stat);
4743 error = xfs_btree_get_rec(cur, &recp, &stat);
4749 cur->bc_ops->init_high_key_from_rec(&rec_key, recp);
4751 if (xfs_btree_keycmp_gt(cur, low_key, &rec_key))
4756 cur->bc_ops->init_key_from_rec(&rec_key, recp);
4757 if (xfs_btree_keycmp_gt(cur, &rec_key, high_key))
4761 error = fn(cur, recp, priv);
4767 error = xfs_btree_increment(cur, 0, &stat);
4797 struct xfs_btree_cur *cur,
4817 level = cur->bc_nlevels - 1;
4818 cur->bc_ops->init_ptr_from_cur(cur, &ptr);
4819 error = xfs_btree_lookup_get_block(cur, level, &ptr, &block);
4822 xfs_btree_get_block(cur, level, &bp);
4823 trace_xfs_btree_overlapped_query_range(cur, level, bp);
4825 error = xfs_btree_check_block(cur, block, level, bp);
4829 cur->bc_levels[level].ptr = 1;
4831 while (level < cur->bc_nlevels) {
4832 block = xfs_btree_get_block(cur, level, &bp);
4835 if (cur->bc_levels[level].ptr >
4838 if (level < cur->bc_nlevels - 1)
4839 cur->bc_levels[level + 1].ptr++;
4846 recp = xfs_btree_rec_addr(cur, cur->bc_levels[0].ptr,
4849 cur->bc_ops->init_high_key_from_rec(&rec_hkey, recp);
4850 cur->bc_ops->init_key_from_rec(&rec_key, recp);
4861 if (xfs_btree_keycmp_lt(cur, high_key, &rec_key))
4863 if (xfs_btree_keycmp_ge(cur, &rec_hkey, low_key)) {
4864 error = fn(cur, recp, priv);
4868 cur->bc_levels[level].ptr++;
4873 lkp = xfs_btree_key_addr(cur, cur->bc_levels[level].ptr, block);
4874 hkp = xfs_btree_high_key_addr(cur, cur->bc_levels[level].ptr,
4876 pp = xfs_btree_ptr_addr(cur, cur->bc_levels[level].ptr, block);
4887 if (xfs_btree_keycmp_lt(cur, high_key, lkp))
4889 if (xfs_btree_keycmp_ge(cur, hkp, low_key)) {
4891 error = xfs_btree_lookup_get_block(cur, level, pp,
4895 xfs_btree_get_block(cur, level, &bp);
4896 trace_xfs_btree_overlapped_query_range(cur, level, bp);
4898 error = xfs_btree_check_block(cur, block, level, bp);
4902 cur->bc_levels[level].ptr = 1;
4905 cur->bc_levels[level].ptr++;
4916 if (cur->bc_levels[0].bp == NULL) {
4917 for (i = 0; i < cur->bc_nlevels; i++) {
4918 if (cur->bc_levels[i].bp) {
4919 xfs_trans_brelse(cur->bc_tp,
4920 cur->bc_levels[i].bp);
4921 cur->bc_levels[i].bp = NULL;
4922 cur->bc_levels[i].ptr = 0;
4923 cur->bc_levels[i].ra = 0;
4933 struct xfs_btree_cur *cur,
4939 cur->bc_rec = *irec;
4940 cur->bc_ops->init_rec_from_cur(cur, &rec);
4941 cur->bc_ops->init_key_from_rec(key, &rec);
4952 struct xfs_btree_cur *cur,
4962 xfs_btree_key_from_irec(cur, &high_key, high_rec);
4963 xfs_btree_key_from_irec(cur, &low_key, low_rec);
4966 if (!xfs_btree_keycmp_le(cur, &low_key, &high_key))
4969 if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
4970 return xfs_btree_simple_query_range(cur, &low_key,
4972 return xfs_btree_overlapped_query_range(cur, &low_key, &high_key,
4979 struct xfs_btree_cur *cur,
4986 memset(&cur->bc_rec, 0, sizeof(cur->bc_rec));
4990 return xfs_btree_simple_query_range(cur, &low_key, &high_key, fn, priv);
4995 struct xfs_btree_cur *cur,
5008 struct xfs_btree_cur *cur,
5012 return xfs_btree_visit_blocks(cur, xfs_btree_count_blocks_helper,
5019 struct xfs_btree_cur *cur,
5023 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
5044 struct xfs_btree_cur *cur,
5053 cur->bc_ops->init_key_from_rec(&rec_key, rec);
5063 if (xfs_btree_masked_keycmp_lt(cur, &info->start_key, &rec_key,
5074 key_contig = cur->bc_ops->keys_contiguous(cur, &info->high_key,
5077 !(cur->bc_flags & XFS_BTREE_OVERLAPPING))
5087 cur->bc_ops->init_high_key_from_rec(&rec_high_key, rec);
5088 if (xfs_btree_masked_keycmp_gt(cur, &rec_high_key, &info->high_key,
5111 struct xfs_btree_cur *cur,
5124 if (!cur->bc_ops->keys_contiguous) {
5129 xfs_btree_key_from_irec(cur, &info.start_key, low);
5130 xfs_btree_key_from_irec(cur, &info.end_key, high);
5132 error = xfs_btree_query_range(cur, low, high,
5147 if (xfs_btree_masked_keycmp_ge(cur, &info.high_key, &info.end_key,
5159 struct xfs_btree_cur *cur)
5164 block = xfs_btree_get_block(cur, 0, &bp);
5167 if (cur->bc_levels[0].ptr < xfs_btree_get_numrecs(block))
5171 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)