fs/reiserfs/item_ops.c

   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 char *print_time(time_t t)
  37 {
  38         static char timebuf[256];
  39
  40         sprintf(timebuf, "%ld", t);
  41         return timebuf;
  42 }
  43
  44 static 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
  63 static void sd_check_item(struct item_head *ih, char *item)
  64 {
  65         /* unused */
  66 }
  67
  68 static 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
  76 static 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
  83 static int sd_check_right(struct virtual_item *vi, int free)
  84 {
  85         return -1;
  86 }
  87
  88 static int sd_part_size(struct virtual_item *vi, int first, int count)
  89 {
  90         BUG_ON(count);
  91         return 0;
  92 }
  93
  94 static int sd_unit_num(struct virtual_item *vi)
  95 {
  96         return vi->vi_item_len - IH_SIZE;
  97 }
  98
  99 static 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
 106 static 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 */
 122 static 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 */
 128 static 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
 135 static 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
 142 static 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
 153 static void direct_check_item(struct item_head *ih, char *item)
 154 {
 155         /* unused */
 156 }
 157
 158 static 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
 166 static 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
 175 static int direct_check_right(struct virtual_item *vi, int free)
 176 {
 177         return direct_check_left(vi, free, 0, 0);
 178 }
 179
 180 static int direct_part_size(struct virtual_item *vi, int first, int count)
 181 {
 182         return count;
 183 }
 184
 185 static int direct_unit_num(struct virtual_item *vi)
 186 {
 187         return vi->vi_item_len - IH_SIZE;
 188 }
 189
 190 static 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
 197 static 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 */
 213 static 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 */
 219 static 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 */
 227 static 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 */
 235 static void start_new_sequence(__u32 * start, int *len, __u32 new)
 236 {
 237         *start = new;
 238         *len = 1;
 239 }
 240
 241 static 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
 257 static 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
 268 static 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
 291 static void indirect_check_item(struct item_head *ih, char *item)
 292 {
 293         /* unused */
 294 }
 295
 296 static 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
 304 static 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
 313 static 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  */
 322 static 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
 328 static 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
 334 static 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
 341 static 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 */
 357 static 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
 364 static 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
 371 static 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
 380 static 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
 420 static 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  */
 438 static 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  */
 466 static 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  */
 533 static 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
 563 static 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 */
 588 static 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
 607 static 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
 614 static 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
 628 static 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. */
 644 static 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
 651 static 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
 657 static 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
 665 static 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
 671 static 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
 677 static 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
 691 static 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
 699 static 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
 706 static 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
 713 static 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
 720 static 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
 726 static 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
 745 struct 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 };