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