Lines Matching refs:left
459 * The header is called struct xfs_btree_block for reasons better left unknown
509 * from that we can pick out record 1 as the appropriate left neighbor.
864 xfs_fsblock_t left = be64_to_cpu(block->bb_u.l.bb_leftsib);
867 if ((lr & XFS_BTCUR_LEFTRA) && left != NULLFSBLOCK) {
868 xfs_btree_reada_bufl(cur->bc_mp, left, 1,
889 xfs_agblock_t left = be32_to_cpu(block->bb_u.s.bb_leftsib);
893 if ((lr & XFS_BTCUR_LEFTRA) && left != NULLAGBLOCK) {
895 left, 1, cur->bc_ops->buf_ops);
916 int lr) /* left/right bits */
1333 * Shift keys one index left/right inside a single btree block.
1352 * Shift records one index left/right inside a single btree block.
1371 * Shift block pointers one index left/right inside a single btree block.
1643 /* Read-ahead to the left at this level. */
1659 /* Fail if we just went off the left edge of the tree. */
1668 * Stop when we don't go off the left edge of a block.
1673 /* Read-ahead the left block for the next loop. */
1892 * - greater than, move left
1911 * If we moved left, need the previous key number,
2241 * Move 1 record left from cur/level if possible.
2250 struct xfs_buf *lbp; /* left buffer pointer */
2251 struct xfs_btree_block *left; /* left btree block */
2252 int lrecs; /* left record count */
2257 union xfs_btree_ptr lptr; /* left btree pointer */
2277 /* If we've got no left sibling then we can't shift an entry left. */
2289 /* Set up the left neighbor as "left". */
2290 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
2295 lrecs = xfs_btree_get_numrecs(left);
2302 * We add one entry to the left side and remove one for the right side.
2313 * If non-leaf, copy a key and a ptr to the left block.
2314 * Log the changes to the left block.
2318 union xfs_btree_key *lkp; /* left btree key */
2319 union xfs_btree_ptr *lpp; /* left address pointer */
2321 lkp = xfs_btree_key_addr(cur, lrecs, left);
2324 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2338 xfs_btree_key_addr(cur, lrecs - 1, left), lkp));
2341 union xfs_btree_rec *lrp; /* left record pointer */
2343 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2350 xfs_btree_rec_addr(cur, lrecs - 1, left), lrp));
2353 xfs_btree_set_numrecs(left, lrecs);
2390 * block on the left.
2406 /* Update the parent high keys of the left block, if needed. */
2419 /* Slide the cursor value left one. */
2447 struct xfs_buf *lbp; /* left buffer pointer */
2448 struct xfs_btree_block *left; /* left btree block */
2455 int lrecs; /* left record count */
2463 /* Set up variables for this block as "left". */
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);
2481 lrecs = xfs_btree_get_numrecs(left);
2500 * copy the last left block entry to the hole.
2508 lkp = xfs_btree_key_addr(cur, lrecs, left);
2509 lpp = xfs_btree_ptr_addr(cur, lrecs, left);
2540 lrp = xfs_btree_rec_addr(cur, lrecs, left);
2551 * Decrement and log left's numrecs, bump and log right's numrecs.
2553 xfs_btree_set_numrecs(left, --lrecs);
2576 /* Update the parent high keys of the left block, if needed. */
2619 union xfs_btree_ptr lptr; /* left sibling block ptr */
2620 struct xfs_buf *lbp; /* left buffer pointer */
2621 struct xfs_btree_block *left; /* left btree block */
2636 /* Set up left block (current one). */
2637 left = xfs_btree_get_block(cur, level, &lbp);
2640 error = xfs_btree_check_block(cur, left, level, lbp);
2661 xfs_btree_init_block_cur(cur, rbp, xfs_btree_get_level(left), 0);
2668 lrecs = xfs_btree_get_numrecs(left);
2678 xfs_btree_set_numrecs(left, lrecs);
2682 * Copy btree block entries from the left block over to the
2688 union xfs_btree_key *lkp; /* left btree key */
2689 union xfs_btree_ptr *lpp; /* left address pointer */
2693 lkp = xfs_btree_key_addr(cur, src_index, left);
2694 lpp = xfs_btree_ptr_addr(cur, src_index, left);
2715 union xfs_btree_rec *lrp; /* left record pointer */
2718 lrp = xfs_btree_rec_addr(cur, src_index, left);
2730 * Find the left block number by looking in the buffer.
2733 xfs_btree_get_sibling(cur, left, &rrptr, XFS_BB_RIGHTSIB);
2736 xfs_btree_set_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
2743 * point back to right instead of to left.
2754 /* Update the parent high keys of the left block, if needed. */
2763 * If it's just pointing past the last entry in left, then we'll
2992 struct xfs_buf *lbp; /* left buffer pointer */
2993 struct xfs_btree_block *left; /* left btree block */
3026 * one the cursor is pointing at, so we set up variables "left" and
3039 /* Our block is left, pick up the right block. */
3042 left = block;
3049 /* Our block is right, pick up the left block. */
3054 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
3068 if (xfs_btree_get_level(left) > 0) {
3070 * Get the keys for the left block's keys and put them directly
3073 xfs_btree_get_node_keys(cur, left,
3079 * Get the keys for the left block's records and put them
3083 xfs_btree_get_leaf_keys(cur, left,
3151 /* Next, try shifting an entry to the left neighbor. */
3218 /* If we're off the left edge, return failure. */
3640 union xfs_btree_ptr lptr; /* left sibling block ptr */
3641 struct xfs_buf *lbp; /* left buffer pointer */
3642 struct xfs_btree_block *left; /* left btree block */
3643 int lrecs = 0; /* left record count */
3731 * nothing left to do.
3750 * If this is the root level, and there's only one entry left,
3796 * tree balanced. Look at the left and right sibling blocks to
3872 * won't make it too empty, and left-shifting an entry out
3918 * If there's a left sibling, see if it's ok to shift an entry
3942 left = xfs_btree_get_block(tcur, level, &lbp);
3944 error = xfs_btree_check_block(cur, left, level, lbp);
3949 xfs_btree_get_sibling(tcur, left, &cptr, XFS_BB_RIGHTSIB);
3952 * If left block is full enough so that removing one entry
3954 * of left to us works, we're done.
3956 if (xfs_btree_get_numrecs(left) - 1 >=
3978 lrecs = xfs_btree_get_numrecs(left);
3993 * "left" to be the left neighbor.
3998 error = xfs_btree_read_buf_block(cur, &lptr, 0, &left, &lbp);
4009 * Set "left" to be the starting block,
4013 left = block;
4031 lrecs = xfs_btree_get_numrecs(left);
4034 * We're now going to join "left" and "right" by moving all the stuff
4035 * in "right" to "left" and deleting "right".
4040 union xfs_btree_key *lkp; /* left btree key */
4041 union xfs_btree_ptr *lpp; /* left address pointer */
4045 lkp = xfs_btree_key_addr(cur, lrecs + 1, left);
4046 lpp = xfs_btree_ptr_addr(cur, lrecs + 1, left);
4063 union xfs_btree_rec *lrp; /* left record pointer */
4066 lrp = xfs_btree_rec_addr(cur, lrecs + 1, left);
4079 xfs_btree_set_numrecs(left, lrecs + rrecs);
4081 xfs_btree_set_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
4085 xfs_btree_get_sibling(cur, left, &cptr, XFS_BB_RIGHTSIB);
4100 * If we joined with the left neighbor, set the buffer in the
4101 * cursor to the left block, and fix up the index.
4230 * Off the right end or left end, return failure.
4293 /* grab the left hand block */
4298 /* readahead the left most block for the next level down */
4335 * pointers so we can just walk all the blocks on each level from left to right