1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5 #include <linux/uaccess.h> 6 #include <linux/string.h> 7 #include <linux/time.h> 8 #include "reiserfs.h" 9 #include <linux/buffer_head.h> 10 11 /* 12 * copy copy_count entries from source directory item to dest buffer 13 * (creating new item if needed) 14 */ 15 static void leaf_copy_dir_entries(struct buffer_info *dest_bi, 16 struct buffer_head *source, int last_first, 17 int item_num, int from, int copy_count) 18 { 19 struct buffer_head *dest = dest_bi->bi_bh; 20 /* 21 * either the number of target item, or if we must create a 22 * new item, the number of the item we will create it next to 23 */ 24 int item_num_in_dest; 25 26 struct item_head *ih; 27 struct reiserfs_de_head *deh; 28 int copy_records_len; /* length of all records in item to be copied */ 29 char *records; 30 31 ih = item_head(source, item_num); 32 33 RFALSE(!is_direntry_le_ih(ih), "vs-10000: item must be directory item"); 34 35 /* 36 * length of all record to be copied and first byte of 37 * the last of them 38 */ 39 deh = B_I_DEH(source, ih); 40 if (copy_count) { 41 copy_records_len = (from ? deh_location(&deh[from - 1]) : 42 ih_item_len(ih)) - 43 deh_location(&deh[from + copy_count - 1]); 44 records = 45 source->b_data + ih_location(ih) + 46 deh_location(&deh[from + copy_count - 1]); 47 } else { 48 copy_records_len = 0; 49 records = NULL; 50 } 51 52 /* when copy last to first, dest buffer can contain 0 items */ 53 item_num_in_dest = 54 (last_first == 55 LAST_TO_FIRST) ? ((B_NR_ITEMS(dest)) ? 0 : -1) : (B_NR_ITEMS(dest) 56 - 1); 57 58 /* 59 * if there are no items in dest or the first/last item in 60 * dest is not item of the same directory 61 */ 62 if ((item_num_in_dest == -1) || 63 (last_first == FIRST_TO_LAST && le_ih_k_offset(ih) == DOT_OFFSET) || 64 (last_first == LAST_TO_FIRST 65 && comp_short_le_keys /*COMP_SHORT_KEYS */ (&ih->ih_key, 66 leaf_key(dest, 67 item_num_in_dest)))) 68 { 69 /* create new item in dest */ 70 struct item_head new_ih; 71 72 /* form item header */ 73 memcpy(&new_ih.ih_key, &ih->ih_key, KEY_SIZE); 74 put_ih_version(&new_ih, KEY_FORMAT_3_5); 75 /* calculate item len */ 76 put_ih_item_len(&new_ih, 77 DEH_SIZE * copy_count + copy_records_len); 78 put_ih_entry_count(&new_ih, 0); 79 80 if (last_first == LAST_TO_FIRST) { 81 /* form key by the following way */ 82 if (from < ih_entry_count(ih)) { 83 set_le_ih_k_offset(&new_ih, 84 deh_offset(&deh[from])); 85 } else { 86 /* 87 * no entries will be copied to this 88 * item in this function 89 */ 90 set_le_ih_k_offset(&new_ih, U32_MAX); 91 /* 92 * this item is not yet valid, but we 93 * want I_IS_DIRECTORY_ITEM to return 1 94 * for it, so we -1 95 */ 96 } 97 set_le_key_k_type(KEY_FORMAT_3_5, &new_ih.ih_key, 98 TYPE_DIRENTRY); 99 } 100 101 /* insert item into dest buffer */ 102 leaf_insert_into_buf(dest_bi, 103 (last_first == 104 LAST_TO_FIRST) ? 0 : B_NR_ITEMS(dest), 105 &new_ih, NULL, 0); 106 } else { 107 /* prepare space for entries */ 108 leaf_paste_in_buffer(dest_bi, 109 (last_first == 110 FIRST_TO_LAST) ? (B_NR_ITEMS(dest) - 111 1) : 0, MAX_US_INT, 112 DEH_SIZE * copy_count + copy_records_len, 113 records, 0); 114 } 115 116 item_num_in_dest = 117 (last_first == FIRST_TO_LAST) ? (B_NR_ITEMS(dest) - 1) : 0; 118 119 leaf_paste_entries(dest_bi, item_num_in_dest, 120 (last_first == 121 FIRST_TO_LAST) ? ih_entry_count(item_head(dest, 122 item_num_in_dest)) 123 : 0, copy_count, deh + from, records, 124 DEH_SIZE * copy_count + copy_records_len); 125 } 126 127 /* 128 * Copy the first (if last_first == FIRST_TO_LAST) or last 129 * (last_first == LAST_TO_FIRST) item or part of it or nothing 130 * (see the return 0 below) from SOURCE to the end (if last_first) 131 * or beginning (!last_first) of the DEST 132 */ 133 /* returns 1 if anything was copied, else 0 */ 134 static int leaf_copy_boundary_item(struct buffer_info *dest_bi, 135 struct buffer_head *src, int last_first, 136 int bytes_or_entries) 137 { 138 struct buffer_head *dest = dest_bi->bi_bh; 139 /* number of items in the source and destination buffers */ 140 int dest_nr_item, src_nr_item; 141 struct item_head *ih; 142 struct item_head *dih; 143 144 dest_nr_item = B_NR_ITEMS(dest); 145 146 /* 147 * if ( DEST is empty or first item of SOURCE and last item of 148 * DEST are the items of different objects or of different types ) 149 * then there is no need to treat this item differently from the 150 * other items that we copy, so we return 151 */ 152 if (last_first == FIRST_TO_LAST) { 153 ih = item_head(src, 0); 154 dih = item_head(dest, dest_nr_item - 1); 155 156 /* there is nothing to merge */ 157 if (!dest_nr_item 158 || (!op_is_left_mergeable(&ih->ih_key, src->b_size))) 159 return 0; 160 161 RFALSE(!ih_item_len(ih), 162 "vs-10010: item can not have empty length"); 163 164 if (is_direntry_le_ih(ih)) { 165 if (bytes_or_entries == -1) 166 /* copy all entries to dest */ 167 bytes_or_entries = ih_entry_count(ih); 168 leaf_copy_dir_entries(dest_bi, src, FIRST_TO_LAST, 0, 0, 169 bytes_or_entries); 170 return 1; 171 } 172 173 /* 174 * copy part of the body of the first item of SOURCE 175 * to the end of the body of the last item of the DEST 176 * part defined by 'bytes_or_entries'; if bytes_or_entries 177 * == -1 copy whole body; don't create new item header 178 */ 179 if (bytes_or_entries == -1) 180 bytes_or_entries = ih_item_len(ih); 181 182 #ifdef CONFIG_REISERFS_CHECK 183 else { 184 if (bytes_or_entries == ih_item_len(ih) 185 && is_indirect_le_ih(ih)) 186 if (get_ih_free_space(ih)) 187 reiserfs_panic(sb_from_bi(dest_bi), 188 "vs-10020", 189 "last unformatted node " 190 "must be filled " 191 "entirely (%h)", ih); 192 } 193 #endif 194 195 /* 196 * merge first item (or its part) of src buffer with the last 197 * item of dest buffer. Both are of the same file 198 */ 199 leaf_paste_in_buffer(dest_bi, 200 dest_nr_item - 1, ih_item_len(dih), 201 bytes_or_entries, ih_item_body(src, ih), 0); 202 203 if (is_indirect_le_ih(dih)) { 204 RFALSE(get_ih_free_space(dih), 205 "vs-10030: merge to left: last unformatted node of non-last indirect item %h must have zerto free space", 206 ih); 207 if (bytes_or_entries == ih_item_len(ih)) 208 set_ih_free_space(dih, get_ih_free_space(ih)); 209 } 210 211 return 1; 212 } 213 214 /* copy boundary item to right (last_first == LAST_TO_FIRST) */ 215 216 /* 217 * (DEST is empty or last item of SOURCE and first item of DEST 218 * are the items of different object or of different types) 219 */ 220 src_nr_item = B_NR_ITEMS(src); 221 ih = item_head(src, src_nr_item - 1); 222 dih = item_head(dest, 0); 223 224 if (!dest_nr_item || !op_is_left_mergeable(&dih->ih_key, src->b_size)) 225 return 0; 226 227 if (is_direntry_le_ih(ih)) { 228 /* 229 * bytes_or_entries = entries number in last 230 * item body of SOURCE 231 */ 232 if (bytes_or_entries == -1) 233 bytes_or_entries = ih_entry_count(ih); 234 235 leaf_copy_dir_entries(dest_bi, src, LAST_TO_FIRST, 236 src_nr_item - 1, 237 ih_entry_count(ih) - bytes_or_entries, 238 bytes_or_entries); 239 return 1; 240 } 241 242 /* 243 * copy part of the body of the last item of SOURCE to the 244 * begin of the body of the first item of the DEST; part defined 245 * by 'bytes_or_entries'; if byte_or_entriess == -1 copy whole body; 246 * change first item key of the DEST; don't create new item header 247 */ 248 249 RFALSE(is_indirect_le_ih(ih) && get_ih_free_space(ih), 250 "vs-10040: merge to right: last unformatted node of non-last indirect item must be filled entirely (%h)", 251 ih); 252 253 if (bytes_or_entries == -1) { 254 /* bytes_or_entries = length of last item body of SOURCE */ 255 bytes_or_entries = ih_item_len(ih); 256 257 RFALSE(le_ih_k_offset(dih) != 258 le_ih_k_offset(ih) + op_bytes_number(ih, src->b_size), 259 "vs-10050: items %h and %h do not match", ih, dih); 260 261 /* change first item key of the DEST */ 262 set_le_ih_k_offset(dih, le_ih_k_offset(ih)); 263 264 /* item becomes non-mergeable */ 265 /* or mergeable if left item was */ 266 set_le_ih_k_type(dih, le_ih_k_type(ih)); 267 } else { 268 /* merge to right only part of item */ 269 RFALSE(ih_item_len(ih) <= bytes_or_entries, 270 "vs-10060: no so much bytes %lu (needed %lu)", 271 (unsigned long)ih_item_len(ih), 272 (unsigned long)bytes_or_entries); 273 274 /* change first item key of the DEST */ 275 if (is_direct_le_ih(dih)) { 276 RFALSE(le_ih_k_offset(dih) <= 277 (unsigned long)bytes_or_entries, 278 "vs-10070: dih %h, bytes_or_entries(%d)", dih, 279 bytes_or_entries); 280 set_le_ih_k_offset(dih, 281 le_ih_k_offset(dih) - 282 bytes_or_entries); 283 } else { 284 RFALSE(le_ih_k_offset(dih) <= 285 (bytes_or_entries / UNFM_P_SIZE) * dest->b_size, 286 "vs-10080: dih %h, bytes_or_entries(%d)", 287 dih, 288 (bytes_or_entries / UNFM_P_SIZE) * dest->b_size); 289 set_le_ih_k_offset(dih, 290 le_ih_k_offset(dih) - 291 ((bytes_or_entries / UNFM_P_SIZE) * 292 dest->b_size)); 293 } 294 } 295 296 leaf_paste_in_buffer(dest_bi, 0, 0, bytes_or_entries, 297 ih_item_body(src, 298 ih) + ih_item_len(ih) - bytes_or_entries, 299 0); 300 return 1; 301 } 302 303 /* 304 * copy cpy_mun items from buffer src to buffer dest 305 * last_first == FIRST_TO_LAST means, that we copy cpy_num items beginning 306 * from first-th item in src to tail of dest 307 * last_first == LAST_TO_FIRST means, that we copy cpy_num items beginning 308 * from first-th item in src to head of dest 309 */ 310 static void leaf_copy_items_entirely(struct buffer_info *dest_bi, 311 struct buffer_head *src, int last_first, 312 int first, int cpy_num) 313 { 314 struct buffer_head *dest; 315 int nr, free_space; 316 int dest_before; 317 int last_loc, last_inserted_loc, location; 318 int i, j; 319 struct block_head *blkh; 320 struct item_head *ih; 321 322 RFALSE(last_first != LAST_TO_FIRST && last_first != FIRST_TO_LAST, 323 "vs-10090: bad last_first parameter %d", last_first); 324 RFALSE(B_NR_ITEMS(src) - first < cpy_num, 325 "vs-10100: too few items in source %d, required %d from %d", 326 B_NR_ITEMS(src), cpy_num, first); 327 RFALSE(cpy_num < 0, "vs-10110: can not copy negative amount of items"); 328 RFALSE(!dest_bi, "vs-10120: can not copy negative amount of items"); 329 330 dest = dest_bi->bi_bh; 331 332 RFALSE(!dest, "vs-10130: can not copy negative amount of items"); 333 334 if (cpy_num == 0) 335 return; 336 337 blkh = B_BLK_HEAD(dest); 338 nr = blkh_nr_item(blkh); 339 free_space = blkh_free_space(blkh); 340 341 /* 342 * we will insert items before 0-th or nr-th item in dest buffer. 343 * It depends of last_first parameter 344 */ 345 dest_before = (last_first == LAST_TO_FIRST) ? 0 : nr; 346 347 /* location of head of first new item */ 348 ih = item_head(dest, dest_before); 349 350 RFALSE(blkh_free_space(blkh) < cpy_num * IH_SIZE, 351 "vs-10140: not enough free space for headers %d (needed %d)", 352 B_FREE_SPACE(dest), cpy_num * IH_SIZE); 353 354 /* prepare space for headers */ 355 memmove(ih + cpy_num, ih, (nr - dest_before) * IH_SIZE); 356 357 /* copy item headers */ 358 memcpy(ih, item_head(src, first), cpy_num * IH_SIZE); 359 360 free_space -= (IH_SIZE * cpy_num); 361 set_blkh_free_space(blkh, free_space); 362 363 /* location of unmovable item */ 364 j = location = (dest_before == 0) ? dest->b_size : ih_location(ih - 1); 365 for (i = dest_before; i < nr + cpy_num; i++) { 366 location -= ih_item_len(ih + i - dest_before); 367 put_ih_location(ih + i - dest_before, location); 368 } 369 370 /* prepare space for items */ 371 last_loc = ih_location(&ih[nr + cpy_num - 1 - dest_before]); 372 last_inserted_loc = ih_location(&ih[cpy_num - 1]); 373 374 /* check free space */ 375 RFALSE(free_space < j - last_inserted_loc, 376 "vs-10150: not enough free space for items %d (needed %d)", 377 free_space, j - last_inserted_loc); 378 379 memmove(dest->b_data + last_loc, 380 dest->b_data + last_loc + j - last_inserted_loc, 381 last_inserted_loc - last_loc); 382 383 /* copy items */ 384 memcpy(dest->b_data + last_inserted_loc, 385 item_body(src, (first + cpy_num - 1)), 386 j - last_inserted_loc); 387 388 /* sizes, item number */ 389 set_blkh_nr_item(blkh, nr + cpy_num); 390 set_blkh_free_space(blkh, free_space - (j - last_inserted_loc)); 391 392 do_balance_mark_leaf_dirty(dest_bi->tb, dest, 0); 393 394 if (dest_bi->bi_parent) { 395 struct disk_child *t_dc; 396 t_dc = B_N_CHILD(dest_bi->bi_parent, dest_bi->bi_position); 397 RFALSE(dc_block_number(t_dc) != dest->b_blocknr, 398 "vs-10160: block number in bh does not match to field in disk_child structure %lu and %lu", 399 (long unsigned)dest->b_blocknr, 400 (long unsigned)dc_block_number(t_dc)); 401 put_dc_size(t_dc, 402 dc_size(t_dc) + (j - last_inserted_loc + 403 IH_SIZE * cpy_num)); 404 405 do_balance_mark_internal_dirty(dest_bi->tb, dest_bi->bi_parent, 406 0); 407 } 408 } 409 410 /* 411 * This function splits the (liquid) item into two items (useful when 412 * shifting part of an item into another node.) 413 */ 414 static void leaf_item_bottle(struct buffer_info *dest_bi, 415 struct buffer_head *src, int last_first, 416 int item_num, int cpy_bytes) 417 { 418 struct buffer_head *dest = dest_bi->bi_bh; 419 struct item_head *ih; 420 421 RFALSE(cpy_bytes == -1, 422 "vs-10170: bytes == - 1 means: do not split item"); 423 424 if (last_first == FIRST_TO_LAST) { 425 /* 426 * if ( if item in position item_num in buffer SOURCE 427 * is directory item ) 428 */ 429 ih = item_head(src, item_num); 430 if (is_direntry_le_ih(ih)) 431 leaf_copy_dir_entries(dest_bi, src, FIRST_TO_LAST, 432 item_num, 0, cpy_bytes); 433 else { 434 struct item_head n_ih; 435 436 /* 437 * copy part of the body of the item number 'item_num' 438 * of SOURCE to the end of the DEST part defined by 439 * 'cpy_bytes'; create new item header; change old 440 * item_header (????); n_ih = new item_header; 441 */ 442 memcpy(&n_ih, ih, IH_SIZE); 443 put_ih_item_len(&n_ih, cpy_bytes); 444 if (is_indirect_le_ih(ih)) { 445 RFALSE(cpy_bytes == ih_item_len(ih) 446 && get_ih_free_space(ih), 447 "vs-10180: when whole indirect item is bottle to left neighbor, it must have free_space==0 (not %lu)", 448 (long unsigned)get_ih_free_space(ih)); 449 set_ih_free_space(&n_ih, 0); 450 } 451 452 RFALSE(op_is_left_mergeable(&ih->ih_key, src->b_size), 453 "vs-10190: bad mergeability of item %h", ih); 454 n_ih.ih_version = ih->ih_version; /* JDM Endian safe, both le */ 455 leaf_insert_into_buf(dest_bi, B_NR_ITEMS(dest), &n_ih, 456 item_body(src, item_num), 0); 457 } 458 } else { 459 /* 460 * if ( if item in position item_num in buffer 461 * SOURCE is directory item ) 462 */ 463 ih = item_head(src, item_num); 464 if (is_direntry_le_ih(ih)) 465 leaf_copy_dir_entries(dest_bi, src, LAST_TO_FIRST, 466 item_num, 467 ih_entry_count(ih) - cpy_bytes, 468 cpy_bytes); 469 else { 470 struct item_head n_ih; 471 472 /* 473 * copy part of the body of the item number 'item_num' 474 * of SOURCE to the begin of the DEST part defined by 475 * 'cpy_bytes'; create new item header; 476 * n_ih = new item_header; 477 */ 478 memcpy(&n_ih, ih, SHORT_KEY_SIZE); 479 480 /* Endian safe, both le */ 481 n_ih.ih_version = ih->ih_version; 482 483 if (is_direct_le_ih(ih)) { 484 set_le_ih_k_offset(&n_ih, 485 le_ih_k_offset(ih) + 486 ih_item_len(ih) - cpy_bytes); 487 set_le_ih_k_type(&n_ih, TYPE_DIRECT); 488 set_ih_free_space(&n_ih, MAX_US_INT); 489 } else { 490 /* indirect item */ 491 RFALSE(!cpy_bytes && get_ih_free_space(ih), 492 "vs-10200: ih->ih_free_space must be 0 when indirect item will be appended"); 493 set_le_ih_k_offset(&n_ih, 494 le_ih_k_offset(ih) + 495 (ih_item_len(ih) - 496 cpy_bytes) / UNFM_P_SIZE * 497 dest->b_size); 498 set_le_ih_k_type(&n_ih, TYPE_INDIRECT); 499 set_ih_free_space(&n_ih, get_ih_free_space(ih)); 500 } 501 502 /* set item length */ 503 put_ih_item_len(&n_ih, cpy_bytes); 504 505 /* Endian safe, both le */ 506 n_ih.ih_version = ih->ih_version; 507 508 leaf_insert_into_buf(dest_bi, 0, &n_ih, 509 item_body(src, item_num) + 510 ih_item_len(ih) - cpy_bytes, 0); 511 } 512 } 513 } 514 515 /* 516 * If cpy_bytes equals minus one than copy cpy_num whole items from SOURCE 517 * to DEST. If cpy_bytes not equal to minus one than copy cpy_num-1 whole 518 * items from SOURCE to DEST. From last item copy cpy_num bytes for regular 519 * item and cpy_num directory entries for directory item. 520 */ 521 static int leaf_copy_items(struct buffer_info *dest_bi, struct buffer_head *src, 522 int last_first, int cpy_num, int cpy_bytes) 523 { 524 struct buffer_head *dest; 525 int pos, i, src_nr_item, bytes; 526 527 dest = dest_bi->bi_bh; 528 RFALSE(!dest || !src, "vs-10210: !dest || !src"); 529 RFALSE(last_first != FIRST_TO_LAST && last_first != LAST_TO_FIRST, 530 "vs-10220:last_first != FIRST_TO_LAST && last_first != LAST_TO_FIRST"); 531 RFALSE(B_NR_ITEMS(src) < cpy_num, 532 "vs-10230: No enough items: %d, req. %d", B_NR_ITEMS(src), 533 cpy_num); 534 RFALSE(cpy_num < 0, "vs-10240: cpy_num < 0 (%d)", cpy_num); 535 536 if (cpy_num == 0) 537 return 0; 538 539 if (last_first == FIRST_TO_LAST) { 540 /* copy items to left */ 541 pos = 0; 542 if (cpy_num == 1) 543 bytes = cpy_bytes; 544 else 545 bytes = -1; 546 547 /* 548 * copy the first item or it part or nothing to the end of 549 * the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,0,bytes)) 550 */ 551 i = leaf_copy_boundary_item(dest_bi, src, FIRST_TO_LAST, bytes); 552 cpy_num -= i; 553 if (cpy_num == 0) 554 return i; 555 pos += i; 556 if (cpy_bytes == -1) 557 /* 558 * copy first cpy_num items starting from position 559 * 'pos' of SOURCE to end of DEST 560 */ 561 leaf_copy_items_entirely(dest_bi, src, FIRST_TO_LAST, 562 pos, cpy_num); 563 else { 564 /* 565 * copy first cpy_num-1 items starting from position 566 * 'pos-1' of the SOURCE to the end of the DEST 567 */ 568 leaf_copy_items_entirely(dest_bi, src, FIRST_TO_LAST, 569 pos, cpy_num - 1); 570 571 /* 572 * copy part of the item which number is 573 * cpy_num+pos-1 to the end of the DEST 574 */ 575 leaf_item_bottle(dest_bi, src, FIRST_TO_LAST, 576 cpy_num + pos - 1, cpy_bytes); 577 } 578 } else { 579 /* copy items to right */ 580 src_nr_item = B_NR_ITEMS(src); 581 if (cpy_num == 1) 582 bytes = cpy_bytes; 583 else 584 bytes = -1; 585 586 /* 587 * copy the last item or it part or nothing to the 588 * begin of the DEST 589 * (i = leaf_copy_boundary_item(DEST,SOURCE,1,bytes)); 590 */ 591 i = leaf_copy_boundary_item(dest_bi, src, LAST_TO_FIRST, bytes); 592 593 cpy_num -= i; 594 if (cpy_num == 0) 595 return i; 596 597 pos = src_nr_item - cpy_num - i; 598 if (cpy_bytes == -1) { 599 /* 600 * starting from position 'pos' copy last cpy_num 601 * items of SOURCE to begin of DEST 602 */ 603 leaf_copy_items_entirely(dest_bi, src, LAST_TO_FIRST, 604 pos, cpy_num); 605 } else { 606 /* 607 * copy last cpy_num-1 items starting from position 608 * 'pos+1' of the SOURCE to the begin of the DEST; 609 */ 610 leaf_copy_items_entirely(dest_bi, src, LAST_TO_FIRST, 611 pos + 1, cpy_num - 1); 612 613 /* 614 * copy part of the item which number is pos to 615 * the begin of the DEST 616 */ 617 leaf_item_bottle(dest_bi, src, LAST_TO_FIRST, pos, 618 cpy_bytes); 619 } 620 } 621 return i; 622 } 623 624 /* 625 * there are types of coping: from S[0] to L[0], from S[0] to R[0], 626 * from R[0] to L[0]. for each of these we have to define parent and 627 * positions of destination and source buffers 628 */ 629 static void leaf_define_dest_src_infos(int shift_mode, struct tree_balance *tb, 630 struct buffer_info *dest_bi, 631 struct buffer_info *src_bi, 632 int *first_last, 633 struct buffer_head *Snew) 634 { 635 memset(dest_bi, 0, sizeof(struct buffer_info)); 636 memset(src_bi, 0, sizeof(struct buffer_info)); 637 638 /* define dest, src, dest parent, dest position */ 639 switch (shift_mode) { 640 case LEAF_FROM_S_TO_L: /* it is used in leaf_shift_left */ 641 src_bi->tb = tb; 642 src_bi->bi_bh = PATH_PLAST_BUFFER(tb->tb_path); 643 src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, 0); 644 645 /* src->b_item_order */ 646 src_bi->bi_position = PATH_H_B_ITEM_ORDER(tb->tb_path, 0); 647 dest_bi->tb = tb; 648 dest_bi->bi_bh = tb->L[0]; 649 dest_bi->bi_parent = tb->FL[0]; 650 dest_bi->bi_position = get_left_neighbor_position(tb, 0); 651 *first_last = FIRST_TO_LAST; 652 break; 653 654 case LEAF_FROM_S_TO_R: /* it is used in leaf_shift_right */ 655 src_bi->tb = tb; 656 src_bi->bi_bh = PATH_PLAST_BUFFER(tb->tb_path); 657 src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, 0); 658 src_bi->bi_position = PATH_H_B_ITEM_ORDER(tb->tb_path, 0); 659 dest_bi->tb = tb; 660 dest_bi->bi_bh = tb->R[0]; 661 dest_bi->bi_parent = tb->FR[0]; 662 dest_bi->bi_position = get_right_neighbor_position(tb, 0); 663 *first_last = LAST_TO_FIRST; 664 break; 665 666 case LEAF_FROM_R_TO_L: /* it is used in balance_leaf_when_delete */ 667 src_bi->tb = tb; 668 src_bi->bi_bh = tb->R[0]; 669 src_bi->bi_parent = tb->FR[0]; 670 src_bi->bi_position = get_right_neighbor_position(tb, 0); 671 dest_bi->tb = tb; 672 dest_bi->bi_bh = tb->L[0]; 673 dest_bi->bi_parent = tb->FL[0]; 674 dest_bi->bi_position = get_left_neighbor_position(tb, 0); 675 *first_last = FIRST_TO_LAST; 676 break; 677 678 case LEAF_FROM_L_TO_R: /* it is used in balance_leaf_when_delete */ 679 src_bi->tb = tb; 680 src_bi->bi_bh = tb->L[0]; 681 src_bi->bi_parent = tb->FL[0]; 682 src_bi->bi_position = get_left_neighbor_position(tb, 0); 683 dest_bi->tb = tb; 684 dest_bi->bi_bh = tb->R[0]; 685 dest_bi->bi_parent = tb->FR[0]; 686 dest_bi->bi_position = get_right_neighbor_position(tb, 0); 687 *first_last = LAST_TO_FIRST; 688 break; 689 690 case LEAF_FROM_S_TO_SNEW: 691 src_bi->tb = tb; 692 src_bi->bi_bh = PATH_PLAST_BUFFER(tb->tb_path); 693 src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, 0); 694 src_bi->bi_position = PATH_H_B_ITEM_ORDER(tb->tb_path, 0); 695 dest_bi->tb = tb; 696 dest_bi->bi_bh = Snew; 697 dest_bi->bi_parent = NULL; 698 dest_bi->bi_position = 0; 699 *first_last = LAST_TO_FIRST; 700 break; 701 702 default: 703 reiserfs_panic(sb_from_bi(src_bi), "vs-10250", 704 "shift type is unknown (%d)", shift_mode); 705 } 706 RFALSE(!src_bi->bi_bh || !dest_bi->bi_bh, 707 "vs-10260: mode==%d, source (%p) or dest (%p) buffer is initialized incorrectly", 708 shift_mode, src_bi->bi_bh, dest_bi->bi_bh); 709 } 710 711 /* 712 * copy mov_num items and mov_bytes of the (mov_num-1)th item to 713 * neighbor. Delete them from source 714 */ 715 int leaf_move_items(int shift_mode, struct tree_balance *tb, int mov_num, 716 int mov_bytes, struct buffer_head *Snew) 717 { 718 int ret_value; 719 struct buffer_info dest_bi, src_bi; 720 int first_last; 721 722 leaf_define_dest_src_infos(shift_mode, tb, &dest_bi, &src_bi, 723 &first_last, Snew); 724 725 ret_value = 726 leaf_copy_items(&dest_bi, src_bi.bi_bh, first_last, mov_num, 727 mov_bytes); 728 729 leaf_delete_items(&src_bi, first_last, 730 (first_last == 731 FIRST_TO_LAST) ? 0 : (B_NR_ITEMS(src_bi.bi_bh) - 732 mov_num), mov_num, mov_bytes); 733 734 return ret_value; 735 } 736 737 /* 738 * Shift shift_num items (and shift_bytes of last shifted item if 739 * shift_bytes != -1) from S[0] to L[0] and replace the delimiting key 740 */ 741 int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes) 742 { 743 struct buffer_head *S0 = PATH_PLAST_BUFFER(tb->tb_path); 744 int i; 745 746 /* 747 * move shift_num (and shift_bytes bytes) items from S[0] 748 * to left neighbor L[0] 749 */ 750 i = leaf_move_items(LEAF_FROM_S_TO_L, tb, shift_num, shift_bytes, NULL); 751 752 if (shift_num) { 753 /* number of items in S[0] == 0 */ 754 if (B_NR_ITEMS(S0) == 0) { 755 756 RFALSE(shift_bytes != -1, 757 "vs-10270: S0 is empty now, but shift_bytes != -1 (%d)", 758 shift_bytes); 759 #ifdef CONFIG_REISERFS_CHECK 760 if (tb->tb_mode == M_PASTE || tb->tb_mode == M_INSERT) { 761 print_cur_tb("vs-10275"); 762 reiserfs_panic(tb->tb_sb, "vs-10275", 763 "balance condition corrupted " 764 "(%c)", tb->tb_mode); 765 } 766 #endif 767 768 if (PATH_H_POSITION(tb->tb_path, 1) == 0) 769 replace_key(tb, tb->CFL[0], tb->lkey[0], 770 PATH_H_PPARENT(tb->tb_path, 0), 0); 771 772 } else { 773 /* replace lkey in CFL[0] by 0-th key from S[0]; */ 774 replace_key(tb, tb->CFL[0], tb->lkey[0], S0, 0); 775 776 RFALSE((shift_bytes != -1 && 777 !(is_direntry_le_ih(item_head(S0, 0)) 778 && !ih_entry_count(item_head(S0, 0)))) && 779 (!op_is_left_mergeable 780 (leaf_key(S0, 0), S0->b_size)), 781 "vs-10280: item must be mergeable"); 782 } 783 } 784 785 return i; 786 } 787 788 /* CLEANING STOPPED HERE */ 789 790 /* 791 * Shift shift_num (shift_bytes) items from S[0] to the right neighbor, 792 * and replace the delimiting key 793 */ 794 int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes) 795 { 796 int ret_value; 797 798 /* 799 * move shift_num (and shift_bytes) items from S[0] to 800 * right neighbor R[0] 801 */ 802 ret_value = 803 leaf_move_items(LEAF_FROM_S_TO_R, tb, shift_num, shift_bytes, NULL); 804 805 /* replace rkey in CFR[0] by the 0-th key from R[0] */ 806 if (shift_num) { 807 replace_key(tb, tb->CFR[0], tb->rkey[0], tb->R[0], 0); 808 809 } 810 811 return ret_value; 812 } 813 814 static void leaf_delete_items_entirely(struct buffer_info *bi, 815 int first, int del_num); 816 /* 817 * If del_bytes == -1, starting from position 'first' delete del_num 818 * items in whole in buffer CUR. 819 * If not. 820 * If last_first == 0. Starting from position 'first' delete del_num-1 821 * items in whole. Delete part of body of the first item. Part defined by 822 * del_bytes. Don't delete first item header 823 * If last_first == 1. Starting from position 'first+1' delete del_num-1 824 * items in whole. Delete part of body of the last item . Part defined by 825 * del_bytes. Don't delete last item header. 826 */ 827 void leaf_delete_items(struct buffer_info *cur_bi, int last_first, 828 int first, int del_num, int del_bytes) 829 { 830 struct buffer_head *bh; 831 int item_amount = B_NR_ITEMS(bh = cur_bi->bi_bh); 832 833 RFALSE(!bh, "10155: bh is not defined"); 834 RFALSE(del_num < 0, "10160: del_num can not be < 0. del_num==%d", 835 del_num); 836 RFALSE(first < 0 837 || first + del_num > item_amount, 838 "10165: invalid number of first item to be deleted (%d) or " 839 "no so much items (%d) to delete (only %d)", first, 840 first + del_num, item_amount); 841 842 if (del_num == 0) 843 return; 844 845 if (first == 0 && del_num == item_amount && del_bytes == -1) { 846 make_empty_node(cur_bi); 847 do_balance_mark_leaf_dirty(cur_bi->tb, bh, 0); 848 return; 849 } 850 851 if (del_bytes == -1) 852 /* delete del_num items beginning from item in position first */ 853 leaf_delete_items_entirely(cur_bi, first, del_num); 854 else { 855 if (last_first == FIRST_TO_LAST) { 856 /* 857 * delete del_num-1 items beginning from 858 * item in position first 859 */ 860 leaf_delete_items_entirely(cur_bi, first, del_num - 1); 861 862 /* 863 * delete the part of the first item of the bh 864 * do not delete item header 865 */ 866 leaf_cut_from_buffer(cur_bi, 0, 0, del_bytes); 867 } else { 868 struct item_head *ih; 869 int len; 870 871 /* 872 * delete del_num-1 items beginning from 873 * item in position first+1 874 */ 875 leaf_delete_items_entirely(cur_bi, first + 1, 876 del_num - 1); 877 878 ih = item_head(bh, B_NR_ITEMS(bh) - 1); 879 if (is_direntry_le_ih(ih)) 880 /* the last item is directory */ 881 /* 882 * len = numbers of directory entries 883 * in this item 884 */ 885 len = ih_entry_count(ih); 886 else 887 /* len = body len of item */ 888 len = ih_item_len(ih); 889 890 /* 891 * delete the part of the last item of the bh 892 * do not delete item header 893 */ 894 leaf_cut_from_buffer(cur_bi, B_NR_ITEMS(bh) - 1, 895 len - del_bytes, del_bytes); 896 } 897 } 898 } 899 900 /* insert item into the leaf node in position before */ 901 void leaf_insert_into_buf(struct buffer_info *bi, int before, 902 struct item_head * const inserted_item_ih, 903 const char * const inserted_item_body, 904 int zeros_number) 905 { 906 struct buffer_head *bh = bi->bi_bh; 907 int nr, free_space; 908 struct block_head *blkh; 909 struct item_head *ih; 910 int i; 911 int last_loc, unmoved_loc; 912 char *to; 913 914 blkh = B_BLK_HEAD(bh); 915 nr = blkh_nr_item(blkh); 916 free_space = blkh_free_space(blkh); 917 918 /* check free space */ 919 RFALSE(free_space < ih_item_len(inserted_item_ih) + IH_SIZE, 920 "vs-10170: not enough free space in block %z, new item %h", 921 bh, inserted_item_ih); 922 RFALSE(zeros_number > ih_item_len(inserted_item_ih), 923 "vs-10172: zero number == %d, item length == %d", 924 zeros_number, ih_item_len(inserted_item_ih)); 925 926 /* get item new item must be inserted before */ 927 ih = item_head(bh, before); 928 929 /* prepare space for the body of new item */ 930 last_loc = nr ? ih_location(&ih[nr - before - 1]) : bh->b_size; 931 unmoved_loc = before ? ih_location(ih - 1) : bh->b_size; 932 933 memmove(bh->b_data + last_loc - ih_item_len(inserted_item_ih), 934 bh->b_data + last_loc, unmoved_loc - last_loc); 935 936 to = bh->b_data + unmoved_loc - ih_item_len(inserted_item_ih); 937 memset(to, 0, zeros_number); 938 to += zeros_number; 939 940 /* copy body to prepared space */ 941 if (inserted_item_body) 942 memmove(to, inserted_item_body, 943 ih_item_len(inserted_item_ih) - zeros_number); 944 else 945 memset(to, '\0', ih_item_len(inserted_item_ih) - zeros_number); 946 947 /* insert item header */ 948 memmove(ih + 1, ih, IH_SIZE * (nr - before)); 949 memmove(ih, inserted_item_ih, IH_SIZE); 950 951 /* change locations */ 952 for (i = before; i < nr + 1; i++) { 953 unmoved_loc -= ih_item_len(&ih[i - before]); 954 put_ih_location(&ih[i - before], unmoved_loc); 955 } 956 957 /* sizes, free space, item number */ 958 set_blkh_nr_item(blkh, blkh_nr_item(blkh) + 1); 959 set_blkh_free_space(blkh, 960 free_space - (IH_SIZE + 961 ih_item_len(inserted_item_ih))); 962 do_balance_mark_leaf_dirty(bi->tb, bh, 1); 963 964 if (bi->bi_parent) { 965 struct disk_child *t_dc; 966 t_dc = B_N_CHILD(bi->bi_parent, bi->bi_position); 967 put_dc_size(t_dc, 968 dc_size(t_dc) + (IH_SIZE + 969 ih_item_len(inserted_item_ih))); 970 do_balance_mark_internal_dirty(bi->tb, bi->bi_parent, 0); 971 } 972 } 973 974 /* 975 * paste paste_size bytes to affected_item_num-th item. 976 * When item is a directory, this only prepare space for new entries 977 */ 978 void leaf_paste_in_buffer(struct buffer_info *bi, int affected_item_num, 979 int pos_in_item, int paste_size, 980 const char *body, int zeros_number) 981 { 982 struct buffer_head *bh = bi->bi_bh; 983 int nr, free_space; 984 struct block_head *blkh; 985 struct item_head *ih; 986 int i; 987 int last_loc, unmoved_loc; 988 989 blkh = B_BLK_HEAD(bh); 990 nr = blkh_nr_item(blkh); 991 free_space = blkh_free_space(blkh); 992 993 /* check free space */ 994 RFALSE(free_space < paste_size, 995 "vs-10175: not enough free space: needed %d, available %d", 996 paste_size, free_space); 997 998 #ifdef CONFIG_REISERFS_CHECK 999 if (zeros_number > paste_size) { 1000 struct super_block *sb = NULL; 1001 if (bi && bi->tb) 1002 sb = bi->tb->tb_sb; 1003 print_cur_tb("10177"); 1004 reiserfs_panic(sb, "vs-10177", 1005 "zeros_number == %d, paste_size == %d", 1006 zeros_number, paste_size); 1007 } 1008 #endif /* CONFIG_REISERFS_CHECK */ 1009 1010 /* item to be appended */ 1011 ih = item_head(bh, affected_item_num); 1012 1013 last_loc = ih_location(&ih[nr - affected_item_num - 1]); 1014 unmoved_loc = affected_item_num ? ih_location(ih - 1) : bh->b_size; 1015 1016 /* prepare space */ 1017 memmove(bh->b_data + last_loc - paste_size, bh->b_data + last_loc, 1018 unmoved_loc - last_loc); 1019 1020 /* change locations */ 1021 for (i = affected_item_num; i < nr; i++) 1022 put_ih_location(&ih[i - affected_item_num], 1023 ih_location(&ih[i - affected_item_num]) - 1024 paste_size); 1025 1026 if (body) { 1027 if (!is_direntry_le_ih(ih)) { 1028 if (!pos_in_item) { 1029 /* shift data to right */ 1030 memmove(bh->b_data + ih_location(ih) + 1031 paste_size, 1032 bh->b_data + ih_location(ih), 1033 ih_item_len(ih)); 1034 /* paste data in the head of item */ 1035 memset(bh->b_data + ih_location(ih), 0, 1036 zeros_number); 1037 memcpy(bh->b_data + ih_location(ih) + 1038 zeros_number, body, 1039 paste_size - zeros_number); 1040 } else { 1041 memset(bh->b_data + unmoved_loc - paste_size, 0, 1042 zeros_number); 1043 memcpy(bh->b_data + unmoved_loc - paste_size + 1044 zeros_number, body, 1045 paste_size - zeros_number); 1046 } 1047 } 1048 } else 1049 memset(bh->b_data + unmoved_loc - paste_size, '\0', paste_size); 1050 1051 put_ih_item_len(ih, ih_item_len(ih) + paste_size); 1052 1053 /* change free space */ 1054 set_blkh_free_space(blkh, free_space - paste_size); 1055 1056 do_balance_mark_leaf_dirty(bi->tb, bh, 0); 1057 1058 if (bi->bi_parent) { 1059 struct disk_child *t_dc = 1060 B_N_CHILD(bi->bi_parent, bi->bi_position); 1061 put_dc_size(t_dc, dc_size(t_dc) + paste_size); 1062 do_balance_mark_internal_dirty(bi->tb, bi->bi_parent, 0); 1063 } 1064 } 1065 1066 /* 1067 * cuts DEL_COUNT entries beginning from FROM-th entry. Directory item 1068 * does not have free space, so it moves DEHs and remaining records as 1069 * necessary. Return value is size of removed part of directory item 1070 * in bytes. 1071 */ 1072 static int leaf_cut_entries(struct buffer_head *bh, 1073 struct item_head *ih, int from, int del_count) 1074 { 1075 char *item; 1076 struct reiserfs_de_head *deh; 1077 int prev_record_offset; /* offset of record, that is (from-1)th */ 1078 char *prev_record; /* */ 1079 int cut_records_len; /* length of all removed records */ 1080 int i; 1081 1082 /* 1083 * make sure that item is directory and there are enough entries to 1084 * remove 1085 */ 1086 RFALSE(!is_direntry_le_ih(ih), "10180: item is not directory item"); 1087 RFALSE(ih_entry_count(ih) < from + del_count, 1088 "10185: item contains not enough entries: entry_count = %d, from = %d, to delete = %d", 1089 ih_entry_count(ih), from, del_count); 1090 1091 if (del_count == 0) 1092 return 0; 1093 1094 /* first byte of item */ 1095 item = bh->b_data + ih_location(ih); 1096 1097 /* entry head array */ 1098 deh = B_I_DEH(bh, ih); 1099 1100 /* 1101 * first byte of remaining entries, those are BEFORE cut entries 1102 * (prev_record) and length of all removed records (cut_records_len) 1103 */ 1104 prev_record_offset = 1105 (from ? deh_location(&deh[from - 1]) : ih_item_len(ih)); 1106 cut_records_len = prev_record_offset /*from_record */ - 1107 deh_location(&deh[from + del_count - 1]); 1108 prev_record = item + prev_record_offset; 1109 1110 /* adjust locations of remaining entries */ 1111 for (i = ih_entry_count(ih) - 1; i > from + del_count - 1; i--) 1112 put_deh_location(&deh[i], 1113 deh_location(&deh[i]) - 1114 (DEH_SIZE * del_count)); 1115 1116 for (i = 0; i < from; i++) 1117 put_deh_location(&deh[i], 1118 deh_location(&deh[i]) - (DEH_SIZE * del_count + 1119 cut_records_len)); 1120 1121 put_ih_entry_count(ih, ih_entry_count(ih) - del_count); 1122 1123 /* shift entry head array and entries those are AFTER removed entries */ 1124 memmove((char *)(deh + from), 1125 deh + from + del_count, 1126 prev_record - cut_records_len - (char *)(deh + from + 1127 del_count)); 1128 1129 /* shift records, those are BEFORE removed entries */ 1130 memmove(prev_record - cut_records_len - DEH_SIZE * del_count, 1131 prev_record, item + ih_item_len(ih) - prev_record); 1132 1133 return DEH_SIZE * del_count + cut_records_len; 1134 } 1135 1136 /* 1137 * when cut item is part of regular file 1138 * pos_in_item - first byte that must be cut 1139 * cut_size - number of bytes to be cut beginning from pos_in_item 1140 * 1141 * when cut item is part of directory 1142 * pos_in_item - number of first deleted entry 1143 * cut_size - count of deleted entries 1144 */ 1145 void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num, 1146 int pos_in_item, int cut_size) 1147 { 1148 int nr; 1149 struct buffer_head *bh = bi->bi_bh; 1150 struct block_head *blkh; 1151 struct item_head *ih; 1152 int last_loc, unmoved_loc; 1153 int i; 1154 1155 blkh = B_BLK_HEAD(bh); 1156 nr = blkh_nr_item(blkh); 1157 1158 /* item head of truncated item */ 1159 ih = item_head(bh, cut_item_num); 1160 1161 if (is_direntry_le_ih(ih)) { 1162 /* first cut entry () */ 1163 cut_size = leaf_cut_entries(bh, ih, pos_in_item, cut_size); 1164 if (pos_in_item == 0) { 1165 /* change key */ 1166 RFALSE(cut_item_num, 1167 "when 0-th enrty of item is cut, that item must be first in the node, not %d-th", 1168 cut_item_num); 1169 /* change item key by key of first entry in the item */ 1170 set_le_ih_k_offset(ih, deh_offset(B_I_DEH(bh, ih))); 1171 } 1172 } else { 1173 /* item is direct or indirect */ 1174 RFALSE(is_statdata_le_ih(ih), "10195: item is stat data"); 1175 RFALSE(pos_in_item && pos_in_item + cut_size != ih_item_len(ih), 1176 "10200: invalid offset (%lu) or trunc_size (%lu) or ih_item_len (%lu)", 1177 (long unsigned)pos_in_item, (long unsigned)cut_size, 1178 (long unsigned)ih_item_len(ih)); 1179 1180 /* shift item body to left if cut is from the head of item */ 1181 if (pos_in_item == 0) { 1182 memmove(bh->b_data + ih_location(ih), 1183 bh->b_data + ih_location(ih) + cut_size, 1184 ih_item_len(ih) - cut_size); 1185 1186 /* change key of item */ 1187 if (is_direct_le_ih(ih)) 1188 set_le_ih_k_offset(ih, 1189 le_ih_k_offset(ih) + 1190 cut_size); 1191 else { 1192 set_le_ih_k_offset(ih, 1193 le_ih_k_offset(ih) + 1194 (cut_size / UNFM_P_SIZE) * 1195 bh->b_size); 1196 RFALSE(ih_item_len(ih) == cut_size 1197 && get_ih_free_space(ih), 1198 "10205: invalid ih_free_space (%h)", ih); 1199 } 1200 } 1201 } 1202 1203 /* location of the last item */ 1204 last_loc = ih_location(&ih[nr - cut_item_num - 1]); 1205 1206 /* location of the item, which is remaining at the same place */ 1207 unmoved_loc = cut_item_num ? ih_location(ih - 1) : bh->b_size; 1208 1209 /* shift */ 1210 memmove(bh->b_data + last_loc + cut_size, bh->b_data + last_loc, 1211 unmoved_loc - last_loc - cut_size); 1212 1213 /* change item length */ 1214 put_ih_item_len(ih, ih_item_len(ih) - cut_size); 1215 1216 if (is_indirect_le_ih(ih)) { 1217 if (pos_in_item) 1218 set_ih_free_space(ih, 0); 1219 } 1220 1221 /* change locations */ 1222 for (i = cut_item_num; i < nr; i++) 1223 put_ih_location(&ih[i - cut_item_num], 1224 ih_location(&ih[i - cut_item_num]) + cut_size); 1225 1226 /* size, free space */ 1227 set_blkh_free_space(blkh, blkh_free_space(blkh) + cut_size); 1228 1229 do_balance_mark_leaf_dirty(bi->tb, bh, 0); 1230 1231 if (bi->bi_parent) { 1232 struct disk_child *t_dc; 1233 t_dc = B_N_CHILD(bi->bi_parent, bi->bi_position); 1234 put_dc_size(t_dc, dc_size(t_dc) - cut_size); 1235 do_balance_mark_internal_dirty(bi->tb, bi->bi_parent, 0); 1236 } 1237 } 1238 1239 /* delete del_num items from buffer starting from the first'th item */ 1240 static void leaf_delete_items_entirely(struct buffer_info *bi, 1241 int first, int del_num) 1242 { 1243 struct buffer_head *bh = bi->bi_bh; 1244 int nr; 1245 int i, j; 1246 int last_loc, last_removed_loc; 1247 struct block_head *blkh; 1248 struct item_head *ih; 1249 1250 RFALSE(bh == NULL, "10210: buffer is 0"); 1251 RFALSE(del_num < 0, "10215: del_num less than 0 (%d)", del_num); 1252 1253 if (del_num == 0) 1254 return; 1255 1256 blkh = B_BLK_HEAD(bh); 1257 nr = blkh_nr_item(blkh); 1258 1259 RFALSE(first < 0 || first + del_num > nr, 1260 "10220: first=%d, number=%d, there is %d items", first, del_num, 1261 nr); 1262 1263 if (first == 0 && del_num == nr) { 1264 /* this does not work */ 1265 make_empty_node(bi); 1266 1267 do_balance_mark_leaf_dirty(bi->tb, bh, 0); 1268 return; 1269 } 1270 1271 ih = item_head(bh, first); 1272 1273 /* location of unmovable item */ 1274 j = (first == 0) ? bh->b_size : ih_location(ih - 1); 1275 1276 /* delete items */ 1277 last_loc = ih_location(&ih[nr - 1 - first]); 1278 last_removed_loc = ih_location(&ih[del_num - 1]); 1279 1280 memmove(bh->b_data + last_loc + j - last_removed_loc, 1281 bh->b_data + last_loc, last_removed_loc - last_loc); 1282 1283 /* delete item headers */ 1284 memmove(ih, ih + del_num, (nr - first - del_num) * IH_SIZE); 1285 1286 /* change item location */ 1287 for (i = first; i < nr - del_num; i++) 1288 put_ih_location(&ih[i - first], 1289 ih_location(&ih[i - first]) + (j - 1290 last_removed_loc)); 1291 1292 /* sizes, item number */ 1293 set_blkh_nr_item(blkh, blkh_nr_item(blkh) - del_num); 1294 set_blkh_free_space(blkh, 1295 blkh_free_space(blkh) + (j - last_removed_loc + 1296 IH_SIZE * del_num)); 1297 1298 do_balance_mark_leaf_dirty(bi->tb, bh, 0); 1299 1300 if (bi->bi_parent) { 1301 struct disk_child *t_dc = 1302 B_N_CHILD(bi->bi_parent, bi->bi_position); 1303 put_dc_size(t_dc, 1304 dc_size(t_dc) - (j - last_removed_loc + 1305 IH_SIZE * del_num)); 1306 do_balance_mark_internal_dirty(bi->tb, bi->bi_parent, 0); 1307 } 1308 } 1309 1310 /* 1311 * paste new_entry_count entries (new_dehs, records) into position 1312 * before to item_num-th item 1313 */ 1314 void leaf_paste_entries(struct buffer_info *bi, 1315 int item_num, 1316 int before, 1317 int new_entry_count, 1318 struct reiserfs_de_head *new_dehs, 1319 const char *records, int paste_size) 1320 { 1321 struct item_head *ih; 1322 char *item; 1323 struct reiserfs_de_head *deh; 1324 char *insert_point; 1325 int i, old_entry_num; 1326 struct buffer_head *bh = bi->bi_bh; 1327 1328 if (new_entry_count == 0) 1329 return; 1330 1331 ih = item_head(bh, item_num); 1332 1333 /* 1334 * make sure, that item is directory, and there are enough 1335 * records in it 1336 */ 1337 RFALSE(!is_direntry_le_ih(ih), "10225: item is not directory item"); 1338 RFALSE(ih_entry_count(ih) < before, 1339 "10230: there are no entry we paste entries before. entry_count = %d, before = %d", 1340 ih_entry_count(ih), before); 1341 1342 /* first byte of dest item */ 1343 item = bh->b_data + ih_location(ih); 1344 1345 /* entry head array */ 1346 deh = B_I_DEH(bh, ih); 1347 1348 /* new records will be pasted at this point */ 1349 insert_point = 1350 item + 1351 (before ? deh_location(&deh[before - 1]) 1352 : (ih_item_len(ih) - paste_size)); 1353 1354 /* adjust locations of records that will be AFTER new records */ 1355 for (i = ih_entry_count(ih) - 1; i >= before; i--) 1356 put_deh_location(&deh[i], 1357 deh_location(&deh[i]) + 1358 (DEH_SIZE * new_entry_count)); 1359 1360 /* adjust locations of records that will be BEFORE new records */ 1361 for (i = 0; i < before; i++) 1362 put_deh_location(&deh[i], 1363 deh_location(&deh[i]) + paste_size); 1364 1365 old_entry_num = ih_entry_count(ih); 1366 put_ih_entry_count(ih, ih_entry_count(ih) + new_entry_count); 1367 1368 /* prepare space for pasted records */ 1369 memmove(insert_point + paste_size, insert_point, 1370 item + (ih_item_len(ih) - paste_size) - insert_point); 1371 1372 /* copy new records */ 1373 memcpy(insert_point + DEH_SIZE * new_entry_count, records, 1374 paste_size - DEH_SIZE * new_entry_count); 1375 1376 /* prepare space for new entry heads */ 1377 deh += before; 1378 memmove((char *)(deh + new_entry_count), deh, 1379 insert_point - (char *)deh); 1380 1381 /* copy new entry heads */ 1382 deh = (struct reiserfs_de_head *)((char *)deh); 1383 memcpy(deh, new_dehs, DEH_SIZE * new_entry_count); 1384 1385 /* set locations of new records */ 1386 for (i = 0; i < new_entry_count; i++) { 1387 put_deh_location(&deh[i], 1388 deh_location(&deh[i]) + 1389 (-deh_location 1390 (&new_dehs[new_entry_count - 1]) + 1391 insert_point + DEH_SIZE * new_entry_count - 1392 item)); 1393 } 1394 1395 /* change item key if necessary (when we paste before 0-th entry */ 1396 if (!before) { 1397 set_le_ih_k_offset(ih, deh_offset(new_dehs)); 1398 } 1399 #ifdef CONFIG_REISERFS_CHECK 1400 { 1401 int prev, next; 1402 /* check record locations */ 1403 deh = B_I_DEH(bh, ih); 1404 for (i = 0; i < ih_entry_count(ih); i++) { 1405 next = 1406 (i < 1407 ih_entry_count(ih) - 1408 1) ? deh_location(&deh[i + 1]) : 0; 1409 prev = (i != 0) ? deh_location(&deh[i - 1]) : 0; 1410 1411 if (prev && prev <= deh_location(&deh[i])) 1412 reiserfs_error(sb_from_bi(bi), "vs-10240", 1413 "directory item (%h) " 1414 "corrupted (prev %a, " 1415 "cur(%d) %a)", 1416 ih, deh + i - 1, i, deh + i); 1417 if (next && next >= deh_location(&deh[i])) 1418 reiserfs_error(sb_from_bi(bi), "vs-10250", 1419 "directory item (%h) " 1420 "corrupted (cur(%d) %a, " 1421 "next %a)", 1422 ih, i, deh + i, deh + i + 1); 1423 } 1424 } 1425 #endif 1426 1427 } 1428