take private bits of reiserfs_xattr.h to fs/reiserfs/xattr.h
[linux-2.6.git] / fs / reiserfs / item_ops.c
index e477aeb..72cb1cc 100644 (file)
 //////////////////////////////////////////////////////////////////////////////
 // stat data functions
 //
-static int sd_bytes_number (struct item_head * ih, int block_size)
+static int sd_bytes_number(struct item_head *ih, int block_size)
 {
-  return 0;
+       return 0;
 }
 
-static void sd_decrement_key (struct cpu_key * key)
+static void sd_decrement_key(struct cpu_key *key)
 {
-    key->on_disk_key.k_objectid --;
-    set_cpu_key_k_type (key, TYPE_ANY);
-    set_cpu_key_k_offset(key, (loff_t)(-1));
+       key->on_disk_key.k_objectid--;
+       set_cpu_key_k_type(key, TYPE_ANY);
+       set_cpu_key_k_offset(key, (loff_t)(~0ULL >> 1));
 }
 
-static int sd_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
+static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize)
 {
-    return 0;
+       return 0;
 }
 
-
-
-static char * print_time (time_t t)
+static char *print_time(time_t t)
 {
-    static char timebuf[256];
+       static char timebuf[256];
 
-    sprintf (timebuf, "%ld", t);
-    return timebuf;
+       sprintf(timebuf, "%ld", t);
+       return timebuf;
 }
 
-
-static void sd_print_item (struct item_head * ih, char * item)
+static void sd_print_item(struct item_head *ih, char *item)
 {
-    printk ("\tmode | size | nlinks | first direct | mtime\n");
-    if (stat_data_v1 (ih)) {
-       struct stat_data_v1 * sd = (struct stat_data_v1 *)item;
+       printk("\tmode | size | nlinks | first direct | mtime\n");
+       if (stat_data_v1(ih)) {
+               struct stat_data_v1 *sd = (struct stat_data_v1 *)item;
 
-       printk ("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
-                sd_v1_size(sd), sd_v1_nlink(sd), sd_v1_first_direct_byte(sd),
-                print_time( sd_v1_mtime(sd) ) );
-    } else {
-       struct stat_data * sd = (struct stat_data *)item;
+               printk("\t0%-6o | %6u | %2u | %d | %s\n", sd_v1_mode(sd),
+                      sd_v1_size(sd), sd_v1_nlink(sd),
+                      sd_v1_first_direct_byte(sd),
+                      print_time(sd_v1_mtime(sd)));
+       } else {
+               struct stat_data *sd = (struct stat_data *)item;
 
-       printk ("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
-            (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
-            sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
-    }
+               printk("\t0%-6o | %6Lu | %2u | %d | %s\n", sd_v2_mode(sd),
+                      (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd),
+                      sd_v2_rdev(sd), print_time(sd_v2_mtime(sd)));
+       }
 }
 
-static void sd_check_item (struct item_head * ih, char * item)
+static void sd_check_item(struct item_head *ih, char *item)
 {
-    // FIXME: type something here!
+       // FIXME: type something here!
 }
 
-
-static int sd_create_vi (struct virtual_node * vn,
-                        struct virtual_item * vi, 
-                        int is_affected, 
-                        int insert_size)
+static int sd_create_vi(struct virtual_node *vn,
+                       struct virtual_item *vi,
+                       int is_affected, int insert_size)
 {
-    vi->vi_index = TYPE_STAT_DATA;
-    //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
-    return 0;
+       vi->vi_index = TYPE_STAT_DATA;
+       //vi->vi_type |= VI_TYPE_STAT_DATA;// not needed?
+       return 0;
 }
 
-
-static int sd_check_left (struct virtual_item * vi, int free, 
-                         int start_skip, int end_skip)
+static int sd_check_left(struct virtual_item *vi, int free,
+                        int start_skip, int end_skip)
 {
-    if (start_skip || end_skip)
-       BUG ();
-    return -1;
+       BUG_ON(start_skip || end_skip);
+       return -1;
 }
 
-
-static int sd_check_right (struct virtual_item * vi, int free)
+static int sd_check_right(struct virtual_item *vi, int free)
 {
-    return -1;
+       return -1;
 }
 
-static int sd_part_size (struct virtual_item * vi, int first, int count)
+static int sd_part_size(struct virtual_item *vi, int first, int count)
 {
-    if (count)
-       BUG ();
-    return 0;
+       BUG_ON(count);
+       return 0;
 }
 
-static int sd_unit_num (struct virtual_item * vi)
+static int sd_unit_num(struct virtual_item *vi)
 {
-    return vi->vi_item_len - IH_SIZE;
+       return vi->vi_item_len - IH_SIZE;
 }
 
-
-static void sd_print_vi (struct virtual_item * vi)
+static void sd_print_vi(struct virtual_item *vi)
 {
-    reiserfs_warning (NULL, "STATDATA, index %d, type 0x%x, %h",
-                     vi->vi_index, vi->vi_type, vi->vi_ih);
+       reiserfs_warning(NULL, "reiserfs-16100",
+                        "STATDATA, index %d, type 0x%x, %h",
+                        vi->vi_index, vi->vi_type, vi->vi_ih);
 }
 
 static struct item_operations stat_data_ops = {
-       .bytes_number           = sd_bytes_number,
-       .decrement_key          = sd_decrement_key,
-       .is_left_mergeable      = sd_is_left_mergeable,
-       .print_item             = sd_print_item,
-       .check_item             = sd_check_item,
-
-       .create_vi              = sd_create_vi,
-       .check_left             = sd_check_left,
-       .check_right            = sd_check_right,
-       .part_size              = sd_part_size,
-       .unit_num               = sd_unit_num,
-       .print_vi               = sd_print_vi
+       .bytes_number = sd_bytes_number,
+       .decrement_key = sd_decrement_key,
+       .is_left_mergeable = sd_is_left_mergeable,
+       .print_item = sd_print_item,
+       .check_item = sd_check_item,
+
+       .create_vi = sd_create_vi,
+       .check_left = sd_check_left,
+       .check_right = sd_check_right,
+       .part_size = sd_part_size,
+       .unit_num = sd_unit_num,
+       .print_vi = sd_print_vi
 };
 
-
-
 //////////////////////////////////////////////////////////////////////////////
 // direct item functions
 //
-static int direct_bytes_number (struct item_head * ih, int block_size)
+static int direct_bytes_number(struct item_head *ih, int block_size)
 {
-  return ih_item_len(ih);
+       return ih_item_len(ih);
 }
 
-
 // FIXME: this should probably switch to indirect as well
-static void direct_decrement_key (struct cpu_key * key)
+static void direct_decrement_key(struct cpu_key *key)
 {
-    cpu_key_k_offset_dec (key);
-    if (cpu_key_k_offset (key) == 0)
-       set_cpu_key_k_type (key, TYPE_STAT_DATA);       
+       cpu_key_k_offset_dec(key);
+       if (cpu_key_k_offset(key) == 0)
+               set_cpu_key_k_type(key, TYPE_STAT_DATA);
 }
 
-
-static int direct_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
+static int direct_is_left_mergeable(struct reiserfs_key *key,
+                                   unsigned long bsize)
 {
-    int version = le_key_version (key);
-    return ((le_key_k_offset (version, key) & (bsize - 1)) != 1);
+       int version = le_key_version(key);
+       return ((le_key_k_offset(version, key) & (bsize - 1)) != 1);
 }
 
-
-static void direct_print_item (struct item_head * ih, char * item)
+static void direct_print_item(struct item_head *ih, char *item)
 {
-    int j = 0;
+       int j = 0;
 
 //    return;
-    printk ("\"");
-    while (j < ih_item_len(ih))
-       printk ("%c", item[j++]);
-    printk ("\"\n");
+       printk("\"");
+       while (j < ih_item_len(ih))
+               printk("%c", item[j++]);
+       printk("\"\n");
 }
 
-
-static void direct_check_item (struct item_head * ih, char * item)
+static void direct_check_item(struct item_head *ih, char *item)
 {
-    // FIXME: type something here!
+       // FIXME: type something here!
 }
 
-
-static int direct_create_vi (struct virtual_node * vn,
-                            struct virtual_item * vi, 
-                            int is_affected, 
-                            int insert_size)
+static int direct_create_vi(struct virtual_node *vn,
+                           struct virtual_item *vi,
+                           int is_affected, int insert_size)
 {
-    vi->vi_index = TYPE_DIRECT;
-    //vi->vi_type |= VI_TYPE_DIRECT;
-    return 0;
+       vi->vi_index = TYPE_DIRECT;
+       //vi->vi_type |= VI_TYPE_DIRECT;
+       return 0;
 }
 
-static int direct_check_left (struct virtual_item * vi, int free,
-                             int start_skip, int end_skip)
+static int direct_check_left(struct virtual_item *vi, int free,
+                            int start_skip, int end_skip)
 {
-    int bytes;
+       int bytes;
 
-    bytes = free - free % 8;
-    return bytes ?: -1;    
+       bytes = free - free % 8;
+       return bytes ? : -1;
 }
 
-
-static int direct_check_right (struct virtual_item * vi, int free)
+static int direct_check_right(struct virtual_item *vi, int free)
 {
-    return direct_check_left (vi, free, 0, 0);
+       return direct_check_left(vi, free, 0, 0);
 }
 
-static int direct_part_size (struct virtual_item * vi, int first, int count)
+static int direct_part_size(struct virtual_item *vi, int first, int count)
 {
-    return count;
+       return count;
 }
 
-
-static int direct_unit_num (struct virtual_item * vi)
+static int direct_unit_num(struct virtual_item *vi)
 {
-    return vi->vi_item_len - IH_SIZE;
+       return vi->vi_item_len - IH_SIZE;
 }
 
-
-static void direct_print_vi (struct virtual_item * vi)
+static void direct_print_vi(struct virtual_item *vi)
 {
-    reiserfs_warning (NULL, "DIRECT, index %d, type 0x%x, %h",
-                     vi->vi_index, vi->vi_type, vi->vi_ih);
+       reiserfs_warning(NULL, "reiserfs-16101",
+                        "DIRECT, index %d, type 0x%x, %h",
+                        vi->vi_index, vi->vi_type, vi->vi_ih);
 }
 
 static struct item_operations direct_ops = {
-       .bytes_number           = direct_bytes_number,
-       .decrement_key          = direct_decrement_key,
-       .is_left_mergeable      = direct_is_left_mergeable,
-       .print_item             = direct_print_item,
-       .check_item             = direct_check_item,
-
-       .create_vi              = direct_create_vi,
-       .check_left             = direct_check_left,
-       .check_right            = direct_check_right,
-       .part_size              = direct_part_size,
-       .unit_num               = direct_unit_num,
-       .print_vi               = direct_print_vi
+       .bytes_number = direct_bytes_number,
+       .decrement_key = direct_decrement_key,
+       .is_left_mergeable = direct_is_left_mergeable,
+       .print_item = direct_print_item,
+       .check_item = direct_check_item,
+
+       .create_vi = direct_create_vi,
+       .check_left = direct_check_left,
+       .check_right = direct_check_right,
+       .part_size = direct_part_size,
+       .unit_num = direct_unit_num,
+       .print_vi = direct_print_vi
 };
 
-
-
 //////////////////////////////////////////////////////////////////////////////
 // indirect item functions
 //
 
-static int indirect_bytes_number (struct item_head * ih, int block_size)
+static int indirect_bytes_number(struct item_head *ih, int block_size)
 {
-  return ih_item_len(ih) / UNFM_P_SIZE * block_size; //- get_ih_free_space (ih);
+       return ih_item_len(ih) / UNFM_P_SIZE * block_size;      //- get_ih_free_space (ih);
 }
 
-
 // decrease offset, if it becomes 0, change type to stat data
-static void indirect_decrement_key (struct cpu_key * key)
+static void indirect_decrement_key(struct cpu_key *key)
 {
-    cpu_key_k_offset_dec (key);
-    if (cpu_key_k_offset (key) == 0)
-       set_cpu_key_k_type (key, TYPE_STAT_DATA);
+       cpu_key_k_offset_dec(key);
+       if (cpu_key_k_offset(key) == 0)
+               set_cpu_key_k_type(key, TYPE_STAT_DATA);
 }
 
-
 // if it is not first item of the body, then it is mergeable
-static int indirect_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
+static int indirect_is_left_mergeable(struct reiserfs_key *key,
+                                     unsigned long bsize)
 {
-    int version = le_key_version (key);
-    return (le_key_k_offset (version, key) != 1);
+       int version = le_key_version(key);
+       return (le_key_k_offset(version, key) != 1);
 }
 
-
 // printing of indirect item
-static void start_new_sequence (__u32 * start, int * len, __u32 new)
+static void start_new_sequence(__u32 * start, int *len, __u32 new)
 {
-    *start = new;
-    *len = 1;
+       *start = new;
+       *len = 1;
 }
 
-
-static int sequence_finished (__u32 start, int * len, __u32 new)
+static int sequence_finished(__u32 start, int *len, __u32 new)
 {
-    if (start == INT_MAX)
-       return 1;
+       if (start == INT_MAX)
+               return 1;
 
-    if (start == 0 && new == 0) {
-       (*len) ++;
-       return 0;
-    }
-    if (start != 0 && (start + *len) == new) {
-       (*len) ++;
-       return 0;
-    }
-    return 1;
+       if (start == 0 && new == 0) {
+               (*len)++;
+               return 0;
+       }
+       if (start != 0 && (start + *len) == new) {
+               (*len)++;
+               return 0;
+       }
+       return 1;
 }
 
-static void print_sequence (__u32 start, int len)
+static void print_sequence(__u32 start, int len)
 {
-    if (start == INT_MAX)
-       return;
+       if (start == INT_MAX)
+               return;
 
-    if (len == 1)
-       printk (" %d", start);
-    else
-       printk (" %d(%d)", start, len);
+       if (len == 1)
+               printk(" %d", start);
+       else
+               printk(" %d(%d)", start, len);
 }
 
-
-static void indirect_print_item (struct item_head * ih, char * item)
+static void indirect_print_item(struct item_head *ih, char *item)
 {
-    int j;
-    __le32 * unp;
-    __u32 prev = INT_MAX;
-    int num;
+       int j;
+       __le32 *unp;
+       __u32 prev = INT_MAX;
+       int num = 0;
 
-    unp = (__le32 *)item;
+       unp = (__le32 *) item;
 
-    if (ih_item_len(ih) % UNFM_P_SIZE)
-       reiserfs_warning (NULL, "indirect_print_item: invalid item len");
+       if (ih_item_len(ih) % UNFM_P_SIZE)
+               reiserfs_warning(NULL, "reiserfs-16102", "invalid item len");
 
-    printk ("%d pointers\n[ ", (int)I_UNFM_NUM (ih));
-    for (j = 0; j < I_UNFM_NUM (ih); j ++) {
-       if (sequence_finished (prev, &num, get_block_num(unp, j))) {
-           print_sequence (prev, num);
-           start_new_sequence (&prev, &num, get_block_num(unp, j));
+       printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih));
+       for (j = 0; j < I_UNFM_NUM(ih); j++) {
+               if (sequence_finished(prev, &num, get_block_num(unp, j))) {
+                       print_sequence(prev, num);
+                       start_new_sequence(&prev, &num, get_block_num(unp, j));
+               }
        }
-    }
-    print_sequence (prev, num);
-    printk ("]\n");
+       print_sequence(prev, num);
+       printk("]\n");
 }
 
-static void indirect_check_item (struct item_head * ih, char * item)
+static void indirect_check_item(struct item_head *ih, char *item)
 {
-    // FIXME: type something here!
+       // FIXME: type something here!
 }
 
-
-static int indirect_create_vi (struct virtual_node * vn,
-                              struct virtual_item * vi, 
-                              int is_affected, 
-                              int insert_size)
+static int indirect_create_vi(struct virtual_node *vn,
+                             struct virtual_item *vi,
+                             int is_affected, int insert_size)
 {
-    vi->vi_index = TYPE_INDIRECT;
-    //vi->vi_type |= VI_TYPE_INDIRECT;
-    return 0;
+       vi->vi_index = TYPE_INDIRECT;
+       //vi->vi_type |= VI_TYPE_INDIRECT;
+       return 0;
 }
 
-static int indirect_check_left (struct virtual_item * vi, int free,
-                               int start_skip, int end_skip)
+static int indirect_check_left(struct virtual_item *vi, int free,
+                              int start_skip, int end_skip)
 {
-    int bytes;
+       int bytes;
 
-    bytes = free - free % UNFM_P_SIZE;
-    return bytes ?: -1;    
+       bytes = free - free % UNFM_P_SIZE;
+       return bytes ? : -1;
 }
 
-
-static int indirect_check_right (struct virtual_item * vi, int free)
+static int indirect_check_right(struct virtual_item *vi, int free)
 {
-    return indirect_check_left (vi, free, 0, 0);
+       return indirect_check_left(vi, free, 0, 0);
 }
 
-
-
 // return size in bytes of 'units' units. If first == 0 - calculate from the head (left), otherwise - from tail (right)
-static int indirect_part_size (struct virtual_item * vi, int first, int units)
+static int indirect_part_size(struct virtual_item *vi, int first, int units)
 {
-    // unit of indirect item is byte (yet)
-    return units;
+       // unit of indirect item is byte (yet)
+       return units;
 }
 
-static int indirect_unit_num (struct virtual_item * vi)
+static int indirect_unit_num(struct virtual_item *vi)
 {
-    // unit of indirect item is byte (yet)
-    return vi->vi_item_len - IH_SIZE;
+       // unit of indirect item is byte (yet)
+       return vi->vi_item_len - IH_SIZE;
 }
 
-static void indirect_print_vi (struct virtual_item * vi)
+static void indirect_print_vi(struct virtual_item *vi)
 {
-    reiserfs_warning (NULL, "INDIRECT, index %d, type 0x%x, %h",
-                     vi->vi_index, vi->vi_type, vi->vi_ih);
+       reiserfs_warning(NULL, "reiserfs-16103",
+                        "INDIRECT, index %d, type 0x%x, %h",
+                        vi->vi_index, vi->vi_type, vi->vi_ih);
 }
 
 static struct item_operations indirect_ops = {
-       .bytes_number           = indirect_bytes_number,
-       .decrement_key          = indirect_decrement_key,
-       .is_left_mergeable      = indirect_is_left_mergeable,
-       .print_item             = indirect_print_item,
-       .check_item             = indirect_check_item,
-
-       .create_vi              = indirect_create_vi,
-       .check_left             = indirect_check_left,
-       .check_right            = indirect_check_right,
-       .part_size              = indirect_part_size,
-       .unit_num               = indirect_unit_num,
-       .print_vi               = indirect_print_vi
+       .bytes_number = indirect_bytes_number,
+       .decrement_key = indirect_decrement_key,
+       .is_left_mergeable = indirect_is_left_mergeable,
+       .print_item = indirect_print_item,
+       .check_item = indirect_check_item,
+
+       .create_vi = indirect_create_vi,
+       .check_left = indirect_check_left,
+       .check_right = indirect_check_right,
+       .part_size = indirect_part_size,
+       .unit_num = indirect_unit_num,
+       .print_vi = indirect_print_vi
 };
 
-
 //////////////////////////////////////////////////////////////////////////////
 // direntry functions
 //
 
-
-static int direntry_bytes_number (struct item_head * ih, int block_size)
+static int direntry_bytes_number(struct item_head *ih, int block_size)
 {
-    reiserfs_warning (NULL, "vs-16090: direntry_bytes_number: "
-                     "bytes number is asked for direntry");
-    return 0;
-}
-
-static void direntry_decrement_key (struct cpu_key * key)
-{
-    cpu_key_k_offset_dec (key);
-    if (cpu_key_k_offset (key) == 0)
-       set_cpu_key_k_type (key, TYPE_STAT_DATA);       
+       reiserfs_warning(NULL, "vs-16090",
+                        "bytes number is asked for direntry");
+       return 0;
 }
 
-
-static int direntry_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
+static void direntry_decrement_key(struct cpu_key *key)
 {
-    if (le32_to_cpu (key->u.k_offset_v1.k_offset) == DOT_OFFSET)
-       return 0;
-    return 1;
-       
+       cpu_key_k_offset_dec(key);
+       if (cpu_key_k_offset(key) == 0)
+               set_cpu_key_k_type(key, TYPE_STAT_DATA);
 }
 
-
-static void direntry_print_item (struct item_head * ih, char * item)
+static int direntry_is_left_mergeable(struct reiserfs_key *key,
+                                     unsigned long bsize)
 {
-    int i;
-    int namelen;
-    struct reiserfs_de_head * deh;
-    char * name;
-    static char namebuf [80];
-
-
-    printk ("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name", "Key of pointed object", "Hash", "Gen number", "Status");
+       if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET)
+               return 0;
+       return 1;
 
-    deh = (struct reiserfs_de_head *)item;
+}
 
-    for (i = 0; i < I_ENTRY_COUNT (ih); i ++, deh ++) {
-       namelen = (i ? (deh_location(deh - 1)) : ih_item_len(ih)) - deh_location(deh);
-       name = item + deh_location(deh);
-       if (name[namelen-1] == 0)
-         namelen = strlen (name);
-       namebuf[0] = '"';
-       if (namelen > sizeof (namebuf) - 3) {
-           strncpy (namebuf + 1, name, sizeof (namebuf) - 3);
-           namebuf[sizeof (namebuf) - 2] = '"';
-           namebuf[sizeof (namebuf) - 1] = 0;
-       } else {
-           memcpy (namebuf + 1, name, namelen);
-           namebuf[namelen + 1] = '"';
-           namebuf[namelen + 2] = 0;
+static void direntry_print_item(struct item_head *ih, char *item)
+{
+       int i;
+       int namelen;
+       struct reiserfs_de_head *deh;
+       char *name;
+       static char namebuf[80];
+
+       printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name",
+              "Key of pointed object", "Hash", "Gen number", "Status");
+
+       deh = (struct reiserfs_de_head *)item;
+
+       for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
+               namelen =
+                   (i ? (deh_location(deh - 1)) : ih_item_len(ih)) -
+                   deh_location(deh);
+               name = item + deh_location(deh);
+               if (name[namelen - 1] == 0)
+                       namelen = strlen(name);
+               namebuf[0] = '"';
+               if (namelen > sizeof(namebuf) - 3) {
+                       strncpy(namebuf + 1, name, sizeof(namebuf) - 3);
+                       namebuf[sizeof(namebuf) - 2] = '"';
+                       namebuf[sizeof(namebuf) - 1] = 0;
+               } else {
+                       memcpy(namebuf + 1, name, namelen);
+                       namebuf[namelen + 1] = '"';
+                       namebuf[namelen + 2] = 0;
+               }
+
+               printk("%d:  %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n",
+                      i, namebuf,
+                      deh_dir_id(deh), deh_objectid(deh),
+                      GET_HASH_VALUE(deh_offset(deh)),
+                      GET_GENERATION_NUMBER((deh_offset(deh))),
+                      (de_hidden(deh)) ? "HIDDEN" : "VISIBLE");
        }
-
-       printk ("%d:  %-15s%-15d%-15d%-15Ld%-15Ld(%s)\n", 
-               i, namebuf,
-               deh_dir_id(deh), deh_objectid(deh),
-               GET_HASH_VALUE (deh_offset (deh)), GET_GENERATION_NUMBER ((deh_offset (deh))),
-               (de_hidden (deh)) ? "HIDDEN" : "VISIBLE");
-    }
 }
 
-
-static void direntry_check_item (struct item_head * ih, char * item)
+static void direntry_check_item(struct item_head *ih, char *item)
 {
-    int i;
-    struct reiserfs_de_head * deh;
+       int i;
+       struct reiserfs_de_head *deh;
 
-    // FIXME: type something here!
-    deh = (struct reiserfs_de_head *)item;
-    for (i = 0; i < I_ENTRY_COUNT (ih); i ++, deh ++) {
-       ;
-    }
+       // FIXME: type something here!
+       deh = (struct reiserfs_de_head *)item;
+       for (i = 0; i < I_ENTRY_COUNT(ih); i++, deh++) {
+               ;
+       }
 }
 
-
-
 #define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1
 
 /*
  * function returns old entry number in directory item in real node
  * using new entry number in virtual item in virtual node */
-static inline int old_entry_num (int is_affected, int virtual_entry_num, int pos_in_item, int mode)
+static inline int old_entry_num(int is_affected, int virtual_entry_num,
+                               int pos_in_item, int mode)
 {
-    if ( mode == M_INSERT || mode == M_DELETE)
-       return virtual_entry_num;
-    
-    if (!is_affected)
-       /* cut or paste is applied to another item */
-       return virtual_entry_num;
-
-    if (virtual_entry_num < pos_in_item)
-       return virtual_entry_num;
+       if (mode == M_INSERT || mode == M_DELETE)
+               return virtual_entry_num;
 
-    if (mode == M_CUT)
-       return virtual_entry_num + 1;
+       if (!is_affected)
+               /* cut or paste is applied to another item */
+               return virtual_entry_num;
 
-    RFALSE( mode != M_PASTE || virtual_entry_num == 0,
-           "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'", mode);
-    
-    return virtual_entry_num - 1;
-}
+       if (virtual_entry_num < pos_in_item)
+               return virtual_entry_num;
 
+       if (mode == M_CUT)
+               return virtual_entry_num + 1;
 
+       RFALSE(mode != M_PASTE || virtual_entry_num == 0,
+              "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'",
+              mode);
 
+       return virtual_entry_num - 1;
+}
 
 /* Create an array of sizes of directory entries for virtual
    item. Return space used by an item. FIXME: no control over
    consuming of space used by this item handler */
-static int direntry_create_vi (struct virtual_node * vn,
-                              struct virtual_item * vi, 
-                              int is_affected, 
-                              int insert_size)
-{
-    struct direntry_uarea * dir_u = vi->vi_uarea;
-    int i, j;
-    int size = sizeof (struct direntry_uarea);
-    struct reiserfs_de_head * deh;
-  
-    vi->vi_index = TYPE_DIRENTRY;
-
-    if (!(vi->vi_ih) || !vi->vi_item)
-       BUG ();
-
-
-    dir_u->flags = 0;
-    if (le_ih_k_offset (vi->vi_ih) == DOT_OFFSET)
-       dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
-
-    deh = (struct reiserfs_de_head *)(vi->vi_item);
-    
-    
-    /* virtual directory item have this amount of entry after */
-    dir_u->entry_count = ih_entry_count (vi->vi_ih) + 
-       ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
-                         (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
-    
-    for (i = 0; i < dir_u->entry_count; i ++) {
-       j = old_entry_num (is_affected, i, vn->vn_pos_in_item, vn->vn_mode);
-        dir_u->entry_sizes[i] = (j ? deh_location( &(deh[j - 1]) ) :
-                                ih_item_len (vi->vi_ih)) -
-                                deh_location( &(deh[j])) + DEH_SIZE;
-    }
-
-    size += (dir_u->entry_count * sizeof (short));
-    
-    /* set size of pasted entry */
-    if (is_affected && vn->vn_mode == M_PASTE)
-       dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
+static int direntry_create_vi(struct virtual_node *vn,
+                             struct virtual_item *vi,
+                             int is_affected, int insert_size)
+{
+       struct direntry_uarea *dir_u = vi->vi_uarea;
+       int i, j;
+       int size = sizeof(struct direntry_uarea);
+       struct reiserfs_de_head *deh;
 
+       vi->vi_index = TYPE_DIRENTRY;
+
+       BUG_ON(!(vi->vi_ih) || !vi->vi_item);
+
+       dir_u->flags = 0;
+       if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET)
+               dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM;
+
+       deh = (struct reiserfs_de_head *)(vi->vi_item);
+
+       /* virtual directory item have this amount of entry after */
+       dir_u->entry_count = ih_entry_count(vi->vi_ih) +
+           ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 :
+                             (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
+
+       for (i = 0; i < dir_u->entry_count; i++) {
+               j = old_entry_num(is_affected, i, vn->vn_pos_in_item,
+                                 vn->vn_mode);
+               dir_u->entry_sizes[i] =
+                   (j ? deh_location(&(deh[j - 1])) : ih_item_len(vi->vi_ih)) -
+                   deh_location(&(deh[j])) + DEH_SIZE;
+       }
+
+       size += (dir_u->entry_count * sizeof(short));
+
+       /* set size of pasted entry */
+       if (is_affected && vn->vn_mode == M_PASTE)
+               dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size;
 
 #ifdef CONFIG_REISERFS_CHECK
-    /* compare total size of entries with item length */
-    {
-       int k, l;
-    
-       l = 0;
-       for (k = 0; k < dir_u->entry_count; k ++)
-           l += dir_u->entry_sizes[k];
-    
-       if (l + IH_SIZE != vi->vi_item_len + 
-           ((is_affected && (vn->vn_mode == M_PASTE || vn->vn_mode == M_CUT)) ? insert_size : 0) ) {
-           reiserfs_panic (NULL, "vs-8025: set_entry_sizes: (mode==%c, insert_size==%d), invalid length of directory item",
-                           vn->vn_mode, insert_size);
+       /* compare total size of entries with item length */
+       {
+               int k, l;
+
+               l = 0;
+               for (k = 0; k < dir_u->entry_count; k++)
+                       l += dir_u->entry_sizes[k];
+
+               if (l + IH_SIZE != vi->vi_item_len +
+                   ((is_affected
+                     && (vn->vn_mode == M_PASTE
+                         || vn->vn_mode == M_CUT)) ? insert_size : 0)) {
+                       reiserfs_panic(NULL, "vs-8025", "(mode==%c, "
+                                      "insert_size==%d), invalid length of "
+                                      "directory item",
+                                      vn->vn_mode, insert_size);
+               }
        }
-    }
 #endif
 
-    return size;
-
+       return size;
 
 }
 
-
 //
 // return number of entries which may fit into specified amount of
 // free space, or -1 if free space is not enough even for 1 entry
 //
-static int direntry_check_left (struct virtual_item * vi, int free,
-                               int start_skip, int end_skip)
+static int direntry_check_left(struct virtual_item *vi, int free,
+                              int start_skip, int end_skip)
 {
-    int i;
-    int entries = 0;
-    struct direntry_uarea * dir_u = vi->vi_uarea;
+       int i;
+       int entries = 0;
+       struct direntry_uarea *dir_u = vi->vi_uarea;
 
-    for (i = start_skip; i < dir_u->entry_count - end_skip; i ++) {
-       if (dir_u->entry_sizes[i] > free)
-           /* i-th entry doesn't fit into the remaining free space */
-           break;
-                 
-       free -= dir_u->entry_sizes[i];
-       entries ++;
-    }
+       for (i = start_skip; i < dir_u->entry_count - end_skip; i++) {
+               if (dir_u->entry_sizes[i] > free)
+                       /* i-th entry doesn't fit into the remaining free space */
+                       break;
 
-    if (entries == dir_u->entry_count) {
-       reiserfs_panic (NULL, "free space %d, entry_count %d\n", free, dir_u->entry_count);
-    }
+               free -= dir_u->entry_sizes[i];
+               entries++;
+       }
 
-    /* "." and ".." can not be separated from each other */
-    if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) && entries < 2)
-       entries = 0;
-    
-    return entries ?: -1;
-}
+       if (entries == dir_u->entry_count) {
+               reiserfs_panic(NULL, "item_ops-1",
+                              "free space %d, entry_count %d", free,
+                              dir_u->entry_count);
+       }
 
+       /* "." and ".." can not be separated from each other */
+       if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
+           && entries < 2)
+               entries = 0;
 
-static int direntry_check_right (struct virtual_item * vi, int free)
+       return entries ? : -1;
+}
+
+static int direntry_check_right(struct virtual_item *vi, int free)
 {
-    int i;
-    int entries = 0;
-    struct direntry_uarea * dir_u = vi->vi_uarea;
-    
-    for (i = dir_u->entry_count - 1; i >= 0; i --) {
-       if (dir_u->entry_sizes[i] > free)
-           /* i-th entry doesn't fit into the remaining free space */
-           break;
-       
-       free -= dir_u->entry_sizes[i];
-       entries ++;
-    }
-    if (entries == dir_u->entry_count)
-       BUG ();
+       int i;
+       int entries = 0;
+       struct direntry_uarea *dir_u = vi->vi_uarea;
 
-    /* "." and ".." can not be separated from each other */
-    if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) && entries > dir_u->entry_count - 2)
-       entries = dir_u->entry_count - 2;
+       for (i = dir_u->entry_count - 1; i >= 0; i--) {
+               if (dir_u->entry_sizes[i] > free)
+                       /* i-th entry doesn't fit into the remaining free space */
+                       break;
 
-    return entries ?: -1;
-}
+               free -= dir_u->entry_sizes[i];
+               entries++;
+       }
+       BUG_ON(entries == dir_u->entry_count);
 
+       /* "." and ".." can not be separated from each other */
+       if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM)
+           && entries > dir_u->entry_count - 2)
+               entries = dir_u->entry_count - 2;
+
+       return entries ? : -1;
+}
 
 /* sum of entry sizes between from-th and to-th entries including both edges */
-static int direntry_part_size (struct virtual_item * vi, int first, int count)
+static int direntry_part_size(struct virtual_item *vi, int first, int count)
 {
-    int i, retval;
-    int from, to;
-    struct direntry_uarea * dir_u = vi->vi_uarea;
-    
-    retval = 0;
-    if (first == 0)
-       from = 0;
-    else
-       from = dir_u->entry_count - count;
-    to = from + count - 1;
+       int i, retval;
+       int from, to;
+       struct direntry_uarea *dir_u = vi->vi_uarea;
 
-    for (i = from; i <= to; i ++)
-       retval += dir_u->entry_sizes[i];
+       retval = 0;
+       if (first == 0)
+               from = 0;
+       else
+               from = dir_u->entry_count - count;
+       to = from + count - 1;
 
-    return retval;
-}
+       for (i = from; i <= to; i++)
+               retval += dir_u->entry_sizes[i];
 
-static int direntry_unit_num (struct virtual_item * vi)
-{
-    struct direntry_uarea * dir_u = vi->vi_uarea;
-    
-    return dir_u->entry_count;
+       return retval;
 }
 
+static int direntry_unit_num(struct virtual_item *vi)
+{
+       struct direntry_uarea *dir_u = vi->vi_uarea;
 
+       return dir_u->entry_count;
+}
 
-static void direntry_print_vi (struct virtual_item * vi)
+static void direntry_print_vi(struct virtual_item *vi)
 {
-    int i;
-    struct direntry_uarea * dir_u = vi->vi_uarea;
+       int i;
+       struct direntry_uarea *dir_u = vi->vi_uarea;
 
-    reiserfs_warning (NULL, "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
-                     vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
-    printk ("%d entries: ", dir_u->entry_count);
-    for (i = 0; i < dir_u->entry_count; i ++)
-       printk ("%d ", dir_u->entry_sizes[i]);
-    printk ("\n");
+       reiserfs_warning(NULL, "reiserfs-16104",
+                        "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x",
+                        vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags);
+       printk("%d entries: ", dir_u->entry_count);
+       for (i = 0; i < dir_u->entry_count; i++)
+               printk("%d ", dir_u->entry_sizes[i]);
+       printk("\n");
 }
 
 static struct item_operations direntry_ops = {
-       .bytes_number           = direntry_bytes_number,
-       .decrement_key          = direntry_decrement_key,
-       .is_left_mergeable      = direntry_is_left_mergeable,
-       .print_item             = direntry_print_item,
-       .check_item             = direntry_check_item,
-
-       .create_vi              = direntry_create_vi,
-       .check_left             = direntry_check_left,
-       .check_right            = direntry_check_right,
-       .part_size              = direntry_part_size,
-       .unit_num               = direntry_unit_num,
-       .print_vi               = direntry_print_vi
+       .bytes_number = direntry_bytes_number,
+       .decrement_key = direntry_decrement_key,
+       .is_left_mergeable = direntry_is_left_mergeable,
+       .print_item = direntry_print_item,
+       .check_item = direntry_check_item,
+
+       .create_vi = direntry_create_vi,
+       .check_left = direntry_check_left,
+       .check_right = direntry_check_right,
+       .part_size = direntry_part_size,
+       .unit_num = direntry_unit_num,
+       .print_vi = direntry_print_vi
 };
 
-
 //////////////////////////////////////////////////////////////////////////////
 // Error catching functions to catch errors caused by incorrect item types.
 //
-static int errcatch_bytes_number (struct item_head * ih, int block_size)
+static int errcatch_bytes_number(struct item_head *ih, int block_size)
 {
-    reiserfs_warning (NULL, "green-16001: Invalid item type observed, run fsck ASAP");
-    return 0;
+       reiserfs_warning(NULL, "green-16001",
+                        "Invalid item type observed, run fsck ASAP");
+       return 0;
 }
 
-static void errcatch_decrement_key (struct cpu_key * key)
+static void errcatch_decrement_key(struct cpu_key *key)
 {
-    reiserfs_warning (NULL, "green-16002: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16002",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
-
-static int errcatch_is_left_mergeable (struct reiserfs_key * key, unsigned long bsize)
+static int errcatch_is_left_mergeable(struct reiserfs_key *key,
+                                     unsigned long bsize)
 {
-    reiserfs_warning (NULL, "green-16003: Invalid item type observed, run fsck ASAP");
-    return 0;
+       reiserfs_warning(NULL, "green-16003",
+                        "Invalid item type observed, run fsck ASAP");
+       return 0;
 }
 
-
-static void errcatch_print_item (struct item_head * ih, char * item)
+static void errcatch_print_item(struct item_head *ih, char *item)
 {
-    reiserfs_warning (NULL, "green-16004: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16004",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
-
-static void errcatch_check_item (struct item_head * ih, char * item)
+static void errcatch_check_item(struct item_head *ih, char *item)
 {
-    reiserfs_warning (NULL, "green-16005: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16005",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
-static int errcatch_create_vi (struct virtual_node * vn,
-                              struct virtual_item * vi, 
-                              int is_affected, 
-                              int insert_size)
+static int errcatch_create_vi(struct virtual_node *vn,
+                             struct virtual_item *vi,
+                             int is_affected, int insert_size)
 {
-    reiserfs_warning (NULL, "green-16006: Invalid item type observed, run fsck ASAP");
-    return 0;  // We might return -1 here as well, but it won't help as create_virtual_node() from where
-               // this operation is called from is of return type void.
+       reiserfs_warning(NULL, "green-16006",
+                        "Invalid item type observed, run fsck ASAP");
+       return 0;               // We might return -1 here as well, but it won't help as create_virtual_node() from where
+       // this operation is called from is of return type void.
 }
 
-static int errcatch_check_left (struct virtual_item * vi, int free,
-                               int start_skip, int end_skip)
+static int errcatch_check_left(struct virtual_item *vi, int free,
+                              int start_skip, int end_skip)
 {
-    reiserfs_warning (NULL, "green-16007: Invalid item type observed, run fsck ASAP");
-    return -1;
+       reiserfs_warning(NULL, "green-16007",
+                        "Invalid item type observed, run fsck ASAP");
+       return -1;
 }
 
-
-static int errcatch_check_right (struct virtual_item * vi, int free)
+static int errcatch_check_right(struct virtual_item *vi, int free)
 {
-    reiserfs_warning (NULL, "green-16008: Invalid item type observed, run fsck ASAP");
-    return -1;
+       reiserfs_warning(NULL, "green-16008",
+                        "Invalid item type observed, run fsck ASAP");
+       return -1;
 }
 
-static int errcatch_part_size (struct virtual_item * vi, int first, int count)
+static int errcatch_part_size(struct virtual_item *vi, int first, int count)
 {
-    reiserfs_warning (NULL, "green-16009: Invalid item type observed, run fsck ASAP");
-    return 0;
+       reiserfs_warning(NULL, "green-16009",
+                        "Invalid item type observed, run fsck ASAP");
+       return 0;
 }
 
-static int errcatch_unit_num (struct virtual_item * vi)
+static int errcatch_unit_num(struct virtual_item *vi)
 {
-    reiserfs_warning (NULL, "green-16010: Invalid item type observed, run fsck ASAP");
-    return 0;
+       reiserfs_warning(NULL, "green-16010",
+                        "Invalid item type observed, run fsck ASAP");
+       return 0;
 }
 
-static void errcatch_print_vi (struct virtual_item * vi)
+static void errcatch_print_vi(struct virtual_item *vi)
 {
-    reiserfs_warning (NULL, "green-16011: Invalid item type observed, run fsck ASAP");
+       reiserfs_warning(NULL, "green-16011",
+                        "Invalid item type observed, run fsck ASAP");
 }
 
 static struct item_operations errcatch_ops = {
-    errcatch_bytes_number,
-    errcatch_decrement_key,
-    errcatch_is_left_mergeable,
-    errcatch_print_item,
-    errcatch_check_item,
-
-    errcatch_create_vi,
-    errcatch_check_left,
-    errcatch_check_right,
-    errcatch_part_size,
-    errcatch_unit_num,
-    errcatch_print_vi
+       errcatch_bytes_number,
+       errcatch_decrement_key,
+       errcatch_is_left_mergeable,
+       errcatch_print_item,
+       errcatch_check_item,
+
+       errcatch_create_vi,
+       errcatch_check_left,
+       errcatch_check_right,
+       errcatch_part_size,
+       errcatch_unit_num,
+       errcatch_print_vi
 };
 
-
-
 //////////////////////////////////////////////////////////////////////////////
 //
 //
@@ -775,15 +746,11 @@ static struct item_operations errcatch_ops = {
 #error Item types must use disk-format assigned values.
 #endif
 
-struct item_operations * item_ops [TYPE_ANY + 1] = {
-  &stat_data_ops,
-  &indirect_ops,
-  &direct_ops,
-  &direntry_ops,
-  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-  &errcatch_ops                /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
+struct item_operations *item_ops[TYPE_ANY + 1] = {
+       &stat_data_ops,
+       &indirect_ops,
+       &direct_ops,
+       &direntry_ops,
+       NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+       &errcatch_ops           /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */
 };
-
-
-
-