Lines Matching refs:cur
54 struct xfs_btree_cur *cur, /* btree cursor */
62 mp = cur->bc_mp;
64 be32_to_cpu(block->bb_magic) == xfs_magics[cur->bc_btnum] &&
67 cur->bc_ops->get_maxrecs(cur, level) &&
90 struct xfs_btree_cur *cur, /* btree cursor */
100 agbp = cur->bc_private.a.agbp;
104 be32_to_cpu(block->bb_magic) == xfs_magics[cur->bc_btnum] &&
107 cur->bc_ops->get_maxrecs(cur, level) &&
114 if (unlikely(XFS_TEST_ERROR(!sblock_ok, cur->bc_mp,
120 XFS_ERRLEVEL_LOW, cur->bc_mp, block);
131 struct xfs_btree_cur *cur, /* btree cursor */
136 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
137 return xfs_btree_check_lblock(cur, block, level, bp);
139 return xfs_btree_check_sblock(cur, block, level, bp);
147 struct xfs_btree_cur *cur, /* btree cursor */
154 XFS_FSB_SANITY_CHECK(cur->bc_mp, bno));
164 struct xfs_btree_cur *cur, /* btree cursor */
168 xfs_agblock_t agblocks = cur->bc_mp->m_sb.sb_agblocks;
183 struct xfs_btree_cur *cur, /* btree cursor */
188 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
189 return xfs_btree_check_lptr(cur,
192 return xfs_btree_check_sptr(cur,
203 xfs_btree_cur_t *cur, /* btree cursor */
218 for (i = 0; i < cur->bc_nlevels; i++) {
219 if (cur->bc_bufs[i])
220 xfs_btree_setbuf(cur, i, NULL);
228 ASSERT(cur->bc_btnum != XFS_BTNUM_BMAP ||
229 cur->bc_private.b.allocated == 0);
233 kmem_zone_free(xfs_btree_cur_zone, cur);
242 xfs_btree_cur_t *cur, /* input cursor */
252 tp = cur->bc_tp;
253 mp = cur->bc_mp;
258 new = cur->bc_ops->dup_cursor(cur);
263 new->bc_rec = cur->bc_rec;
269 new->bc_ptrs[i] = cur->bc_ptrs[i];
270 new->bc_ra[i] = cur->bc_ra[i];
271 if ((bp = cur->bc_bufs[i])) {
321 static inline size_t xfs_btree_block_len(struct xfs_btree_cur *cur)
323 return (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
331 static inline size_t xfs_btree_ptr_len(struct xfs_btree_cur *cur)
333 return (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
342 struct xfs_btree_cur *cur,
345 return xfs_btree_block_len(cur) +
346 (n - 1) * cur->bc_ops->rec_len;
354 struct xfs_btree_cur *cur,
357 return xfs_btree_block_len(cur) +
358 (n - 1) * cur->bc_ops->key_len;
366 struct xfs_btree_cur *cur,
370 return xfs_btree_block_len(cur) +
371 cur->bc_ops->get_maxrecs(cur, level) * cur->bc_ops->key_len +
372 (n - 1) * xfs_btree_ptr_len(cur);
380 struct xfs_btree_cur *cur,
385 ((char *)block + xfs_btree_rec_offset(cur, n));
393 struct xfs_btree_cur *cur,
398 ((char *)block + xfs_btree_key_offset(cur, n));
406 struct xfs_btree_cur *cur,
415 ((char *)block + xfs_btree_ptr_offset(cur, n, level));
426 struct xfs_btree_cur *cur)
430 ifp = XFS_IFORK_PTR(cur->bc_private.b.ip, cur->bc_private.b.whichfork);
440 struct xfs_btree_cur *cur, /* btree cursor */
444 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
445 (level == cur->bc_nlevels - 1)) {
447 return xfs_btree_get_iroot(cur);
450 *bpp = cur->bc_bufs[level];
505 xfs_btree_cur_t *cur, /* btree cursor */
511 block = xfs_btree_get_block(cur, level, &bp);
512 xfs_btree_check_block(cur, block, level, bp);
513 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
525 xfs_btree_cur_t *cur, /* btree cursor */
534 block = xfs_btree_get_block(cur, level, &bp);
535 xfs_btree_check_block(cur, block, level, bp);
544 cur->bc_ptrs[level] = 1;
554 xfs_btree_cur_t *cur, /* btree cursor */
563 block = xfs_btree_get_block(cur, level, &bp);
564 xfs_btree_check_block(cur, block, level, bp);
573 cur->bc_ptrs[level] = be16_to_cpu(block->bb_numrecs);
684 struct xfs_btree_cur *cur,
693 xfs_btree_reada_bufl(cur->bc_mp, left, 1);
698 xfs_btree_reada_bufl(cur->bc_mp, right, 1);
707 struct xfs_btree_cur *cur,
717 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
723 xfs_btree_reada_bufs(cur->bc_mp, cur->bc_private.a.agno,
737 struct xfs_btree_cur *cur, /* btree cursor */
747 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
748 (lev == cur->bc_nlevels - 1))
751 if ((cur->bc_ra[lev] | lr) == cur->bc_ra[lev])
754 cur->bc_ra[lev] |= lr;
755 block = XFS_BUF_TO_BLOCK(cur->bc_bufs[lev]);
757 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
758 return xfs_btree_readahead_lblock(cur, lr, block);
759 return xfs_btree_readahead_sblock(cur, lr, block);
768 xfs_btree_cur_t *cur, /* btree cursor */
775 obp = cur->bc_bufs[lev];
777 xfs_trans_brelse(cur->bc_tp, obp);
778 cur->bc_bufs[lev] = bp;
779 cur->bc_ra[lev] = 0;
783 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
785 cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
787 cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
790 cur->bc_ra[lev] |= XFS_BTCUR_LEFTRA;
792 cur->bc_ra[lev] |= XFS_BTCUR_RIGHTRA;
798 struct xfs_btree_cur *cur,
801 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
809 struct xfs_btree_cur *cur,
812 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
823 struct xfs_btree_cur *cur,
830 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
845 struct xfs_btree_cur *cur,
852 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
867 struct xfs_btree_cur *cur,
872 new->bb_magic = cpu_to_be32(xfs_magics[cur->bc_btnum]);
876 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
892 struct xfs_btree_cur *cur,
900 if (!(cur->bc_flags & XFS_BTREE_LASTREC_UPDATE))
903 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
904 if (!xfs_btree_ptr_is_null(cur, &ptr))
911 struct xfs_btree_cur *cur,
915 if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
916 ptr->l = cpu_to_be64(XFS_DADDR_TO_FSB(cur->bc_mp,
919 ptr->s = cpu_to_be32(xfs_daddr_to_agbno(cur->bc_mp,
926 struct xfs_btree_cur *cur,
929 if (cur->bc_flags & XFS_BTREE_LONG_PTRS) {
932 return XFS_FSB_TO_DADDR(cur->bc_mp, be64_to_cpu(ptr->l));
934 ASSERT(cur->bc_private.a.agno != NULLAGNUMBER);
937 return XFS_AGB_TO_DADDR(cur->bc_mp, cur->bc_private.a.agno,
944 struct xfs_btree_cur *cur,
947 switch (cur->bc_btnum) {
965 struct xfs_btree_cur *cur,
971 struct xfs_mount *mp = cur->bc_mp;
977 d = xfs_btree_ptr_to_daddr(cur, ptr);
978 *bpp = xfs_trans_get_buf(cur->bc_tp, mp->m_ddev_targp, d,
994 struct xfs_btree_cur *cur,
1001 struct xfs_mount *mp = cur->bc_mp;
1008 d = xfs_btree_ptr_to_daddr(cur, ptr);
1009 error = xfs_trans_read_buf(mp, cur->bc_tp, mp->m_ddev_targp, d,
1017 xfs_btree_set_refs(cur, *bpp);
1020 error = xfs_btree_check_block(cur, *block, level, *bpp);
1022 xfs_trans_brelse(cur->bc_tp, *bpp);
1031 struct xfs_btree_cur *cur,
1037 memcpy(dst_key, src_key, numkeys * cur->bc_ops->key_len);
1045 struct xfs_btree_cur *cur,
1051 memcpy(dst_rec, src_rec, numrecs * cur->bc_ops->rec_len);
1059 struct xfs_btree_cur *cur,
1065 memcpy(dst_ptr, src_ptr, numptrs * xfs_btree_ptr_len(cur));
1073 struct xfs_btree_cur *cur,
1083 dst_key = (char *)key + (dir * cur->bc_ops->key_len);
1084 memmove(dst_key, key, numkeys * cur->bc_ops->key_len);
1092 struct xfs_btree_cur *cur,
1102 dst_rec = (char *)rec + (dir * cur->bc_ops->rec_len);
1103 memmove(dst_rec, rec, numrecs * cur->bc_ops->rec_len);
1111 struct xfs_btree_cur *cur,
1121 dst_ptr = (char *)ptr + (dir * xfs_btree_ptr_len(cur));
1122 memmove(dst_ptr, ptr, numptrs * xfs_btree_ptr_len(cur));
1130 struct xfs_btree_cur *cur,
1135 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1136 XFS_BTREE_TRACE_ARGBII(cur, bp, first, last);
1139 xfs_trans_log_buf(cur->bc_tp, bp,
1140 xfs_btree_key_offset(cur, first),
1141 xfs_btree_key_offset(cur, last + 1) - 1);
1143 xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
1144 xfs_ilog_fbroot(cur->bc_private.b.whichfork));
1147 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1155 struct xfs_btree_cur *cur,
1160 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1161 XFS_BTREE_TRACE_ARGBII(cur, bp, first, last);
1163 xfs_trans_log_buf(cur->bc_tp, bp,
1164 xfs_btree_rec_offset(cur, first),
1165 xfs_btree_rec_offset(cur, last + 1) - 1);
1167 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1175 struct xfs_btree_cur *cur, /* btree cursor */
1180 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1181 XFS_BTREE_TRACE_ARGBII(cur, bp, first, last);
1187 xfs_trans_log_buf(cur->bc_tp, bp,
1188 xfs_btree_ptr_offset(cur, first, level),
1189 xfs_btree_ptr_offset(cur, last + 1, level) - 1);
1191 xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
1192 xfs_ilog_fbroot(cur->bc_private.b.whichfork));
1195 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1203 struct xfs_btree_cur *cur, /* btree cursor */
1226 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1227 XFS_BTREE_TRACE_ARGBI(cur, bp, fields);
1231 (cur->bc_flags & XFS_BTREE_LONG_PTRS) ?
1234 xfs_trans_log_buf(cur->bc_tp, bp, first, last);
1236 xfs_trans_log_inode(cur->bc_tp, cur->bc_private.b.ip,
1237 xfs_ilog_fbroot(cur->bc_private.b.whichfork));
1240 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1249 struct xfs_btree_cur *cur,
1259 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1260 XFS_BTREE_TRACE_ARGI(cur, level);
1262 ASSERT(level < cur->bc_nlevels);
1265 xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
1268 block = xfs_btree_get_block(cur, level, &bp);
1271 error = xfs_btree_check_block(cur, block, level, bp);
1277 if (++cur->bc_ptrs[level] <= xfs_btree_get_numrecs(block))
1281 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1282 if (xfs_btree_ptr_is_null(cur, &ptr))
1285 XFS_BTREE_STATS_INC(cur, increment);
1291 for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
1292 block = xfs_btree_get_block(cur, lev, &bp);
1295 error = xfs_btree_check_block(cur, block, lev, bp);
1300 if (++cur->bc_ptrs[lev] <= xfs_btree_get_numrecs(block))
1304 xfs_btree_readahead(cur, lev, XFS_BTCUR_RIGHTRA);
1311 if (lev == cur->bc_nlevels) {
1312 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
1318 ASSERT(lev < cur->bc_nlevels);
1324 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
1327 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
1328 error = xfs_btree_read_buf_block(cur, ptrp, --lev,
1333 xfs_btree_setbuf(cur, lev, bp);
1334 cur->bc_ptrs[lev] = 1;
1337 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1342 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1347 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
1357 struct xfs_btree_cur *cur,
1367 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1368 XFS_BTREE_TRACE_ARGI(cur, level);
1370 ASSERT(level < cur->bc_nlevels);
1373 xfs_btree_readahead(cur, level, XFS_BTCUR_LEFTRA);
1376 if (--cur->bc_ptrs[level] > 0)
1380 block = xfs_btree_get_block(cur, level, &bp);
1383 error = xfs_btree_check_block(cur, block, level, bp);
1389 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
1390 if (xfs_btree_ptr_is_null(cur, &ptr))
1393 XFS_BTREE_STATS_INC(cur, decrement);
1399 for (lev = level + 1; lev < cur->bc_nlevels; lev++) {
1400 if (--cur->bc_ptrs[lev] > 0)
1403 xfs_btree_readahead(cur, lev, XFS_BTCUR_LEFTRA);
1410 if (lev == cur->bc_nlevels) {
1411 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE)
1417 ASSERT(lev < cur->bc_nlevels);
1423 for (block = xfs_btree_get_block(cur, lev, &bp); lev > level; ) {
1426 ptrp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[lev], block);
1427 error = xfs_btree_read_buf_block(cur, ptrp, --lev,
1431 xfs_btree_setbuf(cur, lev, bp);
1432 cur->bc_ptrs[lev] = xfs_btree_get_numrecs(block);
1435 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1440 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1445 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
1451 struct xfs_btree_cur *cur, /* btree cursor */
1460 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
1461 (level == cur->bc_nlevels - 1)) {
1462 *blkp = xfs_btree_get_iroot(cur);
1472 bp = cur->bc_bufs[level];
1473 if (bp && XFS_BUF_ADDR(bp) == xfs_btree_ptr_to_daddr(cur, pp)) {
1478 error = xfs_btree_read_buf_block(cur, pp, level, 0, blkp, &bp);
1482 xfs_btree_setbuf(cur, level, bp);
1493 struct xfs_btree_cur *cur,
1500 cur->bc_ops->init_key_from_rec(kp,
1501 xfs_btree_rec_addr(cur, keyno, block));
1505 return xfs_btree_key_addr(cur, keyno, block);
1514 struct xfs_btree_cur *cur, /* btree cursor */
1526 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1527 XFS_BTREE_TRACE_ARGI(cur, dir);
1529 XFS_BTREE_STATS_INC(cur, lookup);
1535 cur->bc_ops->init_ptr_from_cur(cur, &ptr);
1544 for (level = cur->bc_nlevels - 1, diff = 1; level >= 0; level--) {
1546 error = xfs_btree_lookup_get_block(cur, level, pp, &block);
1567 ASSERT(level == 0 && cur->bc_nlevels == 1);
1569 cur->bc_ptrs[0] = dir != XFS_LOOKUP_LE;
1570 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1580 XFS_BTREE_STATS_INC(cur, compare);
1586 kp = xfs_lookup_get_search_key(cur, level,
1595 diff = cur->bc_ops->key_diff(cur, kp);
1616 pp = xfs_btree_ptr_addr(cur, keyno, block);
1619 error = xfs_btree_check_ptr(cur, pp, 0, level);
1623 cur->bc_ptrs[level] = keyno;
1634 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
1637 !xfs_btree_ptr_is_null(cur, &ptr)) {
1640 cur->bc_ptrs[0] = keyno;
1641 error = xfs_btree_increment(cur, 0, &i);
1645 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1651 cur->bc_ptrs[0] = keyno;
1660 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1664 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
1673 struct xfs_btree_cur *cur,
1682 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1683 XFS_BTREE_TRACE_ARGIK(cur, level, keyp);
1685 ASSERT(!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) || level >= 1);
1693 for (ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
1697 block = xfs_btree_get_block(cur, level, &bp);
1699 error = xfs_btree_check_block(cur, block, level, bp);
1701 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
1705 ptr = cur->bc_ptrs[level];
1706 kp = xfs_btree_key_addr(cur, ptr, block);
1707 xfs_btree_copy_keys(cur, kp, keyp, 1);
1708 xfs_btree_log_keys(cur, bp, ptr, ptr);
1711 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1716 * Update the record referred to by cur to the value in the
1722 struct xfs_btree_cur *cur,
1731 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1732 XFS_BTREE_TRACE_ARGR(cur, rec);
1735 block = xfs_btree_get_block(cur, 0, &bp);
1738 error = xfs_btree_check_block(cur, block, 0, bp);
1743 ptr = cur->bc_ptrs[0];
1744 rp = xfs_btree_rec_addr(cur, ptr, block);
1747 xfs_btree_copy_recs(cur, rp, rec, 1);
1748 xfs_btree_log_recs(cur, bp, ptr, ptr);
1754 if (xfs_btree_is_lastrec(cur, block, 0)) {
1755 cur->bc_ops->update_lastrec(cur, block, rec,
1763 cur->bc_ops->init_key_from_rec(&key, rec);
1764 error = xfs_btree_updkey(cur, &key, 1);
1769 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1773 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
1778 * Move 1 record left from cur/level if possible.
1779 * Update cur to reflect the new path.
1783 struct xfs_btree_cur *cur,
1800 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1801 XFS_BTREE_TRACE_ARGI(cur, level);
1803 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
1804 level == cur->bc_nlevels - 1)
1808 right = xfs_btree_get_block(cur, level, &rbp);
1811 error = xfs_btree_check_block(cur, right, level, rbp);
1817 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
1818 if (xfs_btree_ptr_is_null(cur, &lptr))
1825 if (cur->bc_ptrs[level] <= 1)
1829 error = xfs_btree_read_buf_block(cur, &lptr, level, 0, &left, &lbp);
1835 if (lrecs == cur->bc_ops->get_maxrecs(cur, level))
1848 XFS_BTREE_STATS_INC(cur, lshift);
1849 XFS_BTREE_STATS_ADD(cur, moves, 1);
1860 lkp = xfs_btree_key_addr(cur, lrecs, left);
1861 rkp = xfs_btree_key_addr(cur, 1, right);
1863 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
1864 rpp = xfs_btree_ptr_addr(cur, 1, right);
1866 error = xfs_btree_check_ptr(cur, rpp, 0, level);
1870 xfs_btree_copy_keys(cur, lkp, rkp, 1);
1871 xfs_btree_copy_ptrs(cur, lpp, rpp, 1);
1873 xfs_btree_log_keys(cur, lbp, lrecs, lrecs);
1874 xfs_btree_log_ptrs(cur, lbp, lrecs, lrecs);
1876 ASSERT(cur->bc_ops->keys_inorder(cur,
1877 xfs_btree_key_addr(cur, lrecs - 1, left), lkp));
1882 lrp = xfs_btree_rec_addr(cur, lrecs, left);
1883 rrp = xfs_btree_rec_addr(cur, 1, right);
1885 xfs_btree_copy_recs(cur, lrp, rrp, 1);
1886 xfs_btree_log_recs(cur, lbp, lrecs, lrecs);
1888 ASSERT(cur->bc_ops->recs_inorder(cur,
1889 xfs_btree_rec_addr(cur, lrecs - 1, left), lrp));
1893 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
1896 xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
1901 XFS_BTREE_STATS_ADD(cur, moves, rrecs - 1);
1908 error = xfs_btree_check_ptr(cur, rpp, i + 1, level);
1913 xfs_btree_shift_keys(cur,
1914 xfs_btree_key_addr(cur, 2, right),
1916 xfs_btree_shift_ptrs(cur,
1917 xfs_btree_ptr_addr(cur, 2, right),
1920 xfs_btree_log_keys(cur, rbp, 1, rrecs);
1921 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
1924 xfs_btree_shift_recs(cur,
1925 xfs_btree_rec_addr(cur, 2, right),
1927 xfs_btree_log_recs(cur, rbp, 1, rrecs);
1933 cur->bc_ops->init_key_from_rec(&key,
1934 xfs_btree_rec_addr(cur, 1, right));
1939 error = xfs_btree_updkey(cur, rkp, level + 1);
1944 cur->bc_ptrs[level]--;
1946 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1951 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
1956 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
1961 * Move 1 record right from cur/level if possible.
1962 * Update cur to reflect the new path.
1966 struct xfs_btree_cur *cur,
1983 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
1984 XFS_BTREE_TRACE_ARGI(cur, level);
1986 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
1987 (level == cur->bc_nlevels - 1))
1991 left = xfs_btree_get_block(cur, level, &lbp);
1994 error = xfs_btree_check_block(cur, left, level, lbp);
2000 xfs_btree_get_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2001 if (xfs_btree_ptr_is_null(cur, &rptr))
2009 if (cur->bc_ptrs[level] >= lrecs)
2013 error = xfs_btree_read_buf_block(cur, &rptr, level, 0, &right, &rbp);
2019 if (rrecs == cur->bc_ops->get_maxrecs(cur, level))
2022 XFS_BTREE_STATS_INC(cur, rshift);
2023 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
2035 lkp = xfs_btree_key_addr(cur, lrecs, left);
2036 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2037 rkp = xfs_btree_key_addr(cur, 1, right);
2038 rpp = xfs_btree_ptr_addr(cur, 1, right);
2042 error = xfs_btree_check_ptr(cur, rpp, i, level);
2048 xfs_btree_shift_keys(cur, rkp, 1, rrecs);
2049 xfs_btree_shift_ptrs(cur, rpp, 1, rrecs);
2052 error = xfs_btree_check_ptr(cur, lpp, 0, level);
2058 xfs_btree_copy_keys(cur, rkp, lkp, 1);
2059 xfs_btree_copy_ptrs(cur, rpp, lpp, 1);
2061 xfs_btree_log_keys(cur, rbp, 1, rrecs + 1);
2062 xfs_btree_log_ptrs(cur, rbp, 1, rrecs + 1);
2064 ASSERT(cur->bc_ops->keys_inorder(cur, rkp,
2065 xfs_btree_key_addr(cur, 2, right)));
2071 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2072 rrp = xfs_btree_rec_addr(cur, 1, right);
2074 xfs_btree_shift_recs(cur, rrp, 1, rrecs);
2077 xfs_btree_copy_recs(cur, rrp, lrp, 1);
2078 xfs_btree_log_recs(cur, rbp, 1, rrecs + 1);
2080 cur->bc_ops->init_key_from_rec(&key, rrp);
2083 ASSERT(cur->bc_ops->recs_inorder(cur, rrp,
2084 xfs_btree_rec_addr(cur, 2, right)));
2091 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS);
2094 xfs_btree_log_block(cur, rbp, XFS_BB_NUMRECS);
2100 error = xfs_btree_dup_cursor(cur, &tcur);
2116 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2121 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2126 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2136 * Split cur/level block in half.
2142 struct xfs_btree_cur *cur,
2166 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
2167 XFS_BTREE_TRACE_ARGIPK(cur, level, *ptrp, key);
2169 XFS_BTREE_STATS_INC(cur, split);
2172 left = xfs_btree_get_block(cur, level, &lbp);
2175 error = xfs_btree_check_block(cur, left, level, lbp);
2180 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
2183 error = cur->bc_ops->alloc_block(cur, &lptr, &rptr, 1, stat);
2188 XFS_BTREE_STATS_INC(cur, alloc);
2191 error = xfs_btree_get_buf_block(cur, &rptr, 0, &right, &rbp);
2196 xfs_btree_init_block(cur, xfs_btree_get_level(left), 0, right);
2205 if ((lrecs & 1) && cur->bc_ptrs[level] <= rrecs + 1)
2209 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
2223 lkp = xfs_btree_key_addr(cur, src_index, left);
2224 lpp = xfs_btree_ptr_addr(cur, src_index, left);
2225 rkp = xfs_btree_key_addr(cur, 1, right);
2226 rpp = xfs_btree_ptr_addr(cur, 1, right);
2230 error = xfs_btree_check_ptr(cur, lpp, i, level);
2236 xfs_btree_copy_keys(cur, rkp, lkp, rrecs);
2237 xfs_btree_copy_ptrs(cur, rpp, lpp, rrecs);
2239 xfs_btree_log_keys(cur, rbp, 1, rrecs);
2240 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
2243 xfs_btree_copy_keys(cur, key, rkp, 1);
2249 lrp = xfs_btree_rec_addr(cur, src_index, left);
2250 rrp = xfs_btree_rec_addr(cur, 1, right);
2252 xfs_btree_copy_recs(cur, rrp, lrp, rrecs);
2253 xfs_btree_log_recs(cur, rbp, 1, rrecs);
2255 cur->bc_ops->init_key_from_rec(key,
2256 xfs_btree_rec_addr(cur, 1, right));
2264 xfs_btree_get_sibling(cur, left, &rrptr, XFS_BB_RIGHTSIB);
2265 xfs_btree_set_sibling(cur, right, &rrptr, XFS_BB_RIGHTSIB);
2266 xfs_btree_set_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
2267 xfs_btree_set_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2273 xfs_btree_log_block(cur, rbp, XFS_BB_ALL_BITS);
2274 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
2280 if (!xfs_btree_ptr_is_null(cur, &rrptr)) {
2281 error = xfs_btree_read_buf_block(cur, &rrptr, level,
2285 xfs_btree_set_sibling(cur, rrblock, &rptr, XFS_BB_LEFTSIB);
2286 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
2293 if (cur->bc_ptrs[level] > lrecs + 1) {
2294 xfs_btree_setbuf(cur, level, rbp);
2295 cur->bc_ptrs[level] -= lrecs;
2301 if (level + 1 < cur->bc_nlevels) {
2302 error = xfs_btree_dup_cursor(cur, curp);
2308 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2312 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2317 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2327 struct xfs_btree_cur *cur, /* btree cursor */
2345 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
2346 XFS_BTREE_STATS_INC(cur, newroot);
2348 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
2350 level = cur->bc_nlevels - 1;
2352 block = xfs_btree_get_iroot(cur);
2353 pp = xfs_btree_ptr_addr(cur, 1, block);
2356 error = cur->bc_ops->alloc_block(cur, pp, &nptr, 1, stat);
2360 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2363 XFS_BTREE_STATS_INC(cur, alloc);
2366 error = xfs_btree_get_buf_block(cur, &nptr, 0, &cblock, &cbp);
2370 memcpy(cblock, block, xfs_btree_block_len(cur));
2374 cur->bc_nlevels++;
2375 cur->bc_ptrs[level + 1] = 1;
2377 kp = xfs_btree_key_addr(cur, 1, block);
2378 ckp = xfs_btree_key_addr(cur, 1, cblock);
2379 xfs_btree_copy_keys(cur, ckp, kp, xfs_btree_get_numrecs(cblock));
2381 cpp = xfs_btree_ptr_addr(cur, 1, cblock);
2384 error = xfs_btree_check_ptr(cur, pp, i, level);
2389 xfs_btree_copy_ptrs(cur, cpp, pp, xfs_btree_get_numrecs(cblock));
2392 error = xfs_btree_check_ptr(cur, &nptr, 0, level);
2396 xfs_btree_copy_ptrs(cur, pp, &nptr, 1);
2398 xfs_iroot_realloc(cur->bc_private.b.ip,
2400 cur->bc_private.b.whichfork);
2402 xfs_btree_setbuf(cur, level, cbp);
2408 xfs_btree_log_block(cur, cbp, XFS_BB_ALL_BITS);
2409 xfs_btree_log_keys(cur, cbp, 1, be16_to_cpu(cblock->bb_numrecs));
2410 xfs_btree_log_ptrs(cur, cbp, 1, be16_to_cpu(cblock->bb_numrecs));
2413 XFS_ILOG_CORE | xfs_ilog_fbroot(cur->bc_private.b.whichfork);
2415 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2418 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2427 struct xfs_btree_cur *cur, /* btree cursor */
2443 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
2444 XFS_BTREE_STATS_INC(cur, newroot);
2447 cur->bc_ops->init_ptr_from_cur(cur, &rptr);
2450 error = cur->bc_ops->alloc_block(cur, &rptr, &lptr, 1, stat);
2455 XFS_BTREE_STATS_INC(cur, alloc);
2458 error = xfs_btree_get_buf_block(cur, &lptr, 0, &new, &nbp);
2463 cur->bc_ops->set_root(cur, &lptr, 1);
2471 block = xfs_btree_get_block(cur, cur->bc_nlevels - 1, &bp);
2474 error = xfs_btree_check_block(cur, block, cur->bc_nlevels - 1, bp);
2479 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
2480 if (!xfs_btree_ptr_is_null(cur, &rptr)) {
2483 xfs_btree_buf_to_ptr(cur, lbp, &lptr);
2485 error = xfs_btree_read_buf_block(cur, &rptr,
2486 cur->bc_nlevels - 1, 0, &right, &rbp);
2494 xfs_btree_buf_to_ptr(cur, rbp, &rptr);
2496 xfs_btree_get_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
2497 error = xfs_btree_read_buf_block(cur, &lptr,
2498 cur->bc_nlevels - 1, 0, &left, &lbp);
2505 xfs_btree_init_block(cur, cur->bc_nlevels, 2, new);
2506 xfs_btree_log_block(cur, nbp, XFS_BB_ALL_BITS);
2507 ASSERT(!xfs_btree_ptr_is_null(cur, &lptr) &&
2508 !xfs_btree_ptr_is_null(cur, &rptr));
2512 xfs_btree_copy_keys(cur,
2513 xfs_btree_key_addr(cur, 1, new),
2514 xfs_btree_key_addr(cur, 1, left), 1);
2515 xfs_btree_copy_keys(cur,
2516 xfs_btree_key_addr(cur, 2, new),
2517 xfs_btree_key_addr(cur, 1, right), 1);
2519 cur->bc_ops->init_key_from_rec(
2520 xfs_btree_key_addr(cur, 1, new),
2521 xfs_btree_rec_addr(cur, 1, left));
2522 cur->bc_ops->init_key_from_rec(
2523 xfs_btree_key_addr(cur, 2, new),
2524 xfs_btree_rec_addr(cur, 1, right));
2526 xfs_btree_log_keys(cur, nbp, 1, 2);
2529 xfs_btree_copy_ptrs(cur,
2530 xfs_btree_ptr_addr(cur, 1, new), &lptr, 1);
2531 xfs_btree_copy_ptrs(cur,
2532 xfs_btree_ptr_addr(cur, 2, new), &rptr, 1);
2533 xfs_btree_log_ptrs(cur, nbp, 1, 2);
2536 xfs_btree_setbuf(cur, cur->bc_nlevels, nbp);
2537 cur->bc_ptrs[cur->bc_nlevels] = nptr;
2538 cur->bc_nlevels++;
2539 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2543 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2546 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2553 struct xfs_btree_cur *cur, /* btree cursor */
2566 if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
2567 level == cur->bc_nlevels - 1) {
2568 struct xfs_inode *ip = cur->bc_private.b.ip;
2570 if (numrecs < cur->bc_ops->get_dmaxrecs(cur, level)) {
2573 xfs_iroot_realloc(ip, 1, cur->bc_private.b.whichfork);
2578 error = xfs_btree_new_iroot(cur, &logflags, stat);
2582 xfs_trans_log_inode(cur->bc_tp, ip, logflags);
2589 error = xfs_btree_rshift(cur, level, stat);
2594 error = xfs_btree_lshift(cur, level, stat);
2599 *oindex = *index = cur->bc_ptrs[level];
2609 error = xfs_btree_split(cur, level, nptr, &key, ncur, stat);
2614 *index = cur->bc_ptrs[level];
2615 cur->bc_ops->init_rec_from_key(&key, nrec);
2625 struct xfs_btree_cur *cur, /* btree cursor */
2629 struct xfs_btree_cur **curp, /* output: new cursor replacing cur */
2646 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
2647 XFS_BTREE_TRACE_ARGIPR(cur, level, *ptrp, recp);
2655 if (!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
2656 (level >= cur->bc_nlevels)) {
2657 error = xfs_btree_new_root(cur, stat);
2658 xfs_btree_set_ptr_null(cur, ptrp);
2660 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2665 ptr = cur->bc_ptrs[level];
2667 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2673 cur->bc_ops->init_key_from_rec(&key, recp);
2677 XFS_BTREE_STATS_INC(cur, insrec);
2680 block = xfs_btree_get_block(cur, level, &bp);
2684 error = xfs_btree_check_block(cur, block, level, bp);
2691 ASSERT(cur->bc_ops->recs_inorder(cur, recp,
2692 xfs_btree_rec_addr(cur, ptr, block)));
2694 ASSERT(cur->bc_ops->keys_inorder(cur, &key,
2695 xfs_btree_key_addr(cur, ptr, block)));
2704 xfs_btree_set_ptr_null(cur, &nptr);
2705 if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
2706 error = xfs_btree_make_block_unfull(cur, level, numrecs,
2716 block = xfs_btree_get_block(cur, level, &bp);
2720 error = xfs_btree_check_block(cur, block, level, bp);
2729 XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr + 1);
2736 kp = xfs_btree_key_addr(cur, ptr, block);
2737 pp = xfs_btree_ptr_addr(cur, ptr, block);
2741 error = xfs_btree_check_ptr(cur, pp, i, level);
2747 xfs_btree_shift_keys(cur, kp, 1, numrecs - ptr + 1);
2748 xfs_btree_shift_ptrs(cur, pp, 1, numrecs - ptr + 1);
2751 error = xfs_btree_check_ptr(cur, ptrp, 0, level);
2757 xfs_btree_copy_keys(cur, kp, &key, 1);
2758 xfs_btree_copy_ptrs(cur, pp, ptrp, 1);
2761 xfs_btree_log_ptrs(cur, bp, ptr, numrecs);
2762 xfs_btree_log_keys(cur, bp, ptr, numrecs);
2765 ASSERT(cur->bc_ops->keys_inorder(cur, kp,
2766 xfs_btree_key_addr(cur, ptr + 1, block)));
2773 rp = xfs_btree_rec_addr(cur, ptr, block);
2775 xfs_btree_shift_recs(cur, rp, 1, numrecs - ptr + 1);
2778 xfs_btree_copy_recs(cur, rp, recp, 1);
2780 xfs_btree_log_recs(cur, bp, ptr, numrecs);
2783 ASSERT(cur->bc_ops->recs_inorder(cur, rp,
2784 xfs_btree_rec_addr(cur, ptr + 1, block)));
2790 xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
2794 error = xfs_btree_updkey(cur, &key, level + 1);
2803 if (xfs_btree_is_lastrec(cur, block, level)) {
2804 cur->bc_ops->update_lastrec(cur, block, recp,
2813 if (!xfs_btree_ptr_is_null(cur, &nptr)) {
2818 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2823 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2828 * Insert the record at the point referenced by cur.
2836 struct xfs_btree_cur *cur,
2849 pcur = cur;
2851 xfs_btree_set_ptr_null(cur, &nptr);
2852 cur->bc_ops->init_rec_from_cur(cur, &rec);
2866 if (pcur != cur)
2879 if (pcur != cur &&
2880 (ncur || xfs_btree_ptr_is_null(cur, &nptr))) {
2882 if (cur->bc_ops->update_cursor)
2883 cur->bc_ops->update_cursor(pcur, cur);
2884 cur->bc_nlevels = pcur->bc_nlevels;
2892 } while (!xfs_btree_ptr_is_null(cur, &nptr));
2894 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
2898 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2912 struct xfs_btree_cur *cur)
2914 int whichfork = cur->bc_private.b.whichfork;
2915 struct xfs_inode *ip = cur->bc_private.b.ip;
2932 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
2934 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
2935 ASSERT(cur->bc_nlevels > 1);
2941 level = cur->bc_nlevels - 1;
2948 block = xfs_btree_get_iroot(cur);
2952 cblock = xfs_btree_get_block(cur, level - 1, &cbp);
2960 if (numrecs > cur->bc_ops->get_dmaxrecs(cur, level))
2963 XFS_BTREE_STATS_INC(cur, killroot);
2966 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_LEFTSIB);
2967 ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
2968 xfs_btree_get_sibling(cur, block, &ptr, XFS_BB_RIGHTSIB);
2969 ASSERT(xfs_btree_ptr_is_null(cur, &ptr));
2972 index = numrecs - cur->bc_ops->get_maxrecs(cur, level);
2974 xfs_iroot_realloc(cur->bc_private.b.ip, index,
2975 cur->bc_private.b.whichfork);
2982 kp = xfs_btree_key_addr(cur, 1, block);
2983 ckp = xfs_btree_key_addr(cur, 1, cblock);
2984 xfs_btree_copy_keys(cur, kp, ckp, numrecs);
2986 pp = xfs_btree_ptr_addr(cur, 1, block);
2987 cpp = xfs_btree_ptr_addr(cur, 1, cblock);
2992 error = xfs_btree_check_ptr(cur, cpp, i, level - 1);
2994 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
2999 xfs_btree_copy_ptrs(cur, pp, cpp, numrecs);
3001 cur->bc_ops->free_block(cur, cbp);
3002 XFS_BTREE_STATS_INC(cur, free);
3004 cur->bc_bufs[level - 1] = NULL;
3006 xfs_trans_log_inode(cur->bc_tp, ip,
3007 XFS_ILOG_CORE | xfs_ilog_fbroot(cur->bc_private.b.whichfork));
3008 cur->bc_nlevels--;
3010 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3016 struct xfs_btree_cur *cur,
3024 error = xfs_btree_decrement(cur, level, &i);
3029 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3036 * Delete record pointed to by cur/level.
3042 struct xfs_btree_cur *cur, /* btree cursor */
3067 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
3068 XFS_BTREE_TRACE_ARGI(cur, level);
3073 ptr = cur->bc_ptrs[level];
3075 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3081 block = xfs_btree_get_block(cur, level, &bp);
3085 error = xfs_btree_check_block(cur, block, level, bp);
3092 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3097 XFS_BTREE_STATS_INC(cur, delrec);
3098 XFS_BTREE_STATS_ADD(cur, moves, numrecs - ptr);
3106 lkp = xfs_btree_key_addr(cur, ptr + 1, block);
3107 lpp = xfs_btree_ptr_addr(cur, ptr + 1, block);
3111 error = xfs_btree_check_ptr(cur, lpp, i, level);
3118 xfs_btree_shift_keys(cur, lkp, -1, numrecs - ptr);
3119 xfs_btree_shift_ptrs(cur, lpp, -1, numrecs - ptr);
3120 xfs_btree_log_keys(cur, bp, ptr, numrecs - 1);
3121 xfs_btree_log_ptrs(cur, bp, ptr, numrecs - 1);
3129 keyp = xfs_btree_key_addr(cur, 1, block);
3133 xfs_btree_shift_recs(cur,
3134 xfs_btree_rec_addr(cur, ptr + 1, block),
3136 xfs_btree_log_recs(cur, bp, ptr, numrecs - 1);
3144 cur->bc_ops->init_key_from_rec(&key,
3145 xfs_btree_rec_addr(cur, 1, block));
3154 xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
3160 if (xfs_btree_is_lastrec(cur, block, level)) {
3161 cur->bc_ops->update_lastrec(cur, block, NULL,
3170 if (level == cur->bc_nlevels - 1) {
3171 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
3172 xfs_iroot_realloc(cur->bc_private.b.ip, -1,
3173 cur->bc_private.b.whichfork);
3175 error = xfs_btree_kill_iroot(cur);
3179 error = xfs_btree_dec_cursor(cur, level, stat);
3197 pp = xfs_btree_ptr_addr(cur, 1, block);
3198 error = cur->bc_ops->kill_root(cur, bp, level, pp);
3202 error = xfs_btree_dec_cursor(cur, level, stat);
3215 error = xfs_btree_updkey(cur, keyp, level + 1);
3224 if (numrecs >= cur->bc_ops->get_minrecs(cur, level)) {
3225 error = xfs_btree_dec_cursor(cur, level, stat);
3236 xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
3237 xfs_btree_get_sibling(cur, block, &lptr, XFS_BB_LEFTSIB);
3239 if (cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) {
3245 if (xfs_btree_ptr_is_null(cur, &rptr) &&
3246 xfs_btree_ptr_is_null(cur, &lptr) &&
3247 level == cur->bc_nlevels - 2) {
3248 error = xfs_btree_kill_iroot(cur);
3250 error = xfs_btree_dec_cursor(cur, level, stat);
3257 ASSERT(!xfs_btree_ptr_is_null(cur, &rptr) ||
3258 !xfs_btree_ptr_is_null(cur, &lptr));
3264 error = xfs_btree_dup_cursor(cur, &tcur);
3272 if (!xfs_btree_ptr_is_null(cur, &rptr)) {
3304 cur->bc_ops->get_minrecs(tcur, level)) {
3310 cur->bc_ops->get_minrecs(tcur, level));
3315 error = xfs_btree_dec_cursor(cur, level, stat);
3328 if (!xfs_btree_ptr_is_null(cur, &lptr)) {
3343 if (!xfs_btree_ptr_is_null(cur, &lptr)) {
3360 error = xfs_btree_check_block(cur, left, level, lbp);
3373 cur->bc_ops->get_minrecs(tcur, level)) {
3379 cur->bc_ops->get_minrecs(tcur, level));
3383 cur->bc_ptrs[0]++;
3384 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3402 ASSERT(!xfs_btree_ptr_is_null(cur, &cptr));
3404 if (!xfs_btree_ptr_is_null(cur, &lptr) &&
3406 cur->bc_ops->get_maxrecs(cur, level)) {
3414 error = xfs_btree_read_buf_block(cur, &lptr, level,
3422 } else if (!xfs_btree_ptr_is_null(cur, &rptr) &&
3424 cur->bc_ops->get_maxrecs(cur, level)) {
3432 error = xfs_btree_read_buf_block(cur, &rptr, level,
3442 error = xfs_btree_dec_cursor(cur, level, stat);
3455 XFS_BTREE_STATS_ADD(cur, moves, rrecs);
3463 lkp = xfs_btree_key_addr(cur, lrecs + 1, left);
3464 lpp = xfs_btree_ptr_addr(cur, lrecs + 1, left);
3465 rkp = xfs_btree_key_addr(cur, 1, right);
3466 rpp = xfs_btree_ptr_addr(cur, 1, right);
3469 error = xfs_btree_check_ptr(cur, rpp, i, level);
3474 xfs_btree_copy_keys(cur, lkp, rkp, rrecs);
3475 xfs_btree_copy_ptrs(cur, lpp, rpp, rrecs);
3477 xfs_btree_log_keys(cur, lbp, lrecs + 1, lrecs + rrecs);
3478 xfs_btree_log_ptrs(cur, lbp, lrecs + 1, lrecs + rrecs);
3484 lrp = xfs_btree_rec_addr(cur, lrecs + 1, left);
3485 rrp = xfs_btree_rec_addr(cur, 1, right);
3487 xfs_btree_copy_recs(cur, lrp, rrp, rrecs);
3488 xfs_btree_log_recs(cur, lbp, lrecs + 1, lrecs + rrecs);
3491 XFS_BTREE_STATS_INC(cur, join);
3498 xfs_btree_get_sibling(cur, right, &cptr, XFS_BB_RIGHTSIB),
3499 xfs_btree_set_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
3500 xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
3503 xfs_btree_get_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
3504 if (!xfs_btree_ptr_is_null(cur, &cptr)) {
3505 error = xfs_btree_read_buf_block(cur, &cptr, level,
3509 xfs_btree_set_sibling(cur, rrblock, &lptr, XFS_BB_LEFTSIB);
3510 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
3514 error = cur->bc_ops->free_block(cur, rbp);
3517 XFS_BTREE_STATS_INC(cur, free);
3524 cur->bc_bufs[level] = lbp;
3525 cur->bc_ptrs[level] += lrecs;
3526 cur->bc_ra[level] = 0;
3532 else if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) ||
3533 (level + 1 < cur->bc_nlevels)) {
3534 error = xfs_btree_increment(cur, level + 1, &i);
3546 cur->bc_ptrs[level]--;
3548 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3554 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
3561 * Delete the record pointed to by cur.
3567 struct xfs_btree_cur *cur,
3574 XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
3583 error = xfs_btree_delrec(cur, level, &i);
3589 for (level = 1; level < cur->bc_nlevels; level++) {
3590 if (cur->bc_ptrs[level] == 0) {
3591 error = xfs_btree_decrement(cur, level, &i);
3599 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
3603 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
3612 struct xfs_btree_cur *cur, /* btree cursor */
3623 ptr = cur->bc_ptrs[0];
3624 block = xfs_btree_get_block(cur, 0, &bp);
3627 error = xfs_btree_check_block(cur, block, 0, bp);
3643 *recp = xfs_btree_rec_addr(cur, ptr, block);