linux/fs/reiserfs/item_ops.c
<<
>>
Prefs
   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//
  17static int sd_bytes_number(struct item_head *ih, int block_size)
  18{
  19        return 0;
  20}
  21
  22static 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
  29static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)
  30{
  31        return 0;
  32}
  33
  34static char *print_time(time_t t)
  35{
  36        static char timebuf[256];
  37
  38        sprintf(timebuf, "%ld", t);
  39        return timebuf;
  40}
  41
  42static 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
  61static void sd_check_item(struct item_head *ih, char *item)
  62{
  63        // FIXME: type something here!
  64}
  65
  66static 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
  75static 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
  82static int sd_check_right(struct virtual_item *vi, int free)
  83{
  84        return -1;
  85}
  86
  87static int sd_part_size(struct virtual_item *vi, int first, int count)
  88{
  89        BUG_ON(count);
  90        return 0;
  91}
  92
  93static int sd_unit_num(struct virtual_item *vi)
  94{
  95        return vi->vi_item_len - IH_SIZE;
  96}
  97
  98static 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
 105static 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//
 123static 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
 129static 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
 136static 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
 143static 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
 154static void direct_check_item(struct item_head *ih, char *item)
 155{
 156        // FIXME: type something here!
 157}
 158
 159static 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
 168static 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
 177static int direct_check_right(struct virtual_item *vi, int free)
 178{
 179        return direct_check_left(vi, free, 0, 0);
 180}
 181
 182static int direct_part_size(struct virtual_item *vi, int first, int count)
 183{
 184        return count;
 185}
 186
 187static int direct_unit_num(struct virtual_item *vi)
 188{
 189        return vi->vi_item_len - IH_SIZE;
 190}
 191
 192static 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
 199static 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
 218static 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
 224static 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
 232static 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
 240static void start_new_sequence(__u32 * start, int *len, __u32 new)
 241{
 242        *start = new;
 243        *len = 1;
 244}
 245
 246static 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
 262static 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
 273static 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
 296static void indirect_check_item(struct item_head *ih, char *item)
 297{
 298        // FIXME: type something here!
 299}
 300
 301static 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
 310static 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
 319static 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)
 325static 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
 331static 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
 337static 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
 344static 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
 363static 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
 370static 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
 377static 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
 386static 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
 426static 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 */
 443static 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 */
 469static 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//
 536static 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
 566static 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 */
 591static 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
 610static 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
 617static 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
 631static 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//
 649static 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
 656static 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
 662static 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
 670static 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
 676static 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
 682static 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
 692static 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
 700static 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
 707static 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
 714static 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
 721static 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
 727static 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
 749struct 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};
 757
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.