reiserfs: run scripts/Lindent on reiserfs code

This was a pure indentation change, using:

	scripts/Lindent fs/reiserfs/*.c include/linux/reiserfs_*.h

to make reiserfs match the regular Linux indentation style.  As Jeff
Mahoney <jeffm@suse.com> writes:

 The ReiserFS code is a mix of a number of different coding styles, sometimes
 different even from line-to-line. Since the code has been relatively stable
 for quite some time and there are few outstanding patches to be applied, it
 is time to reformat the code to conform to the Linux style standard outlined
 in Documentation/CodingStyle.

 This patch contains the result of running scripts/Lindent against
 fs/reiserfs/*.c and include/linux/reiserfs_*.h. There are places where the
 code can be made to look better, but I'd rather keep those patches separate
 so that there isn't a subtle by-hand hand accident in the middle of a huge
 patch. To be clear: This patch is reformatting *only*.

 A number of patches may follow that continue to make the code more consistent
 with the Linux coding style.

 Hans wasn't particularly enthusiastic about these patches, but said he
 wouldn't really oppose them either.

Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 471 insertions, 506 deletions

diff --git a/fs/reiserfs/item_ops.c b/fs/reiserfs/item_ops.c
index e477aeba8c92..e237cd668e5b 100644
--- a/fs/reiserfs/item_ops.c
+++ b/fs/reiserfs/item_ops.c
@@ -14,760 +14,729 @@
 //////////////////////////////////////////////////////////////////////////////
 // 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) (-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;
+        if (start_skip || end_skip)
+                BUG();
+        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;
+        if (count)
+                BUG();
+        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, "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, "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;
 
-    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, "indirect_print_item: 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, "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: direntry_bytes_number: "
+                         "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;
+
+        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;
 
 #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: set_entry_sizes: (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, "free space %d, entry_count %d\n", 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++;
+        }
+        if (entries == dir_u->entry_count)
+                BUG();
 
+        /* "." 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, "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 +744,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) */
 };
-
-
-
-