1 /* 2 * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README 3 */ 4 5 #include <linux/time.h> 6 #include "reiserfs.h" 7 8 /* 9 * this contains item handlers for old item types: sd, direct, 10 * indirect, directory 11 */ 12 13 /* 14 * and where are the comments? how about saying where we can find an 15 * explanation of each item handler method? -Hans 16 */ 17 18 /* stat data functions */ 19 static int sd_bytes_number(struct item_head *ih, int block_size) 20 { 21 return 0; 22 } 23 24 static void sd_decrement_key(struct cpu_key *key) 25 { 26 key->on_disk_key.k_objectid--; 27 set_cpu_key_k_type(key, TYPE_ANY); 28 set_cpu_key_k_offset(key, (loff_t)(~0ULL >> 1)); 29 } 30 31 static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize) 32 { 33 return 0; 34 } 35 36 static void sd_print_item(struct item_head *ih, char *item) 37 { 38 printk("\tmode | size | nlinks | first direct | mtime\n"); 39 if (stat_data_v1(ih)) { 40 struct stat_data_v1 *sd = (struct stat_data_v1 *)item; 41 42 printk("\t0%-6o | %6u | %2u | %d | %u\n", sd_v1_mode(sd), 43 sd_v1_size(sd), sd_v1_nlink(sd), 44 sd_v1_first_direct_byte(sd), 45 sd_v1_mtime(sd)); 46 } else { 47 struct stat_data *sd = (struct stat_data *)item; 48 49 printk("\t0%-6o | %6llu | %2u | %d | %u\n", sd_v2_mode(sd), 50 (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd), 51 sd_v2_rdev(sd), sd_v2_mtime(sd)); 52 } 53 } 54 55 static void sd_check_item(struct item_head *ih, char *item) 56 { 57 /* unused */ 58 } 59 60 static int sd_create_vi(struct virtual_node *vn, 61 struct virtual_item *vi, 62 int is_affected, int insert_size) 63 { 64 vi->vi_index = TYPE_STAT_DATA; 65 return 0; 66 } 67 68 static int sd_check_left(struct virtual_item *vi, int free, 69 int start_skip, int end_skip) 70 { 71 BUG_ON(start_skip || end_skip); 72 return -1; 73 } 74 75 static int sd_check_right(struct virtual_item *vi, int free) 76 { 77 return -1; 78 } 79 80 static int sd_part_size(struct virtual_item *vi, int first, int count) 81 { 82 BUG_ON(count); 83 return 0; 84 } 85 86 static int sd_unit_num(struct virtual_item *vi) 87 { 88 return vi->vi_item_len - IH_SIZE; 89 } 90 91 static void sd_print_vi(struct virtual_item *vi) 92 { 93 reiserfs_warning(NULL, "reiserfs-16100", 94 "STATDATA, index %d, type 0x%x, %h", 95 vi->vi_index, vi->vi_type, vi->vi_ih); 96 } 97 98 static struct item_operations stat_data_ops = { 99 .bytes_number = sd_bytes_number, 100 .decrement_key = sd_decrement_key, 101 .is_left_mergeable = sd_is_left_mergeable, 102 .print_item = sd_print_item, 103 .check_item = sd_check_item, 104 105 .create_vi = sd_create_vi, 106 .check_left = sd_check_left, 107 .check_right = sd_check_right, 108 .part_size = sd_part_size, 109 .unit_num = sd_unit_num, 110 .print_vi = sd_print_vi 111 }; 112 113 /* direct item functions */ 114 static int direct_bytes_number(struct item_head *ih, int block_size) 115 { 116 return ih_item_len(ih); 117 } 118 119 /* FIXME: this should probably switch to indirect as well */ 120 static void direct_decrement_key(struct cpu_key *key) 121 { 122 cpu_key_k_offset_dec(key); 123 if (cpu_key_k_offset(key) == 0) 124 set_cpu_key_k_type(key, TYPE_STAT_DATA); 125 } 126 127 static int direct_is_left_mergeable(struct reiserfs_key *key, 128 unsigned long bsize) 129 { 130 int version = le_key_version(key); 131 return ((le_key_k_offset(version, key) & (bsize - 1)) != 1); 132 } 133 134 static void direct_print_item(struct item_head *ih, char *item) 135 { 136 int j = 0; 137 138 /* return; */ 139 printk("\""); 140 while (j < ih_item_len(ih)) 141 printk("%c", item[j++]); 142 printk("\"\n"); 143 } 144 145 static void direct_check_item(struct item_head *ih, char *item) 146 { 147 /* unused */ 148 } 149 150 static int direct_create_vi(struct virtual_node *vn, 151 struct virtual_item *vi, 152 int is_affected, int insert_size) 153 { 154 vi->vi_index = TYPE_DIRECT; 155 return 0; 156 } 157 158 static int direct_check_left(struct virtual_item *vi, int free, 159 int start_skip, int end_skip) 160 { 161 int bytes; 162 163 bytes = free - free % 8; 164 return bytes ? : -1; 165 } 166 167 static int direct_check_right(struct virtual_item *vi, int free) 168 { 169 return direct_check_left(vi, free, 0, 0); 170 } 171 172 static int direct_part_size(struct virtual_item *vi, int first, int count) 173 { 174 return count; 175 } 176 177 static int direct_unit_num(struct virtual_item *vi) 178 { 179 return vi->vi_item_len - IH_SIZE; 180 } 181 182 static void direct_print_vi(struct virtual_item *vi) 183 { 184 reiserfs_warning(NULL, "reiserfs-16101", 185 "DIRECT, index %d, type 0x%x, %h", 186 vi->vi_index, vi->vi_type, vi->vi_ih); 187 } 188 189 static struct item_operations direct_ops = { 190 .bytes_number = direct_bytes_number, 191 .decrement_key = direct_decrement_key, 192 .is_left_mergeable = direct_is_left_mergeable, 193 .print_item = direct_print_item, 194 .check_item = direct_check_item, 195 196 .create_vi = direct_create_vi, 197 .check_left = direct_check_left, 198 .check_right = direct_check_right, 199 .part_size = direct_part_size, 200 .unit_num = direct_unit_num, 201 .print_vi = direct_print_vi 202 }; 203 204 /* indirect item functions */ 205 static int indirect_bytes_number(struct item_head *ih, int block_size) 206 { 207 return ih_item_len(ih) / UNFM_P_SIZE * block_size; 208 } 209 210 /* decrease offset, if it becomes 0, change type to stat data */ 211 static void indirect_decrement_key(struct cpu_key *key) 212 { 213 cpu_key_k_offset_dec(key); 214 if (cpu_key_k_offset(key) == 0) 215 set_cpu_key_k_type(key, TYPE_STAT_DATA); 216 } 217 218 /* if it is not first item of the body, then it is mergeable */ 219 static int indirect_is_left_mergeable(struct reiserfs_key *key, 220 unsigned long bsize) 221 { 222 int version = le_key_version(key); 223 return (le_key_k_offset(version, key) != 1); 224 } 225 226 /* printing of indirect item */ 227 static void start_new_sequence(__u32 * start, int *len, __u32 new) 228 { 229 *start = new; 230 *len = 1; 231 } 232 233 static int sequence_finished(__u32 start, int *len, __u32 new) 234 { 235 if (start == INT_MAX) 236 return 1; 237 238 if (start == 0 && new == 0) { 239 (*len)++; 240 return 0; 241 } 242 if (start != 0 && (start + *len) == new) { 243 (*len)++; 244 return 0; 245 } 246 return 1; 247 } 248 249 static void print_sequence(__u32 start, int len) 250 { 251 if (start == INT_MAX) 252 return; 253 254 if (len == 1) 255 printk(" %d", start); 256 else 257 printk(" %d(%d)", start, len); 258 } 259 260 static void indirect_print_item(struct item_head *ih, char *item) 261 { 262 int j; 263 __le32 *unp; 264 __u32 prev = INT_MAX; 265 int num = 0; 266 267 unp = (__le32 *) item; 268 269 if (ih_item_len(ih) % UNFM_P_SIZE) 270 reiserfs_warning(NULL, "reiserfs-16102", "invalid item len"); 271 272 printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih)); 273 for (j = 0; j < I_UNFM_NUM(ih); j++) { 274 if (sequence_finished(prev, &num, get_block_num(unp, j))) { 275 print_sequence(prev, num); 276 start_new_sequence(&prev, &num, get_block_num(unp, j)); 277 } 278 } 279 print_sequence(prev, num); 280 printk("]\n"); 281 } 282 283 static void indirect_check_item(struct item_head *ih, char *item) 284 { 285 /* unused */ 286 } 287 288 static int indirect_create_vi(struct virtual_node *vn, 289 struct virtual_item *vi, 290 int is_affected, int insert_size) 291 { 292 vi->vi_index = TYPE_INDIRECT; 293 return 0; 294 } 295 296 static int indirect_check_left(struct virtual_item *vi, int free, 297 int start_skip, int end_skip) 298 { 299 int bytes; 300 301 bytes = free - free % UNFM_P_SIZE; 302 return bytes ? : -1; 303 } 304 305 static int indirect_check_right(struct virtual_item *vi, int free) 306 { 307 return indirect_check_left(vi, free, 0, 0); 308 } 309 310 /* 311 * return size in bytes of 'units' units. If first == 0 - calculate 312 * from the head (left), otherwise - from tail (right) 313 */ 314 static int indirect_part_size(struct virtual_item *vi, int first, int units) 315 { 316 /* unit of indirect item is byte (yet) */ 317 return units; 318 } 319 320 static int indirect_unit_num(struct virtual_item *vi) 321 { 322 /* unit of indirect item is byte (yet) */ 323 return vi->vi_item_len - IH_SIZE; 324 } 325 326 static void indirect_print_vi(struct virtual_item *vi) 327 { 328 reiserfs_warning(NULL, "reiserfs-16103", 329 "INDIRECT, index %d, type 0x%x, %h", 330 vi->vi_index, vi->vi_type, vi->vi_ih); 331 } 332 333 static struct item_operations indirect_ops = { 334 .bytes_number = indirect_bytes_number, 335 .decrement_key = indirect_decrement_key, 336 .is_left_mergeable = indirect_is_left_mergeable, 337 .print_item = indirect_print_item, 338 .check_item = indirect_check_item, 339 340 .create_vi = indirect_create_vi, 341 .check_left = indirect_check_left, 342 .check_right = indirect_check_right, 343 .part_size = indirect_part_size, 344 .unit_num = indirect_unit_num, 345 .print_vi = indirect_print_vi 346 }; 347 348 /* direntry functions */ 349 static int direntry_bytes_number(struct item_head *ih, int block_size) 350 { 351 reiserfs_warning(NULL, "vs-16090", 352 "bytes number is asked for direntry"); 353 return 0; 354 } 355 356 static void direntry_decrement_key(struct cpu_key *key) 357 { 358 cpu_key_k_offset_dec(key); 359 if (cpu_key_k_offset(key) == 0) 360 set_cpu_key_k_type(key, TYPE_STAT_DATA); 361 } 362 363 static int direntry_is_left_mergeable(struct reiserfs_key *key, 364 unsigned long bsize) 365 { 366 if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET) 367 return 0; 368 return 1; 369 370 } 371 372 static void direntry_print_item(struct item_head *ih, char *item) 373 { 374 int i; 375 int namelen; 376 struct reiserfs_de_head *deh; 377 char *name; 378 static char namebuf[80]; 379 380 printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name", 381 "Key of pointed object", "Hash", "Gen number", "Status"); 382 383 deh = (struct reiserfs_de_head *)item; 384 385 for (i = 0; i < ih_entry_count(ih); i++, deh++) { 386 namelen = 387 (i ? (deh_location(deh - 1)) : ih_item_len(ih)) - 388 deh_location(deh); 389 name = item + deh_location(deh); 390 if (name[namelen - 1] == 0) 391 namelen = strlen(name); 392 namebuf[0] = '"'; 393 if (namelen > sizeof(namebuf) - 3) { 394 strncpy(namebuf + 1, name, sizeof(namebuf) - 3); 395 namebuf[sizeof(namebuf) - 2] = '"'; 396 namebuf[sizeof(namebuf) - 1] = 0; 397 } else { 398 memcpy(namebuf + 1, name, namelen); 399 namebuf[namelen + 1] = '"'; 400 namebuf[namelen + 2] = 0; 401 } 402 403 printk("%d: %-15s%-15d%-15d%-15lld%-15lld(%s)\n", 404 i, namebuf, 405 deh_dir_id(deh), deh_objectid(deh), 406 GET_HASH_VALUE(deh_offset(deh)), 407 GET_GENERATION_NUMBER((deh_offset(deh))), 408 (de_hidden(deh)) ? "HIDDEN" : "VISIBLE"); 409 } 410 } 411 412 static void direntry_check_item(struct item_head *ih, char *item) 413 { 414 int i; 415 struct reiserfs_de_head *deh; 416 417 /* unused */ 418 deh = (struct reiserfs_de_head *)item; 419 for (i = 0; i < ih_entry_count(ih); i++, deh++) { 420 ; 421 } 422 } 423 424 #define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1 425 426 /* 427 * function returns old entry number in directory item in real node 428 * using new entry number in virtual item in virtual node 429 */ 430 static inline int old_entry_num(int is_affected, int virtual_entry_num, 431 int pos_in_item, int mode) 432 { 433 if (mode == M_INSERT || mode == M_DELETE) 434 return virtual_entry_num; 435 436 if (!is_affected) 437 /* cut or paste is applied to another item */ 438 return virtual_entry_num; 439 440 if (virtual_entry_num < pos_in_item) 441 return virtual_entry_num; 442 443 if (mode == M_CUT) 444 return virtual_entry_num + 1; 445 446 RFALSE(mode != M_PASTE || virtual_entry_num == 0, 447 "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'", 448 mode); 449 450 return virtual_entry_num - 1; 451 } 452 453 /* 454 * Create an array of sizes of directory entries for virtual 455 * item. Return space used by an item. FIXME: no control over 456 * consuming of space used by this item handler 457 */ 458 static int direntry_create_vi(struct virtual_node *vn, 459 struct virtual_item *vi, 460 int is_affected, int insert_size) 461 { 462 struct direntry_uarea *dir_u = vi->vi_uarea; 463 int i, j; 464 int size = sizeof(struct direntry_uarea); 465 struct reiserfs_de_head *deh; 466 467 vi->vi_index = TYPE_DIRENTRY; 468 469 BUG_ON(!(vi->vi_ih) || !vi->vi_item); 470 471 dir_u->flags = 0; 472 if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET) 473 dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM; 474 475 deh = (struct reiserfs_de_head *)(vi->vi_item); 476 477 /* virtual directory item have this amount of entry after */ 478 dir_u->entry_count = ih_entry_count(vi->vi_ih) + 479 ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 : 480 (vn->vn_mode == M_PASTE ? 1 : 0)) : 0); 481 482 for (i = 0; i < dir_u->entry_count; i++) { 483 j = old_entry_num(is_affected, i, vn->vn_pos_in_item, 484 vn->vn_mode); 485 dir_u->entry_sizes[i] = 486 (j ? deh_location(&deh[j - 1]) : ih_item_len(vi->vi_ih)) - 487 deh_location(&deh[j]) + DEH_SIZE; 488 } 489 490 size += (dir_u->entry_count * sizeof(short)); 491 492 /* set size of pasted entry */ 493 if (is_affected && vn->vn_mode == M_PASTE) 494 dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size; 495 496 #ifdef CONFIG_REISERFS_CHECK 497 /* compare total size of entries with item length */ 498 { 499 int k, l; 500 501 l = 0; 502 for (k = 0; k < dir_u->entry_count; k++) 503 l += dir_u->entry_sizes[k]; 504 505 if (l + IH_SIZE != vi->vi_item_len + 506 ((is_affected 507 && (vn->vn_mode == M_PASTE 508 || vn->vn_mode == M_CUT)) ? insert_size : 0)) { 509 reiserfs_panic(NULL, "vs-8025", "(mode==%c, " 510 "insert_size==%d), invalid length of " 511 "directory item", 512 vn->vn_mode, insert_size); 513 } 514 } 515 #endif 516 517 return size; 518 519 } 520 521 /* 522 * return number of entries which may fit into specified amount of 523 * free space, or -1 if free space is not enough even for 1 entry 524 */ 525 static int direntry_check_left(struct virtual_item *vi, int free, 526 int start_skip, int end_skip) 527 { 528 int i; 529 int entries = 0; 530 struct direntry_uarea *dir_u = vi->vi_uarea; 531 532 for (i = start_skip; i < dir_u->entry_count - end_skip; i++) { 533 /* i-th entry doesn't fit into the remaining free space */ 534 if (dir_u->entry_sizes[i] > free) 535 break; 536 537 free -= dir_u->entry_sizes[i]; 538 entries++; 539 } 540 541 if (entries == dir_u->entry_count) { 542 reiserfs_panic(NULL, "item_ops-1", 543 "free space %d, entry_count %d", free, 544 dir_u->entry_count); 545 } 546 547 /* "." and ".." can not be separated from each other */ 548 if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) 549 && entries < 2) 550 entries = 0; 551 552 return entries ? : -1; 553 } 554 555 static int direntry_check_right(struct virtual_item *vi, int free) 556 { 557 int i; 558 int entries = 0; 559 struct direntry_uarea *dir_u = vi->vi_uarea; 560 561 for (i = dir_u->entry_count - 1; i >= 0; i--) { 562 /* i-th entry doesn't fit into the remaining free space */ 563 if (dir_u->entry_sizes[i] > free) 564 break; 565 566 free -= dir_u->entry_sizes[i]; 567 entries++; 568 } 569 BUG_ON(entries == dir_u->entry_count); 570 571 /* "." and ".." can not be separated from each other */ 572 if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) 573 && entries > dir_u->entry_count - 2) 574 entries = dir_u->entry_count - 2; 575 576 return entries ? : -1; 577 } 578 579 /* sum of entry sizes between from-th and to-th entries including both edges */ 580 static int direntry_part_size(struct virtual_item *vi, int first, int count) 581 { 582 int i, retval; 583 int from, to; 584 struct direntry_uarea *dir_u = vi->vi_uarea; 585 586 retval = 0; 587 if (first == 0) 588 from = 0; 589 else 590 from = dir_u->entry_count - count; 591 to = from + count - 1; 592 593 for (i = from; i <= to; i++) 594 retval += dir_u->entry_sizes[i]; 595 596 return retval; 597 } 598 599 static int direntry_unit_num(struct virtual_item *vi) 600 { 601 struct direntry_uarea *dir_u = vi->vi_uarea; 602 603 return dir_u->entry_count; 604 } 605 606 static void direntry_print_vi(struct virtual_item *vi) 607 { 608 int i; 609 struct direntry_uarea *dir_u = vi->vi_uarea; 610 611 reiserfs_warning(NULL, "reiserfs-16104", 612 "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x", 613 vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags); 614 printk("%d entries: ", dir_u->entry_count); 615 for (i = 0; i < dir_u->entry_count; i++) 616 printk("%d ", dir_u->entry_sizes[i]); 617 printk("\n"); 618 } 619 620 static struct item_operations direntry_ops = { 621 .bytes_number = direntry_bytes_number, 622 .decrement_key = direntry_decrement_key, 623 .is_left_mergeable = direntry_is_left_mergeable, 624 .print_item = direntry_print_item, 625 .check_item = direntry_check_item, 626 627 .create_vi = direntry_create_vi, 628 .check_left = direntry_check_left, 629 .check_right = direntry_check_right, 630 .part_size = direntry_part_size, 631 .unit_num = direntry_unit_num, 632 .print_vi = direntry_print_vi 633 }; 634 635 /* Error catching functions to catch errors caused by incorrect item types. */ 636 static int errcatch_bytes_number(struct item_head *ih, int block_size) 637 { 638 reiserfs_warning(NULL, "green-16001", 639 "Invalid item type observed, run fsck ASAP"); 640 return 0; 641 } 642 643 static void errcatch_decrement_key(struct cpu_key *key) 644 { 645 reiserfs_warning(NULL, "green-16002", 646 "Invalid item type observed, run fsck ASAP"); 647 } 648 649 static int errcatch_is_left_mergeable(struct reiserfs_key *key, 650 unsigned long bsize) 651 { 652 reiserfs_warning(NULL, "green-16003", 653 "Invalid item type observed, run fsck ASAP"); 654 return 0; 655 } 656 657 static void errcatch_print_item(struct item_head *ih, char *item) 658 { 659 reiserfs_warning(NULL, "green-16004", 660 "Invalid item type observed, run fsck ASAP"); 661 } 662 663 static void errcatch_check_item(struct item_head *ih, char *item) 664 { 665 reiserfs_warning(NULL, "green-16005", 666 "Invalid item type observed, run fsck ASAP"); 667 } 668 669 static int errcatch_create_vi(struct virtual_node *vn, 670 struct virtual_item *vi, 671 int is_affected, int insert_size) 672 { 673 reiserfs_warning(NULL, "green-16006", 674 "Invalid item type observed, run fsck ASAP"); 675 /* 676 * We might return -1 here as well, but it won't help as 677 * create_virtual_node() from where this operation is called 678 * from is of return type void. 679 */ 680 return 0; 681 } 682 683 static int errcatch_check_left(struct virtual_item *vi, int free, 684 int start_skip, int end_skip) 685 { 686 reiserfs_warning(NULL, "green-16007", 687 "Invalid item type observed, run fsck ASAP"); 688 return -1; 689 } 690 691 static int errcatch_check_right(struct virtual_item *vi, int free) 692 { 693 reiserfs_warning(NULL, "green-16008", 694 "Invalid item type observed, run fsck ASAP"); 695 return -1; 696 } 697 698 static int errcatch_part_size(struct virtual_item *vi, int first, int count) 699 { 700 reiserfs_warning(NULL, "green-16009", 701 "Invalid item type observed, run fsck ASAP"); 702 return 0; 703 } 704 705 static int errcatch_unit_num(struct virtual_item *vi) 706 { 707 reiserfs_warning(NULL, "green-16010", 708 "Invalid item type observed, run fsck ASAP"); 709 return 0; 710 } 711 712 static void errcatch_print_vi(struct virtual_item *vi) 713 { 714 reiserfs_warning(NULL, "green-16011", 715 "Invalid item type observed, run fsck ASAP"); 716 } 717 718 static struct item_operations errcatch_ops = { 719 .bytes_number = errcatch_bytes_number, 720 .decrement_key = errcatch_decrement_key, 721 .is_left_mergeable = errcatch_is_left_mergeable, 722 .print_item = errcatch_print_item, 723 .check_item = errcatch_check_item, 724 725 .create_vi = errcatch_create_vi, 726 .check_left = errcatch_check_left, 727 .check_right = errcatch_check_right, 728 .part_size = errcatch_part_size, 729 .unit_num = errcatch_unit_num, 730 .print_vi = errcatch_print_vi 731 }; 732 733 #if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3) 734 #error Item types must use disk-format assigned values. 735 #endif 736 737 struct item_operations *item_ops[TYPE_ANY + 1] = { 738 &stat_data_ops, 739 &indirect_ops, 740 &direct_ops, 741 &direntry_ops, 742 NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 743 &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */ 744 }; 745