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