reiserfs: balance_leaf refactor, move state variables into tree_balance

+185 -206

fs/reiserfs/do_balan.c

··· 310 310 struct buffer_head **insert_ptr) 311 311 { 312 312 struct buffer_head *tbS0 = PATH_PLAST_BUFFER(tb->tb_path); 313 - /* index into the array of item headers in S[0] of the affected item */ 314 - int item_pos = PATH_LAST_POSITION(tb->tb_path); 315 313 struct buffer_info bi; 316 - /* new nodes allocated to hold what could not fit into S */ 317 - struct buffer_head *S_new[2]; 318 - /* 319 - * number of items that will be placed into S_new 320 - * (includes partially shifted items) 321 - */ 322 - int snum[2]; 323 - /* 324 - * if an item is partially shifted into S_new then if it is a 325 - * directory item it is the number of entries from the item that 326 - * are shifted into S_new else it is the number of bytes from 327 - * the item that are shifted into S_new 328 - */ 329 - int sbytes[2]; 330 314 int n, i; 331 315 int ret_val; 332 - int pos_in_item; 333 - int zeros_num; 334 316 335 317 PROC_INFO_INC(tb->tb_sb, balance_at[0]); 336 318 ··· 320 338 if (tb->insert_size[0] < 0) 321 339 return balance_leaf_when_delete(tb, flag); 322 340 323 - zeros_num = 0; 341 + tb->item_pos = PATH_LAST_POSITION(tb->tb_path), 342 + tb->pos_in_item = tb->tb_path->pos_in_item, 343 + tb->zeroes_num = 0; 324 344 if (flag == M_INSERT && !body) 325 - zeros_num = ih_item_len(ih); 345 + tb->zeroes_num = ih_item_len(ih); 326 346 327 - pos_in_item = tb->tb_path->pos_in_item; 328 347 /* 329 348 * for indirect item pos_in_item is measured in unformatted node 330 349 * pointers. Recalculate to bytes 331 350 */ 332 351 if (flag != M_INSERT 333 - && is_indirect_le_ih(item_head(tbS0, item_pos))) 334 - pos_in_item *= UNFM_P_SIZE; 352 + && is_indirect_le_ih(item_head(tbS0, tb->item_pos))) 353 + tb->pos_in_item *= UNFM_P_SIZE; 335 354 336 355 if (tb->lnum[0] > 0) { 337 356 /* Shift lnum[0] items from S[0] to the left neighbor L[0] */ 338 - if (item_pos < tb->lnum[0]) { 357 + if (tb->item_pos < tb->lnum[0]) { 339 358 /* new item or it part falls to L[0], shift it too */ 340 359 n = B_NR_ITEMS(tb->L[0]); 341 360 342 361 switch (flag) { 343 362 case M_INSERT: /* insert item into L[0] */ 344 363 345 - if (item_pos == tb->lnum[0] - 1 && tb->lbytes != -1) { 364 + if (tb->item_pos == tb->lnum[0] - 1 && tb->lbytes != -1) { 346 365 /* part of new item falls into L[0] */ 347 366 int new_item_len; 348 367 int version; ··· 362 379 /* Insert new item into L[0] */ 363 380 buffer_info_init_left(tb, &bi); 364 381 leaf_insert_into_buf(&bi, 365 - n + item_pos - ret_val, ih, body, 366 - zeros_num > ih_item_len(ih) ? ih_item_len(ih) : zeros_num); 382 + n + tb->item_pos - ret_val, ih, body, 383 + tb->zeroes_num > ih_item_len(ih) ? ih_item_len(ih) : tb->zeroes_num); 367 384 368 385 version = ih_version(ih); 369 386 ··· 372 389 (tb-> lbytes << (is_indirect_le_ih(ih) ? tb->tb_sb-> s_blocksize_bits - UNFM_P_SHIFT : 0))); 373 390 374 391 put_ih_item_len(ih, new_item_len); 375 - if (tb->lbytes > zeros_num) { 376 - body += (tb->lbytes - zeros_num); 377 - zeros_num = 0; 392 + if (tb->lbytes > tb->zeroes_num) { 393 + body += (tb->lbytes - tb->zeroes_num); 394 + tb->zeroes_num = 0; 378 395 } else 379 - zeros_num -= tb->lbytes; 396 + tb->zeroes_num -= tb->lbytes; 380 397 381 398 RFALSE(ih_item_len(ih) <= 0, 382 399 "PAP-12085: there is nothing to insert into S[0]: ih_item_len=%d", ··· 387 404 ret_val = leaf_shift_left(tb, tb->lnum[0] - 1, tb->lbytes); 388 405 /* Insert new item into L[0] */ 389 406 buffer_info_init_left(tb, &bi); 390 - leaf_insert_into_buf(&bi, n + item_pos - ret_val, ih, body, zeros_num); 407 + leaf_insert_into_buf(&bi, n + tb->item_pos - ret_val, ih, body, tb->zeroes_num); 391 408 tb->insert_size[0] = 0; 392 - zeros_num = 0; 409 + tb->zeroes_num = 0; 393 410 } 394 411 break; 395 412 396 413 case M_PASTE: /* append item in L[0] */ 397 414 398 - if (item_pos == tb->lnum[0] - 1 && tb->lbytes != -1) { 415 + if (tb->item_pos == tb->lnum[0] - 1 && tb->lbytes != -1) { 399 416 /* we must shift the part of the appended item */ 400 - if (is_direntry_le_ih(item_head(tbS0, item_pos))) { 417 + if (is_direntry_le_ih(item_head(tbS0, tb->item_pos))) { 401 418 402 - RFALSE(zeros_num, 419 + RFALSE(tb->zeroes_num, 403 420 "PAP-12090: invalid parameter in case of a directory"); 404 421 /* directory item */ 405 - if (tb->lbytes > pos_in_item) { 422 + if (tb->lbytes > tb->pos_in_item) { 406 423 /* new directory entry falls into L[0] */ 407 424 struct item_head *pasted; 408 - int l_pos_in_item = pos_in_item; 425 + int l_pos_in_item = tb->pos_in_item; 409 426 410 427 /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 entries from given directory item */ 411 428 ret_val = leaf_shift_left(tb, tb->lnum[0], tb->lbytes-1); 412 - if (ret_val && !item_pos) { 429 + if (ret_val && !tb->item_pos) { 413 430 pasted = item_head(tb->L[0], B_NR_ITEMS(tb->L[0]) - 1); 414 431 l_pos_in_item += ih_entry_count(pasted) - (tb->lbytes -1); 415 432 } 416 433 417 434 /* Append given directory entry to directory item */ 418 435 buffer_info_init_left(tb, &bi); 419 - leaf_paste_in_buffer(&bi, n + item_pos - ret_val, l_pos_in_item, tb->insert_size[0], body, zeros_num); 436 + leaf_paste_in_buffer(&bi, n + tb->item_pos - ret_val, l_pos_in_item, tb->insert_size[0], body, tb->zeroes_num); 420 437 421 438 /* previous string prepared space for pasting new entry, following string pastes this entry */ 422 439 423 440 /* when we have merge directory item, pos_in_item has been changed too */ 424 441 425 442 /* paste new directory entry. 1 is entry number */ 426 - leaf_paste_entries(&bi, n + item_pos - ret_val, l_pos_in_item, 443 + leaf_paste_entries(&bi, n + tb->item_pos - ret_val, l_pos_in_item, 427 444 1, (struct reiserfs_de_head *) body, 428 445 body + DEH_SIZE, tb->insert_size[0]); 429 446 tb->insert_size[0] = 0; ··· 433 450 leaf_shift_left(tb, tb->lnum[0], tb->lbytes); 434 451 } 435 452 /* Calculate new position to append in item body */ 436 - pos_in_item -= tb->lbytes; 453 + tb->pos_in_item -= tb->lbytes; 437 454 } else { 438 455 /* regular object */ 439 456 RFALSE(tb->lbytes <= 0, "PAP-12095: there is nothing to shift to L[0]. lbytes=%d", tb->lbytes); 440 - RFALSE(pos_in_item != ih_item_len(item_head(tbS0, item_pos)), 457 + RFALSE(tb->pos_in_item != ih_item_len(item_head(tbS0, tb->item_pos)), 441 458 "PAP-12100: incorrect position to paste: item_len=%d, pos_in_item=%d", 442 - ih_item_len(item_head(tbS0, item_pos)),pos_in_item); 459 + ih_item_len(item_head(tbS0, tb->item_pos)), tb->pos_in_item); 443 460 444 - if (tb->lbytes >= pos_in_item) { 461 + if (tb->lbytes >= tb->pos_in_item) { 445 462 /* appended item will be in L[0] in whole */ 446 463 int l_n; 447 464 448 465 /* this bytes number must be appended to the last item of L[h] */ 449 - l_n = tb->lbytes - pos_in_item; 466 + l_n = tb->lbytes - tb->pos_in_item; 450 467 451 468 /* Calculate new insert_size[0] */ 452 469 tb->insert_size[0] -= l_n; ··· 455 472 "PAP-12105: there is nothing to paste into L[0]. insert_size=%d", 456 473 tb->insert_size[0]); 457 474 ret_val = leaf_shift_left(tb, tb->lnum[0], ih_item_len 458 - (item_head(tbS0, item_pos))); 475 + (item_head(tbS0, tb->item_pos))); 459 476 /* Append to body of item in L[0] */ 460 477 buffer_info_init_left(tb, &bi); 461 478 leaf_paste_in_buffer 462 - (&bi, n + item_pos - ret_val, ih_item_len 463 - (item_head(tb->L[0], n + item_pos - ret_val)), 479 + (&bi, n + tb->item_pos - ret_val, ih_item_len 480 + (item_head(tb->L[0], n + tb->item_pos - ret_val)), 464 481 l_n, body, 465 - zeros_num > l_n ? l_n : zeros_num); 482 + tb->zeroes_num > l_n ? l_n : tb->zeroes_num); 466 483 /* 0-th item in S0 can be only of DIRECT type when l_n != 0 */ 467 484 { 468 485 int version; ··· 471 488 RFALSE(ih_item_len(item_head(tbS0, 0)), 472 489 "PAP-12106: item length must be 0"); 473 490 RFALSE(comp_short_le_keys(leaf_key(tbS0, 0), leaf_key 474 - (tb->L[0], n + item_pos - ret_val)), 491 + (tb->L[0], n + tb->item_pos - ret_val)), 475 492 "PAP-12107: items must be of the same file"); 476 - if (is_indirect_le_ih(item_head(tb->L[0], n + item_pos - ret_val))) { 493 + if (is_indirect_le_ih(item_head(tb->L[0], n + tb->item_pos - ret_val))) { 477 494 temp_l = l_n << (tb->tb_sb-> s_blocksize_bits - UNFM_P_SHIFT); 478 495 } 479 496 /* update key of first item in S0 */ ··· 486 503 } 487 504 488 505 /* Calculate new body, position in item and insert_size[0] */ 489 - if (l_n > zeros_num) { 490 - body += (l_n - zeros_num); 491 - zeros_num = 0; 506 + if (l_n > tb->zeroes_num) { 507 + body += (l_n - tb->zeroes_num); 508 + tb->zeroes_num = 0; 492 509 } else 493 - zeros_num -= l_n; 494 - pos_in_item = 0; 510 + tb->zeroes_num -= l_n; 511 + tb->pos_in_item = 0; 495 512 496 513 RFALSE(comp_short_le_keys(leaf_key(tbS0, 0), leaf_key(tb->L[0], B_NR_ITEMS(tb->L[0]) - 1)) 497 514 || !op_is_left_mergeable(leaf_key(tbS0, 0), tbS0->b_size) ··· 500 517 } else { /* only part of the appended item will be in L[0] */ 501 518 502 519 /* Calculate position in item for append in S[0] */ 503 - pos_in_item -= tb->lbytes; 520 + tb->pos_in_item -= tb->lbytes; 504 521 505 - RFALSE(pos_in_item <= 0, "PAP-12125: no place for paste. pos_in_item=%d", pos_in_item); 522 + RFALSE(tb->pos_in_item <= 0, "PAP-12125: no place for paste. pos_in_item=%d", tb->pos_in_item); 506 523 507 524 /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 byte from item number lnum[0] */ 508 525 leaf_shift_left(tb, tb->lnum[0], tb->lbytes); ··· 512 529 513 530 struct item_head *pasted; 514 531 515 - if (!item_pos && op_is_left_mergeable(leaf_key(tbS0, 0), tbS0->b_size)) { /* if we paste into first item of S[0] and it is left mergable */ 532 + if (!tb->item_pos && op_is_left_mergeable(leaf_key(tbS0, 0), tbS0->b_size)) { /* if we paste into first item of S[0] and it is left mergable */ 516 533 /* then increment pos_in_item by the size of the last item in L[0] */ 517 534 pasted = item_head(tb->L[0], n - 1); 518 535 if (is_direntry_le_ih(pasted)) 519 - pos_in_item += ih_entry_count(pasted); 536 + tb->pos_in_item += ih_entry_count(pasted); 520 537 else 521 - pos_in_item += ih_item_len(pasted); 538 + tb->pos_in_item += ih_item_len(pasted); 522 539 } 523 540 524 541 /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 byte from item number lnum[0] */ 525 542 ret_val = leaf_shift_left(tb, tb->lnum[0], tb->lbytes); 526 543 /* Append to body of item in L[0] */ 527 544 buffer_info_init_left(tb, &bi); 528 - leaf_paste_in_buffer(&bi, n + item_pos - ret_val, 529 - pos_in_item, 545 + leaf_paste_in_buffer(&bi, n + tb->item_pos - ret_val, 546 + tb->pos_in_item, 530 547 tb->insert_size[0], 531 - body, zeros_num); 548 + body, tb->zeroes_num); 532 549 533 550 /* if appended item is directory, paste entry */ 534 - pasted = item_head(tb->L[0], n + item_pos - ret_val); 551 + pasted = item_head(tb->L[0], n + tb->item_pos - ret_val); 535 552 if (is_direntry_le_ih(pasted)) 536 - leaf_paste_entries(&bi, n + item_pos - ret_val, 537 - pos_in_item, 1, 553 + leaf_paste_entries(&bi, n + tb->item_pos - ret_val, 554 + tb->pos_in_item, 1, 538 555 (struct reiserfs_de_head *) body, 539 556 body + DEH_SIZE, 540 557 tb->insert_size[0]); ··· 542 559 if (is_indirect_le_ih(pasted)) 543 560 set_ih_free_space(pasted, 0); 544 561 tb->insert_size[0] = 0; 545 - zeros_num = 0; 562 + tb->zeroes_num = 0; 546 563 } 547 564 break; 548 565 default: /* cases d and t */ ··· 559 576 560 577 /* tb->lnum[0] > 0 */ 561 578 /* Calculate new item position */ 562 - item_pos -= (tb->lnum[0] - ((tb->lbytes != -1) ? 1 : 0)); 579 + tb->item_pos -= (tb->lnum[0] - ((tb->lbytes != -1) ? 1 : 0)); 563 580 564 581 if (tb->rnum[0] > 0) { 565 582 /* shift rnum[0] items from S[0] to the right neighbor R[0] */ ··· 567 584 switch (flag) { 568 585 569 586 case M_INSERT: /* insert item */ 570 - if (n - tb->rnum[0] < item_pos) { /* new item or its part falls to R[0] */ 571 - if (item_pos == n - tb->rnum[0] + 1 && tb->rbytes != -1) { /* part of new item falls into R[0] */ 572 - loff_t old_key_comp, old_len, r_zeros_number; 587 + if (n - tb->rnum[0] < tb->item_pos) { /* new item or its part falls to R[0] */ 588 + if (tb->item_pos == n - tb->rnum[0] + 1 && tb->rbytes != -1) { /* part of new item falls into R[0] */ 589 + loff_t old_key_comp, old_len, r_zeroes_number; 573 590 const char *r_body; 574 591 int version; 575 592 loff_t offset; ··· 587 604 put_ih_item_len(ih, tb->rbytes); 588 605 /* Insert part of the item into R[0] */ 589 606 buffer_info_init_right(tb, &bi); 590 - if ((old_len - tb->rbytes) > zeros_num) { 591 - r_zeros_number = 0; 592 - r_body = body + (old_len - tb->rbytes) - zeros_num; 607 + if ((old_len - tb->rbytes) > tb->zeroes_num) { 608 + r_zeroes_number = 0; 609 + r_body = body + (old_len - tb->rbytes) - tb->zeroes_num; 593 610 } else { 594 611 r_body = body; 595 - r_zeros_number = zeros_num - (old_len - tb->rbytes); 596 - zeros_num -= r_zeros_number; 612 + r_zeroes_number = tb->zeroes_num - (old_len - tb->rbytes); 613 + tb->zeroes_num -= r_zeroes_number; 597 614 } 598 615 599 616 leaf_insert_into_buf(&bi, 0, ih, r_body, 600 - r_zeros_number); 617 + r_zeroes_number); 601 618 602 619 /* Replace right delimiting key by first key in R[0] */ 603 620 replace_key(tb, tb->CFR[0], tb->rkey[0], ··· 615 632 ret_val = leaf_shift_right(tb, tb->rnum[0] - 1, tb->rbytes); 616 633 /* Insert new item into R[0] */ 617 634 buffer_info_init_right(tb, &bi); 618 - leaf_insert_into_buf(&bi, item_pos - n + tb->rnum[0] - 1, 619 - ih, body, zeros_num); 635 + leaf_insert_into_buf(&bi, tb->item_pos - n + tb->rnum[0] - 1, 636 + ih, body, tb->zeroes_num); 620 637 621 - if (item_pos - n + tb->rnum[0] - 1 == 0) { 638 + if (tb->item_pos - n + tb->rnum[0] - 1 == 0) { 622 639 replace_key(tb, tb->CFR[0], 623 640 tb->rkey[0], 624 641 tb->R[0], 0); 625 642 626 643 } 627 - zeros_num = tb->insert_size[0] = 0; 644 + tb->zeroes_num = tb->insert_size[0] = 0; 628 645 } 629 646 } else { /* new item or part of it doesn't fall into R[0] */ 630 647 ··· 634 651 635 652 case M_PASTE: /* append item */ 636 653 637 - if (n - tb->rnum[0] <= item_pos) { /* pasted item or part of it falls to R[0] */ 638 - if (item_pos == n - tb->rnum[0] && tb->rbytes != -1) { /* we must shift the part of the appended item */ 639 - if (is_direntry_le_ih(item_head(tbS0, item_pos))) { /* we append to directory item */ 654 + if (n - tb->rnum[0] <= tb->item_pos) { /* pasted item or part of it falls to R[0] */ 655 + if (tb->item_pos == n - tb->rnum[0] && tb->rbytes != -1) { /* we must shift the part of the appended item */ 656 + if (is_direntry_le_ih(item_head(tbS0, tb->item_pos))) { /* we append to directory item */ 640 657 int entry_count; 641 658 642 - RFALSE(zeros_num, 659 + RFALSE(tb->zeroes_num, 643 660 "PAP-12145: invalid parameter in case of a directory"); 644 661 entry_count = ih_entry_count(item_head 645 - (tbS0, item_pos)); 662 + (tbS0, tb->item_pos)); 646 663 if (entry_count - tb->rbytes < 647 - pos_in_item) 664 + tb->pos_in_item) 648 665 /* new directory entry falls into R[0] */ 649 666 { 650 667 int paste_entry_position; ··· 655 672 /* Shift rnum[0]-1 items in whole. Shift rbytes-1 directory entries from directory item number rnum[0] */ 656 673 leaf_shift_right(tb, tb->rnum[0], tb->rbytes - 1); 657 674 /* Paste given directory entry to directory item */ 658 - paste_entry_position = pos_in_item - entry_count + tb->rbytes - 1; 675 + paste_entry_position = tb->pos_in_item - entry_count + tb->rbytes - 1; 659 676 buffer_info_init_right(tb, &bi); 660 - leaf_paste_in_buffer(&bi, 0, paste_entry_position, tb->insert_size[0], body, zeros_num); 677 + leaf_paste_in_buffer(&bi, 0, paste_entry_position, tb->insert_size[0], body, tb->zeroes_num); 661 678 /* paste entry */ 662 679 leaf_paste_entries(&bi, 0, paste_entry_position, 1, 663 680 (struct reiserfs_de_head *) body, ··· 669 686 } 670 687 671 688 tb->insert_size[0] = 0; 672 - pos_in_item++; 689 + tb->pos_in_item++; 673 690 } else { /* new directory entry doesn't fall into R[0] */ 674 691 675 692 leaf_shift_right(tb, tb->rnum[0], tb->rbytes); 676 693 } 677 694 } else { /* regular object */ 678 695 679 - int n_shift, n_rem, r_zeros_number; 696 + int n_shift, n_rem, r_zeroes_number; 680 697 const char *r_body; 681 698 682 699 /* Calculate number of bytes which must be shifted from appended item */ 683 700 if ((n_shift = tb->rbytes - tb->insert_size[0]) < 0) 684 701 n_shift = 0; 685 702 686 - RFALSE(pos_in_item != ih_item_len 687 - (item_head(tbS0, item_pos)), 703 + RFALSE(tb->pos_in_item != ih_item_len 704 + (item_head(tbS0, tb->item_pos)), 688 705 "PAP-12155: invalid position to paste. ih_item_len=%d, pos_in_item=%d", 689 - pos_in_item, ih_item_len 690 - (item_head(tbS0, item_pos))); 706 + tb->pos_in_item, ih_item_len 707 + (item_head(tbS0, tb->item_pos))); 691 708 692 709 leaf_shift_right(tb, tb->rnum[0], n_shift); 693 710 /* Calculate number of bytes which must remain in body after appending to R[0] */ ··· 713 730 714 731 /* Append part of body into R[0] */ 715 732 buffer_info_init_right(tb, &bi); 716 - if (n_rem > zeros_num) { 717 - r_zeros_number = 0; 718 - r_body = body + n_rem - zeros_num; 733 + if (n_rem > tb->zeroes_num) { 734 + r_zeroes_number = 0; 735 + r_body = body + n_rem - tb->zeroes_num; 719 736 } else { 720 737 r_body = body; 721 - r_zeros_number = zeros_num - n_rem; 722 - zeros_num -= r_zeros_number; 738 + r_zeroes_number = tb->zeroes_num - n_rem; 739 + tb->zeroes_num -= r_zeroes_number; 723 740 } 724 741 725 742 leaf_paste_in_buffer(&bi, 0, n_shift, 726 743 tb->insert_size[0] - n_rem, 727 - r_body, r_zeros_number); 744 + r_body, r_zeroes_number); 728 745 729 746 if (is_indirect_le_ih(item_head(tb->R[0], 0))) { 730 747 #if 0 ··· 735 752 } 736 753 tb->insert_size[0] = n_rem; 737 754 if (!n_rem) 738 - pos_in_item++; 755 + tb->pos_in_item++; 739 756 } 740 757 } else { /* pasted item in whole falls into R[0] */ 741 758 ··· 743 760 744 761 ret_val = leaf_shift_right(tb, tb->rnum[0], tb->rbytes); 745 762 /* append item in R[0] */ 746 - if (pos_in_item >= 0) { 763 + if (tb->pos_in_item >= 0) { 747 764 buffer_info_init_right(tb, &bi); 748 - leaf_paste_in_buffer(&bi, item_pos - n + tb->rnum[0], pos_in_item, 749 - tb->insert_size[0], body, zeros_num); 765 + leaf_paste_in_buffer(&bi, tb->item_pos - n + tb->rnum[0], tb->pos_in_item, 766 + tb->insert_size[0], body, tb->zeroes_num); 750 767 } 751 768 752 769 /* paste new entry, if item is directory item */ 753 - pasted = item_head(tb->R[0], item_pos - n + tb->rnum[0]); 754 - if (is_direntry_le_ih(pasted) && pos_in_item >= 0) { 755 - leaf_paste_entries(&bi, item_pos - n + tb->rnum[0], 756 - pos_in_item, 1, 770 + pasted = item_head(tb->R[0], tb->item_pos - n + tb->rnum[0]); 771 + if (is_direntry_le_ih(pasted) && tb->pos_in_item >= 0) { 772 + leaf_paste_entries(&bi, tb->item_pos - n + tb->rnum[0], 773 + tb->pos_in_item, 1, 757 774 (struct reiserfs_de_head *) body, 758 775 body + DEH_SIZE, tb->insert_size[0]); 759 - if (!pos_in_item) { 776 + if (!tb->pos_in_item) { 760 777 761 - RFALSE(item_pos - n + tb->rnum[0], 778 + RFALSE(tb->item_pos - n + tb->rnum[0], 762 779 "PAP-12165: directory item must be first item of node when pasting is in 0th position"); 763 780 764 781 /* update delimiting keys */ ··· 768 785 769 786 if (is_indirect_le_ih(pasted)) 770 787 set_ih_free_space(pasted, 0); 771 - zeros_num = tb->insert_size[0] = 0; 788 + tb->zeroes_num = tb->insert_size[0] = 0; 772 789 } 773 790 } else { /* new item doesn't fall into R[0] */ 774 791 ··· 817 834 } 818 835 819 836 /* Fill new nodes that appear in place of S[0] */ 820 - 821 - /* I am told that this copying is because we need an array to enable 822 - the looping code. -Hans */ 823 - snum[0] = tb->s1num, snum[1] = tb->s2num; 824 - sbytes[0] = tb->s1bytes; 825 - sbytes[1] = tb->s2bytes; 826 837 for (i = tb->blknum[0] - 2; i >= 0; i--) { 827 838 828 - RFALSE(!snum[i], "PAP-12200: snum[%d] == %d. Must be > 0", i, 829 - snum[i]); 839 + RFALSE(!tb->snum[i], 840 + "PAP-12200: snum[%d] == %d. Must be > 0", i, 841 + tb->snum[i]); 830 842 831 843 /* here we shift from S to S_new nodes */ 832 844 833 - S_new[i] = get_FEB(tb); 845 + tb->S_new[i] = get_FEB(tb); 834 846 835 847 /* initialized block type and tree level */ 836 - set_blkh_level(B_BLK_HEAD(S_new[i]), DISK_LEAF_NODE_LEVEL); 848 + set_blkh_level(B_BLK_HEAD(tb->S_new[i]), DISK_LEAF_NODE_LEVEL); 837 849 838 850 n = B_NR_ITEMS(tbS0); 839 851 840 852 switch (flag) { 841 853 case M_INSERT: /* insert item */ 842 854 843 - if (n - snum[i] < item_pos) { /* new item or it's part falls to first new node S_new[i] */ 844 - if (item_pos == n - snum[i] + 1 && sbytes[i] != -1) { /* part of new item falls into S_new[i] */ 845 - int old_key_comp, old_len, r_zeros_number; 855 + if (n - tb->snum[i] < tb->item_pos) { /* new item or it's part falls to first new node S_new[i] */ 856 + if (tb->item_pos == n - tb->snum[i] + 1 && tb->sbytes[i] != -1) { /* part of new item falls into S_new[i] */ 857 + int old_key_comp, old_len, r_zeroes_number; 846 858 const char *r_body; 847 859 int version; 848 860 849 861 /* Move snum[i]-1 items from S[0] to S_new[i] */ 850 862 leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, 851 - snum[i] - 1, -1, 852 - S_new[i]); 863 + tb->snum[i] - 1, -1, 864 + tb->S_new[i]); 853 865 /* Remember key component and item length */ 854 866 version = ih_version(ih); 855 867 old_key_comp = le_ih_k_offset(ih); ··· 852 874 853 875 /* Calculate key component and item length to insert into S_new[i] */ 854 876 set_le_ih_k_offset(ih, le_ih_k_offset(ih) + 855 - ((old_len - sbytes[i]) << (is_indirect_le_ih(ih) ? tb->tb_sb-> s_blocksize_bits - UNFM_P_SHIFT : 0))); 877 + ((old_len - tb->sbytes[i]) << (is_indirect_le_ih(ih) ? tb->tb_sb->s_blocksize_bits - UNFM_P_SHIFT : 0))); 856 878 857 - put_ih_item_len(ih, sbytes[i]); 879 + put_ih_item_len(ih, tb->sbytes[i]); 858 880 859 881 /* Insert part of the item into S_new[i] before 0-th item */ 860 - buffer_info_init_bh(tb, &bi, S_new[i]); 882 + buffer_info_init_bh(tb, &bi, tb->S_new[i]); 861 883 862 - if ((old_len - sbytes[i]) > zeros_num) { 863 - r_zeros_number = 0; 864 - r_body = body + (old_len - sbytes[i]) - zeros_num; 884 + if ((old_len - tb->sbytes[i]) > tb->zeroes_num) { 885 + r_zeroes_number = 0; 886 + r_body = body + (old_len - tb->sbytes[i]) - tb->zeroes_num; 865 887 } else { 866 888 r_body = body; 867 - r_zeros_number = zeros_num - (old_len - sbytes[i]); 868 - zeros_num -= r_zeros_number; 889 + r_zeroes_number = tb->zeroes_num - (old_len - tb->sbytes[i]); 890 + tb->zeroes_num -= r_zeroes_number; 869 891 } 870 892 871 - leaf_insert_into_buf(&bi, 0, ih, r_body, r_zeros_number); 893 + leaf_insert_into_buf(&bi, 0, ih, r_body, r_zeroes_number); 872 894 873 895 /* Calculate key component and item length to insert into S[i] */ 874 896 set_le_ih_k_offset(ih, old_key_comp); 875 - put_ih_item_len(ih, old_len - sbytes[i]); 876 - tb->insert_size[0] -= sbytes[i]; 897 + put_ih_item_len(ih, old_len - tb->sbytes[i]); 898 + tb->insert_size[0] -= tb->sbytes[i]; 877 899 } else { /* whole new item falls into S_new[i] */ 878 900 879 901 /* Shift snum[0] - 1 items to S_new[i] (sbytes[i] of split item) */ 880 902 leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, 881 - snum[i] - 1, sbytes[i], S_new[i]); 903 + tb->snum[i] - 1, tb->sbytes[i], tb->S_new[i]); 882 904 883 905 /* Insert new item into S_new[i] */ 884 - buffer_info_init_bh(tb, &bi, S_new[i]); 885 - leaf_insert_into_buf(&bi, item_pos - n + snum[i] - 1, 886 - ih, body, zeros_num); 906 + buffer_info_init_bh(tb, &bi, tb->S_new[i]); 907 + leaf_insert_into_buf(&bi, tb->item_pos - n + tb->snum[i] - 1, 908 + ih, body, tb->zeroes_num); 887 909 888 - zeros_num = tb->insert_size[0] = 0; 910 + tb->zeroes_num = tb->insert_size[0] = 0; 889 911 } 890 912 } 891 913 892 914 else { /* new item or it part don't falls into S_new[i] */ 893 915 894 916 leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, 895 - snum[i], sbytes[i], S_new[i]); 917 + tb->snum[i], tb->sbytes[i], tb->S_new[i]); 896 918 } 897 919 break; 898 920 899 921 case M_PASTE: /* append item */ 900 922 901 - if (n - snum[i] <= item_pos) { /* pasted item or part if it falls to S_new[i] */ 902 - if (item_pos == n - snum[i] && sbytes[i] != -1) { /* we must shift part of the appended item */ 923 + if (n - tb->snum[i] <= tb->item_pos) { /* pasted item or part if it falls to S_new[i] */ 924 + if (tb->item_pos == n - tb->snum[i] && tb->sbytes[i] != -1) { /* we must shift part of the appended item */ 903 925 struct item_head *aux_ih; 904 926 905 927 RFALSE(ih, "PAP-12210: ih must be 0"); 906 928 907 - aux_ih = item_head(tbS0, item_pos); 929 + aux_ih = item_head(tbS0, tb->item_pos); 908 930 if (is_direntry_le_ih(aux_ih)) { 909 931 /* we append to directory item */ 910 932 ··· 912 934 913 935 entry_count = ih_entry_count(aux_ih); 914 936 915 - if (entry_count - sbytes[i] < pos_in_item && pos_in_item <= entry_count) { 937 + if (entry_count - tb->sbytes[i] < tb->pos_in_item && tb->pos_in_item <= entry_count) { 916 938 /* new directory entry falls into S_new[i] */ 917 939 918 940 RFALSE(!tb->insert_size[0], "PAP-12215: insert_size is already 0"); 919 - RFALSE(sbytes[i] - 1 >= entry_count, 941 + RFALSE(tb->sbytes[i] - 1 >= entry_count, 920 942 "PAP-12220: there are no so much entries (%d), only %d", 921 - sbytes[i] - 1, entry_count); 943 + tb->sbytes[i] - 1, entry_count); 922 944 923 945 /* Shift snum[i]-1 items in whole. Shift sbytes[i] directory entries from directory item number snum[i] */ 924 - leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, snum[i], sbytes[i] - 1, S_new[i]); 946 + leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, tb->snum[i], tb->sbytes[i] - 1, tb->S_new[i]); 925 947 /* Paste given directory entry to directory item */ 926 - buffer_info_init_bh(tb, &bi, S_new[i]); 927 - leaf_paste_in_buffer(&bi, 0, pos_in_item - entry_count + sbytes[i] - 1, 928 - tb->insert_size[0], body, zeros_num); 948 + buffer_info_init_bh(tb, &bi, tb->S_new[i]); 949 + leaf_paste_in_buffer(&bi, 0, tb->pos_in_item - entry_count + tb->sbytes[i] - 1, 950 + tb->insert_size[0], body, tb->zeroes_num); 929 951 /* paste new directory entry */ 930 - leaf_paste_entries(&bi, 0, pos_in_item - entry_count + sbytes[i] - 1, 1, 952 + leaf_paste_entries(&bi, 0, tb->pos_in_item - entry_count + tb->sbytes[i] - 1, 1, 931 953 (struct reiserfs_de_head *) body, 932 954 body + DEH_SIZE, tb->insert_size[0]); 933 955 tb->insert_size[0] = 0; 934 - pos_in_item++; 956 + tb->pos_in_item++; 935 957 } else { /* new directory entry doesn't fall into S_new[i] */ 936 - leaf_move_items(LEAF_FROM_S_TO_SNEW,tb, snum[i], sbytes[i], S_new[i]); 958 + leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, tb->snum[i], tb->sbytes[i], tb->S_new[i]); 937 959 } 938 960 } else { /* regular object */ 939 961 940 - int n_shift, n_rem, r_zeros_number; 962 + int n_shift, n_rem, r_zeroes_number; 941 963 const char *r_body; 942 964 943 - RFALSE(pos_in_item != ih_item_len(item_head(tbS0, item_pos)) || tb->insert_size[0] <= 0, 965 + RFALSE(tb->pos_in_item != ih_item_len(item_head(tbS0, tb->item_pos)) || tb->insert_size[0] <= 0, 944 966 "PAP-12225: item too short or insert_size <= 0"); 945 967 946 968 /* Calculate number of bytes which must be shifted from appended item */ 947 - n_shift = sbytes[i] - tb->insert_size[0]; 969 + n_shift = tb->sbytes[i] - tb->insert_size[0]; 948 970 if (n_shift < 0) 949 971 n_shift = 0; 950 - leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, snum[i], n_shift, S_new[i]); 972 + leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, tb->snum[i], n_shift, tb->S_new[i]); 951 973 952 974 /* Calculate number of bytes which must remain in body after append to S_new[i] */ 953 - n_rem = tb->insert_size[0] - sbytes[i]; 975 + n_rem = tb->insert_size[0] - tb->sbytes[i]; 954 976 if (n_rem < 0) 955 977 n_rem = 0; 956 978 /* Append part of body into S_new[0] */ 957 - buffer_info_init_bh(tb, &bi, S_new[i]); 958 - if (n_rem > zeros_num) { 959 - r_zeros_number = 0; 960 - r_body = body + n_rem - zeros_num; 979 + buffer_info_init_bh(tb, &bi, tb->S_new[i]); 980 + if (n_rem > tb->zeroes_num) { 981 + r_zeroes_number = 0; 982 + r_body = body + n_rem - tb->zeroes_num; 961 983 } else { 962 984 r_body = body; 963 - r_zeros_number = zeros_num - n_rem; 964 - zeros_num -= r_zeros_number; 985 + r_zeroes_number = tb->zeroes_num - n_rem; 986 + tb->zeroes_num -= r_zeroes_number; 965 987 } 966 988 967 989 leaf_paste_in_buffer(&bi, 0, n_shift, 968 990 tb->insert_size[0] - n_rem, 969 - r_body, r_zeros_number); 991 + r_body, r_zeroes_number); 970 992 { 971 993 struct item_head *tmp; 972 994 973 - tmp = item_head(S_new[i], 0); 995 + tmp = item_head(tb->S_new[i], 0); 974 996 if (is_indirect_le_ih 975 997 (tmp)) { 976 998 set_ih_free_space(tmp, 0); ··· 982 1004 983 1005 tb->insert_size[0] = n_rem; 984 1006 if (!n_rem) 985 - pos_in_item++; 1007 + tb->pos_in_item++; 986 1008 } 987 1009 } else 988 1010 /* item falls wholly into S_new[i] */ ··· 991 1013 struct item_head *pasted; 992 1014 993 1015 #ifdef CONFIG_REISERFS_CHECK 994 - struct item_head *ih_check = item_head(tbS0, item_pos); 1016 + struct item_head *ih_check = item_head(tbS0, tb->item_pos); 995 1017 996 1018 if (!is_direntry_le_ih(ih_check) 997 - && (pos_in_item != ih_item_len(ih_check) 1019 + && (tb->pos_in_item != ih_item_len(ih_check) 998 1020 || tb->insert_size[0] <= 0)) 999 1021 reiserfs_panic(tb->tb_sb, 1000 1022 "PAP-12235", ··· 1004 1026 #endif /* CONFIG_REISERFS_CHECK */ 1005 1027 1006 1028 leaf_mi = leaf_move_items(LEAF_FROM_S_TO_SNEW, 1007 - tb, snum[i], 1008 - sbytes[i], 1009 - S_new[i]); 1029 + tb, tb->snum[i], 1030 + tb->sbytes[i], 1031 + tb->S_new[i]); 1010 1032 1011 1033 RFALSE(leaf_mi, 1012 1034 "PAP-12240: unexpected value returned by leaf_move_items (%d)", 1013 1035 leaf_mi); 1014 1036 1015 1037 /* paste into item */ 1016 - buffer_info_init_bh(tb, &bi, S_new[i]); 1038 + buffer_info_init_bh(tb, &bi, tb->S_new[i]); 1017 1039 leaf_paste_in_buffer(&bi, 1018 - item_pos - n + snum[i], 1019 - pos_in_item, 1040 + tb->item_pos - n + tb->snum[i], 1041 + tb->pos_in_item, 1020 1042 tb->insert_size[0], 1021 - body, zeros_num); 1043 + body, tb->zeroes_num); 1022 1044 1023 - pasted = item_head(S_new[i], item_pos - n + snum[i]); 1045 + pasted = item_head(tb->S_new[i], tb->item_pos - n + tb->snum[i]); 1024 1046 if (is_direntry_le_ih(pasted)) { 1025 1047 leaf_paste_entries(&bi, 1026 - item_pos - n + snum[i], 1027 - pos_in_item, 1, 1048 + tb->item_pos - n + tb->snum[i], 1049 + tb->pos_in_item, 1, 1028 1050 (struct reiserfs_de_head *)body, 1029 1051 body + DEH_SIZE, 1030 1052 tb->insert_size[0] ··· 1034 1056 /* if we paste to indirect item update ih_free_space */ 1035 1057 if (is_indirect_le_ih(pasted)) 1036 1058 set_ih_free_space(pasted, 0); 1037 - zeros_num = tb->insert_size[0] = 0; 1059 + tb->zeroes_num = tb->insert_size[0] = 0; 1038 1060 } 1039 1061 } 1040 1062 1041 1063 else { /* pasted item doesn't fall into S_new[i] */ 1042 1064 1043 1065 leaf_move_items(LEAF_FROM_S_TO_SNEW, tb, 1044 - snum[i], sbytes[i], S_new[i]); 1066 + tb->snum[i], tb->sbytes[i], tb->S_new[i]); 1045 1067 } 1046 1068 break; 1047 1069 default: /* cases d and t */ ··· 1050 1072 (flag == M_DELETE) ? "DELETE" : ((flag == M_CUT) ? "CUT" : "UNKNOWN"), flag); 1051 1073 } 1052 1074 1053 - memcpy(insert_key + i, leaf_key(S_new[i], 0), KEY_SIZE); 1054 - insert_ptr[i] = S_new[i]; 1075 + memcpy(insert_key + i, leaf_key(tb->S_new[i], 0), KEY_SIZE); 1076 + insert_ptr[i] = tb->S_new[i]; 1055 1077 1056 - RFALSE(!buffer_journaled(S_new[i]) 1057 - || buffer_journal_dirty(S_new[i]) 1058 - || buffer_dirty(S_new[i]), "PAP-12247: S_new[%d] : (%b)", 1059 - i, S_new[i]); 1078 + RFALSE(!buffer_journaled(tb->S_new[i]) 1079 + || buffer_journal_dirty(tb->S_new[i]) 1080 + || buffer_dirty(tb->S_new[i]), 1081 + "PAP-12247: S_new[%d] : (%b)", 1082 + i, tb->S_new[i]); 1060 1083 } 1061 1084 1062 1085 /* if the affected item was not wholly shifted then we perform all necessary operations on that part or whole of the 1063 1086 affected item which remains in S */ 1064 - if (0 <= item_pos && item_pos < tb->s0num) { /* if we must insert or append into buffer S[0] */ 1087 + if (0 <= tb->item_pos && tb->item_pos < tb->s0num) { /* if we must insert or append into buffer S[0] */ 1065 1088 1066 1089 switch (flag) { 1067 1090 case M_INSERT: /* insert item into S[0] */ 1068 1091 buffer_info_init_tbS0(tb, &bi); 1069 - leaf_insert_into_buf(&bi, item_pos, ih, body, 1070 - zeros_num); 1092 + leaf_insert_into_buf(&bi, tb->item_pos, ih, 1093 + body, tb->zeroes_num); 1071 1094 1072 1095 /* If we insert the first key change the delimiting key */ 1073 - if (item_pos == 0) { 1096 + if (tb->item_pos == 0) { 1074 1097 if (tb->CFL[0]) /* can be 0 in reiserfsck */ 1075 1098 replace_key(tb, tb->CFL[0], tb->lkey[0], tbS0, 0); 1076 1099 } ··· 1080 1101 case M_PASTE:{ /* append item in S[0] */ 1081 1102 struct item_head *pasted; 1082 1103 1083 - pasted = item_head(tbS0, item_pos); 1104 + pasted = item_head(tbS0, tb->item_pos); 1084 1105 /* when directory, may be new entry already pasted */ 1085 1106 if (is_direntry_le_ih(pasted)) { 1086 - if (pos_in_item >= 0 && pos_in_item <= ih_entry_count(pasted)) { 1107 + if (tb->pos_in_item >= 0 && tb->pos_in_item <= ih_entry_count(pasted)) { 1087 1108 1088 1109 RFALSE(!tb->insert_size[0], 1089 1110 "PAP-12260: insert_size is 0 already"); 1090 1111 1091 1112 /* prepare space */ 1092 1113 buffer_info_init_tbS0(tb, &bi); 1093 - leaf_paste_in_buffer(&bi, item_pos, pos_in_item, 1114 + leaf_paste_in_buffer(&bi, tb->item_pos, tb->pos_in_item, 1094 1115 tb->insert_size[0], body, 1095 - zeros_num); 1116 + tb->zeroes_num); 1096 1117 1097 1118 /* paste entry */ 1098 - leaf_paste_entries(&bi, item_pos, pos_in_item, 1, 1119 + leaf_paste_entries(&bi, tb->item_pos, tb->pos_in_item, 1, 1099 1120 (struct reiserfs_de_head *)body, 1100 1121 body + DEH_SIZE, 1101 1122 tb->insert_size[0]); 1102 - if (!item_pos && !pos_in_item) { 1123 + if (!tb->item_pos && !tb->pos_in_item) { 1103 1124 RFALSE(!tb->CFL[0] || !tb->L[0], 1104 1125 "PAP-12270: CFL[0]/L[0] must be specified"); 1105 1126 if (tb->CFL[0]) ··· 1108 1129 tb->insert_size[0] = 0; 1109 1130 } 1110 1131 } else { /* regular object */ 1111 - if (pos_in_item == ih_item_len(pasted)) { 1132 + if (tb->pos_in_item == ih_item_len(pasted)) { 1112 1133 1113 1134 RFALSE(tb->insert_size[0] <= 0, 1114 1135 "PAP-12275: insert size must not be %d", 1115 1136 tb->insert_size[0]); 1116 1137 buffer_info_init_tbS0(tb, &bi); 1117 - leaf_paste_in_buffer(&bi, item_pos, pos_in_item, 1118 - tb->insert_size[0], body, zeros_num); 1138 + leaf_paste_in_buffer(&bi, tb->item_pos, tb->pos_in_item, 1139 + tb->insert_size[0], body, tb->zeroes_num); 1119 1140 1120 1141 if (is_indirect_le_ih(pasted)) { 1121 1142 #if 0

+5 -4

fs/reiserfs/fix_node.c

··· 631 631 /* only for leaf level */ 632 632 if (h == 0) { 633 633 if (s012 != NULL) { 634 - tb->s0num = *s012++, 635 - tb->s1num = *s012++, tb->s2num = *s012++; 636 - tb->s1bytes = *s012++; 637 - tb->s2bytes = *s012; 634 + tb->s0num = *s012++; 635 + tb->snum[0] = *s012++; 636 + tb->snum[1] = *s012++; 637 + tb->sbytes[0] = *s012++; 638 + tb->sbytes[1] = *s012; 638 639 } 639 640 tb->lbytes = lb; 640 641 tb->rbytes = rb;

+3 -3

fs/reiserfs/prints.c

··· 673 673 "* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n" 674 674 "* 0 * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n", 675 675 tb->insert_size[0], tb->lnum[0], tb->lbytes, tb->rnum[0], 676 - tb->rbytes, tb->blknum[0], tb->s0num, tb->s1num, tb->s1bytes, 677 - tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[0], 678 - tb->rkey[0]); 676 + tb->rbytes, tb->blknum[0], tb->s0num, tb->snum[0], 677 + tb->sbytes[0], tb->snum[1], tb->sbytes[1], 678 + tb->cur_blknum, tb->lkey[0], tb->rkey[0]); 679 679 680 680 /* this prints balance parameters for non-leaf levels */ 681 681 h = 0;

+21 -9

fs/reiserfs/reiserfs.h

··· 2471 2471 /* number of items that fall into left most node when S[0] splits */ 2472 2472 int s0num; 2473 2473 2474 - /* number of items that fall into first new node when S[0] splits */ 2475 - int s1num; 2476 - 2477 - /* number of items that fall into second new node when S[0] splits */ 2478 - int s2num; 2479 - 2480 2474 /* 2481 2475 * number of bytes which can flow to the left neighbor from the left 2482 2476 * most liquid item that cannot be shifted from S[0] entirely ··· 2485 2491 */ 2486 2492 int rbytes; 2487 2493 2494 + 2488 2495 /* 2489 - * number of bytes which flow to the first new node when S[0] splits 2496 + * index into the array of item headers in 2497 + * S[0] of the affected item 2498 + */ 2499 + int item_pos; 2500 + 2501 + /* new nodes allocated to hold what could not fit into S */ 2502 + struct buffer_head *S_new[2]; 2503 + 2504 + /* 2505 + * number of items that will be placed into nodes in S_new 2506 + * when S[0] splits 2507 + */ 2508 + int snum[2]; 2509 + 2510 + /* 2511 + * number of bytes which flow to nodes in S_new when S[0] splits 2490 2512 * note: if S[0] splits into 3 nodes, then items do not need to be cut 2491 2513 */ 2492 - int s1bytes; 2493 - int s2bytes; 2514 + int sbytes[2]; 2515 + 2516 + int pos_in_item; 2517 + int zeroes_num; 2494 2518 2495 2519 /* 2496 2520 * buffers which are to be freed after do_balance finishes