1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5 /** 6 ** old_item_num 7 ** old_entry_num 8 ** set_entry_sizes 9 ** create_virtual_node 10 ** check_left 11 ** check_right 12 ** directory_part_size 13 ** get_num_ver 14 ** set_parameters 15 ** is_leaf_removable 16 ** are_leaves_removable 17 ** get_empty_nodes 18 ** get_lfree 19 ** get_rfree 20 ** is_left_neighbor_in_cache 21 ** decrement_key 22 ** get_far_parent 23 ** get_parents 24 ** can_node_be_removed 25 ** ip_check_balance 26 ** dc_check_balance_internal 27 ** dc_check_balance_leaf 28 ** dc_check_balance 29 ** check_balance 30 ** get_direct_parent 31 ** get_neighbors 32 ** fix_nodes 33 ** 34 ** 35 **/ 36 37 #include <linux/time.h> 38 #include <linux/slab.h> 39 #include <linux/string.h> 40 #include <linux/reiserfs_fs.h> 41 #include <linux/buffer_head.h> 42 43 /* To make any changes in the tree we find a node, that contains item 44 to be changed/deleted or position in the node we insert a new item 45 to. We call this node S. To do balancing we need to decide what we 46 will shift to left/right neighbor, or to a new node, where new item 47 will be etc. To make this analysis simpler we build virtual 48 node. Virtual node is an array of items, that will replace items of 49 node S. (For instance if we are going to delete an item, virtual 50 node does not contain it). Virtual node keeps information about 51 item sizes and types, mergeability of first and last items, sizes 52 of all entries in directory item. We use this array of items when 53 calculating what we can shift to neighbors and how many nodes we 54 have to have if we do not any shiftings, if we shift to left/right 55 neighbor or to both. */ 56 57 /* taking item number in virtual node, returns number of item, that it has in source buffer */ 58 static inline int old_item_num(int new_num, int affected_item_num, int mode) 59 { 60 if (mode == M_PASTE || mode == M_CUT || new_num < affected_item_num) 61 return new_num; 62 63 if (mode == M_INSERT) { 64 65 RFALSE(new_num == 0, 66 "vs-8005: for INSERT mode and item number of inserted item"); 67 68 return new_num - 1; 69 } 70 71 RFALSE(mode != M_DELETE, 72 "vs-8010: old_item_num: mode must be M_DELETE (mode = \'%c\'", 73 mode); 74 /* delete mode */ 75 return new_num + 1; 76 } 77 78 static void create_virtual_node(struct tree_balance *tb, int h) 79 { 80 struct item_head *ih; 81 struct virtual_node *vn = tb->tb_vn; 82 int new_num; 83 struct buffer_head *Sh; /* this comes from tb->S[h] */ 84 85 Sh = PATH_H_PBUFFER(tb->tb_path, h); 86 87 /* size of changed node */ 88 vn->vn_size = 89 MAX_CHILD_SIZE(Sh) - B_FREE_SPACE(Sh) + tb->insert_size[h]; 90 91 /* for internal nodes array if virtual items is not created */ 92 if (h) { 93 vn->vn_nr_item = (vn->vn_size - DC_SIZE) / (DC_SIZE + KEY_SIZE); 94 return; 95 } 96 97 /* number of items in virtual node */ 98 vn->vn_nr_item = 99 B_NR_ITEMS(Sh) + ((vn->vn_mode == M_INSERT) ? 1 : 0) - 100 ((vn->vn_mode == M_DELETE) ? 1 : 0); 101 102 /* first virtual item */ 103 vn->vn_vi = (struct virtual_item *)(tb->tb_vn + 1); 104 memset(vn->vn_vi, 0, vn->vn_nr_item * sizeof(struct virtual_item)); 105 vn->vn_free_ptr += vn->vn_nr_item * sizeof(struct virtual_item); 106 107 /* first item in the node */ 108 ih = B_N_PITEM_HEAD(Sh, 0); 109 110 /* define the mergeability for 0-th item (if it is not being deleted) */ 111 if (op_is_left_mergeable(&(ih->ih_key), Sh->b_size) 112 && (vn->vn_mode != M_DELETE || vn->vn_affected_item_num)) 113 vn->vn_vi[0].vi_type |= VI_TYPE_LEFT_MERGEABLE; 114 115 /* go through all items those remain in the virtual node (except for the new (inserted) one) */ 116 for (new_num = 0; new_num < vn->vn_nr_item; new_num++) { 117 int j; 118 struct virtual_item *vi = vn->vn_vi + new_num; 119 int is_affected = 120 ((new_num != vn->vn_affected_item_num) ? 0 : 1); 121 122 if (is_affected && vn->vn_mode == M_INSERT) 123 continue; 124 125 /* get item number in source node */ 126 j = old_item_num(new_num, vn->vn_affected_item_num, 127 vn->vn_mode); 128 129 vi->vi_item_len += ih_item_len(ih + j) + IH_SIZE; 130 vi->vi_ih = ih + j; 131 vi->vi_item = B_I_PITEM(Sh, ih + j); 132 vi->vi_uarea = vn->vn_free_ptr; 133 134 // FIXME: there is no check, that item operation did not 135 // consume too much memory 136 vn->vn_free_ptr += 137 op_create_vi(vn, vi, is_affected, tb->insert_size[0]); 138 if (tb->vn_buf + tb->vn_buf_size < vn->vn_free_ptr) 139 reiserfs_panic(tb->tb_sb, "vs-8030", 140 "virtual node space consumed"); 141 142 if (!is_affected) 143 /* this is not being changed */ 144 continue; 145 146 if (vn->vn_mode == M_PASTE || vn->vn_mode == M_CUT) { 147 vn->vn_vi[new_num].vi_item_len += tb->insert_size[0]; 148 vi->vi_new_data = vn->vn_data; // pointer to data which is going to be pasted 149 } 150 } 151 152 /* virtual inserted item is not defined yet */ 153 if (vn->vn_mode == M_INSERT) { 154 struct virtual_item *vi = vn->vn_vi + vn->vn_affected_item_num; 155 156 RFALSE(vn->vn_ins_ih == NULL, 157 "vs-8040: item header of inserted item is not specified"); 158 vi->vi_item_len = tb->insert_size[0]; 159 vi->vi_ih = vn->vn_ins_ih; 160 vi->vi_item = vn->vn_data; 161 vi->vi_uarea = vn->vn_free_ptr; 162 163 op_create_vi(vn, vi, 0 /*not pasted or cut */ , 164 tb->insert_size[0]); 165 } 166 167 /* set right merge flag we take right delimiting key and check whether it is a mergeable item */ 168 if (tb->CFR[0]) { 169 struct reiserfs_key *key; 170 171 key = B_N_PDELIM_KEY(tb->CFR[0], tb->rkey[0]); 172 if (op_is_left_mergeable(key, Sh->b_size) 173 && (vn->vn_mode != M_DELETE 174 || vn->vn_affected_item_num != B_NR_ITEMS(Sh) - 1)) 175 vn->vn_vi[vn->vn_nr_item - 1].vi_type |= 176 VI_TYPE_RIGHT_MERGEABLE; 177 178 #ifdef CONFIG_REISERFS_CHECK 179 if (op_is_left_mergeable(key, Sh->b_size) && 180 !(vn->vn_mode != M_DELETE 181 || vn->vn_affected_item_num != B_NR_ITEMS(Sh) - 1)) { 182 /* we delete last item and it could be merged with right neighbor's first item */ 183 if (! 184 (B_NR_ITEMS(Sh) == 1 185 && is_direntry_le_ih(B_N_PITEM_HEAD(Sh, 0)) 186 && I_ENTRY_COUNT(B_N_PITEM_HEAD(Sh, 0)) == 1)) { 187 /* node contains more than 1 item, or item is not directory item, or this item contains more than 1 entry */ 188 print_block(Sh, 0, -1, -1); 189 reiserfs_panic(tb->tb_sb, "vs-8045", 190 "rdkey %k, affected item==%d " 191 "(mode==%c) Must be %c", 192 key, vn->vn_affected_item_num, 193 vn->vn_mode, M_DELETE); 194 } 195 } 196 #endif 197 198 } 199 } 200 201 /* using virtual node check, how many items can be shifted to left 202 neighbor */ 203 static void check_left(struct tree_balance *tb, int h, int cur_free) 204 { 205 int i; 206 struct virtual_node *vn = tb->tb_vn; 207 struct virtual_item *vi; 208 int d_size, ih_size; 209 210 RFALSE(cur_free < 0, "vs-8050: cur_free (%d) < 0", cur_free); 211 212 /* internal level */ 213 if (h > 0) { 214 tb->lnum[h] = cur_free / (DC_SIZE + KEY_SIZE); 215 return; 216 } 217 218 /* leaf level */ 219 220 if (!cur_free || !vn->vn_nr_item) { 221 /* no free space or nothing to move */ 222 tb->lnum[h] = 0; 223 tb->lbytes = -1; 224 return; 225 } 226 227 RFALSE(!PATH_H_PPARENT(tb->tb_path, 0), 228 "vs-8055: parent does not exist or invalid"); 229 230 vi = vn->vn_vi; 231 if ((unsigned int)cur_free >= 232 (vn->vn_size - 233 ((vi->vi_type & VI_TYPE_LEFT_MERGEABLE) ? IH_SIZE : 0))) { 234 /* all contents of S[0] fits into L[0] */ 235 236 RFALSE(vn->vn_mode == M_INSERT || vn->vn_mode == M_PASTE, 237 "vs-8055: invalid mode or balance condition failed"); 238 239 tb->lnum[0] = vn->vn_nr_item; 240 tb->lbytes = -1; 241 return; 242 } 243 244 d_size = 0, ih_size = IH_SIZE; 245 246 /* first item may be merge with last item in left neighbor */ 247 if (vi->vi_type & VI_TYPE_LEFT_MERGEABLE) 248 d_size = -((int)IH_SIZE), ih_size = 0; 249 250 tb->lnum[0] = 0; 251 for (i = 0; i < vn->vn_nr_item; 252 i++, ih_size = IH_SIZE, d_size = 0, vi++) { 253 d_size += vi->vi_item_len; 254 if (cur_free >= d_size) { 255 /* the item can be shifted entirely */ 256 cur_free -= d_size; 257 tb->lnum[0]++; 258 continue; 259 } 260 261 /* the item cannot be shifted entirely, try to split it */ 262 /* check whether L[0] can hold ih and at least one byte of the item body */ 263 if (cur_free <= ih_size) { 264 /* cannot shift even a part of the current item */ 265 tb->lbytes = -1; 266 return; 267 } 268 cur_free -= ih_size; 269 270 tb->lbytes = op_check_left(vi, cur_free, 0, 0); 271 if (tb->lbytes != -1) 272 /* count partially shifted item */ 273 tb->lnum[0]++; 274 275 break; 276 } 277 278 return; 279 } 280 281 /* using virtual node check, how many items can be shifted to right 282 neighbor */ 283 static void check_right(struct tree_balance *tb, int h, int cur_free) 284 { 285 int i; 286 struct virtual_node *vn = tb->tb_vn; 287 struct virtual_item *vi; 288 int d_size, ih_size; 289 290 RFALSE(cur_free < 0, "vs-8070: cur_free < 0"); 291 292 /* internal level */ 293 if (h > 0) { 294 tb->rnum[h] = cur_free / (DC_SIZE + KEY_SIZE); 295 return; 296 } 297 298 /* leaf level */ 299 300 if (!cur_free || !vn->vn_nr_item) { 301 /* no free space */ 302 tb->rnum[h] = 0; 303 tb->rbytes = -1; 304 return; 305 } 306 307 RFALSE(!PATH_H_PPARENT(tb->tb_path, 0), 308 "vs-8075: parent does not exist or invalid"); 309 310 vi = vn->vn_vi + vn->vn_nr_item - 1; 311 if ((unsigned int)cur_free >= 312 (vn->vn_size - 313 ((vi->vi_type & VI_TYPE_RIGHT_MERGEABLE) ? IH_SIZE : 0))) { 314 /* all contents of S[0] fits into R[0] */ 315 316 RFALSE(vn->vn_mode == M_INSERT || vn->vn_mode == M_PASTE, 317 "vs-8080: invalid mode or balance condition failed"); 318 319 tb->rnum[h] = vn->vn_nr_item; 320 tb->rbytes = -1; 321 return; 322 } 323 324 d_size = 0, ih_size = IH_SIZE; 325 326 /* last item may be merge with first item in right neighbor */ 327 if (vi->vi_type & VI_TYPE_RIGHT_MERGEABLE) 328 d_size = -(int)IH_SIZE, ih_size = 0; 329 330 tb->rnum[0] = 0; 331 for (i = vn->vn_nr_item - 1; i >= 0; 332 i--, d_size = 0, ih_size = IH_SIZE, vi--) { 333 d_size += vi->vi_item_len; 334 if (cur_free >= d_size) { 335 /* the item can be shifted entirely */ 336 cur_free -= d_size; 337 tb->rnum[0]++; 338 continue; 339 } 340 341 /* check whether R[0] can hold ih and at least one byte of the item body */ 342 if (cur_free <= ih_size) { /* cannot shift even a part of the current item */ 343 tb->rbytes = -1; 344 return; 345 } 346 347 /* R[0] can hold the header of the item and at least one byte of its body */ 348 cur_free -= ih_size; /* cur_free is still > 0 */ 349 350 tb->rbytes = op_check_right(vi, cur_free); 351 if (tb->rbytes != -1) 352 /* count partially shifted item */ 353 tb->rnum[0]++; 354 355 break; 356 } 357 358 return; 359 } 360 361 /* 362 * from - number of items, which are shifted to left neighbor entirely 363 * to - number of item, which are shifted to right neighbor entirely 364 * from_bytes - number of bytes of boundary item (or directory entries) which are shifted to left neighbor 365 * to_bytes - number of bytes of boundary item (or directory entries) which are shifted to right neighbor */ 366 static int get_num_ver(int mode, struct tree_balance *tb, int h, 367 int from, int from_bytes, 368 int to, int to_bytes, short *snum012, int flow) 369 { 370 int i; 371 int cur_free; 372 // int bytes; 373 int units; 374 struct virtual_node *vn = tb->tb_vn; 375 // struct virtual_item * vi; 376 377 int total_node_size, max_node_size, current_item_size; 378 int needed_nodes; 379 int start_item, /* position of item we start filling node from */ 380 end_item, /* position of item we finish filling node by */ 381 start_bytes, /* number of first bytes (entries for directory) of start_item-th item 382 we do not include into node that is being filled */ 383 end_bytes; /* number of last bytes (entries for directory) of end_item-th item 384 we do node include into node that is being filled */ 385 int split_item_positions[2]; /* these are positions in virtual item of 386 items, that are split between S[0] and 387 S1new and S1new and S2new */ 388 389 split_item_positions[0] = -1; 390 split_item_positions[1] = -1; 391 392 /* We only create additional nodes if we are in insert or paste mode 393 or we are in replace mode at the internal level. If h is 0 and 394 the mode is M_REPLACE then in fix_nodes we change the mode to 395 paste or insert before we get here in the code. */ 396 RFALSE(tb->insert_size[h] < 0 || (mode != M_INSERT && mode != M_PASTE), 397 "vs-8100: insert_size < 0 in overflow"); 398 399 max_node_size = MAX_CHILD_SIZE(PATH_H_PBUFFER(tb->tb_path, h)); 400 401 /* snum012 [0-2] - number of items, that lay 402 to S[0], first new node and second new node */ 403 snum012[3] = -1; /* s1bytes */ 404 snum012[4] = -1; /* s2bytes */ 405 406 /* internal level */ 407 if (h > 0) { 408 i = ((to - from) * (KEY_SIZE + DC_SIZE) + DC_SIZE); 409 if (i == max_node_size) 410 return 1; 411 return (i / max_node_size + 1); 412 } 413 414 /* leaf level */ 415 needed_nodes = 1; 416 total_node_size = 0; 417 cur_free = max_node_size; 418 419 // start from 'from'-th item 420 start_item = from; 421 // skip its first 'start_bytes' units 422 start_bytes = ((from_bytes != -1) ? from_bytes : 0); 423 424 // last included item is the 'end_item'-th one 425 end_item = vn->vn_nr_item - to - 1; 426 // do not count last 'end_bytes' units of 'end_item'-th item 427 end_bytes = (to_bytes != -1) ? to_bytes : 0; 428 429 /* go through all item beginning from the start_item-th item and ending by 430 the end_item-th item. Do not count first 'start_bytes' units of 431 'start_item'-th item and last 'end_bytes' of 'end_item'-th item */ 432 433 for (i = start_item; i <= end_item; i++) { 434 struct virtual_item *vi = vn->vn_vi + i; 435 int skip_from_end = ((i == end_item) ? end_bytes : 0); 436 437 RFALSE(needed_nodes > 3, "vs-8105: too many nodes are needed"); 438 439 /* get size of current item */ 440 current_item_size = vi->vi_item_len; 441 442 /* do not take in calculation head part (from_bytes) of from-th item */ 443 current_item_size -= 444 op_part_size(vi, 0 /*from start */ , start_bytes); 445 446 /* do not take in calculation tail part of last item */ 447 current_item_size -= 448 op_part_size(vi, 1 /*from end */ , skip_from_end); 449 450 /* if item fits into current node entierly */ 451 if (total_node_size + current_item_size <= max_node_size) { 452 snum012[needed_nodes - 1]++; 453 total_node_size += current_item_size; 454 start_bytes = 0; 455 continue; 456 } 457 458 if (current_item_size > max_node_size) { 459 /* virtual item length is longer, than max size of item in 460 a node. It is impossible for direct item */ 461 RFALSE(is_direct_le_ih(vi->vi_ih), 462 "vs-8110: " 463 "direct item length is %d. It can not be longer than %d", 464 current_item_size, max_node_size); 465 /* we will try to split it */ 466 flow = 1; 467 } 468 469 if (!flow) { 470 /* as we do not split items, take new node and continue */ 471 needed_nodes++; 472 i--; 473 total_node_size = 0; 474 continue; 475 } 476 // calculate number of item units which fit into node being 477 // filled 478 { 479 int free_space; 480 481 free_space = max_node_size - total_node_size - IH_SIZE; 482 units = 483 op_check_left(vi, free_space, start_bytes, 484 skip_from_end); 485 if (units == -1) { 486 /* nothing fits into current node, take new node and continue */ 487 needed_nodes++, i--, total_node_size = 0; 488 continue; 489 } 490 } 491 492 /* something fits into the current node */ 493 //if (snum012[3] != -1 || needed_nodes != 1) 494 // reiserfs_panic (tb->tb_sb, "vs-8115: get_num_ver: too many nodes required"); 495 //snum012[needed_nodes - 1 + 3] = op_unit_num (vi) - start_bytes - units; 496 start_bytes += units; 497 snum012[needed_nodes - 1 + 3] = units; 498 499 if (needed_nodes > 2) 500 reiserfs_warning(tb->tb_sb, "vs-8111", 501 "split_item_position is out of range"); 502 snum012[needed_nodes - 1]++; 503 split_item_positions[needed_nodes - 1] = i; 504 needed_nodes++; 505 /* continue from the same item with start_bytes != -1 */ 506 start_item = i; 507 i--; 508 total_node_size = 0; 509 } 510 511 // sum012[4] (if it is not -1) contains number of units of which 512 // are to be in S1new, snum012[3] - to be in S0. They are supposed 513 // to be S1bytes and S2bytes correspondingly, so recalculate 514 if (snum012[4] > 0) { 515 int split_item_num; 516 int bytes_to_r, bytes_to_l; 517 int bytes_to_S1new; 518 519 split_item_num = split_item_positions[1]; 520 bytes_to_l = 521 ((from == split_item_num 522 && from_bytes != -1) ? from_bytes : 0); 523 bytes_to_r = 524 ((end_item == split_item_num 525 && end_bytes != -1) ? end_bytes : 0); 526 bytes_to_S1new = 527 ((split_item_positions[0] == 528 split_item_positions[1]) ? snum012[3] : 0); 529 530 // s2bytes 531 snum012[4] = 532 op_unit_num(&vn->vn_vi[split_item_num]) - snum012[4] - 533 bytes_to_r - bytes_to_l - bytes_to_S1new; 534 535 if (vn->vn_vi[split_item_num].vi_index != TYPE_DIRENTRY && 536 vn->vn_vi[split_item_num].vi_index != TYPE_INDIRECT) 537 reiserfs_warning(tb->tb_sb, "vs-8115", 538 "not directory or indirect item"); 539 } 540 541 /* now we know S2bytes, calculate S1bytes */ 542 if (snum012[3] > 0) { 543 int split_item_num; 544 int bytes_to_r, bytes_to_l; 545 int bytes_to_S2new; 546 547 split_item_num = split_item_positions[0]; 548 bytes_to_l = 549 ((from == split_item_num 550 && from_bytes != -1) ? from_bytes : 0); 551 bytes_to_r = 552 ((end_item == split_item_num 553 && end_bytes != -1) ? end_bytes : 0); 554 bytes_to_S2new = 555 ((split_item_positions[0] == split_item_positions[1] 556 && snum012[4] != -1) ? snum012[4] : 0); 557 558 // s1bytes 559 snum012[3] = 560 op_unit_num(&vn->vn_vi[split_item_num]) - snum012[3] - 561 bytes_to_r - bytes_to_l - bytes_to_S2new; 562 } 563 564 return needed_nodes; 565 } 566 567 568 /* Set parameters for balancing. 569 * Performs write of results of analysis of balancing into structure tb, 570 * where it will later be used by the functions that actually do the balancing. 571 * Parameters: 572 * tb tree_balance structure; 573 * h current level of the node; 574 * lnum number of items from S[h] that must be shifted to L[h]; 575 * rnum number of items from S[h] that must be shifted to R[h]; 576 * blk_num number of blocks that S[h] will be splitted into; 577 * s012 number of items that fall into splitted nodes. 578 * lbytes number of bytes which flow to the left neighbor from the item that is not 579 * not shifted entirely 580 * rbytes number of bytes which flow to the right neighbor from the item that is not 581 * not shifted entirely 582 * s1bytes number of bytes which flow to the first new node when S[0] splits (this number is contained in s012 array) 583 */ 584 585 static void set_parameters(struct tree_balance *tb, int h, int lnum, 586 int rnum, int blk_num, short *s012, int lb, int rb) 587 { 588 589 tb->lnum[h] = lnum; 590 tb->rnum[h] = rnum; 591 tb->blknum[h] = blk_num; 592 593 if (h == 0) { /* only for leaf level */ 594 if (s012 != NULL) { 595 tb->s0num = *s012++, 596 tb->s1num = *s012++, tb->s2num = *s012++; 597 tb->s1bytes = *s012++; 598 tb->s2bytes = *s012; 599 } 600 tb->lbytes = lb; 601 tb->rbytes = rb; 602 } 603 PROC_INFO_ADD(tb->tb_sb, lnum[h], lnum); 604 PROC_INFO_ADD(tb->tb_sb, rnum[h], rnum); 605 606 PROC_INFO_ADD(tb->tb_sb, lbytes[h], lb); 607 PROC_INFO_ADD(tb->tb_sb, rbytes[h], rb); 608 } 609 610 /* check, does node disappear if we shift tb->lnum[0] items to left 611 neighbor and tb->rnum[0] to the right one. */ 612 static int is_leaf_removable(struct tree_balance *tb) 613 { 614 struct virtual_node *vn = tb->tb_vn; 615 int to_left, to_right; 616 int size; 617 int remain_items; 618 619 /* number of items, that will be shifted to left (right) neighbor 620 entirely */ 621 to_left = tb->lnum[0] - ((tb->lbytes != -1) ? 1 : 0); 622 to_right = tb->rnum[0] - ((tb->rbytes != -1) ? 1 : 0); 623 remain_items = vn->vn_nr_item; 624 625 /* how many items remain in S[0] after shiftings to neighbors */ 626 remain_items -= (to_left + to_right); 627 628 if (remain_items < 1) { 629 /* all content of node can be shifted to neighbors */ 630 set_parameters(tb, 0, to_left, vn->vn_nr_item - to_left, 0, 631 NULL, -1, -1); 632 return 1; 633 } 634 635 if (remain_items > 1 || tb->lbytes == -1 || tb->rbytes == -1) 636 /* S[0] is not removable */ 637 return 0; 638 639 /* check, whether we can divide 1 remaining item between neighbors */ 640 641 /* get size of remaining item (in item units) */ 642 size = op_unit_num(&(vn->vn_vi[to_left])); 643 644 if (tb->lbytes + tb->rbytes >= size) { 645 set_parameters(tb, 0, to_left + 1, to_right + 1, 0, NULL, 646 tb->lbytes, -1); 647 return 1; 648 } 649 650 return 0; 651 } 652 653 /* check whether L, S, R can be joined in one node */ 654 static int are_leaves_removable(struct tree_balance *tb, int lfree, int rfree) 655 { 656 struct virtual_node *vn = tb->tb_vn; 657 int ih_size; 658 struct buffer_head *S0; 659 660 S0 = PATH_H_PBUFFER(tb->tb_path, 0); 661 662 ih_size = 0; 663 if (vn->vn_nr_item) { 664 if (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE) 665 ih_size += IH_SIZE; 666 667 if (vn->vn_vi[vn->vn_nr_item - 1]. 668 vi_type & VI_TYPE_RIGHT_MERGEABLE) 669 ih_size += IH_SIZE; 670 } else { 671 /* there was only one item and it will be deleted */ 672 struct item_head *ih; 673 674 RFALSE(B_NR_ITEMS(S0) != 1, 675 "vs-8125: item number must be 1: it is %d", 676 B_NR_ITEMS(S0)); 677 678 ih = B_N_PITEM_HEAD(S0, 0); 679 if (tb->CFR[0] 680 && !comp_short_le_keys(&(ih->ih_key), 681 B_N_PDELIM_KEY(tb->CFR[0], 682 tb->rkey[0]))) 683 if (is_direntry_le_ih(ih)) { 684 /* Directory must be in correct state here: that is 685 somewhere at the left side should exist first directory 686 item. But the item being deleted can not be that first 687 one because its right neighbor is item of the same 688 directory. (But first item always gets deleted in last 689 turn). So, neighbors of deleted item can be merged, so 690 we can save ih_size */ 691 ih_size = IH_SIZE; 692 693 /* we might check that left neighbor exists and is of the 694 same directory */ 695 RFALSE(le_ih_k_offset(ih) == DOT_OFFSET, 696 "vs-8130: first directory item can not be removed until directory is not empty"); 697 } 698 699 } 700 701 if (MAX_CHILD_SIZE(S0) + vn->vn_size <= rfree + lfree + ih_size) { 702 set_parameters(tb, 0, -1, -1, -1, NULL, -1, -1); 703 PROC_INFO_INC(tb->tb_sb, leaves_removable); 704 return 1; 705 } 706 return 0; 707 708 } 709 710 /* when we do not split item, lnum and rnum are numbers of entire items */ 711 #define SET_PAR_SHIFT_LEFT \ 712 if (h)\ 713 {\ 714 int to_l;\ 715 \ 716 to_l = (MAX_NR_KEY(Sh)+1 - lpar + vn->vn_nr_item + 1) / 2 -\ 717 (MAX_NR_KEY(Sh) + 1 - lpar);\ 718 \ 719 set_parameters (tb, h, to_l, 0, lnver, NULL, -1, -1);\ 720 }\ 721 else \ 722 {\ 723 if (lset==LEFT_SHIFT_FLOW)\ 724 set_parameters (tb, h, lpar, 0, lnver, snum012+lset,\ 725 tb->lbytes, -1);\ 726 else\ 727 set_parameters (tb, h, lpar - (tb->lbytes!=-1), 0, lnver, snum012+lset,\ 728 -1, -1);\ 729 } 730 731 #define SET_PAR_SHIFT_RIGHT \ 732 if (h)\ 733 {\ 734 int to_r;\ 735 \ 736 to_r = (MAX_NR_KEY(Sh)+1 - rpar + vn->vn_nr_item + 1) / 2 - (MAX_NR_KEY(Sh) + 1 - rpar);\ 737 \ 738 set_parameters (tb, h, 0, to_r, rnver, NULL, -1, -1);\ 739 }\ 740 else \ 741 {\ 742 if (rset==RIGHT_SHIFT_FLOW)\ 743 set_parameters (tb, h, 0, rpar, rnver, snum012+rset,\ 744 -1, tb->rbytes);\ 745 else\ 746 set_parameters (tb, h, 0, rpar - (tb->rbytes!=-1), rnver, snum012+rset,\ 747 -1, -1);\ 748 } 749 750 static void free_buffers_in_tb(struct tree_balance *tb) 751 { 752 int i; 753 754 pathrelse(tb->tb_path); 755 756 for (i = 0; i < MAX_HEIGHT; i++) { 757 brelse(tb->L[i]); 758 brelse(tb->R[i]); 759 brelse(tb->FL[i]); 760 brelse(tb->FR[i]); 761 brelse(tb->CFL[i]); 762 brelse(tb->CFR[i]); 763 764 tb->L[i] = NULL; 765 tb->R[i] = NULL; 766 tb->FL[i] = NULL; 767 tb->FR[i] = NULL; 768 tb->CFL[i] = NULL; 769 tb->CFR[i] = NULL; 770 } 771 } 772 773 /* Get new buffers for storing new nodes that are created while balancing. 774 * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked; 775 * CARRY_ON - schedule didn't occur while the function worked; 776 * NO_DISK_SPACE - no disk space. 777 */ 778 /* The function is NOT SCHEDULE-SAFE! */ 779 static int get_empty_nodes(struct tree_balance *tb, int h) 780 { 781 struct buffer_head *new_bh, 782 *Sh = PATH_H_PBUFFER(tb->tb_path, h); 783 b_blocknr_t *blocknr, blocknrs[MAX_AMOUNT_NEEDED] = { 0, }; 784 int counter, number_of_freeblk, amount_needed, /* number of needed empty blocks */ 785 retval = CARRY_ON; 786 struct super_block *sb = tb->tb_sb; 787 788 /* number_of_freeblk is the number of empty blocks which have been 789 acquired for use by the balancing algorithm minus the number of 790 empty blocks used in the previous levels of the analysis, 791 number_of_freeblk = tb->cur_blknum can be non-zero if a schedule occurs 792 after empty blocks are acquired, and the balancing analysis is 793 then restarted, amount_needed is the number needed by this level 794 (h) of the balancing analysis. 795 796 Note that for systems with many processes writing, it would be 797 more layout optimal to calculate the total number needed by all 798 levels and then to run reiserfs_new_blocks to get all of them at once. */ 799 800 /* Initiate number_of_freeblk to the amount acquired prior to the restart of 801 the analysis or 0 if not restarted, then subtract the amount needed 802 by all of the levels of the tree below h. */ 803 /* blknum includes S[h], so we subtract 1 in this calculation */ 804 for (counter = 0, number_of_freeblk = tb->cur_blknum; 805 counter < h; counter++) 806 number_of_freeblk -= 807 (tb->blknum[counter]) ? (tb->blknum[counter] - 808 1) : 0; 809 810 /* Allocate missing empty blocks. */ 811 /* if Sh == 0 then we are getting a new root */ 812 amount_needed = (Sh) ? (tb->blknum[h] - 1) : 1; 813 /* Amount_needed = the amount that we need more than the amount that we have. */ 814 if (amount_needed > number_of_freeblk) 815 amount_needed -= number_of_freeblk; 816 else /* If we have enough already then there is nothing to do. */ 817 return CARRY_ON; 818 819 /* No need to check quota - is not allocated for blocks used for formatted nodes */ 820 if (reiserfs_new_form_blocknrs(tb, blocknrs, 821 amount_needed) == NO_DISK_SPACE) 822 return NO_DISK_SPACE; 823 824 /* for each blocknumber we just got, get a buffer and stick it on FEB */ 825 for (blocknr = blocknrs, counter = 0; 826 counter < amount_needed; blocknr++, counter++) { 827 828 RFALSE(!*blocknr, 829 "PAP-8135: reiserfs_new_blocknrs failed when got new blocks"); 830 831 new_bh = sb_getblk(sb, *blocknr); 832 RFALSE(buffer_dirty(new_bh) || 833 buffer_journaled(new_bh) || 834 buffer_journal_dirty(new_bh), 835 "PAP-8140: journaled or dirty buffer %b for the new block", 836 new_bh); 837 838 /* Put empty buffers into the array. */ 839 RFALSE(tb->FEB[tb->cur_blknum], 840 "PAP-8141: busy slot for new buffer"); 841 842 set_buffer_journal_new(new_bh); 843 tb->FEB[tb->cur_blknum++] = new_bh; 844 } 845 846 if (retval == CARRY_ON && FILESYSTEM_CHANGED_TB(tb)) 847 retval = REPEAT_SEARCH; 848 849 return retval; 850 } 851 852 /* Get free space of the left neighbor, which is stored in the parent 853 * node of the left neighbor. */ 854 static int get_lfree(struct tree_balance *tb, int h) 855 { 856 struct buffer_head *l, *f; 857 int order; 858 859 if ((f = PATH_H_PPARENT(tb->tb_path, h)) == NULL || 860 (l = tb->FL[h]) == NULL) 861 return 0; 862 863 if (f == l) 864 order = PATH_H_B_ITEM_ORDER(tb->tb_path, h) - 1; 865 else { 866 order = B_NR_ITEMS(l); 867 f = l; 868 } 869 870 return (MAX_CHILD_SIZE(f) - dc_size(B_N_CHILD(f, order))); 871 } 872 873 /* Get free space of the right neighbor, 874 * which is stored in the parent node of the right neighbor. 875 */ 876 static int get_rfree(struct tree_balance *tb, int h) 877 { 878 struct buffer_head *r, *f; 879 int order; 880 881 if ((f = PATH_H_PPARENT(tb->tb_path, h)) == NULL || 882 (r = tb->FR[h]) == NULL) 883 return 0; 884 885 if (f == r) 886 order = PATH_H_B_ITEM_ORDER(tb->tb_path, h) + 1; 887 else { 888 order = 0; 889 f = r; 890 } 891 892 return (MAX_CHILD_SIZE(f) - dc_size(B_N_CHILD(f, order))); 893 894 } 895 896 /* Check whether left neighbor is in memory. */ 897 static int is_left_neighbor_in_cache(struct tree_balance *tb, int h) 898 { 899 struct buffer_head *father, *left; 900 struct super_block *sb = tb->tb_sb; 901 b_blocknr_t left_neighbor_blocknr; 902 int left_neighbor_position; 903 904 /* Father of the left neighbor does not exist. */ 905 if (!tb->FL[h]) 906 return 0; 907 908 /* Calculate father of the node to be balanced. */ 909 father = PATH_H_PBUFFER(tb->tb_path, h + 1); 910 911 RFALSE(!father || 912 !B_IS_IN_TREE(father) || 913 !B_IS_IN_TREE(tb->FL[h]) || 914 !buffer_uptodate(father) || 915 !buffer_uptodate(tb->FL[h]), 916 "vs-8165: F[h] (%b) or FL[h] (%b) is invalid", 917 father, tb->FL[h]); 918 919 /* Get position of the pointer to the left neighbor into the left father. */ 920 left_neighbor_position = (father == tb->FL[h]) ? 921 tb->lkey[h] : B_NR_ITEMS(tb->FL[h]); 922 /* Get left neighbor block number. */ 923 left_neighbor_blocknr = 924 B_N_CHILD_NUM(tb->FL[h], left_neighbor_position); 925 /* Look for the left neighbor in the cache. */ 926 if ((left = sb_find_get_block(sb, left_neighbor_blocknr))) { 927 928 RFALSE(buffer_uptodate(left) && !B_IS_IN_TREE(left), 929 "vs-8170: left neighbor (%b %z) is not in the tree", 930 left, left); 931 put_bh(left); 932 return 1; 933 } 934 935 return 0; 936 } 937 938 #define LEFT_PARENTS 'l' 939 #define RIGHT_PARENTS 'r' 940 941 static void decrement_key(struct cpu_key *key) 942 { 943 // call item specific function for this key 944 item_ops[cpu_key_k_type(key)]->decrement_key(key); 945 } 946 947 /* Calculate far left/right parent of the left/right neighbor of the current node, that 948 * is calculate the left/right (FL[h]/FR[h]) neighbor of the parent F[h]. 949 * Calculate left/right common parent of the current node and L[h]/R[h]. 950 * Calculate left/right delimiting key position. 951 * Returns: PATH_INCORRECT - path in the tree is not correct; 952 SCHEDULE_OCCURRED - schedule occurred while the function worked; 953 * CARRY_ON - schedule didn't occur while the function worked; 954 */ 955 static int get_far_parent(struct tree_balance *tb, 956 int h, 957 struct buffer_head **pfather, 958 struct buffer_head **pcom_father, char c_lr_par) 959 { 960 struct buffer_head *parent; 961 INITIALIZE_PATH(s_path_to_neighbor_father); 962 struct treepath *path = tb->tb_path; 963 struct cpu_key s_lr_father_key; 964 int counter, 965 position = INT_MAX, 966 first_last_position = 0, 967 path_offset = PATH_H_PATH_OFFSET(path, h); 968 969 /* Starting from F[h] go upwards in the tree, and look for the common 970 ancestor of F[h], and its neighbor l/r, that should be obtained. */ 971 972 counter = path_offset; 973 974 RFALSE(counter < FIRST_PATH_ELEMENT_OFFSET, 975 "PAP-8180: invalid path length"); 976 977 for (; counter > FIRST_PATH_ELEMENT_OFFSET; counter--) { 978 /* Check whether parent of the current buffer in the path is really parent in the tree. */ 979 if (!B_IS_IN_TREE 980 (parent = PATH_OFFSET_PBUFFER(path, counter - 1))) 981 return REPEAT_SEARCH; 982 /* Check whether position in the parent is correct. */ 983 if ((position = 984 PATH_OFFSET_POSITION(path, 985 counter - 1)) > 986 B_NR_ITEMS(parent)) 987 return REPEAT_SEARCH; 988 /* Check whether parent at the path really points to the child. */ 989 if (B_N_CHILD_NUM(parent, position) != 990 PATH_OFFSET_PBUFFER(path, counter)->b_blocknr) 991 return REPEAT_SEARCH; 992 /* Return delimiting key if position in the parent is not equal to first/last one. */ 993 if (c_lr_par == RIGHT_PARENTS) 994 first_last_position = B_NR_ITEMS(parent); 995 if (position != first_last_position) { 996 *pcom_father = parent; 997 get_bh(*pcom_father); 998 /*(*pcom_father = parent)->b_count++; */ 999 break; 1000 } 1001 } 1002 1003 /* if we are in the root of the tree, then there is no common father */ 1004 if (counter == FIRST_PATH_ELEMENT_OFFSET) { 1005 /* Check whether first buffer in the path is the root of the tree. */ 1006 if (PATH_OFFSET_PBUFFER 1007 (tb->tb_path, 1008 FIRST_PATH_ELEMENT_OFFSET)->b_blocknr == 1009 SB_ROOT_BLOCK(tb->tb_sb)) { 1010 *pfather = *pcom_father = NULL; 1011 return CARRY_ON; 1012 } 1013 return REPEAT_SEARCH; 1014 } 1015 1016 RFALSE(B_LEVEL(*pcom_father) <= DISK_LEAF_NODE_LEVEL, 1017 "PAP-8185: (%b %z) level too small", 1018 *pcom_father, *pcom_father); 1019 1020 /* Check whether the common parent is locked. */ 1021 1022 if (buffer_locked(*pcom_father)) { 1023 1024 /* Release the write lock while the buffer is busy */ 1025 reiserfs_write_unlock(tb->tb_sb); 1026 __wait_on_buffer(*pcom_father); 1027 reiserfs_write_lock(tb->tb_sb); 1028 if (FILESYSTEM_CHANGED_TB(tb)) { 1029 brelse(*pcom_father); 1030 return REPEAT_SEARCH; 1031 } 1032 } 1033 1034 /* So, we got common parent of the current node and its left/right neighbor. 1035 Now we are geting the parent of the left/right neighbor. */ 1036 1037 /* Form key to get parent of the left/right neighbor. */ 1038 le_key2cpu_key(&s_lr_father_key, 1039 B_N_PDELIM_KEY(*pcom_father, 1040 (c_lr_par == 1041 LEFT_PARENTS) ? (tb->lkey[h - 1] = 1042 position - 1043 1) : (tb->rkey[h - 1044 1] = 1045 position))); 1046 1047 if (c_lr_par == LEFT_PARENTS) 1048 decrement_key(&s_lr_father_key); 1049 1050 if (search_by_key 1051 (tb->tb_sb, &s_lr_father_key, &s_path_to_neighbor_father, 1052 h + 1) == IO_ERROR) 1053 // path is released 1054 return IO_ERROR; 1055 1056 if (FILESYSTEM_CHANGED_TB(tb)) { 1057 pathrelse(&s_path_to_neighbor_father); 1058 brelse(*pcom_father); 1059 return REPEAT_SEARCH; 1060 } 1061 1062 *pfather = PATH_PLAST_BUFFER(&s_path_to_neighbor_father); 1063 1064 RFALSE(B_LEVEL(*pfather) != h + 1, 1065 "PAP-8190: (%b %z) level too small", *pfather, *pfather); 1066 RFALSE(s_path_to_neighbor_father.path_length < 1067 FIRST_PATH_ELEMENT_OFFSET, "PAP-8192: path length is too small"); 1068 1069 s_path_to_neighbor_father.path_length--; 1070 pathrelse(&s_path_to_neighbor_father); 1071 return CARRY_ON; 1072 } 1073 1074 /* Get parents of neighbors of node in the path(S[path_offset]) and common parents of 1075 * S[path_offset] and L[path_offset]/R[path_offset]: F[path_offset], FL[path_offset], 1076 * FR[path_offset], CFL[path_offset], CFR[path_offset]. 1077 * Calculate numbers of left and right delimiting keys position: lkey[path_offset], rkey[path_offset]. 1078 * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked; 1079 * CARRY_ON - schedule didn't occur while the function worked; 1080 */ 1081 static int get_parents(struct tree_balance *tb, int h) 1082 { 1083 struct treepath *path = tb->tb_path; 1084 int position, 1085 ret, 1086 path_offset = PATH_H_PATH_OFFSET(tb->tb_path, h); 1087 struct buffer_head *curf, *curcf; 1088 1089 /* Current node is the root of the tree or will be root of the tree */ 1090 if (path_offset <= FIRST_PATH_ELEMENT_OFFSET) { 1091 /* The root can not have parents. 1092 Release nodes which previously were obtained as parents of the current node neighbors. */ 1093 brelse(tb->FL[h]); 1094 brelse(tb->CFL[h]); 1095 brelse(tb->FR[h]); 1096 brelse(tb->CFR[h]); 1097 tb->FL[h] = NULL; 1098 tb->CFL[h] = NULL; 1099 tb->FR[h] = NULL; 1100 tb->CFR[h] = NULL; 1101 return CARRY_ON; 1102 } 1103 1104 /* Get parent FL[path_offset] of L[path_offset]. */ 1105 position = PATH_OFFSET_POSITION(path, path_offset - 1); 1106 if (position) { 1107 /* Current node is not the first child of its parent. */ 1108 curf = PATH_OFFSET_PBUFFER(path, path_offset - 1); 1109 curcf = PATH_OFFSET_PBUFFER(path, path_offset - 1); 1110 get_bh(curf); 1111 get_bh(curf); 1112 tb->lkey[h] = position - 1; 1113 } else { 1114 /* Calculate current parent of L[path_offset], which is the left neighbor of the current node. 1115 Calculate current common parent of L[path_offset] and the current node. Note that 1116 CFL[path_offset] not equal FL[path_offset] and CFL[path_offset] not equal F[path_offset]. 1117 Calculate lkey[path_offset]. */ 1118 if ((ret = get_far_parent(tb, h + 1, &curf, 1119 &curcf, 1120 LEFT_PARENTS)) != CARRY_ON) 1121 return ret; 1122 } 1123 1124 brelse(tb->FL[h]); 1125 tb->FL[h] = curf; /* New initialization of FL[h]. */ 1126 brelse(tb->CFL[h]); 1127 tb->CFL[h] = curcf; /* New initialization of CFL[h]. */ 1128 1129 RFALSE((curf && !B_IS_IN_TREE(curf)) || 1130 (curcf && !B_IS_IN_TREE(curcf)), 1131 "PAP-8195: FL (%b) or CFL (%b) is invalid", curf, curcf); 1132 1133 /* Get parent FR[h] of R[h]. */ 1134 1135 /* Current node is the last child of F[h]. FR[h] != F[h]. */ 1136 if (position == B_NR_ITEMS(PATH_H_PBUFFER(path, h + 1))) { 1137 /* Calculate current parent of R[h], which is the right neighbor of F[h]. 1138 Calculate current common parent of R[h] and current node. Note that CFR[h] 1139 not equal FR[path_offset] and CFR[h] not equal F[h]. */ 1140 if ((ret = 1141 get_far_parent(tb, h + 1, &curf, &curcf, 1142 RIGHT_PARENTS)) != CARRY_ON) 1143 return ret; 1144 } else { 1145 /* Current node is not the last child of its parent F[h]. */ 1146 curf = PATH_OFFSET_PBUFFER(path, path_offset - 1); 1147 curcf = PATH_OFFSET_PBUFFER(path, path_offset - 1); 1148 get_bh(curf); 1149 get_bh(curf); 1150 tb->rkey[h] = position; 1151 } 1152 1153 brelse(tb->FR[h]); 1154 /* New initialization of FR[path_offset]. */ 1155 tb->FR[h] = curf; 1156 1157 brelse(tb->CFR[h]); 1158 /* New initialization of CFR[path_offset]. */ 1159 tb->CFR[h] = curcf; 1160 1161 RFALSE((curf && !B_IS_IN_TREE(curf)) || 1162 (curcf && !B_IS_IN_TREE(curcf)), 1163 "PAP-8205: FR (%b) or CFR (%b) is invalid", curf, curcf); 1164 1165 return CARRY_ON; 1166 } 1167 1168 /* it is possible to remove node as result of shiftings to 1169 neighbors even when we insert or paste item. */ 1170 static inline int can_node_be_removed(int mode, int lfree, int sfree, int rfree, 1171 struct tree_balance *tb, int h) 1172 { 1173 struct buffer_head *Sh = PATH_H_PBUFFER(tb->tb_path, h); 1174 int levbytes = tb->insert_size[h]; 1175 struct item_head *ih; 1176 struct reiserfs_key *r_key = NULL; 1177 1178 ih = B_N_PITEM_HEAD(Sh, 0); 1179 if (tb->CFR[h]) 1180 r_key = B_N_PDELIM_KEY(tb->CFR[h], tb->rkey[h]); 1181 1182 if (lfree + rfree + sfree < MAX_CHILD_SIZE(Sh) + levbytes 1183 /* shifting may merge items which might save space */ 1184 - 1185 ((!h 1186 && op_is_left_mergeable(&(ih->ih_key), Sh->b_size)) ? IH_SIZE : 0) 1187 - 1188 ((!h && r_key 1189 && op_is_left_mergeable(r_key, Sh->b_size)) ? IH_SIZE : 0) 1190 + ((h) ? KEY_SIZE : 0)) { 1191 /* node can not be removed */ 1192 if (sfree >= levbytes) { /* new item fits into node S[h] without any shifting */ 1193 if (!h) 1194 tb->s0num = 1195 B_NR_ITEMS(Sh) + 1196 ((mode == M_INSERT) ? 1 : 0); 1197 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1198 return NO_BALANCING_NEEDED; 1199 } 1200 } 1201 PROC_INFO_INC(tb->tb_sb, can_node_be_removed[h]); 1202 return !NO_BALANCING_NEEDED; 1203 } 1204 1205 /* Check whether current node S[h] is balanced when increasing its size by 1206 * Inserting or Pasting. 1207 * Calculate parameters for balancing for current level h. 1208 * Parameters: 1209 * tb tree_balance structure; 1210 * h current level of the node; 1211 * inum item number in S[h]; 1212 * mode i - insert, p - paste; 1213 * Returns: 1 - schedule occurred; 1214 * 0 - balancing for higher levels needed; 1215 * -1 - no balancing for higher levels needed; 1216 * -2 - no disk space. 1217 */ 1218 /* ip means Inserting or Pasting */ 1219 static int ip_check_balance(struct tree_balance *tb, int h) 1220 { 1221 struct virtual_node *vn = tb->tb_vn; 1222 int levbytes, /* Number of bytes that must be inserted into (value 1223 is negative if bytes are deleted) buffer which 1224 contains node being balanced. The mnemonic is 1225 that the attempted change in node space used level 1226 is levbytes bytes. */ 1227 ret; 1228 1229 int lfree, sfree, rfree /* free space in L, S and R */ ; 1230 1231 /* nver is short for number of vertixes, and lnver is the number if 1232 we shift to the left, rnver is the number if we shift to the 1233 right, and lrnver is the number if we shift in both directions. 1234 The goal is to minimize first the number of vertixes, and second, 1235 the number of vertixes whose contents are changed by shifting, 1236 and third the number of uncached vertixes whose contents are 1237 changed by shifting and must be read from disk. */ 1238 int nver, lnver, rnver, lrnver; 1239 1240 /* used at leaf level only, S0 = S[0] is the node being balanced, 1241 sInum [ I = 0,1,2 ] is the number of items that will 1242 remain in node SI after balancing. S1 and S2 are new 1243 nodes that might be created. */ 1244 1245 /* we perform 8 calls to get_num_ver(). For each call we calculate five parameters. 1246 where 4th parameter is s1bytes and 5th - s2bytes 1247 */ 1248 short snum012[40] = { 0, }; /* s0num, s1num, s2num for 8 cases 1249 0,1 - do not shift and do not shift but bottle 1250 2 - shift only whole item to left 1251 3 - shift to left and bottle as much as possible 1252 4,5 - shift to right (whole items and as much as possible 1253 6,7 - shift to both directions (whole items and as much as possible) 1254 */ 1255 1256 /* Sh is the node whose balance is currently being checked */ 1257 struct buffer_head *Sh; 1258 1259 Sh = PATH_H_PBUFFER(tb->tb_path, h); 1260 levbytes = tb->insert_size[h]; 1261 1262 /* Calculate balance parameters for creating new root. */ 1263 if (!Sh) { 1264 if (!h) 1265 reiserfs_panic(tb->tb_sb, "vs-8210", 1266 "S[0] can not be 0"); 1267 switch (ret = get_empty_nodes(tb, h)) { 1268 case CARRY_ON: 1269 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1270 return NO_BALANCING_NEEDED; /* no balancing for higher levels needed */ 1271 1272 case NO_DISK_SPACE: 1273 case REPEAT_SEARCH: 1274 return ret; 1275 default: 1276 reiserfs_panic(tb->tb_sb, "vs-8215", "incorrect " 1277 "return value of get_empty_nodes"); 1278 } 1279 } 1280 1281 if ((ret = get_parents(tb, h)) != CARRY_ON) /* get parents of S[h] neighbors. */ 1282 return ret; 1283 1284 sfree = B_FREE_SPACE(Sh); 1285 1286 /* get free space of neighbors */ 1287 rfree = get_rfree(tb, h); 1288 lfree = get_lfree(tb, h); 1289 1290 if (can_node_be_removed(vn->vn_mode, lfree, sfree, rfree, tb, h) == 1291 NO_BALANCING_NEEDED) 1292 /* and new item fits into node S[h] without any shifting */ 1293 return NO_BALANCING_NEEDED; 1294 1295 create_virtual_node(tb, h); 1296 1297 /* 1298 determine maximal number of items we can shift to the left neighbor (in tb structure) 1299 and the maximal number of bytes that can flow to the left neighbor 1300 from the left most liquid item that cannot be shifted from S[0] entirely (returned value) 1301 */ 1302 check_left(tb, h, lfree); 1303 1304 /* 1305 determine maximal number of items we can shift to the right neighbor (in tb structure) 1306 and the maximal number of bytes that can flow to the right neighbor 1307 from the right most liquid item that cannot be shifted from S[0] entirely (returned value) 1308 */ 1309 check_right(tb, h, rfree); 1310 1311 /* all contents of internal node S[h] can be moved into its 1312 neighbors, S[h] will be removed after balancing */ 1313 if (h && (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1)) { 1314 int to_r; 1315 1316 /* Since we are working on internal nodes, and our internal 1317 nodes have fixed size entries, then we can balance by the 1318 number of items rather than the space they consume. In this 1319 routine we set the left node equal to the right node, 1320 allowing a difference of less than or equal to 1 child 1321 pointer. */ 1322 to_r = 1323 ((MAX_NR_KEY(Sh) << 1) + 2 - tb->lnum[h] - tb->rnum[h] + 1324 vn->vn_nr_item + 1) / 2 - (MAX_NR_KEY(Sh) + 1 - 1325 tb->rnum[h]); 1326 set_parameters(tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL, 1327 -1, -1); 1328 return CARRY_ON; 1329 } 1330 1331 /* this checks balance condition, that any two neighboring nodes can not fit in one node */ 1332 RFALSE(h && 1333 (tb->lnum[h] >= vn->vn_nr_item + 1 || 1334 tb->rnum[h] >= vn->vn_nr_item + 1), 1335 "vs-8220: tree is not balanced on internal level"); 1336 RFALSE(!h && ((tb->lnum[h] >= vn->vn_nr_item && (tb->lbytes == -1)) || 1337 (tb->rnum[h] >= vn->vn_nr_item && (tb->rbytes == -1))), 1338 "vs-8225: tree is not balanced on leaf level"); 1339 1340 /* all contents of S[0] can be moved into its neighbors 1341 S[0] will be removed after balancing. */ 1342 if (!h && is_leaf_removable(tb)) 1343 return CARRY_ON; 1344 1345 /* why do we perform this check here rather than earlier?? 1346 Answer: we can win 1 node in some cases above. Moreover we 1347 checked it above, when we checked, that S[0] is not removable 1348 in principle */ 1349 if (sfree >= levbytes) { /* new item fits into node S[h] without any shifting */ 1350 if (!h) 1351 tb->s0num = vn->vn_nr_item; 1352 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1353 return NO_BALANCING_NEEDED; 1354 } 1355 1356 { 1357 int lpar, rpar, nset, lset, rset, lrset; 1358 /* 1359 * regular overflowing of the node 1360 */ 1361 1362 /* get_num_ver works in 2 modes (FLOW & NO_FLOW) 1363 lpar, rpar - number of items we can shift to left/right neighbor (including splitting item) 1364 nset, lset, rset, lrset - shows, whether flowing items give better packing 1365 */ 1366 #define FLOW 1 1367 #define NO_FLOW 0 /* do not any splitting */ 1368 1369 /* we choose one the following */ 1370 #define NOTHING_SHIFT_NO_FLOW 0 1371 #define NOTHING_SHIFT_FLOW 5 1372 #define LEFT_SHIFT_NO_FLOW 10 1373 #define LEFT_SHIFT_FLOW 15 1374 #define RIGHT_SHIFT_NO_FLOW 20 1375 #define RIGHT_SHIFT_FLOW 25 1376 #define LR_SHIFT_NO_FLOW 30 1377 #define LR_SHIFT_FLOW 35 1378 1379 lpar = tb->lnum[h]; 1380 rpar = tb->rnum[h]; 1381 1382 /* calculate number of blocks S[h] must be split into when 1383 nothing is shifted to the neighbors, 1384 as well as number of items in each part of the split node (s012 numbers), 1385 and number of bytes (s1bytes) of the shared drop which flow to S1 if any */ 1386 nset = NOTHING_SHIFT_NO_FLOW; 1387 nver = get_num_ver(vn->vn_mode, tb, h, 1388 0, -1, h ? vn->vn_nr_item : 0, -1, 1389 snum012, NO_FLOW); 1390 1391 if (!h) { 1392 int nver1; 1393 1394 /* note, that in this case we try to bottle between S[0] and S1 (S1 - the first new node) */ 1395 nver1 = get_num_ver(vn->vn_mode, tb, h, 1396 0, -1, 0, -1, 1397 snum012 + NOTHING_SHIFT_FLOW, FLOW); 1398 if (nver > nver1) 1399 nset = NOTHING_SHIFT_FLOW, nver = nver1; 1400 } 1401 1402 /* calculate number of blocks S[h] must be split into when 1403 l_shift_num first items and l_shift_bytes of the right most 1404 liquid item to be shifted are shifted to the left neighbor, 1405 as well as number of items in each part of the splitted node (s012 numbers), 1406 and number of bytes (s1bytes) of the shared drop which flow to S1 if any 1407 */ 1408 lset = LEFT_SHIFT_NO_FLOW; 1409 lnver = get_num_ver(vn->vn_mode, tb, h, 1410 lpar - ((h || tb->lbytes == -1) ? 0 : 1), 1411 -1, h ? vn->vn_nr_item : 0, -1, 1412 snum012 + LEFT_SHIFT_NO_FLOW, NO_FLOW); 1413 if (!h) { 1414 int lnver1; 1415 1416 lnver1 = get_num_ver(vn->vn_mode, tb, h, 1417 lpar - 1418 ((tb->lbytes != -1) ? 1 : 0), 1419 tb->lbytes, 0, -1, 1420 snum012 + LEFT_SHIFT_FLOW, FLOW); 1421 if (lnver > lnver1) 1422 lset = LEFT_SHIFT_FLOW, lnver = lnver1; 1423 } 1424 1425 /* calculate number of blocks S[h] must be split into when 1426 r_shift_num first items and r_shift_bytes of the left most 1427 liquid item to be shifted are shifted to the right neighbor, 1428 as well as number of items in each part of the splitted node (s012 numbers), 1429 and number of bytes (s1bytes) of the shared drop which flow to S1 if any 1430 */ 1431 rset = RIGHT_SHIFT_NO_FLOW; 1432 rnver = get_num_ver(vn->vn_mode, tb, h, 1433 0, -1, 1434 h ? (vn->vn_nr_item - rpar) : (rpar - 1435 ((tb-> 1436 rbytes != 1437 -1) ? 1 : 1438 0)), -1, 1439 snum012 + RIGHT_SHIFT_NO_FLOW, NO_FLOW); 1440 if (!h) { 1441 int rnver1; 1442 1443 rnver1 = get_num_ver(vn->vn_mode, tb, h, 1444 0, -1, 1445 (rpar - 1446 ((tb->rbytes != -1) ? 1 : 0)), 1447 tb->rbytes, 1448 snum012 + RIGHT_SHIFT_FLOW, FLOW); 1449 1450 if (rnver > rnver1) 1451 rset = RIGHT_SHIFT_FLOW, rnver = rnver1; 1452 } 1453 1454 /* calculate number of blocks S[h] must be split into when 1455 items are shifted in both directions, 1456 as well as number of items in each part of the splitted node (s012 numbers), 1457 and number of bytes (s1bytes) of the shared drop which flow to S1 if any 1458 */ 1459 lrset = LR_SHIFT_NO_FLOW; 1460 lrnver = get_num_ver(vn->vn_mode, tb, h, 1461 lpar - ((h || tb->lbytes == -1) ? 0 : 1), 1462 -1, 1463 h ? (vn->vn_nr_item - rpar) : (rpar - 1464 ((tb-> 1465 rbytes != 1466 -1) ? 1 : 1467 0)), -1, 1468 snum012 + LR_SHIFT_NO_FLOW, NO_FLOW); 1469 if (!h) { 1470 int lrnver1; 1471 1472 lrnver1 = get_num_ver(vn->vn_mode, tb, h, 1473 lpar - 1474 ((tb->lbytes != -1) ? 1 : 0), 1475 tb->lbytes, 1476 (rpar - 1477 ((tb->rbytes != -1) ? 1 : 0)), 1478 tb->rbytes, 1479 snum012 + LR_SHIFT_FLOW, FLOW); 1480 if (lrnver > lrnver1) 1481 lrset = LR_SHIFT_FLOW, lrnver = lrnver1; 1482 } 1483 1484 /* Our general shifting strategy is: 1485 1) to minimized number of new nodes; 1486 2) to minimized number of neighbors involved in shifting; 1487 3) to minimized number of disk reads; */ 1488 1489 /* we can win TWO or ONE nodes by shifting in both directions */ 1490 if (lrnver < lnver && lrnver < rnver) { 1491 RFALSE(h && 1492 (tb->lnum[h] != 1 || 1493 tb->rnum[h] != 1 || 1494 lrnver != 1 || rnver != 2 || lnver != 2 1495 || h != 1), "vs-8230: bad h"); 1496 if (lrset == LR_SHIFT_FLOW) 1497 set_parameters(tb, h, tb->lnum[h], tb->rnum[h], 1498 lrnver, snum012 + lrset, 1499 tb->lbytes, tb->rbytes); 1500 else 1501 set_parameters(tb, h, 1502 tb->lnum[h] - 1503 ((tb->lbytes == -1) ? 0 : 1), 1504 tb->rnum[h] - 1505 ((tb->rbytes == -1) ? 0 : 1), 1506 lrnver, snum012 + lrset, -1, -1); 1507 1508 return CARRY_ON; 1509 } 1510 1511 /* if shifting doesn't lead to better packing then don't shift */ 1512 if (nver == lrnver) { 1513 set_parameters(tb, h, 0, 0, nver, snum012 + nset, -1, 1514 -1); 1515 return CARRY_ON; 1516 } 1517 1518 /* now we know that for better packing shifting in only one 1519 direction either to the left or to the right is required */ 1520 1521 /* if shifting to the left is better than shifting to the right */ 1522 if (lnver < rnver) { 1523 SET_PAR_SHIFT_LEFT; 1524 return CARRY_ON; 1525 } 1526 1527 /* if shifting to the right is better than shifting to the left */ 1528 if (lnver > rnver) { 1529 SET_PAR_SHIFT_RIGHT; 1530 return CARRY_ON; 1531 } 1532 1533 /* now shifting in either direction gives the same number 1534 of nodes and we can make use of the cached neighbors */ 1535 if (is_left_neighbor_in_cache(tb, h)) { 1536 SET_PAR_SHIFT_LEFT; 1537 return CARRY_ON; 1538 } 1539 1540 /* shift to the right independently on whether the right neighbor in cache or not */ 1541 SET_PAR_SHIFT_RIGHT; 1542 return CARRY_ON; 1543 } 1544 } 1545 1546 /* Check whether current node S[h] is balanced when Decreasing its size by 1547 * Deleting or Cutting for INTERNAL node of S+tree. 1548 * Calculate parameters for balancing for current level h. 1549 * Parameters: 1550 * tb tree_balance structure; 1551 * h current level of the node; 1552 * inum item number in S[h]; 1553 * mode i - insert, p - paste; 1554 * Returns: 1 - schedule occurred; 1555 * 0 - balancing for higher levels needed; 1556 * -1 - no balancing for higher levels needed; 1557 * -2 - no disk space. 1558 * 1559 * Note: Items of internal nodes have fixed size, so the balance condition for 1560 * the internal part of S+tree is as for the B-trees. 1561 */ 1562 static int dc_check_balance_internal(struct tree_balance *tb, int h) 1563 { 1564 struct virtual_node *vn = tb->tb_vn; 1565 1566 /* Sh is the node whose balance is currently being checked, 1567 and Fh is its father. */ 1568 struct buffer_head *Sh, *Fh; 1569 int maxsize, ret; 1570 int lfree, rfree /* free space in L and R */ ; 1571 1572 Sh = PATH_H_PBUFFER(tb->tb_path, h); 1573 Fh = PATH_H_PPARENT(tb->tb_path, h); 1574 1575 maxsize = MAX_CHILD_SIZE(Sh); 1576 1577 /* using tb->insert_size[h], which is negative in this case, create_virtual_node calculates: */ 1578 /* new_nr_item = number of items node would have if operation is */ 1579 /* performed without balancing (new_nr_item); */ 1580 create_virtual_node(tb, h); 1581 1582 if (!Fh) { /* S[h] is the root. */ 1583 if (vn->vn_nr_item > 0) { 1584 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1585 return NO_BALANCING_NEEDED; /* no balancing for higher levels needed */ 1586 } 1587 /* new_nr_item == 0. 1588 * Current root will be deleted resulting in 1589 * decrementing the tree height. */ 1590 set_parameters(tb, h, 0, 0, 0, NULL, -1, -1); 1591 return CARRY_ON; 1592 } 1593 1594 if ((ret = get_parents(tb, h)) != CARRY_ON) 1595 return ret; 1596 1597 /* get free space of neighbors */ 1598 rfree = get_rfree(tb, h); 1599 lfree = get_lfree(tb, h); 1600 1601 /* determine maximal number of items we can fit into neighbors */ 1602 check_left(tb, h, lfree); 1603 check_right(tb, h, rfree); 1604 1605 if (vn->vn_nr_item >= MIN_NR_KEY(Sh)) { /* Balance condition for the internal node is valid. 1606 * In this case we balance only if it leads to better packing. */ 1607 if (vn->vn_nr_item == MIN_NR_KEY(Sh)) { /* Here we join S[h] with one of its neighbors, 1608 * which is impossible with greater values of new_nr_item. */ 1609 if (tb->lnum[h] >= vn->vn_nr_item + 1) { 1610 /* All contents of S[h] can be moved to L[h]. */ 1611 int n; 1612 int order_L; 1613 1614 order_L = 1615 ((n = 1616 PATH_H_B_ITEM_ORDER(tb->tb_path, 1617 h)) == 1618 0) ? B_NR_ITEMS(tb->FL[h]) : n - 1; 1619 n = dc_size(B_N_CHILD(tb->FL[h], order_L)) / 1620 (DC_SIZE + KEY_SIZE); 1621 set_parameters(tb, h, -n - 1, 0, 0, NULL, -1, 1622 -1); 1623 return CARRY_ON; 1624 } 1625 1626 if (tb->rnum[h] >= vn->vn_nr_item + 1) { 1627 /* All contents of S[h] can be moved to R[h]. */ 1628 int n; 1629 int order_R; 1630 1631 order_R = 1632 ((n = 1633 PATH_H_B_ITEM_ORDER(tb->tb_path, 1634 h)) == 1635 B_NR_ITEMS(Fh)) ? 0 : n + 1; 1636 n = dc_size(B_N_CHILD(tb->FR[h], order_R)) / 1637 (DC_SIZE + KEY_SIZE); 1638 set_parameters(tb, h, 0, -n - 1, 0, NULL, -1, 1639 -1); 1640 return CARRY_ON; 1641 } 1642 } 1643 1644 if (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1) { 1645 /* All contents of S[h] can be moved to the neighbors (L[h] & R[h]). */ 1646 int to_r; 1647 1648 to_r = 1649 ((MAX_NR_KEY(Sh) << 1) + 2 - tb->lnum[h] - 1650 tb->rnum[h] + vn->vn_nr_item + 1) / 2 - 1651 (MAX_NR_KEY(Sh) + 1 - tb->rnum[h]); 1652 set_parameters(tb, h, vn->vn_nr_item + 1 - to_r, to_r, 1653 0, NULL, -1, -1); 1654 return CARRY_ON; 1655 } 1656 1657 /* Balancing does not lead to better packing. */ 1658 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1659 return NO_BALANCING_NEEDED; 1660 } 1661 1662 /* Current node contain insufficient number of items. Balancing is required. */ 1663 /* Check whether we can merge S[h] with left neighbor. */ 1664 if (tb->lnum[h] >= vn->vn_nr_item + 1) 1665 if (is_left_neighbor_in_cache(tb, h) 1666 || tb->rnum[h] < vn->vn_nr_item + 1 || !tb->FR[h]) { 1667 int n; 1668 int order_L; 1669 1670 order_L = 1671 ((n = 1672 PATH_H_B_ITEM_ORDER(tb->tb_path, 1673 h)) == 1674 0) ? B_NR_ITEMS(tb->FL[h]) : n - 1; 1675 n = dc_size(B_N_CHILD(tb->FL[h], order_L)) / (DC_SIZE + 1676 KEY_SIZE); 1677 set_parameters(tb, h, -n - 1, 0, 0, NULL, -1, -1); 1678 return CARRY_ON; 1679 } 1680 1681 /* Check whether we can merge S[h] with right neighbor. */ 1682 if (tb->rnum[h] >= vn->vn_nr_item + 1) { 1683 int n; 1684 int order_R; 1685 1686 order_R = 1687 ((n = 1688 PATH_H_B_ITEM_ORDER(tb->tb_path, 1689 h)) == B_NR_ITEMS(Fh)) ? 0 : (n + 1); 1690 n = dc_size(B_N_CHILD(tb->FR[h], order_R)) / (DC_SIZE + 1691 KEY_SIZE); 1692 set_parameters(tb, h, 0, -n - 1, 0, NULL, -1, -1); 1693 return CARRY_ON; 1694 } 1695 1696 /* All contents of S[h] can be moved to the neighbors (L[h] & R[h]). */ 1697 if (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1) { 1698 int to_r; 1699 1700 to_r = 1701 ((MAX_NR_KEY(Sh) << 1) + 2 - tb->lnum[h] - tb->rnum[h] + 1702 vn->vn_nr_item + 1) / 2 - (MAX_NR_KEY(Sh) + 1 - 1703 tb->rnum[h]); 1704 set_parameters(tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL, 1705 -1, -1); 1706 return CARRY_ON; 1707 } 1708 1709 /* For internal nodes try to borrow item from a neighbor */ 1710 RFALSE(!tb->FL[h] && !tb->FR[h], "vs-8235: trying to borrow for root"); 1711 1712 /* Borrow one or two items from caching neighbor */ 1713 if (is_left_neighbor_in_cache(tb, h) || !tb->FR[h]) { 1714 int from_l; 1715 1716 from_l = 1717 (MAX_NR_KEY(Sh) + 1 - tb->lnum[h] + vn->vn_nr_item + 1718 1) / 2 - (vn->vn_nr_item + 1); 1719 set_parameters(tb, h, -from_l, 0, 1, NULL, -1, -1); 1720 return CARRY_ON; 1721 } 1722 1723 set_parameters(tb, h, 0, 1724 -((MAX_NR_KEY(Sh) + 1 - tb->rnum[h] + vn->vn_nr_item + 1725 1) / 2 - (vn->vn_nr_item + 1)), 1, NULL, -1, -1); 1726 return CARRY_ON; 1727 } 1728 1729 /* Check whether current node S[h] is balanced when Decreasing its size by 1730 * Deleting or Truncating for LEAF node of S+tree. 1731 * Calculate parameters for balancing for current level h. 1732 * Parameters: 1733 * tb tree_balance structure; 1734 * h current level of the node; 1735 * inum item number in S[h]; 1736 * mode i - insert, p - paste; 1737 * Returns: 1 - schedule occurred; 1738 * 0 - balancing for higher levels needed; 1739 * -1 - no balancing for higher levels needed; 1740 * -2 - no disk space. 1741 */ 1742 static int dc_check_balance_leaf(struct tree_balance *tb, int h) 1743 { 1744 struct virtual_node *vn = tb->tb_vn; 1745 1746 /* Number of bytes that must be deleted from 1747 (value is negative if bytes are deleted) buffer which 1748 contains node being balanced. The mnemonic is that the 1749 attempted change in node space used level is levbytes bytes. */ 1750 int levbytes; 1751 /* the maximal item size */ 1752 int maxsize, ret; 1753 /* S0 is the node whose balance is currently being checked, 1754 and F0 is its father. */ 1755 struct buffer_head *S0, *F0; 1756 int lfree, rfree /* free space in L and R */ ; 1757 1758 S0 = PATH_H_PBUFFER(tb->tb_path, 0); 1759 F0 = PATH_H_PPARENT(tb->tb_path, 0); 1760 1761 levbytes = tb->insert_size[h]; 1762 1763 maxsize = MAX_CHILD_SIZE(S0); /* maximal possible size of an item */ 1764 1765 if (!F0) { /* S[0] is the root now. */ 1766 1767 RFALSE(-levbytes >= maxsize - B_FREE_SPACE(S0), 1768 "vs-8240: attempt to create empty buffer tree"); 1769 1770 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1771 return NO_BALANCING_NEEDED; 1772 } 1773 1774 if ((ret = get_parents(tb, h)) != CARRY_ON) 1775 return ret; 1776 1777 /* get free space of neighbors */ 1778 rfree = get_rfree(tb, h); 1779 lfree = get_lfree(tb, h); 1780 1781 create_virtual_node(tb, h); 1782 1783 /* if 3 leaves can be merge to one, set parameters and return */ 1784 if (are_leaves_removable(tb, lfree, rfree)) 1785 return CARRY_ON; 1786 1787 /* determine maximal number of items we can shift to the left/right neighbor 1788 and the maximal number of bytes that can flow to the left/right neighbor 1789 from the left/right most liquid item that cannot be shifted from S[0] entirely 1790 */ 1791 check_left(tb, h, lfree); 1792 check_right(tb, h, rfree); 1793 1794 /* check whether we can merge S with left neighbor. */ 1795 if (tb->lnum[0] >= vn->vn_nr_item && tb->lbytes == -1) 1796 if (is_left_neighbor_in_cache(tb, h) || ((tb->rnum[0] - ((tb->rbytes == -1) ? 0 : 1)) < vn->vn_nr_item) || /* S can not be merged with R */ 1797 !tb->FR[h]) { 1798 1799 RFALSE(!tb->FL[h], 1800 "vs-8245: dc_check_balance_leaf: FL[h] must exist"); 1801 1802 /* set parameter to merge S[0] with its left neighbor */ 1803 set_parameters(tb, h, -1, 0, 0, NULL, -1, -1); 1804 return CARRY_ON; 1805 } 1806 1807 /* check whether we can merge S[0] with right neighbor. */ 1808 if (tb->rnum[0] >= vn->vn_nr_item && tb->rbytes == -1) { 1809 set_parameters(tb, h, 0, -1, 0, NULL, -1, -1); 1810 return CARRY_ON; 1811 } 1812 1813 /* All contents of S[0] can be moved to the neighbors (L[0] & R[0]). Set parameters and return */ 1814 if (is_leaf_removable(tb)) 1815 return CARRY_ON; 1816 1817 /* Balancing is not required. */ 1818 tb->s0num = vn->vn_nr_item; 1819 set_parameters(tb, h, 0, 0, 1, NULL, -1, -1); 1820 return NO_BALANCING_NEEDED; 1821 } 1822 1823 /* Check whether current node S[h] is balanced when Decreasing its size by 1824 * Deleting or Cutting. 1825 * Calculate parameters for balancing for current level h. 1826 * Parameters: 1827 * tb tree_balance structure; 1828 * h current level of the node; 1829 * inum item number in S[h]; 1830 * mode d - delete, c - cut. 1831 * Returns: 1 - schedule occurred; 1832 * 0 - balancing for higher levels needed; 1833 * -1 - no balancing for higher levels needed; 1834 * -2 - no disk space. 1835 */ 1836 static int dc_check_balance(struct tree_balance *tb, int h) 1837 { 1838 RFALSE(!(PATH_H_PBUFFER(tb->tb_path, h)), 1839 "vs-8250: S is not initialized"); 1840 1841 if (h) 1842 return dc_check_balance_internal(tb, h); 1843 else 1844 return dc_check_balance_leaf(tb, h); 1845 } 1846 1847 /* Check whether current node S[h] is balanced. 1848 * Calculate parameters for balancing for current level h. 1849 * Parameters: 1850 * 1851 * tb tree_balance structure: 1852 * 1853 * tb is a large structure that must be read about in the header file 1854 * at the same time as this procedure if the reader is to successfully 1855 * understand this procedure 1856 * 1857 * h current level of the node; 1858 * inum item number in S[h]; 1859 * mode i - insert, p - paste, d - delete, c - cut. 1860 * Returns: 1 - schedule occurred; 1861 * 0 - balancing for higher levels needed; 1862 * -1 - no balancing for higher levels needed; 1863 * -2 - no disk space. 1864 */ 1865 static int check_balance(int mode, 1866 struct tree_balance *tb, 1867 int h, 1868 int inum, 1869 int pos_in_item, 1870 struct item_head *ins_ih, const void *data) 1871 { 1872 struct virtual_node *vn; 1873 1874 vn = tb->tb_vn = (struct virtual_node *)(tb->vn_buf); 1875 vn->vn_free_ptr = (char *)(tb->tb_vn + 1); 1876 vn->vn_mode = mode; 1877 vn->vn_affected_item_num = inum; 1878 vn->vn_pos_in_item = pos_in_item; 1879 vn->vn_ins_ih = ins_ih; 1880 vn->vn_data = data; 1881 1882 RFALSE(mode == M_INSERT && !vn->vn_ins_ih, 1883 "vs-8255: ins_ih can not be 0 in insert mode"); 1884 1885 if (tb->insert_size[h] > 0) 1886 /* Calculate balance parameters when size of node is increasing. */ 1887 return ip_check_balance(tb, h); 1888 1889 /* Calculate balance parameters when size of node is decreasing. */ 1890 return dc_check_balance(tb, h); 1891 } 1892 1893 /* Check whether parent at the path is the really parent of the current node.*/ 1894 static int get_direct_parent(struct tree_balance *tb, int h) 1895 { 1896 struct buffer_head *bh; 1897 struct treepath *path = tb->tb_path; 1898 int position, 1899 path_offset = PATH_H_PATH_OFFSET(tb->tb_path, h); 1900 1901 /* We are in the root or in the new root. */ 1902 if (path_offset <= FIRST_PATH_ELEMENT_OFFSET) { 1903 1904 RFALSE(path_offset < FIRST_PATH_ELEMENT_OFFSET - 1, 1905 "PAP-8260: invalid offset in the path"); 1906 1907 if (PATH_OFFSET_PBUFFER(path, FIRST_PATH_ELEMENT_OFFSET)-> 1908 b_blocknr == SB_ROOT_BLOCK(tb->tb_sb)) { 1909 /* Root is not changed. */ 1910 PATH_OFFSET_PBUFFER(path, path_offset - 1) = NULL; 1911 PATH_OFFSET_POSITION(path, path_offset - 1) = 0; 1912 return CARRY_ON; 1913 } 1914 return REPEAT_SEARCH; /* Root is changed and we must recalculate the path. */ 1915 } 1916 1917 if (!B_IS_IN_TREE 1918 (bh = PATH_OFFSET_PBUFFER(path, path_offset - 1))) 1919 return REPEAT_SEARCH; /* Parent in the path is not in the tree. */ 1920 1921 if ((position = 1922 PATH_OFFSET_POSITION(path, 1923 path_offset - 1)) > B_NR_ITEMS(bh)) 1924 return REPEAT_SEARCH; 1925 1926 if (B_N_CHILD_NUM(bh, position) != 1927 PATH_OFFSET_PBUFFER(path, path_offset)->b_blocknr) 1928 /* Parent in the path is not parent of the current node in the tree. */ 1929 return REPEAT_SEARCH; 1930 1931 if (buffer_locked(bh)) { 1932 reiserfs_write_unlock(tb->tb_sb); 1933 __wait_on_buffer(bh); 1934 reiserfs_write_lock(tb->tb_sb); 1935 if (FILESYSTEM_CHANGED_TB(tb)) 1936 return REPEAT_SEARCH; 1937 } 1938 1939 return CARRY_ON; /* Parent in the path is unlocked and really parent of the current node. */ 1940 } 1941 1942 /* Using lnum[h] and rnum[h] we should determine what neighbors 1943 * of S[h] we 1944 * need in order to balance S[h], and get them if necessary. 1945 * Returns: SCHEDULE_OCCURRED - schedule occurred while the function worked; 1946 * CARRY_ON - schedule didn't occur while the function worked; 1947 */ 1948 static int get_neighbors(struct tree_balance *tb, int h) 1949 { 1950 int child_position, 1951 path_offset = PATH_H_PATH_OFFSET(tb->tb_path, h + 1); 1952 unsigned long son_number; 1953 struct super_block *sb = tb->tb_sb; 1954 struct buffer_head *bh; 1955 1956 PROC_INFO_INC(sb, get_neighbors[h]); 1957 1958 if (tb->lnum[h]) { 1959 /* We need left neighbor to balance S[h]. */ 1960 PROC_INFO_INC(sb, need_l_neighbor[h]); 1961 bh = PATH_OFFSET_PBUFFER(tb->tb_path, path_offset); 1962 1963 RFALSE(bh == tb->FL[h] && 1964 !PATH_OFFSET_POSITION(tb->tb_path, path_offset), 1965 "PAP-8270: invalid position in the parent"); 1966 1967 child_position = 1968 (bh == 1969 tb->FL[h]) ? tb->lkey[h] : B_NR_ITEMS(tb-> 1970 FL[h]); 1971 son_number = B_N_CHILD_NUM(tb->FL[h], child_position); 1972 reiserfs_write_unlock(sb); 1973 bh = sb_bread(sb, son_number); 1974 reiserfs_write_lock(sb); 1975 if (!bh) 1976 return IO_ERROR; 1977 if (FILESYSTEM_CHANGED_TB(tb)) { 1978 brelse(bh); 1979 PROC_INFO_INC(sb, get_neighbors_restart[h]); 1980 return REPEAT_SEARCH; 1981 } 1982 1983 RFALSE(!B_IS_IN_TREE(tb->FL[h]) || 1984 child_position > B_NR_ITEMS(tb->FL[h]) || 1985 B_N_CHILD_NUM(tb->FL[h], child_position) != 1986 bh->b_blocknr, "PAP-8275: invalid parent"); 1987 RFALSE(!B_IS_IN_TREE(bh), "PAP-8280: invalid child"); 1988 RFALSE(!h && 1989 B_FREE_SPACE(bh) != 1990 MAX_CHILD_SIZE(bh) - 1991 dc_size(B_N_CHILD(tb->FL[0], child_position)), 1992 "PAP-8290: invalid child size of left neighbor"); 1993 1994 brelse(tb->L[h]); 1995 tb->L[h] = bh; 1996 } 1997 1998 /* We need right neighbor to balance S[path_offset]. */ 1999 if (tb->rnum[h]) { /* We need right neighbor to balance S[path_offset]. */ 2000 PROC_INFO_INC(sb, need_r_neighbor[h]); 2001 bh = PATH_OFFSET_PBUFFER(tb->tb_path, path_offset); 2002 2003 RFALSE(bh == tb->FR[h] && 2004 PATH_OFFSET_POSITION(tb->tb_path, 2005 path_offset) >= 2006 B_NR_ITEMS(bh), 2007 "PAP-8295: invalid position in the parent"); 2008 2009 child_position = 2010 (bh == tb->FR[h]) ? tb->rkey[h] + 1 : 0; 2011 son_number = B_N_CHILD_NUM(tb->FR[h], child_position); 2012 reiserfs_write_unlock(sb); 2013 bh = sb_bread(sb, son_number); 2014 reiserfs_write_lock(sb); 2015 if (!bh) 2016 return IO_ERROR; 2017 if (FILESYSTEM_CHANGED_TB(tb)) { 2018 brelse(bh); 2019 PROC_INFO_INC(sb, get_neighbors_restart[h]); 2020 return REPEAT_SEARCH; 2021 } 2022 brelse(tb->R[h]); 2023 tb->R[h] = bh; 2024 2025 RFALSE(!h 2026 && B_FREE_SPACE(bh) != 2027 MAX_CHILD_SIZE(bh) - 2028 dc_size(B_N_CHILD(tb->FR[0], child_position)), 2029 "PAP-8300: invalid child size of right neighbor (%d != %d - %d)", 2030 B_FREE_SPACE(bh), MAX_CHILD_SIZE(bh), 2031 dc_size(B_N_CHILD(tb->FR[0], child_position))); 2032 2033 } 2034 return CARRY_ON; 2035 } 2036 2037 static int get_virtual_node_size(struct super_block *sb, struct buffer_head *bh) 2038 { 2039 int max_num_of_items; 2040 int max_num_of_entries; 2041 unsigned long blocksize = sb->s_blocksize; 2042 2043 #define MIN_NAME_LEN 1 2044 2045 max_num_of_items = (blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN); 2046 max_num_of_entries = (blocksize - BLKH_SIZE - IH_SIZE) / 2047 (DEH_SIZE + MIN_NAME_LEN); 2048 2049 return sizeof(struct virtual_node) + 2050 max(max_num_of_items * sizeof(struct virtual_item), 2051 sizeof(struct virtual_item) + sizeof(struct direntry_uarea) + 2052 (max_num_of_entries - 1) * sizeof(__u16)); 2053 } 2054 2055 /* maybe we should fail balancing we are going to perform when kmalloc 2056 fails several times. But now it will loop until kmalloc gets 2057 required memory */ 2058 static int get_mem_for_virtual_node(struct tree_balance *tb) 2059 { 2060 int check_fs = 0; 2061 int size; 2062 char *buf; 2063 2064 size = get_virtual_node_size(tb->tb_sb, PATH_PLAST_BUFFER(tb->tb_path)); 2065 2066 if (size > tb->vn_buf_size) { 2067 /* we have to allocate more memory for virtual node */ 2068 if (tb->vn_buf) { 2069 /* free memory allocated before */ 2070 kfree(tb->vn_buf); 2071 /* this is not needed if kfree is atomic */ 2072 check_fs = 1; 2073 } 2074 2075 /* virtual node requires now more memory */ 2076 tb->vn_buf_size = size; 2077 2078 /* get memory for virtual item */ 2079 buf = kmalloc(size, GFP_ATOMIC | __GFP_NOWARN); 2080 if (!buf) { 2081 /* getting memory with GFP_KERNEL priority may involve 2082 balancing now (due to indirect_to_direct conversion on 2083 dcache shrinking). So, release path and collected 2084 resources here */ 2085 free_buffers_in_tb(tb); 2086 buf = kmalloc(size, GFP_NOFS); 2087 if (!buf) { 2088 tb->vn_buf_size = 0; 2089 } 2090 tb->vn_buf = buf; 2091 schedule(); 2092 return REPEAT_SEARCH; 2093 } 2094 2095 tb->vn_buf = buf; 2096 } 2097 2098 if (check_fs && FILESYSTEM_CHANGED_TB(tb)) 2099 return REPEAT_SEARCH; 2100 2101 return CARRY_ON; 2102 } 2103 2104 #ifdef CONFIG_REISERFS_CHECK 2105 static void tb_buffer_sanity_check(struct super_block *sb, 2106 struct buffer_head *bh, 2107 const char *descr, int level) 2108 { 2109 if (bh) { 2110 if (atomic_read(&(bh->b_count)) <= 0) 2111 2112 reiserfs_panic(sb, "jmacd-1", "negative or zero " 2113 "reference counter for buffer %s[%d] " 2114 "(%b)", descr, level, bh); 2115 2116 if (!buffer_uptodate(bh)) 2117 reiserfs_panic(sb, "jmacd-2", "buffer is not up " 2118 "to date %s[%d] (%b)", 2119 descr, level, bh); 2120 2121 if (!B_IS_IN_TREE(bh)) 2122 reiserfs_panic(sb, "jmacd-3", "buffer is not " 2123 "in tree %s[%d] (%b)", 2124 descr, level, bh); 2125 2126 if (bh->b_bdev != sb->s_bdev) 2127 reiserfs_panic(sb, "jmacd-4", "buffer has wrong " 2128 "device %s[%d] (%b)", 2129 descr, level, bh); 2130 2131 if (bh->b_size != sb->s_blocksize) 2132 reiserfs_panic(sb, "jmacd-5", "buffer has wrong " 2133 "blocksize %s[%d] (%b)", 2134 descr, level, bh); 2135 2136 if (bh->b_blocknr > SB_BLOCK_COUNT(sb)) 2137 reiserfs_panic(sb, "jmacd-6", "buffer block " 2138 "number too high %s[%d] (%b)", 2139 descr, level, bh); 2140 } 2141 } 2142 #else 2143 static void tb_buffer_sanity_check(struct super_block *sb, 2144 struct buffer_head *bh, 2145 const char *descr, int level) 2146 {; 2147 } 2148 #endif 2149 2150 static int clear_all_dirty_bits(struct super_block *s, struct buffer_head *bh) 2151 { 2152 return reiserfs_prepare_for_journal(s, bh, 0); 2153 } 2154 2155 static int wait_tb_buffers_until_unlocked(struct tree_balance *tb) 2156 { 2157 struct buffer_head *locked; 2158 #ifdef CONFIG_REISERFS_CHECK 2159 int repeat_counter = 0; 2160 #endif 2161 int i; 2162 2163 do { 2164 2165 locked = NULL; 2166 2167 for (i = tb->tb_path->path_length; 2168 !locked && i > ILLEGAL_PATH_ELEMENT_OFFSET; i--) { 2169 if (PATH_OFFSET_PBUFFER(tb->tb_path, i)) { 2170 /* if I understand correctly, we can only be sure the last buffer 2171 ** in the path is in the tree --clm 2172 */ 2173 #ifdef CONFIG_REISERFS_CHECK 2174 if (PATH_PLAST_BUFFER(tb->tb_path) == 2175 PATH_OFFSET_PBUFFER(tb->tb_path, i)) 2176 tb_buffer_sanity_check(tb->tb_sb, 2177 PATH_OFFSET_PBUFFER 2178 (tb->tb_path, 2179 i), "S", 2180 tb->tb_path-> 2181 path_length - i); 2182 #endif 2183 if (!clear_all_dirty_bits(tb->tb_sb, 2184 PATH_OFFSET_PBUFFER 2185 (tb->tb_path, 2186 i))) { 2187 locked = 2188 PATH_OFFSET_PBUFFER(tb->tb_path, 2189 i); 2190 } 2191 } 2192 } 2193 2194 for (i = 0; !locked && i < MAX_HEIGHT && tb->insert_size[i]; 2195 i++) { 2196 2197 if (tb->lnum[i]) { 2198 2199 if (tb->L[i]) { 2200 tb_buffer_sanity_check(tb->tb_sb, 2201 tb->L[i], 2202 "L", i); 2203 if (!clear_all_dirty_bits 2204 (tb->tb_sb, tb->L[i])) 2205 locked = tb->L[i]; 2206 } 2207 2208 if (!locked && tb->FL[i]) { 2209 tb_buffer_sanity_check(tb->tb_sb, 2210 tb->FL[i], 2211 "FL", i); 2212 if (!clear_all_dirty_bits 2213 (tb->tb_sb, tb->FL[i])) 2214 locked = tb->FL[i]; 2215 } 2216 2217 if (!locked && tb->CFL[i]) { 2218 tb_buffer_sanity_check(tb->tb_sb, 2219 tb->CFL[i], 2220 "CFL", i); 2221 if (!clear_all_dirty_bits 2222 (tb->tb_sb, tb->CFL[i])) 2223 locked = tb->CFL[i]; 2224 } 2225 2226 } 2227 2228 if (!locked && (tb->rnum[i])) { 2229 2230 if (tb->R[i]) { 2231 tb_buffer_sanity_check(tb->tb_sb, 2232 tb->R[i], 2233 "R", i); 2234 if (!clear_all_dirty_bits 2235 (tb->tb_sb, tb->R[i])) 2236 locked = tb->R[i]; 2237 } 2238 2239 if (!locked && tb->FR[i]) { 2240 tb_buffer_sanity_check(tb->tb_sb, 2241 tb->FR[i], 2242 "FR", i); 2243 if (!clear_all_dirty_bits 2244 (tb->tb_sb, tb->FR[i])) 2245 locked = tb->FR[i]; 2246 } 2247 2248 if (!locked && tb->CFR[i]) { 2249 tb_buffer_sanity_check(tb->tb_sb, 2250 tb->CFR[i], 2251 "CFR", i); 2252 if (!clear_all_dirty_bits 2253 (tb->tb_sb, tb->CFR[i])) 2254 locked = tb->CFR[i]; 2255 } 2256 } 2257 } 2258 /* as far as I can tell, this is not required. The FEB list seems 2259 ** to be full of newly allocated nodes, which will never be locked, 2260 ** dirty, or anything else. 2261 ** To be safe, I'm putting in the checks and waits in. For the moment, 2262 ** they are needed to keep the code in journal.c from complaining 2263 ** about the buffer. That code is inside CONFIG_REISERFS_CHECK as well. 2264 ** --clm 2265 */ 2266 for (i = 0; !locked && i < MAX_FEB_SIZE; i++) { 2267 if (tb->FEB[i]) { 2268 if (!clear_all_dirty_bits 2269 (tb->tb_sb, tb->FEB[i])) 2270 locked = tb->FEB[i]; 2271 } 2272 } 2273 2274 if (locked) { 2275 #ifdef CONFIG_REISERFS_CHECK 2276 repeat_counter++; 2277 if ((repeat_counter % 10000) == 0) { 2278 reiserfs_warning(tb->tb_sb, "reiserfs-8200", 2279 "too many iterations waiting " 2280 "for buffer to unlock " 2281 "(%b)", locked); 2282 2283 /* Don't loop forever. Try to recover from possible error. */ 2284 2285 return (FILESYSTEM_CHANGED_TB(tb)) ? 2286 REPEAT_SEARCH : CARRY_ON; 2287 } 2288 #endif 2289 reiserfs_write_unlock(tb->tb_sb); 2290 __wait_on_buffer(locked); 2291 reiserfs_write_lock(tb->tb_sb); 2292 if (FILESYSTEM_CHANGED_TB(tb)) 2293 return REPEAT_SEARCH; 2294 } 2295 2296 } while (locked); 2297 2298 return CARRY_ON; 2299 } 2300 2301 /* Prepare for balancing, that is 2302 * get all necessary parents, and neighbors; 2303 * analyze what and where should be moved; 2304 * get sufficient number of new nodes; 2305 * Balancing will start only after all resources will be collected at a time. 2306 * 2307 * When ported to SMP kernels, only at the last moment after all needed nodes 2308 * are collected in cache, will the resources be locked using the usual 2309 * textbook ordered lock acquisition algorithms. Note that ensuring that 2310 * this code neither write locks what it does not need to write lock nor locks out of order 2311 * will be a pain in the butt that could have been avoided. Grumble grumble. -Hans 2312 * 2313 * fix is meant in the sense of render unchanging 2314 * 2315 * Latency might be improved by first gathering a list of what buffers are needed 2316 * and then getting as many of them in parallel as possible? -Hans 2317 * 2318 * Parameters: 2319 * op_mode i - insert, d - delete, c - cut (truncate), p - paste (append) 2320 * tb tree_balance structure; 2321 * inum item number in S[h]; 2322 * pos_in_item - comment this if you can 2323 * ins_ih item head of item being inserted 2324 * data inserted item or data to be pasted 2325 * Returns: 1 - schedule occurred while the function worked; 2326 * 0 - schedule didn't occur while the function worked; 2327 * -1 - if no_disk_space 2328 */ 2329 2330 int fix_nodes(int op_mode, struct tree_balance *tb, 2331 struct item_head *ins_ih, const void *data) 2332 { 2333 int ret, h, item_num = PATH_LAST_POSITION(tb->tb_path); 2334 int pos_in_item; 2335 2336 /* we set wait_tb_buffers_run when we have to restore any dirty bits cleared 2337 ** during wait_tb_buffers_run 2338 */ 2339 int wait_tb_buffers_run = 0; 2340 struct buffer_head *tbS0 = PATH_PLAST_BUFFER(tb->tb_path); 2341 2342 ++REISERFS_SB(tb->tb_sb)->s_fix_nodes; 2343 2344 pos_in_item = tb->tb_path->pos_in_item; 2345 2346 tb->fs_gen = get_generation(tb->tb_sb); 2347 2348 /* we prepare and log the super here so it will already be in the 2349 ** transaction when do_balance needs to change it. 2350 ** This way do_balance won't have to schedule when trying to prepare 2351 ** the super for logging 2352 */ 2353 reiserfs_prepare_for_journal(tb->tb_sb, 2354 SB_BUFFER_WITH_SB(tb->tb_sb), 1); 2355 journal_mark_dirty(tb->transaction_handle, tb->tb_sb, 2356 SB_BUFFER_WITH_SB(tb->tb_sb)); 2357 if (FILESYSTEM_CHANGED_TB(tb)) 2358 return REPEAT_SEARCH; 2359 2360 /* if it possible in indirect_to_direct conversion */ 2361 if (buffer_locked(tbS0)) { 2362 reiserfs_write_unlock(tb->tb_sb); 2363 __wait_on_buffer(tbS0); 2364 reiserfs_write_lock(tb->tb_sb); 2365 if (FILESYSTEM_CHANGED_TB(tb)) 2366 return REPEAT_SEARCH; 2367 } 2368 #ifdef CONFIG_REISERFS_CHECK 2369 if (REISERFS_SB(tb->tb_sb)->cur_tb) { 2370 print_cur_tb("fix_nodes"); 2371 reiserfs_panic(tb->tb_sb, "PAP-8305", 2372 "there is pending do_balance"); 2373 } 2374 2375 if (!buffer_uptodate(tbS0) || !B_IS_IN_TREE(tbS0)) 2376 reiserfs_panic(tb->tb_sb, "PAP-8320", "S[0] (%b %z) is " 2377 "not uptodate at the beginning of fix_nodes " 2378 "or not in tree (mode %c)", 2379 tbS0, tbS0, op_mode); 2380 2381 /* Check parameters. */ 2382 switch (op_mode) { 2383 case M_INSERT: 2384 if (item_num <= 0 || item_num > B_NR_ITEMS(tbS0)) 2385 reiserfs_panic(tb->tb_sb, "PAP-8330", "Incorrect " 2386 "item number %d (in S0 - %d) in case " 2387 "of insert", item_num, 2388 B_NR_ITEMS(tbS0)); 2389 break; 2390 case M_PASTE: 2391 case M_DELETE: 2392 case M_CUT: 2393 if (item_num < 0 || item_num >= B_NR_ITEMS(tbS0)) { 2394 print_block(tbS0, 0, -1, -1); 2395 reiserfs_panic(tb->tb_sb, "PAP-8335", "Incorrect " 2396 "item number(%d); mode = %c " 2397 "insert_size = %d", 2398 item_num, op_mode, 2399 tb->insert_size[0]); 2400 } 2401 break; 2402 default: 2403 reiserfs_panic(tb->tb_sb, "PAP-8340", "Incorrect mode " 2404 "of operation"); 2405 } 2406 #endif 2407 2408 if (get_mem_for_virtual_node(tb) == REPEAT_SEARCH) 2409 // FIXME: maybe -ENOMEM when tb->vn_buf == 0? Now just repeat 2410 return REPEAT_SEARCH; 2411 2412 /* Starting from the leaf level; for all levels h of the tree. */ 2413 for (h = 0; h < MAX_HEIGHT && tb->insert_size[h]; h++) { 2414 ret = get_direct_parent(tb, h); 2415 if (ret != CARRY_ON) 2416 goto repeat; 2417 2418 ret = check_balance(op_mode, tb, h, item_num, 2419 pos_in_item, ins_ih, data); 2420 if (ret != CARRY_ON) { 2421 if (ret == NO_BALANCING_NEEDED) { 2422 /* No balancing for higher levels needed. */ 2423 ret = get_neighbors(tb, h); 2424 if (ret != CARRY_ON) 2425 goto repeat; 2426 if (h != MAX_HEIGHT - 1) 2427 tb->insert_size[h + 1] = 0; 2428 /* ok, analysis and resource gathering are complete */ 2429 break; 2430 } 2431 goto repeat; 2432 } 2433 2434 ret = get_neighbors(tb, h); 2435 if (ret != CARRY_ON) 2436 goto repeat; 2437 2438 /* No disk space, or schedule occurred and analysis may be 2439 * invalid and needs to be redone. */ 2440 ret = get_empty_nodes(tb, h); 2441 if (ret != CARRY_ON) 2442 goto repeat; 2443 2444 if (!PATH_H_PBUFFER(tb->tb_path, h)) { 2445 /* We have a positive insert size but no nodes exist on this 2446 level, this means that we are creating a new root. */ 2447 2448 RFALSE(tb->blknum[h] != 1, 2449 "PAP-8350: creating new empty root"); 2450 2451 if (h < MAX_HEIGHT - 1) 2452 tb->insert_size[h + 1] = 0; 2453 } else if (!PATH_H_PBUFFER(tb->tb_path, h + 1)) { 2454 if (tb->blknum[h] > 1) { 2455 /* The tree needs to be grown, so this node S[h] 2456 which is the root node is split into two nodes, 2457 and a new node (S[h+1]) will be created to 2458 become the root node. */ 2459 2460 RFALSE(h == MAX_HEIGHT - 1, 2461 "PAP-8355: attempt to create too high of a tree"); 2462 2463 tb->insert_size[h + 1] = 2464 (DC_SIZE + 2465 KEY_SIZE) * (tb->blknum[h] - 1) + 2466 DC_SIZE; 2467 } else if (h < MAX_HEIGHT - 1) 2468 tb->insert_size[h + 1] = 0; 2469 } else 2470 tb->insert_size[h + 1] = 2471 (DC_SIZE + KEY_SIZE) * (tb->blknum[h] - 1); 2472 } 2473 2474 ret = wait_tb_buffers_until_unlocked(tb); 2475 if (ret == CARRY_ON) { 2476 if (FILESYSTEM_CHANGED_TB(tb)) { 2477 wait_tb_buffers_run = 1; 2478 ret = REPEAT_SEARCH; 2479 goto repeat; 2480 } else { 2481 return CARRY_ON; 2482 } 2483 } else { 2484 wait_tb_buffers_run = 1; 2485 goto repeat; 2486 } 2487 2488 repeat: 2489 // fix_nodes was unable to perform its calculation due to 2490 // filesystem got changed under us, lack of free disk space or i/o 2491 // failure. If the first is the case - the search will be 2492 // repeated. For now - free all resources acquired so far except 2493 // for the new allocated nodes 2494 { 2495 int i; 2496 2497 /* Release path buffers. */ 2498 if (wait_tb_buffers_run) { 2499 pathrelse_and_restore(tb->tb_sb, tb->tb_path); 2500 } else { 2501 pathrelse(tb->tb_path); 2502 } 2503 /* brelse all resources collected for balancing */ 2504 for (i = 0; i < MAX_HEIGHT; i++) { 2505 if (wait_tb_buffers_run) { 2506 reiserfs_restore_prepared_buffer(tb->tb_sb, 2507 tb->L[i]); 2508 reiserfs_restore_prepared_buffer(tb->tb_sb, 2509 tb->R[i]); 2510 reiserfs_restore_prepared_buffer(tb->tb_sb, 2511 tb->FL[i]); 2512 reiserfs_restore_prepared_buffer(tb->tb_sb, 2513 tb->FR[i]); 2514 reiserfs_restore_prepared_buffer(tb->tb_sb, 2515 tb-> 2516 CFL[i]); 2517 reiserfs_restore_prepared_buffer(tb->tb_sb, 2518 tb-> 2519 CFR[i]); 2520 } 2521 2522 brelse(tb->L[i]); 2523 brelse(tb->R[i]); 2524 brelse(tb->FL[i]); 2525 brelse(tb->FR[i]); 2526 brelse(tb->CFL[i]); 2527 brelse(tb->CFR[i]); 2528 2529 tb->L[i] = NULL; 2530 tb->R[i] = NULL; 2531 tb->FL[i] = NULL; 2532 tb->FR[i] = NULL; 2533 tb->CFL[i] = NULL; 2534 tb->CFR[i] = NULL; 2535 } 2536 2537 if (wait_tb_buffers_run) { 2538 for (i = 0; i < MAX_FEB_SIZE; i++) { 2539 if (tb->FEB[i]) 2540 reiserfs_restore_prepared_buffer 2541 (tb->tb_sb, tb->FEB[i]); 2542 } 2543 } 2544 return ret; 2545 } 2546 2547 } 2548 2549 /* Anatoly will probably forgive me renaming tb to tb. I just 2550 wanted to make lines shorter */ 2551 void unfix_nodes(struct tree_balance *tb) 2552 { 2553 int i; 2554 2555 /* Release path buffers. */ 2556 pathrelse_and_restore(tb->tb_sb, tb->tb_path); 2557 2558 /* brelse all resources collected for balancing */ 2559 for (i = 0; i < MAX_HEIGHT; i++) { 2560 reiserfs_restore_prepared_buffer(tb->tb_sb, tb->L[i]); 2561 reiserfs_restore_prepared_buffer(tb->tb_sb, tb->R[i]); 2562 reiserfs_restore_prepared_buffer(tb->tb_sb, tb->FL[i]); 2563 reiserfs_restore_prepared_buffer(tb->tb_sb, tb->FR[i]); 2564 reiserfs_restore_prepared_buffer(tb->tb_sb, tb->CFL[i]); 2565 reiserfs_restore_prepared_buffer(tb->tb_sb, tb->CFR[i]); 2566 2567 brelse(tb->L[i]); 2568 brelse(tb->R[i]); 2569 brelse(tb->FL[i]); 2570 brelse(tb->FR[i]); 2571 brelse(tb->CFL[i]); 2572 brelse(tb->CFR[i]); 2573 } 2574 2575 /* deal with list of allocated (used and unused) nodes */ 2576 for (i = 0; i < MAX_FEB_SIZE; i++) { 2577 if (tb->FEB[i]) { 2578 b_blocknr_t blocknr = tb->FEB[i]->b_blocknr; 2579 /* de-allocated block which was not used by balancing and 2580 bforget about buffer for it */ 2581 brelse(tb->FEB[i]); 2582 reiserfs_free_block(tb->transaction_handle, NULL, 2583 blocknr, 0); 2584 } 2585 if (tb->used[i]) { 2586 /* release used as new nodes including a new root */ 2587 brelse(tb->used[i]); 2588 } 2589 } 2590 2591 kfree(tb->vn_buf); 2592 2593 } 2594