int
search_by_key(struct reiserfs_sb_info *p_s_sbi,
const struct cpu_key * p_s_key, /* Key to search. */
struct path * p_s_search_path, /* This structure was allocated and
initialized by the calling function.
It is filled up by this function. */
int n_stop_level) /* How far down the tree to search. To
stop at leaf level - set to
DISK_LEAF_NODE_LEVEL */
{
int error;
int n_node_level, n_retval;
int n_block_number, expected_level, fs_gen;
struct path_element *p_s_last_element;
struct buf *p_s_bp, *tmp_bp;
/*
* As we add each node to a path we increase its count. This means that
* we must be careful to release all nodes in a path before we either
* discard the path struct or re-use the path struct, as we do here.
*/
decrement_counters_in_path(p_s_search_path);
/*
* With each iteration of this loop we search through the items in the
* current node, and calculate the next current node(next path element)
* for the next iteration of this loop...
*/
n_block_number = SB_ROOT_BLOCK(p_s_sbi);
expected_level = -1;
reiserfs_log(LOG_DEBUG, "root block: #%d\n", n_block_number);
while (1) {
/* Prep path to have another element added to it. */
reiserfs_log(LOG_DEBUG, "path element #%d\n",
p_s_search_path->path_length);
p_s_last_element = PATH_OFFSET_PELEMENT(p_s_search_path,
++p_s_search_path->path_length);
fs_gen = get_generation(p_s_sbi);
/*
* Read the next tree node, and set the last element in the
* path to have a pointer to it.
*/
reiserfs_log(LOG_DEBUG, "reading block #%d\n",
n_block_number);
if ((error = bread(p_s_sbi->s_devvp,
n_block_number * btodb(p_s_sbi->s_blocksize),
p_s_sbi->s_blocksize, NOCRED, &tmp_bp)) != 0) {
reiserfs_log(LOG_DEBUG, "error reading block\n");
p_s_search_path->path_length--;
pathrelse(p_s_search_path);
return (IO_ERROR);
}
reiserfs_log(LOG_DEBUG, "blkno = %ju, lblkno = %ju\n",
(intmax_t)tmp_bp->b_blkno, (intmax_t)tmp_bp->b_lblkno);
/*
* As i didn't found a way to handle the lock correctly,
* i copy the data into a fake buffer
*/
reiserfs_log(LOG_DEBUG, "allocating p_s_bp\n");
p_s_bp = malloc(sizeof *p_s_bp, M_REISERFSPATH, M_WAITOK);
if (!p_s_bp) {
reiserfs_log(LOG_DEBUG, "error allocating memory\n");
p_s_search_path->path_length--;
pathrelse(p_s_search_path);
brelse(tmp_bp);
return (IO_ERROR);
}
reiserfs_log(LOG_DEBUG, "copying struct buf\n");
bcopy(tmp_bp, p_s_bp, sizeof(struct buf));
reiserfs_log(LOG_DEBUG, "allocating p_s_bp->b_data\n");
p_s_bp->b_data = malloc(p_s_sbi->s_blocksize,
M_REISERFSPATH, M_WAITOK);
if (!p_s_bp->b_data) {
reiserfs_log(LOG_DEBUG, "error allocating memory\n");
p_s_search_path->path_length--;
pathrelse(p_s_search_path);
free(p_s_bp, M_REISERFSPATH);
brelse(tmp_bp);
return (IO_ERROR);
}
reiserfs_log(LOG_DEBUG, "copying buffer data\n");
bcopy(tmp_bp->b_data, p_s_bp->b_data, p_s_sbi->s_blocksize);
brelse(tmp_bp);
tmp_bp = NULL;
reiserfs_log(LOG_DEBUG, "...done\n");
p_s_last_element->pe_buffer = p_s_bp;
if (expected_level == -1)
expected_level = SB_TREE_HEIGHT(p_s_sbi);
expected_level--;
reiserfs_log(LOG_DEBUG, "expected level: %d (%d)\n",
expected_level, SB_TREE_HEIGHT(p_s_sbi));
/* XXX */
/*
* It is possible that schedule occurred. We must check
* whether the key to search is still in the tree rooted
* from the current buffer. If not then repeat search
* from the root.
*/
if (fs_changed(fs_gen, p_s_sbi) &&
(!B_IS_IN_TREE(p_s_bp) ||
B_LEVEL(p_s_bp) != expected_level ||
!key_in_buffer(p_s_search_path, p_s_key, p_s_sbi))) {
reiserfs_log(LOG_DEBUG,
"the key isn't in the tree anymore\n");
decrement_counters_in_path(p_s_search_path);
/*
* Get the root block number so that we can repeat
* the search starting from the root.
*/
n_block_number = SB_ROOT_BLOCK(p_s_sbi);
expected_level = -1;
/* Repeat search from the root */
continue;
}
/*
* Make sure, that the node contents look like a node of
* certain level
*/
if (!is_tree_node(p_s_bp, expected_level)) {
reiserfs_log(LOG_WARNING,
"invalid format found in block %ju. Fsck?",
(intmax_t)p_s_bp->b_blkno);
pathrelse (p_s_search_path);
return (IO_ERROR);
}
/* Ok, we have acquired next formatted node in the tree */
n_node_level = B_LEVEL(p_s_bp);
reiserfs_log(LOG_DEBUG, "block info:\n");
reiserfs_log(LOG_DEBUG, " node level: %d\n",
n_node_level);
reiserfs_log(LOG_DEBUG, " nb of items: %d\n",
B_NR_ITEMS(p_s_bp));
reiserfs_log(LOG_DEBUG, " free space: %d bytes\n",
B_FREE_SPACE(p_s_bp));
reiserfs_log(LOG_DEBUG, "bin_search with :\n"
" p_s_key = (objectid=%d, dirid=%d)\n"
" B_NR_ITEMS(p_s_bp) = %d\n"
" p_s_last_element->pe_position = %d (path_length = %d)\n",
p_s_key->on_disk_key.k_objectid,
p_s_key->on_disk_key.k_dir_id,
B_NR_ITEMS(p_s_bp),
p_s_last_element->pe_position,
p_s_search_path->path_length);
n_retval = bin_search(p_s_key, B_N_PITEM_HEAD(p_s_bp, 0),
B_NR_ITEMS(p_s_bp),
(n_node_level == DISK_LEAF_NODE_LEVEL) ? IH_SIZE : KEY_SIZE,
&(p_s_last_element->pe_position));
reiserfs_log(LOG_DEBUG, "bin_search result: %d\n",
n_retval);
if (n_node_level == n_stop_level) {
reiserfs_log(LOG_DEBUG, "stop level reached (%s)\n",
n_retval == ITEM_FOUND ? "found" : "not found");
return (n_retval);
}
/* We are not in the stop level */
if (n_retval == ITEM_FOUND)
/*
* Item has been found, so we choose the pointer
* which is to the right of the found one
*/
p_s_last_element->pe_position++;
/*
* If item was not found we choose the position which is
* to the left of the found item. This requires no code,
* bin_search did it already.
*/
/*
* So we have chosen a position in the current node which
* is an internal node. Now we calculate child block number
* by position in the node.
*/
n_block_number = B_N_CHILD_NUM(p_s_bp,
p_s_last_element->pe_position);
}
reiserfs_log(LOG_DEBUG, "done\n");
return (0);
}
/* Delete insert_num node pointers together with their left items
* and balance current node.*/
static void balance_internal_when_delete(struct tree_balance *tb,
int h, int child_pos)
{
int insert_num;
int n;
struct buffer_head *tbSh = PATH_H_PBUFFER(tb->tb_path, h);
struct buffer_info bi;
insert_num = tb->insert_size[h] / ((int)(DC_SIZE + KEY_SIZE));
/* delete child-node-pointer(s) together with their left item(s) */
bi.tb = tb;
bi.bi_bh = tbSh;
bi.bi_parent = PATH_H_PPARENT(tb->tb_path, h);
bi.bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
internal_delete_childs(&bi, child_pos, -insert_num);
RFALSE(tb->blknum[h] > 1,
"tb->blknum[%d]=%d when insert_size < 0", h, tb->blknum[h]);
n = B_NR_ITEMS(tbSh);
if (tb->lnum[h] == 0 && tb->rnum[h] == 0) {
if (tb->blknum[h] == 0) {
/* node S[h] (root of the tree) is empty now */
struct buffer_head *new_root;
RFALSE(n
|| B_FREE_SPACE(tbSh) !=
MAX_CHILD_SIZE(tbSh) - DC_SIZE,
"buffer must have only 0 keys (%d)", n);
RFALSE(bi.bi_parent, "root has parent (%p)",
bi.bi_parent);
/* choose a new root */
if (!tb->L[h - 1] || !B_NR_ITEMS(tb->L[h - 1]))
new_root = tb->R[h - 1];
else
new_root = tb->L[h - 1];
/* switch super block's tree root block number to the new value */
PUT_SB_ROOT_BLOCK(tb->tb_sb, new_root->b_blocknr);
//REISERFS_SB(tb->tb_sb)->s_rs->s_tree_height --;
PUT_SB_TREE_HEIGHT(tb->tb_sb,
SB_TREE_HEIGHT(tb->tb_sb) - 1);
do_balance_mark_sb_dirty(tb,
REISERFS_SB(tb->tb_sb)->s_sbh,
1);
/*&&&&&&&&&&&&&&&&&&&&&& */
if (h > 1)
/* use check_internal if new root is an internal node */
check_internal(new_root);
/*&&&&&&&&&&&&&&&&&&&&&& */
/* do what is needed for buffer thrown from tree */
reiserfs_invalidate_buffer(tb, tbSh);
return;
}
return;
}
if (tb->L[h] && tb->lnum[h] == -B_NR_ITEMS(tb->L[h]) - 1) { /* join S[h] with L[h] */
RFALSE(tb->rnum[h] != 0,
"invalid tb->rnum[%d]==%d when joining S[h] with L[h]",
h, tb->rnum[h]);
internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h, n + 1);
reiserfs_invalidate_buffer(tb, tbSh);
return;
}
if (tb->R[h] && tb->rnum[h] == -B_NR_ITEMS(tb->R[h]) - 1) { /* join S[h] with R[h] */
RFALSE(tb->lnum[h] != 0,
"invalid tb->lnum[%d]==%d when joining S[h] with R[h]",
h, tb->lnum[h]);
internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h, n + 1);
reiserfs_invalidate_buffer(tb, tbSh);
return;
}
if (tb->lnum[h] < 0) { /* borrow from left neighbor L[h] */
RFALSE(tb->rnum[h] != 0,
"wrong tb->rnum[%d]==%d when borrow from L[h]", h,
tb->rnum[h]);
/*internal_shift_right (tb, h, tb->L[h], tb->CFL[h], tb->lkey[h], tb->S[h], -tb->lnum[h]); */
internal_shift_right(INTERNAL_SHIFT_FROM_L_TO_S, tb, h,
-tb->lnum[h]);
return;
}
if (tb->rnum[h] < 0) { /* borrow from right neighbor R[h] */
RFALSE(tb->lnum[h] != 0,
"invalid tb->lnum[%d]==%d when borrow from R[h]",
h, tb->lnum[h]);
internal_shift_left(INTERNAL_SHIFT_FROM_R_TO_S, tb, h, -tb->rnum[h]); /*tb->S[h], tb->CFR[h], tb->rkey[h], tb->R[h], -tb->rnum[h]); */
return;
}
if (tb->lnum[h] > 0) { /* split S[h] into two parts and put them into neighbors */
RFALSE(tb->rnum[h] == 0 || tb->lnum[h] + tb->rnum[h] != n + 1,
"invalid tb->lnum[%d]==%d or tb->rnum[%d]==%d when S[h](item number == %d) is split between them",
h, tb->lnum[h], h, tb->rnum[h], n);
internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h, tb->lnum[h]); /*tb->L[h], tb->CFL[h], tb->lkey[h], tb->S[h], tb->lnum[h]); */
internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
tb->rnum[h]);
reiserfs_invalidate_buffer(tb, tbSh);
return;
}
reiserfs_panic(tb->tb_sb, "ibalance-2",
"unexpected tb->lnum[%d]==%d or tb->rnum[%d]==%d",
h, tb->lnum[h], h, tb->rnum[h]);
}
int balance_internal(struct tree_balance *tb, /* tree_balance structure */
int h, /* level of the tree */
int child_pos, struct item_head *insert_key, /* key for insertion on higher level */
struct buffer_head **insert_ptr /* node for insertion on higher level */
)
/* if inserting/pasting
{
child_pos is the position of the node-pointer in S[h] that *
pointed to S[h-1] before balancing of the h-1 level; *
this means that new pointers and items must be inserted AFTER *
child_pos
}
else
{
it is the position of the leftmost pointer that must be deleted (together with
its corresponding key to the left of the pointer)
as a result of the previous level's balancing.
}
*/
{
struct buffer_head *tbSh = PATH_H_PBUFFER(tb->tb_path, h);
struct buffer_info bi;
int order; /* we return this: it is 0 if there is no S[h], else it is tb->S[h]->b_item_order */
int insert_num, n, k;
struct buffer_head *S_new;
struct item_head new_insert_key;
struct buffer_head *new_insert_ptr = NULL;
struct item_head *new_insert_key_addr = insert_key;
RFALSE(h < 1, "h (%d) can not be < 1 on internal level", h);
PROC_INFO_INC(tb->tb_sb, balance_at[h]);
order =
(tbSh) ? PATH_H_POSITION(tb->tb_path,
h + 1) /*tb->S[h]->b_item_order */ : 0;
/* Using insert_size[h] calculate the number insert_num of items
that must be inserted to or deleted from S[h]. */
insert_num = tb->insert_size[h] / ((int)(KEY_SIZE + DC_SIZE));
/* Check whether insert_num is proper * */
RFALSE(insert_num < -2 || insert_num > 2,
"incorrect number of items inserted to the internal node (%d)",
insert_num);
RFALSE(h > 1 && (insert_num > 1 || insert_num < -1),
"incorrect number of items (%d) inserted to the internal node on a level (h=%d) higher than last internal level",
insert_num, h);
/* Make balance in case insert_num < 0 */
if (insert_num < 0) {
balance_internal_when_delete(tb, h, child_pos);
return order;
}
k = 0;
if (tb->lnum[h] > 0) {
/* shift lnum[h] items from S[h] to the left neighbor L[h].
check how many of new items fall into L[h] or CFL[h] after
shifting */
n = B_NR_ITEMS(tb->L[h]); /* number of items in L[h] */
if (tb->lnum[h] <= child_pos) {
/* new items don't fall into L[h] or CFL[h] */
internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h,
tb->lnum[h]);
/*internal_shift_left (tb->L[h],tb->CFL[h],tb->lkey[h],tbSh,tb->lnum[h]); */
child_pos -= tb->lnum[h];
} else if (tb->lnum[h] > child_pos + insert_num) {
/* all new items fall into L[h] */
internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h,
tb->lnum[h] - insert_num);
/* internal_shift_left(tb->L[h],tb->CFL[h],tb->lkey[h],tbSh,
tb->lnum[h]-insert_num);
*/
/* insert insert_num keys and node-pointers into L[h] */
bi.tb = tb;
bi.bi_bh = tb->L[h];
bi.bi_parent = tb->FL[h];
bi.bi_position = get_left_neighbor_position(tb, h);
internal_insert_childs(&bi,
/*tb->L[h], tb->S[h-1]->b_next */
n + child_pos + 1,
insert_num, insert_key,
insert_ptr);
insert_num = 0;
} else {
struct disk_child *dc;
/* some items fall into L[h] or CFL[h], but some don't fall */
internal_shift1_left(tb, h, child_pos + 1);
/* calculate number of new items that fall into L[h] */
k = tb->lnum[h] - child_pos - 1;
bi.tb = tb;
bi.bi_bh = tb->L[h];
bi.bi_parent = tb->FL[h];
bi.bi_position = get_left_neighbor_position(tb, h);
internal_insert_childs(&bi,
/*tb->L[h], tb->S[h-1]->b_next, */
n + child_pos + 1, k,
insert_key, insert_ptr);
replace_lkey(tb, h, insert_key + k);
/* replace the first node-ptr in S[h] by node-ptr to insert_ptr[k] */
dc = B_N_CHILD(tbSh, 0);
put_dc_size(dc,
MAX_CHILD_SIZE(insert_ptr[k]) -
B_FREE_SPACE(insert_ptr[k]));
put_dc_block_number(dc, insert_ptr[k]->b_blocknr);
do_balance_mark_internal_dirty(tb, tbSh, 0);
k++;
insert_key += k;
insert_ptr += k;
insert_num -= k;
child_pos = 0;
}
}
/* tb->lnum[h] > 0 */
if (tb->rnum[h] > 0) {
/*shift rnum[h] items from S[h] to the right neighbor R[h] */
/* check how many of new items fall into R or CFR after shifting */
n = B_NR_ITEMS(tbSh); /* number of items in S[h] */
if (n - tb->rnum[h] >= child_pos)
/* new items fall into S[h] */
/*internal_shift_right(tb,h,tbSh,tb->CFR[h],tb->rkey[h],tb->R[h],tb->rnum[h]); */
internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
tb->rnum[h]);
else if (n + insert_num - tb->rnum[h] < child_pos) {
/* all new items fall into R[h] */
/*internal_shift_right(tb,h,tbSh,tb->CFR[h],tb->rkey[h],tb->R[h],
tb->rnum[h] - insert_num); */
internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
tb->rnum[h] - insert_num);
/* insert insert_num keys and node-pointers into R[h] */
bi.tb = tb;
bi.bi_bh = tb->R[h];
bi.bi_parent = tb->FR[h];
bi.bi_position = get_right_neighbor_position(tb, h);
internal_insert_childs(&bi,
/*tb->R[h],tb->S[h-1]->b_next */
child_pos - n - insert_num +
tb->rnum[h] - 1,
insert_num, insert_key,
insert_ptr);
insert_num = 0;
} else {
struct disk_child *dc;
/* one of the items falls into CFR[h] */
internal_shift1_right(tb, h, n - child_pos + 1);
/* calculate number of new items that fall into R[h] */
k = tb->rnum[h] - n + child_pos - 1;
bi.tb = tb;
bi.bi_bh = tb->R[h];
bi.bi_parent = tb->FR[h];
bi.bi_position = get_right_neighbor_position(tb, h);
internal_insert_childs(&bi,
/*tb->R[h], tb->R[h]->b_child, */
0, k, insert_key + 1,
insert_ptr + 1);
replace_rkey(tb, h, insert_key + insert_num - k - 1);
/* replace the first node-ptr in R[h] by node-ptr insert_ptr[insert_num-k-1] */
dc = B_N_CHILD(tb->R[h], 0);
put_dc_size(dc,
MAX_CHILD_SIZE(insert_ptr
[insert_num - k - 1]) -
B_FREE_SPACE(insert_ptr
[insert_num - k - 1]));
put_dc_block_number(dc,
insert_ptr[insert_num - k -
1]->b_blocknr);
do_balance_mark_internal_dirty(tb, tb->R[h], 0);
insert_num -= (k + 1);
}
}
/** Fill new node that appears instead of S[h] **/
RFALSE(tb->blknum[h] > 2, "blknum can not be > 2 for internal level");
RFALSE(tb->blknum[h] < 0, "blknum can not be < 0");
if (!tb->blknum[h]) { /* node S[h] is empty now */
RFALSE(!tbSh, "S[h] is equal NULL");
/* do what is needed for buffer thrown from tree */
reiserfs_invalidate_buffer(tb, tbSh);
return order;
}
if (!tbSh) {
/* create new root */
struct disk_child *dc;
struct buffer_head *tbSh_1 = PATH_H_PBUFFER(tb->tb_path, h - 1);
struct block_head *blkh;
if (tb->blknum[h] != 1)
reiserfs_panic(NULL, "ibalance-3", "One new node "
"required for creating the new root");
/* S[h] = empty buffer from the list FEB. */
tbSh = get_FEB(tb);
blkh = B_BLK_HEAD(tbSh);
set_blkh_level(blkh, h + 1);
/* Put the unique node-pointer to S[h] that points to S[h-1]. */
dc = B_N_CHILD(tbSh, 0);
put_dc_block_number(dc, tbSh_1->b_blocknr);
put_dc_size(dc,
(MAX_CHILD_SIZE(tbSh_1) - B_FREE_SPACE(tbSh_1)));
tb->insert_size[h] -= DC_SIZE;
set_blkh_free_space(blkh, blkh_free_space(blkh) - DC_SIZE);
do_balance_mark_internal_dirty(tb, tbSh, 0);
/*&&&&&&&&&&&&&&&&&&&&&&&& */
check_internal(tbSh);
/*&&&&&&&&&&&&&&&&&&&&&&&& */
/* put new root into path structure */
PATH_OFFSET_PBUFFER(tb->tb_path, ILLEGAL_PATH_ELEMENT_OFFSET) =
tbSh;
/* Change root in structure super block. */
PUT_SB_ROOT_BLOCK(tb->tb_sb, tbSh->b_blocknr);
PUT_SB_TREE_HEIGHT(tb->tb_sb, SB_TREE_HEIGHT(tb->tb_sb) + 1);
do_balance_mark_sb_dirty(tb, REISERFS_SB(tb->tb_sb)->s_sbh, 1);
}
if (tb->blknum[h] == 2) {
int snum;
struct buffer_info dest_bi, src_bi;
/* S_new = free buffer from list FEB */
S_new = get_FEB(tb);
set_blkh_level(B_BLK_HEAD(S_new), h + 1);
dest_bi.tb = tb;
dest_bi.bi_bh = S_new;
dest_bi.bi_parent = NULL;
dest_bi.bi_position = 0;
src_bi.tb = tb;
src_bi.bi_bh = tbSh;
src_bi.bi_parent = PATH_H_PPARENT(tb->tb_path, h);
src_bi.bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
n = B_NR_ITEMS(tbSh); /* number of items in S[h] */
snum = (insert_num + n + 1) / 2;
if (n - snum >= child_pos) {
/* new items don't fall into S_new */
/* store the delimiting key for the next level */
/* new_insert_key = (n - snum)'th key in S[h] */
memcpy(&new_insert_key, B_N_PDELIM_KEY(tbSh, n - snum),
KEY_SIZE);
/* last parameter is del_par */
internal_move_pointers_items(&dest_bi, &src_bi,
LAST_TO_FIRST, snum, 0);
/* internal_move_pointers_items(S_new, tbSh, LAST_TO_FIRST, snum, 0); */
} else if (n + insert_num - snum < child_pos) {
/* all new items fall into S_new */
/* store the delimiting key for the next level */
/* new_insert_key = (n + insert_item - snum)'th key in S[h] */
memcpy(&new_insert_key,
B_N_PDELIM_KEY(tbSh, n + insert_num - snum),
KEY_SIZE);
/* last parameter is del_par */
internal_move_pointers_items(&dest_bi, &src_bi,
LAST_TO_FIRST,
snum - insert_num, 0);
/* internal_move_pointers_items(S_new,tbSh,1,snum - insert_num,0); */
/* insert insert_num keys and node-pointers into S_new */
internal_insert_childs(&dest_bi,
/*S_new,tb->S[h-1]->b_next, */
child_pos - n - insert_num +
snum - 1,
insert_num, insert_key,
insert_ptr);
insert_num = 0;
} else {
struct disk_child *dc;
/* some items fall into S_new, but some don't fall */
/* last parameter is del_par */
internal_move_pointers_items(&dest_bi, &src_bi,
LAST_TO_FIRST,
n - child_pos + 1, 1);
/* internal_move_pointers_items(S_new,tbSh,1,n - child_pos + 1,1); */
/* calculate number of new items that fall into S_new */
k = snum - n + child_pos - 1;
internal_insert_childs(&dest_bi, /*S_new, */ 0, k,
insert_key + 1, insert_ptr + 1);
/* new_insert_key = insert_key[insert_num - k - 1] */
memcpy(&new_insert_key, insert_key + insert_num - k - 1,
KEY_SIZE);
/* replace first node-ptr in S_new by node-ptr to insert_ptr[insert_num-k-1] */
dc = B_N_CHILD(S_new, 0);
put_dc_size(dc,
(MAX_CHILD_SIZE
(insert_ptr[insert_num - k - 1]) -
B_FREE_SPACE(insert_ptr
[insert_num - k - 1])));
put_dc_block_number(dc,
insert_ptr[insert_num - k -
1]->b_blocknr);
do_balance_mark_internal_dirty(tb, S_new, 0);
insert_num -= (k + 1);
}
/* new_insert_ptr = node_pointer to S_new */
new_insert_ptr = S_new;
RFALSE(!buffer_journaled(S_new) || buffer_journal_dirty(S_new)
|| buffer_dirty(S_new), "cm-00001: bad S_new (%b)",
S_new);
// S_new is released in unfix_nodes
}
n = B_NR_ITEMS(tbSh); /*number of items in S[h] */
if (0 <= child_pos && child_pos <= n && insert_num > 0) {
bi.tb = tb;
bi.bi_bh = tbSh;
bi.bi_parent = PATH_H_PPARENT(tb->tb_path, h);
bi.bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
internal_insert_childs(&bi, /*tbSh, */
/* ( tb->S[h-1]->b_parent == tb->S[h] ) ? tb->S[h-1]->b_next : tb->S[h]->b_child->b_next, */
child_pos, insert_num, insert_key,
insert_ptr);
}
memcpy(new_insert_key_addr, &new_insert_key, KEY_SIZE);
insert_ptr[0] = new_insert_ptr;
return order;
}
/* This function fills up the path from the root to the leaf as it
descends the tree looking for the key. It uses reiserfs_bread to
try to find buffers in the cache given their block number. If it
does not find them in the cache it reads them from disk. For each
node search_by_key finds using reiserfs_bread it then uses
bin_search to look through that node. bin_search will find the
position of the block_number of the next node if it is looking
through an internal node. If it is looking through a leaf node
bin_search will find the position of the item which has key either
equal to given key, or which is the maximal key less than the given
key. search_by_key returns a path that must be checked for the
correctness of the top of the path but need not be checked for the
correctness of the bottom of the path */
int search_by_key(
struct super_block * p_s_sb, /* Super block. */
struct key * p_s_key, /* Key to search. */
struct path * p_s_search_path,/* This structure was allocated and initialized by
the calling function. It is filled up by this
function. */
int * p_n_repeat, /* Whether schedule occured. */
int n_stop_level /* How far down the tree to search.*/
) {
dev_t n_dev = p_s_sb->s_dev;
int n_repeat,
n_block_number = SB_ROOT_BLOCK (p_s_sb),
expected_level = SB_TREE_HEIGHT (p_s_sb),
n_block_size = p_s_sb->s_blocksize;
struct buffer_head * p_s_bh;
struct path_element * p_s_last_element;
int n_retval;
int right_neighbor_of_leaf_node;
#ifdef CONFIG_REISERFS_CHECK
int n_repeat_counter = 0;
#endif
/* As we add each node to a path we increase its count. This
means that we must be careful to release all nodes in a path
before we either discard the path struct or re-use the path
struct, as we do here. */
pathrelse (p_s_search_path);
*p_n_repeat = CARRY_ON;
/* With each iteration of this loop we search through the items in
the current node, and calculate the next current node(next path
element) for the next iteration of this loop.. */
while ( 1 ) {
#ifdef CONFIG_REISERFS_CHECK
if ( !(++n_repeat_counter % 50000) )
printk ("PAP-5100: search_by_key(pid %u): there were %d searches from the tree_root lokking for key %p\n",
current->pid, n_repeat_counter, p_s_key);
#endif
/* prep path to have another element added to it. */
p_s_last_element = PATH_OFFSET_PELEMENT(p_s_search_path, ++p_s_search_path->path_length);
expected_level --;
n_repeat = CARRY_ON;
/* Read the next tree node, and set the last element in the
path to have a pointer to it. */
if ( ! (p_s_bh = p_s_last_element->pe_buffer =
reiserfs_bread(n_dev, n_block_number, n_block_size, &n_repeat)) ) {
p_s_search_path->path_length --;
pathrelse(p_s_search_path);
*p_n_repeat |= n_repeat;
return IO_ERROR;
}
*p_n_repeat |= n_repeat;
/* It is possible that schedule occured. We must check whether
the key to search is still in the tree rooted from the
current buffer. If not then repeat search from the root. */
if ( n_repeat != CARRY_ON &&
(!B_IS_IN_TREE (p_s_bh) || (! key_in_buffer(p_s_search_path, p_s_key, p_s_sb))) ) {
pathrelse (p_s_search_path);
/* Get the root block number so that we can repeat the
search starting from the root. */
n_block_number = SB_ROOT_BLOCK (p_s_sb);
expected_level = SB_TREE_HEIGHT (p_s_sb);
right_neighbor_of_leaf_node = 0;
/* repeat search from the root */
continue;
}
#ifdef CONFIG_REISERFS_CHECK
if ( ! key_in_buffer(p_s_search_path, p_s_key, p_s_sb) )
reiserfs_panic(p_s_sb, "PAP-5130: search_by_key: key is not in the buffer");
if ( cur_tb ) {
/* print_tb (init_mode, init_item_pos, init_pos_in_item, &init_tb, "5140");*/
reiserfs_panic(p_s_sb, "PAP-5140: search_by_key: schedule occurred in do_balance!");
}
#endif
// make sure, that the node contents look like a nod of
// certain level
if (!is_tree_node (p_s_bh, expected_level)) {
print_block (stderr, 0, p_s_bh, 3, -1, -1);
reiserfs_panic ("vs-5150: search_by_key: expeced level %d", expected_level);
pathrelse (p_s_search_path);
return IO_ERROR;
}
/* ok, we have acquired next formatted node in the tree */
n_retval = bin_search (p_s_key, B_N_PITEM_HEAD(p_s_bh, 0), B_NR_ITEMS(p_s_bh),
is_leaf_node (p_s_bh) ? IH_SIZE : KEY_SIZE, &(p_s_last_element->pe_position));
if (node_level (p_s_bh) == n_stop_level)
return n_retval;
/* we are not in the stop level */
if (n_retval == ITEM_FOUND)
/* item has been found, so we choose the pointer which is to the right of the found one */
p_s_last_element->pe_position++;
/* if item was not found we choose the position which is to the left of the found item. This
requires no code, bin_search did it already.*/
/* So we have chosen a position in the current node which is an
internal node. Now we calculate child block number by position in the node. */
n_block_number = B_N_CHILD_NUM(p_s_bh, p_s_last_element->pe_position);
}
}