Lines Matching refs:cur
59 struct xfs_btree_cur *cur,
64 struct xfs_mount *mp = cur->bc_mp;
65 xfs_btnum_t btnum = cur->bc_btnum;
83 cur->bc_ops->get_maxrecs(cur, level))
86 !xfs_btree_check_lptr(cur, be64_to_cpu(block->bb_u.l.bb_leftsib),
90 !xfs_btree_check_lptr(cur, be64_to_cpu(block->bb_u.l.bb_rightsib),
100 struct xfs_btree_cur *cur,
105 struct xfs_mount *mp = cur->bc_mp;
108 fa = __xfs_btree_check_lblock(cur, block, level, bp);
124 struct xfs_btree_cur *cur,
129 struct xfs_mount *mp = cur->bc_mp;
130 xfs_btnum_t btnum = cur->bc_btnum;
146 cur->bc_ops->get_maxrecs(cur, level))
149 !xfs_btree_check_sptr(cur, be32_to_cpu(block->bb_u.s.bb_leftsib),
153 !xfs_btree_check_sptr(cur, be32_to_cpu(block->bb_u.s.bb_rightsib),
163 struct xfs_btree_cur *cur,
168 struct xfs_mount *mp = cur->bc_mp;
171 fa = __xfs_btree_check_sblock(cur, block, level, bp);
186 struct xfs_btree_cur *cur, /* btree cursor */
191 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
192 return xfs_btree_check_lblock(cur, block, level, bp);
194 return xfs_btree_check_sblock(cur, block, level, bp);
200 struct xfs_btree_cur *cur,
206 return xfs_verify_fsbno(cur->bc_mp, fsbno);
212 struct xfs_btree_cur *cur,
218 return xfs_verify_agbno(cur->bc_mp, cur->bc_ag.agno, agbno);
227 struct xfs_btree_cur *cur,
232 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
233 if (xfs_btree_check_lptr(cur, be64_to_cpu((&ptr->l)[index]),
236 xfs_err(cur->bc_mp,
238 cur->bc_ino.ip->i_ino,
239 cur->bc_ino.whichfork, cur->bc_btnum,
242 if (xfs_btree_check_sptr(cur, be32_to_cpu((&ptr->s)[index]),
245 xfs_err(cur->bc_mp,
247 cur->bc_ag.agno, cur->bc_btnum,
338 struct xfs_btree_cur *cur,
343 error = cur->bc_ops->free_block(cur, bp);
345 xfs_trans_binval(cur->bc_tp, bp);
346 XFS_BTREE_STATS_INC(cur, free);
356 struct xfs_btree_cur *cur, /* btree cursor */
368 for (i = 0; i < cur->bc_nlevels; i++) {
369 if (cur->bc_bufs[i])
370 xfs_trans_brelse(cur->bc_tp, cur->bc_bufs[i]);
381 ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP || cur->bc_ino.allocated == 0 ||
382 XFS_FORCED_SHUTDOWN(cur->bc_mp) || error != 0);
383 if (unlikely(cur->bc_flags & XFS_BTREE_STAGING))
384 kmem_free(cur->bc_ops);
385 kmem_cache_free(xfs_btree_cur_zone, cur);
394 xfs_btree_cur_t *cur, /* input cursor */
404 tp = cur->bc_tp;
405 mp = cur->bc_mp;
410 new = cur->bc_ops->dup_cursor(cur);
415 new->bc_rec = cur->bc_rec;
421 new->bc_ptrs[i] = cur->bc_ptrs[i];
422 new->bc_ra[i] = cur->bc_ra[i];
423 bp = cur->bc_bufs[i];
428 cur->bc_ops->buf_ops);
518 static inline size_t xfs_btree_block_len(struct xfs_btree_cur *cur)
520 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
521 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS)
525 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS)
533 static inline size_t xfs_btree_ptr_len(struct xfs_btree_cur *cur)
535 return (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
544 struct xfs_btree_cur *cur,
547 return xfs_btree_block_len(cur) +
548 (n - 1) * cur->bc_ops->rec_len;
556 struct xfs_btree_cur *cur,
559 return xfs_btree_block_len(cur) +
560 (n - 1) * cur->bc_ops->key_len;
568 struct xfs_btree_cur *cur,
571 return xfs_btree_block_len(cur) +
572 (n - 1) * cur->bc_ops->key_len + (cur->bc_ops->key_len / 2);
580 struct xfs_btree_cur *cur,
584 return xfs_btree_block_len(cur) +
585 cur->bc_ops->get_maxrecs(cur, level) * cur->bc_ops->key_len +
586 (n - 1) * xfs_btree_ptr_len(cur);
594 struct xfs_btree_cur *cur,
599 ((char *)block + xfs_btree_rec_offset(cur, n));
607 struct xfs_btree_cur *cur,
612 ((char *)block + xfs_btree_key_offset(cur, n));
620 struct xfs_btree_cur *cur,
625 ((char *)block + xfs_btree_high_key_offset(cur, n));
633 struct xfs_btree_cur *cur,
642 ((char *)block + xfs_btree_ptr_offset(cur, n, level));
647 struct xfs_btree_cur *cur)
649 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
651 if (cur->bc_flags & XFS_BTREE_STAGING)
652 return cur->bc_ino.ifake->if_fork;
653 return XFS_IFORK_PTR(cur->bc_ino.ip, cur->bc_ino.whichfork);
664 struct xfs_btree_cur *cur)
666 struct xfs_ifork *ifp = xfs_btree_ifork_ptr(cur);
677 struct xfs_btree_cur *cur, /* btree cursor */
681 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
682 (level == cur->bc_nlevels - 1)) {
684 return xfs_btree_get_iroot(cur);
687 *bpp = cur->bc_bufs[level];
697 xfs_btree_cur_t *cur, /* btree cursor */
706 block = xfs_btree_get_block(cur, level, &bp);
707 if (xfs_btree_check_block(cur, block, level, bp))
717 cur->bc_ptrs[level] = 1;
727 xfs_btree_cur_t *cur, /* btree cursor */
736 block = xfs_btree_get_block(cur, level, &bp);
737 if (xfs_btree_check_block(cur, block, level, bp))
747 cur->bc_ptrs[level] = be16_to_cpu(block->bb_numrecs);
859 struct xfs_btree_cur *cur,
868 xfs_btree_reada_bufl(cur->bc_mp, left, 1,
869 cur->bc_ops->buf_ops);
874 xfs_btree_reada_bufl(cur->bc_mp, right, 1,
875 cur->bc_ops->buf_ops);
884 struct xfs_btree_cur *cur,
894 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_ag.agno,
895 left, 1, cur->bc_ops->buf_ops);
900 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_ag.agno,
901 right, 1, cur->bc_ops->buf_ops);
914 struct xfs_btree_cur *cur, /* btree cursor */
924 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
925 (lev == cur->bc_nlevels - 1))
928 if ((cur->bc_ra[lev] | lr) == cur->bc_ra[lev])
931 cur->bc_ra[lev] |= lr;
932 block = XFS_BUF_TO_BLOCK(cur->bc_bufs[lev]);
934 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
935 return xfs_btree_readahead_lblock(cur, lr, block);
936 return xfs_btree_readahead_sblock(cur, lr, block);
941 struct xfs_btree_cur *cur,
949 error = xfs_btree_check_ptr(cur, ptr, 0, 1);
953 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
955 *daddr = XFS_FSB_TO_DADDR(cur->bc_mp, fsbno);
958 *daddr = XFS_AGB_TO_DADDR(cur->bc_mp, cur->bc_ag.agno,
973 struct xfs_btree_cur *cur,
979 if (xfs_btree_ptr_to_daddr(cur, ptr, &daddr))
981 xfs_buf_readahead(cur->bc_mp->m_ddev_targp, daddr,
982 cur->bc_mp->m_bsize * count, cur->bc_ops->buf_ops);
991 xfs_btree_cur_t *cur, /* btree cursor */
997 if (cur->bc_bufs[lev])
998 xfs_trans_brelse(cur->bc_tp, cur->bc_bufs[lev]);
999 cur->bc_bufs[lev] = bp;
1000 cur->bc_ra[lev] = 0;
1003 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1005 cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
1007 cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
1010 cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
1012 cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
1018 struct xfs_btree_cur *cur,
1021 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1029 struct xfs_btree_cur *cur,
1032 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1043 struct xfs_btree_cur *cur,
1050 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1065 struct xfs_btree_cur *cur,
1072 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
1143 struct xfs_btree_cur *cur,
1156 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1157 owner = cur->bc_ino.ip->i_ino;
1159 owner = cur->bc_ag.agno;
1161 xfs_btree_init_block_int(cur->bc_mp, XFS_BUF_TO_BLOCK(bp), bp->b_bn,
1162 cur->bc_btnum, level, numrecs,
1163 owner, cur->bc_flags);
1173 struct xfs_btree_cur *cur,
1181 if (!(cur->bc_flags & XFS_BTREE_LASTREC_UPDATE))
1184 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1185 if (!xfs_btree_ptr_is_null(cur, &ptr))
1192 struct xfs_btree_cur *cur,
1196 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
1197 ptr->l = cpu_to_be64(XFS_DADDR_TO_FSB(cur->bc_mp,
1200 ptr->s = cpu_to_be32(xfs_daddr_to_agbno(cur->bc_mp,
1207 struct xfs_btree_cur *cur,
1210 switch (cur->bc_btnum) {
1235 struct xfs_btree_cur *cur,
1240 struct xfs_mount *mp = cur->bc_mp;
1244 error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
1247 error = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d, mp->m_bsize,
1252 (*bpp)->b_ops = cur->bc_ops->buf_ops;
1263 struct xfs_btree_cur *cur,
1269 struct xfs_mount *mp = cur->bc_mp;
1276 error = xfs_btree_ptr_to_daddr(cur, ptr, &d);
1279 error = xfs_trans_read_buf(mp, cur->bc_tp, mp->m_ddev_targp, d,
1281 cur->bc_ops->buf_ops);
1285 xfs_btree_set_refs(cur, *bpp);
1295 struct xfs_btree_cur *cur,
1301 memcpy(dst_key, src_key, numkeys * cur->bc_ops->key_len);
1309 struct xfs_btree_cur *cur,
1315 memcpy(dst_rec, src_rec, numrecs * cur->bc_ops->rec_len);
1323 struct xfs_btree_cur *cur,
1329 memcpy(dst_ptr, src_ptr, numptrs * xfs_btree_ptr_len(cur));
1337 struct xfs_btree_cur *cur,
1347 dst_key = (char *)key + (dir * cur->bc_ops->key_len);
1348 memmove(dst_key, key, numkeys * cur->bc_ops->key_len);
1356 struct xfs_btree_cur *cur,
1366 dst_rec = (char *)rec + (dir * cur->bc_ops->rec_len);
1367 memmove(dst_rec, rec, numrecs * cur->bc_ops->rec_len);
1375 struct xfs_btree_cur *cur,
1385 dst_ptr = (char *)ptr + (dir * xfs_btree_ptr_len(cur));
1386 memmove(dst_ptr, ptr, numptrs * xfs_btree_ptr_len(cur));
1394 struct xfs_btree_cur *cur,
1401 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1402 xfs_trans_log_buf(cur->bc_tp, bp,
1403 xfs_btree_key_offset(cur, first),
1404 xfs_btree_key_offset(cur, last + 1) - 1);
1406 xfs_trans_log_inode(cur->bc_tp, cur->bc_ino.ip,
1407 xfs_ilog_fbroot(cur->bc_ino.whichfork));
1416 struct xfs_btree_cur *cur,
1422 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1423 xfs_trans_log_buf(cur->bc_tp, bp,
1424 xfs_btree_rec_offset(cur, first),
1425 xfs_btree_rec_offset(cur, last + 1) - 1);
1434 struct xfs_btree_cur *cur, /* btree cursor */
1444 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1445 xfs_trans_log_buf(cur->bc_tp, bp,
1446 xfs_btree_ptr_offset(cur, first, level),
1447 xfs_btree_ptr_offset(cur, last + 1, level) - 1);
1449 xfs_trans_log_inode(cur->bc_tp, cur->bc_ino.ip,
1450 xfs_ilog_fbroot(cur->bc_ino.whichfork));
1460 struct xfs_btree_cur *cur, /* btree cursor */
1497 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS) {
1512 (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
1515 xfs_trans_buf_set_type(cur->bc_tp, bp, XFS_BLFT_BTREE_BUF);
1516 xfs_trans_log_buf(cur->bc_tp, bp, first, last);
1518 xfs_trans_log_inode(cur->bc_tp, cur->bc_ino.ip,
1519 xfs_ilog_fbroot(cur->bc_ino.whichfork));
1529 struct xfs_btree_cur *cur,
1539 ASSERT(level < cur->bc_nlevels);
1542 xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
1545 block = xfs_btree_get_block(cur, level, &bp);
1548 error = xfs_btree_check_block(cur, block, level, bp);
1554 if (++cur->bc_ptrs[level] <= xfs_btree_get_numrecs(block))
1558 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1559 if (xfs_btree_ptr_is_null(cur, &ptr))
1562 XFS_BTREE_STATS_INC(cur, increment);
1568 for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
1569 block = xfs_btree_get_block(cur, lev, &bp);
1572 error = xfs_btree_check_block(cur, block, lev, bp);
1577 if (++cur->bc_ptrs[lev] <= xfs_btree_get_numrecs(block))
1581 xfs_btree_readahead(cur, lev, XFS_BTCUR_RIGHTRA);
1588 if (lev == cur->bc_nlevels) {
1589 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
1595 ASSERT(lev < cur->bc_nlevels);
1601 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
1604 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
1606 error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp);
1610 xfs_btree_setbuf(cur, lev, bp);
1611 cur->bc_ptrs[lev] = 1;
1631 struct xfs_btree_cur *cur,
1641 ASSERT(level < cur->bc_nlevels);
1644 xfs_btree_readahead(cur, level, XFS_BTCUR_LEFTRA);
1647 if (--cur->bc_ptrs[level] > 0)
1651 block = xfs_btree_get_block(cur, level, &bp);
1654 error = xfs_btree_check_block(cur, block, level, bp);
1660 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
1661 if (xfs_btree_ptr_is_null(cur, &ptr))
1664 XFS_BTREE_STATS_INC(cur, decrement);
1670 for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
1671 if (--cur->bc_ptrs[lev] > 0)
1674 xfs_btree_readahead(cur, lev, XFS_BTCUR_LEFTRA);
1681 if (lev == cur->bc_nlevels) {
1682 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
1688 ASSERT(lev < cur->bc_nlevels);
1694 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
1697 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
1699 error = xfs_btree_read_buf_block(cur, ptrp, 0, &block, &bp);
1702 xfs_btree_setbuf(cur, lev, bp);
1703 cur->bc_ptrs[lev] = xfs_btree_get_numrecs(block);
1719 struct xfs_btree_cur *cur, /* btree cursor */
1729 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
1730 (level == cur->bc_nlevels - 1)) {
1731 *blkp = xfs_btree_get_iroot(cur);
1741 bp = cur->bc_bufs[level];
1742 error = xfs_btree_ptr_to_daddr(cur, pp, &daddr);
1750 error = xfs_btree_read_buf_block(cur, pp, 0, blkp, &bp);
1755 if (xfs_sb_version_hascrc(&cur->bc_mp->m_sb) &&
1756 !(cur->bc_ino.flags & XFS_BTCUR_BMBT_INVALID_OWNER) &&
1757 (cur->bc_flags & XFS_BTREE_LONG_PTRS) &&
1759 cur->bc_ino.ip->i_ino)
1770 xfs_btree_setbuf(cur, level, bp);
1776 xfs_trans_brelse(cur->bc_tp, bp);
1787 struct xfs_btree_cur *cur,
1794 cur->bc_ops->init_key_from_rec(kp,
1795 xfs_btree_rec_addr(cur, keyno, block));
1799 return xfs_btree_key_addr(cur, keyno, block);
1808 struct xfs_btree_cur *cur, /* btree cursor */
1820 XFS_BTREE_STATS_INC(cur, lookup);
1823 if (XFS_IS_CORRUPT(cur->bc_mp, cur->bc_nlevels == 0))
1830 cur->bc_ops->init_ptr_from_cur(cur, &ptr);
1839 for (level = cur->bc_nlevels - 1, diff = 1; level >= 0; level--) {
1841 error = xfs_btree_lookup_get_block(cur, level, pp, &block);
1862 if (level != 0 || cur->bc_nlevels != 1) {
1865 cur->bc_mp, block,
1870 cur->bc_ptrs[0] = dir != XFS_LOOKUP_LE;
1880 XFS_BTREE_STATS_INC(cur, compare);
1886 kp = xfs_lookup_get_search_key(cur, level,
1895 diff = cur->bc_ops->key_diff(cur, kp);
1916 pp = xfs_btree_ptr_addr(cur, keyno, block);
1918 error = xfs_btree_debug_check_ptr(cur, pp, 0, level);
1922 cur->bc_ptrs[level] = keyno;
1933 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1936 !xfs_btree_ptr_is_null(cur, &ptr)) {
1939 cur->bc_ptrs[0] = keyno;
1940 error = xfs_btree_increment(cur, 0, &i);
1943 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1))
1950 cur->bc_ptrs[0] = keyno;
1968 struct xfs_btree_cur *cur,
1971 ASSERT(cur->bc_flags & XFS_BTREE_OVERLAPPING);
1973 (cur->bc_ops->key_len / 2));
1979 struct xfs_btree_cur *cur,
1989 rec = xfs_btree_rec_addr(cur, 1, block);
1990 cur->bc_ops->init_key_from_rec(key, rec);
1992 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
1994 cur->bc_ops->init_high_key_from_rec(&max_hkey, rec);
1996 rec = xfs_btree_rec_addr(cur, n, block);
1997 cur->bc_ops->init_high_key_from_rec(&hkey, rec);
1998 if (cur->bc_ops->diff_two_keys(cur, &hkey, &max_hkey)
2003 high = xfs_btree_high_key_from_key(cur, key);
2004 memcpy(high, &max_hkey, cur->bc_ops->key_len / 2);
2011 struct xfs_btree_cur *cur,
2020 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2021 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2022 cur->bc_ops->key_len / 2);
2024 max_hkey = xfs_btree_high_key_addr(cur, 1, block);
2026 hkey = xfs_btree_high_key_addr(cur, n, block);
2027 if (cur->bc_ops->diff_two_keys(cur, hkey, max_hkey) > 0)
2031 high = xfs_btree_high_key_from_key(cur, key);
2032 memcpy(high, max_hkey, cur->bc_ops->key_len / 2);
2034 memcpy(key, xfs_btree_key_addr(cur, 1, block),
2035 cur->bc_ops->key_len);
2042 struct xfs_btree_cur *cur,
2047 xfs_btree_get_leaf_keys(cur, block, key);
2049 xfs_btree_get_node_keys(cur, block, key);
2061 struct xfs_btree_cur *cur,
2064 return (cur->bc_flags & XFS_BTREE_OVERLAPPING) || ptr == 1;
2074 struct xfs_btree_cur *cur,
2088 ASSERT(cur->bc_flags & XFS_BTREE_OVERLAPPING);
2091 if (level + 1 >= cur->bc_nlevels)
2094 trace_xfs_btree_updkeys(cur, level, bp0);
2097 hkey = xfs_btree_high_key_from_key(cur, lkey);
2098 xfs_btree_get_keys(cur, block, lkey);
2099 for (level++; level < cur->bc_nlevels; level++) {
2103 block = xfs_btree_get_block(cur, level, &bp);
2104 trace_xfs_btree_updkeys(cur, level, bp);
2106 error = xfs_btree_check_block(cur, block, level, bp);
2110 ptr = cur->bc_ptrs[level];
2111 nlkey = xfs_btree_key_addr(cur, ptr, block);
2112 nhkey = xfs_btree_high_key_addr(cur, ptr, block);
2114 !(cur->bc_ops->diff_two_keys(cur, nlkey, lkey) != 0 ||
2115 cur->bc_ops->diff_two_keys(cur, nhkey, hkey) != 0))
2117 xfs_btree_copy_keys(cur, nlkey, lkey, 1);
2118 xfs_btree_log_keys(cur, bp, ptr, ptr);
2119 if (level + 1 >= cur->bc_nlevels)
2121 xfs_btree_get_node_keys(cur, block, lkey);
2130 struct xfs_btree_cur *cur,
2136 block = xfs_btree_get_block(cur, level, &bp);
2137 return __xfs_btree_updkeys(cur, level, block, bp, true);
2145 struct xfs_btree_cur *cur,
2156 block = xfs_btree_get_block(cur, level, &bp);
2157 if (cur->bc_flags & XFS_BTREE_OVERLAPPING)
2158 return __xfs_btree_updkeys(cur, level, block, bp, false);
2166 xfs_btree_get_keys(cur, block, &key);
2167 for (level++, ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
2171 block = xfs_btree_get_block(cur, level, &bp);
2173 error = xfs_btree_check_block(cur, block, level, bp);
2177 ptr = cur->bc_ptrs[level];
2178 kp = xfs_btree_key_addr(cur, ptr, block);
2179 xfs_btree_copy_keys(cur, kp, &key, 1);
2180 xfs_btree_log_keys(cur, bp, ptr, ptr);
2187 * Update the record referred to by cur to the value in the
2193 struct xfs_btree_cur *cur,
2203 block = xfs_btree_get_block(cur, 0, &bp);
2206 error = xfs_btree_check_block(cur, block, 0, bp);
2211 ptr = cur->bc_ptrs[0];
2212 rp = xfs_btree_rec_addr(cur, ptr, block);
2215 xfs_btree_copy_recs(cur, rp, rec, 1);
2216 xfs_btree_log_recs(cur, bp, ptr, ptr);
2222 if (xfs_btree_is_lastrec(cur, block, 0)) {
2223 cur->bc_ops->update_lastrec(cur, block, rec,
2228 if (xfs_btree_needs_key_update(cur, ptr)) {
2229 error = xfs_btree_update_keys(cur, 0);
2241 * Move 1 record left from cur/level if possible.
2242 * Update cur to reflect the new path.
2246 struct xfs_btree_cur *cur,
2264 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
2265 level == cur->bc_nlevels - 1)
2269 right = xfs_btree_get_block(cur, level, &rbp);
2272 error = xfs_btree_check_block(cur, right, level, rbp);
2278 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
2279 if (xfs_btree_ptr_is_null(cur, &lptr))
2286 if (cur->bc_ptrs[level] <= 1)
2290 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
2296 if (lrecs == cur->bc_ops->get_maxrecs(cur, level))
2309 XFS_BTREE_STATS_INC(cur, lshift);
2310 XFS_BTREE_STATS_ADD(cur, moves, 1);
2321 lkp = xfs_btree_key_addr(cur, lrecs, left);
2322 rkp = xfs_btree_key_addr(cur, 1, right);
2324 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2325 rpp = xfs_btree_ptr_addr(cur, 1, right);
2327 error = xfs_btree_debug_check_ptr(cur, rpp, 0, level);
2331 xfs_btree_copy_keys(cur, lkp, rkp, 1);
2332 xfs_btree_copy_ptrs(cur, lpp, rpp, 1);
2334 xfs_btree_log_keys(cur, lbp, lrecs, lrecs);
2335 xfs_btree_log_ptrs(cur, lbp, lrecs, lrecs);
2337 ASSERT(cur->bc_ops->keys_inorder(cur,
2338 xfs_btree_key_addr(cur, lrecs - 1, left), lkp));
2343 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2344 rrp = xfs_btree_rec_addr(cur, 1, right);
2346 xfs_btree_copy_recs(cur, lrp, rrp, 1);
2347 xfs_btree_log_recs(cur, lbp, lrecs, lrecs);
2349 ASSERT(cur->bc_ops->recs_inorder(cur,
2350 xfs_btree_rec_addr(cur, lrecs - 1, left), lrp));
2354 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
2357 xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
2362 XFS_BTREE_STATS_ADD(cur, moves, rrecs - 1);
2366 error = xfs_btree_debug_check_ptr(cur, rpp, i + 1, level);
2371 xfs_btree_shift_keys(cur,
2372 xfs_btree_key_addr(cur, 2, right),
2374 xfs_btree_shift_ptrs(cur,
2375 xfs_btree_ptr_addr(cur, 2, right),
2378 xfs_btree_log_keys(cur, rbp, 1, rrecs);
2379 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
2382 xfs_btree_shift_recs(cur,
2383 xfs_btree_rec_addr(cur, 2, right),
2385 xfs_btree_log_recs(cur, rbp, 1, rrecs);
2392 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2393 error = xfs_btree_dup_cursor(cur, &tcur);
2415 error = xfs_btree_update_keys(cur, level);
2420 cur->bc_ptrs[level]--;
2438 * Move 1 record right from cur/level if possible.
2439 * Update cur to reflect the new path.
2443 struct xfs_btree_cur *cur,
2459 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
2460 (level == cur->bc_nlevels - 1))
2464 left = xfs_btree_get_block(cur, level, &lbp);
2467 error = xfs_btree_check_block(cur, left, level, lbp);
2473 xfs_btree_get_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2474 if (xfs_btree_ptr_is_null(cur, &rptr))
2482 if (cur->bc_ptrs[level] >= lrecs)
2486 error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
2492 if (rrecs == cur->bc_ops->get_maxrecs(cur, level))
2495 XFS_BTREE_STATS_INC(cur, rshift);
2496 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
2508 lkp = xfs_btree_key_addr(cur, lrecs, left);
2509 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2510 rkp = xfs_btree_key_addr(cur, 1, right);
2511 rpp = xfs_btree_ptr_addr(cur, 1, right);
2514 error = xfs_btree_debug_check_ptr(cur, rpp, i, level);
2519 xfs_btree_shift_keys(cur, rkp, 1, rrecs);
2520 xfs_btree_shift_ptrs(cur, rpp, 1, rrecs);
2522 error = xfs_btree_debug_check_ptr(cur, lpp, 0, level);
2527 xfs_btree_copy_keys(cur, rkp, lkp, 1);
2528 xfs_btree_copy_ptrs(cur, rpp, lpp, 1);
2530 xfs_btree_log_keys(cur, rbp, 1, rrecs + 1);
2531 xfs_btree_log_ptrs(cur, rbp, 1, rrecs + 1);
2533 ASSERT(cur->bc_ops->keys_inorder(cur, rkp,
2534 xfs_btree_key_addr(cur, 2, right)));
2540 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2541 rrp = xfs_btree_rec_addr(cur, 1, right);
2543 xfs_btree_shift_recs(cur, rrp, 1, rrecs);
2546 xfs_btree_copy_recs(cur, rrp, lrp, 1);
2547 xfs_btree_log_recs(cur, rbp, 1, rrecs + 1);
2554 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
2557 xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
2563 error = xfs_btree_dup_cursor(cur, &tcur);
2577 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2578 error = xfs_btree_update_keys(cur, level);
2606 * Split cur/level block in half.
2612 struct xfs_btree_cur *cur,
2634 XFS_BTREE_STATS_INC(cur, split);
2637 left = xfs_btree_get_block(cur, level, &lbp);
2640 error = xfs_btree_check_block(cur, left, level, lbp);
2645 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
2648 error = cur->bc_ops->alloc_block(cur, &lptr, &rptr, stat);
2653 XFS_BTREE_STATS_INC(cur, alloc);
2656 error = xfs_btree_get_buf_block(cur, &rptr, &right, &rbp);
2661 xfs_btree_init_block_cur(cur, rbp, xfs_btree_get_level(left), 0);
2670 if ((lrecs & 1) && cur->bc_ptrs[level] <= rrecs + 1)
2674 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
2693 lkp = xfs_btree_key_addr(cur, src_index, left);
2694 lpp = xfs_btree_ptr_addr(cur, src_index, left);
2695 rkp = xfs_btree_key_addr(cur, 1, right);
2696 rpp = xfs_btree_ptr_addr(cur, 1, right);
2699 error = xfs_btree_debug_check_ptr(cur, lpp, i, level);
2705 xfs_btree_copy_keys(cur, rkp, lkp, rrecs);
2706 xfs_btree_copy_ptrs(cur, rpp, lpp, rrecs);
2708 xfs_btree_log_keys(cur, rbp, 1, rrecs);
2709 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
2712 xfs_btree_get_node_keys(cur, right, key);
2718 lrp = xfs_btree_rec_addr(cur, src_index, left);
2719 rrp = xfs_btree_rec_addr(cur, 1, right);
2722 xfs_btree_copy_recs(cur, rrp, lrp, rrecs);
2723 xfs_btree_log_recs(cur, rbp, 1, rrecs);
2726 xfs_btree_get_leaf_keys(cur, right, key);
2733 xfs_btree_get_sibling(cur, left, &rrptr, XFS_BB_RIGHTSIB);
2734 xfs_btree_set_sibling(cur, right, &rrptr, XFS_BB_RIGHTSIB);
2735 xfs_btree_set_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
2736 xfs_btree_set_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2738 xfs_btree_log_block(cur, rbp, XFS_BB_ALL_BITS);
2739 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
2745 if (!xfs_btree_ptr_is_null(cur, &rrptr)) {
2746 error = xfs_btree_read_buf_block(cur, &rrptr,
2750 xfs_btree_set_sibling(cur, rrblock, &rptr, XFS_BB_LEFTSIB);
2751 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
2755 if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
2756 error = xfs_btree_update_keys(cur, level);
2766 if (cur->bc_ptrs[level] > lrecs + 1) {
2767 xfs_btree_setbuf(cur, level, rbp);
2768 cur->bc_ptrs[level] -= lrecs;
2774 if (level + 1 < cur->bc_nlevels) {
2775 error = xfs_btree_dup_cursor(cur, curp);
2792 struct xfs_btree_cur *cur;
2826 xfs_trans_set_context(args->cur->bc_tp);
2828 args->result = __xfs_btree_split(args->cur, args->level, args->ptrp,
2831 xfs_trans_clear_context(args->cur->bc_tp);
2849 struct xfs_btree_cur *cur,
2859 if (cur->bc_btnum != XFS_BTNUM_BMAP)
2860 return __xfs_btree_split(cur, level, ptrp, key, curp, stat);
2862 args.cur = cur;
2884 struct xfs_btree_cur *cur, /* btree cursor */
2900 XFS_BTREE_STATS_INC(cur, newroot);
2902 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
2904 level = cur->bc_nlevels - 1;
2906 block = xfs_btree_get_iroot(cur);
2907 pp = xfs_btree_ptr_addr(cur, 1, block);
2910 error = cur->bc_ops->alloc_block(cur, pp, &nptr, stat);
2916 XFS_BTREE_STATS_INC(cur, alloc);
2919 error = xfs_btree_get_buf_block(cur, &nptr, &cblock, &cbp);
2927 memcpy(cblock, block, xfs_btree_block_len(cur));
2928 if (cur->bc_flags & XFS_BTREE_CRC_BLOCKS) {
2929 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
2937 cur->bc_nlevels++;
2938 cur->bc_ptrs[level + 1] = 1;
2940 kp = xfs_btree_key_addr(cur, 1, block);
2941 ckp = xfs_btree_key_addr(cur, 1, cblock);
2942 xfs_btree_copy_keys(cur, ckp, kp, xfs_btree_get_numrecs(cblock));
2944 cpp = xfs_btree_ptr_addr(cur, 1, cblock);
2946 error = xfs_btree_debug_check_ptr(cur, pp, i, level);
2951 xfs_btree_copy_ptrs(cur, cpp, pp, xfs_btree_get_numrecs(cblock));
2953 error = xfs_btree_debug_check_ptr(cur, &nptr, 0, level);
2957 xfs_btree_copy_ptrs(cur, pp, &nptr, 1);
2959 xfs_iroot_realloc(cur->bc_ino.ip,
2961 cur->bc_ino.whichfork);
2963 xfs_btree_setbuf(cur, level, cbp);
2969 xfs_btree_log_block(cur, cbp, XFS_BB_ALL_BITS);
2970 xfs_btree_log_keys(cur, cbp, 1, be16_to_cpu(cblock->bb_numrecs));
2971 xfs_btree_log_ptrs(cur, cbp, 1, be16_to_cpu(cblock->bb_numrecs));
2974 XFS_ILOG_CORE | xfs_ilog_fbroot(cur->bc_ino.whichfork);
2986 struct xfs_btree_cur *cur, /* btree cursor */
3002 XFS_BTREE_STATS_INC(cur, newroot);
3005 cur->bc_ops->init_ptr_from_cur(cur, &rptr);
3008 error = cur->bc_ops->alloc_block(cur, &rptr, &lptr, stat);
3013 XFS_BTREE_STATS_INC(cur, alloc);
3016 error = xfs_btree_get_buf_block(cur, &lptr, &new, &nbp);
3021 cur->bc_ops->set_root(cur, &lptr, 1);
3029 block = xfs_btree_get_block(cur, cur->bc_nlevels - 1, &bp);
3032 error = xfs_btree_check_block(cur, block, cur->bc_nlevels - 1, bp);
3037 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
3038 if (!xfs_btree_ptr_is_null(cur, &rptr)) {
3041 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
3043 error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
3051 xfs_btree_buf_to_ptr(cur, rbp, &rptr);
3053 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
3054 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
3062 xfs_btree_init_block_cur(cur, nbp, cur->bc_nlevels, 2);
3063 xfs_btree_log_block(cur, nbp, XFS_BB_ALL_BITS);
3064 ASSERT(!xfs_btree_ptr_is_null(cur, &lptr) &&
3065 !xfs_btree_ptr_is_null(cur, &rptr));
3073 xfs_btree_get_node_keys(cur, left,
3074 xfs_btree_key_addr(cur, 1, new));
3075 xfs_btree_get_node_keys(cur, right,
3076 xfs_btree_key_addr(cur, 2, new));
3083 xfs_btree_get_leaf_keys(cur, left,
3084 xfs_btree_key_addr(cur, 1, new));
3085 xfs_btree_get_leaf_keys(cur, right,
3086 xfs_btree_key_addr(cur, 2, new));
3088 xfs_btree_log_keys(cur, nbp, 1, 2);
3091 xfs_btree_copy_ptrs(cur,
3092 xfs_btree_ptr_addr(cur, 1, new), &lptr, 1);
3093 xfs_btree_copy_ptrs(cur,
3094 xfs_btree_ptr_addr(cur, 2, new), &rptr, 1);
3095 xfs_btree_log_ptrs(cur, nbp, 1, 2);
3098 xfs_btree_setbuf(cur, cur->bc_nlevels, nbp);
3099 cur->bc_ptrs[cur->bc_nlevels] = nptr;
3100 cur->bc_nlevels++;
3112 struct xfs_btree_cur *cur, /* btree cursor */
3124 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
3125 level == cur->bc_nlevels - 1) {
3126 struct xfs_inode *ip = cur->bc_ino.ip;
3128 if (numrecs < cur->bc_ops->get_dmaxrecs(cur, level)) {
3130 xfs_iroot_realloc(ip, 1, cur->bc_ino.whichfork);
3136 error = xfs_btree_new_iroot(cur, &logflags, stat);
3140 xfs_trans_log_inode(cur->bc_tp, ip, logflags);
3147 error = xfs_btree_rshift(cur, level, stat);
3152 error = xfs_btree_lshift(cur, level, stat);
3157 *oindex = *index = cur->bc_ptrs[level];
3167 error = xfs_btree_split(cur, level, nptr, key, ncur, stat);
3172 *index = cur->bc_ptrs[level];
3182 struct xfs_btree_cur *cur, /* btree cursor */
3187 struct xfs_btree_cur **curp, /* output: new cursor replacing cur */
3210 if (!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
3211 (level >= cur->bc_nlevels)) {
3212 error = xfs_btree_new_root(cur, stat);
3213 xfs_btree_set_ptr_null(cur, ptrp);
3219 ptr = cur->bc_ptrs[level];
3227 XFS_BTREE_STATS_INC(cur, insrec);
3230 block = xfs_btree_get_block(cur, level, &bp);
3235 error = xfs_btree_check_block(cur, block, level, bp);
3242 ASSERT(cur->bc_ops->recs_inorder(cur, rec,
3243 xfs_btree_rec_addr(cur, ptr, block)));
3245 ASSERT(cur->bc_ops->keys_inorder(cur, key,
3246 xfs_btree_key_addr(cur, ptr, block)));
3255 xfs_btree_set_ptr_null(cur, &nptr);
3256 if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
3257 error = xfs_btree_make_block_unfull(cur, level, numrecs,
3267 block = xfs_btree_get_block(cur, level, &bp);
3271 error = xfs_btree_check_block(cur, block, level, bp);
3280 XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr + 1);
3287 kp = xfs_btree_key_addr(cur, ptr, block);
3288 pp = xfs_btree_ptr_addr(cur, ptr, block);
3291 error = xfs_btree_debug_check_ptr(cur, pp, i, level);
3296 xfs_btree_shift_keys(cur, kp, 1, numrecs - ptr + 1);
3297 xfs_btree_shift_ptrs(cur, pp, 1, numrecs - ptr + 1);
3299 error = xfs_btree_debug_check_ptr(cur, ptrp, 0, level);
3304 xfs_btree_copy_keys(cur, kp, key, 1);
3305 xfs_btree_copy_ptrs(cur, pp, ptrp, 1);
3308 xfs_btree_log_ptrs(cur, bp, ptr, numrecs);
3309 xfs_btree_log_keys(cur, bp, ptr, numrecs);
3312 ASSERT(cur->bc_ops->keys_inorder(cur, kp,
3313 xfs_btree_key_addr(cur, ptr + 1, block)));
3320 rp = xfs_btree_rec_addr(cur, ptr, block);
3322 xfs_btree_shift_recs(cur, rp, 1, numrecs - ptr + 1);
3325 xfs_btree_copy_recs(cur, rp, rec, 1);
3327 xfs_btree_log_recs(cur, bp, ptr, numrecs);
3330 ASSERT(cur->bc_ops->recs_inorder(cur, rp,
3331 xfs_btree_rec_addr(cur, ptr + 1, block)));
3337 xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
3348 xfs_btree_get_keys(cur, block, lkey);
3349 } else if (xfs_btree_needs_key_update(cur, optr)) {
3350 error = xfs_btree_update_keys(cur, level);
3359 if (xfs_btree_is_lastrec(cur, block, level)) {
3360 cur->bc_ops->update_lastrec(cur, block, rec,
3369 if (!xfs_btree_ptr_is_null(cur, &nptr)) {
3370 xfs_btree_copy_keys(cur, key, lkey, 1);
3384 * Insert the record at the point referenced by cur.
3392 struct xfs_btree_cur *cur,
3407 pcur = cur;
3410 xfs_btree_set_ptr_null(cur, &nptr);
3413 cur->bc_ops->init_rec_from_cur(cur, &rec);
3414 cur->bc_ops->init_key_from_rec(key, &rec);
3429 if (pcur != cur)
3434 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3445 if (pcur != cur &&
3446 (ncur || xfs_btree_ptr_is_null(cur, &nptr))) {
3448 if (cur->bc_ops->update_cursor)
3449 cur->bc_ops->update_cursor(pcur, cur);
3450 cur->bc_nlevels = pcur->bc_nlevels;
3458 } while (!xfs_btree_ptr_is_null(cur, &nptr));
3476 struct xfs_btree_cur *cur)
3478 int whichfork = cur->bc_ino.whichfork;
3479 struct xfs_inode *ip = cur->bc_ino.ip;
3497 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
3498 ASSERT(cur->bc_nlevels > 1);
3504 level = cur->bc_nlevels - 1;
3511 block = xfs_btree_get_iroot(cur);
3515 cblock = xfs_btree_get_block(cur, level - 1, &cbp);
3523 if (numrecs > cur->bc_ops->get_dmaxrecs(cur, level))
3526 XFS_BTREE_STATS_INC(cur, killroot);
3529 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
3530 ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
3531 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
3532 ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
3535 index = numrecs - cur->bc_ops->get_maxrecs(cur, level);
3537 xfs_iroot_realloc(cur->bc_ino.ip, index,
3538 cur->bc_ino.whichfork);
3545 kp = xfs_btree_key_addr(cur, 1, block);
3546 ckp = xfs_btree_key_addr(cur, 1, cblock);
3547 xfs_btree_copy_keys(cur, kp, ckp, numrecs);
3549 pp = xfs_btree_ptr_addr(cur, 1, block);
3550 cpp = xfs_btree_ptr_addr(cur, 1, cblock);
3553 error = xfs_btree_debug_check_ptr(cur, cpp, i, level - 1);
3558 xfs_btree_copy_ptrs(cur, pp, cpp, numrecs);
3560 error = xfs_btree_free_block(cur, cbp);
3564 cur->bc_bufs[level - 1] = NULL;
3566 xfs_trans_log_inode(cur->bc_tp, ip,
3567 XFS_ILOG_CORE | xfs_ilog_fbroot(cur->bc_ino.whichfork));
3568 cur->bc_nlevels--;
3578 struct xfs_btree_cur *cur,
3585 XFS_BTREE_STATS_INC(cur, killroot);
3591 cur->bc_ops->set_root(cur, newroot, -1);
3593 error = xfs_btree_free_block(cur, bp);
3597 cur->bc_bufs[level] = NULL;
3598 cur->bc_ra[level] = 0;
3599 cur->bc_nlevels--;
3606 struct xfs_btree_cur *cur,
3614 error = xfs_btree_decrement(cur, level, &i);
3625 * Delete record pointed to by cur/level.
3631 struct xfs_btree_cur *cur, /* btree cursor */
3657 ptr = cur->bc_ptrs[level];
3664 block = xfs_btree_get_block(cur, level, &bp);
3668 error = xfs_btree_check_block(cur, block, level, bp);
3679 XFS_BTREE_STATS_INC(cur, delrec);
3680 XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr);
3688 lkp = xfs_btree_key_addr(cur, ptr + 1, block);
3689 lpp = xfs_btree_ptr_addr(cur, ptr + 1, block);
3692 error = xfs_btree_debug_check_ptr(cur, lpp, i, level);
3698 xfs_btree_shift_keys(cur, lkp, -1, numrecs - ptr);
3699 xfs_btree_shift_ptrs(cur, lpp, -1, numrecs - ptr);
3700 xfs_btree_log_keys(cur, bp, ptr, numrecs - 1);
3701 xfs_btree_log_ptrs(cur, bp, ptr, numrecs - 1);
3706 xfs_btree_shift_recs(cur,
3707 xfs_btree_rec_addr(cur, ptr + 1, block),
3709 xfs_btree_log_recs(cur, bp, ptr, numrecs - 1);
3717 xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
3723 if (xfs_btree_is_lastrec(cur, block, level)) {
3724 cur->bc_ops->update_lastrec(cur, block, NULL,
3733 if (level == cur->bc_nlevels - 1) {
3734 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
3735 xfs_iroot_realloc(cur->bc_ino.ip, -1,
3736 cur->bc_ino.whichfork);
3738 error = xfs_btree_kill_iroot(cur);
3742 error = xfs_btree_dec_cursor(cur, level, stat);
3760 pp = xfs_btree_ptr_addr(cur, 1, block);
3761 error = xfs_btree_kill_root(cur, bp, level, pp);
3765 error = xfs_btree_dec_cursor(cur, level, stat);
3777 if (xfs_btree_needs_key_update(cur, ptr)) {
3778 error = xfs_btree_update_keys(cur, level);
3787 if (numrecs >= cur->bc_ops->get_minrecs(cur, level)) {
3788 error = xfs_btree_dec_cursor(cur, level, stat);
3799 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
3800 xfs_btree_get_sibling(cur, block, &lptr, XFS_BB_LEFTSIB);
3802 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
3808 if (xfs_btree_ptr_is_null(cur, &rptr) &&
3809 xfs_btree_ptr_is_null(cur, &lptr) &&
3810 level == cur->bc_nlevels - 2) {
3811 error = xfs_btree_kill_iroot(cur);
3813 error = xfs_btree_dec_cursor(cur, level, stat);
3820 ASSERT(!xfs_btree_ptr_is_null(cur, &rptr) ||
3821 !xfs_btree_ptr_is_null(cur, &lptr));
3827 error = xfs_btree_dup_cursor(cur, &tcur);
3835 if (!xfs_btree_ptr_is_null(cur, &rptr)) {
3841 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3849 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3855 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3876 cur->bc_ops->get_minrecs(tcur, level)) {
3882 cur->bc_ops->get_minrecs(tcur, level));
3887 error = xfs_btree_dec_cursor(cur, level, stat);
3900 if (!xfs_btree_ptr_is_null(cur, &lptr)) {
3902 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3910 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3921 if (!xfs_btree_ptr_is_null(cur, &lptr)) {
3927 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3936 if (XFS_IS_CORRUPT(cur->bc_mp, i != 1)) {
3944 error = xfs_btree_check_block(cur, left, level, lbp);
3957 cur->bc_ops->get_minrecs(tcur, level)) {
3963 cur->bc_ops->get_minrecs(tcur, level));
3967 cur->bc_ptrs[0]++;
3986 ASSERT(!xfs_btree_ptr_is_null(cur, &cptr));
3988 if (!xfs_btree_ptr_is_null(cur, &lptr) &&
3990 cur->bc_ops->get_maxrecs(cur, level)) {
3998 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
4005 } else if (!xfs_btree_ptr_is_null(cur, &rptr) &&
4007 cur->bc_ops->get_maxrecs(cur, level)) {
4015 error = xfs_btree_read_buf_block(cur, &rptr, 0, &right, &rbp);
4024 error = xfs_btree_dec_cursor(cur, level, stat);
4037 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
4045 lkp = xfs_btree_key_addr(cur, lrecs + 1, left);
4046 lpp = xfs_btree_ptr_addr(cur, lrecs + 1, left);
4047 rkp = xfs_btree_key_addr(cur, 1, right);
4048 rpp = xfs_btree_ptr_addr(cur, 1, right);
4051 error = xfs_btree_debug_check_ptr(cur, rpp, i, level);
4056 xfs_btree_copy_keys(cur, lkp, rkp, rrecs);
4057 xfs_btree_copy_ptrs(cur, lpp, rpp, rrecs);
4059 xfs_btree_log_keys(cur, lbp, lrecs + 1, lrecs + rrecs);
4060 xfs_btree_log_ptrs(cur, lbp, lrecs + 1, lrecs + rrecs);
4066 lrp = xfs_btree_rec_addr(cur, lrecs + 1, left);
4067 rrp = xfs_btree_rec_addr(cur, 1, right);
4069 xfs_btree_copy_recs(cur, lrp, rrp, rrecs);
4070 xfs_btree_log_recs(cur, lbp, lrecs + 1, lrecs + rrecs);
4073 XFS_BTREE_STATS_INC(cur, join);
4080 xfs_btree_get_sibling(cur, right, &cptr, XFS_BB_RIGHTSIB),
4081 xfs_btree_set_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
4082 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
4085 xfs_btree_get_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
4086 if (!xfs_btree_ptr_is_null(cur, &cptr)) {
4087 error = xfs_btree_read_buf_block(cur, &cptr, 0, &rrblock, &rrbp);
4090 xfs_btree_set_sibling(cur, rrblock, &lptr, XFS_BB_LEFTSIB);
4091 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
4095 error = xfs_btree_free_block(cur, rbp);
4104 cur->bc_bufs[level] = lbp;
4105 cur->bc_ptrs[level] += lrecs;
4106 cur->bc_ra[level] = 0;
4112 else if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) ||
4113 (level + 1 < cur->bc_nlevels)) {
4114 error = xfs_btree_increment(cur, level + 1, &i);
4126 cur->bc_ptrs[level]--;
4149 * Delete the record pointed to by cur.
4155 struct xfs_btree_cur *cur,
4170 error = xfs_btree_delrec(cur, level, &i);
4181 if (joined && (cur->bc_flags & XFS_BTREE_OVERLAPPING)) {
4182 error = xfs_btree_updkeys_force(cur, 0);
4188 for (level = 1; level < cur->bc_nlevels; level++) {
4189 if (cur->bc_ptrs[level] == 0) {
4190 error = xfs_btree_decrement(cur, level, &i);
4209 struct xfs_btree_cur *cur, /* btree cursor */
4220 ptr = cur->bc_ptrs[0];
4221 block = xfs_btree_get_block(cur, 0, &bp);
4224 error = xfs_btree_check_block(cur, block, 0, bp);
4240 *recp = xfs_btree_rec_addr(cur, ptr, block);
4248 struct xfs_btree_cur *cur,
4259 xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
4260 block = xfs_btree_get_block(cur, level, &bp);
4263 error = fn(cur, level, data);
4268 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
4269 if (xfs_btree_ptr_is_null(cur, &rptr))
4272 return xfs_btree_lookup_get_block(cur, level, &rptr, &block);
4279 struct xfs_btree_cur *cur,
4289 cur->bc_ops->init_ptr_from_cur(cur, &lptr);
4292 for (level = cur->bc_nlevels - 1; level >= 0; level--) {
4294 error = xfs_btree_lookup_get_block(cur, level, &lptr, &block);
4302 ptr = xfs_btree_ptr_addr(cur, 1, block);
4303 xfs_btree_readahead_ptr(cur, ptr, 1);
4306 xfs_btree_copy_ptrs(cur, &lptr, ptr, 1);
4316 error = xfs_btree_visit_block(cur, level, fn, data);
4357 struct xfs_btree_cur *cur,
4366 block = xfs_btree_get_block(cur, level, &bp);
4367 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
4385 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
4386 ASSERT(level == cur->bc_nlevels - 1);
4390 if (cur->bc_tp) {
4391 if (!xfs_trans_ordered_buf(cur->bc_tp, bp)) {
4392 xfs_btree_log_block(cur, bp, XFS_BB_OWNER);
4404 struct xfs_btree_cur *cur,
4413 return xfs_btree_visit_blocks(cur, xfs_btree_block_change_owner,
4543 struct xfs_btree_cur *cur,
4556 ASSERT(cur->bc_ops->init_high_key_from_rec);
4557 ASSERT(cur->bc_ops->diff_two_keys);
4564 error = xfs_btree_lookup(cur, XFS_LOOKUP_LE, &stat);
4570 error = xfs_btree_increment(cur, 0, &stat);
4577 error = xfs_btree_get_rec(cur, &recp, &stat);
4583 cur->bc_ops->init_high_key_from_rec(&rec_key, recp);
4585 diff = cur->bc_ops->diff_two_keys(cur, low_key,
4592 cur->bc_ops->init_key_from_rec(&rec_key, recp);
4593 diff = cur->bc_ops->diff_two_keys(cur, &rec_key, high_key);
4598 error = fn(cur, recp, priv);
4604 error = xfs_btree_increment(cur, 0, &stat);
4634 struct xfs_btree_cur *cur,
4656 level = cur->bc_nlevels - 1;
4657 cur->bc_ops->init_ptr_from_cur(cur, &ptr);
4658 error = xfs_btree_lookup_get_block(cur, level, &ptr, &block);
4661 xfs_btree_get_block(cur, level, &bp);
4662 trace_xfs_btree_overlapped_query_range(cur, level, bp);
4664 error = xfs_btree_check_block(cur, block, level, bp);
4668 cur->bc_ptrs[level] = 1;
4670 while (level < cur->bc_nlevels) {
4671 block = xfs_btree_get_block(cur, level, &bp);
4674 if (cur->bc_ptrs[level] > be16_to_cpu(block->bb_numrecs)) {
4676 if (level < cur->bc_nlevels - 1)
4677 cur->bc_ptrs[level + 1]++;
4684 recp = xfs_btree_rec_addr(cur, cur->bc_ptrs[0], block);
4686 cur->bc_ops->init_high_key_from_rec(&rec_hkey, recp);
4687 ldiff = cur->bc_ops->diff_two_keys(cur, &rec_hkey,
4690 cur->bc_ops->init_key_from_rec(&rec_key, recp);
4691 hdiff = cur->bc_ops->diff_two_keys(cur, high_key,
4700 error = fn(cur, recp, priv);
4707 cur->bc_ptrs[level]++;
4712 lkp = xfs_btree_key_addr(cur, cur->bc_ptrs[level], block);
4713 hkp = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level], block);
4714 pp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[level], block);
4716 ldiff = cur->bc_ops->diff_two_keys(cur, hkp, low_key);
4717 hdiff = cur->bc_ops->diff_two_keys(cur, high_key, lkp);
4726 error = xfs_btree_lookup_get_block(cur, level, pp,
4730 xfs_btree_get_block(cur, level, &bp);
4731 trace_xfs_btree_overlapped_query_range(cur, level, bp);
4733 error = xfs_btree_check_block(cur, block, level, bp);
4737 cur->bc_ptrs[level] = 1;
4743 cur->bc_ptrs[level]++;
4754 if (cur->bc_bufs[0] == NULL) {
4755 for (i = 0; i < cur->bc_nlevels; i++) {
4756 if (cur->bc_bufs[i]) {
4757 xfs_trans_brelse(cur->bc_tp, cur->bc_bufs[i]);
4758 cur->bc_bufs[i] = NULL;
4759 cur->bc_ptrs[i] = 0;
4760 cur->bc_ra[i] = 0;
4776 struct xfs_btree_cur *cur,
4787 cur->bc_rec = *high_rec;
4788 cur->bc_ops->init_rec_from_cur(cur, &rec);
4789 cur->bc_ops->init_key_from_rec(&high_key, &rec);
4791 cur->bc_rec = *low_rec;
4792 cur->bc_ops->init_rec_from_cur(cur, &rec);
4793 cur->bc_ops->init_key_from_rec(&low_key, &rec);
4796 if (cur->bc_ops->diff_two_keys(cur, &low_key, &high_key) > 0)
4799 if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
4800 return xfs_btree_simple_query_range(cur, &low_key,
4802 return xfs_btree_overlapped_query_range(cur, &low_key, &high_key,
4809 struct xfs_btree_cur *cur,
4816 memset(&cur->bc_rec, 0, sizeof(cur->bc_rec));
4820 return xfs_btree_simple_query_range(cur, &low_key, &high_key, fn, priv);
4848 struct xfs_btree_cur *cur,
4861 struct xfs_btree_cur *cur,
4865 return xfs_btree_visit_blocks(cur, xfs_btree_count_blocks_helper,
4872 struct xfs_btree_cur *cur,
4876 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
4884 struct xfs_btree_cur *cur,
4894 struct xfs_btree_cur *cur,
4901 error = xfs_btree_query_range(cur, low, high,
4914 struct xfs_btree_cur *cur)
4919 block = xfs_btree_get_block(cur, 0, &bp);
4922 if (cur->bc_ptrs[0] < xfs_btree_get_numrecs(block))
4926 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)