cleanup: run indent with the Linux Kernel style across all code

Over the years, the reiserfs kernel code has been gradually cleaned up
to be more readable. This patch does the same to the progs code.

Signed-off-by: Jeff Mahoney <jeffm@suse.com>

51 files changed, 27954 insertions, 25783 deletions

diff --git a/debugreiserfs/corruption.c b/debugreiserfs/corruption.c
index c5ba996..8396d07 100644
--- a/debugreiserfs/corruption.c
+++ b/debugreiserfs/corruption.c
@@ -8,212 +8,217 @@
 
 extern struct reiserfs_fsstat g_stat_info;
 
-int  do_one_ih_corrupt (struct item_head * ih, unsigned int nr_bytes);
-int  do_one_ih_random_corrupt (struct item_head * ih);
+int do_one_ih_corrupt(struct item_head *ih, unsigned int nr_bytes);
+int do_one_ih_random_corrupt(struct item_head *ih);
 
-void do_one_corruption_in_one_block (reiserfs_filsys_t * fs, struct buffer_head * bh, char * corruption_command);
-int corrupt_block_header (struct block_head * blkh, unsigned int offset, unsigned int bytes );
-void do_one_block_random_corrupt (struct buffer_head * bh);
+void do_one_corruption_in_one_block(reiserfs_filsys_t *fs,
+				    struct buffer_head *bh,
+				    char *corruption_command);
+int corrupt_block_header(struct block_head *blkh, unsigned int offset,
+			 unsigned int bytes);
+void do_one_block_random_corrupt(struct buffer_head *bh);
 
-static int str2int (char * str, int * res)
+static int str2int(char *str, int *res)
 {
-    int val;
-    char * tmp;
+	int val;
+	char *tmp;
 
-    val = (int) strtol (str, &tmp, 0);
-    if (tmp == str)
+	val = (int)strtol(str, &tmp, 0);
+	if (tmp == str)
 		/* could not convert string into a number */
 		return 0;
-    *res = val;
-    return 1;
+	*res = val;
+	return 1;
 }
 
-static int get_rand (double min, double max) {
+static int get_rand(double min, double max)
+{
 
 	/* srand (time (0)); */
 	int ret;
 
-	ret =  (int)(min + (int)((max - min + 1) * rand() / (RAND_MAX + 1.0)));
+	ret = (int)(min + (int)((max - min + 1) * rand() / (RAND_MAX + 1.0)));
 	if ((ret < min) || (ret > max))
-		die ("get_rand failed: min %d, max %d, returned %d\n", (int)min, (int)max, ret);
+		die("get_rand failed: min %d, max %d, returned %d\n", (int)min,
+		    (int)max, ret);
 
 	return ret;
 }
 
-static void edit_journal_params (struct journal_params * jp)
+static void edit_journal_params(struct journal_params *jp)
 {
-    char * str;
-    size_t n;
-    int num;
-
-    printf ("Journal parameters:\n");
-    printf ("\tDevice: current: %x: new:", get_jp_journal_dev (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_dev (jp, num);
-
-    printf ("\tFirst block: current: %d: new:",
-			get_jp_journal_1st_block (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_1st_block (jp, num);
-
-    printf ("\tSize: current: %d: new:", get_jp_journal_size (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_size (jp, num);
-
-    printf ("\tMagic number: current: %d: new:", get_jp_journal_magic (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_magic (jp, num);
-
-    printf ("\tMax transaction size: current: %d: new:",
-			get_jp_journal_max_trans_len (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_max_trans_len (jp, num);
-
-    printf ("\tMax batch size: current: %d: new:",
-			get_jp_journal_max_batch (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_max_batch (jp, num);
-
-    printf ("\tMax commit age: current: %d: new:",
-			get_jp_journal_max_commit_age (jp));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_jp_journal_max_commit_age (jp, num);
+	char *str;
+	size_t n;
+	int num;
+
+	printf("Journal parameters:\n");
+	printf("\tDevice: current: %x: new:", get_jp_journal_dev(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_dev(jp, num);
+
+	printf("\tFirst block: current: %d: new:",
+	       get_jp_journal_1st_block(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_1st_block(jp, num);
+
+	printf("\tSize: current: %d: new:", get_jp_journal_size(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_size(jp, num);
+
+	printf("\tMagic number: current: %d: new:", get_jp_journal_magic(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_magic(jp, num);
+
+	printf("\tMax transaction size: current: %d: new:",
+	       get_jp_journal_max_trans_len(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_max_trans_len(jp, num);
+
+	printf("\tMax batch size: current: %d: new:",
+	       get_jp_journal_max_batch(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_max_batch(jp, num);
+
+	printf("\tMax commit age: current: %d: new:",
+	       get_jp_journal_max_commit_age(jp));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_jp_journal_max_commit_age(jp, num);
 }
 
 /* this allows to edit all super block fields */
-static void edit_super_block (reiserfs_filsys_t * fs)
+static void edit_super_block(reiserfs_filsys_t *fs)
 {
-    char * str;
-    size_t n;
-    int num;
-
-    str = 0;
-    n = 0;
-
-    /* bs_block_count */
-    printf ("\tBlock count: current: %u: new:",
-			get_sb_block_count (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_block_count (fs->fs_ondisk_sb, num);
-
-    
-    /* sb_free_blocks */
-    printf ("\tFree block count: current: %u: new:",
-			get_sb_free_blocks (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_free_blocks (fs->fs_ondisk_sb, num);
-
-    /* sb_root_block */
-    printf ("\tRoot block: current: %u: new:",
-			get_sb_root_block (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_root_block (fs->fs_ondisk_sb, num);
-
-    /* sb_journal */
-    edit_journal_params (sb_jp (fs->fs_ondisk_sb));
-    
-    /* sb_blocksize */
-    printf ("\tBlocksize: current: %u: new:",
-			get_sb_block_size (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_block_size (fs->fs_ondisk_sb, num);
-
-    /* sb_oid_maxsize */
-    printf ("\tMax objectid size: current: %u: new:",
-			get_sb_oid_maxsize (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_oid_maxsize (fs->fs_ondisk_sb, num);
-
-    /* sb_oid_cursize */
-    printf ("\tCur objectid size: current: %u: new:",
-			get_sb_oid_cursize (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_oid_cursize (fs->fs_ondisk_sb, num);
-	
-    /* sb_state */
-    printf ("\tUmount state: current: %u: new:",
-			get_sb_umount_state (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_umount_state (fs->fs_ondisk_sb, num);
-
-    /* char s_magic [10]; */
-    printf ("\tMagic: current: \"%s\": new:", fs->fs_ondisk_sb->s_v1.s_magic);
-    getline (&str, &n, stdin);
-    if (strcmp (str, "\n"))
-		strncpy (fs->fs_ondisk_sb->s_v1.s_magic, str, n > 10 ? 10 : n);
-    
-    /* __u16 sb_fsck_state; */
-    printf ("\tFilesystem state: current: %u: new:", get_sb_fs_state (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_fs_state (fs->fs_ondisk_sb, num);
-	
-    /* __u32 sb_hash_function_code; */
-    printf ("\tHash code: current: %u: new (tea %d, r5 %d, rupasov %d):",
-			get_sb_hash_code (fs->fs_ondisk_sb), TEA_HASH, R5_HASH, YURA_HASH);
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_hash_code (fs->fs_ondisk_sb, num);
-    
-    /* __u16 sb_tree_height; */
-    printf ("\tTree height: current: %u: new:",
-			get_sb_tree_height (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_tree_height (fs->fs_ondisk_sb, num);
-    
-    /* __u16 sb_bmap_nr; */
-    printf ("\tNumber of bitmaps: current: %u: new:",
-			get_sb_bmap_nr (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_bmap_nr (fs->fs_ondisk_sb, num);
-
-    /* __u16 sb_version; */
-    printf ("\tFilesystem format: current: %u: new:",
-			le16_to_cpu (fs->fs_ondisk_sb->s_v1.sb_version));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_version (fs->fs_ondisk_sb, num);
-
-    /* __u16 sb_reserved_for_journal; */
-    printf ("\tSpace reserved for journal: current: %u: new:",
-			get_sb_reserved_for_journal (fs->fs_ondisk_sb));
-    getline (&str, &n, stdin);
-    if (str2int (str, &num))
-		set_sb_reserved_for_journal (fs->fs_ondisk_sb, num);
-
-    print_block (stdout, fs, fs->fs_super_bh);
-    if (user_confirmed (stderr, "Is this ok ? [N/Yes]: ", "Yes\n")) {
-		mark_buffer_dirty (fs->fs_super_bh);
-		bwrite (fs->fs_super_bh);
-    }
+	char *str;
+	size_t n;
+	int num;
+
+	str = 0;
+	n = 0;
+
+	/* bs_block_count */
+	printf("\tBlock count: current: %u: new:",
+	       get_sb_block_count(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_block_count(fs->fs_ondisk_sb, num);
+
+	/* sb_free_blocks */
+	printf("\tFree block count: current: %u: new:",
+	       get_sb_free_blocks(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_free_blocks(fs->fs_ondisk_sb, num);
+
+	/* sb_root_block */
+	printf("\tRoot block: current: %u: new:",
+	       get_sb_root_block(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_root_block(fs->fs_ondisk_sb, num);
+
+	/* sb_journal */
+	edit_journal_params(sb_jp(fs->fs_ondisk_sb));
+
+	/* sb_blocksize */
+	printf("\tBlocksize: current: %u: new:",
+	       get_sb_block_size(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_block_size(fs->fs_ondisk_sb, num);
+
+	/* sb_oid_maxsize */
+	printf("\tMax objectid size: current: %u: new:",
+	       get_sb_oid_maxsize(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_oid_maxsize(fs->fs_ondisk_sb, num);
+
+	/* sb_oid_cursize */
+	printf("\tCur objectid size: current: %u: new:",
+	       get_sb_oid_cursize(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_oid_cursize(fs->fs_ondisk_sb, num);
+
+	/* sb_state */
+	printf("\tUmount state: current: %u: new:",
+	       get_sb_umount_state(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_umount_state(fs->fs_ondisk_sb, num);
+
+	/* char s_magic [10]; */
+	printf("\tMagic: current: \"%s\": new:",
+	       fs->fs_ondisk_sb->s_v1.s_magic);
+	getline(&str, &n, stdin);
+	if (strcmp(str, "\n"))
+		strncpy(fs->fs_ondisk_sb->s_v1.s_magic, str, n > 10 ? 10 : n);
+
+	/* __u16 sb_fsck_state; */
+	printf("\tFilesystem state: current: %u: new:",
+	       get_sb_fs_state(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_fs_state(fs->fs_ondisk_sb, num);
+
+	/* __u32 sb_hash_function_code; */
+	printf("\tHash code: current: %u: new (tea %d, r5 %d, rupasov %d):",
+	       get_sb_hash_code(fs->fs_ondisk_sb), TEA_HASH, R5_HASH,
+	       YURA_HASH);
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_hash_code(fs->fs_ondisk_sb, num);
+
+	/* __u16 sb_tree_height; */
+	printf("\tTree height: current: %u: new:",
+	       get_sb_tree_height(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_tree_height(fs->fs_ondisk_sb, num);
+
+	/* __u16 sb_bmap_nr; */
+	printf("\tNumber of bitmaps: current: %u: new:",
+	       get_sb_bmap_nr(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_bmap_nr(fs->fs_ondisk_sb, num);
+
+	/* __u16 sb_version; */
+	printf("\tFilesystem format: current: %u: new:",
+	       le16_to_cpu(fs->fs_ondisk_sb->s_v1.sb_version));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_version(fs->fs_ondisk_sb, num);
+
+	/* __u16 sb_reserved_for_journal; */
+	printf("\tSpace reserved for journal: current: %u: new:",
+	       get_sb_reserved_for_journal(fs->fs_ondisk_sb));
+	getline(&str, &n, stdin);
+	if (str2int(str, &num))
+		set_sb_reserved_for_journal(fs->fs_ondisk_sb, num);
+
+	print_block(stdout, fs, fs->fs_super_bh);
+	if (user_confirmed(stderr, "Is this ok ? [N/Yes]: ", "Yes\n")) {
+		mark_buffer_dirty(fs->fs_super_bh);
+		bwrite(fs->fs_super_bh);
+	}
 }
 
-
-static void corrupt_clobber_hash (char * name, struct item_head * ih, 
-								  struct reiserfs_de_head * deh)
+static void corrupt_clobber_hash(char *name, struct item_head *ih,
+				 struct reiserfs_de_head *deh)
 {
-    printf ("\tCorrupting deh_offset of entry \"%s\" of [%u %u]\n", name,
-			get_key_dirid (&ih->ih_key), get_key_objectid (&ih->ih_key));
-    set_deh_offset (deh, 700);
+	printf("\tCorrupting deh_offset of entry \"%s\" of [%u %u]\n", name,
+	       get_key_dirid(&ih->ih_key), get_key_objectid(&ih->ih_key));
+	set_deh_offset(deh, 700);
 }
 
-
 /* this reads list of desired corruptions from stdin and perform the
    corruptions. Format of that list:
    A hash_code
@@ -231,957 +236,1023 @@ static void corrupt_clobber_hash (char * name, struct item_head * ih,
                                start from offset
 */
 
-void do_corrupt_one_block (reiserfs_filsys_t * fs, char * fline)
+void do_corrupt_one_block(reiserfs_filsys_t *fs, char *fline)
 {
-    struct buffer_head * bh;
-    char * line = 0;
-    size_t n = 0;
-    unsigned long block;
-
-    block = certain_block (fs);
-    printf ("block = %lu\n", block);
-    if (block == fs->fs_super_bh->b_blocknr) {
-		edit_super_block (fs);
+	struct buffer_head *bh;
+	char *line = 0;
+	size_t n = 0;
+	unsigned long block;
+
+	block = certain_block(fs);
+	printf("block = %lu\n", block);
+	if (block == fs->fs_super_bh->b_blocknr) {
+		edit_super_block(fs);
 		return;
-    }
-
-    if (!fs->fs_bitmap2) {
-        struct buffer_head * bm_bh;
-        unsigned long bm_block;
-        
-        if (spread_bitmaps (fs))
-            bm_block = ( block / (fs->fs_blocksize * 8) ) ? 
-				(block / (fs->fs_blocksize * 8)) * (fs->fs_blocksize * 8) : 
-			fs->fs_super_bh->b_blocknr + 1;
-        else
-            bm_block = fs->fs_super_bh->b_blocknr + 1 + (block / (fs->fs_blocksize * 8));
-        
-        bm_bh = bread (fs->fs_dev, bm_block, fs->fs_blocksize);
-        if (bm_bh) {
-            if ( misc_test_bit((block % (fs->fs_blocksize * 8)), bm_bh->b_data) )
-                fprintf (stderr, "%lu is used in ondisk bitmap\n", block);
-            else
-				fprintf (stderr, "%lu is free in ondisk bitmap\n", block);
-	        
-            brelse (bm_bh);
-        }
-    } else {
-        if (reiserfs_bitmap_test_bit (fs->fs_bitmap2, block))
-			fprintf (stderr, "%lu is used in ondisk bitmap\n", block);
-        else
-			fprintf (stderr, "%lu is free in ondisk bitmap\n", block);
-    }
-    
-    /* READ block */
-    bh = bread (fs->fs_dev, block, fs->fs_blocksize);
-    if (!bh) {
-		printf ("corrupt_one_block: bread fialed\n");
+	}
+
+	if (!fs->fs_bitmap2) {
+		struct buffer_head *bm_bh;
+		unsigned long bm_block;
+
+		if (spread_bitmaps(fs))
+			bm_block = (block / (fs->fs_blocksize * 8)) ?
+			    (block / (fs->fs_blocksize * 8)) *
+			    (fs->fs_blocksize *
+			     8) : fs->fs_super_bh->b_blocknr + 1;
+		else
+			bm_block =
+			    fs->fs_super_bh->b_blocknr + 1 +
+			    (block / (fs->fs_blocksize * 8));
+
+		bm_bh = bread(fs->fs_dev, bm_block, fs->fs_blocksize);
+		if (bm_bh) {
+			if (misc_test_bit
+			    ((block % (fs->fs_blocksize * 8)), bm_bh->b_data))
+				fprintf(stderr,
+					"%lu is used in ondisk bitmap\n",
+					block);
+			else
+				fprintf(stderr,
+					"%lu is free in ondisk bitmap\n",
+					block);
+
+			brelse(bm_bh);
+		}
+	} else {
+		if (reiserfs_bitmap_test_bit(fs->fs_bitmap2, block))
+			fprintf(stderr, "%lu is used in ondisk bitmap\n",
+				block);
+		else
+			fprintf(stderr, "%lu is free in ondisk bitmap\n",
+				block);
+	}
+
+	/* READ block */
+	bh = bread(fs->fs_dev, block, fs->fs_blocksize);
+	if (!bh) {
+		printf("corrupt_one_block: bread fialed\n");
 		return;
-    }
+	}
 
-    if (who_is_this (bh->b_data, fs->fs_blocksize) != THE_LEAF) {
-		printf ("Can not corrupt not a leaf node\n");
-		brelse (bh);
+	if (who_is_this(bh->b_data, fs->fs_blocksize) != THE_LEAF) {
+		printf("Can not corrupt not a leaf node\n");
+		brelse(bh);
 		return;
-    }
+	}
 
-    printf ("Corrupting block %lu..\n", bh->b_blocknr);
+	printf("Corrupting block %lu..\n", bh->b_blocknr);
 
-    if (data(fs)->log_file_name) {
-		printf ("Log file : %s\n", data(fs)->log_file_name);
-    } else {
-		printf ("No Log file specified\n");
-    }
+	if (data(fs)->log_file_name) {
+		printf("Log file : %s\n", data(fs)->log_file_name);
+	} else {
+		printf("No Log file specified\n");
+	}
 
-    if (fline != NULL) {
-		do_one_corruption_in_one_block (fs, bh, fline);
+	if (fline != NULL) {
+		do_one_corruption_in_one_block(fs, bh, fline);
 		if ((data(fs)->log_file_name) && (data(fs)->log)) {
-			fprintf (data(fs)->log, "%lu\n", block);
-			fprintf (data(fs)->log, "%s\n", fline);
+			fprintf(data(fs)->log, "%lu\n", block);
+			fprintf(data(fs)->log, "%s\n", fline);
 		}
-    } else {
+	} else {
 		/* Get list of corruptions from stdin */
-        while (getline (&line, &n, stdin) != -1) {
-			if ( line [0] == '\n' ) {
-				free (line);
+		while (getline(&line, &n, stdin) != -1) {
+			if (line[0] == '\n') {
+				free(line);
 				line = 0;
 				n = 0;
 				break;
 			}
-			do_one_corruption_in_one_block (fs, bh, line);
+			do_one_corruption_in_one_block(fs, bh, line);
 			if ((data(fs)->log_file_name) && (data(fs)->log)) {
-				fprintf (data(fs)->log, "%lu\n", block);
-				fprintf (data(fs)->log, "%s\n", line);
+				fprintf(data(fs)->log, "%lu\n", block);
+				fprintf(data(fs)->log, "%s\n", line);
 			}
-			
-			free (line);
+
+			free(line);
 			line = 0;
 			n = 0;
 		}
-    }
+	}
 
-    printf ("Done\n");
-    bwrite(bh);
-    brelse (bh);
-    return;
+	printf("Done\n");
+	bwrite(bh);
+	brelse(bh);
+	return;
 }
 
-void do_one_corruption_in_one_block (reiserfs_filsys_t * fs,
-									 struct buffer_head * bh,
-									 char * corruption_command)
+void do_one_corruption_in_one_block(reiserfs_filsys_t *fs,
+				    struct buffer_head *bh,
+				    char *corruption_command)
 {
-    int i, j;
-    struct item_head * ih;
-    int item_num;
-    int item_numbers;
-    int bytes_to_corrupt;
-    char code, name [100];
-    __u32 objectid, new_objectid;
-    int value;
-    int hash_code;
-    unsigned int pos_in_item;
-    int type, format;
-
-    printf ("corruption_command  : %s", corruption_command);
-
-    switch (corruption_command [0]) {
+	int i, j;
+	struct item_head *ih;
+	int item_num;
+	int item_numbers;
+	int bytes_to_corrupt;
+	char code, name[100];
+	__u32 objectid, new_objectid;
+	int value;
+	int hash_code;
+	unsigned int pos_in_item;
+	int type, format;
+
+	printf("corruption_command  : %s", corruption_command);
+
+	switch (corruption_command[0]) {
 	case '#':
 	case '\n':
 		break;
-		
+
 	case '?':
-		printf ("A hash_code     - reset hAsh code in super block\n"
-				"T item_num type (0, 1, 2, 3) format (0, 1)\n"
-				"C name objectid - Cut entry 'name' from directory item with 'objectid'\n"
-				"H name objectid - clobber Hash of entry 'name' of directory 'objectid'\n"
-				"I item_num pos_in_item  make pos_in_tem-th slot of Indirect item to point out of device\n"
-				"O item_num      - destroy item Order - make 'item_num'-th to have key bigger than 'item_num' + 1-th item\n"
-				"D item_num      - Delete item_num-th item\n"
-				"S item_num value - change file Size (item_num-th item must be stat data)\n"
-				"F item_num value - change sd_First_direct_byte of stat data\n"
-				"J item_num objectid - set 'obJectid' of 'item_num'-th item\n"
-				"E name objectid objectid - set deh_objectid of an entry to objectid\n"
-				"N item_numbers bytes_to_corrupt - corrupt bytes_to_corrupt in number of bytes in item_numbers items\n"
-				"B offset bytes_to_corrupt - corrupt bytes_to_corrupt in block_header, start corruption from offset\n");
-		
-	    break;
-		
+		printf("A hash_code     - reset hAsh code in super block\n"
+		       "T item_num type (0, 1, 2, 3) format (0, 1)\n"
+		       "C name objectid - Cut entry 'name' from directory item with 'objectid'\n"
+		       "H name objectid - clobber Hash of entry 'name' of directory 'objectid'\n"
+		       "I item_num pos_in_item  make pos_in_tem-th slot of Indirect item to point out of device\n"
+		       "O item_num      - destroy item Order - make 'item_num'-th to have key bigger than 'item_num' + 1-th item\n"
+		       "D item_num      - Delete item_num-th item\n"
+		       "S item_num value - change file Size (item_num-th item must be stat data)\n"
+		       "F item_num value - change sd_First_direct_byte of stat data\n"
+		       "J item_num objectid - set 'obJectid' of 'item_num'-th item\n"
+		       "E name objectid objectid - set deh_objectid of an entry to objectid\n"
+		       "N item_numbers bytes_to_corrupt - corrupt bytes_to_corrupt in number of bytes in item_numbers items\n"
+		       "B offset bytes_to_corrupt - corrupt bytes_to_corrupt in block_header, start corruption from offset\n");
+
+		break;
+
 	case 'P':
-		print_block (stderr, fs, bh, 3, -1, -1);
+		print_block(stderr, fs, bh, 3, -1, -1);
 		break;
-	    
+
 	case 'A':
 		/* corrupt hash record in super block */
-		if (sscanf (corruption_command, "%c %d\n", &code, &hash_code) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		if (sscanf(corruption_command, "%c %d\n", &code, &hash_code) !=
+		    2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		reiserfs_warning (stderr, "Changing %s to %s\n",
-						  code2name (get_sb_hash_code (fs->fs_ondisk_sb)),
-						  code2name (hash_code));
-		set_sb_hash_code (fs->fs_ondisk_sb, hash_code);
+		reiserfs_warning(stderr, "Changing %s to %s\n",
+				 code2name(get_sb_hash_code(fs->fs_ondisk_sb)),
+				 code2name(hash_code));
+		set_sb_hash_code(fs->fs_ondisk_sb, hash_code);
 		break;
-	    
-	case 'C': /* cut entry */
-	case 'H': /* make hash wrong */
-		if (sscanf (corruption_command, "%c %s %u\n", &code, name, &objectid) != 3) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+
+	case 'C':		/* cut entry */
+	case 'H':		/* make hash wrong */
+		if (sscanf
+		    (corruption_command, "%c %s %u\n", &code, name,
+		     &objectid) != 3) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
-	  }
-		
-		ih = B_N_PITEM_HEAD (bh, 0);
-		for (i = 0; i < get_blkh_nr_items (B_BLK_HEAD (bh)); i ++, ih ++) {
-			struct reiserfs_de_head * deh;
+		}
+
+		ih = B_N_PITEM_HEAD(bh, 0);
+		for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
+			struct reiserfs_de_head *deh;
 			/* look for property objectid */
-			if (get_key_objectid (&ih->ih_key) != objectid || !is_direntry_ih (ih))
+			if (get_key_objectid(&ih->ih_key) != objectid
+			    || !is_direntry_ih(ih))
 				continue;
 
-			deh = B_I_DEH (bh, ih);
-			
-			for (j = 0; j < get_ih_entry_count (ih); j ++, deh ++) {
+			deh = B_I_DEH(bh, ih);
+
+			for (j = 0; j < get_ih_entry_count(ih); j++, deh++) {
 				/* look for proper entry */
-				if (name_in_entry_length (ih, deh, j) == (int)strlen (name) &&
-					!strncmp (name, name_in_entry (deh, j), strlen (name)))
+				if (name_in_entry_length(ih, deh, j) ==
+				    (int)strlen(name)
+				    && !strncmp(name, name_in_entry(deh, j),
+						strlen(name)))
 					break;
 			}
-			if (j == get_ih_entry_count (ih)) {
-				printf ("Can't find entry %s\n", name);
-				exit (1);
+			if (j == get_ih_entry_count(ih)) {
+				printf("Can't find entry %s\n", name);
+				exit(1);
 			}
 			switch (code) {
-			case 'H' : /* clobber hash */
-				corrupt_clobber_hash (name, ih, deh);
+			case 'H':	/* clobber hash */
+				corrupt_clobber_hash(name, ih, deh);
 				break;
 
-			case 'C' : /* cut entry */
-				cut_entry (fs, bh, i, j, 1);
+			case 'C':	/* cut entry */
+				cut_entry(fs, bh, i, j, 1);
 				break;
 
 			default:
-				printf ("Unknown command found\n");
+				printf("Unknown command found\n");
 			}
 		}
 
-		if (!B_IS_IN_TREE (bh)) {
-			printf ("NOTE: block is deleted from the tree\n");
-			exit (0);
+		if (!B_IS_IN_TREE(bh)) {
+			printf("NOTE: block is deleted from the tree\n");
+			exit(0);
 		}
 		break;
-		
-	case 'E': /* set objectid : used to simulate objectid sharing problem */
-		if (sscanf (corruption_command, "%c %s %u %d\n", &code, name, &objectid, &new_objectid) != 4) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+
+	case 'E':		/* set objectid : used to simulate objectid sharing problem */
+		if (sscanf
+		    (corruption_command, "%c %s %u %d\n", &code, name,
+		     &objectid, &new_objectid) != 4) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		ih = B_N_PITEM_HEAD (bh, 0);
-		for (i = 0; i < get_blkh_nr_items (B_BLK_HEAD (bh)); i ++, ih ++) {
-			struct reiserfs_de_head * deh;
+		ih = B_N_PITEM_HEAD(bh, 0);
+		for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
+			struct reiserfs_de_head *deh;
 			/* look for property objectid */
-			if (get_key_objectid (&ih->ih_key) != objectid || !is_direntry_ih (ih))
+			if (get_key_objectid(&ih->ih_key) != objectid
+			    || !is_direntry_ih(ih))
 				continue;
-			deh = B_I_DEH (bh, ih);
-			set_deh_objectid (deh, new_objectid);
+			deh = B_I_DEH(bh, ih);
+			set_deh_objectid(deh, new_objectid);
 			break;
-		}  
+		}
 		break;
-		
-	case 'T': /* set type of item */
-	    if (sscanf (corruption_command, "%c %d %d %d\n", &code, &item_num, &type, &format) != 4) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+
+	case 'T':		/* set type of item */
+		if (sscanf
+		    (corruption_command, "%c %d %d %d\n", &code, &item_num,
+		     &type, &format) != 4) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
-	    }
-	    if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-			printf ("Wrong format \'%c\', wrong item_num \n", corruption_command [0]);
+		}
+		if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+			printf("Wrong format \'%c\', wrong item_num \n",
+			       corruption_command[0]);
 			return;
-	    }
-		
-	    ih = B_N_PITEM_HEAD (bh, item_num);
-	    set_ih_key_format (ih, format);
-	    set_type (format, &ih->ih_key, type);
-		
-	    break;
-		
-	case 'J': /* set objectid : used to simulate objectid sharing problem */
-	    if (sscanf (corruption_command, "%c %d %d\n", &code, &item_num, &objectid) != 3) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		}
+
+		ih = B_N_PITEM_HEAD(bh, item_num);
+		set_ih_key_format(ih, format);
+		set_type(format, &ih->ih_key, type);
+
+		break;
+
+	case 'J':		/* set objectid : used to simulate objectid sharing problem */
+		if (sscanf
+		    (corruption_command, "%c %d %d\n", &code, &item_num,
+		     &objectid) != 3) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
-	    }
-	    if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-			printf ("Wrong format \'%c\', wrong item_num \n", corruption_command [0]);
+		}
+		if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+			printf("Wrong format \'%c\', wrong item_num \n",
+			       corruption_command[0]);
 			return;
-	    }
-	    ih = B_N_PITEM_HEAD (bh, item_num);
-	    set_key_objectid (&ih->ih_key, objectid);
-	    break;
-		
-	case 'I': /* break unformatted node pointer */
-	    if (sscanf (corruption_command, "%c %d %u\n", &code, &item_num, &pos_in_item) != 3) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		}
+		ih = B_N_PITEM_HEAD(bh, item_num);
+		set_key_objectid(&ih->ih_key, objectid);
+		break;
+
+	case 'I':		/* break unformatted node pointer */
+		if (sscanf
+		    (corruption_command, "%c %d %u\n", &code, &item_num,
+		     &pos_in_item) != 3) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
-	    }
-	    if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-			printf ("Wrong format \'%c\', wrong item_num \n", corruption_command [0]);
+		}
+		if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+			printf("Wrong format \'%c\', wrong item_num \n",
+			       corruption_command[0]);
 			return;
-	    }
-	    ih = B_N_PITEM_HEAD (bh, item_num);
-	    if (!is_indirect_ih (ih) || pos_in_item >= I_UNFM_NUM (ih)) {
-	        reiserfs_warning (stderr, "Not an indirect item or there is "
-							  "not so many unfm ptrs in it\n");
+		}
+		ih = B_N_PITEM_HEAD(bh, item_num);
+		if (!is_indirect_ih(ih) || pos_in_item >= I_UNFM_NUM(ih)) {
+			reiserfs_warning(stderr,
+					 "Not an indirect item or there is "
+					 "not so many unfm ptrs in it\n");
 			return;
-	    }
-	    d32_put((__u32 *)B_I_PITEM (bh, ih), pos_in_item, 
-		    get_sb_block_count (fs->fs_ondisk_sb) + 100);
-	    break;
-	    
-	case 'D': /* delete item */
-	    if (sscanf (corruption_command, "%c %d\n", &code, &item_num) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		}
+		d32_put((__u32 *) B_I_PITEM(bh, ih), pos_in_item,
+			get_sb_block_count(fs->fs_ondisk_sb) + 100);
+		break;
+
+	case 'D':		/* delete item */
+		if (sscanf(corruption_command, "%c %d\n", &code, &item_num) !=
+		    2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
-	    }
-	    if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-			printf ("Wrong format \'%c\', wrong item_num \n", corruption_command [0]);
+		}
+		if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+			printf("Wrong format \'%c\', wrong item_num \n",
+			       corruption_command[0]);
 			return;
-	    }
-	    delete_item (fs, bh, item_num);
-	    break;
-		
-	case 'O': /* make item out of order */
+		}
+		delete_item(fs, bh, item_num);
+		break;
+
+	case 'O':		/* make item out of order */
 		{
 			struct reiserfs_key *key;
-			if (sscanf (corruption_command, "%c %d\n", &code, &item_num) != 2) {
-				printf ("Wrong format \'%c\'\n", corruption_command [0]);
+			if (sscanf
+			    (corruption_command, "%c %d\n", &code,
+			     &item_num) != 2) {
+				printf("Wrong format \'%c\'\n",
+				       corruption_command[0]);
 				return;
 			}
-			if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-				printf ("Wrong format \'%c\', wrong item_num \n", corruption_command [0]);
+			if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+				printf("Wrong format \'%c\', wrong item_num \n",
+				       corruption_command[0]);
 				return;
 			}
-			
+
 			/* destroy item order */
-			
-			if (item_num == get_blkh_nr_items (B_BLK_HEAD (bh)) - 1) {
-				printf ("can not destroy order\n");
+
+			if (item_num == get_blkh_nr_items(B_BLK_HEAD(bh)) - 1) {
+				printf("can not destroy order\n");
 				return;
 			}
-			ih = B_N_PITEM_HEAD (bh, item_num);
+			ih = B_N_PITEM_HEAD(bh, item_num);
 			key = &(ih + 1)->ih_key;
-			set_key_dirid (&ih->ih_key, get_key_dirid (key) + 1);
-			
+			set_key_dirid(&ih->ih_key, get_key_dirid(key) + 1);
+
 			break;
-		}  
-	case 'S': /* corrupt st_size */
+		}
+	case 'S':		/* corrupt st_size */
 		{
 			/* fixme: old stat data only */
-			struct stat_data_v1 * sd;
-			
-			if (sscanf (corruption_command, "%c %d %d\n", &code, &item_num, &value) != 3) {
-				printf ("Wrong format \'%c\'\n", corruption_command [0]);
+			struct stat_data_v1 *sd;
+
+			if (sscanf
+			    (corruption_command, "%c %d %d\n", &code, &item_num,
+			     &value) != 3) {
+				printf("Wrong format \'%c\'\n",
+				       corruption_command[0]);
 				return;
 			}
-			if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-				printf ("Wrong format \'%c\', wrong item_num \n", corruption_command [0]);
+			if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+				printf("Wrong format \'%c\', wrong item_num \n",
+				       corruption_command[0]);
 				return;
 			}
-			ih = B_N_PITEM_HEAD (bh, item_num);
-			
-			sd = (struct stat_data_v1 *)B_I_PITEM (bh, ih); 
-			reiserfs_warning (stderr, "Changing sd_size of %k from %d to %d\n",
-							  &ih->ih_key, sd_v1_size(sd), value);
-			set_sd_v1_size( sd, value );
+			ih = B_N_PITEM_HEAD(bh, item_num);
+
+			sd = (struct stat_data_v1 *)B_I_PITEM(bh, ih);
+			reiserfs_warning(stderr,
+					 "Changing sd_size of %k from %d to %d\n",
+					 &ih->ih_key, sd_v1_size(sd), value);
+			set_sd_v1_size(sd, value);
 			break;
 		}
-		
-    case 'F': /*         st_first_direct_byte */
+
+	case 'F':		/*         st_first_direct_byte */
 		{
 			/* fixme: old stat data only */
-			struct stat_data_v1 * sd;
-			
-			if (sscanf (corruption_command, "%c %d %d\n", &code, &item_num, &value) != 3) {
-				printf ("Wrong format \'%c\'\n", corruption_command [0]);
+			struct stat_data_v1 *sd;
+
+			if (sscanf
+			    (corruption_command, "%c %d %d\n", &code, &item_num,
+			     &value) != 3) {
+				printf("Wrong format \'%c\'\n",
+				       corruption_command[0]);
 				return;
 			}
-			if (item_num > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-				printf ("Wrong format \'%c\', wrong item_num \n",
-						corruption_command [0]);
+			if (item_num > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+				printf("Wrong format \'%c\', wrong item_num \n",
+				       corruption_command[0]);
 				return;
 			}
-			ih = B_N_PITEM_HEAD (bh, item_num);
-			
-			sd = (struct stat_data_v1 *)B_I_PITEM (bh, ih); 
-			reiserfs_warning (stderr, "Changing sd_first_direct_byte of %k from %d to %d\n",
-							  &ih->ih_key, sd_v1_first_direct_byte(sd), value);		
-			set_sd_v1_first_direct_byte( sd, value );
+			ih = B_N_PITEM_HEAD(bh, item_num);
+
+			sd = (struct stat_data_v1 *)B_I_PITEM(bh, ih);
+			reiserfs_warning(stderr,
+					 "Changing sd_first_direct_byte of %k from %d to %d\n",
+					 &ih->ih_key,
+					 sd_v1_first_direct_byte(sd), value);
+			set_sd_v1_first_direct_byte(sd, value);
 			break;
 		}
-		
-	case 'N': /* corrupt N number of items */
-	    if (sscanf (corruption_command, "%c %d %d\n",
-					&code, &item_numbers, &bytes_to_corrupt) != 3) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+
+	case 'N':		/* corrupt N number of items */
+		if (sscanf(corruption_command, "%c %d %d\n",
+			   &code, &item_numbers, &bytes_to_corrupt) != 3) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
-	    }
-		
-	    if (item_numbers > get_blkh_nr_items (B_BLK_HEAD (bh))) {
-			printf ("Wrong item_numbers %d expected not more then %d\n",
-					item_numbers,
-					get_blkh_nr_items (B_BLK_HEAD (bh)));
+		}
+
+		if (item_numbers > get_blkh_nr_items(B_BLK_HEAD(bh))) {
+			printf
+			    ("Wrong item_numbers %d expected not more then %d\n",
+			     item_numbers, get_blkh_nr_items(B_BLK_HEAD(bh)));
 			return;
-	    }
-		
-	    for (i = 0; i < item_numbers; i++) { 
-			printf ("Do corruptions :  %d item header; \n", i );
-			ih = B_N_PITEM_HEAD (bh, i);
-			do_one_ih_corrupt (ih, bytes_to_corrupt);
-			printf ("Ok\n");
-	    }
-		
-	    break;
-	case 'B' :
+		}
+
+		for (i = 0; i < item_numbers; i++) {
+			printf("Do corruptions :  %d item header; \n", i);
+			ih = B_N_PITEM_HEAD(bh, i);
+			do_one_ih_corrupt(ih, bytes_to_corrupt);
+			printf("Ok\n");
+		}
+
+		break;
+	case 'B':
 		{
-			struct block_head * blkh;
+			struct block_head *blkh;
 			unsigned int offset;
-			
-			if (sscanf (corruption_command, "%c %d %d\n",
-						&code, &offset, &bytes_to_corrupt) != 3) {
-				printf ("Wrong format \'%c\'\n", corruption_command [0]);
+
+			if (sscanf(corruption_command, "%c %d %d\n",
+				   &code, &offset, &bytes_to_corrupt) != 3) {
+				printf("Wrong format \'%c\'\n",
+				       corruption_command[0]);
 				return;
 			}
-			
-			blkh = B_BLK_HEAD (bh);
-			corrupt_block_header (blkh, offset, bytes_to_corrupt);
+
+			blkh = B_BLK_HEAD(bh);
+			corrupt_block_header(blkh, offset, bytes_to_corrupt);
 			break;
 		}
-		
+
 	default:
-		printf ("Unknown command found\n");
-	} 
-    mark_buffer_dirty (bh);
-    return;
+		printf("Unknown command found\n");
+	}
+	mark_buffer_dirty(bh);
+	return;
 }
 
 /* corrupt first nr_bytes bytes in item header */
-int do_one_ih_corrupt (struct item_head * ih, unsigned int nr_bytes)
+int do_one_ih_corrupt(struct item_head *ih, unsigned int nr_bytes)
 {
 	if (nr_bytes > IH_SIZE) {
-		printf ("Bad byte number %u expected not more then %lu\n", nr_bytes,
-				(unsigned long)IH_SIZE);
-		exit (1);
+		printf("Bad byte number %u expected not more then %lu\n",
+		       nr_bytes, (unsigned long)IH_SIZE);
+		exit(1);
 	}
 
-	if (memset ((char *)ih, 0, nr_bytes) != ih ) {
-		perror ("do_one_ih_corrupt: memset failed");
-		exit (1);
+	if (memset((char *)ih, 0, nr_bytes) != ih) {
+		perror("do_one_ih_corrupt: memset failed");
+		exit(1);
 	}
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "\tfirst %u bytes corrupted\n", nr_bytes);
+		fprintf(data(fs)->log, "\tfirst %u bytes corrupted\n",
+			nr_bytes);
 
-	printf ("\tfirst %u bytes corrupted\n", nr_bytes);
+	printf("\tfirst %u bytes corrupted\n", nr_bytes);
 	return 0;
 }
 
 /* item header random corruption */
-int do_one_ih_random_corrupt (struct item_head * ih)
+int do_one_ih_random_corrupt(struct item_head *ih)
 {
 	unsigned int i;
 	unsigned int from;
 	unsigned int count;
-		
-	from = get_rand (0,  IH_SIZE - 1);
-	count = get_rand (1, IH_SIZE);
+
+	from = get_rand(0, IH_SIZE - 1);
+	count = get_rand(1, IH_SIZE);
 
 	if (from + count > IH_SIZE)
 		count = IH_SIZE - from;
 
-	for (i = from; i < from + count; i ++)
+	for (i = from; i < from + count; i++)
 		((char *)ih)[i] = get_rand(0, 255);
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "\tfrom %u ( %u )\n", from, count);
+		fprintf(data(fs)->log, "\tfrom %u ( %u )\n", from, count);
 
-	printf ("\tfrom %u ( %u )\n",  from, count);
+	printf("\tfrom %u ( %u )\n", from, count);
 	return 0;
 }
 
 /* Corrupt n bytes in block header */
-int corrupt_block_header (struct block_head * blkh, unsigned int offset, 
-			  unsigned int bytes) 
+int corrupt_block_header(struct block_head *blkh, unsigned int offset,
+			 unsigned int bytes)
 {
 	if ((offset + bytes) > BLKH_SIZE) {
-		printf ("Bad offset number: %u or bad bytes number: %u, the suumary "
-			"value expected not more then %lu\n", offset, bytes, 
-			(unsigned long)BLKH_SIZE);
-		exit (1);
-	} 
-
-	if (memset ((char *)blkh, 0, bytes) != blkh ) {
-		perror ("corrupt_block_head: memset failed");
-		exit (1);   
+		printf
+		    ("Bad offset number: %u or bad bytes number: %u, the suumary "
+		     "value expected not more then %lu\n", offset, bytes,
+		     (unsigned long)BLKH_SIZE);
+		exit(1);
 	}
 
-	printf ("offset : %u, corrupt %u bytes\n", offset, bytes);
+	if (memset((char *)blkh, 0, bytes) != blkh) {
+		perror("corrupt_block_head: memset failed");
+		exit(1);
+	}
+
+	printf("offset : %u, corrupt %u bytes\n", offset, bytes);
 	return 0;
 }
 
 /* corrupt random number of bytes within block header started from random
    offset */
-void do_one_blkh_random_corrupt (struct buffer_head * bh)
+void do_one_blkh_random_corrupt(struct buffer_head *bh)
 {
-	struct block_head * blkh;
+	struct block_head *blkh;
 	unsigned int from;
 	unsigned int count;
 	unsigned int i;
 
-	from = get_rand (0, BLKH_SIZE - 1);
-	count = get_rand (1, BLKH_SIZE);
+	from = get_rand(0, BLKH_SIZE - 1);
+	count = get_rand(1, BLKH_SIZE);
 
-	blkh = B_BLK_HEAD (bh);
+	blkh = B_BLK_HEAD(bh);
 
 	if (from + count > BLKH_SIZE)
 		count = BLKH_SIZE - from;
 
-	for (i = from; i < from + count; i ++)
+	for (i = from; i < from + count; i++)
 		((char *)blkh)[i] = get_rand(0, 255);
 
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "# : %lu #    ", bh->b_blocknr);
-		fprintf (data(fs)->log, "from %u (%u)\n", from, count);
+		fprintf(data(fs)->log, "# : %lu #    ", bh->b_blocknr);
+		fprintf(data(fs)->log, "from %u (%u)\n", from, count);
 	}
 
-	printf ("# : %lu #   ", bh->b_blocknr);
-	printf ("from %u (%u)\n", from, count);
+	printf("# : %lu #   ", bh->b_blocknr);
+	printf("from %u (%u)\n", from, count);
 
 }
 
-void do_leaves_corruption (reiserfs_filsys_t * fs,
-						   unsigned long nr_leaves_cr) 
-						   
+void do_leaves_corruption(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr)
 {
-	struct buffer_head * bh;
-    unsigned long nr_leaves = 0;
+	struct buffer_head *bh;
+	unsigned long nr_leaves = 0;
 	unsigned int i, should_be_corrupted;
 
-	srand (time (0));
-	printf ("%lu leaves will be corrupted\n", nr_leaves_cr);
+	srand(time(0));
+	printf("%lu leaves will be corrupted\n", nr_leaves_cr);
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "Block headers in %lu leaves will be corrupted\n", nr_leaves_cr);
+		fprintf(data(fs)->log,
+			"Block headers in %lu leaves will be corrupted\n",
+			nr_leaves_cr);
 	}
 
-    if (reiserfs_open_ondisk_bitmap (fs) < 0)
-		reiserfs_exit (1, "Could not open ondisk bitmap");
+	if (reiserfs_open_ondisk_bitmap(fs) < 0)
+		reiserfs_exit(1, "Could not open ondisk bitmap");
 
-    for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
-			 nr_leaves < nr_leaves_cr; i ++) {
+	for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) &&
+	     nr_leaves < nr_leaves_cr; i++) {
 
-		if (!reiserfs_bitmap_test_bit (fs->fs_bitmap2, i))
+		if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i))
 			continue;
 
-		bh = bread (fs->fs_dev, i, fs->fs_blocksize);
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
 		if (!bh) {
-			reiserfs_warning (stderr, "could not read block %lu\n", i);
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 i);
 			continue;
 		}
 
-		if (who_is_this (bh->b_data, bh->b_size) != THE_LEAF) {
-			brelse (bh);	
+		if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) {
+			brelse(bh);
 			continue;
 		}
 
-		if ((!is_leaf_node (bh)) || (block_of_journal (fs, i))) {
-			brelse (bh);	
+		if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) {
+			brelse(bh);
 			continue;
 		}
 
-		should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
-		if (should_be_corrupted == 0)
-		{
-			brelse (bh);
+		should_be_corrupted =
+		    (unsigned int)get_rand((double)0, (double)1);
+		if (should_be_corrupted == 0) {
+			brelse(bh);
 			continue;
 		}
-		do_one_blkh_random_corrupt (bh);
+		do_one_blkh_random_corrupt(bh);
 		/* do_one_block_random_corrupt (bh); */
-		mark_buffer_dirty (bh);
+		mark_buffer_dirty(bh);
 		bwrite(bh);
-		brelse (bh);
-		nr_leaves ++;
+		brelse(bh);
+		nr_leaves++;
 	}
 
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log,
-				 "%lu leaves WERE corrupted\n",
-				 nr_leaves);
+		fprintf(data(fs)->log,
+			"%lu leaves WERE corrupted\n", nr_leaves);
 	}
 
-	printf ("%lu leaves WERE corrupted\n", nr_leaves);
+	printf("%lu leaves WERE corrupted\n", nr_leaves);
 
-	reiserfs_close_ondisk_bitmap (fs);
+	reiserfs_close_ondisk_bitmap(fs);
 	return;
 }
 
-void do_one_block_random_corrupt (struct buffer_head * bh) 
+void do_one_block_random_corrupt(struct buffer_head *bh)
 {
-	unsigned int from = get_rand (0, bh->b_size - 1);
-	unsigned int count = get_rand (1, bh->b_size);
+	unsigned int from = get_rand(0, bh->b_size - 1);
+	unsigned int count = get_rand(1, bh->b_size);
 	unsigned int i;
 
 	if (from + count > bh->b_size)
 		count = bh->b_size - from;
 
-	for (i = from; i < from + count; i ++)
+	for (i = from; i < from + count; i++)
 		((char *)bh->b_data)[i] = get_rand(0, 255);
 
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "# block %lu: ", bh->b_blocknr);
-		fprintf (data(fs)->log, "from %u ( %u )\n", from, count);
+		fprintf(data(fs)->log, "# block %lu: ", bh->b_blocknr);
+		fprintf(data(fs)->log, "from %u ( %u )\n", from, count);
 	}
 
-	printf ("# block %lu: ", bh->b_blocknr);
-	printf ("from %u ( %u )\n", from, count);
-	
+	printf("# block %lu: ", bh->b_blocknr);
+	printf("from %u ( %u )\n", from, count);
+
 }
 
-void do_bitmap_corruption (reiserfs_filsys_t * fs)
+void do_bitmap_corruption(reiserfs_filsys_t *fs)
 {
 
 	unsigned long first = fs->fs_super_bh->b_blocknr + 1;
 	unsigned long nr_bitmap_to_corrupt;
 	unsigned long block;
-	struct buffer_head * bh;
+	struct buffer_head *bh;
 	unsigned int i;
 
-	nr_bitmap_to_corrupt = (unsigned long)get_rand (1, reiserfs_fs_bmap_nr(fs) - 1);
+	nr_bitmap_to_corrupt =
+	    (unsigned long)get_rand(1, reiserfs_fs_bmap_nr(fs) - 1);
 
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "%lu bitmaps will be corrupted\n", nr_bitmap_to_corrupt);
+		fprintf(data(fs)->log, "%lu bitmaps will be corrupted\n",
+			nr_bitmap_to_corrupt);
 	}
-	printf ("%lu bitmaps will be corrupted\n", nr_bitmap_to_corrupt);
-	for (i = 0; i < nr_bitmap_to_corrupt; i ++ )
-		{
-			block = ( i == 0 ) ? first 
-				: fs->fs_blocksize * 8 * i;
-			bh = bread (fs->fs_dev, block, fs->fs_blocksize);
-
-			if (!bh) {
-				printf ("do_bitmap_corruption: bread failed for bitmap %d: %lu\n",
-						i, block); 
-				exit (1);
-			}
-			do_one_block_random_corrupt (bh);
-			mark_buffer_dirty (bh);
-			bwrite(bh);
-			brelse (bh);
+	printf("%lu bitmaps will be corrupted\n", nr_bitmap_to_corrupt);
+	for (i = 0; i < nr_bitmap_to_corrupt; i++) {
+		block = (i == 0) ? first : fs->fs_blocksize * 8 * i;
+		bh = bread(fs->fs_dev, block, fs->fs_blocksize);
+
+		if (!bh) {
+			printf
+			    ("do_bitmap_corruption: bread failed for bitmap %d: %lu\n",
+			     i, block);
+			exit(1);
 		}
+		do_one_block_random_corrupt(bh);
+		mark_buffer_dirty(bh);
+		bwrite(bh);
+		brelse(bh);
+	}
 
-} 
+}
 
 /* corrupt the random number of item headers in random number of leaves */
-void do_ih_random_corrupt (reiserfs_filsys_t * fs,
-							  unsigned long nr_leaves_cr) 
+void do_ih_random_corrupt(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr)
 {
 	unsigned int nr_ih_cr;
 	unsigned int i, j;
-	struct buffer_head * bh;
-	struct item_head * ih;
+	struct buffer_head *bh;
+	struct item_head *ih;
 	unsigned long nr_leaves = 0;
 	unsigned int should_be_corrupted = 0;
 
-	srand (time (0));
+	srand(time(0));
 
-	printf ("item headers in %lu leaves will be corrupted\n", nr_leaves_cr);
+	printf("item headers in %lu leaves will be corrupted\n", nr_leaves_cr);
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "item headers in %lu leaves will be corrupted\n", nr_leaves_cr);
+		fprintf(data(fs)->log,
+			"item headers in %lu leaves will be corrupted\n",
+			nr_leaves_cr);
 	}
 
-    if (reiserfs_open_ondisk_bitmap (fs) < 0)
-		reiserfs_exit (1, "Could not open ondisk bitmap");
+	if (reiserfs_open_ondisk_bitmap(fs) < 0)
+		reiserfs_exit(1, "Could not open ondisk bitmap");
 
-    for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
-			 nr_leaves < nr_leaves_cr; i ++) {
+	for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) &&
+	     nr_leaves < nr_leaves_cr; i++) {
 
-		if (!reiserfs_bitmap_test_bit (fs->fs_bitmap2, i))
+		if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i))
 			continue;
 
-		bh = bread (fs->fs_dev, i, fs->fs_blocksize);
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
 		if (!bh) {
-			reiserfs_warning (stderr, "could not read block %lu\n", i);
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 i);
 			continue;
 		}
 
-		if (who_is_this (bh->b_data, bh->b_size) != THE_LEAF) {
-			brelse (bh);	
+		if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) {
+			brelse(bh);
 			continue;
 		}
 
-		if ((!is_leaf_node (bh)) || (block_of_journal (fs, i))) {
-			brelse (bh);	
+		if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) {
+			brelse(bh);
 			continue;
 		}
 
-		should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
-		if (should_be_corrupted == 0)
-		{
-			brelse (bh);
+		should_be_corrupted =
+		    (unsigned int)get_rand((double)0, (double)1);
+		if (should_be_corrupted == 0) {
+			brelse(bh);
 			continue;
 		}
 
-		nr_ih_cr = get_rand (1, get_blkh_nr_items (B_BLK_HEAD (bh))); 
-		for (j = 0; j < nr_ih_cr; j ++ ) {
-			should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
+		nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh)));
+		for (j = 0; j < nr_ih_cr; j++) {
+			should_be_corrupted =
+			    (unsigned int)get_rand((double)0, (double)1);
 			if (should_be_corrupted == 0)
 				continue;
 
 			if ((data(fs)->log_file_name) && (data(fs)->log))
-				fprintf (data(fs)->log, "# block %lu , item header %d\n",
-						 bh->b_blocknr, j);
-			printf ("# block %lu , item header %d\n", bh->b_blocknr, j);
-			
-			ih = B_N_PITEM_HEAD (bh, j);
-			do_one_ih_random_corrupt (ih);
+				fprintf(data(fs)->log,
+					"# block %lu , item header %d\n",
+					bh->b_blocknr, j);
+			printf("# block %lu , item header %d\n", bh->b_blocknr,
+			       j);
+
+			ih = B_N_PITEM_HEAD(bh, j);
+			do_one_ih_random_corrupt(ih);
 		}
-		mark_buffer_dirty (bh);
+		mark_buffer_dirty(bh);
 		bwrite(bh);
-		brelse (bh);
-		nr_leaves ++ ;
+		brelse(bh);
+		nr_leaves++;
 	}
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "item headers in %lu leaves WERE corrupted\n",
-				 nr_leaves);
-	printf ("item headers in %lu leaves WERE corrupted\n", nr_leaves);
+		fprintf(data(fs)->log,
+			"item headers in %lu leaves WERE corrupted\n",
+			nr_leaves);
+	printf("item headers in %lu leaves WERE corrupted\n", nr_leaves);
 
-	reiserfs_close_ondisk_bitmap (fs);
+	reiserfs_close_ondisk_bitmap(fs);
 }
 
 /* corrupt item */
-void do_one_item_random_corrupt (struct buffer_head * bh,
-								 struct item_head * ih)
+void do_one_item_random_corrupt(struct buffer_head *bh, struct item_head *ih)
 {
 	unsigned int i;
 	unsigned int from;
 	unsigned int count;
-	char * p;
+	char *p;
 
 	p = (char *)B_I_PITEM(bh, ih);
 
-	from = get_rand (0, get_ih_item_len(ih)  - 1);
-	count = get_rand (1, get_ih_item_len(ih));
+	from = get_rand(0, get_ih_item_len(ih) - 1);
+	count = get_rand(1, get_ih_item_len(ih));
 
 	if (from + count > get_ih_item_len(ih))
 		count = get_ih_item_len(ih) - from;
 
-	for (i = from; i < from + count; i ++)
+	for (i = from; i < from + count; i++)
 		((char *)p)[i] = get_rand(0, 255);
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "item body \tfrom %u ( %u )\n", from, count);
+		fprintf(data(fs)->log, "item body \tfrom %u ( %u )\n", from,
+			count);
 
-	printf ("item body \tfrom %u ( %u )\n",  from, count);
-	return ;
+	printf("item body \tfrom %u ( %u )\n", from, count);
+	return;
 
 }
 
-
 /* corrupt the random number of directory items in random number of leaves */
-void do_dir_random_corrupt (reiserfs_filsys_t * fs,
-							unsigned long nr_leaves_cr) 
+void do_dir_random_corrupt(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr)
 {
- 	unsigned int nr_ih_cr;
+	unsigned int nr_ih_cr;
 	unsigned int i, j;
-	struct buffer_head * bh;
-	struct item_head * ih;
+	struct buffer_head *bh;
+	struct item_head *ih;
 	unsigned long nr_leaves = 0;
 	unsigned int should_be_corrupted = 0;
 
-	srand (time (0));
+	srand(time(0));
 
-	printf ("DIR items in %lu leaves will be corrupted\n", nr_leaves_cr);
+	printf("DIR items in %lu leaves will be corrupted\n", nr_leaves_cr);
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "DIR items in %lu leaves will be corrupted\n", nr_leaves_cr);
+		fprintf(data(fs)->log,
+			"DIR items in %lu leaves will be corrupted\n",
+			nr_leaves_cr);
 	}
 
-    if (reiserfs_open_ondisk_bitmap (fs) < 0)
-		reiserfs_exit (1, "Could not open ondisk bitmap");
+	if (reiserfs_open_ondisk_bitmap(fs) < 0)
+		reiserfs_exit(1, "Could not open ondisk bitmap");
 
-    for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
-			 nr_leaves < nr_leaves_cr; i ++) {
+	for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) &&
+	     nr_leaves < nr_leaves_cr; i++) {
 
-		if (!reiserfs_bitmap_test_bit (fs->fs_bitmap2, i))
+		if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i))
 			continue;
 
-		bh = bread (fs->fs_dev, i, fs->fs_blocksize);
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
 		if (!bh) {
-			reiserfs_warning (stderr, "could not read block %lu\n", i);
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 i);
 			continue;
 		}
 
-		if (who_is_this (bh->b_data, bh->b_size) != THE_LEAF) {
-			brelse (bh);	
+		if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) {
+			brelse(bh);
 			continue;
 		}
 
-		if ((!is_leaf_node (bh)) || (block_of_journal (fs, i))) {
-			brelse (bh);	
+		if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) {
+			brelse(bh);
 			continue;
 		}
 
-		should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
-		if (should_be_corrupted == 0)
-		{
-			brelse (bh);
+		should_be_corrupted =
+		    (unsigned int)get_rand((double)0, (double)1);
+		if (should_be_corrupted == 0) {
+			brelse(bh);
 			continue;
 		}
 
 		/* get next item, look is it a DIR */
-		nr_ih_cr = get_rand (1, get_blkh_nr_items (B_BLK_HEAD (bh))); 
-		for (j = 0; j < nr_ih_cr; j ++ ) {
-			should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
+		nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh)));
+		for (j = 0; j < nr_ih_cr; j++) {
+			should_be_corrupted =
+			    (unsigned int)get_rand((double)0, (double)1);
 			if (should_be_corrupted == 0)
 				continue;
 
 			if ((data(fs)->log_file_name) && (data(fs)->log))
-				fprintf (data(fs)->log, "# block %lu , item %d\n",
-						 bh->b_blocknr, j);
-			printf ("# block %lu , item %d\n", bh->b_blocknr, j);
-			
-			ih = B_N_PITEM_HEAD (bh, j);
-			if (get_type (&ih->ih_key) != TYPE_DIRENTRY)
+				fprintf(data(fs)->log,
+					"# block %lu , item %d\n",
+					bh->b_blocknr, j);
+			printf("# block %lu , item %d\n", bh->b_blocknr, j);
+
+			ih = B_N_PITEM_HEAD(bh, j);
+			if (get_type(&ih->ih_key) != TYPE_DIRENTRY)
 				continue;
-			do_one_item_random_corrupt (bh, ih);
+			do_one_item_random_corrupt(bh, ih);
 		}
-		mark_buffer_dirty (bh);
+		mark_buffer_dirty(bh);
 		bwrite(bh);
-		brelse (bh);
-		nr_leaves ++ ;
+		brelse(bh);
+		nr_leaves++;
 	}
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "DIR items in %lu leaves WERE corrupted\n",
-				 nr_leaves);
-	printf ("DIR items in %lu leaves WERE corrupted\n", nr_leaves);
+		fprintf(data(fs)->log,
+			"DIR items in %lu leaves WERE corrupted\n", nr_leaves);
+	printf("DIR items in %lu leaves WERE corrupted\n", nr_leaves);
 
-	reiserfs_close_ondisk_bitmap (fs);
+	reiserfs_close_ondisk_bitmap(fs);
 }
 
 /* corrupt the random number of stat data items in random number of leaves */
-void do_sd_random_corrupt (reiserfs_filsys_t * fs,
-						   unsigned long nr_leaves_cr) 
+void do_sd_random_corrupt(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr)
 {
- 	unsigned int nr_ih_cr;
+	unsigned int nr_ih_cr;
 	unsigned int i, j;
-	struct buffer_head * bh;
-	struct item_head * ih;
+	struct buffer_head *bh;
+	struct item_head *ih;
 	unsigned long nr_leaves = 0;
 	unsigned int should_be_corrupted = 0;
 
-	srand (time (0));
+	srand(time(0));
 
-	printf ("SD items in %lu leaves will be corrupted\n", nr_leaves_cr);
+	printf("SD items in %lu leaves will be corrupted\n", nr_leaves_cr);
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "SD items in %lu leaves will be corrupted\n", nr_leaves_cr);
+		fprintf(data(fs)->log,
+			"SD items in %lu leaves will be corrupted\n",
+			nr_leaves_cr);
 	}
 
-    if (reiserfs_open_ondisk_bitmap (fs) < 0)
-		reiserfs_exit (1, "Could not open ondisk bitmap");
+	if (reiserfs_open_ondisk_bitmap(fs) < 0)
+		reiserfs_exit(1, "Could not open ondisk bitmap");
 
-    for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
-			 nr_leaves < nr_leaves_cr; i ++) {
+	for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) &&
+	     nr_leaves < nr_leaves_cr; i++) {
 
-		if (!reiserfs_bitmap_test_bit (fs->fs_bitmap2, i))
+		if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i))
 			continue;
 
-		bh = bread (fs->fs_dev, i, fs->fs_blocksize);
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
 		if (!bh) {
-			reiserfs_warning (stderr, "could not read block %lu\n", i);
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 i);
 			continue;
 		}
 
-		if (who_is_this (bh->b_data, bh->b_size) != THE_LEAF) {
-			brelse (bh);	
+		if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) {
+			brelse(bh);
 			continue;
 		}
 
-		if ((!is_leaf_node (bh)) || (block_of_journal (fs, i))) {
-			brelse (bh);	
+		if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) {
+			brelse(bh);
 			continue;
 		}
-		
-		should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
-		if (should_be_corrupted == 0)
-		{
-			brelse (bh);
+
+		should_be_corrupted =
+		    (unsigned int)get_rand((double)0, (double)1);
+		if (should_be_corrupted == 0) {
+			brelse(bh);
 			continue;
 		}
 
 		/* get next item, look is it a SD */
-		nr_ih_cr = get_rand (1, get_blkh_nr_items (B_BLK_HEAD (bh))); 
-		for (j = 0; j < nr_ih_cr; j ++ ) {
-			should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
+		nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh)));
+		for (j = 0; j < nr_ih_cr; j++) {
+			should_be_corrupted =
+			    (unsigned int)get_rand((double)0, (double)1);
 			if (should_be_corrupted == 0)
 				continue;
 
 			if ((data(fs)->log_file_name) && (data(fs)->log))
-				fprintf (data(fs)->log, "# block %lu , item %d\n",
-						 bh->b_blocknr, j);
-			printf ("# block %lu , item %d\n", bh->b_blocknr, j);
-			
-			ih = B_N_PITEM_HEAD (bh, j);
-			if (get_type (&ih->ih_key) != TYPE_STAT_DATA)
+				fprintf(data(fs)->log,
+					"# block %lu , item %d\n",
+					bh->b_blocknr, j);
+			printf("# block %lu , item %d\n", bh->b_blocknr, j);
+
+			ih = B_N_PITEM_HEAD(bh, j);
+			if (get_type(&ih->ih_key) != TYPE_STAT_DATA)
 				continue;
-			do_one_item_random_corrupt (bh, ih);
+			do_one_item_random_corrupt(bh, ih);
 		}
-		mark_buffer_dirty (bh);
+		mark_buffer_dirty(bh);
 		bwrite(bh);
-		brelse (bh);
-		nr_leaves ++ ;
+		brelse(bh);
+		nr_leaves++;
 	}
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "SD items in %lu leaves WERE corrupted\n",
-				 nr_leaves);
-	printf ("SD items in %lu leaves WERE corrupted\n", nr_leaves);
+		fprintf(data(fs)->log,
+			"SD items in %lu leaves WERE corrupted\n", nr_leaves);
+	printf("SD items in %lu leaves WERE corrupted\n", nr_leaves);
 
-	reiserfs_close_ondisk_bitmap (fs);
+	reiserfs_close_ondisk_bitmap(fs);
 }
 
 /* corrupt the random number of indierct items in random number of leaves */
-void do_ind_random_corrupt (reiserfs_filsys_t * fs,
-						   unsigned long nr_leaves_cr) 
+void do_ind_random_corrupt(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr)
 {
- 	unsigned int nr_ih_cr;
+	unsigned int nr_ih_cr;
 	unsigned int i, j;
-	struct buffer_head * bh;
-	struct item_head * ih;
+	struct buffer_head *bh;
+	struct item_head *ih;
 	unsigned long nr_leaves = 0;
 	unsigned int should_be_corrupted = 0;
 
-	srand (time (0));
+	srand(time(0));
 
-	printf ("IND items in %lu leaves will be corrupted\n", nr_leaves_cr);
+	printf("IND items in %lu leaves will be corrupted\n", nr_leaves_cr);
 	if ((data(fs)->log_file_name) && (data(fs)->log)) {
-		fprintf (data(fs)->log, "IND items in %lu leaves will be corrupted\n", nr_leaves_cr);
+		fprintf(data(fs)->log,
+			"IND items in %lu leaves will be corrupted\n",
+			nr_leaves_cr);
 	}
 
-    if (reiserfs_open_ondisk_bitmap (fs) < 0)
-		reiserfs_exit (1, "Could not open ondisk bitmap");
+	if (reiserfs_open_ondisk_bitmap(fs) < 0)
+		reiserfs_exit(1, "Could not open ondisk bitmap");
 
-    for (i = 0; (i < get_sb_block_count (fs->fs_ondisk_sb)) &&
-			 nr_leaves < nr_leaves_cr; i ++) {
+	for (i = 0; (i < get_sb_block_count(fs->fs_ondisk_sb)) &&
+	     nr_leaves < nr_leaves_cr; i++) {
 
-		if (!reiserfs_bitmap_test_bit (fs->fs_bitmap2, i))
+		if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i))
 			continue;
 
-		bh = bread (fs->fs_dev, i, fs->fs_blocksize);
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
 		if (!bh) {
-			reiserfs_warning (stderr, "could not read block %lu\n", i);
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 i);
 			continue;
 		}
 
-		if (who_is_this (bh->b_data, bh->b_size) != THE_LEAF) {
-			brelse (bh);	
+		if (who_is_this(bh->b_data, bh->b_size) != THE_LEAF) {
+			brelse(bh);
 			continue;
 		}
 
-		if ((!is_leaf_node (bh)) || (block_of_journal (fs, i))) {
-			brelse (bh);	
+		if ((!is_leaf_node(bh)) || (block_of_journal(fs, i))) {
+			brelse(bh);
 			continue;
 		}
-		
-		should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
-		if (should_be_corrupted == 0)
-		{
-			brelse (bh);
+
+		should_be_corrupted =
+		    (unsigned int)get_rand((double)0, (double)1);
+		if (should_be_corrupted == 0) {
+			brelse(bh);
 			continue;
 		}
 
 		/* get next item, look is it an IND */
-		nr_ih_cr = get_rand (1, get_blkh_nr_items (B_BLK_HEAD (bh))); 
-		for (j = 0; j < nr_ih_cr; j ++ ) {
-			should_be_corrupted = (unsigned int) get_rand ((double)0, (double)1);
+		nr_ih_cr = get_rand(1, get_blkh_nr_items(B_BLK_HEAD(bh)));
+		for (j = 0; j < nr_ih_cr; j++) {
+			should_be_corrupted =
+			    (unsigned int)get_rand((double)0, (double)1);
 			if (should_be_corrupted == 0)
 				continue;
 
-			ih = B_N_PITEM_HEAD (bh, j);
-			if (get_type (&ih->ih_key) != TYPE_INDIRECT)
+			ih = B_N_PITEM_HEAD(bh, j);
+			if (get_type(&ih->ih_key) != TYPE_INDIRECT)
 				continue;
 			if ((data(fs)->log_file_name) && (data(fs)->log))
-				fprintf (data(fs)->log, "# block %lu , item %d\n",
-						 bh->b_blocknr, j);
-			printf ("# block %lu , item %d\n", bh->b_blocknr, j);
+				fprintf(data(fs)->log,
+					"# block %lu , item %d\n",
+					bh->b_blocknr, j);
+			printf("# block %lu , item %d\n", bh->b_blocknr, j);
 
-			do_one_item_random_corrupt (bh, ih);
+			do_one_item_random_corrupt(bh, ih);
 		}
-		mark_buffer_dirty (bh);
+		mark_buffer_dirty(bh);
 		bwrite(bh);
-		brelse (bh);
-		nr_leaves ++ ;
+		brelse(bh);
+		nr_leaves++;
 	}
 
 	if ((data(fs)->log_file_name) && (data(fs)->log))
-		fprintf (data(fs)->log, "IND items in %lu leaves WERE corrupted\n",
-				 nr_leaves);
-	printf ("IND items in %lu leaves WERE corrupted\n", nr_leaves);
+		fprintf(data(fs)->log,
+			"IND items in %lu leaves WERE corrupted\n", nr_leaves);
+	printf("IND items in %lu leaves WERE corrupted\n", nr_leaves);
 
-	reiserfs_close_ondisk_bitmap (fs);
+	reiserfs_close_ondisk_bitmap(fs);
 }
 
 /* this reads list of desired corruptions from stdin and performs the
@@ -1197,97 +1268,103 @@ void do_ind_random_corrupt (reiserfs_filsys_t * fs,
                  corrupted
 */
 
-void what_to_corrupt (reiserfs_filsys_t * fs, char * corruption_command)
+void what_to_corrupt(reiserfs_filsys_t *fs, char *corruption_command)
 {
 	unsigned long nr_leaves_cr;
 	char code;
 
-	switch (corruption_command [0]){
-	case 'B' :
+	switch (corruption_command[0]) {
+	case 'B':
 		/* bitmap */
-		do_bitmap_corruption (fs);
+		do_bitmap_corruption(fs);
 		break;
 
-	case 'L' :
+	case 'L':
 		/* leaves */
-		if (sscanf (corruption_command, "%c %lu\n", &code, &nr_leaves_cr) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr)
+		    != 2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		do_leaves_corruption (fs, nr_leaves_cr);		
+		do_leaves_corruption(fs, nr_leaves_cr);
 		break;
 
-	case 'H' :
+	case 'H':
 		/* item headers */
-		if (sscanf (corruption_command, "%c %lu\n", &code, &nr_leaves_cr) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr)
+		    != 2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		do_ih_random_corrupt (fs, nr_leaves_cr);
+		do_ih_random_corrupt(fs, nr_leaves_cr);
 		break;
 
-	case 'D' :
+	case 'D':
 		/* directory items */
-		if (sscanf (corruption_command, "%c %lu\n", &code, &nr_leaves_cr) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr)
+		    != 2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		do_dir_random_corrupt (fs, nr_leaves_cr);
+		do_dir_random_corrupt(fs, nr_leaves_cr);
 		break;
 
-	case 'S' :
+	case 'S':
 		/* stat data items */
-		if (sscanf (corruption_command, "%c %lu\n", &code, &nr_leaves_cr) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr)
+		    != 2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		do_sd_random_corrupt (fs, nr_leaves_cr);
+		do_sd_random_corrupt(fs, nr_leaves_cr);
 		break;
 
-	case 'I' :
+	case 'I':
 		/* indirect items */
-		if (sscanf (corruption_command, "%c %lu\n", &code, &nr_leaves_cr) != 2) {
-			printf ("Wrong format \'%c\'\n", corruption_command [0]);
+		if (sscanf(corruption_command, "%c %lu\n", &code, &nr_leaves_cr)
+		    != 2) {
+			printf("Wrong format \'%c\'\n", corruption_command[0]);
 			return;
 		}
-		do_ind_random_corrupt (fs, nr_leaves_cr);
+		do_ind_random_corrupt(fs, nr_leaves_cr);
 		break;
 
-	default :
-		printf ("Unknown command specified\n");
+	default:
+		printf("Unknown command specified\n");
 	}
 }
 
-void do_fs_random_corrupt (reiserfs_filsys_t * fs)
+void do_fs_random_corrupt(reiserfs_filsys_t *fs)
 {
-    char * line = 0;
-    size_t n = 0;
-
-    printf ("Corrupting fs. Please insert one of the following command\n"
-			" B - the random number of bitmap to be corrupted\n"
-			" L nr_leaves - block headers in nr_leaves leaves to be corupted\n"
-			" H nr_leaves - the random number of item headers in nr_leaves to be corrupted\n"
-			" S nr_leaves - the random number of stat data items in nr_leaves to be corrupted\n"
-			" D nr_leaves - the random number of directory items in nr_leaves to be corrupted\n"
-			" I nr_leaves - the random number of indirect items in nr_leaves to be corrupted\n"
-			".. ->\n");
+	char *line = 0;
+	size_t n = 0;
+
+	printf("Corrupting fs. Please insert one of the following command\n"
+	       " B - the random number of bitmap to be corrupted\n"
+	       " L nr_leaves - block headers in nr_leaves leaves to be corupted\n"
+	       " H nr_leaves - the random number of item headers in nr_leaves to be corrupted\n"
+	       " S nr_leaves - the random number of stat data items in nr_leaves to be corrupted\n"
+	       " D nr_leaves - the random number of directory items in nr_leaves to be corrupted\n"
+	       " I nr_leaves - the random number of indirect items in nr_leaves to be corrupted\n"
+	       ".. ->\n");
 
 	/* Get list of corruptions from stdin */
-	while (getline (&line, &n, stdin) != -1) {
-		if ( line [0] == '\n' ) {
-			free (line);
+	while (getline(&line, &n, stdin) != -1) {
+		if (line[0] == '\n') {
+			free(line);
 			line = 0;
 			n = 0;
 			break;
 		}
-		printf ("################## command : %s", line);
+		printf("################## command : %s", line);
 		if ((data(fs)->log_file_name) && (data(fs)->log)) {
-			fprintf (data(fs)->log, "################## command : %s", line);
+			fprintf(data(fs)->log,
+				"################## command : %s", line);
 		}
 
-		what_to_corrupt (fs, line);
-		
-		free (line);
+		what_to_corrupt(fs, line);
+
+		free(line);
 		line = 0;
 		n = 0;
 	}
@@ -1302,11 +1379,3 @@ void do_fs_random_corrupt (reiserfs_filsys_t * fs)
    fill-column: 80
    End:
 */
-
-
-
-
-
-
-
-
diff --git a/debugreiserfs/debugreiserfs.c b/debugreiserfs/debugreiserfs.c
index 5a515ee..8d1a78c 100644
--- a/debugreiserfs/debugreiserfs.c
+++ b/debugreiserfs/debugreiserfs.c
@@ -5,7 +5,7 @@
 
 #include "debugreiserfs.h"
 
-reiserfs_filsys_t * fs;
+reiserfs_filsys_t *fs;
 
 #define print_usage_and_exit() {\
 fprintf (stderr, "Usage: %s [options] device\n\n\
@@ -59,176 +59,177 @@ Options:\n\
 
 #if 1
 struct reiserfs_fsstat {
-    unsigned int nr_internals;
-    unsigned int nr_leaves;
-    unsigned int nr_files;
-    unsigned int nr_directories;
-    unsigned int nr_unformatted;
+	unsigned int nr_internals;
+	unsigned int nr_leaves;
+	unsigned int nr_files;
+	unsigned int nr_directories;
+	unsigned int nr_unformatted;
 } g_stat_info;
 #endif
 
-static void print_disk_tree (reiserfs_filsys_t * fs, unsigned long block_nr)
+static void print_disk_tree(reiserfs_filsys_t *fs, unsigned long block_nr)
 {
-    struct buffer_head * bh;
-    int i, j, count;
-    static int level = -1;
-	
-    if (level == -1)
-	    level = get_sb_tree_height (fs->fs_ondisk_sb);
-
-    bh = bread (fs->fs_dev, block_nr, fs->fs_blocksize);
-    if (!bh) {
-	    die ("Could not read block %lu\n", block_nr);
-    }
-    level --;
-
-    if (level < 1)
-	    die ("level too small");
-	
-    if (level != get_blkh_level (B_BLK_HEAD (bh))) {
-	    printf ("%d expected, %d found in %lu\n", level, 
-		    get_blkh_level (B_BLK_HEAD (bh)), bh->b_blocknr);
-    }
-
-    if (is_internal_node (bh)) {
-	    struct disk_child * dc;
-
-	    g_stat_info.nr_internals ++;
-	    print_block (stdout, fs, bh, 
-			 data(fs)->options & PRINT_TREE_DETAILS, -1, -1);
-
-	    dc = B_N_CHILD (bh, 0);
-	    count = B_NR_ITEMS(bh);
-	    for (i = 0; i <= count; i++, dc++)
-		    print_disk_tree (fs, get_dc_child_blocknr (dc));
-    } else if (is_leaf_node (bh)) {
-	    struct item_head *ih;
-
-	    g_stat_info.nr_leaves ++;
-	    print_block (stdout, fs, bh, 
-			 data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
-
-	    ih = B_N_PITEM_HEAD (bh, 0);
-	    count = leaf_item_number_estimate(bh);
-	    for (i = 0; i < count; i++, ih++) {
-		    if (is_indirect_ih(ih)) {
-			    __u32 * ind_item = (__u32 *)B_I_PITEM (bh, ih);
-
-			    for (j =  0; j < (int)I_UNFM_NUM (ih); j ++) {
-				    if (d32_get (ind_item, j)) {
-					    g_stat_info.nr_unformatted += 1;
-				    }
-			    }
-		    }
-	    }
-    } else {
-	    print_block (stdout, fs, bh, 
-			 data (fs)->options & PRINT_TREE_DETAILS, -1, -1);
-	    
-	    reiserfs_warning (stdout, "print_disk_tree: bad block "
-			      "type (%b)\n", bh);
-    }
-    brelse (bh);
-    level ++;
+	struct buffer_head *bh;
+	int i, j, count;
+	static int level = -1;
+
+	if (level == -1)
+		level = get_sb_tree_height(fs->fs_ondisk_sb);
+
+	bh = bread(fs->fs_dev, block_nr, fs->fs_blocksize);
+	if (!bh) {
+		die("Could not read block %lu\n", block_nr);
+	}
+	level--;
+
+	if (level < 1)
+		die("level too small");
+
+	if (level != get_blkh_level(B_BLK_HEAD(bh))) {
+		printf("%d expected, %d found in %lu\n", level,
+		       get_blkh_level(B_BLK_HEAD(bh)), bh->b_blocknr);
+	}
+
+	if (is_internal_node(bh)) {
+		struct disk_child *dc;
+
+		g_stat_info.nr_internals++;
+		print_block(stdout, fs, bh,
+			    data(fs)->options & PRINT_TREE_DETAILS, -1, -1);
+
+		dc = B_N_CHILD(bh, 0);
+		count = B_NR_ITEMS(bh);
+		for (i = 0; i <= count; i++, dc++)
+			print_disk_tree(fs, get_dc_child_blocknr(dc));
+	} else if (is_leaf_node(bh)) {
+		struct item_head *ih;
+
+		g_stat_info.nr_leaves++;
+		print_block(stdout, fs, bh,
+			    data(fs)->options & PRINT_TREE_DETAILS, -1, -1);
+
+		ih = B_N_PITEM_HEAD(bh, 0);
+		count = leaf_item_number_estimate(bh);
+		for (i = 0; i < count; i++, ih++) {
+			if (is_indirect_ih(ih)) {
+				__u32 *ind_item = (__u32 *) B_I_PITEM(bh, ih);
+
+				for (j = 0; j < (int)I_UNFM_NUM(ih); j++) {
+					if (d32_get(ind_item, j)) {
+						g_stat_info.nr_unformatted += 1;
+					}
+				}
+			}
+		}
+	} else {
+		print_block(stdout, fs, bh,
+			    data(fs)->options & PRINT_TREE_DETAILS, -1, -1);
+
+		reiserfs_warning(stdout, "print_disk_tree: bad block "
+				 "type (%b)\n", bh);
+	}
+	brelse(bh);
+	level++;
 }
 
-static void print_disk_blocks (reiserfs_filsys_t * fs)
+static void print_disk_blocks(reiserfs_filsys_t *fs)
 {
-    int type;
-    unsigned long done = 0, total;
-    struct buffer_head * bh;
-    unsigned int j;
-	
-    total = reiserfs_bitmap_ones (input_bitmap(fs));
-	
-    for (j = 0; j < get_sb_block_count (fs->fs_ondisk_sb); j ++) {
-		if (!reiserfs_bitmap_test_bit (input_bitmap (fs), j))
+	int type;
+	unsigned long done = 0, total;
+	struct buffer_head *bh;
+	unsigned int j;
+
+	total = reiserfs_bitmap_ones(input_bitmap(fs));
+
+	for (j = 0; j < get_sb_block_count(fs->fs_ondisk_sb); j++) {
+		if (!reiserfs_bitmap_test_bit(input_bitmap(fs), j))
 			continue;
-		
-		print_how_far (stderr, &done, total, 1, be_quiet (fs));
-		
-		bh = bread (fs->fs_dev, j, fs->fs_blocksize);
+
+		print_how_far(stderr, &done, total, 1, be_quiet(fs));
+
+		bh = bread(fs->fs_dev, j, fs->fs_blocksize);
 		if (!bh) {
-			reiserfs_warning (stderr, "could not read block %lu\n", j);
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 j);
 			continue;
 		}
-		
-		type = who_is_this (bh->b_data, bh->b_size);
+
+		type = who_is_this(bh->b_data, bh->b_size);
 		if (type != THE_UNKNOWN) {
-			print_block (stdout, fs, bh, 
-				     PRINT_TREE_DETAILS | PRINT_DIRECT_ITEMS, 
-				     -1, -1);
+			print_block(stdout, fs, bh,
+				    PRINT_TREE_DETAILS | PRINT_DIRECT_ITEMS,
+				    -1, -1);
 		}
-		
+
 		if (type == THE_INTERNAL)
-			g_stat_info.nr_internals ++;
+			g_stat_info.nr_internals++;
 		else if (type == THE_LEAF || type == HAS_IH_ARRAY)
-			g_stat_info.nr_leaves ++;
-	    
-		brelse (bh);
-    }
-    fprintf (stderr, "\n");
-}
+			g_stat_info.nr_leaves++;
 
+		brelse(bh);
+	}
+	fprintf(stderr, "\n");
+}
 
-void pack_one_block (reiserfs_filsys_t * fs, unsigned long block);
-static void print_one_block (reiserfs_filsys_t * fs, unsigned long block)
+void pack_one_block(reiserfs_filsys_t *fs, unsigned long block);
+static void print_one_block(reiserfs_filsys_t *fs, unsigned long block)
 {
-    struct buffer_head * bh;
-    
-    if (!fs->fs_bitmap2) {
-        struct buffer_head * bm_bh;
-        unsigned long bm_block;
-        
-        if (spread_bitmaps (fs))
-		bm_block = 
-			( block / (fs->fs_blocksize * 8) ) ? 
-			(block / (fs->fs_blocksize * 8)) * 
-			(fs->fs_blocksize * 8) : 
-			fs->fs_super_bh->b_blocknr + 1;
-        else
-		bm_block = fs->fs_super_bh->b_blocknr + 1 + 
-			(block / (fs->fs_blocksize * 8));
-
-        bm_bh = bread (fs->fs_dev, bm_block, fs->fs_blocksize);
-        if (bm_bh) {
-		if (misc_test_bit((block % (fs->fs_blocksize * 8)), 
-				  bm_bh->b_data))
-		{
-			fprintf (stderr, "%lu is used in "
-				 "ondisk bitmap\n", block);
-		} else {
-			fprintf (stderr, "%lu is free in "
-				 "ondisk bitmap\n", block);
+	struct buffer_head *bh;
+
+	if (!fs->fs_bitmap2) {
+		struct buffer_head *bm_bh;
+		unsigned long bm_block;
+
+		if (spread_bitmaps(fs))
+			bm_block =
+			    (block / (fs->fs_blocksize * 8)) ?
+			    (block / (fs->fs_blocksize * 8)) *
+			    (fs->fs_blocksize * 8) :
+			    fs->fs_super_bh->b_blocknr + 1;
+		else
+			bm_block = fs->fs_super_bh->b_blocknr + 1 +
+			    (block / (fs->fs_blocksize * 8));
+
+		bm_bh = bread(fs->fs_dev, bm_block, fs->fs_blocksize);
+		if (bm_bh) {
+			if (misc_test_bit((block % (fs->fs_blocksize * 8)),
+					  bm_bh->b_data)) {
+				fprintf(stderr, "%lu is used in "
+					"ondisk bitmap\n", block);
+			} else {
+				fprintf(stderr, "%lu is free in "
+					"ondisk bitmap\n", block);
+			}
+
+			brelse(bm_bh);
 		}
-	        
-            brelse (bm_bh);
-        }
-    } else {
-        if (reiserfs_bitmap_test_bit (fs->fs_bitmap2, block))
-		fprintf (stderr, "%lu is used in ondisk bitmap\n", block);
-        else
-		fprintf (stderr, "%lu is free in ondisk bitmap\n", block);
-    }
-    
-    bh = bread (fs->fs_dev, block, fs->fs_blocksize);
-    if (!bh) {
-	    printf ("print_one_block: bread failed\n");
-	    return;
-    }
-	
-    if (debug_mode (fs) == DO_PACK) {
-	    pack_one_block (fs, bh->b_blocknr);
-	    brelse (bh);
-	    return;
-    }
-	
-    if (who_is_this (bh->b_data, bh->b_size) != THE_UNKNOWN)
-	    print_block (stdout, fs, bh, PRINT_TREE_DETAILS, -1, -1);
-    else
-	    printf ("Looks like unformatted\n");
-    brelse (bh);
-    return;
+	} else {
+		if (reiserfs_bitmap_test_bit(fs->fs_bitmap2, block))
+			fprintf(stderr, "%lu is used in ondisk bitmap\n",
+				block);
+		else
+			fprintf(stderr, "%lu is free in ondisk bitmap\n",
+				block);
+	}
+
+	bh = bread(fs->fs_dev, block, fs->fs_blocksize);
+	if (!bh) {
+		printf("print_one_block: bread failed\n");
+		return;
+	}
+
+	if (debug_mode(fs) == DO_PACK) {
+		pack_one_block(fs, bh->b_blocknr);
+		brelse(bh);
+		return;
+	}
+
+	if (who_is_this(bh->b_data, bh->b_size) != THE_UNKNOWN)
+		print_block(stdout, fs, bh, PRINT_TREE_DETAILS, -1, -1);
+	else
+		printf("Looks like unformatted\n");
+	brelse(bh);
+	return;
 }
 
 /* debugreiserfs -p or -P compresses reiserfs meta data: super block, journal,
@@ -237,202 +238,203 @@ static void print_one_block (reiserfs_filsys_t * fs, unsigned long block)
    "bitmap" saved in that file and build the tree of blocks marked used in
    that "bitmap"
 */
-char * where_to_save;
-char * badblocks_file;
-char * corruption_list_file;
+char *where_to_save;
+char *badblocks_file;
+char *corruption_list_file;
 char *program_name;
 
-static char * parse_options (struct debugreiserfs_data * data, 
-			     int argc, char * argv [])
+static char *parse_options(struct debugreiserfs_data *data,
+			   int argc, char *argv[])
 {
-    int c;
-    char * tmp;
-    
-    data->scan_area = USED_BLOCKS;
-    data->mode = DO_DUMP;
-    
-    program_name = strrchr( argv[ 0 ], '/' );
-    
-    if (program_name)
-	program_name++;
-    else
-	program_name = argv[ 0 ];
-
-    while ((c = getopt (argc, argv, "a:b:C:F:SU1:pkn:Nfr:dDomj:JqtZl:LVB:uv")) 
-	   != EOF) 
-    {
-	    switch (c) {
-	    case 'a': /* -r will read this, -n and -N will write to it */
-		    asprintf (&data->map_file, "%s", optarg);
-		    break;
-
-	    case 'b':
-		    /* will load bitmap from a file and read only blocks
-		       marked in it. This is for -p and -k */
-		    asprintf (&data->input_bitmap, "%s", optarg);
-		    data->scan_area = EXTERN_BITMAP;
-		    break;
-
-	    case 'S':
-		    /* have debugreiserfs -p or -k to read all the device */
-		    data->scan_area = ALL_BLOCKS;
-		    break;
-
-	    case 'U':
-		    /* have debugreiserfs -p or -k to read unused blocks only */
-		    data->scan_area = UNUSED_BLOCKS;
-		    break;
-
-	    case '1':	/* print a single node */
-		    data->block = strtol (optarg, &tmp, 0);
-		    if (*tmp)
-			    die ("parse_options: bad block number");
-		    break;
-
-	    case 'C':
-		    data->mode = DO_CORRUPT_ONE;
-		    data->block = strtol (optarg, &tmp, 0);
-		    if (*tmp) {
-			    die ("parse_options: bad block number");
-		    }
-		    break;
-
-	    case 'F':
-		    data->mode = DO_CORRUPT_FILE;
-		    if (asprintf (&corruption_list_file, "%s", optarg) == -1 ) {    
-			    die ("parse_options: bad list corruption file");
-		    }
-		    break;
-
-	    case 'p':
-		    data->mode = DO_PACK;
-		    break;
-
-	    case 'u':
-		    data->mode = DO_UNPACK;
-		    break;
-
-	    case 't':
-		    data->mode = DO_STAT;
-		    break;
-
-	    case 'k':
-		    /* read the device and print reiserfs blocks which contain 
-		       defined key */
-		    data->mode = DO_SCAN;
-		    break;
-
-	    case 'n': /* scan for names matching a specified pattern */
-		    data->mode = DO_SCAN_FOR_NAME;
-		    data->pattern = optarg;
-		    /*asprintf (&data->pattern, "%s", optarg);*/
-		    break;
-
-	    case 'N': /* search name in the tree */
-		    data->mode = DO_LOOK_FOR_NAME;
-		    break;
-
-	    case 'f':
-		    data->mode = DO_FILE_MAP;
-		    break;
-
-	    case 'r':
-		    asprintf (&data->recovery_file, "%s", optarg);
-		    data->mode = DO_RECOVER;
-		    break;
-
-	    case 'd':
-		    /*  print leaf details from internal tree */
-		    data->options |= PRINT_TREE_DETAILS;
-		    break;
-
-	    case 'D':
-		    /* print leaf details accordingly the bitmap - can be used 
-		       with -S */
-		    data->options |= PRINT_DETAILS;
-		    break;
-
-	    case 'o':
-		    /* print objectid map */
-		    data->options |= PRINT_OBJECTID_MAP;
-		    break;
-
-	    case 'm':	/* print a block map */
-	    case 'M':	/* print a block map with details */
-		    data->options |= PRINT_BITMAP;
-		    break;
-
-	    case 'j': /* -j must have a parameter */
-		    data->options |= PRINT_JOURNAL;
-		    data->journal_device_name = optarg;
-		    break;
-
-	    case 'J':
-		    data->options |= PRINT_JOURNAL_HEADER;
-		    break;
-
-	    case 'R': /* read block numbers from stdin and look for them in the
-			 journal */
-		    data->mode = DO_SCAN_JOURNAL;
-		    data->JJ ++;
-		    break;
-
-	    case 'B':              /*disabled for a while*/
-		    asprintf (&badblocks_file, "%s", optarg);
-		    data->mode = DO_EXTRACT_BADBLOCKS;
-		    break;
-	    case 'q':
-		    /* this makes packing to not show speed info during -p or -P */
-		    data->options |= BE_QUIET;
-		    break;
-	    case 'Z':
-		    data->mode = DO_ZERO;
-		    break;
-
-	    case 'l': /* --logfile */
-		    data->log_file_name = optarg;
-		    data->log = fopen (optarg, "w");
-		    if (!data->log) {
-			    fprintf (stderr, "debugreiserfs: Cannot not open "
-				     "\'%s\': %s", optarg, strerror(errno));
-		    }
-		    break;
-	    case 'L' :
-		    /* random fs corruption */
-		    data->mode = DO_RANDOM_CORRUPTION;
-		    break;
-	    case 'V':
-		    data->mode = DO_NOTHING;
-		    break;
-	    case 'v':
-		    data->options |= BE_VERBOSE;
-		    break;
-	    }
-    }
-
-    if (data->mode == DO_NOTHING) {
-	    print_banner(program_name);
-	    exit(0);
-    }
-
-    if (optind != argc - 1)
-	    /* only one non-option argument is permitted */
-	    print_usage_and_exit();
-
-    print_banner(program_name);
-
-    data->device_name = argv[optind];
-    return argv[optind];
+	int c;
+	char *tmp;
+
+	data->scan_area = USED_BLOCKS;
+	data->mode = DO_DUMP;
+
+	program_name = strrchr(argv[0], '/');
+
+	if (program_name)
+		program_name++;
+	else
+		program_name = argv[0];
+
+	while ((c =
+		getopt(argc, argv, "a:b:C:F:SU1:pkn:Nfr:dDomj:JqtZl:LVB:uv"))
+	       != EOF) {
+		switch (c) {
+		case 'a':	/* -r will read this, -n and -N will write to it */
+			asprintf(&data->map_file, "%s", optarg);
+			break;
+
+		case 'b':
+			/* will load bitmap from a file and read only blocks
+			   marked in it. This is for -p and -k */
+			asprintf(&data->input_bitmap, "%s", optarg);
+			data->scan_area = EXTERN_BITMAP;
+			break;
+
+		case 'S':
+			/* have debugreiserfs -p or -k to read all the device */
+			data->scan_area = ALL_BLOCKS;
+			break;
+
+		case 'U':
+			/* have debugreiserfs -p or -k to read unused blocks only */
+			data->scan_area = UNUSED_BLOCKS;
+			break;
+
+		case '1':	/* print a single node */
+			data->block = strtol(optarg, &tmp, 0);
+			if (*tmp)
+				die("parse_options: bad block number");
+			break;
+
+		case 'C':
+			data->mode = DO_CORRUPT_ONE;
+			data->block = strtol(optarg, &tmp, 0);
+			if (*tmp) {
+				die("parse_options: bad block number");
+			}
+			break;
+
+		case 'F':
+			data->mode = DO_CORRUPT_FILE;
+			if (asprintf(&corruption_list_file, "%s", optarg) == -1) {
+				die("parse_options: bad list corruption file");
+			}
+			break;
+
+		case 'p':
+			data->mode = DO_PACK;
+			break;
+
+		case 'u':
+			data->mode = DO_UNPACK;
+			break;
+
+		case 't':
+			data->mode = DO_STAT;
+			break;
+
+		case 'k':
+			/* read the device and print reiserfs blocks which contain 
+			   defined key */
+			data->mode = DO_SCAN;
+			break;
+
+		case 'n':	/* scan for names matching a specified pattern */
+			data->mode = DO_SCAN_FOR_NAME;
+			data->pattern = optarg;
+			/*asprintf (&data->pattern, "%s", optarg); */
+			break;
+
+		case 'N':	/* search name in the tree */
+			data->mode = DO_LOOK_FOR_NAME;
+			break;
+
+		case 'f':
+			data->mode = DO_FILE_MAP;
+			break;
+
+		case 'r':
+			asprintf(&data->recovery_file, "%s", optarg);
+			data->mode = DO_RECOVER;
+			break;
+
+		case 'd':
+			/*  print leaf details from internal tree */
+			data->options |= PRINT_TREE_DETAILS;
+			break;
+
+		case 'D':
+			/* print leaf details accordingly the bitmap - can be used 
+			   with -S */
+			data->options |= PRINT_DETAILS;
+			break;
+
+		case 'o':
+			/* print objectid map */
+			data->options |= PRINT_OBJECTID_MAP;
+			break;
+
+		case 'm':	/* print a block map */
+		case 'M':	/* print a block map with details */
+			data->options |= PRINT_BITMAP;
+			break;
+
+		case 'j':	/* -j must have a parameter */
+			data->options |= PRINT_JOURNAL;
+			data->journal_device_name = optarg;
+			break;
+
+		case 'J':
+			data->options |= PRINT_JOURNAL_HEADER;
+			break;
+
+		case 'R':	/* read block numbers from stdin and look for them in the
+				   journal */
+			data->mode = DO_SCAN_JOURNAL;
+			data->JJ++;
+			break;
+
+		case 'B':	/*disabled for a while */
+			asprintf(&badblocks_file, "%s", optarg);
+			data->mode = DO_EXTRACT_BADBLOCKS;
+			break;
+		case 'q':
+			/* this makes packing to not show speed info during -p or -P */
+			data->options |= BE_QUIET;
+			break;
+		case 'Z':
+			data->mode = DO_ZERO;
+			break;
+
+		case 'l':	/* --logfile */
+			data->log_file_name = optarg;
+			data->log = fopen(optarg, "w");
+			if (!data->log) {
+				fprintf(stderr,
+					"debugreiserfs: Cannot not open "
+					"\'%s\': %s", optarg, strerror(errno));
+			}
+			break;
+		case 'L':
+			/* random fs corruption */
+			data->mode = DO_RANDOM_CORRUPTION;
+			break;
+		case 'V':
+			data->mode = DO_NOTHING;
+			break;
+		case 'v':
+			data->options |= BE_VERBOSE;
+			break;
+		}
+	}
+
+	if (data->mode == DO_NOTHING) {
+		print_banner(program_name);
+		exit(0);
+	}
+
+	if (optind != argc - 1)
+		/* only one non-option argument is permitted */
+		print_usage_and_exit();
+
+	print_banner(program_name);
+
+	data->device_name = argv[optind];
+	return argv[optind];
 }
 
-void pack_partition (reiserfs_filsys_t * fs);
+void pack_partition(reiserfs_filsys_t *fs);
 
-static void do_pack (reiserfs_filsys_t * fs)
+static void do_pack(reiserfs_filsys_t *fs)
 {
-    if (certain_block (fs))
-	    pack_one_block (fs, certain_block (fs));
-    else
-	    pack_partition (fs);
+	if (certain_block(fs))
+		pack_one_block(fs, certain_block(fs));
+	else
+		pack_partition(fs);
 }
 
 /*
@@ -450,330 +452,334 @@ static int comp (const void * vp1, const void * vp2)
 }
 */
 
-static void init_bitmap (reiserfs_filsys_t * fs)
+static void init_bitmap(reiserfs_filsys_t *fs)
 {
-    FILE * fp;
-    unsigned long block_count;
-	
-	
-    if (reiserfs_open_ondisk_bitmap (fs) < 0)
-	    reiserfs_exit (1, "Could not open ondisk bitmap");
-	
-    block_count = get_sb_block_count (fs->fs_ondisk_sb);
-	
-    switch (scan_area (fs)) {
-    case ALL_BLOCKS:
-	    input_bitmap (fs) = reiserfs_create_bitmap (block_count);
-	    reiserfs_bitmap_fill (input_bitmap (fs));
-	    reiserfs_warning (stderr, "Whole device (%u blocks) is to be scanned\n",
-			      reiserfs_bitmap_ones (input_bitmap (fs)));	
-	    break;
-    case USED_BLOCKS:
-	    reiserfs_warning (stderr, "Loading on-disk bitmap .. ");
-	    input_bitmap (fs) = reiserfs_create_bitmap (block_count);
-	    reiserfs_bitmap_copy (input_bitmap (fs), fs->fs_bitmap2);
-	    reiserfs_warning (stderr, "%lu bits set - done\n",
-			      reiserfs_bitmap_ones (input_bitmap (fs)));
-	    break;
-    case UNUSED_BLOCKS:
-	    reiserfs_warning (stderr, "Loading on-disk bitmap .. ");
-	    input_bitmap (fs) = reiserfs_create_bitmap (block_count);
-	    reiserfs_bitmap_copy (input_bitmap (fs), fs->fs_bitmap2);
-	    reiserfs_bitmap_invert (input_bitmap (fs));
-	    reiserfs_warning (stderr, "%lu bits set - done\n",
-			      reiserfs_bitmap_ones (input_bitmap (fs)));
-	    break;
-    case EXTERN_BITMAP:
-	    fp = fopen (input_bitmap_file_name(fs), "r");
-	    if (!fp) {
-		    reiserfs_exit (1, "init_bitmap: could not load bitmap: %m\n");
-	    }
-
-	    input_bitmap (fs) = reiserfs_bitmap_load (fp);
-	    if (!input_bitmap (fs)) {
-		    reiserfs_exit (1, "could not load fitmap from \"%s\"", 
-				   input_bitmap_file_name(fs));
-	    }
-	    reiserfs_warning (stderr, "%u blocks marked in the given bitmap\n",
-			      reiserfs_bitmap_ones (input_bitmap (fs)));
-	    fclose (fp);
-	    break;
-    default:
-	    reiserfs_panic ("No area to scan specified");
-    }
+	FILE *fp;
+	unsigned long block_count;
+
+	if (reiserfs_open_ondisk_bitmap(fs) < 0)
+		reiserfs_exit(1, "Could not open ondisk bitmap");
+
+	block_count = get_sb_block_count(fs->fs_ondisk_sb);
+
+	switch (scan_area(fs)) {
+	case ALL_BLOCKS:
+		input_bitmap(fs) = reiserfs_create_bitmap(block_count);
+		reiserfs_bitmap_fill(input_bitmap(fs));
+		reiserfs_warning(stderr,
+				 "Whole device (%u blocks) is to be scanned\n",
+				 reiserfs_bitmap_ones(input_bitmap(fs)));
+		break;
+	case USED_BLOCKS:
+		reiserfs_warning(stderr, "Loading on-disk bitmap .. ");
+		input_bitmap(fs) = reiserfs_create_bitmap(block_count);
+		reiserfs_bitmap_copy(input_bitmap(fs), fs->fs_bitmap2);
+		reiserfs_warning(stderr, "%lu bits set - done\n",
+				 reiserfs_bitmap_ones(input_bitmap(fs)));
+		break;
+	case UNUSED_BLOCKS:
+		reiserfs_warning(stderr, "Loading on-disk bitmap .. ");
+		input_bitmap(fs) = reiserfs_create_bitmap(block_count);
+		reiserfs_bitmap_copy(input_bitmap(fs), fs->fs_bitmap2);
+		reiserfs_bitmap_invert(input_bitmap(fs));
+		reiserfs_warning(stderr, "%lu bits set - done\n",
+				 reiserfs_bitmap_ones(input_bitmap(fs)));
+		break;
+	case EXTERN_BITMAP:
+		fp = fopen(input_bitmap_file_name(fs), "r");
+		if (!fp) {
+			reiserfs_exit(1,
+				      "init_bitmap: could not load bitmap: %m\n");
+		}
+
+		input_bitmap(fs) = reiserfs_bitmap_load(fp);
+		if (!input_bitmap(fs)) {
+			reiserfs_exit(1, "could not load fitmap from \"%s\"",
+				      input_bitmap_file_name(fs));
+		}
+		reiserfs_warning(stderr,
+				 "%u blocks marked in the given bitmap\n",
+				 reiserfs_bitmap_ones(input_bitmap(fs)));
+		fclose(fp);
+		break;
+	default:
+		reiserfs_panic("No area to scan specified");
+	}
 }
 
 /* FIXME: statistics does not work */
-static void do_dump_tree (reiserfs_filsys_t * fs)
+static void do_dump_tree(reiserfs_filsys_t *fs)
 {
-    if (certain_block (fs)) {
-	    print_one_block (fs, certain_block (fs));
-	    return;
-    }
-	
-    if (((data (fs)->options & PRINT_JOURNAL) || 
-	 (data (fs)->options & PRINT_JOURNAL_HEADER)) && 
-	!reiserfs_journal_opened (fs))
-    {
-	    if (reiserfs_open_journal (fs, data(fs)->journal_device_name, 
-				       O_RDONLY)) 
-	    {
-		    printf ("Could not open journal\n");
-		    return;
-	    }
-    }
-	
-    print_filesystem_state (stdout, fs);
-    print_block (stdout, fs, fs->fs_super_bh);
-	
-    if (data (fs)->options & PRINT_JOURNAL)
-		print_journal (fs);
-
-    if (data (fs)->options & PRINT_JOURNAL_HEADER)
-		print_journal_header (fs);
-	
-    if (data (fs)->options & PRINT_OBJECTID_MAP)
-		print_objectid_map (stdout, fs);
-	
-    if (data (fs)->options & PRINT_BITMAP)
-		print_bmap (stdout, fs, 0/*opt_print_block_map == 1 ? 1 : 0*/);
-	
-    if (data (fs)->options & PRINT_DETAILS)
-        init_bitmap (fs);
-	
-    if (data (fs)->options & PRINT_DETAILS || 
-	data (fs)->options & PRINT_TREE_DETAILS) 
-    {
-	    if (data (fs)->options & PRINT_DETAILS) {
-		    print_disk_blocks (fs);
-		    printf("The '%s' device with reiserfs has:\n", 
-			   fs->fs_file_name);
-	    } else {
-		    print_disk_tree (fs, get_sb_root_block(fs->fs_ondisk_sb));
-		    printf("The internal reiserfs tree has:\n");
-	    }
-
-	    /* print the statistic */
-	    printf ("\t%u internal + %u leaves + %u "
-		    "unformatted nodes = %u blocks\n",
-		    g_stat_info.nr_internals,   g_stat_info.nr_leaves, 
-		    g_stat_info.nr_unformatted, g_stat_info.nr_internals + 
-		    g_stat_info.nr_leaves + g_stat_info.nr_unformatted);
-    }
+	if (certain_block(fs)) {
+		print_one_block(fs, certain_block(fs));
+		return;
+	}
+
+	if (((data(fs)->options & PRINT_JOURNAL) ||
+	     (data(fs)->options & PRINT_JOURNAL_HEADER)) &&
+	    !reiserfs_journal_opened(fs)) {
+		if (reiserfs_open_journal(fs, data(fs)->journal_device_name,
+					  O_RDONLY)) {
+			printf("Could not open journal\n");
+			return;
+		}
+	}
+
+	print_filesystem_state(stdout, fs);
+	print_block(stdout, fs, fs->fs_super_bh);
+
+	if (data(fs)->options & PRINT_JOURNAL)
+		print_journal(fs);
+
+	if (data(fs)->options & PRINT_JOURNAL_HEADER)
+		print_journal_header(fs);
+
+	if (data(fs)->options & PRINT_OBJECTID_MAP)
+		print_objectid_map(stdout, fs);
+
+	if (data(fs)->options & PRINT_BITMAP)
+		print_bmap(stdout, fs,
+			   0 /*opt_print_block_map == 1 ? 1 : 0 */ );
+
+	if (data(fs)->options & PRINT_DETAILS)
+		init_bitmap(fs);
+
+	if (data(fs)->options & PRINT_DETAILS ||
+	    data(fs)->options & PRINT_TREE_DETAILS) {
+		if (data(fs)->options & PRINT_DETAILS) {
+			print_disk_blocks(fs);
+			printf("The '%s' device with reiserfs has:\n",
+			       fs->fs_file_name);
+		} else {
+			print_disk_tree(fs,
+					get_sb_root_block(fs->fs_ondisk_sb));
+			printf("The internal reiserfs tree has:\n");
+		}
+
+		/* print the statistic */
+		printf("\t%u internal + %u leaves + %u "
+		       "unformatted nodes = %u blocks\n",
+		       g_stat_info.nr_internals, g_stat_info.nr_leaves,
+		       g_stat_info.nr_unformatted, g_stat_info.nr_internals +
+		       g_stat_info.nr_leaves + g_stat_info.nr_unformatted);
+	}
 }
 
-static void callback_badblock_print(reiserfs_filsys_t *fs, 
-				    struct reiserfs_path *badblock_path, 
-				    void *data) 
+static void callback_badblock_print(reiserfs_filsys_t *fs,
+				    struct reiserfs_path *badblock_path,
+				    void *data)
 {
 	struct item_head *tmp_ih;
-	FILE *fd = (FILE *)data;
+	FILE *fd = (FILE *) data;
 	__u32 *ind_item;
 	__u32 i;
-	
+
 	tmp_ih = get_ih(badblock_path);
-	ind_item = (__u32 *)get_item(badblock_path);
-	
+	ind_item = (__u32 *) get_item(badblock_path);
+
 	for (i = 0; i < I_UNFM_NUM(tmp_ih); i++)
-		fprintf (fd, "%u\n", d32_get (ind_item, i));
+		fprintf(fd, "%u\n", d32_get(ind_item, i));
 
-	pathrelse (badblock_path);
+	pathrelse(badblock_path);
 }
 
-void extract_badblock_list () {
-    FILE *fd;
+void extract_badblock_list()
+{
+	FILE *fd;
 
-    if (!(fd = fopen (badblocks_file, "w"))) {
-	reiserfs_exit(1, "debugreiserfs: could not open badblock file %s\n",
-		      badblocks_file);
-    }
+	if (!(fd = fopen(badblocks_file, "w"))) {
+		reiserfs_exit(1,
+			      "debugreiserfs: could not open badblock file %s\n",
+			      badblocks_file);
+	}
 
-    badblock_list(fs, callback_badblock_print, fd);
-    fclose (fd);
+	badblock_list(fs, callback_badblock_print, fd);
+	fclose(fd);
 }
 
-static int str2int (char * str, int * res)
+static int str2int(char *str, int *res)
 {
-    int val;
-    char * tmp;
-	
-    val = (int) strtol (str, &tmp, 0);
-    if (tmp == str)
+	int val;
+	char *tmp;
+
+	val = (int)strtol(str, &tmp, 0);
+	if (tmp == str)
 		/* could not convert string into a number */
 		return 0;
-    *res = val;
-    return 1;
+	*res = val;
+	return 1;
 }
 
-void do_corrupt_blocks (reiserfs_filsys_t * fs)
+void do_corrupt_blocks(reiserfs_filsys_t *fs)
 {
-	char * line;
-	FILE * fd;
+	char *line;
+	FILE *fd;
 	size_t n = 0;
 	int numblock;
-	
-	fd = fopen (corruption_list_file, "r");
+
+	fd = fopen(corruption_list_file, "r");
 	if (fd == NULL) {
 		reiserfs_exit(1, "debugreiserfs: could not open corruption "
 			      "list file %s\n", corruption_list_file);
 	}
-	
+
 	while (1) {
 		line = NULL;
 		n = 0;
-		if (getline (&line, &n, fd) == -1) {
+		if (getline(&line, &n, fd) == -1) {
 			break;
 		}
-		
+
 		/* remove '\n' */
-		line [strlen (line) - 1] = '\0';
-		
+		line[strlen(line) - 1] = '\0';
+
 		if (str2int(line, &numblock)) {
-			data (fs)->block = (unsigned long) numblock;
+			data(fs)->block = (unsigned long)numblock;
 		} else {
 			do_corrupt_one_block(fs, line);
 		}
-		printf ("before free line : %s\n", line);
-		free (line);
-		printf ("after free\n");
-		reiserfs_reopen (fs, O_RDWR);
+		printf("before free line : %s\n", line);
+		free(line);
+		printf("after free\n");
+		reiserfs_reopen(fs, O_RDWR);
 	}
-	fclose (fd);
+	fclose(fd);
 	return;
 }
 
-void debugreiserfs_zero_reiserfs(reiserfs_filsys_t * fs) {
-    unsigned long done, total, i;
-    struct buffer_head * bh;
-	
-    reiserfs_reopen (fs, O_RDWR);
-    
-    total = reiserfs_bitmap_ones (input_bitmap (fs));
-    done = 0;
-	
-    for (i = 0; i < input_bitmap(fs)->bm_bit_size; i ++) {
-		if (!reiserfs_bitmap_test_bit (input_bitmap(fs), i))
+void debugreiserfs_zero_reiserfs(reiserfs_filsys_t *fs)
+{
+	unsigned long done, total, i;
+	struct buffer_head *bh;
+
+	reiserfs_reopen(fs, O_RDWR);
+
+	total = reiserfs_bitmap_ones(input_bitmap(fs));
+	done = 0;
+
+	for (i = 0; i < input_bitmap(fs)->bm_bit_size; i++) {
+		if (!reiserfs_bitmap_test_bit(input_bitmap(fs), i))
 			continue;
-		
+
 		bh = getblk(fs->fs_dev, i, fs->fs_blocksize);
-		
+
 		if (!bh)
 			die("Could not get block %lu\n", i);
-		
+
 		memset(bh->b_data, 0, fs->fs_blocksize);
 		mark_buffer_dirty(bh);
 		mark_buffer_uptodate(bh, 0);
-		
+
 		bwrite(bh);
-		
-		brelse (bh);
-		print_how_far (stderr, &done, total, 1, be_quiet (fs));
-    }
-	
-    fprintf(stderr, "\n");
-    fflush(stderr);
-}
 
+		brelse(bh);
+		print_how_far(stderr, &done, total, 1, be_quiet(fs));
+	}
+
+	fprintf(stderr, "\n");
+	fflush(stderr);
+}
 
 /* FIXME: need to open reiserfs filesystem first */
-int main (int argc, char * argv[])
+int main(int argc, char *argv[])
 {
-    char * file_name;
-    int error;
-    struct debugreiserfs_data * data;
-	
-    data = getmem (sizeof (struct debugreiserfs_data));
-    file_name = parse_options (data, argc, argv);
-    
-    if (data->mode == DO_UNPACK) {
-	    do_unpack(file_name, data->journal_device_name, 
-		      data->input_bitmap, data->options & BE_VERBOSE);
-	    return 0;
-    }
-    
-    fs = reiserfs_open (file_name, O_RDONLY, &error, data, 0);
-    
-    if (no_reiserfs_found (fs)) {
-	    reiserfs_exit (1, "\n\ndebugreiserfs: can not open reiserfs on "
-			   "\"%s\": %s\n\n", file_name, error ? strerror(error)
-			   : "no filesystem found");
-	    exit(1) ;
-    }
-    
-    if (reiserfs_open_journal (fs, data (fs)->journal_device_name, O_RDONLY)) {
-	    fprintf(stderr,"\ndebugreiserfs: Failed to open the fs journal.\n");
-    }
-	
-    switch (debug_mode (fs)) {
-    case DO_STAT:
-	    init_bitmap (fs);
-	    do_stat (fs);
-	    break;
-
-    case DO_PACK:
-	    init_bitmap (fs);
-	    do_pack (fs);
-	    break;
-
-    case DO_CORRUPT_ONE:
-	    reiserfs_reopen (fs, O_RDWR);
-	    do_corrupt_one_block (fs, (char *)NULL);
-	    break;
-
-    case DO_CORRUPT_FILE:
-	    reiserfs_reopen (fs, O_RDWR);
-	    do_corrupt_blocks (fs);
-	    break;
-    case DO_RANDOM_CORRUPTION:
-	    reiserfs_reopen (fs, O_RDWR);
-	    /*
-	       do_leaves_corruption (fs);
-	       do_bitmap_corruption (fs);
-	     */		
-	    do_fs_random_corrupt (fs);
-	    break;
-
-    case DO_DUMP:
-	    do_dump_tree (fs);
-	    break;
-
-    case DO_SCAN:
-    case DO_SCAN_FOR_NAME:
-    case DO_LOOK_FOR_NAME:
-    case DO_SCAN_JOURNAL:
-	    init_bitmap (fs);
-	    do_scan (fs);
-	    break;
-
-    case DO_FILE_MAP:
-	    print_map(fs);
-	    break;
-
-
-    case DO_RECOVER:
-	    do_recover (fs);
-	    break;
-
-    case DO_TEST:
-	    /*do_test (fs);*/
-	    break;
-    case DO_EXTRACT_BADBLOCKS:
-	    reiserfs_warning (stderr, "Will try to extract list of bad blocks "
-			      "and save it to '%s' file\n", badblocks_file);
-
-	    extract_badblock_list ();
-	    reiserfs_warning (stderr, "Done\n\n");
-	    break;
-    case DO_ZERO:
-	    init_bitmap (fs);
-	    debugreiserfs_zero_reiserfs(fs);
-	    break;
-    }
-
-    reiserfs_close (fs);
-    if (data(fs)->log) {
-	    fclose (data(fs)->log); 
-    }
-    return 0;
-}
+	char *file_name;
+	int error;
+	struct debugreiserfs_data *data;
+
+	data = getmem(sizeof(struct debugreiserfs_data));
+	file_name = parse_options(data, argc, argv);
+
+	if (data->mode == DO_UNPACK) {
+		do_unpack(file_name, data->journal_device_name,
+			  data->input_bitmap, data->options & BE_VERBOSE);
+		return 0;
+	}
 
+	fs = reiserfs_open(file_name, O_RDONLY, &error, data, 0);
+
+	if (no_reiserfs_found(fs)) {
+		reiserfs_exit(1, "\n\ndebugreiserfs: can not open reiserfs on "
+			      "\"%s\": %s\n\n", file_name,
+			      error ? strerror(error)
+			      : "no filesystem found");
+		exit(1);
+	}
+
+	if (reiserfs_open_journal(fs, data(fs)->journal_device_name, O_RDONLY)) {
+		fprintf(stderr,
+			"\ndebugreiserfs: Failed to open the fs journal.\n");
+	}
+
+	switch (debug_mode(fs)) {
+	case DO_STAT:
+		init_bitmap(fs);
+		do_stat(fs);
+		break;
+
+	case DO_PACK:
+		init_bitmap(fs);
+		do_pack(fs);
+		break;
+
+	case DO_CORRUPT_ONE:
+		reiserfs_reopen(fs, O_RDWR);
+		do_corrupt_one_block(fs, (char *)NULL);
+		break;
+
+	case DO_CORRUPT_FILE:
+		reiserfs_reopen(fs, O_RDWR);
+		do_corrupt_blocks(fs);
+		break;
+	case DO_RANDOM_CORRUPTION:
+		reiserfs_reopen(fs, O_RDWR);
+		/*
+		   do_leaves_corruption (fs);
+		   do_bitmap_corruption (fs);
+		 */
+		do_fs_random_corrupt(fs);
+		break;
+
+	case DO_DUMP:
+		do_dump_tree(fs);
+		break;
+
+	case DO_SCAN:
+	case DO_SCAN_FOR_NAME:
+	case DO_LOOK_FOR_NAME:
+	case DO_SCAN_JOURNAL:
+		init_bitmap(fs);
+		do_scan(fs);
+		break;
+
+	case DO_FILE_MAP:
+		print_map(fs);
+		break;
+
+	case DO_RECOVER:
+		do_recover(fs);
+		break;
+
+	case DO_TEST:
+		/*do_test (fs); */
+		break;
+	case DO_EXTRACT_BADBLOCKS:
+		reiserfs_warning(stderr,
+				 "Will try to extract list of bad blocks "
+				 "and save it to '%s' file\n", badblocks_file);
+
+		extract_badblock_list();
+		reiserfs_warning(stderr, "Done\n\n");
+		break;
+	case DO_ZERO:
+		init_bitmap(fs);
+		debugreiserfs_zero_reiserfs(fs);
+		break;
+	}
+
+	reiserfs_close(fs);
+	if (data(fs)->log) {
+		fclose(data(fs)->log);
+	}
+	return 0;
+}
diff --git a/debugreiserfs/debugreiserfs.h b/debugreiserfs/debugreiserfs.h
index 58e58e6..ec9d2eb 100644
--- a/debugreiserfs/debugreiserfs.h
+++ b/debugreiserfs/debugreiserfs.h
@@ -17,32 +17,30 @@
 #include <string.h>
 #include <errno.h>
 
-extern reiserfs_filsys_t * fs;
-
+extern reiserfs_filsys_t *fs;
 
 /*
  *  modes
  */
-#define DO_DUMP    		1  /* not a real dump, just printing to stdout contents of
-                      			tree nodes */
-#define DO_CORRUPT_ONE 		2 /* used to make filesystem corruption and then test fsck */
-#define DO_CORRUPT_FILE		3 /* used to make filesystem corruption and then test fsck, the list of corruption is set on the file */
+#define DO_DUMP    		1	/* not a real dump, just printing to stdout contents of
+					   tree nodes */
+#define DO_CORRUPT_ONE 		2	/* used to make filesystem corruption and then test fsck */
+#define DO_CORRUPT_FILE		3	/* used to make filesystem corruption and then test fsck, the list of corruption is set on the file */
 #define DO_RANDOM_CORRUPTION 	4
 #define DO_SCAN    		5
 #define DO_RECOVER 		6
 #define DO_TEST    		7
-#define DO_PACK    		8  /* -p extract meta data of reiserfs filesystem */
-#define DO_UNPACK    		9  /* -u create the fs by the givem metadata  */
+#define DO_PACK    		8	/* -p extract meta data of reiserfs filesystem */
+#define DO_UNPACK    		9	/* -u create the fs by the givem metadata  */
 #define DO_STAT    		10
-#define DO_SCAN_FOR_NAME 	11 /* -n */
-#define DO_LOOK_FOR_NAME 	12 /* -N */
-#define DO_SCAN_JOURNAL  	13 /* -J */
+#define DO_SCAN_FOR_NAME 	11	/* -n */
+#define DO_LOOK_FOR_NAME 	12	/* -N */
+#define DO_SCAN_JOURNAL  	13	/* -J */
 #define DO_EXTRACT_BADBLOCKS	14
 #define DO_FILE_MAP 		15
 #define DO_ZERO 		16
 #define DO_NOTHING		17
 
-
 /*first bits are in reiserfs_fs.b*/
 #define PRINT_JOURNAL 		0x10
 #define PRINT_JOURNAL_HEADER	0x20
@@ -52,11 +50,10 @@ extern reiserfs_filsys_t * fs;
 #define BE_VERBOSE 		0x200
 
 /* these moved to reiserfs_fs.h */
-//#define PRINT_TREE_DETAILS 		
-//#define PRINT_DETAILS 	
-//#define PRINT_ITEM_DETAILS 	 	
-//#define PRINT_DIRECT_ITEMS 	 	
-
+//#define PRINT_TREE_DETAILS            
+//#define PRINT_DETAILS         
+//#define PRINT_ITEM_DETAILS            
+//#define PRINT_DIRECT_ITEMS            
 
 // the leaf is stored in compact form:
 // start magic number
@@ -70,8 +67,6 @@ extern reiserfs_filsys_t * fs;
 #define LEAF_START_MAGIC 0xa6
 #define LEAF_END_MAGIC 0x5a
 
-
-
 #define FULL_BLOCK_START_MAGIC 0xb6
 #define FULL_BLOCK_END_MAGIC 0x6b
 #define UNFORMATTED_BITMAP_START_MAGIC 0xc7
@@ -88,40 +83,36 @@ extern reiserfs_filsys_t * fs;
 #define MAP_MAGIC 0xe9
 #define MAP_END_MAGIC 0x9e
 
-
 /* 12 bits of mask are used to define */
-#define NEW_FORMAT 			0x01   /* 1. 0 here means - old format, 1 - new format */
-#define DIR_ID     			0x02   /* 2. dir_id is stored */
-#define OBJECT_ID  			0x04   /* 3. objectid is stored */
-#define OFFSET_BITS_32 			0x08   /* 4. offset is stored as 32 bit */
-#define OFFSET_BITS_64 			0x10   /* 5. offset is stored as 64 bit */
-#define IH_ENTRY_COUNT 			0x20   /* 6. ih_free_space/ih_entry_count is stored */
+#define NEW_FORMAT 			0x01	/* 1. 0 here means - old format, 1 - new format */
+#define DIR_ID     			0x02	/* 2. dir_id is stored */
+#define OBJECT_ID  			0x04	/* 3. objectid is stored */
+#define OFFSET_BITS_32 			0x08	/* 4. offset is stored as 32 bit */
+#define OFFSET_BITS_64 			0x10	/* 5. offset is stored as 64 bit */
+#define IH_ENTRY_COUNT 			0x20	/* 6. ih_free_space/ih_entry_count is stored */
 #define IH_FREE_SPACE  			0x20
-#define IH_FORMAT 			0x40   /* 7. ih_format is stored */
-#define WITH_SD_FIRST_DIRECT_BYTE 	0x80   /* 8. for old stat data first_direct_byte is stored */
-#define NLINK_BITS_32 			0x0100 /* 9. nlinks stored in 32 bits */
-#define SIZE_BITS_64  			0x0200 /* 10. size has to be stored in 64 bit */
-#define WHOLE_INDIRECT 			0x0400 /* 11. indirect item is stored with compression */
-#define SAFE_LINK			0x0800 /* 11. indirect item is stored with compression */
-
-
-#define TYPE_MASK 0x3 /* two lowest bits are used to store item type */
+#define IH_FORMAT 			0x40	/* 7. ih_format is stored */
+#define WITH_SD_FIRST_DIRECT_BYTE 	0x80	/* 8. for old stat data first_direct_byte is stored */
+#define NLINK_BITS_32 			0x0100	/* 9. nlinks stored in 32 bits */
+#define SIZE_BITS_64  			0x0200	/* 10. size has to be stored in 64 bit */
+#define WHOLE_INDIRECT 			0x0400	/* 11. indirect item is stored with compression */
+#define SAFE_LINK			0x0800	/* 11. indirect item is stored with compression */
+
+#define TYPE_MASK 0x3		/* two lowest bits are used to store item type */
 //#define MASK_MASK 0xffffc /* what is packed: dirid, objectid, etc */
-#define ITEM_LEN_MASK 0xfff00000 /* contents of ih_item_len of item_head */
+#define ITEM_LEN_MASK 0xfff00000	/* contents of ih_item_len of item_head */
 
 struct packed_item {
-    __u32 type_2_mask_18_len_12;
+	__u32 type_2_mask_18_len_12;
 };
 
-
 /* defined as inlines in both pack.c and unpack.c */
-inline void set_pi_type( struct packed_item *pi, __u32 val );
-inline __u32 get_pi_type( const struct packed_item *pi );
-inline void set_pi_mask( struct packed_item *pi, __u32 val );
-inline __u32 get_pi_mask( const struct packed_item *pi );
-inline void set_pi_item_len( struct packed_item *pi, __u32 val );
-inline __u32 get_pi_item_len( const struct packed_item *pi );
-
+inline void set_pi_type(struct packed_item *pi, __u32 val);
+inline __u32 get_pi_type(const struct packed_item *pi);
+inline void set_pi_mask(struct packed_item *pi, __u32 val);
+inline __u32 get_pi_mask(const struct packed_item *pi);
+inline void set_pi_item_len(struct packed_item *pi, __u32 val);
+inline __u32 get_pi_item_len(const struct packed_item *pi);
 
 #define HAS_DIR_ID      0x01
 #define HAS_GEN_COUNTER 0x02
@@ -131,15 +122,14 @@ inline __u32 get_pi_item_len( const struct packed_item *pi );
 #define R5              0x20
 
 struct packed_dir_entry {
-    __u8 mask;
-    __u16 entrylen;
+	__u8 mask;
+	__u16 entrylen;
 };
 
 /* packed_dir_entry.mask is *always* endian safe, since it's 8 bit */
 #define get_pe_entrylen(pe)     (le16_to_cpu((pe)->entrylen))
 #define set_pe_entrylen(pe,v)   ((pe)->entrylen = cpu_to_le16(v))
 
-
 #define fread8(pv) fread (pv, sizeof (__u8), 1, stdin)
 
 #define fread_le16(pv)\
@@ -163,13 +153,11 @@ struct packed_dir_entry {
     *pv = le64_to_cpu(tmp); \
 }
 
-
 #define fread8(pv) fread (pv, sizeof (__u8), 1, stdin)
 #define fread16(pv) fread (pv, sizeof (__u16), 1, stdin)
 #define fread32(pv) fread (pv, sizeof (__u32), 1, stdin)
 #define fread64(pv) fread (pv, sizeof (__u64), 1, stdin)
 
-
 #define fwrite_le16(pv)\
 {\
     __u16 tmp = cpu_to_le16(*(pv));\
@@ -209,30 +197,29 @@ if (fwrite (pv, sizeof (__u64), 1, stdout) != 1)\
 sent_bytes += 8;\
 }
 
-
 struct debugreiserfs_data {
-    int mode; /* DO_DUMP | DO_PACK | DO_CORRUPT_ONE... */
+	int mode;		/* DO_DUMP | DO_PACK | DO_CORRUPT_ONE... */
 #define USED_BLOCKS 	1
 #define EXTERN_BITMAP 	2
 #define ALL_BLOCKS 	3
 #define UNUSED_BLOCKS 	4
 
-	int scan_area; /* for -p, -s and -n */
-    char * input_bitmap; /* when ->scan_area is set to EXTERN_BITMAP */
-    reiserfs_bitmap_t * bitmap; /* bitmap is read from ->input_bitmap */
-    unsigned long block; /* set by -B. this is a must for -C, option for -p and -d */
-    char * pattern; /* for -n */
-    char * device_name;
-    char * journal_device_name; /* for -j */
-    char * map_file; /* for -n, -N and -f */
-    char * recovery_file; /* for -r */
-
-    unsigned long options; /* -q only yet*/
-    int JJ;
-  /* log file name and handle */
-    char * log_file_name;
-    FILE * log ;
-    
+	int scan_area;		/* for -p, -s and -n */
+	char *input_bitmap;	/* when ->scan_area is set to EXTERN_BITMAP */
+	reiserfs_bitmap_t *bitmap;	/* bitmap is read from ->input_bitmap */
+	unsigned long block;	/* set by -B. this is a must for -C, option for -p and -d */
+	char *pattern;		/* for -n */
+	char *device_name;
+	char *journal_device_name;	/* for -j */
+	char *map_file;		/* for -n, -N and -f */
+	char *recovery_file;	/* for -r */
+
+	unsigned long options;	/* -q only yet */
+	int JJ;
+	/* log file name and handle */
+	char *log_file_name;
+	FILE *log;
+
 };
 
 #define data(fs) ((struct debugreiserfs_data *)((fs)->fs_vp))
@@ -251,33 +238,33 @@ struct debugreiserfs_data {
 #define be_quiet(fs)  (data(fs)->options & BE_QUIET)
 
 /* stat.c */
-void do_stat (reiserfs_filsys_t * fs);
+void do_stat(reiserfs_filsys_t *fs);
 
 /* corruption.c */
-void do_corrupt_one_block (reiserfs_filsys_t * fs, char * fline);
-void do_leaves_corruption (reiserfs_filsys_t * fs, unsigned long nr_leaves_cr);
-void do_bitmap_corruption (reiserfs_filsys_t * fs);
-void do_fs_random_corrupt (reiserfs_filsys_t * fs);
+void do_corrupt_one_block(reiserfs_filsys_t *fs, char *fline);
+void do_leaves_corruption(reiserfs_filsys_t *fs, unsigned long nr_leaves_cr);
+void do_bitmap_corruption(reiserfs_filsys_t *fs);
+void do_fs_random_corrupt(reiserfs_filsys_t *fs);
 
 /* recover.c */
-void do_recover (reiserfs_filsys_t * fs);
+void do_recover(reiserfs_filsys_t *fs);
 
 /* scan.c */
-void do_scan (reiserfs_filsys_t * fs);
+void do_scan(reiserfs_filsys_t *fs);
 
 /* journal.c */
-void scan_journal (reiserfs_filsys_t * fs);
+void scan_journal(reiserfs_filsys_t *fs);
 
 /* unpack.c */
 extern int do_unpack(char *host, char *j_filename, char *filename, int verbose);
 
-void print_map(reiserfs_filsys_t * fs);
+void print_map(reiserfs_filsys_t *fs);
 
 struct saved_item {
-    struct item_head si_ih;
-    unsigned long si_block;
-    int si_item_num, si_entry_pos;
-    struct saved_item *si_next; /* list of items having the same key */
+	struct item_head si_ih;
+	unsigned long si_block;
+	int si_item_num, si_entry_pos;
+	struct saved_item *si_next;	/* list of items having the same key */
 };
 
 /*
@@ -289,6 +276,3 @@ struct saved_item {
    fill-column: 80
    End:
 */
-
-
-
diff --git a/debugreiserfs/pack.c b/debugreiserfs/pack.c
index cedae26..fddc935 100644
--- a/debugreiserfs/pack.c
+++ b/debugreiserfs/pack.c
@@ -5,195 +5,174 @@
 
 #include "debugreiserfs.h"
 
-
-
 /* counters for each kind of blocks */
-unsigned int packed,
-    packed_leaves,
-    full_blocks,
-    having_ih_array, /* blocks with broken block head */
-    bad_leaves, /* failed to compress */
-    internals,
-    descs,
-    others;
+unsigned int packed, packed_leaves, full_blocks, having_ih_array,	/* blocks with broken block head */
+ bad_leaves,			/* failed to compress */
+ internals, descs, others;
 
-reiserfs_bitmap_t * what_to_pack;
+reiserfs_bitmap_t *what_to_pack;
 
 /* these are to calculate compression */
-unsigned long sent_bytes; /* how many bytes sent to stdout */
-unsigned long had_to_be_sent; /* how many bytes were to be sent */
-
+unsigned long sent_bytes;	/* how many bytes sent to stdout */
+unsigned long had_to_be_sent;	/* how many bytes were to be sent */
 
-inline void set_pi_type( struct packed_item *pi, __u32 val )
+inline void set_pi_type(struct packed_item *pi, __u32 val)
 {
-    set_bit_field_XX (32, pi, val, 0, 2);
+	set_bit_field_XX(32, pi, val, 0, 2);
 }
 
-
-inline __u32 get_pi_type( const struct packed_item *pi )
+inline __u32 get_pi_type(const struct packed_item *pi)
 {
-    get_bit_field_XX (32, pi, 0, 2);
+	get_bit_field_XX(32, pi, 0, 2);
 }
 
-
-inline void set_pi_mask( struct packed_item *pi, __u32 val )
+inline void set_pi_mask(struct packed_item *pi, __u32 val)
 {
-    set_bit_field_XX (32, pi, val, 2, 18);
+	set_bit_field_XX(32, pi, val, 2, 18);
 }
 
-
-__u32 get_pi_mask( const struct packed_item *pi )
+__u32 get_pi_mask(const struct packed_item *pi)
 {
-    get_bit_field_XX (32, pi, 2, 18);
+	get_bit_field_XX(32, pi, 2, 18);
 }
 
-
-inline void set_pi_item_len( struct packed_item *pi, __u32 val )
+inline void set_pi_item_len(struct packed_item *pi, __u32 val)
 {
-    set_bit_field_XX (32, pi, val, 20, 12);
+	set_bit_field_XX(32, pi, val, 20, 12);
 }
 
-
-inline __u32 get_pi_item_len( const struct packed_item *pi )
+inline __u32 get_pi_item_len(const struct packed_item *pi)
 {
-    get_bit_field_XX (32, pi, 20, 12);
+	get_bit_field_XX(32, pi, 20, 12);
 }
 
-
-static void pack_ih (struct packed_item * pi, struct item_head * ih)
+static void pack_ih(struct packed_item *pi, struct item_head *ih)
 {
-    __u32 v32;
-    __u16 v16;
-
-    /* send packed item head first */
-    fwrite (pi, sizeof (*pi), 1, stdout);
-    sent_bytes += sizeof (*pi);
-
-    /* sen key components which are to be sent */
-    if (get_pi_mask(pi) & DIR_ID) {
-	v32 = get_key_dirid (&ih->ih_key);
-	fwrite_le32 (&v32);
-    }
-
-    if (get_pi_mask(pi) & OBJECT_ID) {
-	v32 = get_key_objectid (&ih->ih_key);
-	fwrite_le32 (&v32);
-    }
-
-    if (get_pi_mask(pi) & OFFSET_BITS_64) {
-	__u64 offset;
-
-	offset = get_offset (&ih->ih_key);
-	fwrite_le64 (&offset);
-    }
-
-    if (get_pi_mask(pi) & OFFSET_BITS_32) {
-	__u32 offset;
-
-	offset = get_offset (&ih->ih_key);
-	fwrite_le32 (&offset);
-    }
-
-    if (get_pi_mask(pi) & IH_FREE_SPACE) {
-	v16 = get_ih_entry_count (ih);
-	fwrite_le16 (&v16);
-    }
-
-    if (get_pi_mask(pi) & IH_FORMAT) {
-	/* fixme */
-	fwrite16 (&ih->ih_format);
-    }
-}
+	__u32 v32;
+	__u16 v16;
 
+	/* send packed item head first */
+	fwrite(pi, sizeof(*pi), 1, stdout);
+	sent_bytes += sizeof(*pi);
 
-static void pack_direct (struct packed_item * pi, struct buffer_head * bh, 
-			 struct item_head * ih)
-{
-    if (get_ih_free_space (ih) != 0xffff)
-	/* ih_free_space has unexpected value */
-        set_pi_mask (pi, get_pi_mask (pi) | IH_FREE_SPACE);
+	/* sen key components which are to be sent */
+	if (get_pi_mask(pi) & DIR_ID) {
+		v32 = get_key_dirid(&ih->ih_key);
+		fwrite_le32(&v32);
+	}
 
-    if (get_pi_mask(pi) & SAFE_LINK)
-	set_key_dirid(&ih->ih_key, d32_get((__u32 *)B_I_PITEM (bh, ih), 0) );
+	if (get_pi_mask(pi) & OBJECT_ID) {
+		v32 = get_key_objectid(&ih->ih_key);
+		fwrite_le32(&v32);
+	}
+
+	if (get_pi_mask(pi) & OFFSET_BITS_64) {
+		__u64 offset;
+
+		offset = get_offset(&ih->ih_key);
+		fwrite_le64(&offset);
+	}
+
+	if (get_pi_mask(pi) & OFFSET_BITS_32) {
+		__u32 offset;
+
+		offset = get_offset(&ih->ih_key);
+		fwrite_le32(&offset);
+	}
+
+	if (get_pi_mask(pi) & IH_FREE_SPACE) {
+		v16 = get_ih_entry_count(ih);
+		fwrite_le16(&v16);
+	}
 
-    /* send key components which are to be sent */
-    pack_ih (pi, ih);
+	if (get_pi_mask(pi) & IH_FORMAT) {
+		/* fixme */
+		fwrite16(&ih->ih_format);
+	}
 }
 
+static void pack_direct(struct packed_item *pi, struct buffer_head *bh,
+			struct item_head *ih)
+{
+	if (get_ih_free_space(ih) != 0xffff)
+		/* ih_free_space has unexpected value */
+		set_pi_mask(pi, get_pi_mask(pi) | IH_FREE_SPACE);
+
+	if (get_pi_mask(pi) & SAFE_LINK)
+		set_key_dirid(&ih->ih_key,
+			      d32_get((__u32 *) B_I_PITEM(bh, ih), 0));
+
+	/* send key components which are to be sent */
+	pack_ih(pi, ih);
+}
 
 /* if there is at least one extent longer than 2 - it is worth packing */
-static int should_pack_indirect (__u32 * ind_item, int unfm_num)
+static int should_pack_indirect(__u32 * ind_item, int unfm_num)
 {
-    int i, len;
-
-    for (i = 1, len = 1; i < unfm_num; i ++) {
-	if ((d32_get(ind_item, i) == 0 && d32_get(ind_item, i - 1) == 0) ||
-	    d32_get(ind_item, i) == d32_get(ind_item, i - 1) + 1) 
-	{
-	    len ++;
-	    if (len > 2)
-		return 1;
-	} else {
-	    /* sequence of blocks or hole broke */
-	    len = 1;
+	int i, len;
+
+	for (i = 1, len = 1; i < unfm_num; i++) {
+		if ((d32_get(ind_item, i) == 0 && d32_get(ind_item, i - 1) == 0)
+		    || d32_get(ind_item, i) == d32_get(ind_item, i - 1) + 1) {
+			len++;
+			if (len > 2)
+				return 1;
+		} else {
+			/* sequence of blocks or hole broke */
+			len = 1;
+		}
 	}
-    }
-    return 0;
+	return 0;
 }
 
-
 /* indirect item can be either packed using "extents" (when it is
    worth doing) or be stored as is. Size of item in packed form is not
    stored. Unpacking will stop when full item length is reached */
-static void pack_indirect (struct packed_item * pi, struct buffer_head * bh, 
-			   struct item_head * ih)
+static void pack_indirect(struct packed_item *pi, struct buffer_head *bh,
+			  struct item_head *ih)
 {
-    unsigned int i;
-    __u32 * ind_item;
-    __u16 len;
-
+	unsigned int i;
+	__u32 *ind_item;
+	__u16 len;
 
-    if (get_ih_entry_count (ih))
-        set_pi_mask (pi, get_pi_mask (pi) | IH_FREE_SPACE);
+	if (get_ih_entry_count(ih))
+		set_pi_mask(pi, get_pi_mask(pi) | IH_FREE_SPACE);
 
-    ind_item = (__u32 *)B_I_PITEM (bh, ih);
-    if (!should_pack_indirect (ind_item, I_UNFM_NUM (ih)))
-        set_pi_mask (pi, get_pi_mask (pi) | WHOLE_INDIRECT);
+	ind_item = (__u32 *) B_I_PITEM(bh, ih);
+	if (!should_pack_indirect(ind_item, I_UNFM_NUM(ih)))
+		set_pi_mask(pi, get_pi_mask(pi) | WHOLE_INDIRECT);
 
+	if (get_pi_mask(pi) & SAFE_LINK)
+		set_key_dirid(&ih->ih_key, d32_get(ind_item, 0));
 
-    if (get_pi_mask(pi) & SAFE_LINK)
-	set_key_dirid(&ih->ih_key, d32_get(ind_item, 0));
+	pack_ih(pi, ih);
 
-    pack_ih (pi, ih);
+	if (get_pi_mask(pi) & SAFE_LINK)
+		return;
 
-    if (get_pi_mask(pi) & SAFE_LINK)
-        return;
-
-    if (get_pi_mask(pi) & WHOLE_INDIRECT) {
-	fwrite (ind_item, get_ih_item_len (ih), 1, stdout);
-	sent_bytes += get_ih_item_len (ih);
-	return;
-    }
-
-    fwrite32 (&ind_item [0]);
+	if (get_pi_mask(pi) & WHOLE_INDIRECT) {
+		fwrite(ind_item, get_ih_item_len(ih), 1, stdout);
+		sent_bytes += get_ih_item_len(ih);
+		return;
+	}
 
-    for (i = 1, len = 1; i < I_UNFM_NUM (ih); i ++) {
-	if ((d32_get(ind_item, i) == 0 && d32_get(ind_item, i - 1) == 0)  || 
-	    d32_get(ind_item, i) == d32_get(ind_item, i - 1) + 1) 
-	{
-	    len ++;
-	} else {
-	    fwrite_le16 (&len);
-	    fwrite32 ((char *)(ind_item + i));
-	    len = 1;
+	fwrite32(&ind_item[0]);
+
+	for (i = 1, len = 1; i < I_UNFM_NUM(ih); i++) {
+		if ((d32_get(ind_item, i) == 0 && d32_get(ind_item, i - 1) == 0)
+		    || d32_get(ind_item, i) == d32_get(ind_item, i - 1) + 1) {
+			len++;
+		} else {
+			fwrite_le16(&len);
+			fwrite32((char *)(ind_item + i));
+			len = 1;
+		}
 	}
-    }
-    fwrite_le16 (&len);
+	fwrite_le16(&len);
 
-    return;
+	return;
 }
 
-
 /* directory item is packed:
    entry count - 16 bits
    for each entry
@@ -205,539 +184,549 @@ static void pack_indirect (struct packed_item * pi, struct buffer_head * bh,
 		maybe gencounter (16)
 		maybe deh_state (16)
 */
-static void pack_direntry (reiserfs_filsys_t * fs, struct packed_item * pi,
-			   struct buffer_head * bh,
-			   struct item_head * ih)
+static void pack_direntry(reiserfs_filsys_t *fs, struct packed_item *pi,
+			  struct buffer_head *bh, struct item_head *ih)
 {
-    int i;
-    struct reiserfs_de_head * deh;
-    struct packed_dir_entry pe;
-    __u16 entry_count, gen_counter;
-
-
-    set_pi_mask (pi, get_pi_mask (pi) | IH_ENTRY_COUNT);
-
-    /* send item_head components which are to be sent */
-    pack_ih (pi, ih);
-
-    /* entry count is sent unconditionally */
-    entry_count = get_ih_entry_count (ih);
-
-    deh = B_I_DEH (bh, ih);
-    for (i = 0; i < entry_count; i ++, deh ++) {
-	pe.entrylen = entry_length (ih, deh, i);
-	pe.mask = 0;
-	if (get_deh_dirid (deh) != get_key_objectid (&ih->ih_key))
-	    /* entry points to name of another directory, store deh_dir_id */
-	    pe.mask |= HAS_DIR_ID;
-
-	gen_counter = GET_GENERATION_NUMBER (get_deh_offset (deh));
-	if (gen_counter != 0)
-	    /* store generation counter if it is != 0 */
-	    pe.mask |= HAS_GEN_COUNTER;
-
-	if (get_deh_state (deh) != 4)
-	    /* something unusual in deh_state. Store it */
-	    pe.mask |= HAS_STATE;
-
-	fwrite8 (&pe.mask);
-	fwrite_le16 (&pe.entrylen);
-	fwrite (name_in_entry (deh, i), pe.entrylen, 1, stdout);
-	sent_bytes += pe.entrylen;
-	fwrite32 (&(deh->deh2_objectid));
-	
-	if (pe.mask & HAS_DIR_ID)
-	    fwrite32 (&deh->deh2_dir_id);
-
-	if (pe.mask & HAS_GEN_COUNTER)
-	    fwrite_le16 (&gen_counter);
-
-	if (pe.mask & HAS_STATE)
-	    fwrite16 (&deh->deh2_state);
-    }
+	int i;
+	struct reiserfs_de_head *deh;
+	struct packed_dir_entry pe;
+	__u16 entry_count, gen_counter;
+
+	set_pi_mask(pi, get_pi_mask(pi) | IH_ENTRY_COUNT);
+
+	/* send item_head components which are to be sent */
+	pack_ih(pi, ih);
+
+	/* entry count is sent unconditionally */
+	entry_count = get_ih_entry_count(ih);
+
+	deh = B_I_DEH(bh, ih);
+	for (i = 0; i < entry_count; i++, deh++) {
+		pe.entrylen = entry_length(ih, deh, i);
+		pe.mask = 0;
+		if (get_deh_dirid(deh) != get_key_objectid(&ih->ih_key))
+			/* entry points to name of another directory, store deh_dir_id */
+			pe.mask |= HAS_DIR_ID;
+
+		gen_counter = GET_GENERATION_NUMBER(get_deh_offset(deh));
+		if (gen_counter != 0)
+			/* store generation counter if it is != 0 */
+			pe.mask |= HAS_GEN_COUNTER;
+
+		if (get_deh_state(deh) != 4)
+			/* something unusual in deh_state. Store it */
+			pe.mask |= HAS_STATE;
+
+		fwrite8(&pe.mask);
+		fwrite_le16(&pe.entrylen);
+		fwrite(name_in_entry(deh, i), pe.entrylen, 1, stdout);
+		sent_bytes += pe.entrylen;
+		fwrite32(&(deh->deh2_objectid));
+
+		if (pe.mask & HAS_DIR_ID)
+			fwrite32(&deh->deh2_dir_id);
+
+		if (pe.mask & HAS_GEN_COUNTER)
+			fwrite_le16(&gen_counter);
+
+		if (pe.mask & HAS_STATE)
+			fwrite16(&deh->deh2_state);
+	}
 }
 
-
-static void pack_stat_data (struct packed_item * pi, struct buffer_head * bh,
-			    struct item_head * ih)
+static void pack_stat_data(struct packed_item *pi, struct buffer_head *bh,
+			   struct item_head *ih)
 {
-    if (get_ih_free_space (ih) != 0xffff)
-	/* ih_free_space has unexpected value */
-        set_pi_mask (pi, get_pi_mask (pi) | IH_FREE_SPACE);
-
-    if (stat_data_v1 (ih)) {
-	/* for old stat data: we take
-	   mode - 16 bits
-	   nlink - 16 bits
-	   size - 32 bits
-	   blocks/rdev - 32 bits
-	   maybe first_direct byte 32 bits
-	*/
-	struct stat_data_v1 * sd_v1;
-
-	sd_v1 = (struct stat_data_v1 *)B_I_PITEM (bh, ih);
-	if (sd_v1->sd_first_direct_byte != 0xffffffff) /* ok if -1 */
-            set_pi_mask (pi, get_pi_mask (pi) | WITH_SD_FIRST_DIRECT_BYTE);
-
-
-	pack_ih (pi, ih);
-	
-	fwrite16 (&sd_v1->sd_mode);
-	fwrite16 (&sd_v1->sd_nlink);
-	fwrite32 (&sd_v1->sd_size);
-	fwrite32 (&sd_v1->u.sd_blocks);
-
-	if (get_pi_mask(pi) & WITH_SD_FIRST_DIRECT_BYTE)
-	    fwrite32 (&sd_v1->sd_first_direct_byte);
-    } else {
-	/* for new stat data
-	   mode - 16 bits
-	   nlink in either 16 or 32 bits
-	   size in either 32 or 64 bits
-	   blocks - 32 bits
-	*/
-	struct stat_data * sd;
-        /* these will maintain disk-order values */
-	__u16 nlink16;
-	__u32 nlink32, size32;
-	__u64 size64;
-
-	sd = (struct stat_data *)B_I_PITEM (bh, ih);
-	if (sd_v2_nlink (sd) > 0xffff) {
-            set_pi_mask (pi, get_pi_mask (pi) | NLINK_BITS_32);
-	    nlink32 = sd->sd_nlink;
-	} else {
-            /* This is required to deal with big endian systems */
-	    nlink16 = cpu_to_le16 ((__u16)sd_v2_nlink (sd));
-	}
-	if (sd_v2_size (sd) > 0xffffffff) {
-            set_pi_mask (pi, get_pi_mask (pi) | SIZE_BITS_64);
-	    size64 = sd->sd_size;
-	} else {
-            /* This is required to deal with big endian systems */
-	    size32 = cpu_to_le32 ((__u32)sd_v2_size (sd));
-	}
-
-
-	pack_ih (pi, ih);
-
-	fwrite16 (&sd->sd_mode);
-
-	if (get_pi_mask (pi) & NLINK_BITS_32) {
-	    fwrite32 (&nlink32);
+	if (get_ih_free_space(ih) != 0xffff)
+		/* ih_free_space has unexpected value */
+		set_pi_mask(pi, get_pi_mask(pi) | IH_FREE_SPACE);
+
+	if (stat_data_v1(ih)) {
+		/* for old stat data: we take
+		   mode - 16 bits
+		   nlink - 16 bits
+		   size - 32 bits
+		   blocks/rdev - 32 bits
+		   maybe first_direct byte 32 bits
+		 */
+		struct stat_data_v1 *sd_v1;
+
+		sd_v1 = (struct stat_data_v1 *)B_I_PITEM(bh, ih);
+		if (sd_v1->sd_first_direct_byte != 0xffffffff)	/* ok if -1 */
+			set_pi_mask(pi,
+				    get_pi_mask(pi) |
+				    WITH_SD_FIRST_DIRECT_BYTE);
+
+		pack_ih(pi, ih);
+
+		fwrite16(&sd_v1->sd_mode);
+		fwrite16(&sd_v1->sd_nlink);
+		fwrite32(&sd_v1->sd_size);
+		fwrite32(&sd_v1->u.sd_blocks);
+
+		if (get_pi_mask(pi) & WITH_SD_FIRST_DIRECT_BYTE)
+			fwrite32(&sd_v1->sd_first_direct_byte);
 	} else {
-	    fwrite16 (&nlink16);	
+		/* for new stat data
+		   mode - 16 bits
+		   nlink in either 16 or 32 bits
+		   size in either 32 or 64 bits
+		   blocks - 32 bits
+		 */
+		struct stat_data *sd;
+		/* these will maintain disk-order values */
+		__u16 nlink16;
+		__u32 nlink32, size32;
+		__u64 size64;
+
+		sd = (struct stat_data *)B_I_PITEM(bh, ih);
+		if (sd_v2_nlink(sd) > 0xffff) {
+			set_pi_mask(pi, get_pi_mask(pi) | NLINK_BITS_32);
+			nlink32 = sd->sd_nlink;
+		} else {
+			/* This is required to deal with big endian systems */
+			nlink16 = cpu_to_le16((__u16) sd_v2_nlink(sd));
+		}
+		if (sd_v2_size(sd) > 0xffffffff) {
+			set_pi_mask(pi, get_pi_mask(pi) | SIZE_BITS_64);
+			size64 = sd->sd_size;
+		} else {
+			/* This is required to deal with big endian systems */
+			size32 = cpu_to_le32((__u32) sd_v2_size(sd));
+		}
+
+		pack_ih(pi, ih);
+
+		fwrite16(&sd->sd_mode);
+
+		if (get_pi_mask(pi) & NLINK_BITS_32) {
+			fwrite32(&nlink32);
+		} else {
+			fwrite16(&nlink16);
+		}
+
+		if (get_pi_mask(pi) & SIZE_BITS_64) {
+			fwrite64(&size64);
+		} else {
+			fwrite32(&size32);
+		}
+
+		fwrite32(&sd->sd_blocks);
 	}
-
-	if (get_pi_mask (pi) & SIZE_BITS_64) {
-	    fwrite64 (&size64);
-	} else {
-	    fwrite32 (&size32);
-	}
-    
-	fwrite32 (&sd->sd_blocks);
-    }
 }
 
-
-static void pack_full_block (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static void pack_full_block(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    __u16 magic;
-    __u32 block;
+	__u16 magic;
+	__u32 block;
 
+	magic = FULL_BLOCK_START_MAGIC;
+	fwrite_le16(&magic);
 
-    magic = FULL_BLOCK_START_MAGIC;
-    fwrite_le16 (&magic);
+	block = bh->b_blocknr;
+	fwrite_le32(&block);
 
-    block = bh->b_blocknr;
-    fwrite_le32 (&block);
-    
-    fwrite (bh->b_data, fs->fs_blocksize, 1, stdout);
+	fwrite(bh->b_data, fs->fs_blocksize, 1, stdout);
 
-    sent_bytes += fs->fs_blocksize;
-    had_to_be_sent += fs->fs_blocksize;
+	sent_bytes += fs->fs_blocksize;
+	had_to_be_sent += fs->fs_blocksize;
 
-    full_blocks ++;
+	full_blocks++;
 }
 
-
 #if 0
 /* unformatted node pointer is considered bad when it points either to blocks
    of journal, bitmap blocks, super block or is transparently out of range of
    disk block numbers */
-static int check_unfm_ptr (reiserfs_filsys_t * fs, __u32 block)
+static int check_unfm_ptr(reiserfs_filsys_t *fs, __u32 block)
 {
-    if (block >= SB_BLOCK_COUNT (fs))
-        return 1;
+	if (block >= SB_BLOCK_COUNT(fs))
+		return 1;
 
-    if (not_data_block (fs, block))
-        return 1;
+	if (not_data_block(fs, block))
+		return 1;
 
-    return 0;
+	return 0;
 }
 #endif
 
 /* we only pack leaves which do not have any corruptions */
-static int can_pack_leaf (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static int can_pack_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    int i;
-    struct item_head * ih;
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < get_blkh_nr_items (B_BLK_HEAD (bh)); i ++, ih ++) {
-	if (is_it_bad_item (fs, ih, B_I_PITEM (bh, ih), 0/*check_unfm_ptr*/, 1/*bad dir*/))
-	    return 0;
-    }
-    return 1;
+	int i;
+	struct item_head *ih;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
+		if (is_it_bad_item
+		    (fs, ih, B_I_PITEM(bh, ih), 0 /*check_unfm_ptr */ ,
+		     1 /*bad dir */ ))
+			return 0;
+	}
+	return 1;
 }
 
-
 /* pack leaf only if all its items are correct: keys are correct,
    direntries are hashed properly and hash function is defined,
    indirect items are correct, stat data ?, */
-static void pack_leaf (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static void pack_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    int i;
-    struct item_head * ih;
-    struct packed_item pi;
-    __u16 v16;
-
-    if (!can_pack_leaf (fs, bh)) {
-	/* something looks suspicious in this leaf - pack whole block */
-	bad_leaves ++;
-	pack_full_block (fs, bh);
-	return;
-    }
+	int i;
+	struct item_head *ih;
+	struct packed_item pi;
+	__u16 v16;
+
+	if (!can_pack_leaf(fs, bh)) {
+		/* something looks suspicious in this leaf - pack whole block */
+		bad_leaves++;
+		pack_full_block(fs, bh);
+		return;
+	}
+
+	/* start magic in low 8 bits, hash code in high 8 bits */
+	v16 = (LEAF_START_MAGIC | (func2code(fs->fs_hash_function) << 8));
+	fwrite_le16(&v16);
 
-    /* start magic in low 8 bits, hash code in high 8 bits */
-    v16 = (LEAF_START_MAGIC | (func2code (fs->fs_hash_function) << 8));
-    fwrite_le16 (&v16);
-    
-    /* block number */
-    fwrite_le32 (&bh->b_blocknr);
+	/* block number */
+	fwrite_le32(&bh->b_blocknr);
 
-    /* item number */
-    v16 = get_blkh_nr_items (B_BLK_HEAD (bh));
-    fwrite_le16 (&v16);
+	/* item number */
+	v16 = get_blkh_nr_items(B_BLK_HEAD(bh));
+	fwrite_le16(&v16);
 
-    ih = B_N_PITEM_HEAD (bh, 0);
+	ih = B_N_PITEM_HEAD(bh, 0);
 
-    for (i = 0; i < v16; i ++, ih ++) {
+	for (i = 0; i < v16; i++, ih++) {
 #if 0
-	v32 = ITEM_START_MAGIC;
-	fwrite32 (&v32);
+		v32 = ITEM_START_MAGIC;
+		fwrite32(&v32);
 #endif
 
-        set_pi_mask (&pi, 0);
-        set_pi_item_len (&pi, get_ih_item_len (ih));
-        set_pi_type (&pi, get_type (&ih->ih_key));
-
-	// format
-	if (get_ih_key_format (ih) == KEY_FORMAT_2)
-            set_pi_mask( &pi, get_pi_mask(&pi) | NEW_FORMAT );
-
-	// k_dir_id
-	if (!i || (i && get_key_dirid (&ih->ih_key) != get_key_dirid (&(ih - 1)->ih_key))) {
-	    /* if item is first in the leaf or if previous item has different
-               k_dir_id - store it */
-            set_pi_mask (&pi, get_pi_mask (&pi) | DIR_ID);
-	}
-	// k_object_id
-	if (!i || (i && get_key_objectid (&ih->ih_key) != get_key_objectid (&(ih - 1)->ih_key))) {
-	    /* if item is first in the leaf or if previous item has different
-               k_objectid - store it */
-            set_pi_mask (&pi, get_pi_mask (&pi) | OBJECT_ID);
-	}
-
-	/* store offset if it is != 0 in 32 or 64 bits */
-	if (get_offset (&ih->ih_key)) {
-	    int send_offset = 1;
-
-	    if ((get_pi_mask (&pi) & DIR_ID) == 0 && (get_pi_mask (&pi) & OBJECT_ID) == 0) {
-		/* previous item is of the same object, so try to avoid
-                   sending k_offset */
-		if ((is_stat_data_ih (ih - 1) && get_offset (&ih->ih_key) == 1) ||
-		    (is_indirect_ih (ih - 1) && is_direct_ih (ih) && 
-		     get_offset (&(ih - 1)->ih_key) + get_bytes_number (ih - 1, fs->fs_blocksize) == get_offset (&ih->ih_key)))
-		    /* unpack can calculate offset itself */
-		    send_offset = 0;
-	    }
-	    if (send_offset) {
-		if (get_offset (&ih->ih_key) > 0xffffffffULL)
-                    set_pi_mask (&pi, get_pi_mask (&pi) | OFFSET_BITS_64);
+		set_pi_mask(&pi, 0);
+		set_pi_item_len(&pi, get_ih_item_len(ih));
+		set_pi_type(&pi, get_type(&ih->ih_key));
+
+		// format
+		if (get_ih_key_format(ih) == KEY_FORMAT_2)
+			set_pi_mask(&pi, get_pi_mask(&pi) | NEW_FORMAT);
+
+		// k_dir_id
+		if (!i
+		    || (i
+			&& get_key_dirid(&ih->ih_key) !=
+			get_key_dirid(&(ih - 1)->ih_key))) {
+			/* if item is first in the leaf or if previous item has different
+			   k_dir_id - store it */
+			set_pi_mask(&pi, get_pi_mask(&pi) | DIR_ID);
+		}
+		// k_object_id
+		if (!i
+		    || (i
+			&& get_key_objectid(&ih->ih_key) !=
+			get_key_objectid(&(ih - 1)->ih_key))) {
+			/* if item is first in the leaf or if previous item has different
+			   k_objectid - store it */
+			set_pi_mask(&pi, get_pi_mask(&pi) | OBJECT_ID);
+		}
+
+		/* store offset if it is != 0 in 32 or 64 bits */
+		if (get_offset(&ih->ih_key)) {
+			int send_offset = 1;
+
+			if ((get_pi_mask(&pi) & DIR_ID) == 0
+			    && (get_pi_mask(&pi) & OBJECT_ID) == 0) {
+				/* previous item is of the same object, so try to avoid
+				   sending k_offset */
+				if ((is_stat_data_ih(ih - 1)
+				     && get_offset(&ih->ih_key) == 1)
+				    || (is_indirect_ih(ih - 1)
+					&& is_direct_ih(ih)
+					&& get_offset(&(ih - 1)->ih_key) +
+					get_bytes_number(ih - 1,
+							 fs->fs_blocksize) ==
+					get_offset(&ih->ih_key)))
+					/* unpack can calculate offset itself */
+					send_offset = 0;
+			}
+			if (send_offset) {
+				if (get_offset(&ih->ih_key) > 0xffffffffULL)
+					set_pi_mask(&pi,
+						    get_pi_mask(&pi) |
+						    OFFSET_BITS_64);
+				else
+					set_pi_mask(&pi,
+						    get_pi_mask(&pi) |
+						    OFFSET_BITS_32);
+			}
+		}
+
+		/* ih key format is correct, check fsck_need field */
+		if (get_ih_flags(ih))
+			set_pi_mask(&pi, get_pi_mask(&pi) | IH_FORMAT);
+
+		if ((get_key_dirid(&ih->ih_key) == (__u32) - 1)
+		    && (get_ih_item_len(ih) == 4))
+			set_pi_mask(&pi, get_pi_mask(&pi) | SAFE_LINK);
+
+		if (is_direct_ih(ih)) {
+			pack_direct(&pi, bh, ih);
+		} else if (is_indirect_ih(ih))
+			pack_indirect(&pi, bh, ih);
+		else if (is_direntry_ih(ih))
+			pack_direntry(fs, &pi, bh, ih);
+		else if (is_stat_data_ih(ih))
+			pack_stat_data(&pi, bh, ih);
 		else
-                    set_pi_mask (&pi, get_pi_mask (&pi) | OFFSET_BITS_32);
-	    }
-	}
-
-	/* ih key format is correct, check fsck_need field */
-	if (get_ih_flags (ih))
-            set_pi_mask (&pi, get_pi_mask (&pi) | IH_FORMAT);
-
-	if ((get_key_dirid (&ih->ih_key) == (__u32)-1) && (get_ih_item_len (ih) == 4))
-            set_pi_mask (&pi, get_pi_mask (&pi) | SAFE_LINK);
-
-	if (is_direct_ih (ih)) {
-	    pack_direct (&pi, bh, ih);
-	} else if (is_indirect_ih (ih))
-	    pack_indirect (&pi, bh, ih);
-	else if (is_direntry_ih (ih))
-	    pack_direntry (fs, &pi, bh, ih);
-	else if (is_stat_data_ih (ih))
-	    pack_stat_data (&pi, bh, ih);
-	else
-	    die ("pack_leaf: unknown item found");
+			die("pack_leaf: unknown item found");
 #if 0
-	v32 = ITEM_END_MAGIC;
-	fwrite32 (&v32);
+		v32 = ITEM_END_MAGIC;
+		fwrite32(&v32);
 #endif
-    }
-
-    v16 = LEAF_END_MAGIC;
-    fwrite_le16 (&v16);
+	}
 
+	v16 = LEAF_END_MAGIC;
+	fwrite_le16(&v16);
 
-    had_to_be_sent += fs->fs_blocksize;
-    packed_leaves ++;
+	had_to_be_sent += fs->fs_blocksize;
+	packed_leaves++;
 
-    return;
+	return;
 }
 
-
-static int can_pack_internal (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static int can_pack_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    return 0;
+	return 0;
 }
 
-
 /* pack internal node as a full block */
-static void pack_internal (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static void pack_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    internals ++;
-    if (!can_pack_internal (fs, bh)) {
-	pack_full_block (fs, bh);
-	return;
-    }
+	internals++;
+	if (!can_pack_internal(fs, bh)) {
+		pack_full_block(fs, bh);
+		return;
+	}
 
-    reiserfs_panic ("pack_internal: packing code is not ready");
+	reiserfs_panic("pack_internal: packing code is not ready");
 }
 
-
 /* packed blocks are marked free in the bitmap*/
-static void send_block (reiserfs_filsys_t * fs, struct buffer_head * bh, int send_unknown)
+static void send_block(reiserfs_filsys_t *fs, struct buffer_head *bh,
+		       int send_unknown)
 {
-    int type;
-
-    packed ++;
-    type = who_is_this (bh->b_data, bh->b_size);
-    switch (type) {
-    case THE_LEAF:
-	pack_leaf (fs, bh);
-	break;
-
-    case HAS_IH_ARRAY:
-	having_ih_array ++;
-//	fprintf (stderr, "BROKEN BLOCK HEAD %lu\n", bh->b_blocknr);
-	pack_full_block (fs, bh);
-	break;
-	
-    case THE_INTERNAL:
-	pack_internal (fs, bh);
-	break;
-
-    default:
-	if (send_unknown)
-	    pack_full_block (fs, bh);
-	else
-	    packed --;
-	break;
-    }
-
+	int type;
+
+	packed++;
+	type = who_is_this(bh->b_data, bh->b_size);
+	switch (type) {
+	case THE_LEAF:
+		pack_leaf(fs, bh);
+		break;
+
+	case HAS_IH_ARRAY:
+		having_ih_array++;
+//      fprintf (stderr, "BROKEN BLOCK HEAD %lu\n", bh->b_blocknr);
+		pack_full_block(fs, bh);
+		break;
+
+	case THE_INTERNAL:
+		pack_internal(fs, bh);
+		break;
+
+	default:
+		if (send_unknown)
+			pack_full_block(fs, bh);
+		else
+			packed--;
+		break;
+	}
 
-    /* do not send one block twice */
-    reiserfs_bitmap_clear_bit (what_to_pack, bh->b_blocknr);
+	/* do not send one block twice */
+	reiserfs_bitmap_clear_bit(what_to_pack, bh->b_blocknr);
 }
 
-
 /* super block, journal, bitmaps */
-static void pack_frozen_data (reiserfs_filsys_t * fs)
+static void pack_frozen_data(reiserfs_filsys_t *fs)
 {
-    struct buffer_head * bh;
-    unsigned long block;
-    __u16 magic16;
-    int sent_journal_start_magic = 0;
-    unsigned int i;
-    
-    if (is_reiserfs_jr_magic_string(fs->fs_ondisk_sb) &&
-	get_jp_journal_dev(sb_jp(fs->fs_ondisk_sb)) &&
-	!journal_device_name(fs)) {
-	if (!user_confirmed (stderr,
-			     "\n File system has non-standard journal "
-			     "that hasn't been specified.\n"
-			     "Continue packing without journal? [N/Yes] (note need to type Yes):", "Yes\n"))
-	    exit (0);
-    }
-    
-    /* super block */
-    reiserfs_warning (stderr, "super block..");fflush (stderr);
-    send_block (fs, fs->fs_super_bh, 1/*send block even if its format is not determined */);
-    reiserfs_warning (stderr, "ok\nbitmaps..(%d).. ", reiserfs_fs_bmap_nr(fs));
-    fflush (stderr);
-
-    /* bitmaps */
-    block = fs->fs_super_bh->b_blocknr + 1;
-    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
-	bh = bread (fs->fs_dev, block, fs->fs_blocksize);
-	if (!bh) {
-	    fprintf (stderr, "pack_frozen_data: bread failed: %lu\n", block);
-	    continue;
+	struct buffer_head *bh;
+	unsigned long block;
+	__u16 magic16;
+	int sent_journal_start_magic = 0;
+	unsigned int i;
+
+	if (is_reiserfs_jr_magic_string(fs->fs_ondisk_sb) &&
+	    get_jp_journal_dev(sb_jp(fs->fs_ondisk_sb)) &&
+	    !journal_device_name(fs)) {
+		if (!user_confirmed(stderr,
+				    "\n File system has non-standard journal "
+				    "that hasn't been specified.\n"
+				    "Continue packing without journal? [N/Yes] (note need to type Yes):",
+				    "Yes\n"))
+			exit(0);
 	}
-	send_block (fs, bh, 1);
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8);
-	else
-	    block ++;	
-	brelse (bh);
-    }
-
-    /* journal */
-
-    if (get_jp_journal_dev (sb_jp (fs->fs_ondisk_sb))) {
-	/* non-standard journal is on a separate device */
-	    
-	if (journal_device_name (fs) && !reiserfs_journal_opened (fs))
-	    die ("Specified journal is not available. Specify it correctly or "
-		 "don't specify at all");
-	else if (!journal_device_name(fs)) 
-	    /* non-standard journal was not specified (that confirmed by user) -
-	       skipped packing journal */
-	    return;
-	else {
-	    magic16 = SEPARATED_JOURNAL_START_MAGIC;
-	    fwrite_le16 (&magic16);
-	    sent_journal_start_magic = 1;
+
+	/* super block */
+	reiserfs_warning(stderr, "super block..");
+	fflush(stderr);
+	send_block(fs, fs->fs_super_bh,
+		   1 /*send block even if its format is not determined */ );
+	reiserfs_warning(stderr, "ok\nbitmaps..(%d).. ",
+			 reiserfs_fs_bmap_nr(fs));
+	fflush(stderr);
+
+	/* bitmaps */
+	block = fs->fs_super_bh->b_blocknr + 1;
+	for (i = 0; i < reiserfs_fs_bmap_nr(fs); i++) {
+		bh = bread(fs->fs_dev, block, fs->fs_blocksize);
+		if (!bh) {
+			fprintf(stderr, "pack_frozen_data: bread failed: %lu\n",
+				block);
+			continue;
+		}
+		send_block(fs, bh, 1);
+		if (spread_bitmaps(fs))
+			block =
+			    (block / (fs->fs_blocksize * 8) +
+			     1) * (fs->fs_blocksize * 8);
+		else
+			block++;
+		brelse(bh);
 	}
-    }
-    block = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));
-    reiserfs_warning (stderr, "ok\njournal (from %lu to %lu)..",
-		      block, block + get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)));
-    fflush (stderr);
-    for (i = 0; i <= get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)); i ++) {
-	bh = bread (fs->fs_journal_dev, block + i, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (stderr, "could not read %lu, skipped\n", i);
-	    continue;
+
+	/* journal */
+
+	if (get_jp_journal_dev(sb_jp(fs->fs_ondisk_sb))) {
+		/* non-standard journal is on a separate device */
+
+		if (journal_device_name(fs) && !reiserfs_journal_opened(fs))
+			die("Specified journal is not available. Specify it correctly or " "don't specify at all");
+		else if (!journal_device_name(fs))
+			/* non-standard journal was not specified (that confirmed by user) -
+			   skipped packing journal */
+			return;
+		else {
+			magic16 = SEPARATED_JOURNAL_START_MAGIC;
+			fwrite_le16(&magic16);
+			sent_journal_start_magic = 1;
+		}
+	}
+	block = get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb));
+	reiserfs_warning(stderr, "ok\njournal (from %lu to %lu)..",
+			 block,
+			 block + get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)));
+	fflush(stderr);
+	for (i = 0; i <= get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)); i++) {
+		bh = bread(fs->fs_journal_dev, block + i, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(stderr,
+					 "could not read %lu, skipped\n", i);
+			continue;
+		}
+
+		send_block(fs, bh, 1);
+		brelse(bh);
+	}
+	if (sent_journal_start_magic) {
+		magic16 = SEPARATED_JOURNAL_END_MAGIC;
+		fwrite_le16(&magic16);
 	}
-	
-	send_block (fs, bh, 1);
-	brelse (bh);
-    }
-    if (sent_journal_start_magic) {
-	magic16 = SEPARATED_JOURNAL_END_MAGIC;
-	fwrite_le16 (&magic16);
-    }
-    reiserfs_warning (stderr, "ok\n");fflush (stderr);
-    reiserfs_warning (stderr, 
-		      "Super block, bitmaps, journal - %u blocks - done, %u blocks left\n",
-		      packed, reiserfs_bitmap_ones (what_to_pack));
+	reiserfs_warning(stderr, "ok\n");
+	fflush(stderr);
+	reiserfs_warning(stderr,
+			 "Super block, bitmaps, journal - %u blocks - done, %u blocks left\n",
+			 packed, reiserfs_bitmap_ones(what_to_pack));
 }
 
-
 /* pack all "not data blocks" and correct leaf */
-void pack_partition (reiserfs_filsys_t * fs)
+void pack_partition(reiserfs_filsys_t *fs)
 {
-    struct buffer_head * bh;
-    __u32 magic32;
-    __u16 blocksize;
-    __u16 magic16;
-    unsigned long done = 0, total;
-    unsigned int i;
-    
-
-    magic32 = REISERFS_SUPER_MAGIC;
-    fwrite_le32 (&magic32);
+	struct buffer_head *bh;
+	__u32 magic32;
+	__u16 blocksize;
+	__u16 magic16;
+	unsigned long done = 0, total;
+	unsigned int i;
 
-    blocksize = fs->fs_blocksize;
-    fwrite_le16 (&blocksize);
-    
+	magic32 = REISERFS_SUPER_MAGIC;
+	fwrite_le32(&magic32);
 
-    /* will get information about what is to be packed. Bits corresponding to
-       packed blocks will be cleared */
-    what_to_pack = input_bitmap(fs);
+	blocksize = fs->fs_blocksize;
+	fwrite_le16(&blocksize);
 
+	/* will get information about what is to be packed. Bits corresponding to
+	   packed blocks will be cleared */
+	what_to_pack = input_bitmap(fs);
 
-    /* super block, journal, bitmaps */
-    pack_frozen_data (fs);
+	/* super block, journal, bitmaps */
+	pack_frozen_data(fs);
 
+	/* what's left */
+	total = reiserfs_bitmap_ones(what_to_pack);
 
-    /* what's left */
-    total = reiserfs_bitmap_ones (what_to_pack);
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (!reiserfs_bitmap_test_bit(what_to_pack, i))
+			continue;
 
+		print_how_far(stderr, &done, total, 1, be_quiet(fs));
 
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	if (!reiserfs_bitmap_test_bit (what_to_pack, i))
-	    continue;
-	
-	print_how_far (stderr, &done, total, 1, be_quiet (fs));
+		bh = bread(fs->fs_dev, i, blocksize);
+		if (!bh) {
+			reiserfs_warning(stderr, "could not read block %lu\n",
+					 i);
+			continue;
+		}
 
-	bh = bread (fs->fs_dev, i, blocksize);
-	if (!bh) {
-	    reiserfs_warning (stderr, "could not read block %lu\n", i);
-	    continue;
+		send_block(fs, bh,
+			   0 /*do not send block of not determined format */ );
+		brelse(bh);
 	}
 
-	send_block (fs, bh, 0/*do not send block of not determined format */);
-	brelse (bh);
-    }
-
-    magic16 = END_MAGIC;
-    fwrite_le16 (&magic16);
-
-    fprintf (stderr, "\nPacked %u blocks:\n"
-	     "\tcompessed %u\n"
-	     "\tfull blocks %u\n"
-	     "\t\tleaves with broken block head %u\n"
-	     "\t\tcorrupted leaves %u\n"
-	     "\t\tinternals %u\n"
-	     "\t\tdescriptors %u\n",
-	     packed,
-	     packed_leaves, full_blocks, having_ih_array,
-	     bad_leaves, internals, descs);
-
-    fprintf (stderr, "data packed with ratio %.2f\n", (double)sent_bytes / had_to_be_sent);
+	magic16 = END_MAGIC;
+	fwrite_le16(&magic16);
+
+	fprintf(stderr, "\nPacked %u blocks:\n"
+		"\tcompessed %u\n"
+		"\tfull blocks %u\n"
+		"\t\tleaves with broken block head %u\n"
+		"\t\tcorrupted leaves %u\n"
+		"\t\tinternals %u\n"
+		"\t\tdescriptors %u\n",
+		packed,
+		packed_leaves, full_blocks, having_ih_array,
+		bad_leaves, internals, descs);
+
+	fprintf(stderr, "data packed with ratio %.2f\n",
+		(double)sent_bytes / had_to_be_sent);
 }
 
-
-
-void pack_one_block (reiserfs_filsys_t * fs, unsigned long block)
+void pack_one_block(reiserfs_filsys_t *fs, unsigned long block)
 {
-    __u32 magic32;
-    __u16 magic16;
-    struct buffer_head * bh;
+	__u32 magic32;
+	__u16 magic16;
+	struct buffer_head *bh;
 
-    // reiserfs magic
-    magic32 = REISERFS_SUPER_MAGIC;
-    fwrite_le32 (&magic32);
+	// reiserfs magic
+	magic32 = REISERFS_SUPER_MAGIC;
+	fwrite_le32(&magic32);
 
-    // blocksize
-    fwrite_le16 (&fs->fs_blocksize);
-    
-    bh = bread (fs->fs_dev, block, fs->fs_blocksize);
+	// blocksize
+	fwrite_le16(&fs->fs_blocksize);
 
-    if (!bh) 
-	return;
+	bh = bread(fs->fs_dev, block, fs->fs_blocksize);
 
-    if (who_is_this (bh->b_data, bh->b_size) == THE_LEAF)
-	pack_leaf (fs, bh);
-    else
-	pack_full_block (fs, bh);
+	if (!bh)
+		return;
 
-    brelse (bh);
+	if (who_is_this(bh->b_data, bh->b_size) == THE_LEAF)
+		pack_leaf(fs, bh);
+	else
+		pack_full_block(fs, bh);
 
-    // end magic
-    magic16 = END_MAGIC;
-    fwrite_le16 (&magic16);
+	brelse(bh);
 
-    fprintf (stderr, "Done\n");
-}
+	// end magic
+	magic16 = END_MAGIC;
+	fwrite_le16(&magic16);
 
+	fprintf(stderr, "Done\n");
+}
diff --git a/debugreiserfs/recover.c b/debugreiserfs/recover.c
index 2c26471..be930f1 100644
--- a/debugreiserfs/recover.c
+++ b/debugreiserfs/recover.c
@@ -5,7 +5,6 @@
 
 #include "debugreiserfs.h"
 
-
 #if 0
 
 /* this reads stdin and recover file of given key:  */
@@ -16,119 +15,139 @@
    ..
    then recover_file will read every block, look there specified file and put it into
 */
-void do_recover (reiserfs_filsys_t fs)
+void do_recover(reiserfs_filsys_t fs)
 {
-    char name [100];
-    char * line = 0;
-    int n = 0;
-    int fd;
-    struct reiserfs_key key = {0, 0, };
-    struct buffer_head * bh;
-    struct item_head * ih;
-    unsigned long block;
-    char code;
-    loff_t recovered = 0;
-    int i, j;
-    reiserfs_bitmap_t bitmap;
-    int used, not_used;
-
-    bitmap = reiserfs_create_bitmap (SB_BLOCK_COUNT (fs));
-    reiserfs_fetch_disk_bitmap (bitmap, fs);
-    /* we check how many blocks recoverd items point to are free or used */
-    used = 0;
-    not_used = 0;
-
-    fd = 0;
-    while (getline (&line, &n, stdin) != -1) {
-	if (line [0] == '#' || line [0] == '\n')
-	    continue;
-	switch (line [0]) {
-	case 'K':
-	    /* get a key of file which is to be recovered */
-	    if (sscanf (line, "%c %u %u\n", &code, &key.k_dir_id, &key.k_objectid) != 3) {
-		die ("recover_file: wrong input K format");
-	    }
-	    printf ("Recovering file (%u, %u)\n", key.k_dir_id, key.k_objectid);
-	    break;
-
-	case 'N':
-	    /* get a file name */
-	    recovered = 0;
-	    if (sscanf (line, "%c %s\n", &code, name) != 2) {
-		die ("recover_file: wrong input N format");
-	    }
-	    fd = open (name, O_RDWR | O_CREAT | O_EXCL, 0644);
-	    if (fd == -1)
-		die ("recover_file: could not create file %s: %s",
-		     name,strerror (errno));
-	    printf ("Recovering file %s..\n", name);
-	    break;
-
-	case 'B':
-	    if (!fd)
-		die ("recover_file: file name is not specified");
-	    if (sscanf (line, "%c %lu\n", &code, &block) != 2) {
-		die ("recover_file: wrong input B format");
-	    }
-	    bh = bread (fs->s_dev, block, fs->s_blocksize);
-	    if (!bh) {
-		printf ("reading block %lu failed\n", block);
-		continue;
-	    }
-
-	    printf ("working with block %lu..\n", block);
-
-	    ih = B_N_PITEM_HEAD (bh, 0);
-	    for (i = 0; i < node_item_number (bh); i ++, ih ++) {
-		__u32 * indirect;
-		struct buffer_head * tmp_bh;
-
-		if (!is_indirect_ih (ih) || key.k_dir_id != ih->ih_key.k_dir_id ||
-		    key.k_objectid != ih->ih_key.k_objectid)
-		    continue;
-
-		indirect = (__u32 *)B_I_PITEM (bh, ih);
-		for (j = 0; j < I_UNFM_NUM (ih); j ++) {
-		    block = le32_to_cpu (indirect [j]);
-		    if (!block)
+	char name[100];
+	char *line = 0;
+	int n = 0;
+	int fd;
+	struct reiserfs_key key = { 0, 0, };
+	struct buffer_head *bh;
+	struct item_head *ih;
+	unsigned long block;
+	char code;
+	loff_t recovered = 0;
+	int i, j;
+	reiserfs_bitmap_t bitmap;
+	int used, not_used;
+
+	bitmap = reiserfs_create_bitmap(SB_BLOCK_COUNT(fs));
+	reiserfs_fetch_disk_bitmap(bitmap, fs);
+	/* we check how many blocks recoverd items point to are free or used */
+	used = 0;
+	not_used = 0;
+
+	fd = 0;
+	while (getline(&line, &n, stdin) != -1) {
+		if (line[0] == '#' || line[0] == '\n')
 			continue;
-		    tmp_bh = bread (fs->s_dev, block, fs->s_blocksize);
-		    if (!tmp_bh) {
-			printf ("reading block %Lu failed\n", (loff_t)block * fs->s_blocksize);
-			continue;
-		    }
-		    if (lseek64 (fd, get_offset (&ih->ih_key) + j * fs->s_blocksize - 1,
-				 SEEK_SET) == (loff_t)-1) {
-			printf ("llseek failed to pos %Ld\n", (loff_t)block * fs->s_blocksize);
-			brelse (tmp_bh);
-			continue;
-		    }
-		    if (reiserfs_bitmap_test_bit (bitmap, block))
-			used ++;
-		    else
-			not_used ++;
-		    /*printf ("block of file %Ld gets block %lu\n",
-		      (get_offset (&ih->ih_key) - 1) / fs->s_blocksize + j, block);*/
-		    if (write (fd, tmp_bh->b_data, tmp_bh->b_size) != tmp_bh->b_size) {
-			printf ("write failed to pos %Ld\n", (loff_t)block * fs->s_blocksize);
-			brelse (tmp_bh);
-			continue;
-		    }
-		    recovered += fs->s_blocksize;
-		    brelse (tmp_bh);
+		switch (line[0]) {
+		case 'K':
+			/* get a key of file which is to be recovered */
+			if (sscanf
+			    (line, "%c %u %u\n", &code, &key.k_dir_id,
+			     &key.k_objectid) != 3) {
+				die("recover_file: wrong input K format");
+			}
+			printf("Recovering file (%u, %u)\n", key.k_dir_id,
+			       key.k_objectid);
+			break;
+
+		case 'N':
+			/* get a file name */
+			recovered = 0;
+			if (sscanf(line, "%c %s\n", &code, name) != 2) {
+				die("recover_file: wrong input N format");
+			}
+			fd = open(name, O_RDWR | O_CREAT | O_EXCL, 0644);
+			if (fd == -1)
+				die("recover_file: could not create file %s: %s", name, strerror(errno));
+			printf("Recovering file %s..\n", name);
+			break;
+
+		case 'B':
+			if (!fd)
+				die("recover_file: file name is not specified");
+			if (sscanf(line, "%c %lu\n", &code, &block) != 2) {
+				die("recover_file: wrong input B format");
+			}
+			bh = bread(fs->s_dev, block, fs->s_blocksize);
+			if (!bh) {
+				printf("reading block %lu failed\n", block);
+				continue;
+			}
+
+			printf("working with block %lu..\n", block);
+
+			ih = B_N_PITEM_HEAD(bh, 0);
+			for (i = 0; i < node_item_number(bh); i++, ih++) {
+				__u32 *indirect;
+				struct buffer_head *tmp_bh;
+
+				if (!is_indirect_ih(ih)
+				    || key.k_dir_id != ih->ih_key.k_dir_id
+				    || key.k_objectid != ih->ih_key.k_objectid)
+					continue;
+
+				indirect = (__u32 *) B_I_PITEM(bh, ih);
+				for (j = 0; j < I_UNFM_NUM(ih); j++) {
+					block = le32_to_cpu(indirect[j]);
+					if (!block)
+						continue;
+					tmp_bh =
+					    bread(fs->s_dev, block,
+						  fs->s_blocksize);
+					if (!tmp_bh) {
+						printf
+						    ("reading block %Lu failed\n",
+						     (loff_t) block *
+						     fs->s_blocksize);
+						continue;
+					}
+					if (lseek64
+					    (fd,
+					     get_offset(&ih->ih_key) +
+					     j * fs->s_blocksize - 1,
+					     SEEK_SET) == (loff_t) - 1) {
+						printf
+						    ("llseek failed to pos %Ld\n",
+						     (loff_t) block *
+						     fs->s_blocksize);
+						brelse(tmp_bh);
+						continue;
+					}
+					if (reiserfs_bitmap_test_bit
+					    (bitmap, block))
+						used++;
+					else
+						not_used++;
+					/*printf ("block of file %Ld gets block %lu\n",
+					   (get_offset (&ih->ih_key) - 1) / fs->s_blocksize + j, block); */
+					if (write
+					    (fd, tmp_bh->b_data,
+					     tmp_bh->b_size) !=
+					    tmp_bh->b_size) {
+						printf
+						    ("write failed to pos %Ld\n",
+						     (loff_t) block *
+						     fs->s_blocksize);
+						brelse(tmp_bh);
+						continue;
+					}
+					recovered += fs->s_blocksize;
+					brelse(tmp_bh);
+				}
+			}
+			brelse(bh);
+			break;
 		}
-	    }
-	    brelse (bh);
-	    break;
 	}
-    }
-    printf ("recover_file: %Ld bytes recovered of file %s, key %u %u, %d blocks are free and %d are used\n",
-	    recovered, name, key.k_dir_id, key.k_objectid, not_used, used);
+	printf
+	    ("recover_file: %Ld bytes recovered of file %s, key %u %u, %d blocks are free and %d are used\n",
+	     recovered, name, key.k_dir_id, key.k_objectid, not_used, used);
 }
 #endif
 
-
-
 /* read a file containing map of one or more files and either recover
    them or just print info */
 /*
@@ -140,7 +159,6 @@ static void read_map (FILE * fp)
     __u32 ids [4];
     int do_recover = 0;
 
-
     buf = 0;
     while (1) {
 	if (fread (&v32, sizeof (v32), 1, fp) != 1)
@@ -215,8 +233,7 @@ static void read_map (FILE * fp)
     free (buf);
 }
 
-
-void do_recover (reiserfs_filsys_t * fs)
+void do_recover (reiserfs_filsys_t *fs)
 {
     FILE * fp;
 
@@ -242,148 +259,181 @@ void do_recover (reiserfs_filsys_t * fs)
 
 #include <limits.h>
 
-static long int get_answer(long int max) {
-    char *answer, *tmp;    
-    size_t n = 0;    
-    long int result = 0;
-
-    do {
-	printf("Which should be left?: ");
-	getline (&answer, &n, stdin);
-	result = strtol (answer, &tmp, 0);
-	if ((errno != ERANGE) && (result < max) && (result >= 0) &&
-	    (answer != tmp))
-	    break;
-    } while (1);
-    return result;
+static long int get_answer(long int max)
+{
+	char *answer, *tmp;
+	size_t n = 0;
+	long int result = 0;
+
+	do {
+		printf("Which should be left?: ");
+		getline(&answer, &n, stdin);
+		result = strtol(answer, &tmp, 0);
+		if ((errno != ERANGE) && (result < max) && (result >= 0) &&
+		    (answer != tmp))
+			break;
+	} while (1);
+	return result;
 }
 
-static void recover_items(FILE *fp, reiserfs_filsys_t * fs, FILE *target_file) {
-    struct buffer_head *bh, *bh_pointed;
-    struct item_head *ih;
-    struct saved_item item, *cur;
-    int size = sizeof(struct saved_item) - sizeof(struct saved_item *);
-    struct saved_item *map = NULL;
-    __u32 map_size = 0;
-    int start = -1;
-    unsigned int i, j;
-    __u64 offset = 0, length;
-    long int result = 0;
-    unsigned long unfm_ptr;
-
-    while (fread(&item, size, 1, fp) == 1) {
-	map_size += sizeof(struct saved_item);
-	map = realloc(map, map_size);
-	memcpy((void *)map + map_size - sizeof(struct saved_item), &item, size);
-    }
-    
-    for (i = 1, cur = map + 1; i <= map_size / sizeof(struct saved_item); i++, cur++) {
-	bh = bread (fs->fs_dev, (cur - 1)->si_block, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (fp, "bread failed\n");
-	    continue;
+static void recover_items(FILE * fp, reiserfs_filsys_t *fs, FILE * target_file)
+{
+	struct buffer_head *bh, *bh_pointed;
+	struct item_head *ih;
+	struct saved_item item, *cur;
+	int size = sizeof(struct saved_item) - sizeof(struct saved_item *);
+	struct saved_item *map = NULL;
+	__u32 map_size = 0;
+	int start = -1;
+	unsigned int i, j;
+	__u64 offset = 0, length;
+	long int result = 0;
+	unsigned long unfm_ptr;
+
+	while (fread(&item, size, 1, fp) == 1) {
+		map_size += sizeof(struct saved_item);
+		map = realloc(map, map_size);
+		memcpy((void *)map + map_size - sizeof(struct saved_item),
+		       &item, size);
 	}
 
-	if (i == map_size / sizeof(struct saved_item)) {
-	    if (start != -1) {
-		reiserfs_print_item(stdout, bh, B_N_PITEM_HEAD (bh, (cur - 1)->si_item_num));
-		result = get_answer(i - start) + start;
-	    } else {
-		result = i - 1;
-	    }
-	    
-	    start = -1;
-	} else if (is_direntry_ih(&(cur - 1)->si_ih) || is_stat_data_ih(&(cur - 1)->si_ih)) {
-	    brelse(bh);
-	    continue;
-	} else { 
-	    length = get_bytes_number(&(cur - 1)->si_ih, fs->fs_blocksize);
-	    if (offset < get_offset(&(cur - 1)->si_ih.ih_key) + 
-		get_bytes_number(&(cur - 1)->si_ih, fs->fs_blocksize))
-		offset = get_offset(&(cur - 1)->si_ih.ih_key) + (length ? length - 1 : 0);
-	
-	    if (offset >= get_offset(&cur->si_ih.ih_key)) {
-		/* Problem interval */
-		if (start == -1)
-		    start = i - 1;
-	    
-		printf("Problem item %d:\n", i - start - 1);
-		reiserfs_print_item(stdout, bh, B_N_PITEM_HEAD (bh, (cur - 1)->si_item_num));
-	    } else if (start != -1) {
-		/* problem interval finished */
-		printf("Problem item %d:\n", i - start - 1);
-		reiserfs_print_item(stdout, bh, B_N_PITEM_HEAD (bh, (cur - 1)->si_item_num));
-	    
-		result = get_answer((long int)i - start) + start;
-		start = -1;
-	    } else {
-		result = i - 1;
-	    }
-	}
-	brelse(bh);
-	
-	if (start != -1)
-	    continue;
+	for (i = 1, cur = map + 1; i <= map_size / sizeof(struct saved_item);
+	     i++, cur++) {
+		bh = bread(fs->fs_dev, (cur - 1)->si_block, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(fp, "bread failed\n");
+			continue;
+		}
 
-	printf("write %ld\n", result);
+		if (i == map_size / sizeof(struct saved_item)) {
+			if (start != -1) {
+				reiserfs_print_item(stdout, bh,
+						    B_N_PITEM_HEAD(bh,
+								   (cur -
+								    1)->
+								   si_item_num));
+				result = get_answer(i - start) + start;
+			} else {
+				result = i - 1;
+			}
+
+			start = -1;
+		} else if (is_direntry_ih(&(cur - 1)->si_ih)
+			   || is_stat_data_ih(&(cur - 1)->si_ih)) {
+			brelse(bh);
+			continue;
+		} else {
+			length =
+			    get_bytes_number(&(cur - 1)->si_ih,
+					     fs->fs_blocksize);
+			if (offset <
+			    get_offset(&(cur - 1)->si_ih.ih_key) +
+			    get_bytes_number(&(cur - 1)->si_ih,
+					     fs->fs_blocksize))
+				offset =
+				    get_offset(&(cur - 1)->si_ih.ih_key) +
+				    (length ? length - 1 : 0);
+
+			if (offset >= get_offset(&cur->si_ih.ih_key)) {
+				/* Problem interval */
+				if (start == -1)
+					start = i - 1;
+
+				printf("Problem item %d:\n", i - start - 1);
+				reiserfs_print_item(stdout, bh,
+						    B_N_PITEM_HEAD(bh,
+								   (cur -
+								    1)->
+								   si_item_num));
+			} else if (start != -1) {
+				/* problem interval finished */
+				printf("Problem item %d:\n", i - start - 1);
+				reiserfs_print_item(stdout, bh,
+						    B_N_PITEM_HEAD(bh,
+								   (cur -
+								    1)->
+								   si_item_num));
+
+				result =
+				    get_answer((long int)i - start) + start;
+				start = -1;
+			} else {
+				result = i - 1;
+			}
+		}
+		brelse(bh);
 
-	bh = bread (fs->fs_dev, (map + result)->si_block, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (fp, "bread failed\n");
-	    continue;
-	}
+		if (start != -1)
+			continue;
+
+		printf("write %ld\n", result);
 
-	fseek(target_file, get_offset(&(map + result)->si_ih.ih_key) - 1, SEEK_SET);
-	ih = B_N_PITEM_HEAD (bh, (map + result)->si_item_num);
-	if (is_direct_ih(ih)) {
-	    fwrite(B_I_PITEM(bh, ih), (map + result)->si_ih.ih2_item_len, 1, target_file);
-	} else if (is_indirect_ih(ih)) {
-	    for (j = 0; j < I_UNFM_NUM (ih); j ++) {
-		unfm_ptr = d32_get((__u32 *)B_I_PITEM(bh, ih), j);
-		if (!unfm_ptr) {
-		    fseek(target_file, fs->fs_blocksize, SEEK_CUR);
-		    continue;
+		bh = bread(fs->fs_dev, (map + result)->si_block,
+			   fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(fp, "bread failed\n");
+			continue;
 		}
-		bh_pointed = bread (fs->fs_dev, unfm_ptr, fs->fs_blocksize);
-		if (!bh_pointed) {
-		    reiserfs_warning (fp, "bread failed\n");
-		    continue;
+
+		fseek(target_file,
+		      get_offset(&(map + result)->si_ih.ih_key) - 1, SEEK_SET);
+		ih = B_N_PITEM_HEAD(bh, (map + result)->si_item_num);
+		if (is_direct_ih(ih)) {
+			fwrite(B_I_PITEM(bh, ih),
+			       (map + result)->si_ih.ih2_item_len, 1,
+			       target_file);
+		} else if (is_indirect_ih(ih)) {
+			for (j = 0; j < I_UNFM_NUM(ih); j++) {
+				unfm_ptr =
+				    d32_get((__u32 *) B_I_PITEM(bh, ih), j);
+				if (!unfm_ptr) {
+					fseek(target_file, fs->fs_blocksize,
+					      SEEK_CUR);
+					continue;
+				}
+				bh_pointed =
+				    bread(fs->fs_dev, unfm_ptr,
+					  fs->fs_blocksize);
+				if (!bh_pointed) {
+					reiserfs_warning(fp, "bread failed\n");
+					continue;
+				}
+				fwrite(bh_pointed->b_data, fs->fs_blocksize, 1,
+				       target_file);
+				brelse(bh_pointed);
+			}
 		}
-		fwrite(bh_pointed->b_data, fs->fs_blocksize, 1, target_file);
-		brelse(bh_pointed);
-	    }
+		brelse(bh);
 	}
-	brelse(bh);
-    }
 
-    free(map);
+	free(map);
 }
 
-void do_recover(reiserfs_filsys_t * fs) {
-    FILE *fp, *recovery;
+void do_recover(reiserfs_filsys_t *fs)
+{
+	FILE *fp, *recovery;
 
-    if (map_file (fs)) {
-	fp = fopen (map_file (fs), "r");
-	if (fp == 0) {
-	    reiserfs_warning (stderr, "fopen failed: %m\n");
-	    return;
+	if (map_file(fs)) {
+		fp = fopen(map_file(fs), "r");
+		if (fp == 0) {
+			reiserfs_warning(stderr, "fopen failed: %m\n");
+			return;
+		}
+	} else {
+		reiserfs_warning(stderr, "Reading file map from stdin..\n");
+		fflush(stderr);
+		fp = stdin;
 	}
-    } else {
-	reiserfs_warning (stderr, "Reading file map from stdin..\n");
-	fflush (stderr);
-	fp = stdin;
-    }
 
-    if (!(recovery = fopen(recovery_file(fs), "w+"))) {
-	reiserfs_warning (stderr, "fopen failed: %m\n");
-	return;
-    }
+	if (!(recovery = fopen(recovery_file(fs), "w+"))) {
+		reiserfs_warning(stderr, "fopen failed: %m\n");
+		return;
+	}
 
-    
-    recover_items(fp, fs, recovery);
-    
-    if (fp != stdin)
-	fclose (fp);
-    
-    fclose(recovery);
+	recover_items(fp, fs, recovery);
+
+	if (fp != stdin)
+		fclose(fp);
+
+	fclose(recovery);
 }
diff --git a/debugreiserfs/scan.c b/debugreiserfs/scan.c
index 7ed6444..8463dc5 100644
--- a/debugreiserfs/scan.c
+++ b/debugreiserfs/scan.c
@@ -11,7 +11,6 @@
 #define obstack_chunk_alloc malloc
 #define obstack_chunk_free free
 
-
 /* -n pattern scans the area (on-disk bitmap, or all the device or extern
    bitmap) and looks for every name matching the pattern. All those names get
    stored in 'name_store' and are indexed by name (name_index) and by a key
@@ -23,247 +22,245 @@ struct obstack item_store;
 int saved_names;
 int saved_items;
 int skipped_names;
-void * key_index;
-void * name_index;
+void *key_index;
+void *name_index;
 
 regex_t pattern;
 
 struct saved_name {
-    unsigned int dirid; /* pointed object */
-    unsigned int objectid;
-    struct saved_name * first_name; /* pointer to name which points to the
-                                       same object and contains list of file
-                                       items */
-
-    unsigned int parent_dirid; /* parent directory */
-    unsigned int parent_objectid;
-    unsigned long block; /* where we saw the name for the first time */
-    unsigned short count; /* how many times the name appeared */
-
-    void * items;
-    struct saved_name * name_next; /* list of identical names */
-
-    unsigned short name_len;
-    char name[1];
+	unsigned int dirid;	/* pointed object */
+	unsigned int objectid;
+	struct saved_name *first_name;	/* pointer to name which points to the
+					   same object and contains list of file
+					   items */
+
+	unsigned int parent_dirid;	/* parent directory */
+	unsigned int parent_objectid;
+	unsigned long block;	/* where we saw the name for the first time */
+	unsigned short count;	/* how many times the name appeared */
+
+	void *items;
+	struct saved_name *name_next;	/* list of identical names */
+
+	unsigned short name_len;
+	char name[1];
 };
 
-
-
 /* attach item to every name in the list */
-static void store_item (struct saved_name * name, struct buffer_head * bh,
-			struct item_head * ih, int pos)
+static void store_item(struct saved_name *name, struct buffer_head *bh,
+		       struct item_head *ih, int pos)
 {
-    struct saved_item * new;
-    void * vp;
-    struct saved_item * item_in;
-
-    new = obstack_alloc (&item_store, sizeof (struct saved_item));
-    new->si_ih = *ih;
-    new->si_block = bh->b_blocknr;
-    new->si_item_num = ih - B_N_PITEM_HEAD (bh, 0);
-    new->si_next = 0;
-    new->si_entry_pos = pos;
-    
-    vp = tfind (new, &name->items, comp_keys);
-    if (vp) {
-	item_in = *(void **)vp;
-	/* add item to the end of list of items having this key */
-	while (1) {
-	    if (!item_in->si_next) {
-		item_in->si_next = new;
-		break;
-	    }
-	    item_in = item_in->si_next;
-	}
-    } else
-	tsearch (new, &name->items, comp_keys);
+	struct saved_item *new;
+	void *vp;
+	struct saved_item *item_in;
+
+	new = obstack_alloc(&item_store, sizeof(struct saved_item));
+	new->si_ih = *ih;
+	new->si_block = bh->b_blocknr;
+	new->si_item_num = ih - B_N_PITEM_HEAD(bh, 0);
+	new->si_next = 0;
+	new->si_entry_pos = pos;
+
+	vp = tfind(new, &name->items, comp_keys);
+	if (vp) {
+		item_in = *(void **)vp;
+		/* add item to the end of list of items having this key */
+		while (1) {
+			if (!item_in->si_next) {
+				item_in->si_next = new;
+				break;
+			}
+			item_in = item_in->si_next;
+		}
+	} else
+		tsearch(new, &name->items, comp_keys);
 
-    saved_items ++;
+	saved_items++;
 }
 
-
-static int comp_names (const void * p1, const void * p2)
+static int comp_names(const void *p1, const void *p2)
 {
-    struct saved_name * name1, * name2;
+	struct saved_name *name1, *name2;
 
-    name1 = (struct saved_name *)p1;
-    name2 = (struct saved_name *)p2;
+	name1 = (struct saved_name *)p1;
+	name2 = (struct saved_name *)p2;
 
-    return strcmp (name1->name, name2->name);
+	return strcmp(name1->name, name2->name);
 }
 
-
-static int comp_pointed (const void * p1, const void * p2)
+static int comp_pointed(const void *p1, const void *p2)
 {
-    struct saved_name * name1, * name2;
+	struct saved_name *name1, *name2;
 
-    name1 = (struct saved_name *)p1;
-    name2 = (struct saved_name *)p2;
+	name1 = (struct saved_name *)p1;
+	name2 = (struct saved_name *)p2;
 
-    return comp_short_keys (&name1->dirid, &name2->dirid);
+	return comp_short_keys(&name1->dirid, &name2->dirid);
 }
 
-
 /* we consider name found only if it points to the same object and from the
    same directory */
-static int name_found (struct saved_name * name, struct saved_name ** name_in)
+static int name_found(struct saved_name *name, struct saved_name **name_in)
 {
-    void * vp;
-    struct saved_name * cur;
+	void *vp;
+	struct saved_name *cur;
 
-    vp = tfind (name, &name_index, comp_names);
-    if (!vp) {
-	*name_in = 0;
-	return 0;
-    }
+	vp = tfind(name, &name_index, comp_names);
+	if (!vp) {
+		*name_in = 0;
+		return 0;
+	}
+
+	*name_in = *(void **)vp;
 
-    *name_in =  *(void **)vp;
-
-    /* check every name in the list */
-    cur = *name_in;
-    while (cur) {
-	if (!not_of_one_file (&name->dirid, &cur->dirid) &&
-	    !not_of_one_file (&name->parent_dirid, &cur->parent_dirid)) 
-	{
-	    cur->count ++;
-	    *name_in = cur;
-	    return 1;
+	/* check every name in the list */
+	cur = *name_in;
+	while (cur) {
+		if (!not_of_one_file(&name->dirid, &cur->dirid) &&
+		    !not_of_one_file(&name->parent_dirid, &cur->parent_dirid)) {
+			cur->count++;
+			*name_in = cur;
+			return 1;
+		}
+		cur = cur->name_next;
 	}
-	cur = cur->name_next;
-    }
-    
-    return 0;
-}
 
+	return 0;
+}
 
 /* add key name is pointing to to the index of keys. If there was already name
    pointing to this key - add pointer to that name */
-static void add_key (struct saved_name * name)
+static void add_key(struct saved_name *name)
 {
-    void * vp;
-  
-    vp = tfind (name, &key_index, comp_pointed);
-    if (vp) {
-	/* */
-	name->first_name = *(void **)vp;
-    } else {
-	tsearch (name, &key_index, comp_pointed);
-    }
-}
+	void *vp;
 
+	vp = tfind(name, &key_index, comp_pointed);
+	if (vp) {
+		/* */
+		name->first_name = *(void **)vp;
+	} else {
+		tsearch(name, &key_index, comp_pointed);
+	}
+}
 
-static void add_name (struct saved_name * name, struct saved_name * name_in)
+static void add_name(struct saved_name *name, struct saved_name *name_in)
 {
-    if (name_in) {
-	/* add name to the end of list of identical names */
-	while (1) {
-	    if (!name_in->name_next) {
-		name_in->name_next = name;
-		break;
-	    }
-	    name_in = name_in->name_next;
+	if (name_in) {
+		/* add name to the end of list of identical names */
+		while (1) {
+			if (!name_in->name_next) {
+				name_in->name_next = name;
+				break;
+			}
+			name_in = name_in->name_next;
+		}
+	} else {
+		/* add name into name index */
+		tsearch(name, &name_index, comp_names);
 	}
-    } else {
-	/* add name into name index */
-	tsearch (name, &name_index, comp_names);
-    }
 }
 
-
 /* take each name matching to a given pattern, */
-static void scan_for_name (struct buffer_head * bh)
+static void scan_for_name(struct buffer_head *bh)
 {
-    int i, j, i_num;
-    struct item_head * ih;
-    struct reiserfs_de_head * deh;
-    int namelen;
-    char * name;
-    struct saved_name * new, *name_in;
-    char ch;
-    int retval;
-    int min_entry_size = 1;
-    int ih_entry_count = 0;
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    i_num = leaf_item_number_estimate(bh);
-    for (i = 0; i < i_num; i ++, ih ++) {
-	if (!is_direntry_ih (ih))
-	    continue;
-	if (is_it_bad_item (fs, ih, B_I_PITEM (bh, ih), 0, 1))
-	    continue;
-
-	deh = B_I_DEH (bh, ih);
-	
-        if ( (get_ih_entry_count (ih) > (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size))) ||
-            (get_ih_entry_count (ih) == 0))
-            ih_entry_count = get_ih_item_len(ih) / (DEH_SIZE + min_entry_size);
-        else 
-            ih_entry_count = get_ih_entry_count (ih);
-	
-	for (j = 0; j < ih_entry_count; j ++, deh ++) {
-	    name = name_in_entry (deh, j);
-	    namelen = name_in_entry_length (ih, deh, j);
-	    ch = name[namelen];
-	    name[namelen] = 0;
-	    retval = regexec (&pattern, name, 0, NULL, 0);
-	    name[namelen] = ch;	    
-	    if (retval != 0)
-		continue;
-
-	    /* name matching given pattern found */
-
-	    new = obstack_alloc (&name_store, sizeof (struct saved_name) + namelen);
-
-	    /* pointed object */
-	    new->dirid = get_deh_dirid (deh);
-	    new->objectid = get_deh_objectid (deh);
-
-	    /* pointer to first name which points the same key */
-	    new->first_name = 0;
-
-	    /* where this name is from */
-	    new->parent_dirid = get_key_dirid (&ih->ih_key);
-	    new->parent_objectid = get_key_objectid (&ih->ih_key);
-	    new->block = bh->b_blocknr;
-
-	    new->count = 1;
-	    new->items = 0;
-
-	    /* name */
-	    new->name_len = namelen;
-	    memcpy (new->name, name, namelen);
-	    new->name [namelen] = 0;
-	    new->name_next = 0;
-
-	    /*
-	    reiserfs_warning (stdout, "\n(%K):%s-->(%K) - ", &new->parent_dirid,
-			      new->name, &new->dirid);
-	    */
-	    if (name_found (new, &name_in)) {
-		/* there was already exactly this name */
-		obstack_free (&name_store, new);
-		continue;
-	    }
-
-	    saved_names ++;
-	    add_name (new, name_in);		
-	    add_key (new);
-	} /* for each entry */
-    } /* for each item */
+	int i, j, i_num;
+	struct item_head *ih;
+	struct reiserfs_de_head *deh;
+	int namelen;
+	char *name;
+	struct saved_name *new, *name_in;
+	char ch;
+	int retval;
+	int min_entry_size = 1;
+	int ih_entry_count = 0;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	i_num = leaf_item_number_estimate(bh);
+	for (i = 0; i < i_num; i++, ih++) {
+		if (!is_direntry_ih(ih))
+			continue;
+		if (is_it_bad_item(fs, ih, B_I_PITEM(bh, ih), 0, 1))
+			continue;
+
+		deh = B_I_DEH(bh, ih);
+
+		if ((get_ih_entry_count(ih) >
+		     (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size)))
+		    || (get_ih_entry_count(ih) == 0))
+			ih_entry_count =
+			    get_ih_item_len(ih) / (DEH_SIZE + min_entry_size);
+		else
+			ih_entry_count = get_ih_entry_count(ih);
+
+		for (j = 0; j < ih_entry_count; j++, deh++) {
+			name = name_in_entry(deh, j);
+			namelen = name_in_entry_length(ih, deh, j);
+			ch = name[namelen];
+			name[namelen] = 0;
+			retval = regexec(&pattern, name, 0, NULL, 0);
+			name[namelen] = ch;
+			if (retval != 0)
+				continue;
+
+			/* name matching given pattern found */
+
+			new =
+			    obstack_alloc(&name_store,
+					  sizeof(struct saved_name) + namelen);
+
+			/* pointed object */
+			new->dirid = get_deh_dirid(deh);
+			new->objectid = get_deh_objectid(deh);
+
+			/* pointer to first name which points the same key */
+			new->first_name = 0;
+
+			/* where this name is from */
+			new->parent_dirid = get_key_dirid(&ih->ih_key);
+			new->parent_objectid = get_key_objectid(&ih->ih_key);
+			new->block = bh->b_blocknr;
+
+			new->count = 1;
+			new->items = 0;
+
+			/* name */
+			new->name_len = namelen;
+			memcpy(new->name, name, namelen);
+			new->name[namelen] = 0;
+			new->name_next = 0;
+
+			/*
+			   reiserfs_warning (stdout, "\n(%K):%s-->(%K) - ", &new->parent_dirid,
+			   new->name, &new->dirid);
+			 */
+			if (name_found(new, &name_in)) {
+				/* there was already exactly this name */
+				obstack_free(&name_store, new);
+				continue;
+			}
+
+			saved_names++;
+			add_name(new, name_in);
+			add_key(new);
+		}		/* for each entry */
+	}			/* for each item */
 
-    return;
+	return;
 }
 
-static struct saved_name *scan_for_key(struct reiserfs_key *key) {
+static struct saved_name *scan_for_key(struct reiserfs_key *key)
+{
 	char *name;
-	struct saved_name * new, *name_in;
+	struct saved_name *new, *name_in;
 
-	asprintf (&name, "%u_%u", get_key_dirid (key), get_key_objectid (key));
-	new = obstack_alloc (&name_store, sizeof (struct saved_name) + strlen(name));
+	asprintf(&name, "%u_%u", get_key_dirid(key), get_key_objectid(key));
+	new =
+	    obstack_alloc(&name_store,
+			  sizeof(struct saved_name) + strlen(name));
 
 	/* pointed object */
-	new->dirid = get_key_dirid (key);
-	new->objectid = get_key_objectid (key);
+	new->dirid = get_key_dirid(key);
+	new->objectid = get_key_objectid(key);
 
 	/* pointer to first name which points the same key */
 	new->first_name = 0;
@@ -278,355 +275,374 @@ static struct saved_name *scan_for_key(struct reiserfs_key *key) {
 
 	/* name */
 	new->name_len = strlen(name);
-	memcpy (new->name, name, new->name_len);
-	new->name [new->name_len] = 0;
+	memcpy(new->name, name, new->name_len);
+	new->name[new->name_len] = 0;
 	new->name_next = 0;
 
 	free(name);
-	
-	if (name_found (new, &name_in)) {
+
+	if (name_found(new, &name_in)) {
 		/* there was already exactly this name */
-		obstack_free (&name_store, new);
+		obstack_free(&name_store, new);
 		return name_in;
 	}
 
-	saved_names ++;
-	add_name (new, name_in);
+	saved_names++;
+	add_name(new, name_in);
 
 	return new;
 }
 
-static int comp_token_key(struct buffer_head *bh, struct item_head *ih, struct reiserfs_key *key) {
-    struct reiserfs_de_head * deh;
-    int j, ih_entry_count = 0;
-    int min_entry_size = 1;
-    
-    if ((get_key_dirid(&ih->ih_key) == get_key_dirid(key) || 
-	 get_key_dirid(key) == ~(__u32)0) &&
-	(get_key_objectid(&ih->ih_key) == get_key_objectid(key) || 
-	 get_key_objectid(key) == ~(__u32)0))
-	return -1;
-
-    if (!is_direntry_ih (ih))
-	return 0;
-	
-    deh = B_I_DEH (bh, ih);
-
-    if ( (get_ih_entry_count (ih) > (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size))) ||
-	 (get_ih_entry_count (ih) == 0))
-	 ih_entry_count = get_ih_item_len(ih) / (DEH_SIZE + min_entry_size);
-    else 
-	 ih_entry_count = get_ih_entry_count (ih);
-
-	
-    for (j = 0; j < ih_entry_count; j ++, deh ++) {
-	if ((get_deh_dirid (deh) == get_key_dirid (key) || (int)get_key_dirid (key) == -1) &&
-	    (get_deh_objectid (deh) == get_key_objectid (key) || (int)get_key_objectid (key) == -1)) 
-	{
-	    return j;
+static int comp_token_key(struct buffer_head *bh, struct item_head *ih,
+			  struct reiserfs_key *key)
+{
+	struct reiserfs_de_head *deh;
+	int j, ih_entry_count = 0;
+	int min_entry_size = 1;
+
+	if ((get_key_dirid(&ih->ih_key) == get_key_dirid(key) ||
+	     get_key_dirid(key) == ~(__u32) 0) &&
+	    (get_key_objectid(&ih->ih_key) == get_key_objectid(key) ||
+	     get_key_objectid(key) == ~(__u32) 0))
+		return -1;
+
+	if (!is_direntry_ih(ih))
+		return 0;
+
+	deh = B_I_DEH(bh, ih);
+
+	if ((get_ih_entry_count(ih) >
+	     (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size)))
+	    || (get_ih_entry_count(ih) == 0))
+		ih_entry_count =
+		    get_ih_item_len(ih) / (DEH_SIZE + min_entry_size);
+	else
+		ih_entry_count = get_ih_entry_count(ih);
+
+	for (j = 0; j < ih_entry_count; j++, deh++) {
+		if ((get_deh_dirid(deh) == get_key_dirid(key)
+		     || (int)get_key_dirid(key) == -1)
+		    && (get_deh_objectid(deh) == get_key_objectid(key)
+			|| (int)get_key_objectid(key) == -1)) {
+			return j;
+		}
 	}
-    }
 
-    return 0;
+	return 0;
 }
 
 /* take every item, look for its key in the key index, if it is found - store
    item in the sorted list of items of a file */
-static void scan_items (struct buffer_head * bh, struct reiserfs_key *key) {
-    int i, i_num, pos;
-    struct item_head * ih;
-    struct saved_name * name_in_store;
-    void * res;
-
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    i_num = leaf_item_number_estimate(bh);
-    for (i = 0; i < i_num; i ++, ih ++) {
-	if (key) {
-	    if (!(pos = comp_token_key(bh, ih, key)))
-		    continue;
-
-	    name_in_store = scan_for_key(&ih->ih_key);
-	} else {
-	    if (!(res = tfind (&ih->ih_key, &key_index, comp_pointed)))
-		continue;
+static void scan_items(struct buffer_head *bh, struct reiserfs_key *key)
+{
+	int i, i_num, pos;
+	struct item_head *ih;
+	struct saved_name *name_in_store;
+	void *res;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	i_num = leaf_item_number_estimate(bh);
+	for (i = 0; i < i_num; i++, ih++) {
+		if (key) {
+			if (!(pos = comp_token_key(bh, ih, key)))
+				continue;
+
+			name_in_store = scan_for_key(&ih->ih_key);
+		} else {
+			if (!
+			    (res =
+			     tfind(&ih->ih_key, &key_index, comp_pointed)))
+				continue;
+
+			/* name pointing to this key found */
+			name_in_store = *(struct saved_name **)res;
+			pos = -1;
+		}
 
-	    /* name pointing to this key found */
-	    name_in_store = *(struct saved_name **)res;
-	    pos = -1;
+		store_item(name_in_store, bh, ih, pos);
 	}
-
-	store_item (name_in_store, bh, ih, pos);
-    }
 }
 
-
 /* FIXME: does not work for long files */
 struct version {
-    int flag; /* direct or indirect */
-    int len;
-    __u32 from;
-    int count;
-    void * data;
+	int flag;		/* direct or indirect */
+	int len;
+	__u32 from;
+	int count;
+	void *data;
 };
 
-
 struct tail {
-    __u32 offset;
-    int len;
-    char * data;
+	__u32 offset;
+	int len;
+	char *data;
 };
 
-
 struct file_map {
-    int head_len; /* number of unfm pointers */
-    void * head;
-
-    int tail_nr; /* number of tails found */
-    struct tail * tails;
-    
-    int version_nr;
-    void * versions; /* list of range versions */
-};
+	int head_len;		/* number of unfm pointers */
+	void *head;
 
+	int tail_nr;		/* number of tails found */
+	struct tail *tails;
 
-struct file_map map;
+	int version_nr;
+	void *versions;		/* list of range versions */
+};
 
+struct file_map map;
 
-static int have_to_append (struct item_head * ih)
+static int have_to_append(struct item_head *ih)
 {
-    loff_t off = get_offset (&ih->ih_key);
-
-    if (is_indirect_ih (ih)) {
-	if (map.head_len * fs->fs_blocksize + 1 <= off)
-	    return 1;
-	return 0;
-    } else if (is_direct_ih (ih)) {
-	int i;
-	__u32 tail_start;
-	
-	tail_start = (off & ~(fs->fs_blocksize - 1)) + 1;
+	loff_t off = get_offset(&ih->ih_key);
 
-	// find correct tail first 
-	for (i = 0; i < map.tail_nr; i ++) {
-	    if (map.tails[i].offset == tail_start) {
-		if (map.tails[i].offset + map.tails[i].len <= off)
-		    return 1;
+	if (is_indirect_ih(ih)) {
+		if (map.head_len * fs->fs_blocksize + 1 <= off)
+			return 1;
 		return 0;
-	    }
+	} else if (is_direct_ih(ih)) {
+		int i;
+		__u32 tail_start;
+
+		tail_start = (off & ~(fs->fs_blocksize - 1)) + 1;
+
+		// find correct tail first 
+		for (i = 0; i < map.tail_nr; i++) {
+			if (map.tails[i].offset == tail_start) {
+				if (map.tails[i].offset + map.tails[i].len <=
+				    off)
+					return 1;
+				return 0;
+			}
+		}
+		// there was no this tail yet 
+		return 1;
 	}
-	// there was no this tail yet 
-	return 1;
-    }
-    return 0;
+	return 0;
 }
 
-
-static void do_append (struct item_head * ih, void * data)
+static void do_append(struct item_head *ih, void *data)
 {
-    int i;
-    int padd;
-    unsigned long long off = get_offset (&ih->ih_key);
-
-    if (is_indirect_ih (ih)) {
-
-	padd = (off - 1) / fs->fs_blocksize - map.head_len;
-	map.head = realloc (map.head, (map.head_len + padd + I_UNFM_NUM (ih)) * 4);
-	if (!map.head)
-	    reiserfs_panic ("realloc failed");
-	memset ((char *)map.head + map.head_len * 4, 0, padd * 4);
-	memcpy ((char *)map.head + (map.head_len + padd) * 4, data,
-		get_ih_item_len (ih));
-	map.head_len += (padd + I_UNFM_NUM (ih));
-
-    } else if (is_direct_ih (ih)) {
-	unsigned int tail_start, skip;
-	
-	// find correct tail first 
-	tail_start = (off & ~(fs->fs_blocksize - 1)) + 1;
-	skip = (off - 1) & (fs->fs_blocksize - 1);
-	for (i = 0; i < map.tail_nr; i ++) {
-	    if (map.tails[i].offset == tail_start) {
-		map.tails[i].data = realloc (map.tails[i].data,
-					     off - tail_start + get_ih_item_len (ih));
-		if (!map.tails[i].data)
-		    reiserfs_panic ("realloc failed");
-		padd = skip - map.tails[i].len;
-		memset (map.tails[i].data + map.tails[i].len, 0, padd);
-		memcpy (map.tails[i].data + map.tails[i].len + padd, data, get_ih_item_len (ih));
-		map.tails[i].len += (padd + get_ih_item_len (ih));
-		return;
-	    }
+	int i;
+	int padd;
+	unsigned long long off = get_offset(&ih->ih_key);
+
+	if (is_indirect_ih(ih)) {
+
+		padd = (off - 1) / fs->fs_blocksize - map.head_len;
+		map.head =
+		    realloc(map.head,
+			    (map.head_len + padd + I_UNFM_NUM(ih)) * 4);
+		if (!map.head)
+			reiserfs_panic("realloc failed");
+		memset((char *)map.head + map.head_len * 4, 0, padd * 4);
+		memcpy((char *)map.head + (map.head_len + padd) * 4, data,
+		       get_ih_item_len(ih));
+		map.head_len += (padd + I_UNFM_NUM(ih));
+
+	} else if (is_direct_ih(ih)) {
+		unsigned int tail_start, skip;
+
+		// find correct tail first 
+		tail_start = (off & ~(fs->fs_blocksize - 1)) + 1;
+		skip = (off - 1) & (fs->fs_blocksize - 1);
+		for (i = 0; i < map.tail_nr; i++) {
+			if (map.tails[i].offset == tail_start) {
+				map.tails[i].data = realloc(map.tails[i].data,
+							    off - tail_start +
+							    get_ih_item_len
+							    (ih));
+				if (!map.tails[i].data)
+					reiserfs_panic("realloc failed");
+				padd = skip - map.tails[i].len;
+				memset(map.tails[i].data + map.tails[i].len, 0,
+				       padd);
+				memcpy(map.tails[i].data + map.tails[i].len +
+				       padd, data, get_ih_item_len(ih));
+				map.tails[i].len +=
+				    (padd + get_ih_item_len(ih));
+				return;
+			}
+		}
+		// allocate memory for new tail 
+		map.tails =
+		    realloc(map.tails, (map.tail_nr + 1) * sizeof(struct tail));
+		if (!map.tails)
+			reiserfs_panic("realloc failed");
+
+		map.tails[map.tail_nr].offset = off;
+		map.tails[map.tail_nr].len = skip + get_ih_item_len(ih);
+		map.tails[map.tail_nr].data =
+		    malloc(map.tails[map.tail_nr].len);
+		memset(map.tails[map.tail_nr].data, 0, skip);
+		memcpy(map.tails[map.tail_nr].data + skip, data,
+		       get_ih_item_len(ih));
+		map.tail_nr++;
 	}
-	// allocate memory for new tail 
-	map.tails = realloc (map.tails, (map.tail_nr + 1) * sizeof (struct tail));
-	if (!map.tails)
-	    reiserfs_panic ("realloc failed");
-
-	map.tails[map.tail_nr].offset = off;
-	map.tails[map.tail_nr].len = skip + get_ih_item_len (ih);
-	map.tails[map.tail_nr].data = malloc (map.tails[map.tail_nr].len);
-	memset (map.tails[map.tail_nr].data, 0, skip);
-	memcpy (map.tails[map.tail_nr].data + skip, data, get_ih_item_len (ih));
-	map.tail_nr ++;		    
-    }
 }
 
-
 // map contains 
-static void do_overwrite (struct item_head * ih, void * data)
+static void do_overwrite(struct item_head *ih, void *data)
 {
-    unsigned long long off, skip;
-    int to_compare, to_append;
-    struct item_head tmp_ih;
-    char * p;
-    
-    off = get_offset (&ih->ih_key);
-    
-    if (is_indirect_ih (ih)) {
-
-	skip = (off - 1) / fs->fs_blocksize;
-	to_compare = (map.head_len - skip > I_UNFM_NUM (ih)) ? 
-	    I_UNFM_NUM (ih) : (map.head_len - skip);
-	to_append = I_UNFM_NUM (ih) - to_compare;
-	
-	p = (char *)map.head + skip * 4;
-
-	if (memcmp (p, data, to_compare * 4))
-	    reiserfs_warning (stderr, "overwrite (indirect): %H contains different data\n", ih);
-
-	if (to_append) {
-	    tmp_ih = *ih;
-	    set_ih_item_len (&tmp_ih, get_ih_item_len (ih) - to_compare * 4);
-	    set_offset (key_format (&ih->ih_key), &tmp_ih.ih_key, off + to_compare * fs->fs_blocksize);
-	    do_append (&tmp_ih, (char *)data + to_compare * 4);
-	}
+	unsigned long long off, skip;
+	int to_compare, to_append;
+	struct item_head tmp_ih;
+	char *p;
 
-    } else if (is_direct_ih (ih)) {
-	unsigned int tail_start;
-	int i;
+	off = get_offset(&ih->ih_key);
 
-	// find correct tail first 
-	tail_start = (off & ~(fs->fs_blocksize - 1)) + 1;
-	for (i = 0; i < map.tail_nr; i ++) {
-	    if (map.tails[i].offset == tail_start) {
-		// ih is a part of this tail 
-		skip = (off - 1) & (fs->fs_blocksize - 1);
-		to_compare = (map.tails[i].len - skip > get_ih_item_len (ih) ? get_ih_item_len (ih) :
-		    map.tails[i].len - skip);
-		to_append = get_ih_item_len (ih) - to_compare;
+	if (is_indirect_ih(ih)) {
 
-		p = (char *)map.tails[i].data + skip;
+		skip = (off - 1) / fs->fs_blocksize;
+		to_compare = (map.head_len - skip > I_UNFM_NUM(ih)) ?
+		    I_UNFM_NUM(ih) : (map.head_len - skip);
+		to_append = I_UNFM_NUM(ih) - to_compare;
+
+		p = (char *)map.head + skip * 4;
+
+		if (memcmp(p, data, to_compare * 4))
+			reiserfs_warning(stderr,
+					 "overwrite (indirect): %H contains different data\n",
+					 ih);
 
-		if (memcmp (p, data, to_compare))
-		    reiserfs_warning (stderr, "overwrite (direct): %H contains different data\n", ih);
-		
 		if (to_append) {
-		    tmp_ih = *ih;
-		    set_ih_item_len (&tmp_ih, get_ih_item_len (ih) - to_compare);
-		    set_offset (key_format (&ih->ih_key), &tmp_ih.ih_key, off + to_compare);
-		    do_append (&tmp_ih, (char *)data + to_compare);
+			tmp_ih = *ih;
+			set_ih_item_len(&tmp_ih,
+					get_ih_item_len(ih) - to_compare * 4);
+			set_offset(key_format(&ih->ih_key), &tmp_ih.ih_key,
+				   off + to_compare * fs->fs_blocksize);
+			do_append(&tmp_ih, (char *)data + to_compare * 4);
 		}
-		return;
-	    }
+
+	} else if (is_direct_ih(ih)) {
+		unsigned int tail_start;
+		int i;
+
+		// find correct tail first 
+		tail_start = (off & ~(fs->fs_blocksize - 1)) + 1;
+		for (i = 0; i < map.tail_nr; i++) {
+			if (map.tails[i].offset == tail_start) {
+				// ih is a part of this tail 
+				skip = (off - 1) & (fs->fs_blocksize - 1);
+				to_compare =
+				    (map.tails[i].len - skip >
+				     get_ih_item_len(ih) ? get_ih_item_len(ih) :
+				     map.tails[i].len - skip);
+				to_append = get_ih_item_len(ih) - to_compare;
+
+				p = (char *)map.tails[i].data + skip;
+
+				if (memcmp(p, data, to_compare))
+					reiserfs_warning(stderr,
+							 "overwrite (direct): %H contains different data\n",
+							 ih);
+
+				if (to_append) {
+					tmp_ih = *ih;
+					set_ih_item_len(&tmp_ih,
+							get_ih_item_len(ih) -
+							to_compare);
+					set_offset(key_format(&ih->ih_key),
+						   &tmp_ih.ih_key,
+						   off + to_compare);
+					do_append(&tmp_ih,
+						  (char *)data + to_compare);
+				}
+				return;
+			}
+		}
+		reiserfs_panic("no appropriate tail found");
 	}
-	reiserfs_panic ("no appropriate tail found");
-    }
 }
 
-
-static void map_one_item (struct saved_item * item)
+static void map_one_item(struct saved_item *item)
 {
-    struct buffer_head * bh;
-    struct item_head * ih;
-    void * data;
-
-    // read the block containing the item 
-    bh = bread (fs->fs_dev, item->si_block, fs->fs_blocksize);
-    if (!bh) {
-	reiserfs_warning (stderr, "bread failed\n");
-	return;
-    }
+	struct buffer_head *bh;
+	struct item_head *ih;
+	void *data;
+
+	// read the block containing the item 
+	bh = bread(fs->fs_dev, item->si_block, fs->fs_blocksize);
+	if (!bh) {
+		reiserfs_warning(stderr, "bread failed\n");
+		return;
+	}
 
-    ih = B_N_PITEM_HEAD (bh, item->si_item_num);
-    data = B_I_PITEM (bh, ih);
-    if (memcmp (&item->si_ih, ih, sizeof (*ih)))
-	reiserfs_panic ("wrong item");
+	ih = B_N_PITEM_HEAD(bh, item->si_item_num);
+	data = B_I_PITEM(bh, ih);
+	if (memcmp(&item->si_ih, ih, sizeof(*ih)))
+		reiserfs_panic("wrong item");
 
-    if (have_to_append (ih)) {
-	do_append (ih, data);
-    } else
-	do_overwrite (ih, data);
+	if (have_to_append(ih)) {
+		do_append(ih, data);
+	} else
+		do_overwrite(ih, data);
 
-    brelse (bh);
+	brelse(bh);
 }
 
 // flush map which is in variable map 
-static void flush_map (reiserfs_filsys_t * fs,
-		       struct reiserfs_key *dir,
-		       char * name,
-		       struct reiserfs_key *key)
+static void flush_map(reiserfs_filsys_t *fs,
+		      struct reiserfs_key *dir,
+		      char *name, struct reiserfs_key *key)
 {
-    int i;
-    FILE * fp;
-    __u32 v32;
-
-
-    if (!map_file (fs))
-	asprintf (&map_file (fs), "%s", ".map");
-	
-    //reiserfs_warning (stderr, "Saving maps into %s\n", map_file (fs));
-    fp = fopen (map_file (fs), "a");
-    if (fp == 0) {
-	reiserfs_warning (stderr, "flush_map: fopen failed: %m");
-	return;
-    }
+	int i;
+	FILE *fp;
+	__u32 v32;
+
+	if (!map_file(fs))
+		asprintf(&map_file(fs), "%s", ".map");
 
-    v32 = MAP_MAGIC;
-    fwrite (&v32, sizeof (v32), 1, fp);
-
-    // device name 
-    v32 = strlen (device_name (fs)) + 1;
-    fwrite (&v32, sizeof (v32), 1, fp);
-    fwrite (device_name (fs), v32, 1, fp);
-
-    // name length and the name itself 
-    v32 = strlen (name) + 1;
-    fwrite (&v32, sizeof (v32), 1, fp);
-    fwrite (name, v32, 1, fp);
-    
-    // short key of a directory 
-    fwrite (dir, SHORT_KEY_SIZE, 1, fp);
-
-    // short key of file 
-    fwrite (key, SHORT_KEY_SIZE, 1, fp);
-
-    // list of data block pointers 
-    fwrite (&map.head_len, sizeof (map.head_len), 1, fp);
-    fwrite (map.head, map.head_len * 4, 1, fp);
-
-
-    // find correct tail first 
-    for (i = 0; i < map.tail_nr; i ++) {
-	if (map.tails [i].offset == map.head_len * fs->fs_blocksize) {
-	    // tail length and the tail itself 
-	    fwrite (&map.tails [i].len, sizeof (map.tails [i].len), 1, fp);
-	    fwrite (map.tails [i].data, map.tails [i].len, 1, fp);
-	    break;
+	//reiserfs_warning (stderr, "Saving maps into %s\n", map_file (fs));
+	fp = fopen(map_file(fs), "a");
+	if (fp == 0) {
+		reiserfs_warning(stderr, "flush_map: fopen failed: %m");
+		return;
 	}
-    }
-    if (i == map.tail_nr) {
-	// no tail 
-	v32 = 0;
-	fwrite (&v32, sizeof (v32), 1, fp);
-    }
 
-    v32 = MAP_END_MAGIC;
-    fwrite (&v32, sizeof (v32), 1, fp);
+	v32 = MAP_MAGIC;
+	fwrite(&v32, sizeof(v32), 1, fp);
 
-    fclose (fp);
-}
+	// device name 
+	v32 = strlen(device_name(fs)) + 1;
+	fwrite(&v32, sizeof(v32), 1, fp);
+	fwrite(device_name(fs), v32, 1, fp);
+
+	// name length and the name itself 
+	v32 = strlen(name) + 1;
+	fwrite(&v32, sizeof(v32), 1, fp);
+	fwrite(name, v32, 1, fp);
+
+	// short key of a directory 
+	fwrite(dir, SHORT_KEY_SIZE, 1, fp);
+
+	// short key of file 
+	fwrite(key, SHORT_KEY_SIZE, 1, fp);
+
+	// list of data block pointers 
+	fwrite(&map.head_len, sizeof(map.head_len), 1, fp);
+	fwrite(map.head, map.head_len * 4, 1, fp);
+
+	// find correct tail first 
+	for (i = 0; i < map.tail_nr; i++) {
+		if (map.tails[i].offset == map.head_len * fs->fs_blocksize) {
+			// tail length and the tail itself 
+			fwrite(&map.tails[i].len, sizeof(map.tails[i].len), 1,
+			       fp);
+			fwrite(map.tails[i].data, map.tails[i].len, 1, fp);
+			break;
+		}
+	}
+	if (i == map.tail_nr) {
+		// no tail 
+		v32 = 0;
+		fwrite(&v32, sizeof(v32), 1, fp);
+	}
+
+	v32 = MAP_END_MAGIC;
+	fwrite(&v32, sizeof(v32), 1, fp);
 
+	fclose(fp);
+}
 
 // write map of file to a map file 
 /*
@@ -702,382 +718,412 @@ static void make_file_map (const void *nodep, VISIT value, int level)
 }
 */
 
-static void print_items(FILE *fp, reiserfs_filsys_t * fs) {
-    struct buffer_head *bh;
-    struct item_head *ih;
-    struct saved_item item;
-    int size = sizeof(struct saved_item) - sizeof(struct saved_item *);
-
-    while (fread(&item, size, 1, fp) == 1) {
-	bh = bread (fs->fs_dev, item.si_block, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (fp, "bread failed\n");
-	    continue;
+static void print_items(FILE * fp, reiserfs_filsys_t *fs)
+{
+	struct buffer_head *bh;
+	struct item_head *ih;
+	struct saved_item item;
+	int size = sizeof(struct saved_item) - sizeof(struct saved_item *);
+
+	while (fread(&item, size, 1, fp) == 1) {
+		bh = bread(fs->fs_dev, item.si_block, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(fp, "bread failed\n");
+			continue;
+		}
+		ih = B_N_PITEM_HEAD(bh, item.si_item_num);
+		reiserfs_print_item(stdout, bh, ih);
+		brelse(bh);
 	}
-	ih = B_N_PITEM_HEAD (bh, item.si_item_num);
-	reiserfs_print_item(stdout, bh, ih);
-	brelse(bh);
-    }
 }
 
-void print_map(reiserfs_filsys_t * fs) {
-    FILE * fp;
+void print_map(reiserfs_filsys_t *fs)
+{
+	FILE *fp;
 
-    if (map_file (fs)) {
-	fp = fopen (map_file (fs), "r");
-	if (fp == 0) {
-	    reiserfs_warning (stderr, "fopen failed: %m\n");
-	    return;
+	if (map_file(fs)) {
+		fp = fopen(map_file(fs), "r");
+		if (fp == 0) {
+			reiserfs_warning(stderr, "fopen failed: %m\n");
+			return;
+		}
+	} else {
+		reiserfs_warning(stderr, "Reading file map from stdin..\n");
+		fflush(stderr);
+		fp = stdin;
 	}
-    } else {
-	reiserfs_warning (stderr, "Reading file map from stdin..\n");
-	fflush (stderr);
-	fp = stdin;
-    }
 
-    print_items(fp, fs);
-    
-    if (fp != stdin) {
-	fclose (fp); 
-	fp = NULL;
-    }
-}
+	print_items(fp, fs);
 
+	if (fp != stdin) {
+		fclose(fp);
+		fp = NULL;
+	}
+}
 
 static FILE *fp = 0;
-FILE * log_to;
+FILE *log_to;
 
-static void save_items(const void *nodep, VISIT value, int level) {
-    struct saved_item *item;
-    
-    
-    if (value != leaf && value != postorder)
-	return;
+static void save_items(const void *nodep, VISIT value, int level)
+{
+	struct saved_item *item;
 
-    item = *(struct saved_item **)nodep;
+	if (value != leaf && value != postorder)
+		return;
 
-    while (item) {
-	if (fp) {
-	    fwrite(item, sizeof(struct saved_item) - sizeof(struct saved_item *), 1, fp);
-	} else {
-	    if (is_direntry_ih (&item->si_ih) && item->si_entry_pos != -1) {
-		reiserfs_warning(log_to, "block %lu, item %d (%H): entry %d\n",
-				 item->si_block, item->si_item_num, 
-				 &item->si_ih, item->si_entry_pos);
-	    } else {
-		reiserfs_warning(log_to, "block %lu, item %d belongs to file %K: %H\n",
-				 item->si_block, item->si_item_num, &item->si_ih.ih_key,
-				 &item->si_ih);
-
-	    } 
+	item = *(struct saved_item **)nodep;
+
+	while (item) {
+		if (fp) {
+			fwrite(item,
+			       sizeof(struct saved_item) -
+			       sizeof(struct saved_item *), 1, fp);
+		} else {
+			if (is_direntry_ih(&item->si_ih)
+			    && item->si_entry_pos != -1) {
+				reiserfs_warning(log_to,
+						 "block %lu, item %d (%H): entry %d\n",
+						 item->si_block,
+						 item->si_item_num,
+						 &item->si_ih,
+						 item->si_entry_pos);
+			} else {
+				reiserfs_warning(log_to,
+						 "block %lu, item %d belongs to file %K: %H\n",
+						 item->si_block,
+						 item->si_item_num,
+						 &item->si_ih.ih_key,
+						 &item->si_ih);
+
+			}
+		}
+
+		item = item->si_next;
 	}
-	
-	item = item->si_next;
-    }
 }
 
-static void make_map(const void *nodep, VISIT value, int level) {
-    struct saved_name * name;
-    char *file_name = 0;
-    static int nr = 0;
-
-    name = *(struct saved_name **)nodep;
-    
-    if (value == leaf || value == postorder) {
-	while (name) {
-	    if (map_file(fs)) {
-		asprintf(&file_name, "%s.%d", map_file(fs), ++nr);
-		reiserfs_warning (log_to, "%d - (%d): [%K]:\"%s\": stored in the %s\n", 
-				  nr, name->count, &name->parent_dirid, name->name, file_name);
-
-		if (fp == 0) {
-		    fp = fopen (file_name, "w+");
-		    if (!fp) {
-			reiserfs_exit (1, "could open %s: %m", file_name);
-		    }
+static void make_map(const void *nodep, VISIT value, int level)
+{
+	struct saved_name *name;
+	char *file_name = 0;
+	static int nr = 0;
+
+	name = *(struct saved_name **)nodep;
+
+	if (value == leaf || value == postorder) {
+		while (name) {
+			if (map_file(fs)) {
+				asprintf(&file_name, "%s.%d", map_file(fs),
+					 ++nr);
+				reiserfs_warning(log_to,
+						 "%d - (%d): [%K]:\"%s\": stored in the %s\n",
+						 nr, name->count,
+						 &name->parent_dirid,
+						 name->name, file_name);
+
+				if (fp == 0) {
+					fp = fopen(file_name, "w+");
+					if (!fp) {
+						reiserfs_exit(1,
+							      "could open %s: %m",
+							      file_name);
+					}
+				}
+			}
+
+			if (name->items)
+				twalk(name->items, save_items);
+
+			name = name->name_next;
+			if (fp) {
+				fclose(fp);
+				fp = NULL;
+				free(file_name);
+			}
 		}
-	    }
-
-	    if (name->items) 
-		twalk (name->items, save_items);
-
-	    name = name->name_next;
-	    if (fp) {
-		fclose(fp);
-		fp = NULL;
-		free(file_name);
-	    }
 	}
-    }
 }
 
 /* store map if it is a regular file */
-static void locate_file (reiserfs_filsys_t * fs, struct reiserfs_key *key)
+static void locate_file(reiserfs_filsys_t *fs, struct reiserfs_key *key)
 {
-    INITIALIZE_REISERFS_PATH(path);
-    struct reiserfs_key *next_key;
-    int retval;
-
-    do {
-	retval = reiserfs_search_by_key_4 (fs, key, &path);
-	if (retval != ITEM_FOUND)
-	    break;
-
-	if (!is_stat_data_key (key) && !is_direntry_key (key)) {
-	    struct saved_item si;
-
-	    si.si_block = get_bh (&path)->b_blocknr;
-	    si.si_item_num = get_item_pos (&path);
-	    si.si_ih = *get_ih (&path);
-	    map_one_item (&si);
-	}
+	INITIALIZE_REISERFS_PATH(path);
+	struct reiserfs_key *next_key;
+	int retval;
+
+	do {
+		retval = reiserfs_search_by_key_4(fs, key, &path);
+		if (retval != ITEM_FOUND)
+			break;
+
+		if (!is_stat_data_key(key) && !is_direntry_key(key)) {
+			struct saved_item si;
+
+			si.si_block = get_bh(&path)->b_blocknr;
+			si.si_item_num = get_item_pos(&path);
+			si.si_ih = *get_ih(&path);
+			map_one_item(&si);
+		}
 
-	/*reiserfs_warning (stdout, "\t");
-	  reiserfs_print_item (stdout, get_bh (&path), get_ih (&path));*/
-	
-	next_key = reiserfs_next_key (&path);
-	if (!next_key || not_of_one_file (next_key, key))
-	    break;
+		/*reiserfs_warning (stdout, "\t");
+		   reiserfs_print_item (stdout, get_bh (&path), get_ih (&path)); */
 
-	*key = *next_key;
-	pathrelse (&path); 
-    } while (1);
+		next_key = reiserfs_next_key(&path);
+		if (!next_key || not_of_one_file(next_key, key))
+			break;
 
-    pathrelse (&path); 
-}
+		*key = *next_key;
+		pathrelse(&path);
+	} while (1);
 
+	pathrelse(&path);
+}
 
 /* read stdin and look for specified name in the specified directory */
-static void look_for_name (reiserfs_filsys_t * fs)
+static void look_for_name(reiserfs_filsys_t *fs)
 {
-    INITIALIZE_REISERFS_PATH(path);
-    char * name, * objectid, * dirid;
-    size_t n;
-    struct reiserfs_key key = {0, };
-
-    reiserfs_warning (stderr,
-		      "Enter dirid objectid \"name\" or press ^D to quit\n");
-    while (1) {
-	reiserfs_warning (stderr, ">");
-	n = 0; dirid = 0;
-	if (getdelim (&dirid, &n, ' ', stdin) == -1)
-	    break;
-	if (!strcmp (dirid, "\n"))
-	    break;
-	set_key_dirid (&key, atol (dirid));
-
-	n = 0; objectid = 0;
-	if (getdelim (&objectid, &n, ' ', stdin) == -1)
-	    break;
-	set_key_objectid (&key, atol (objectid));
-
-	n = 0; name = 0;
-	if (getdelim (&name, &n, '\n', stdin) == -1)
-	    break;
-
-	name [strlen (name) - 1] = 0;
-	reiserfs_warning (stdout, "looking for file \"%s\" in (%K) - ",
-			  name, &key);
-
-	if (reiserfs_locate_entry (fs, &key, name, &path)) {
-	    struct reiserfs_key fkey = {0, };
-	    struct reiserfs_de_head * deh;
-
-	    reiserfs_warning (stdout, "name is found in block %lu (item %d, entry %d)\n",
-			      get_bh (&path)->b_blocknr, get_item_pos (&path),
-			      path.pos_in_item);
-	    deh = B_I_DEH (get_bh (&path), get_ih (&path)) + path.pos_in_item;
-	    set_key_dirid (&fkey, get_deh_dirid (deh));
-	    set_key_objectid (&fkey, get_deh_objectid (deh));
-	    
-	    pathrelse (&path);
-
-	    /* look for file and print its layout */
-	    memset (&map, 0, sizeof (struct file_map));
-
-	    locate_file (fs, &fkey);
+	INITIALIZE_REISERFS_PATH(path);
+	char *name, *objectid, *dirid;
+	size_t n;
+	struct reiserfs_key key = { 0, };
 
-	    flush_map (fs, &key, name, &fkey);
+	reiserfs_warning(stderr,
+			 "Enter dirid objectid \"name\" or press ^D to quit\n");
+	while (1) {
+		reiserfs_warning(stderr, ">");
+		n = 0;
+		dirid = 0;
+		if (getdelim(&dirid, &n, ' ', stdin) == -1)
+			break;
+		if (!strcmp(dirid, "\n"))
+			break;
+		set_key_dirid(&key, atol(dirid));
+
+		n = 0;
+		objectid = 0;
+		if (getdelim(&objectid, &n, ' ', stdin) == -1)
+			break;
+		set_key_objectid(&key, atol(objectid));
+
+		n = 0;
+		name = 0;
+		if (getdelim(&name, &n, '\n', stdin) == -1)
+			break;
+
+		name[strlen(name) - 1] = 0;
+		reiserfs_warning(stdout, "looking for file \"%s\" in (%K) - ",
+				 name, &key);
+
+		if (reiserfs_locate_entry(fs, &key, name, &path)) {
+			struct reiserfs_key fkey = { 0, };
+			struct reiserfs_de_head *deh;
+
+			reiserfs_warning(stdout,
+					 "name is found in block %lu (item %d, entry %d)\n",
+					 get_bh(&path)->b_blocknr,
+					 get_item_pos(&path), path.pos_in_item);
+			deh =
+			    B_I_DEH(get_bh(&path),
+				    get_ih(&path)) + path.pos_in_item;
+			set_key_dirid(&fkey, get_deh_dirid(deh));
+			set_key_objectid(&fkey, get_deh_objectid(deh));
+
+			pathrelse(&path);
+
+			/* look for file and print its layout */
+			memset(&map, 0, sizeof(struct file_map));
+
+			locate_file(fs, &fkey);
+
+			flush_map(fs, &key, name, &fkey);
+
+		} else {
+			reiserfs_warning(stdout, "name not found\n");
+		}
 
-	} else {
-	    reiserfs_warning (stdout, "name not found\n");
+		free(dirid);
+		free(objectid);
+		free(name);
 	}
-
-	free (dirid);
-	free (objectid);
-	free (name);
-    }
 }
 
 #if 0
-static void scan_for_key (struct buffer_head * bh, struct reiserfs_key *key)
+static void scan_for_key(struct buffer_head *bh, struct reiserfs_key *key)
 {
-    int i, j, i_num;
-    struct item_head * ih;
-    struct reiserfs_de_head * deh;
-    int min_entry_size = 1;
-    int ih_entry_count = 0;
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    i_num = leaf_item_number_estimate(bh);
-    for (i = 0; i < i_num; i ++, ih ++) {
-	if ((get_key_dirid(&ih->ih_key) == get_key_dirid(key) || 
-	     get_key_dirid(key) == ~(__u32)0) &&
-	    (get_key_objectid(&ih->ih_key) == get_key_objectid(key) || 
-	     get_key_objectid(key) == ~(__u32)0)) 
-	{
-	    reiserfs_warning(log_to, "%d-th item of block %lu is item of file %K: %H\n",
-			      i, bh->b_blocknr, key, ih);
+	int i, j, i_num;
+	struct item_head *ih;
+	struct reiserfs_de_head *deh;
+	int min_entry_size = 1;
+	int ih_entry_count = 0;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	i_num = leaf_item_number_estimate(bh);
+	for (i = 0; i < i_num; i++, ih++) {
+		if ((get_key_dirid(&ih->ih_key) == get_key_dirid(key) ||
+		     get_key_dirid(key) == ~(__u32) 0) &&
+		    (get_key_objectid(&ih->ih_key) == get_key_objectid(key) ||
+		     get_key_objectid(key) == ~(__u32) 0)) {
+			reiserfs_warning(log_to,
+					 "%d-th item of block %lu is item of file %K: %H\n",
+					 i, bh->b_blocknr, key, ih);
+		}
+		if (!is_direntry_ih(ih))
+			continue;
+		deh = B_I_DEH(bh, ih);
+
+		if ((get_ih_entry_count(ih) >
+		     (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size)))
+		    || (get_ih_entry_count(ih) == 0))
+			ih_entry_count =
+			    get_ih_item_len(ih) / (DEH_SIZE + min_entry_size);
+		else
+			ih_entry_count = get_ih_entry_count(ih);
+
+		for (j = 0; j < ih_entry_count; j++, deh++) {
+			if ((get_deh_dirid(deh) == get_key_dirid(key)
+			     || (int)get_key_dirid(key) == -1)
+			    && (get_deh_objectid(deh) == get_key_objectid(key)
+				|| (int)get_key_objectid(key) == -1)) {
+				reiserfs_warning(log_to,
+						 "dir item %d (%H) of block %lu has "
+						 "entry (%d-th) %.*s pointing to %K\n",
+						 i, ih, bh->b_blocknr, j,
+						 name_in_entry_length(ih, deh,
+								      j),
+						 name_in_entry(deh, j), key);
+			}
+		}
 	}
-	if (!is_direntry_ih (ih))
-	    continue;
-	deh = B_I_DEH (bh, ih);
-	
-        if ( (get_ih_entry_count (ih) > (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size))) ||
-            (get_ih_entry_count (ih) == 0))
-            ih_entry_count = get_ih_item_len(ih) / (DEH_SIZE + min_entry_size);
-        else 
-            ih_entry_count = get_ih_entry_count (ih);
-	
-	
-	for (j = 0; j < ih_entry_count; j ++, deh ++) {
-	    if ((get_deh_dirid (deh) == get_key_dirid (key) || (int)get_key_dirid (key) == -1) &&
-		(get_deh_objectid (deh) == get_key_objectid (key) || (int)get_key_objectid (key) == -1)) {
-		reiserfs_warning (log_to, "dir item %d (%H) of block %lu has "
-				  "entry (%d-th) %.*s pointing to %K\n",
-				  i, ih, bh->b_blocknr, j,
-				  name_in_entry_length (ih, deh, j), name_in_entry (deh, j), key);
-	    }
-	}	
-    }
-    return;
+	return;
 }
 #endif
 
-void do_scan (reiserfs_filsys_t * fs)
+void do_scan(reiserfs_filsys_t *fs)
 {
-    unsigned long i;
-    struct buffer_head * bh;
-    int type;
-    char * answer = 0;
-    size_t n = 0;
-    struct reiserfs_key key = {0, 0, };
-    unsigned long done, total;
-
-    if (debug_mode (fs) == DO_LOOK_FOR_NAME) {
-	/* look for a file in using tree algorithms */
-	look_for_name (fs);
-	return;
-    }
+	unsigned long i;
+	struct buffer_head *bh;
+	int type;
+	char *answer = 0;
+	size_t n = 0;
+	struct reiserfs_key key = { 0, 0, };
+	unsigned long done, total;
+
+	if (debug_mode(fs) == DO_LOOK_FOR_NAME) {
+		/* look for a file in using tree algorithms */
+		look_for_name(fs);
+		return;
+	}
 
-    /* scan area of disk and store all names matching the pattern */
+	/* scan area of disk and store all names matching the pattern */
 
-    /* initialize storage and two indexes */
-    obstack_init (&name_store);
-    obstack_init (&item_store);
-    key_index = 0;
-    name_index = 0;
+	/* initialize storage and two indexes */
+	obstack_init(&name_store);
+	obstack_init(&item_store);
+	key_index = 0;
+	name_index = 0;
 
-    total = reiserfs_bitmap_ones (input_bitmap (fs));
+	total = reiserfs_bitmap_ones(input_bitmap(fs));
 
-    log_to = fopen ("scan.log", "w+");
-    printf ("Log file 'scan.log' is opened\n");
+	log_to = fopen("scan.log", "w+");
+	printf("Log file 'scan.log' is opened\n");
 
-    if (debug_mode (fs) == DO_SCAN_FOR_NAME) {
-	if (regcomp (&pattern, name_pattern (fs), 0)) {
-	    printf ("regcomp failed");
-	    return;
-	}
+	if (debug_mode(fs) == DO_SCAN_FOR_NAME) {
+		if (regcomp(&pattern, name_pattern(fs), 0)) {
+			printf("regcomp failed");
+			return;
+		}
 
-	printf ("Looking for names matching %s\n", name_pattern (fs));
-	set_key_dirid (&key, 1);
-    } else {
-	printf ("What key do you want to find: dirid?");
-	getline (&answer, &n, stdin);
-	set_key_dirid (&key, atoi (answer));
-
-	printf ("objectid?");
-	getline (&answer, &n, stdin);
-	set_key_objectid (&key, atoi (answer));
-	reiserfs_warning (stderr, "looking for (%K)\n", &key);
-    }
+		printf("Looking for names matching %s\n", name_pattern(fs));
+		set_key_dirid(&key, 1);
+	} else {
+		printf("What key do you want to find: dirid?");
+		getline(&answer, &n, stdin);
+		set_key_dirid(&key, atoi(answer));
+
+		printf("objectid?");
+		getline(&answer, &n, stdin);
+		set_key_objectid(&key, atoi(answer));
+		reiserfs_warning(stderr, "looking for (%K)\n", &key);
+	}
 
-    if (debug_mode (fs) == DO_SCAN_FOR_NAME) {
-	done = 0;
-	for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	    if (!reiserfs_bitmap_test_bit (input_bitmap (fs), i))
-		continue;
-	    bh = bread (fs->fs_dev, i, fs->fs_blocksize);
-	    if (!bh) {
-		printf ("could not read block %lu\n", i);
-		continue;
-	    }
-	    type = who_is_this (bh->b_data, bh->b_size);
-	    if (type == THE_LEAF || type == HAS_IH_ARRAY)
-		scan_for_name (bh);
-	    else
-		reiserfs_bitmap_clear_bit (input_bitmap (fs), i);
-	    brelse (bh);
-	    print_how_far (stderr, &done, total, 1, be_quiet (fs));
+	if (debug_mode(fs) == DO_SCAN_FOR_NAME) {
+		done = 0;
+		for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+			if (!reiserfs_bitmap_test_bit(input_bitmap(fs), i))
+				continue;
+			bh = bread(fs->fs_dev, i, fs->fs_blocksize);
+			if (!bh) {
+				printf("could not read block %lu\n", i);
+				continue;
+			}
+			type = who_is_this(bh->b_data, bh->b_size);
+			if (type == THE_LEAF || type == HAS_IH_ARRAY)
+				scan_for_name(bh);
+			else
+				reiserfs_bitmap_clear_bit(input_bitmap(fs), i);
+			brelse(bh);
+			print_how_far(stderr, &done, total, 1, be_quiet(fs));
+		}
 	}
-    }
 
-    fprintf (stderr, "\n");
-    if (debug_mode (fs) == DO_SCAN_FOR_NAME)
-        fprintf (stderr, "There were found %d names matching the pattern \"%s\", %d names skipped\n",
-            saved_names, name_pattern (fs), skipped_names);
-    fflush (stderr);
+	fprintf(stderr, "\n");
+	if (debug_mode(fs) == DO_SCAN_FOR_NAME)
+		fprintf(stderr,
+			"There were found %d names matching the pattern \"%s\", %d names skipped\n",
+			saved_names, name_pattern(fs), skipped_names);
+	fflush(stderr);
 
+	/* step 2: */
+	done = 0;
+	total = reiserfs_bitmap_ones(input_bitmap(fs));
+	printf("%lu bits set in bitmap\n", total);
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		int type;
+
+		if (!reiserfs_bitmap_test_bit(input_bitmap(fs), i))
+			continue;
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
+		if (!bh) {
+			printf("could not read block %lu\n", i);
+			continue;
+		}
+		type = who_is_this(bh->b_data, bh->b_size);
+		switch (type) {
+		case THE_JDESC:
+			if (!get_key_dirid(&key))
+				printf("block %lu is journal descriptor\n", i);
+			break;
+		case THE_SUPER:
+			if (!get_key_dirid(&key))
+				printf("block %lu is reiserfs super block\n",
+				       i);
+			break;
+		case THE_INTERNAL:
+			if (!get_key_dirid(&key))
+				printf("block %lu is reiserfs internal node\n",
+				       i);
+			break;
+		case THE_LEAF:
+		case HAS_IH_ARRAY:
+			scan_items(bh,
+				   (debug_mode(fs) ==
+				    DO_SCAN_FOR_NAME ? NULL : &key));
+			break;
+		default:
+			break;
+		}
 
-    /* step 2: */
-    done = 0;
-    total = reiserfs_bitmap_ones (input_bitmap (fs));
-    printf ("%lu bits set in bitmap\n", total);
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	int type;
-	
-	if (!reiserfs_bitmap_test_bit (input_bitmap (fs), i))
-	    continue;
-	bh = bread (fs->fs_dev, i, fs->fs_blocksize);
-	if (!bh) {
-	    printf ("could not read block %lu\n", i);
-	    continue;
-	}
-	type = who_is_this (bh->b_data, bh->b_size);
-	switch (type) {
-	case THE_JDESC:
-	    if (!get_key_dirid (&key))
-		printf ("block %lu is journal descriptor\n", i);
-	    break;
-	case THE_SUPER:
-	    if (!get_key_dirid (&key))
-		printf ("block %lu is reiserfs super block\n", i);
-	    break;
-	case THE_INTERNAL:
-	    if (!get_key_dirid (&key))
-		printf ("block %lu is reiserfs internal node\n", i);
-	    break;
-	case THE_LEAF:
-	case HAS_IH_ARRAY:
-	    scan_items (bh, (debug_mode (fs) == DO_SCAN_FOR_NAME ? NULL : &key));
-	    break;
-	default:
-	    break;
+		brelse(bh);
+		print_how_far(stderr, &done, total, 1, be_quiet(fs));
 	}
+	fprintf(stderr, "\nThere were %d items saved\n", saved_items);
 
-	brelse (bh);
-	print_how_far (stderr, &done, total, 1, be_quiet (fs));
-    }
-    fprintf (stderr, "\nThere were %d items saved\n", saved_items);
-
-    /* ok, print what we found */
-    /*twalk (name_index, print_file);*/
+	/* ok, print what we found */
+	/*twalk (name_index, print_file); */
 
-    /* create map for every file in */
-    twalk (name_index, make_map);
+	/* create map for every file in */
+	twalk(name_index, make_map);
 
-    /* print names of files we have map of in a file 'file.list' */
-    /*twalk (name_index, print_name);*/
+	/* print names of files we have map of in a file 'file.list' */
+	/*twalk (name_index, print_name); */
 }
-
-
diff --git a/debugreiserfs/stat.c b/debugreiserfs/stat.c
index 9c38239..dbcd6c5 100644
--- a/debugreiserfs/stat.c
+++ b/debugreiserfs/stat.c
@@ -10,65 +10,59 @@
 #define obstack_chunk_alloc malloc
 #define obstack_chunk_free free
 
-
 /* try to find blocks which contain only items which are */
 
-
 /* read blocks marked in debug_bitmap and collect statistic of it:
  number of stat data */
 struct {
-    unsigned long all;
-    unsigned long items [5];
-    unsigned long unique_keys; /* keys of stat datas */
-    unsigned long unique_entry_keys; /* keys which appear in directory entries */
-    unsigned long names; /* dir entries but "." and ".." */
-    unsigned long dir_blocks; /* block containing only one directory item */
-    unsigned long unique_items;
-    unsigned long leaves;
-    unsigned long blocks_to_skip;
+	unsigned long all;
+	unsigned long items[5];
+	unsigned long unique_keys;	/* keys of stat datas */
+	unsigned long unique_entry_keys;	/* keys which appear in directory entries */
+	unsigned long names;	/* dir entries but "." and ".." */
+	unsigned long dir_blocks;	/* block containing only one directory item */
+	unsigned long unique_items;
+	unsigned long leaves;
+	unsigned long blocks_to_skip;
 } fs_stat;
 
-
 /* store unique item heads */
 struct obstack items;
 
 /* tree sorting item heades by comp_items_1 */
-void * items_tree;
+void *items_tree;
 
-
-static int comp_items_1 (const void * p1, const void * p2)
+static int comp_items_1(const void *p1, const void *p2)
 {
-    int retval;
-    struct item_head * ih1, * ih2;
-
-    /*    
-    if (*(int *)p1 != *(int *)p2)
-      retval = 1;
-    else
-      retval = 0;
-    */
-    retval = comp_keys (p1, p2);
-    /*retval = comp_short_keys (p1, p2);*/
-    if (retval)
-	return retval;
-
-
-    ih1 = (struct item_head *)p1;
-    ih2 = (struct item_head *)p2;
-
-    if (get_ih_item_len (ih1) < get_ih_item_len (ih2))
-	return -1;
-    if (get_ih_item_len (ih1) > get_ih_item_len (ih2))
-	return 1;
-    if (get_ih_entry_count (ih1) < get_ih_entry_count (ih2))
-	return -1;
-    if (get_ih_entry_count (ih1) > get_ih_entry_count (ih2))
-	return 1;
+	int retval;
+	struct item_head *ih1, *ih2;
+
+	/*    
+	   if (*(int *)p1 != *(int *)p2)
+	   retval = 1;
+	   else
+	   retval = 0;
+	 */
+	retval = comp_keys(p1, p2);
+	/*retval = comp_short_keys (p1, p2); */
+	if (retval)
+		return retval;
+
+	ih1 = (struct item_head *)p1;
+	ih2 = (struct item_head *)p2;
+
+	if (get_ih_item_len(ih1) < get_ih_item_len(ih2))
+		return -1;
+	if (get_ih_item_len(ih1) > get_ih_item_len(ih2))
+		return 1;
+	if (get_ih_entry_count(ih1) < get_ih_entry_count(ih2))
+		return -1;
+	if (get_ih_entry_count(ih1) > get_ih_entry_count(ih2))
+		return 1;
 
-    return 0;
+	return 0;
 }
 
-
 /*
 static void print_node (const void *nodep, VISIT value, int level)
 {
@@ -88,64 +82,61 @@ static void print_node (const void *nodep, VISIT value, int level)
 }
 */
 
-
-static int is_unique_item (struct obstack * ostack, void ** tree, void * ih)
+static int is_unique_item(struct obstack *ostack, void **tree, void *ih)
 {
-    void * res;
-    void * key1;
+	void *res;
+	void *key1;
 
-    key1 = obstack_copy (ostack, ih, IH_SIZE);
-    res = tsearch (key1, tree, comp_items_1);
-    if (!res)
-	reiserfs_panic ("Too many keys found");
+	key1 = obstack_copy(ostack, ih, IH_SIZE);
+	res = tsearch(key1, tree, comp_items_1);
+	if (!res)
+		reiserfs_panic("Too many keys found");
 
 /*    twalk (*tree, print_node);*/
 /*    reiserfs_warning (stderr, "\n\n");*/
-    if (*(void **)res != key1) {
-	/* key is in tree already, remove it from obstack */
-      /*reiserfs_warning (stdout, "%H is skipped\n", ih);fflush (stdout);*/
-	obstack_free (ostack, key1);
-	return 0;
-    }
+	if (*(void **)res != key1) {
+		/* key is in tree already, remove it from obstack */
+		/*reiserfs_warning (stdout, "%H is skipped\n", ih);fflush (stdout); */
+		obstack_free(ostack, key1);
+		return 0;
+	}
 
-    /*reiserfs_warning (stdout, "%k is added\n", ih);fflush (stdout);*/
-    return 1;
+	/*reiserfs_warning (stdout, "%k is added\n", ih);fflush (stdout); */
+	return 1;
 }
 
-
-static void stat1_the_leaf (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static void stat1_the_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    int i, i_num;
-    struct item_head * ih;
-    int is_there_unique_item;
-
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    is_there_unique_item = 0;
-    i_num = leaf_item_number_estimate(bh);
-    for (i = 0; i < i_num; i ++, ih ++) {
-	/* count all items */
-	fs_stat.all ++;
-
-	if (is_unique_item (&items, &items_tree, ih)) {
-	    /* this is item we have not seen yet */
-	    fs_stat.unique_items ++;
-	    is_there_unique_item ++;
+	int i, i_num;
+	struct item_head *ih;
+	int is_there_unique_item;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	is_there_unique_item = 0;
+	i_num = leaf_item_number_estimate(bh);
+	for (i = 0; i < i_num; i++, ih++) {
+		/* count all items */
+		fs_stat.all++;
+
+		if (is_unique_item(&items, &items_tree, ih)) {
+			/* this is item we have not seen yet */
+			fs_stat.unique_items++;
+			is_there_unique_item++;
+		}
 	}
-    }
 
-    if (!is_there_unique_item) {
-	/* the node contains only items we have seen already. so we will skip
-           it */
-	fs_stat.blocks_to_skip ++;
-	reiserfs_bitmap_clear_bit (input_bitmap (fs), bh->b_blocknr);
-    } else {
-	ih = B_N_PITEM_HEAD (bh, 0);
-	/* node contains at least one unique item. We will put it in, count items of each type */
-	for (i = 0; i < i_num; i ++, ih ++) {
-	    fs_stat.items [get_type (&ih->ih_key)] ++;
+	if (!is_there_unique_item) {
+		/* the node contains only items we have seen already. so we will skip
+		   it */
+		fs_stat.blocks_to_skip++;
+		reiserfs_bitmap_clear_bit(input_bitmap(fs), bh->b_blocknr);
+	} else {
+		ih = B_N_PITEM_HEAD(bh, 0);
+		/* node contains at least one unique item. We will put it in, count items of each type */
+		for (i = 0; i < i_num; i++, ih++) {
+			fs_stat.items[get_type(&ih->ih_key)]++;
+		}
 	}
-    }
 }
 
 /*
@@ -161,17 +152,16 @@ static void stat2_the_leaf (struct buffer_head * bh)
 }
 */
 
-void do_stat (reiserfs_filsys_t * fs)
+void do_stat(reiserfs_filsys_t *fs)
 {
-    unsigned long i;
-    unsigned long done, total;
-    struct buffer_head * bh;
-    int type;
-    FILE * fp;
+	unsigned long i;
+	unsigned long done, total;
+	struct buffer_head *bh;
+	int type;
+	FILE *fp;
 
-
-    obstack_init (&items);
-    items_tree = 0;
+	obstack_init(&items);
+	items_tree = 0;
 
 /*
     bh = bread (fs->s_dev, 8211, fs->s_blocksize);
@@ -180,95 +170,93 @@ void do_stat (reiserfs_filsys_t * fs)
     return;
 */
 
-    /* pass 0 of stating */
-    total = reiserfs_bitmap_ones (input_bitmap (fs));
-    done = 0;
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	if (!reiserfs_bitmap_test_bit (input_bitmap (fs), i))
-	    continue;
-
-	print_how_far (stderr, &done, total, 1, be_quiet (fs));
-
-	bh = bread (fs->fs_dev, i, fs->fs_blocksize);
-	if (!bh) {
-	    printf ("could not read block %lu\n", i);
-	    continue;
-	}
-	type = who_is_this (bh->b_data, bh->b_size);
-	if (type != THE_LEAF && type != HAS_IH_ARRAY) {
-	    reiserfs_bitmap_clear_bit (input_bitmap (fs), i);
-	    brelse (bh);
-	    continue;
+	/* pass 0 of stating */
+	total = reiserfs_bitmap_ones(input_bitmap(fs));
+	done = 0;
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (!reiserfs_bitmap_test_bit(input_bitmap(fs), i))
+			continue;
+
+		print_how_far(stderr, &done, total, 1, be_quiet(fs));
+
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
+		if (!bh) {
+			printf("could not read block %lu\n", i);
+			continue;
+		}
+		type = who_is_this(bh->b_data, bh->b_size);
+		if (type != THE_LEAF && type != HAS_IH_ARRAY) {
+			reiserfs_bitmap_clear_bit(input_bitmap(fs), i);
+			brelse(bh);
+			continue;
+		}
+		fs_stat.leaves++;
+		stat1_the_leaf(fs, bh);
+		brelse(bh);
 	}
-	fs_stat.leaves ++;
-	stat1_the_leaf (fs, bh);
-	brelse (bh);
-    }
 
-    reiserfs_warning (stderr, "\nThere were found on the '%s' device:\n"
-		      "\tleaves %lu\n"
-		      "\ttotal number of items %lu\n"
-		      "\tblocks containing at least one unique item %lu\n"
-		      "\tblocks which can be skipped %lu\n"
-		      "\t\tstat data %lu\n"
-		      "\t\tindirect %lu\n"
-		      "\t\tdirect %lu\n"
-		      "\t\tdirectory items %lu\n"
-		      "\tunique items %lu\n",
-		      /*
-		      "\tnames there (but \".\" and \"..\") %lu\n"
-		      "\tpointing to unique keys %lu\n"
-		      "other items %lu\n"
-		      "blocks containing only 1 dir item %lu\n",
-		      */
-		      fs->fs_file_name,
-		      fs_stat.leaves,
-		      fs_stat.all,
-		      fs_stat.leaves - fs_stat.blocks_to_skip,
-		      fs_stat.blocks_to_skip,
-		      fs_stat.items [TYPE_STAT_DATA],
-		      fs_stat.items [TYPE_INDIRECT],
-		      fs_stat.items [TYPE_DIRECT],
-		      fs_stat.items [TYPE_DIRENTRY],
-		      fs_stat.unique_items);
+	reiserfs_warning(stderr, "\nThere were found on the '%s' device:\n"
+			 "\tleaves %lu\n"
+			 "\ttotal number of items %lu\n"
+			 "\tblocks containing at least one unique item %lu\n"
+			 "\tblocks which can be skipped %lu\n"
+			 "\t\tstat data %lu\n"
+			 "\t\tindirect %lu\n"
+			 "\t\tdirect %lu\n"
+			 "\t\tdirectory items %lu\n" "\tunique items %lu\n",
+			 /*
+			    "\tnames there (but \".\" and \"..\") %lu\n"
+			    "\tpointing to unique keys %lu\n"
+			    "other items %lu\n"
+			    "blocks containing only 1 dir item %lu\n",
+			  */
+			 fs->fs_file_name,
+			 fs_stat.leaves,
+			 fs_stat.all,
+			 fs_stat.leaves - fs_stat.blocks_to_skip,
+			 fs_stat.blocks_to_skip,
+			 fs_stat.items[TYPE_STAT_DATA],
+			 fs_stat.items[TYPE_INDIRECT],
+			 fs_stat.items[TYPE_DIRECT],
+			 fs_stat.items[TYPE_DIRENTRY], fs_stat.unique_items);
 /*
 		      fs_stat.names,
 		      fs_stat.unique_keys,
 		      fs_stat.items [4],
 		      fs_stat.dir_blocks);
 */
-    if (!input_bitmap_file_name(fs))
-	return;
+	if (!input_bitmap_file_name(fs))
+		return;
 
-    fp = fopen (input_bitmap_file_name(fs), "w");
-    if (!fp) {
-	reiserfs_exit (1, "could not open %s to save bitmap: %m\n",
-		       input_bitmap_file_name(fs));
-    }
-    reiserfs_warning (stderr, "Updated bitmap contains %u blocks marked\n",
-		      reiserfs_bitmap_ones (input_bitmap (fs)));
-    
-    reiserfs_bitmap_save (fp, input_bitmap (fs));
-    fclose (fp);
-    return;
-
-
-    /* pass 2 of stating */
-    reiserfs_warning (stderr, "Looking for blocks containing only keys not pointed by any of entries\n");
-    total = reiserfs_bitmap_ones (input_bitmap (fs));
-    done = 0;
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	if (!reiserfs_bitmap_test_bit (input_bitmap (fs), i))
-	    continue;
+	fp = fopen(input_bitmap_file_name(fs), "w");
+	if (!fp) {
+		reiserfs_exit(1, "could not open %s to save bitmap: %m\n",
+			      input_bitmap_file_name(fs));
+	}
+	reiserfs_warning(stderr, "Updated bitmap contains %u blocks marked\n",
+			 reiserfs_bitmap_ones(input_bitmap(fs)));
 
-	print_how_far (stderr, &done, total, 1, be_quiet (fs));
+	reiserfs_bitmap_save(fp, input_bitmap(fs));
+	fclose(fp);
+	return;
 
-	bh = bread (fs->fs_dev, i, fs->fs_blocksize);
-	if (!bh) {
-	    printf ("could not read block %lu\n", i);
-	    continue;
+	/* pass 2 of stating */
+	reiserfs_warning(stderr,
+			 "Looking for blocks containing only keys not pointed by any of entries\n");
+	total = reiserfs_bitmap_ones(input_bitmap(fs));
+	done = 0;
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (!reiserfs_bitmap_test_bit(input_bitmap(fs), i))
+			continue;
+
+		print_how_far(stderr, &done, total, 1, be_quiet(fs));
+
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
+		if (!bh) {
+			printf("could not read block %lu\n", i);
+			continue;
+		}
+		/*stat2_the_leaf (bh); */
 	}
-	/*stat2_the_leaf (bh);*/
-    }
 
 }
diff --git a/debugreiserfs/unpack.c b/debugreiserfs/unpack.c
index e71306a..d77dce9 100644
--- a/debugreiserfs/unpack.c
+++ b/debugreiserfs/unpack.c
@@ -2,21 +2,18 @@
  * Copyright 2000-2004 by Hans Reiser, licensing governed by 
  * reiserfsprogs/README
  */
-  
+
 #include "debugreiserfs.h"
 #include <sys/resource.h>
 
-
 #define print_usage_and_exit() die ("Usage: %s [-v] [-b filename] device\n\
 -v		prints blocks number of every block unpacked\n\
 -b filename	saves bitmap of blocks unpacked to filename\n\
 -j filename     stores journal in the filename\n", argv[0]);
 
-
 /* when super block gets unpacked for the first time - create a bitmap
    and mark in it what have been unpacked. Save that bitmap at the end */
-reiserfs_bitmap_t * what_unpacked = 0;
-
+reiserfs_bitmap_t *what_unpacked = 0;
 
 int leaves, full;
 
@@ -24,51 +21,51 @@ int verbose = 0;
 
 int Default_journal = 1;
 
-static void unpack_offset (struct packed_item * pi, struct item_head * ih, int blocksize)
+static void unpack_offset(struct packed_item *pi, struct item_head *ih,
+			  int blocksize)
 {
 
-    if (get_pi_mask(pi) & OFFSET_BITS_64) {
-	__u64 v64;
+	if (get_pi_mask(pi) & OFFSET_BITS_64) {
+		__u64 v64;
 
-	if (get_ih_key_format (ih) != KEY_FORMAT_2)
-	    die ("unpack_offset: key format is not set or wrong");
-	fread_le64 (&v64);
-	set_offset (KEY_FORMAT_2, &ih->ih_key, v64);
-	return;
-    }
+		if (get_ih_key_format(ih) != KEY_FORMAT_2)
+			die("unpack_offset: key format is not set or wrong");
+		fread_le64(&v64);
+		set_offset(KEY_FORMAT_2, &ih->ih_key, v64);
+		return;
+	}
 
-    if (get_pi_mask(pi) & OFFSET_BITS_32) {
-	__u32 v32;
+	if (get_pi_mask(pi) & OFFSET_BITS_32) {
+		__u32 v32;
 
-	fread_le32 (&v32);
-	set_offset (get_ih_key_format (ih), &ih->ih_key, v32);
+		fread_le32(&v32);
+		set_offset(get_ih_key_format(ih), &ih->ih_key, v32);
+		return;
+	}
+
+	if ((get_pi_mask(pi) & DIR_ID) == 0
+	    && (get_pi_mask(pi) & OBJECT_ID) == 0) {
+		/* offset was not sent, as it can be calculated looking at the
+		   previous item */
+		if (is_stat_data_ih(ih - 1))
+			set_offset(get_ih_key_format(ih), &ih->ih_key, 1);
+		if (is_indirect_ih(ih - 1))
+			set_offset(get_ih_key_format(ih), &ih->ih_key,
+				   get_offset(&(ih - 1)->ih_key) +
+				   get_bytes_number(ih - 1, blocksize));
+	}
+	// offset is 0
 	return;
-    }
-
-    if ((get_pi_mask(pi) & DIR_ID) == 0 && (get_pi_mask(pi) & OBJECT_ID) == 0) {
-	/* offset was not sent, as it can be calculated looking at the
-           previous item */
-	if (is_stat_data_ih (ih - 1))
-	    set_offset (get_ih_key_format (ih), &ih->ih_key, 1);
-	if (is_indirect_ih (ih - 1))
-	    set_offset (get_ih_key_format (ih), &ih->ih_key, 
-			get_offset (&(ih - 1)->ih_key) + get_bytes_number (ih - 1, blocksize));
-    }
-
-    // offset is 0
-    return;
 }
 
-
-static void unpack_type (struct packed_item * pi, struct item_head * ih)
+static void unpack_type(struct packed_item *pi, struct item_head *ih)
 {
-    set_type (get_ih_key_format (ih), &ih->ih_key, get_pi_type(pi));
-    if (type_unknown (&ih->ih_key))
-	reiserfs_panic ("unpack_type: unknown type %d unpacked for %H\n",
-			get_pi_type(pi), ih);
+	set_type(get_ih_key_format(ih), &ih->ih_key, get_pi_type(pi));
+	if (type_unknown(&ih->ih_key))
+		reiserfs_panic("unpack_type: unknown type %d unpacked for %H\n",
+			       get_pi_type(pi), ih);
 }
 
-
 /* direntry item comes in the following format: 
    for each entry
       mask - 8 bits
@@ -79,552 +76,552 @@ static void unpack_type (struct packed_item * pi, struct item_head * ih)
 	maybe gencounter (16)
 	maybe deh_state (16)
 */
-static void unpack_direntry (struct packed_item * pi, struct buffer_head * bh,
-			     struct item_head * ih, hashf_t hash_func)
+static void unpack_direntry(struct packed_item *pi, struct buffer_head *bh,
+			    struct item_head *ih, hashf_t hash_func)
 {
-    __u16 entry_count, namelen, gen_counter, entry_len;
-    __u8 mask;
-    int i;
-    struct reiserfs_de_head * deh;
-    int location;
-    char * item;
+	__u16 entry_count, namelen, gen_counter, entry_len;
+	__u8 mask;
+	int i;
+	struct reiserfs_de_head *deh;
+	int location;
+	char *item;
 
 /*    if (!hash_func)
 	die ("unpack_direntry: hash function is not set");*/
 
-    if (!(get_pi_mask(pi) & IH_FREE_SPACE))
-        die ("ih_entry_count must be packed for directory items");
+	if (!(get_pi_mask(pi) & IH_FREE_SPACE))
+		die("ih_entry_count must be packed for directory items");
 
-    entry_count = get_ih_entry_count (ih);
+	entry_count = get_ih_entry_count(ih);
 /*    if (!entry_count)
 	reiserfs_panic ("unpack_direntry: entry count should be set already");*/
 
-    item = bh->b_data + get_ih_location (ih);
-    deh = (struct reiserfs_de_head *)item;
-    location = get_pi_item_len(pi);
-    for (i = 0; i < entry_count; i ++, deh ++) {
-	fread8 (&mask);
-	fread_le16 (&entry_len);
-	location -= entry_len;
-	set_deh_location (deh, location);
-	fread (item + location, entry_len, 1, stdin);
-
-	/* find name length */
-	if (*(item + location + entry_len - 1))
-	    namelen = entry_len;
-	else
-	    namelen = strlen (item + location);
-
-	fread32 (&deh->deh2_objectid);
-	if (mask & HAS_DIR_ID)
-	    fread32 (&deh->deh2_dir_id);
-	else
-	    set_deh_dirid (deh, get_key_objectid (&ih->ih_key));
-
-	if (*(item + location) == '.' && namelen == 1)
-	    /* old or new "." */
-	    set_deh_offset (deh, DOT_OFFSET);
-	else if (*(item + location) == '.' && *(item + location + 1) == '.' && namelen == 2)
-	    /* old or new ".." */
-	    set_deh_offset (deh, DOT_DOT_OFFSET);
-	else if (hash_func)
-	    set_deh_offset (deh, hash_value(hash_func, item + location, namelen));
-	if (mask & HAS_GEN_COUNTER) {
-	    fread_le16 (&gen_counter);
-	    set_deh_offset (deh, get_deh_offset (deh) | gen_counter);
+	item = bh->b_data + get_ih_location(ih);
+	deh = (struct reiserfs_de_head *)item;
+	location = get_pi_item_len(pi);
+	for (i = 0; i < entry_count; i++, deh++) {
+		fread8(&mask);
+		fread_le16(&entry_len);
+		location -= entry_len;
+		set_deh_location(deh, location);
+		fread(item + location, entry_len, 1, stdin);
+
+		/* find name length */
+		if (*(item + location + entry_len - 1))
+			namelen = entry_len;
+		else
+			namelen = strlen(item + location);
+
+		fread32(&deh->deh2_objectid);
+		if (mask & HAS_DIR_ID)
+			fread32(&deh->deh2_dir_id);
+		else
+			set_deh_dirid(deh, get_key_objectid(&ih->ih_key));
+
+		if (*(item + location) == '.' && namelen == 1)
+			/* old or new "." */
+			set_deh_offset(deh, DOT_OFFSET);
+		else if (*(item + location) == '.'
+			 && *(item + location + 1) == '.' && namelen == 2)
+			/* old or new ".." */
+			set_deh_offset(deh, DOT_DOT_OFFSET);
+		else if (hash_func)
+			set_deh_offset(deh,
+				       hash_value(hash_func, item + location,
+						  namelen));
+		if (mask & HAS_GEN_COUNTER) {
+			fread_le16(&gen_counter);
+			set_deh_offset(deh, get_deh_offset(deh) | gen_counter);
+		}
+
+		if (mask & HAS_STATE)
+			fread16(&deh->deh2_state);
+		else
+			set_deh_state(deh, (1 << DEH_Visible2));
 	}
 
-	if (mask & HAS_STATE)
-	    fread16 (&deh->deh2_state);
-	else
-	    set_deh_state (deh, (1 << DEH_Visible2));
-    }
-
-    return;
+	return;
 }
 
-
 /* struct packed_item is already unpacked */
-static void unpack_stat_data (struct packed_item * pi, struct buffer_head * bh,
-			      struct item_head * ih)
+static void unpack_stat_data(struct packed_item *pi, struct buffer_head *bh,
+			     struct item_head *ih)
 {
-    if (!(get_pi_mask(pi) & IH_FREE_SPACE)) {
-        /* ih_free_space was not packed - set default */
-        set_ih_entry_count (ih, 0xffff);
-    }
-
-    if (get_ih_key_format (ih) == KEY_FORMAT_1) {
-	/* stat data comes in the following format:
-	   if this is old stat data:
-	   mode - 16 bits
-	   nlink - 16 bits
-	   size - 32 bits
-	   blocks/rdev - 32 bits
-	   maybe first_direct byte 32 bits
-	*/
-	struct stat_data_v1 * sd;
-
-	sd = (struct stat_data_v1 *)B_I_PITEM (bh, ih);
-	memset (sd, 0, sizeof (sd));
-
-	fread16 (&sd->sd_mode);
-	fread16 (&sd->sd_nlink);
-	fread32 (&sd->sd_size);
-	fread32 (&sd->u.sd_blocks);
-	
-	if (get_pi_mask(pi) & WITH_SD_FIRST_DIRECT_BYTE) {
-	    fread32 (&sd->sd_first_direct_byte);
-	} else {
-	    sd->sd_first_direct_byte = 0xffffffff;
-	}
-    } else {
-	/* for new stat data
-	   mode - 16 bits
-	   nlink in either 16 or 32 bits
-	   size in either 32 or 64 bits
-	   blocks - 32 bits
-	*/
-	struct stat_data * sd;
-
-	sd = (struct stat_data *)B_I_PITEM (bh, ih);
-	memset (sd, 0, sizeof (sd));
-	
-	fread16 (&sd->sd_mode);
-
-	if (get_pi_mask(pi) & NLINK_BITS_32) {
-	    fread32 (&sd->sd_nlink);
-	} else {
-	    __u16 nlink16;
-
-	    fread16 (&nlink16);
-            set_sd_v2_nlink (sd, le16_to_cpu(nlink16));
+	if (!(get_pi_mask(pi) & IH_FREE_SPACE)) {
+		/* ih_free_space was not packed - set default */
+		set_ih_entry_count(ih, 0xffff);
 	}
 
-	if (get_pi_mask(pi) & SIZE_BITS_64) {
-	    fread64 (&sd->sd_size);
+	if (get_ih_key_format(ih) == KEY_FORMAT_1) {
+		/* stat data comes in the following format:
+		   if this is old stat data:
+		   mode - 16 bits
+		   nlink - 16 bits
+		   size - 32 bits
+		   blocks/rdev - 32 bits
+		   maybe first_direct byte 32 bits
+		 */
+		struct stat_data_v1 *sd;
+
+		sd = (struct stat_data_v1 *)B_I_PITEM(bh, ih);
+		memset(sd, 0, sizeof(sd));
+
+		fread16(&sd->sd_mode);
+		fread16(&sd->sd_nlink);
+		fread32(&sd->sd_size);
+		fread32(&sd->u.sd_blocks);
+
+		if (get_pi_mask(pi) & WITH_SD_FIRST_DIRECT_BYTE) {
+			fread32(&sd->sd_first_direct_byte);
+		} else {
+			sd->sd_first_direct_byte = 0xffffffff;
+		}
 	} else {
-	    __u32 size32;
-
-            /* We need the endian conversions since sd->sd_size is 64 bit */
-	    fread_le32 (&size32);
-            set_sd_v2_size (sd, size32 );
+		/* for new stat data
+		   mode - 16 bits
+		   nlink in either 16 or 32 bits
+		   size in either 32 or 64 bits
+		   blocks - 32 bits
+		 */
+		struct stat_data *sd;
+
+		sd = (struct stat_data *)B_I_PITEM(bh, ih);
+		memset(sd, 0, sizeof(sd));
+
+		fread16(&sd->sd_mode);
+
+		if (get_pi_mask(pi) & NLINK_BITS_32) {
+			fread32(&sd->sd_nlink);
+		} else {
+			__u16 nlink16;
+
+			fread16(&nlink16);
+			set_sd_v2_nlink(sd, le16_to_cpu(nlink16));
+		}
+
+		if (get_pi_mask(pi) & SIZE_BITS_64) {
+			fread64(&sd->sd_size);
+		} else {
+			__u32 size32;
+
+			/* We need the endian conversions since sd->sd_size is 64 bit */
+			fread_le32(&size32);
+			set_sd_v2_size(sd, size32);
+		}
+
+		fread32(&sd->sd_blocks);
 	}
 
-	fread32 (&sd->sd_blocks);
-    }
-
-    return;
+	return;
 }
 
-
 /* indirect item comes either in packed form or as is. ih_free_space
    can go first */
-static void unpack_indirect (struct packed_item * pi, struct buffer_head * bh,
-			     struct item_head * ih)
+static void unpack_indirect(struct packed_item *pi, struct buffer_head *bh,
+			    struct item_head *ih)
 {
-    __u32 * ind_item, * end;
-    int i;
-    __u16 v16;
+	__u32 *ind_item, *end;
+	int i;
+	__u16 v16;
 
-    if (!(get_pi_mask(pi) & IH_FREE_SPACE)) {
-        /* ih_free_space was not packed - set default */
-        set_ih_entry_count (ih, 0);
-    }
+	if (!(get_pi_mask(pi) & IH_FREE_SPACE)) {
+		/* ih_free_space was not packed - set default */
+		set_ih_entry_count(ih, 0);
+	}
 
-    ind_item = (__u32 *)B_I_PITEM (bh, ih);
+	ind_item = (__u32 *) B_I_PITEM(bh, ih);
 
-    if (get_pi_mask(pi) & SAFE_LINK) {
-	d32_put(ind_item, 0, get_key_dirid(&ih->ih_key));
-	set_key_dirid(&ih->ih_key, (__u32)-1);
-	return;
-    }
+	if (get_pi_mask(pi) & SAFE_LINK) {
+		d32_put(ind_item, 0, get_key_dirid(&ih->ih_key));
+		set_key_dirid(&ih->ih_key, (__u32) - 1);
+		return;
+	}
 
-    if (get_pi_mask(pi) & WHOLE_INDIRECT) {
-	fread (ind_item, get_pi_item_len(pi), 1, stdin);
-	return;
-    }
-
-    end = ind_item + I_UNFM_NUM (ih);
-    while (ind_item < end) {
-        __u32 base;
-	fread32 (ind_item);
-	fread_le16 (&v16);
-        base = d32_get(ind_item, 0);
-	for (i = 1; i < v16; i ++) {
-	    if (base != 0)
-		d32_put(ind_item, i, base + i);
-	    else
-		d32_put(ind_item, i, 0);
+	if (get_pi_mask(pi) & WHOLE_INDIRECT) {
+		fread(ind_item, get_pi_item_len(pi), 1, stdin);
+		return;
 	}
-	ind_item += i;
-    }
-    return;
-}
 
+	end = ind_item + I_UNFM_NUM(ih);
+	while (ind_item < end) {
+		__u32 base;
+		fread32(ind_item);
+		fread_le16(&v16);
+		base = d32_get(ind_item, 0);
+		for (i = 1; i < v16; i++) {
+			if (base != 0)
+				d32_put(ind_item, i, base + i);
+			else
+				d32_put(ind_item, i, 0);
+		}
+		ind_item += i;
+	}
+	return;
+}
 
 // FIXME: we have no way to preserve symlinks
-static void unpack_direct (struct packed_item * pi, struct buffer_head * bh,
-			   struct item_head * ih)
+static void unpack_direct(struct packed_item *pi, struct buffer_head *bh,
+			  struct item_head *ih)
 {
-    __u32 * d_item = (__u32 *)B_I_PITEM (bh, ih);
-
-    if (!(get_pi_mask(pi) & IH_FREE_SPACE))
-        /* ih_free_space was not packed - set default */
-        set_ih_entry_count (ih, 0xffff);
-
-    if (get_pi_mask(pi) & SAFE_LINK) {
-	d32_put(d_item, 0, get_key_dirid(&ih->ih_key));
-	set_key_dirid(&ih->ih_key, (__u32)-1);
-    } else {
-	memset (d_item, 'a', get_pi_item_len(pi));
-    }
-    return;
-}
+	__u32 *d_item = (__u32 *) B_I_PITEM(bh, ih);
 
+	if (!(get_pi_mask(pi) & IH_FREE_SPACE))
+		/* ih_free_space was not packed - set default */
+		set_ih_entry_count(ih, 0xffff);
 
-static void unpack_leaf (int dev, hashf_t hash_func, __u16 blocksize)
-{
-    static int unpacked_leaves = 0;
-    struct buffer_head * bh;
-    struct packed_item pi;
-    struct item_head * ih;
-    int i;
-    __u16 v16;
-    __u32 v32;
-    
-    /* block number */
-    fread_le32 (&v32);
-
-
-    /* item number */
-    fread_le16 (&v16);
-
-    if (verbose)
-	reiserfs_warning (stderr, "leaf %d: %d items\n", v32, v16);
-
-    bh = getblk (dev, v32, blocksize);
-    if (!bh)
-	die ("unpack_leaf: getblk failed");
-
-    set_blkh_nr_items (B_BLK_HEAD (bh), v16);
-    set_blkh_level (B_BLK_HEAD (bh), DISK_LEAF_NODE_LEVEL);
-    set_blkh_free_space (B_BLK_HEAD (bh), MAX_FREE_SPACE (bh->b_size));
-    
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < get_blkh_nr_items (B_BLK_HEAD (bh)); i ++, ih ++) {
-#if 0
-	fread32 (&v32);
-	if (v32 != ITEM_START_MAGIC)
-	    die ("unpack_leaf: no start item magic found: block %lu, item %i",
-		 bh->b_blocknr, i);
-#endif	
-
-	fread (&pi, sizeof (struct packed_item), 1, stdin);
-	
-	/* dir_id - if it is there */
-	if (get_pi_mask(&pi) & DIR_ID) {
-	    fread32 (&v32);
-            set_key_dirid (&ih->ih_key, le32_to_cpu(v32));
+	if (get_pi_mask(pi) & SAFE_LINK) {
+		d32_put(d_item, 0, get_key_dirid(&ih->ih_key));
+		set_key_dirid(&ih->ih_key, (__u32) - 1);
 	} else {
-	    if (!i)
-		die ("unpack_leaf: dir_id is not set");
-	    set_key_dirid (&ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
+		memset(d_item, 'a', get_pi_item_len(pi));
 	}
+	return;
+}
 
-	/* object_id - if it is there */
-	if (get_pi_mask(&pi) & OBJECT_ID) {
-	    fread32 (&v32);
-            set_key_objectid (&ih->ih_key, le32_to_cpu(v32));
-	} else {
-	    if (!i)
-		die ("unpack_leaf: object_id is not set");
-	    set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-	}
+static void unpack_leaf(int dev, hashf_t hash_func, __u16 blocksize)
+{
+	static int unpacked_leaves = 0;
+	struct buffer_head *bh;
+	struct packed_item pi;
+	struct item_head *ih;
+	int i;
+	__u16 v16;
+	__u32 v32;
 
-	// we need to set item format before offset unpacking
-	set_ih_key_format (ih, (get_pi_mask(&pi) & NEW_FORMAT) ? KEY_FORMAT_2 : KEY_FORMAT_1);
+	/* block number */
+	fread_le32(&v32);
 
-	// offset
-	unpack_offset (&pi, ih, bh->b_size);
+	/* item number */
+	fread_le16(&v16);
 
-	/* type */
-	unpack_type (&pi, ih);
+	if (verbose)
+		reiserfs_warning(stderr, "leaf %d: %d items\n", v32, v16);
 
-	/* ih_free_space and ih_format */
-	if (get_pi_mask(&pi) & IH_FREE_SPACE) {
-	    fread16 (&v16);
-	    set_ih_entry_count (ih, le16_to_cpu(v16));
-	}
+	bh = getblk(dev, v32, blocksize);
+	if (!bh)
+		die("unpack_leaf: getblk failed");
 
-	if (get_pi_mask(&pi) & IH_FORMAT)
-	    fread16 (&ih->ih_format);
-
-	/* item length and item location */
-	set_ih_item_len (ih, get_pi_item_len(&pi));
-	set_ih_location (ih, (i ? get_ih_location (ih - 1) : bh->b_size) - get_pi_item_len(&pi));
-
-	// item itself
-	if (is_direct_ih (ih)) {
-	    unpack_direct (&pi, bh, ih);
-	} else if (is_indirect_ih (ih)) {
-	    unpack_indirect (&pi, bh, ih);
-	} else if (is_direntry_ih (ih)) {
-	    unpack_direntry (&pi, bh, ih, hash_func);
-	} else if (is_stat_data_ih (ih)) {
-	    unpack_stat_data (&pi, bh, ih);
-	}
-	set_blkh_free_space (B_BLK_HEAD (bh), get_blkh_free_space (B_BLK_HEAD (bh)) -
-			     (IH_SIZE + get_ih_item_len (ih)));
+	set_blkh_nr_items(B_BLK_HEAD(bh), v16);
+	set_blkh_level(B_BLK_HEAD(bh), DISK_LEAF_NODE_LEVEL);
+	set_blkh_free_space(B_BLK_HEAD(bh), MAX_FREE_SPACE(bh->b_size));
 
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
 #if 0
-	fread32 (&v32);
-	if (v32 != ITEM_END_MAGIC)
-	    die ("unpack_leaf: no end item magic found: block %lu, item %i",
-		 bh->b_blocknr, i);
-	if (verbose)
-	    reiserfs_warning (stderr, "%d: %H\n", i, ih);
+		fread32(&v32);
+		if (v32 != ITEM_START_MAGIC)
+			die("unpack_leaf: no start item magic found: block %lu, item %i", bh->b_blocknr, i);
 #endif
-    }
-
-    fread_le16 (&v16);
-    if (v16 != LEAF_END_MAGIC)
-	die ("unpack_leaf: wrong end signature found - %x, block %lu", 
-	     v16, bh->b_blocknr);
 
-    mark_buffer_uptodate (bh, 1);
-    mark_buffer_dirty (bh);
-    bwrite (bh);
-    /*
-    if (!not_data_block (bh->b_blocknr))
-	data_blocks_unpacked ++;
-    */
-    brelse (bh);
+		fread(&pi, sizeof(struct packed_item), 1, stdin);
+
+		/* dir_id - if it is there */
+		if (get_pi_mask(&pi) & DIR_ID) {
+			fread32(&v32);
+			set_key_dirid(&ih->ih_key, le32_to_cpu(v32));
+		} else {
+			if (!i)
+				die("unpack_leaf: dir_id is not set");
+			set_key_dirid(&ih->ih_key,
+				      get_key_dirid(&(ih - 1)->ih_key));
+		}
+
+		/* object_id - if it is there */
+		if (get_pi_mask(&pi) & OBJECT_ID) {
+			fread32(&v32);
+			set_key_objectid(&ih->ih_key, le32_to_cpu(v32));
+		} else {
+			if (!i)
+				die("unpack_leaf: object_id is not set");
+			set_key_objectid(&ih->ih_key,
+					 get_key_objectid(&(ih - 1)->ih_key));
+		}
+
+		// we need to set item format before offset unpacking
+		set_ih_key_format(ih,
+				  (get_pi_mask(&pi) & NEW_FORMAT) ? KEY_FORMAT_2
+				  : KEY_FORMAT_1);
+
+		// offset
+		unpack_offset(&pi, ih, bh->b_size);
+
+		/* type */
+		unpack_type(&pi, ih);
+
+		/* ih_free_space and ih_format */
+		if (get_pi_mask(&pi) & IH_FREE_SPACE) {
+			fread16(&v16);
+			set_ih_entry_count(ih, le16_to_cpu(v16));
+		}
+
+		if (get_pi_mask(&pi) & IH_FORMAT)
+			fread16(&ih->ih_format);
+
+		/* item length and item location */
+		set_ih_item_len(ih, get_pi_item_len(&pi));
+		set_ih_location(ih,
+				(i ? get_ih_location(ih - 1) : bh->b_size) -
+				get_pi_item_len(&pi));
+
+		// item itself
+		if (is_direct_ih(ih)) {
+			unpack_direct(&pi, bh, ih);
+		} else if (is_indirect_ih(ih)) {
+			unpack_indirect(&pi, bh, ih);
+		} else if (is_direntry_ih(ih)) {
+			unpack_direntry(&pi, bh, ih, hash_func);
+		} else if (is_stat_data_ih(ih)) {
+			unpack_stat_data(&pi, bh, ih);
+		}
+		set_blkh_free_space(B_BLK_HEAD(bh),
+				    get_blkh_free_space(B_BLK_HEAD(bh)) -
+				    (IH_SIZE + get_ih_item_len(ih)));
 
-    if (what_unpacked)
-	reiserfs_bitmap_set_bit (what_unpacked, bh->b_blocknr);
-    /*unpacked ++;*/
+#if 0
+		fread32(&v32);
+		if (v32 != ITEM_END_MAGIC)
+			die("unpack_leaf: no end item magic found: block %lu, item %i", bh->b_blocknr, i);
+		if (verbose)
+			reiserfs_warning(stderr, "%d: %H\n", i, ih);
+#endif
+	}
 
-    if (!(++ unpacked_leaves % 10))
-	fprintf (stderr, "#");
+	fread_le16(&v16);
+	if (v16 != LEAF_END_MAGIC)
+		die("unpack_leaf: wrong end signature found - %x, block %lu",
+		    v16, bh->b_blocknr);
+
+	mark_buffer_uptodate(bh, 1);
+	mark_buffer_dirty(bh);
+	bwrite(bh);
+	/*
+	   if (!not_data_block (bh->b_blocknr))
+	   data_blocks_unpacked ++;
+	 */
+	brelse(bh);
+
+	if (what_unpacked)
+		reiserfs_bitmap_set_bit(what_unpacked, bh->b_blocknr);
+	/*unpacked ++; */
+
+	if (!(++unpacked_leaves % 10))
+		fprintf(stderr, "#");
 }
 
-
-static void unpack_full_block (int dev, int blocksize)
+static void unpack_full_block(int dev, int blocksize)
 {
-    static int full_blocks_unpacked = 0;
-    __u32 block;
-    struct buffer_head * bh;
-
-    fread_le32 (&block);
-
-    if (verbose)
-	fprintf (stderr, "full #%d\n", block);
-
-    bh = getblk (dev, block, blocksize);
-    if (!bh)
-	die ("unpack_full_block: getblk failed");
-
-    fread (bh->b_data, bh->b_size, 1, stdin);
-
-    if (who_is_this (bh->b_data, bh->b_size) == THE_SUPER && !what_unpacked) {
-	unsigned long blocks;
-	struct buffer_head * tmp;
-	
-	blocks = get_sb_block_count ((struct reiserfs_super_block *)(bh->b_data));
-	fprintf (stderr, "There were %lu blocks on the device\n", blocks);
-	what_unpacked = reiserfs_create_bitmap (blocks);
-
-	/* make file as long as filesystem is */
-	tmp = getblk (dev, blocks - 1, blocksize);
-	mark_buffer_dirty (tmp);
-	mark_buffer_uptodate (tmp, 0);
-	bwrite (tmp);
-	brelse (tmp);
-    }
-
-    mark_buffer_uptodate (bh, 1);
-    mark_buffer_dirty (bh);
-    bwrite (bh);
+	static int full_blocks_unpacked = 0;
+	__u32 block;
+	struct buffer_head *bh;
+
+	fread_le32(&block);
+
+	if (verbose)
+		fprintf(stderr, "full #%d\n", block);
+
+	bh = getblk(dev, block, blocksize);
+	if (!bh)
+		die("unpack_full_block: getblk failed");
+
+	fread(bh->b_data, bh->b_size, 1, stdin);
+
+	if (who_is_this(bh->b_data, bh->b_size) == THE_SUPER && !what_unpacked) {
+		unsigned long blocks;
+		struct buffer_head *tmp;
+
+		blocks =
+		    get_sb_block_count((struct reiserfs_super_block *)(bh->
+								       b_data));
+		fprintf(stderr, "There were %lu blocks on the device\n",
+			blocks);
+		what_unpacked = reiserfs_create_bitmap(blocks);
+
+		/* make file as long as filesystem is */
+		tmp = getblk(dev, blocks - 1, blocksize);
+		mark_buffer_dirty(tmp);
+		mark_buffer_uptodate(tmp, 0);
+		bwrite(tmp);
+		brelse(tmp);
+	}
+
+	mark_buffer_uptodate(bh, 1);
+	mark_buffer_dirty(bh);
+	bwrite(bh);
 /*
     if (!not_data_block (bh->b_blocknr))
 	data_blocks_unpacked ++;
 */
-    brelse (bh);
+	brelse(bh);
 
-    if (what_unpacked)
-	reiserfs_bitmap_set_bit (what_unpacked, block);
-    /*unpacked ++;*/
+	if (what_unpacked)
+		reiserfs_bitmap_set_bit(what_unpacked, block);
+	/*unpacked ++; */
 
-    if (!(++ full_blocks_unpacked % 50))
-	fprintf (stderr, ".");
+	if (!(++full_blocks_unpacked % 50))
+		fprintf(stderr, ".");
 }
 
-
 /* just skip bitmaps of unformatted nodes */
-static void unpack_unformatted_bitmap (int dev, int blocksize)
+static void unpack_unformatted_bitmap(int dev, int blocksize)
 {
-    __u16 bmap_num;
-    __u32 block_count;
-    int i;
-    char * buf;
- 
-    fread_le16 (&bmap_num);
-    fread_le32 (&block_count);
-    
-    buf = malloc (blocksize);
-    if (!buf)
-	reiserfs_panic ("unpack_unformatted_bitmap: malloc failed: %m");
-
-    for (i = 0; i < bmap_num; i ++) {
-	if (fread (buf, blocksize, 1, stdin) != 1)
-	    reiserfs_panic ("unpack_unformatted_bitmap: "
-			    "could not read bitmap #%d: %m", i);
-    }
-    free (buf);
+	__u16 bmap_num;
+	__u32 block_count;
+	int i;
+	char *buf;
+
+	fread_le16(&bmap_num);
+	fread_le32(&block_count);
+
+	buf = malloc(blocksize);
+	if (!buf)
+		reiserfs_panic("unpack_unformatted_bitmap: malloc failed: %m");
+
+	for (i = 0; i < bmap_num; i++) {
+		if (fread(buf, blocksize, 1, stdin) != 1)
+			reiserfs_panic("unpack_unformatted_bitmap: "
+				       "could not read bitmap #%d: %m", i);
+	}
+	free(buf);
 }
 
-
 // read packed reiserfs partition metadata from stdin
-void unpack_partition (int fd, int jfd)
+void unpack_partition(int fd, int jfd)
 {
-    __u32 magic32;
-    long position;
-    __u16 magic16;
-    __u16 blocksize;
-    int dev = fd;
-    
-    fread_le32 (&magic32);
-    if (magic32 != REISERFS_SUPER_MAGIC)
-	die ("unpack_partition: reiserfs magic number (0x%x) not found - %x\n",
-             REISERFS_SUPER_MAGIC, magic32);
-    
-    fread_le16 (&blocksize);
-    
-    if (verbose)
-	fprintf (stderr, "Blocksize %d\n", blocksize);
-    
-    while (!feof (stdin)) {
-	char c[2];
-
-	fread (c, 1, 1, stdin);
-	switch (c[0]) {
-	case '.':
-	    if (verbose)
-		fprintf (stderr, "\".\" skipped\n");
-	    continue;
-
-	case '1':
-	    fread (c, 1, 1, stdin); /* that was 100%, read in first 0 */
-	case '2':
-	case '4':
-	case '6':
-	case '8':
-	    fread (c, 1, 1, stdin);
-	case '0':
-	    fread (c + 1, 1, 1, stdin); /* read % */
-		
-	    if (c[0] != '0' || c[1] != '%')
-		die ("0%% expected\n");
-
-	    if (verbose)
-		fprintf (stderr, "0%% skipped\n");
-	    continue;
-	}
+	__u32 magic32;
+	long position;
+	__u16 magic16;
+	__u16 blocksize;
+	int dev = fd;
+
+	fread_le32(&magic32);
+	if (magic32 != REISERFS_SUPER_MAGIC)
+		die("unpack_partition: reiserfs magic number (0x%x) not found - %x\n", REISERFS_SUPER_MAGIC, magic32);
 
-	fread16 (&magic16);
-	magic16 = le16_to_cpu(magic16);
-	
-	switch (magic16 & 0xff) {
-	case LEAF_START_MAGIC:
-	    leaves ++;
-	    unpack_leaf (dev, code2func (magic16 >> 8), blocksize);
-	    break;
-	    
-	case SEPARATED_JOURNAL_START_MAGIC:
-	    if (Default_journal)
-		die ("file name for separated journal has to be specified");	
-	    dev = jfd;
-	    break;    
-
-	case SEPARATED_JOURNAL_END_MAGIC:
-	    dev = fd;
-	    break;
-	    
-	case FULL_BLOCK_START_MAGIC:
-	    full ++;
-	    unpack_full_block (dev, blocksize);
-	    break;
-
-	case UNFORMATTED_BITMAP_START_MAGIC:
-	    fprintf (stderr, "\nBitmap of unformatted - ignored\n");
-	    unpack_unformatted_bitmap (dev, blocksize);
-	    break;
-	    
-	case END_MAGIC:
-	    goto out;
-
-	default:
-	    position = ftell(stdin);
-	    if (position == ~(long)0)
-		die ("unpack_partition: bad magic found - %x", magic16 & 0xff);
-	    else
-		die ("unpack_partition: bad magic found - %x, position %lu", 
-		    magic16 & 0xff, ftell(stdin));
+	fread_le16(&blocksize);
+
+	if (verbose)
+		fprintf(stderr, "Blocksize %d\n", blocksize);
+
+	while (!feof(stdin)) {
+		char c[2];
+
+		fread(c, 1, 1, stdin);
+		switch (c[0]) {
+		case '.':
+			if (verbose)
+				fprintf(stderr, "\".\" skipped\n");
+			continue;
+
+		case '1':
+			fread(c, 1, 1, stdin);	/* that was 100%, read in first 0 */
+		case '2':
+		case '4':
+		case '6':
+		case '8':
+			fread(c, 1, 1, stdin);
+		case '0':
+			fread(c + 1, 1, 1, stdin);	/* read % */
+
+			if (c[0] != '0' || c[1] != '%')
+				die("0%% expected\n");
+
+			if (verbose)
+				fprintf(stderr, "0%% skipped\n");
+			continue;
+		}
+
+		fread16(&magic16);
+		magic16 = le16_to_cpu(magic16);
+
+		switch (magic16 & 0xff) {
+		case LEAF_START_MAGIC:
+			leaves++;
+			unpack_leaf(dev, code2func(magic16 >> 8), blocksize);
+			break;
+
+		case SEPARATED_JOURNAL_START_MAGIC:
+			if (Default_journal)
+				die("file name for separated journal has to be specified");
+			dev = jfd;
+			break;
+
+		case SEPARATED_JOURNAL_END_MAGIC:
+			dev = fd;
+			break;
+
+		case FULL_BLOCK_START_MAGIC:
+			full++;
+			unpack_full_block(dev, blocksize);
+			break;
+
+		case UNFORMATTED_BITMAP_START_MAGIC:
+			fprintf(stderr, "\nBitmap of unformatted - ignored\n");
+			unpack_unformatted_bitmap(dev, blocksize);
+			break;
+
+		case END_MAGIC:
+			goto out;
+
+		default:
+			position = ftell(stdin);
+			if (position == ~(long)0)
+				die("unpack_partition: bad magic found - %x",
+				    magic16 & 0xff);
+			else
+				die("unpack_partition: bad magic found - %x, position %lu", magic16 & 0xff, ftell(stdin));
+		}
 	}
-    }
 out:
-    fprintf (stderr, "Unpacked %d leaves, %d full blocks\n", leaves, full);
+	fprintf(stderr, "Unpacked %d leaves, %d full blocks\n", leaves, full);
 
-
-    /*    fclose (block_list);*/
+	/*    fclose (block_list); */
 }
 
+int do_unpack(char *host, char *j_filename, char *filename, int verbose)
+{
+	int fd, fdj = -2;
+	struct rlimit lim = { RLIM_INFINITY, RLIM_INFINITY };
+
+	if (filename == NULL)
+		filename = ".bitmap";
 
-int do_unpack(char *host, char *j_filename, char *filename, int verbose) {
-    int fd, fdj = -2;
-    struct rlimit lim = {RLIM_INFINITY, RLIM_INFINITY};
+	if (j_filename)
+		Default_journal = 0;
 
-    if (filename == NULL)
-	    filename = ".bitmap";
-    
-    if (j_filename)
-	    Default_journal = 0;
-    
-    /* with this 2.4.0-test9's file_write does not send SIGXFSZ */
-    if (setrlimit (RLIMIT_FSIZE, &lim)) {
-	fprintf  (stderr, "sertlimit failed: %m\n");
-    }
+	/* with this 2.4.0-test9's file_write does not send SIGXFSZ */
+	if (setrlimit(RLIMIT_FSIZE, &lim)) {
+		fprintf(stderr, "sertlimit failed: %m\n");
+	}
 
-    if (misc_device_mounted(host) > 0) {
-	fprintf(stderr, "%s seems mounted, umount it first\n", host);
-	return 0;
-    }
-  
-    fd = open (host, O_RDWR | O_LARGEFILE);
-    if (fd == -1) {
-	perror ("open failed");
-	return 0;
-    }
+	if (misc_device_mounted(host) > 0) {
+		fprintf(stderr, "%s seems mounted, umount it first\n", host);
+		return 0;
+	}
 
-    if (!Default_journal) {
-	fdj = open (j_filename, O_RDWR | O_LARGEFILE);
-	if (fdj == -1) {
-	    perror ("open failed");
-	    return 0;
+	fd = open(host, O_RDWR | O_LARGEFILE);
+	if (fd == -1) {
+		perror("open failed");
+		return 0;
 	}
-    }
 
-    unpack_partition (fd, fdj);
+	if (!Default_journal) {
+		fdj = open(j_filename, O_RDWR | O_LARGEFILE);
+		if (fdj == -1) {
+			perror("open failed");
+			return 0;
+		}
+	}
+
+	unpack_partition(fd, fdj);
 
-    if (what_unpacked && filename) {
-        FILE * file = open_file(filename, "w+");
-        reiserfs_bitmap_save (file,  what_unpacked);
-        close_file(file);
-    }
+	if (what_unpacked && filename) {
+		FILE *file = open_file(filename, "w+");
+		reiserfs_bitmap_save(file, what_unpacked);
+		close_file(file);
+	}
 
-    close (fd);
-    if (!Default_journal)
-	close (fdj);	
-    return 0;
+	close(fd);
+	if (!Default_journal)
+		close(fdj);
+	return 0;
 }
diff --git a/fsck/check_tree.c b/fsck/check_tree.c
index fefd428..9c56e4c 100644
--- a/fsck/check_tree.c
+++ b/fsck/check_tree.c
@@ -7,80 +7,81 @@
 
 #if 0
 struct check_relocated {
-    __u32 old_dir_id;
-    __u32 old_objectid;
-    /*mode_t mode;*/
-    struct check_relocated * next;
+	__u32 old_dir_id;
+	__u32 old_objectid;
+	/*mode_t mode; */
+	struct check_relocated *next;
 };
 
-static struct check_relocated * relocated_list;
+static struct check_relocated *relocated_list;
 
-void to_be_relocated (struct reiserfs_key *key)
+void to_be_relocated(struct reiserfs_key *key)
 {
-    struct check_relocated * cur, * prev, * new_relocated;
+	struct check_relocated *cur, *prev, *new_relocated;
 
-    cur = relocated_list;
-    prev = 0;
+	cur = relocated_list;
+	prev = 0;
 
-    while (cur && comp_short_keys(key, (struct reiserfs_key *)cur) != 1) {
-	if (comp_short_keys (key, (struct reiserfs_key *)cur) == 0)
-	    return;
-	prev = cur;
-        cur = cur->next;
-    }
-        
-    new_relocated = getmem (sizeof (struct check_relocated));
-    copy_short_key ((struct reiserfs_key *)new_relocated, key);
-             
-    if (prev) {
-        new_relocated->next = prev->next;
-        prev->next = new_relocated;
-    } else {
-        new_relocated->next = relocated_list;
-        relocated_list = new_relocated;
-    }
+	while (cur && comp_short_keys(key, (struct reiserfs_key *)cur) != 1) {
+		if (comp_short_keys(key, (struct reiserfs_key *)cur) == 0)
+			return;
+		prev = cur;
+		cur = cur->next;
+	}
+
+	new_relocated = getmem(sizeof(struct check_relocated));
+	copy_short_key((struct reiserfs_key *)new_relocated, key);
+
+	if (prev) {
+		new_relocated->next = prev->next;
+		prev->next = new_relocated;
+	} else {
+		new_relocated->next = relocated_list;
+		relocated_list = new_relocated;
+	}
 }
 
-int should_be_relocated (struct reiserfs_key *key)
+int should_be_relocated(struct reiserfs_key *key)
 {
-    struct check_relocated *cur, *prev;
-    int ret = 0;
+	struct check_relocated *cur, *prev;
+	int ret = 0;
 
-    if (!key)
-	return 0;
-    
-    cur = relocated_list;
-
-    prev = NULL;
-    while (cur && comp_short_keys(key, (struct reiserfs_key *)cur) != 1) {
-	if (comp_short_keys (key, (struct reiserfs_key *)cur) == 0) {
-	    ret = 1;
-	    break;
+	if (!key)
+		return 0;
+
+	cur = relocated_list;
+
+	prev = NULL;
+	while (cur && comp_short_keys(key, (struct reiserfs_key *)cur) != 1) {
+		if (comp_short_keys(key, (struct reiserfs_key *)cur) == 0) {
+			ret = 1;
+			break;
+		}
+		prev = cur;
+		cur = cur->next;
 	}
-	prev = cur;
-	cur = cur->next;
-    }
- 
-    if (ret) {
-	/* cur is found */
-	if (prev) /* not the first */
-	    prev->next = cur->next;
-	else /* first */
-	    relocated_list = cur->next;
-	freemem (cur);
-    }
- 
-    return ret;    
+
+	if (ret) {
+		/* cur is found */
+		if (prev)	/* not the first */
+			prev->next = cur->next;
+		else		/* first */
+			relocated_list = cur->next;
+		freemem(cur);
+	}
+
+	return ret;
 }
 
-void clear_relocated_list() {
-    struct check_relocated *next;
+void clear_relocated_list()
+{
+	struct check_relocated *next;
 
-    while (relocated_list) {
-        next = relocated_list->next;
-        freemem (relocated_list);
-        relocated_list = next;
-    }
+	while (relocated_list) {
+		next = relocated_list->next;
+		freemem(relocated_list);
+		relocated_list = next;
+	}
 }
 
 #endif
@@ -100,152 +101,146 @@ void clear_relocated_list() {
 // 5. delimiting keys are incorrect
 //      
 
-
-
 /* mark every block we see in the tree in control bitmap, so, when to make
    sure, that no blocks are pointed to from more than one place we use
    additional bitmap (control_bitmap). If we see pointer to a block we set
    corresponding bit to 1. If it is set already - run fsck with --rebuild-tree */
-static reiserfs_bitmap_t * control_bitmap;
-static reiserfs_bitmap_t * source_bitmap;
+static reiserfs_bitmap_t *control_bitmap;
+static reiserfs_bitmap_t *source_bitmap;
 
 static int tree_scanning_failed = 0;
 
-
 /* 1 if block is not marked as used in the bitmap */
-static int is_block_free (reiserfs_filsys_t * fs, unsigned long block)
+static int is_block_free(reiserfs_filsys_t *fs, unsigned long block)
 {
-    return !reiserfs_bitmap_test_bit (source_bitmap, block);
+	return !reiserfs_bitmap_test_bit(source_bitmap, block);
 }
 
-
 /*static unsigned int hits = 0;*/
 
 /* we have seen this block in the tree, mark corresponding bit in the
    control bitmap */
-static void we_met_it (unsigned long block)
+static void we_met_it(unsigned long block)
 {
-    reiserfs_bitmap_set_bit (control_bitmap, block);
-    /*hits ++;*/
+	reiserfs_bitmap_set_bit(control_bitmap, block);
+	/*hits ++; */
 }
 
-
 /* have we seen this block somewhere in the tree before? */
-static int did_we_meet_it (unsigned long block)
+static int did_we_meet_it(unsigned long block)
 {
-    return reiserfs_bitmap_test_bit (control_bitmap, block);
+	return reiserfs_bitmap_test_bit(control_bitmap, block);
 }
 
-
-static void init_control_bitmap (reiserfs_filsys_t * fs)
+static void init_control_bitmap(reiserfs_filsys_t *fs)
 {
-    unsigned int i;
-    unsigned long block;
-    unsigned long reserved;
-    unsigned int blocks = get_sb_block_count(fs->fs_ondisk_sb);
-    
-
-    control_bitmap = reiserfs_create_bitmap(blocks);
-    if (!control_bitmap)
-	die ("init_control_bitmap: Failed to allocate a control bitmap.");
-
-    /*printf ("Initially number of zeros in control bitmap %d\n", 
-	      reiserfs_bitmap_zeros (control_bitmap));*/
-
-    /* skipped and super block */
-    for (i = 0; i <= fs->fs_super_bh->b_blocknr; i ++)
-    	we_met_it (i);
-
-    /*printf ("SKIPPED: %u blocks marked used (%d)\n", hits,
-              reiserfs_bitmap_zeros (control_bitmap));
-      hits = 0;*/
-
-    /* bitmaps */
-    block = fs->fs_super_bh->b_blocknr + 1;
-    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
-        we_met_it (block);
-
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * 
-		    (fs->fs_blocksize * 8);
-	else
-	    block ++;	
-    }
-    
-    /*printf ("BITMAPS: %u blocks marked used (%d)\n", hits,
-	      reiserfs_bitmap_zeros (control_bitmap));
-	      
-      hits = 0;*/
-    
-    /* mark as used area of the main device either containing a journal or
-       reserved to hold it */
-
-    reserved = get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb);
-    
-    /* where does journal area (or reserved journal area) start from */
-
-    if (!is_new_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) &&
-    	!is_old_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
-	die ("init_control_bitmap: Wrong super block location. You must run "
-	     "--rebuild-sb.");
-
-    block = get_journal_start_must (fs);
-
-    for (i = block; i < reserved + block; i ++)
-	we_met_it (i);
-
-    if (fs->fs_badblocks_bm)
-	for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	    if (reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))
-	    	we_met_it (i);	
+	unsigned int i;
+	unsigned long block;
+	unsigned long reserved;
+	unsigned int blocks = get_sb_block_count(fs->fs_ondisk_sb);
+
+	control_bitmap = reiserfs_create_bitmap(blocks);
+	if (!control_bitmap)
+		die("init_control_bitmap: Failed to allocate a control bitmap.");
+
+	/*printf ("Initially number of zeros in control bitmap %d\n", 
+	   reiserfs_bitmap_zeros (control_bitmap)); */
+
+	/* skipped and super block */
+	for (i = 0; i <= fs->fs_super_bh->b_blocknr; i++)
+		we_met_it(i);
+
+	/*printf ("SKIPPED: %u blocks marked used (%d)\n", hits,
+	   reiserfs_bitmap_zeros (control_bitmap));
+	   hits = 0; */
+
+	/* bitmaps */
+	block = fs->fs_super_bh->b_blocknr + 1;
+	for (i = 0; i < reiserfs_fs_bmap_nr(fs); i++) {
+		we_met_it(block);
+
+		if (spread_bitmaps(fs))
+			block = (block / (fs->fs_blocksize * 8) + 1) *
+			    (fs->fs_blocksize * 8);
+		else
+			block++;
 	}
-}
 
+	/*printf ("BITMAPS: %u blocks marked used (%d)\n", hits,
+	   reiserfs_bitmap_zeros (control_bitmap));
+
+	   hits = 0; */
+
+	/* mark as used area of the main device either containing a journal or
+	   reserved to hold it */
+
+	reserved = get_size_of_journal_or_reserved_area(fs->fs_ondisk_sb);
+
+	/* where does journal area (or reserved journal area) start from */
+
+	if (!is_new_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) &&
+	    !is_old_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
+		die("init_control_bitmap: Wrong super block location. You must run " "--rebuild-sb.");
+
+	block = get_journal_start_must(fs);
+
+	for (i = block; i < reserved + block; i++)
+		we_met_it(i);
+
+	if (fs->fs_badblocks_bm)
+		for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+			if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i))
+				we_met_it(i);
+		}
+}
 
 /* if we managed to complete tree scanning and if control bitmap and/or proper
    amount of free blocks mismatch with bitmap on disk and super block's
    s_free_blocks - we can fix that */
-static void handle_bitmaps (reiserfs_filsys_t * fs)
+static void handle_bitmaps(reiserfs_filsys_t *fs)
 {
-    int problem = 0;
+	int problem = 0;
 
-    if (tree_scanning_failed) {
-	fsck_progress ("Could not scan the internal tree. --rebuild-tree "
-		       "is required\n");
-	return;
-    }
+	if (tree_scanning_failed) {
+		fsck_progress
+		    ("Could not scan the internal tree. --rebuild-tree "
+		     "is required\n");
+		return;
+	}
 
-    fsck_progress ("Comparing bitmaps..");
+	fsck_progress("Comparing bitmaps..");
 
-    /* check free block counter */
-    if (get_sb_free_blocks (fs->fs_ondisk_sb) != 
-	reiserfs_bitmap_zeros (control_bitmap)) 
-    {
+	/* check free block counter */
+	if (get_sb_free_blocks(fs->fs_ondisk_sb) !=
+	    reiserfs_bitmap_zeros(control_bitmap)) {
 /*	fsck_log ("vpf-10630: The count of free blocks in the on-disk bitmap "
 		  "(%lu) mismatches with the correct one (%lu).\n",  
 		  get_sb_free_blocks (fs->fs_ondisk_sb),
 		  reiserfs_bitmap_zeros (control_bitmap));
 */
-	problem++;
-    }
+		problem++;
+	}
 
-    if (reiserfs_bitmap_compare (source_bitmap, control_bitmap))
-	problem++;    
+	if (reiserfs_bitmap_compare(source_bitmap, control_bitmap))
+		problem++;
 
-    if (problem) {
-        if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-	    fsck_log ("vpf-10630: The on-disk and the correct bitmaps differs. "
-		"Will be fixed later.\n");
+	if (problem) {
+		if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+			fsck_log
+			    ("vpf-10630: The on-disk and the correct bitmaps differs. "
+			     "Will be fixed later.\n");
 //            fsck_progress ("Trying to fix bitmap ..\n");
-            /* mark blocks as used in source bitmap if they are used in 
-	       control bitmap */
-            reiserfs_bitmap_disjunction (source_bitmap, control_bitmap);
-            /* change used blocks count accordinly source bitmap, copy bitmap 
-	       changes to on_disk bitmap */
-            set_sb_free_blocks (fs->fs_ondisk_sb, 
-				reiserfs_bitmap_zeros(source_bitmap));
-            reiserfs_bitmap_copy (fs->fs_bitmap2, source_bitmap);
-            mark_buffer_dirty (fs->fs_super_bh);
+			/* mark blocks as used in source bitmap if they are used in 
+			   control bitmap */
+			reiserfs_bitmap_disjunction(source_bitmap,
+						    control_bitmap);
+			/* change used blocks count accordinly source bitmap, copy bitmap 
+			   changes to on_disk bitmap */
+			set_sb_free_blocks(fs->fs_ondisk_sb,
+					   reiserfs_bitmap_zeros
+					   (source_bitmap));
+			reiserfs_bitmap_copy(fs->fs_bitmap2, source_bitmap);
+			mark_buffer_dirty(fs->fs_super_bh);
 /*
             // check again 
             if ((diff = reiserfs_bitmap_compare(source_bitmap, 
@@ -260,45 +255,46 @@ static void handle_bitmaps (reiserfs_filsys_t * fs)
                 fsck_progress ("finished\n");
             }
 */
-        } else if (problem) {
-	    fsck_log ("vpf-10640: The on-disk and the correct bitmaps differs.\n");
-            while (problem) {
-                /* fixable corruptions because we can try to recover them 
-		   without rebuilding the tree */
-        	one_more_corruption (fs, FIXABLE); 
-        	problem --;
-            }
-        }
-    } else 
-        fsck_progress ("finished\n");
-        
-    return;
+		} else if (problem) {
+			fsck_log
+			    ("vpf-10640: The on-disk and the correct bitmaps differs.\n");
+			while (problem) {
+				/* fixable corruptions because we can try to recover them 
+				   without rebuilding the tree */
+				one_more_corruption(fs, FIXABLE);
+				problem--;
+			}
+		}
+	} else
+		fsck_progress("finished\n");
+
+	return;
 }
 
-static int auto_handle_bitmaps (reiserfs_filsys_t *fs) {
-    unsigned long i;
-    
-    if (source_bitmap->bm_byte_size != control_bitmap->bm_byte_size)
-	return -1;
-    
-    for (i = 0; i < source_bitmap->bm_byte_size; i ++) {
-	if (control_bitmap->bm_map[i] & ~source_bitmap->bm_map[i]) {
-	    return 1;
+static int auto_handle_bitmaps(reiserfs_filsys_t *fs)
+{
+	unsigned long i;
+
+	if (source_bitmap->bm_byte_size != control_bitmap->bm_byte_size)
+		return -1;
+
+	for (i = 0; i < source_bitmap->bm_byte_size; i++) {
+		if (control_bitmap->bm_map[i] & ~source_bitmap->bm_map[i]) {
+			return 1;
+		}
 	}
-    }
-    
-    return 0;
-}
 
+	return 0;
+}
 
 /* is this block legal to be pointed to by some place of the tree? */
-static int bad_block_number (reiserfs_filsys_t * fs, unsigned long block)
+static int bad_block_number(reiserfs_filsys_t *fs, unsigned long block)
 {
-    if (block >= get_sb_block_count (fs->fs_ondisk_sb) ||
-	not_data_block (fs, block)) {
-	/* block has value which can not be used as a pointer in a tree */
-	
-	return 1;
+	if (block >= get_sb_block_count(fs->fs_ondisk_sb) ||
+	    not_data_block(fs, block)) {
+		/* block has value which can not be used as a pointer in a tree */
+
+		return 1;
 /*
 	if (is_unfm_pointer) {
 	    // unformatted node pointer will be zeroed
@@ -311,58 +307,59 @@ static int bad_block_number (reiserfs_filsys_t * fs, unsigned long block)
 	return 1;
 */
 
-    }
+	}
 
-    if (is_block_free (fs, block)) {
-	/* block is marked free - bitmap problems will be handled later */
-	//one_more_corruption (fs, fixable);
-    }
+	if (is_block_free(fs, block)) {
+		/* block is marked free - bitmap problems will be handled later */
+		//one_more_corruption (fs, fixable);
+	}
 
-    return 0;
+	return 0;
 }
 
-
-static int got_already (reiserfs_filsys_t * fs, unsigned long block)
+static int got_already(reiserfs_filsys_t *fs, unsigned long block)
 {
-    if (did_we_meet_it (block)) {
-	/* block is in tree at least twice */
-    	return 1;
-    }
-    we_met_it (block);
-    return 0;
+	if (did_we_meet_it(block)) {
+		/* block is in tree at least twice */
+		return 1;
+	}
+	we_met_it(block);
+	return 0;
 }
 
 /* 1 if it does not look like reasonable stat data */
-static int bad_stat_data (reiserfs_filsys_t * fs, 
-			  struct buffer_head * bh, 
-			  struct item_head * ih)
+static int bad_stat_data(reiserfs_filsys_t *fs,
+			 struct buffer_head *bh, struct item_head *ih)
 {
-    unsigned long objectid;
+	unsigned long objectid;
 //    __u32 links;
 
-    objectid = get_key_objectid (&ih->ih_key);
-    if (!is_objectid_used (fs, objectid)) {
-	/* FIXME: this could be cured right here */
-	fsck_log ("bad_stat_data: The objectid (%lu) is marked free, but used "
-		  "by an object %k\n", objectid, &ih->ih_key);
-
-        /* if it is FIX_FIXABLE we flush objectid map at the end
-           no way to call one_less_corruption later
-        */
-	if (fsck_mode (fs) != FSCK_FIX_FIXABLE)
-	    one_more_corruption (fs, FIXABLE);
-    }
+	objectid = get_key_objectid(&ih->ih_key);
+	if (!is_objectid_used(fs, objectid)) {
+		/* FIXME: this could be cured right here */
+		fsck_log
+		    ("bad_stat_data: The objectid (%lu) is marked free, but used "
+		     "by an object %k\n", objectid, &ih->ih_key);
+
+		/* if it is FIX_FIXABLE we flush objectid map at the end
+		   no way to call one_less_corruption later
+		 */
+		if (fsck_mode(fs) != FSCK_FIX_FIXABLE)
+			one_more_corruption(fs, FIXABLE);
+	}
 
-    if (id_map_mark(proper_id_map (fs), objectid)) {
-	fsck_log ("bad_stat_data: The objectid (%lu) is shared by at least two "
-		  "files. Can be fixed with --rebuild-tree only.\n", objectid);
+	if (id_map_mark(proper_id_map(fs), objectid)) {
+		fsck_log
+		    ("bad_stat_data: The objectid (%lu) is shared by at least two "
+		     "files. Can be fixed with --rebuild-tree only.\n",
+		     objectid);
 #if 0
-	to_be_relocated (&ih->ih_key);
-//	one_more_corruption (fs, FIXABLE);	
+		to_be_relocated(&ih->ih_key);
+//      one_more_corruption (fs, FIXABLE);      
 #endif
-    }
+	}
 
-    return 0;
+	return 0;
 /* Check this on semantic_check pass.    
 
     sd = (struct stat_data *)B_I_PITEM(bh,ih);
@@ -380,51 +377,47 @@ static int bad_stat_data (reiserfs_filsys_t * fs,
             one_more_corruption (fs, fatal);
         }
     }
-*/    
+*/
 }
 
-
 /* it looks like we can check item length only */
-static int bad_direct_item (reiserfs_filsys_t * fs, 
-			    struct buffer_head * bh, 
-			    struct item_head * ih)
+static int bad_direct_item(reiserfs_filsys_t *fs,
+			   struct buffer_head *bh, struct item_head *ih)
 {
-    return 0;
+	return 0;
 }
 
-
-inline void handle_one_pointer (reiserfs_filsys_t * fs, 
-				struct buffer_head * bh,
-				__u32 * item, int offset)
+inline void handle_one_pointer(reiserfs_filsys_t *fs,
+			       struct buffer_head *bh, __u32 * item, int offset)
 {
-    if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-	fsck_log (" - zeroed");
-	d32_put (item, offset, 0);
-	mark_buffer_dirty (bh);
-    } else {
-	one_more_corruption (fs, FIXABLE);
-    }
+	if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+		fsck_log(" - zeroed");
+		d32_put(item, offset, 0);
+		mark_buffer_dirty(bh);
+	} else {
+		one_more_corruption(fs, FIXABLE);
+	}
 }
 
+static int bad_badblocks_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
+			      struct item_head *ih)
+{
+	__u32 i;
+	__u32 *ind = (__u32 *) B_I_PITEM(bh, ih);
+
+	if (get_ih_item_len(ih) % 4) {
+		fsck_log("%s: block %lu: item (%H) has bad length\n",
+			 __FUNCTION__, bh->b_blocknr, ih);
+		one_more_corruption(fs, FATAL);
+		return 1;
+	}
 
-static int bad_badblocks_item (reiserfs_filsys_t * fs, struct buffer_head * bh,
-			      struct item_head * ih) {
-    __u32 i;
-    __u32 * ind = (__u32 *)B_I_PITEM (bh, ih);
+	/* All valid badblocks are given in badblock bitmap. Nothing to check anymore. */
+	if (fs->fs_badblocks_bm)
+		return 0;
 
-    if (get_ih_item_len (ih) % 4) {
-	fsck_log ("%s: block %lu: item (%H) has bad length\n", __FUNCTION__,
-		  bh->b_blocknr, ih);
-	one_more_corruption (fs, FATAL);
-	return 1;
-    }
-	
-    /* All valid badblocks are given in badblock bitmap. Nothing to check anymore. */
-    if (fs->fs_badblocks_bm)
-	    return 0;
-    
-    for (i = 0; i < I_UNFM_NUM (ih); i ++) {
-	if (!d32_get (ind, i)) {
+	for (i = 0; i < I_UNFM_NUM(ih); i++) {
+		if (!d32_get(ind, i)) {
 /*	    fsck_log ("%s: block %lu: badblocks item (%H) has zero pointer.",
 		      __FUNCTION__, bh->b_blocknr, ih);
 	    
@@ -433,457 +426,489 @@ static int bad_badblocks_item (reiserfs_filsys_t * fs, struct buffer_head * bh,
 	    } else {
 		    fsck_log("Will be deleted later.\n");
 	    }*/
-	    
-	    continue;
-	}
 
-	/* check list of badblocks pointers */
-	if (d32_get (ind, i) >= get_sb_block_count (fs->fs_ondisk_sb)) {
-	    fsck_log ("%s: badblock pointer (block %lu) points out of disk spase (%lu)",
-			__FUNCTION__, bh->b_blocknr, d32_get (ind, i));
-	    handle_one_pointer (fs, bh, ind, i);
-	    fsck_log ("\n");
-	}
+			continue;
+		}
 
-	if (did_we_meet_it (d32_get (ind, i))) {
-	    /* it can be
-	       1. not_data_block
-	       		delete pointer
-	       2. ind [i] or internal/leaf
-	          advice to run fix-fixable if there is no fatal errors
-	          with list of badblocks, say that it could fix it. */
-	
-	    if (not_data_block (fs, d32_get (ind, i))) {
-		fsck_log ("%s: badblock pointer (block %lu) points on fs metadata (%lu)",
-			  __FUNCTION__, bh->b_blocknr, d32_get (ind, i));
-		handle_one_pointer (fs, bh, ind, i);
-		fsck_log ("\n");
-	    } else {
-		one_more_corruption(fs, FIXABLE);
-	        fsck_log ("%s: badblock pointer (block %lu) points to a block (%lu) "
-			  "which is in the tree already. Use badblock option (-B) to"
-			  " fix the problem\n", __FUNCTION__, bh->b_blocknr, 
-			  d32_get (ind, i));
-	    }
+		/* check list of badblocks pointers */
+		if (d32_get(ind, i) >= get_sb_block_count(fs->fs_ondisk_sb)) {
+			fsck_log
+			    ("%s: badblock pointer (block %lu) points out of disk spase (%lu)",
+			     __FUNCTION__, bh->b_blocknr, d32_get(ind, i));
+			handle_one_pointer(fs, bh, ind, i);
+			fsck_log("\n");
+		}
 
-	    continue;
+		if (did_we_meet_it(d32_get(ind, i))) {
+			/* it can be
+			   1. not_data_block
+			   delete pointer
+			   2. ind [i] or internal/leaf
+			   advice to run fix-fixable if there is no fatal errors
+			   with list of badblocks, say that it could fix it. */
+
+			if (not_data_block(fs, d32_get(ind, i))) {
+				fsck_log
+				    ("%s: badblock pointer (block %lu) points on fs metadata (%lu)",
+				     __FUNCTION__, bh->b_blocknr, d32_get(ind,
+									  i));
+				handle_one_pointer(fs, bh, ind, i);
+				fsck_log("\n");
+			} else {
+				one_more_corruption(fs, FIXABLE);
+				fsck_log
+				    ("%s: badblock pointer (block %lu) points to a block (%lu) "
+				     "which is in the tree already. Use badblock option (-B) to"
+				     " fix the problem\n", __FUNCTION__,
+				     bh->b_blocknr, d32_get(ind, i));
+			}
+
+			continue;
+		}
+
+		we_met_it(d32_get(ind, i));
 	}
-	
-	we_met_it(d32_get(ind, i));
-    }
 
-    return 0;
+	return 0;
 }
 
 /* for each unformatted node pointer: make sure it points to data area and
    that it is not in the tree yet */
-static int bad_indirect_item (reiserfs_filsys_t * fs, struct buffer_head * bh,
-			      struct item_head * ih)
+static int bad_indirect_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
+			     struct item_head *ih)
 {
-    __u32 * ind = (__u32 *)B_I_PITEM (bh, ih);
-    unsigned int i;
+	__u32 *ind = (__u32 *) B_I_PITEM(bh, ih);
+	unsigned int i;
+
+	if (get_ih_item_len(ih) % 4) {
+		fsck_log
+		    ("%s: block %lu: The item (%H) has the bad length (%u)\n",
+		     __FUNCTION__, bh->b_blocknr, ih, get_ih_item_len(ih));
+		one_more_corruption(fs, FATAL);
+		return 1;
+	}
 
-    if (get_ih_item_len (ih) % 4) {
-	fsck_log ("%s: block %lu: The item (%H) has the bad length (%u)\n",
-	    __FUNCTION__, bh->b_blocknr, ih, get_ih_item_len (ih));
-	one_more_corruption (fs, FATAL);
-	return 1;
-    }
+	for (i = 0; i < I_UNFM_NUM(ih); i++) {
 
-    for (i = 0; i < I_UNFM_NUM (ih); i ++) {
+		fsck_check_stat(fs)->unfm_pointers++;
+		if (!d32_get(ind, i)) {
+			fsck_check_stat(fs)->zero_unfm_pointers++;
+			continue;
+		}
 
-	fsck_check_stat (fs)->unfm_pointers ++;
-	if (!d32_get (ind, i)) {
-	    fsck_check_stat (fs)->zero_unfm_pointers ++;
-	    continue;
-	}
+		/* check unformatted node pointer and mark it used in the
+		   control bitmap */
+		if (bad_block_number(fs, d32_get(ind, i))) {
+			fsck_log
+			    ("%s: block %lu: The item %k has the bad pointer (%d) to "
+			     "the block (%lu)", __FUNCTION__, bh->b_blocknr,
+			     &ih->ih_key, i, d32_get(ind, i));
+
+			handle_one_pointer(fs, bh, ind, i);
+			fsck_log("\n");
+			continue;
+		}
 
-	/* check unformatted node pointer and mark it used in the
-           control bitmap */
-	if (bad_block_number (fs, d32_get (ind, i))) {
-	    fsck_log ("%s: block %lu: The item %k has the bad pointer (%d) to "
-		      "the block (%lu)", __FUNCTION__, bh->b_blocknr, 
-		      &ih->ih_key, i, d32_get (ind, i));
-	    
-	    handle_one_pointer (fs, bh, ind, i);
-	    fsck_log ("\n");
-	    continue;
-	}
+		if (got_already(fs, d32_get(ind, i))) {
+			fsck_log
+			    ("%s: block %lu: The item (%H) has the bad pointer (%d) "
+			     "to the block (%lu), which is in tree already",
+			     __FUNCTION__, bh->b_blocknr, ih, i, d32_get(ind,
+									 i));
 
-        if (got_already (fs, d32_get (ind, i))) {
-	    fsck_log ("%s: block %lu: The item (%H) has the bad pointer (%d) "
-		      "to the block (%lu), which is in tree already", 
-		      __FUNCTION__, bh->b_blocknr, ih, i, d32_get (ind, i));
-	    
-	    handle_one_pointer (fs, bh, ind, i);
-	    fsck_log ("\n");
-            continue;
+			handle_one_pointer(fs, bh, ind, i);
+			fsck_log("\n");
+			continue;
+		}
 	}
-    }
 
 #if 0
-    /* delete this check for 3.6 */
-    if (get_ih_free_space (ih) > fs->fs_blocksize - 1) {
-        if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-            /*FIXME: fix it if needed*/
-        } else {
-            fsck_log ("bad_indirect_item: %H has wrong ih_free_space\n", ih);
-            one_more_corruption (fs, fixable);
-        }
-    }
+	/* delete this check for 3.6 */
+	if (get_ih_free_space(ih) > fs->fs_blocksize - 1) {
+		if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+			/*FIXME: fix it if needed */
+		} else {
+			fsck_log
+			    ("bad_indirect_item: %H has wrong ih_free_space\n",
+			     ih);
+			one_more_corruption(fs, fixable);
+		}
+	}
 #endif
 
-    return 0;
+	return 0;
 }
 
-
 /* FIXME: this was is_bad_directory from pass0.c */
-static int bad_directory_item (reiserfs_filsys_t * fs, 
-			       struct buffer_head * bh, 
-			       struct item_head * ih)
+static int bad_directory_item(reiserfs_filsys_t *fs,
+			      struct buffer_head *bh, struct item_head *ih)
 {
-    char *name, *prev_name;
-    __u32 off, prev_off;
-    unsigned int count, i;
-    struct reiserfs_de_head * deh = B_I_DEH (bh, ih);
-    int min_entry_size = 1;/* We have no way to understand whether the
-                              filesystem was created in 3.6 format or
-                              converted to it. So, we assume that minimal name
-                              length is 1 */
-    __u16 state;
-    int namelen;
-
-    count = get_ih_entry_count (ih);
-
-    if (count == 0) {
-	one_more_corruption (fs, FATAL);	
-	return 1;
-    }
-    
-    /* make sure item looks like a directory */
-    if (get_ih_item_len (ih) / (DEH_SIZE + min_entry_size) < count) {
-	/* entry count can not be that big */
-	fsck_log ("%s: block %lu: The directory item %k has the exsessively "
-		  "big entry count (%u)\n",  __FUNCTION__, bh->b_blocknr, 
-		  &ih->ih_key, count);
-	
-	one_more_corruption (fs, FATAL);	
-	return 1;
-    }
-
-    if (get_deh_location (&deh[count - 1]) != DEH_SIZE * count) {
-	/* last entry should start right after array of dir entry headers */
-	fsck_log ("%s: block %lu: The directory item %k has the corrupted "
-		  "entry structure\n", __FUNCTION__, bh->b_blocknr, 
-		  &ih->ih_key);
-	
-	one_more_corruption (fs, FATAL);
-	return 1;
-    }
-    
-    /* check name hashing */
-    prev_name = B_I_PITEM(bh, ih) + get_ih_item_len(ih);
-    prev_off = 0;
-
-    for (i = 0; i < count; i ++, deh ++) {
-	namelen = name_in_entry_length (ih, deh, i);
-	name = name_in_entry (deh, i);
-	off = get_deh_offset (deh);
-	
-	if (namelen > (int)REISERFS_MAX_NAME_LEN(fs->fs_blocksize) || 
-	    name >= prev_name || off <= prev_off) 
-	{
-	    fsck_log ("%s: block %lu: The directory item %k has a broken entry "
-		      "(%d)\n", __FUNCTION__, bh->b_blocknr, &ih->ih_key, i);
-	    one_more_corruption (fs, FATAL);
-	    return 1;
+	char *name, *prev_name;
+	__u32 off, prev_off;
+	unsigned int count, i;
+	struct reiserfs_de_head *deh = B_I_DEH(bh, ih);
+	int min_entry_size = 1;	/* We have no way to understand whether the
+				   filesystem was created in 3.6 format or
+				   converted to it. So, we assume that minimal name
+				   length is 1 */
+	__u16 state;
+	int namelen;
+
+	count = get_ih_entry_count(ih);
+
+	if (count == 0) {
+		one_more_corruption(fs, FATAL);
+		return 1;
 	}
 
-	if (!is_properly_hashed (fs, name, namelen, off)) {
-	    fsck_log ("%s: block %lu: The directory item %k has a not properly "
-		      "hashed entry (%d)\n", __FUNCTION__, bh->b_blocknr, 
-		      &ih->ih_key, i);
-	    
-	    one_more_corruption (fs, FATAL);
-	    return 1;
+	/* make sure item looks like a directory */
+	if (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size) < count) {
+		/* entry count can not be that big */
+		fsck_log
+		    ("%s: block %lu: The directory item %k has the exsessively "
+		     "big entry count (%u)\n", __FUNCTION__, bh->b_blocknr,
+		     &ih->ih_key, count);
+
+		one_more_corruption(fs, FATAL);
+		return 1;
 	}
 
-	prev_name = name;
-	prev_off = off;
-    }
+	if (get_deh_location(&deh[count - 1]) != DEH_SIZE * count) {
+		/* last entry should start right after array of dir entry headers */
+		fsck_log
+		    ("%s: block %lu: The directory item %k has the corrupted "
+		     "entry structure\n", __FUNCTION__, bh->b_blocknr,
+		     &ih->ih_key);
 
-    deh = B_I_DEH (bh, ih);
-    state = (1 << DEH_Visible2);
-    /* ok, items looks like a directory */
-    for (i = 0; i < count; i ++, deh ++) {
-	if (get_deh_state (deh) != state) {
-	    fsck_log ("bad_directory_item: block %lu: The directory item %k "
-		      "has the entry (%d) \"%.*s\" with a not legal state "
-		      "(%o), (%o) expected", bh->b_blocknr, &ih->ih_key, i, 
-		      name_in_entry_length (ih, deh, i), name_in_entry (deh, i), 
-		      get_deh_state (deh), state);
-	    
-	    if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-		set_deh_state (deh, 1 << DEH_Visible2);
-		mark_buffer_dirty (bh);
-		fsck_log (" - corrected\n");
-	    } else 
-		one_more_corruption (fs, FIXABLE);
-	    
-	    fsck_log ("\n");
+		one_more_corruption(fs, FATAL);
+		return 1;
 	}
-    }
 
-    return 0;
-}
+	/* check name hashing */
+	prev_name = B_I_PITEM(bh, ih) + get_ih_item_len(ih);
+	prev_off = 0;
+
+	for (i = 0; i < count; i++, deh++) {
+		namelen = name_in_entry_length(ih, deh, i);
+		name = name_in_entry(deh, i);
+		off = get_deh_offset(deh);
+
+		if (namelen > (int)REISERFS_MAX_NAME_LEN(fs->fs_blocksize) ||
+		    name >= prev_name || off <= prev_off) {
+			fsck_log
+			    ("%s: block %lu: The directory item %k has a broken entry "
+			     "(%d)\n", __FUNCTION__, bh->b_blocknr, &ih->ih_key,
+			     i);
+			one_more_corruption(fs, FATAL);
+			return 1;
+		}
 
+		if (!is_properly_hashed(fs, name, namelen, off)) {
+			fsck_log
+			    ("%s: block %lu: The directory item %k has a not properly "
+			     "hashed entry (%d)\n", __FUNCTION__, bh->b_blocknr,
+			     &ih->ih_key, i);
 
-static int bad_item (reiserfs_filsys_t * fs, struct buffer_head * bh, int num)
-{
-    struct item_head * ih;
-    int format;
+			one_more_corruption(fs, FATAL);
+			return 1;
+		}
 
-    ih = B_N_PITEM_HEAD (bh, num);
+		prev_name = name;
+		prev_off = off;
+	}
 
-    if ((get_ih_flags(ih)) != 0) {
-	if (fsck_mode(fs) != FSCK_FIX_FIXABLE) {
-	    one_more_corruption (fs, FIXABLE);
-	    fsck_log ("%s: vpf-10570: block %lu: The item header (%d) has not "
-		      "cleaned flags.\n", __FUNCTION__, bh->b_blocknr, num);
-	} else {
-	    fsck_log ("%s: vpf-10580: block %lu: Flags in the item header "
-		      "(%d) were cleaned\n", __FUNCTION__, bh->b_blocknr, num);
-	    
-	    clean_ih_flags(ih);
-	    mark_buffer_dirty(bh);
+	deh = B_I_DEH(bh, ih);
+	state = (1 << DEH_Visible2);
+	/* ok, items looks like a directory */
+	for (i = 0; i < count; i++, deh++) {
+		if (get_deh_state(deh) != state) {
+			fsck_log
+			    ("bad_directory_item: block %lu: The directory item %k "
+			     "has the entry (%d) \"%.*s\" with a not legal state "
+			     "(%o), (%o) expected", bh->b_blocknr, &ih->ih_key,
+			     i, name_in_entry_length(ih, deh, i),
+			     name_in_entry(deh, i), get_deh_state(deh), state);
+
+			if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+				set_deh_state(deh, 1 << DEH_Visible2);
+				mark_buffer_dirty(bh);
+				fsck_log(" - corrected\n");
+			} else
+				one_more_corruption(fs, FIXABLE);
+
+			fsck_log("\n");
+		}
 	}
-    }
 
-    
-    if (is_stat_data_ih(ih) && get_ih_item_len(ih) == SD_SIZE)
-	format = KEY_FORMAT_2;
-    else if (is_stat_data_ih(ih) && get_ih_item_len(ih) == SD_V1_SIZE)
-	format = KEY_FORMAT_1;
-    else 
-	format = key_format(&ih->ih_key);
-    
-    if (format != get_ih_key_format(ih)) {
-	if (fsck_mode(fs) != FSCK_FIX_FIXABLE) {
-	    one_more_corruption (fs, FIXABLE);
-	    fsck_log ("%s: vpf-10710: block %lu: The format (%d) specified "
-		      "in the item header (%d) differs from the key format "
-		      "(%d).\n", __FUNCTION__, bh->b_blocknr, 
-		      get_ih_key_format(ih), num, format);
-	} else {
-	    fsck_log ("%s: vpf-10720: block %lu: The format (%d) specified in "
-		      "the item header (%d) was fixed to the key format (%d).\n", 
-		      __FUNCTION__, bh->b_blocknr, get_ih_key_format(ih), num, 
-		      format);
+	return 0;
+}
 
-	    set_ih_key_format(ih, format);
-	    mark_buffer_dirty(bh);
+static int bad_item(reiserfs_filsys_t *fs, struct buffer_head *bh, int num)
+{
+	struct item_head *ih;
+	int format;
+
+	ih = B_N_PITEM_HEAD(bh, num);
+
+	if ((get_ih_flags(ih)) != 0) {
+		if (fsck_mode(fs) != FSCK_FIX_FIXABLE) {
+			one_more_corruption(fs, FIXABLE);
+			fsck_log
+			    ("%s: vpf-10570: block %lu: The item header (%d) has not "
+			     "cleaned flags.\n", __FUNCTION__, bh->b_blocknr,
+			     num);
+		} else {
+			fsck_log
+			    ("%s: vpf-10580: block %lu: Flags in the item header "
+			     "(%d) were cleaned\n", __FUNCTION__, bh->b_blocknr,
+			     num);
+
+			clean_ih_flags(ih);
+			mark_buffer_dirty(bh);
+		}
 	}
-    }
 
-    if (get_key_objectid (&ih->ih_key) == BADBLOCK_OBJID) {
-	if (get_key_dirid (&ih->ih_key) == BADBLOCK_DIRID && is_indirect_ih (ih)) {
-		/* Bad Block support. */
-		return bad_badblocks_item (fs, bh, ih);
+	if (is_stat_data_ih(ih) && get_ih_item_len(ih) == SD_SIZE)
+		format = KEY_FORMAT_2;
+	else if (is_stat_data_ih(ih) && get_ih_item_len(ih) == SD_V1_SIZE)
+		format = KEY_FORMAT_1;
+	else
+		format = key_format(&ih->ih_key);
+
+	if (format != get_ih_key_format(ih)) {
+		if (fsck_mode(fs) != FSCK_FIX_FIXABLE) {
+			one_more_corruption(fs, FIXABLE);
+			fsck_log
+			    ("%s: vpf-10710: block %lu: The format (%d) specified "
+			     "in the item header (%d) differs from the key format "
+			     "(%d).\n", __FUNCTION__, bh->b_blocknr,
+			     get_ih_key_format(ih), num, format);
+		} else {
+			fsck_log
+			    ("%s: vpf-10720: block %lu: The format (%d) specified in "
+			     "the item header (%d) was fixed to the key format (%d).\n",
+			     __FUNCTION__, bh->b_blocknr, get_ih_key_format(ih),
+			     num, format);
+
+			set_ih_key_format(ih, format);
+			mark_buffer_dirty(bh);
+		}
 	}
 
-	goto error;
-    } else {
-	if (get_key_dirid (&ih->ih_key) == (__u32)-1) {
-	    /*  Safe Link support. Allowable safe links are:
-		-1 object_id           0x1	INDIRECT (truncate) or
-		-1 object_id   blocksize+1	DIRECT   (unlink) */
-	    if (is_direct_ih(ih) && get_offset(&ih->ih_key) == fs->fs_blocksize + 1) {
-		if (get_ih_item_len (ih) == 4) {
-		    /*fsck_log("vpf-00010: safe link found %k\n", &ih->ih_key);*/
-		    fsck_check_stat(fs)->safe ++;
-		    return 0;
+	if (get_key_objectid(&ih->ih_key) == BADBLOCK_OBJID) {
+		if (get_key_dirid(&ih->ih_key) == BADBLOCK_DIRID
+		    && is_indirect_ih(ih)) {
+			/* Bad Block support. */
+			return bad_badblocks_item(fs, bh, ih);
 		}
-	    }
 
-	    if (is_indirect_ih(ih) && get_offset(&ih->ih_key) == 0x1) {
-		if (get_ih_item_len (ih) == 4) {
-		    /*fsck_log("vpf-00020: safe link found %k\n", &ih->ih_key);*/
-		    fsck_check_stat(fs)->safe ++;
-		    return 0;
+		goto error;
+	} else {
+		if (get_key_dirid(&ih->ih_key) == (__u32) - 1) {
+			/*  Safe Link support. Allowable safe links are:
+			   -1 object_id           0x1       INDIRECT (truncate) or
+			   -1 object_id   blocksize+1       DIRECT   (unlink) */
+			if (is_direct_ih(ih)
+			    && get_offset(&ih->ih_key) ==
+			    fs->fs_blocksize + 1) {
+				if (get_ih_item_len(ih) == 4) {
+					/*fsck_log("vpf-00010: safe link found %k\n", &ih->ih_key); */
+					fsck_check_stat(fs)->safe++;
+					return 0;
+				}
+			}
+
+			if (is_indirect_ih(ih)
+			    && get_offset(&ih->ih_key) == 0x1) {
+				if (get_ih_item_len(ih) == 4) {
+					/*fsck_log("vpf-00020: safe link found %k\n", &ih->ih_key); */
+					fsck_check_stat(fs)->safe++;
+					return 0;
+				}
+			}
+
+			/* it does not look like safe link */
+			goto error;
 		}
-	    }
-	
-	    /* it does not look like safe link */
-	    goto error;
 	}
-    }
-    
-    if (is_stat_data_ih (ih))
-	return bad_stat_data (fs, bh, ih);
-
-    if (is_direct_ih (ih))
-	return bad_direct_item (fs, bh, ih);
-
-    if (is_indirect_ih(ih))
-	return bad_indirect_item (fs, bh, ih);
-    
-    return bad_directory_item (fs, bh, ih);
- 
- error:
-    one_more_corruption (fs, FATAL);
-    fsck_log ("%s: vpf-10310: block %lu, item %d: The item has a wrong "
-	      "key %k\n", __FUNCTION__, num, bh->b_blocknr, &ih->ih_key);
-    return 1;
-}
 
+	if (is_stat_data_ih(ih))
+		return bad_stat_data(fs, bh, ih);
 
-/* 1 if i-th and (i-1)-th items can not be neighbors in a leaf */
-int bad_pair (reiserfs_filsys_t * fs, struct buffer_head * bh, int pos) {
-    struct item_head * ih;
+	if (is_direct_ih(ih))
+		return bad_direct_item(fs, bh, ih);
 
-    ih = B_N_PITEM_HEAD (bh, pos);
+	if (is_indirect_ih(ih))
+		return bad_indirect_item(fs, bh, ih);
 
-    if (comp_keys (&((ih - 1)->ih_key), &ih->ih_key) != -1) {
-	if (fsck_mode (fs) != FSCK_REBUILD)
-	    one_more_corruption (fs, FATAL);	
+	return bad_directory_item(fs, bh, ih);
+
+error:
+	one_more_corruption(fs, FATAL);
+	fsck_log("%s: vpf-10310: block %lu, item %d: The item has a wrong "
+		 "key %k\n", __FUNCTION__, num, bh->b_blocknr, &ih->ih_key);
 	return 1;
-    }
+}
 
-    if (is_stat_data_ih (ih))
-	/* left item must be of another object */
-	if (comp_short_keys (&((ih - 1)->ih_key), &ih->ih_key) != -1) {
-	    if (fsck_mode (fs) != FSCK_REBUILD)
-		one_more_corruption (fs, FATAL);	
-	    return 1;
-	}
+/* 1 if i-th and (i-1)-th items can not be neighbors in a leaf */
+int bad_pair(reiserfs_filsys_t *fs, struct buffer_head *bh, int pos)
+{
+	struct item_head *ih;
 
-    if (get_key_objectid (&ih->ih_key) == BADBLOCK_OBJID) {
-	/* BAD BLOCK LIST SUPPORT. */
-	if (get_key_dirid(&ih->ih_key) == BADBLOCK_DIRID && 
-	    is_indirect_ih(ih) && comp_short_keys(&((ih - 1)->ih_key), 
-						  &ih->ih_key))
-		return 0;
-    } else {
-	/* Safe link support. */
-	if (get_key_dirid (&ih->ih_key) == (__u32)-1) {
-	    if (comp_short_keys (&((ih - 1)->ih_key), &ih->ih_key) == 0) {
-		if (is_indirect_ih (ih - 1) && is_direct_ih(ih))
-		    return 0; /* safe link */
-		/* they do not look like safe links */
-	    } else {
-		if (is_indirect_ih (ih) || is_direct_ih(ih))
-		    return 0; /* safe link */
-		/* it does not look like safe link */
-	    }
+	ih = B_N_PITEM_HEAD(bh, pos);
+
+	if (comp_keys(&((ih - 1)->ih_key), &ih->ih_key) != -1) {
+		if (fsck_mode(fs) != FSCK_REBUILD)
+			one_more_corruption(fs, FATAL);
+		return 1;
 	}
-    }
-    
-    if (is_direct_ih(ih)) {
-	/* left item must be indirect or stat data item of the same file */
-	if (not_of_one_file (&((ih - 1)->ih_key), &ih->ih_key)) {
-	    if (fsck_mode (fs) != FSCK_REBUILD)
-		one_more_corruption (fs, FATAL);
-	    
-	    return 1;
+
+	if (is_stat_data_ih(ih))
+		/* left item must be of another object */
+		if (comp_short_keys(&((ih - 1)->ih_key), &ih->ih_key) != -1) {
+			if (fsck_mode(fs) != FSCK_REBUILD)
+				one_more_corruption(fs, FATAL);
+			return 1;
+		}
+
+	if (get_key_objectid(&ih->ih_key) == BADBLOCK_OBJID) {
+		/* BAD BLOCK LIST SUPPORT. */
+		if (get_key_dirid(&ih->ih_key) == BADBLOCK_DIRID &&
+		    is_indirect_ih(ih) && comp_short_keys(&((ih - 1)->ih_key),
+							  &ih->ih_key))
+			return 0;
+	} else {
+		/* Safe link support. */
+		if (get_key_dirid(&ih->ih_key) == (__u32) - 1) {
+			if (comp_short_keys(&((ih - 1)->ih_key), &ih->ih_key) ==
+			    0) {
+				if (is_indirect_ih(ih - 1) && is_direct_ih(ih))
+					return 0;	/* safe link */
+				/* they do not look like safe links */
+			} else {
+				if (is_indirect_ih(ih) || is_direct_ih(ih))
+					return 0;	/* safe link */
+				/* it does not look like safe link */
+			}
+		}
 	}
 
-	if (!((is_stat_data_ih (ih - 1) && get_offset (&ih->ih_key) == 1) ||
-	      (is_indirect_ih (ih - 1) && get_offset (&(ih - 1)->ih_key) + 
-	       get_bytes_number (ih-1, bh->b_size) == get_offset (&ih->ih_key)))) 
-	{
-	    if (fsck_mode (fs) != FSCK_REBUILD)
-		one_more_corruption (fs, FATAL);
-	    
-	    return 1;
+	if (is_direct_ih(ih)) {
+		/* left item must be indirect or stat data item of the same file */
+		if (not_of_one_file(&((ih - 1)->ih_key), &ih->ih_key)) {
+			if (fsck_mode(fs) != FSCK_REBUILD)
+				one_more_corruption(fs, FATAL);
+
+			return 1;
+		}
+
+		if (!
+		    ((is_stat_data_ih(ih - 1) && get_offset(&ih->ih_key) == 1)
+		     || (is_indirect_ih(ih - 1)
+			 && get_offset(&(ih - 1)->ih_key) +
+			 get_bytes_number(ih - 1,
+					  bh->b_size) ==
+			 get_offset(&ih->ih_key)))) {
+			if (fsck_mode(fs) != FSCK_REBUILD)
+				one_more_corruption(fs, FATAL);
+
+			return 1;
+		}
 	}
-    }
 
-    if (is_indirect_ih (ih) || is_direntry_ih (ih)) {
-	/* left item must be stat data of the same object */
-	if (not_of_one_file (&((ih - 1)->ih_key), &ih->ih_key) ||
-	    !is_stat_data_ih (ih - 1)) {
-	    if (fsck_mode (fs) != FSCK_REBUILD)
-		one_more_corruption (fs, FATAL);
-	    return 1;
+	if (is_indirect_ih(ih) || is_direntry_ih(ih)) {
+		/* left item must be stat data of the same object */
+		if (not_of_one_file(&((ih - 1)->ih_key), &ih->ih_key) ||
+		    !is_stat_data_ih(ih - 1)) {
+			if (fsck_mode(fs) != FSCK_REBUILD)
+				one_more_corruption(fs, FATAL);
+			return 1;
+		}
 	}
-    }
 
-    return 0;
+	return 0;
 }
 
 /* 1 if block head or any of items is bad */
-static int bad_leaf (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static int bad_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    int i;
+	int i;
 
-    if (leaf_structure_check(fs, bh))
-	return 1;
-    
-    for (i = 0; i < B_NR_ITEMS (bh); i ++) {
-	if (bad_item (fs, bh, i)) {
-	    fsck_log ("bad_leaf: block %lu, item %d: The corrupted item found "
-		      "(%H)\n", bh->b_blocknr, i, B_N_PITEM_HEAD (bh, i));
-	}
+	if (leaf_structure_check(fs, bh))
+		return 1;
 
-	if (i && bad_pair (fs, bh, i)) {
-	    fsck_log ("bad_leaf: block %lu, items %d and %d: The wrong order "
-		      "of items: %k, %k\n", bh->b_blocknr, i - 1, i, 
-		      &B_N_PITEM_HEAD (bh, i-1)->ih_key, 
-		      &B_N_PITEM_HEAD (bh, i)->ih_key);
+	for (i = 0; i < B_NR_ITEMS(bh); i++) {
+		if (bad_item(fs, bh, i)) {
+			fsck_log
+			    ("bad_leaf: block %lu, item %d: The corrupted item found "
+			     "(%H)\n", bh->b_blocknr, i, B_N_PITEM_HEAD(bh, i));
+		}
+
+		if (i && bad_pair(fs, bh, i)) {
+			fsck_log
+			    ("bad_leaf: block %lu, items %d and %d: The wrong order "
+			     "of items: %k, %k\n", bh->b_blocknr, i - 1, i,
+			     &B_N_PITEM_HEAD(bh, i - 1)->ih_key,
+			     &B_N_PITEM_HEAD(bh, i)->ih_key);
+		}
 	}
-    }
-    return 0;
+	return 0;
 }
 
 /* 1 if bh does not look like internal node */
-static int bad_internal (reiserfs_filsys_t * fs, struct buffer_head * bh)
+static int bad_internal(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    int i;
-
-    for (i = 0; i <= B_NR_ITEMS (bh); i ++) {
-        if (i != B_NR_ITEMS (bh) && i != B_NR_ITEMS (bh) - 1)
-	    /* make sure that keys are in increasing order */
-            if (comp_keys (B_N_PDELIM_KEY (bh, i), 
-			   B_N_PDELIM_KEY (bh, i + 1)) != -1) 
-	    {
-		fsck_log ("%s: vpf-10320: block %lu, items %d and %d: The "
-			  "wrong order of items: %k, %k\n", __FUNCTION__, 
-			  bh->b_blocknr, i, i + 1, B_N_PDELIM_KEY (bh, i), 
-			  B_N_PDELIM_KEY (bh, i + 1));
-		
-		one_more_corruption (fs, FATAL);
-                return 1;
-	    }
-
-	/* make sure that the child is correct */
-        if (bad_block_number (fs, get_dc_child_blocknr (B_N_CHILD (bh,i)))) {
-	    fsck_log ("%s: vpf-10330: block %lu, item %d: The internal item "
-		      "points to the not legal block (%lu)\n", __FUNCTION__, 
-		      bh->b_blocknr, i, get_dc_child_blocknr (B_N_CHILD (bh,i)));
-	    
-            one_more_corruption (fs, FATAL);
-            return 1;
+	int i;
+
+	for (i = 0; i <= B_NR_ITEMS(bh); i++) {
+		if (i != B_NR_ITEMS(bh) && i != B_NR_ITEMS(bh) - 1)
+			/* make sure that keys are in increasing order */
+			if (comp_keys(B_N_PDELIM_KEY(bh, i),
+				      B_N_PDELIM_KEY(bh, i + 1)) != -1) {
+				fsck_log
+				    ("%s: vpf-10320: block %lu, items %d and %d: The "
+				     "wrong order of items: %k, %k\n",
+				     __FUNCTION__, bh->b_blocknr, i, i + 1,
+				     B_N_PDELIM_KEY(bh, i), B_N_PDELIM_KEY(bh,
+									   i +
+									   1));
+
+				one_more_corruption(fs, FATAL);
+				return 1;
+			}
+
+		/* make sure that the child is correct */
+		if (bad_block_number
+		    (fs, get_dc_child_blocknr(B_N_CHILD(bh, i)))) {
+			fsck_log
+			    ("%s: vpf-10330: block %lu, item %d: The internal item "
+			     "points to the not legal block (%lu)\n",
+			     __FUNCTION__, bh->b_blocknr, i,
+			     get_dc_child_blocknr(B_N_CHILD(bh, i)));
+
+			one_more_corruption(fs, FATAL);
+			return 1;
+		}
 	}
-    }
-    return 0;
+	return 0;
 }
 
-
 /* h == 0 for root level. block head's level == 1 for leaf level  */
-static inline int h_to_level (reiserfs_filsys_t * fs, int h)
+static inline int h_to_level(reiserfs_filsys_t *fs, int h)
 {
-    return get_sb_tree_height (fs->fs_ondisk_sb) - h - 1;
+	return get_sb_tree_height(fs->fs_ondisk_sb) - h - 1;
 }
 
 #if 0
-int dc_fix(struct buffer_head *bh, int pos, __u32 block) {
+int dc_fix(struct buffer_head *bh, int pos, __u32 block)
+{
 	if (!bh || !bh->b_data)
 		return -1;
 
 	if (B_NR_ITEMS(bh) < pos)
 		return -1;
 
-	set_dc_child_blocknr(B_N_CHILD(bh,pos), block);
+	set_dc_child_blocknr(B_N_CHILD(bh, pos), block);
 
 	mark_buffer_dirty(bh);
 	bwrite(bh);
@@ -892,10 +917,11 @@ int dc_fix(struct buffer_head *bh, int pos, __u32 block) {
 }
 
 /* Removes @N-th key and @(N+1) pointer. */
-int internal_remove(struct buffer_head *bh, int pos) {
+int internal_remove(struct buffer_head *bh, int pos)
+{
 	char *delete;
 	__u32 nr;
-	
+
 	if (!bh || !bh->b_data)
 		return -1;
 
@@ -903,28 +929,26 @@ int internal_remove(struct buffer_head *bh, int pos) {
 		return -1;
 
 	delete = (char *)B_N_CHILD(bh, pos + 2);
-	memmove(delete - DC_SIZE, delete, 
-		bh->b_size - (delete - bh->b_data));
+	memmove(delete - DC_SIZE, delete, bh->b_size - (delete - bh->b_data));
 
 	delete = (char *)B_N_PDELIM_KEY(bh, pos + 1);
-	memmove(delete - KEY_SIZE, delete, 
-		bh->b_size - (delete - bh->b_data));
+	memmove(delete - KEY_SIZE, delete, bh->b_size - (delete - bh->b_data));
 
 	nr = B_NR_ITEMS(bh) - 1;
-	
+
 	set_blkh_nr_items(B_BLK_HEAD(bh), nr);
-	set_blkh_free_space(B_BLK_HEAD(bh), bh->b_size - 
+	set_blkh_free_space(B_BLK_HEAD(bh), bh->b_size -
 			    (BLKH_SIZE + KEY_SIZE * nr + DC_SIZE * (nr + 1)));
-	
+
 	mark_buffer_dirty(bh);
 	bwrite(bh);
-	
+
 	return 0;
 }
 
-int leaf_fix_key_oid(struct buffer_head *bh, int pos, __u32 oid) {
-	struct item_head * ih;
-
+int leaf_fix_key_oid(struct buffer_head *bh, int pos, __u32 oid)
+{
+	struct item_head *ih;
 
 	if (!bh || !bh->b_data)
 		return -1;
@@ -932,9 +956,9 @@ int leaf_fix_key_oid(struct buffer_head *bh, int pos, __u32 oid) {
 	if (B_NR_ITEMS(bh) < pos)
 		return -1;
 
-	ih = B_N_PITEM_HEAD (bh, pos);
+	ih = B_N_PITEM_HEAD(bh, pos);
 	set_key_objectid(&ih->ih_key, oid);
-	
+
 	mark_buffer_dirty(bh);
 	bwrite(bh);
 
@@ -943,236 +967,252 @@ int leaf_fix_key_oid(struct buffer_head *bh, int pos, __u32 oid) {
 #endif
 
 /* bh must be formatted node. blk_level must be tree_height - h + 1 */
-static int bad_node (reiserfs_filsys_t * fs, struct buffer_head ** path, int h)
+static int bad_node(reiserfs_filsys_t *fs, struct buffer_head **path, int h)
 {
-    struct buffer_head ** pbh = &path[h];
-
-    if (B_LEVEL (*pbh) != h_to_level (fs, h)) {
-       	fsck_log ("block %lu: The level of the node (%d) is not correct, "
-		  "(%d) expected\n", (*pbh)->b_blocknr, B_LEVEL (*pbh), 
-		  h_to_level (fs, h));
-	
-	one_more_corruption (fs, FATAL);
-        return 1;
-    }
+	struct buffer_head **pbh = &path[h];
 
-    if (bad_block_number (fs, (*pbh)->b_blocknr)) {
-	one_more_corruption (fs, FATAL);
-	fsck_log ("%s: vpf-10340: The node in the wrong block number (%lu) "
-		  "found in the tree\n",  __FUNCTION__, (*pbh)->b_blocknr);
-	return 1;
-    }
+	if (B_LEVEL(*pbh) != h_to_level(fs, h)) {
+		fsck_log
+		    ("block %lu: The level of the node (%d) is not correct, "
+		     "(%d) expected\n", (*pbh)->b_blocknr, B_LEVEL(*pbh),
+		     h_to_level(fs, h));
 
-    if (got_already (fs, (*pbh)->b_blocknr)) {
-	fsck_log ("%s: vpf-10350: The block (%lu) is used more than once "
-		  "in the tree.\n",  __FUNCTION__, (*pbh)->b_blocknr);
-	one_more_corruption (fs, FATAL);
-        return 1;
-    }
-    
-    if (is_leaf_node (*pbh)) {
-	fsck_check_stat (fs)->leaves ++;
-	return bad_leaf (fs, *pbh);
-    }
-    
-    fsck_check_stat (fs)->internals ++;
-    return bad_internal (fs, *pbh);
-}
+		one_more_corruption(fs, FATAL);
+		return 1;
+	}
+
+	if (bad_block_number(fs, (*pbh)->b_blocknr)) {
+		one_more_corruption(fs, FATAL);
+		fsck_log
+		    ("%s: vpf-10340: The node in the wrong block number (%lu) "
+		     "found in the tree\n", __FUNCTION__, (*pbh)->b_blocknr);
+		return 1;
+	}
+
+	if (got_already(fs, (*pbh)->b_blocknr)) {
+		fsck_log
+		    ("%s: vpf-10350: The block (%lu) is used more than once "
+		     "in the tree.\n", __FUNCTION__, (*pbh)->b_blocknr);
+		one_more_corruption(fs, FATAL);
+		return 1;
+	}
+
+	if (is_leaf_node(*pbh)) {
+		fsck_check_stat(fs)->leaves++;
+		return bad_leaf(fs, *pbh);
+	}
 
+	fsck_check_stat(fs)->internals++;
+	return bad_internal(fs, *pbh);
+}
 
 /* internal node bh must point to block */
-static int get_pos (struct buffer_head * bh, unsigned long block)
+static int get_pos(struct buffer_head *bh, unsigned long block)
 {
-    int i;
+	int i;
 
-    for (i = 0; i <= B_NR_ITEMS (bh); i ++) {
-	if (get_dc_child_blocknr (B_N_CHILD (bh, i)) == block)
-	    return i;
-    }
-    die ("An internal pointer to the block (%lu) cannot be found in the node (%lu)", 
-	block, bh->b_blocknr);
-    return 0;
+	for (i = 0; i <= B_NR_ITEMS(bh); i++) {
+		if (get_dc_child_blocknr(B_N_CHILD(bh, i)) == block)
+			return i;
+	}
+	die("An internal pointer to the block (%lu) cannot be found in the node (%lu)", block, bh->b_blocknr);
+	return 0;
 }
 
-
 /* path[h] - leaf node */
-static struct reiserfs_key *lkey (struct buffer_head ** path, int h)
+static struct reiserfs_key *lkey(struct buffer_head **path, int h)
 {
-    int pos;
+	int pos;
 
-    while (h > 0) {
-       pos = get_pos (path[h - 1], path[h]->b_blocknr);
-       if (pos)
-           return B_N_PDELIM_KEY(path[h - 1], pos - 1);
-       h --;
-    }
-    return 0;
+	while (h > 0) {
+		pos = get_pos(path[h - 1], path[h]->b_blocknr);
+		if (pos)
+			return B_N_PDELIM_KEY(path[h - 1], pos - 1);
+		h--;
+	}
+	return 0;
 }
 
-
 /* path[h] - leaf node */
-static struct reiserfs_key *rkey (struct buffer_head ** path, int h)
+static struct reiserfs_key *rkey(struct buffer_head **path, int h)
 {
-    int pos;
+	int pos;
 
-    while (h > 0) {
-       pos = get_pos (path[h - 1], path[h]->b_blocknr);
-       if (pos != B_NR_ITEMS (path[h - 1]))
-           return B_N_PDELIM_KEY (path[h - 1], pos);
-       h --;
-    }
-    return 0;
+	while (h > 0) {
+		pos = get_pos(path[h - 1], path[h]->b_blocknr);
+		if (pos != B_NR_ITEMS(path[h - 1]))
+			return B_N_PDELIM_KEY(path[h - 1], pos);
+		h--;
+	}
+	return 0;
 }
 
-
 /* are all delimiting keys correct */
-static int bad_path (reiserfs_filsys_t * fs, struct buffer_head ** path, int h1)
+static int bad_path(reiserfs_filsys_t *fs, struct buffer_head **path, int h1)
 {
-    int h = 0;
-    struct reiserfs_key *dk;
-    int pos = 0;
-
-    while (path[h])
-	h ++;
-
-    h--;
-    
-    // path[h] is leaf
-    if (h != h1)
-	die ("bad_path: The leaf is expected as the last element in the path");
-
-    if (h)
-	pos = get_pos (path[h - 1], path[h]->b_blocknr);
-
-    dk = lkey (path, h);
-    if (dk && comp_keys (dk, B_N_PKEY (path[h], 0))) {
-	/* left delimiting key must be equal to the key of 0-th item in the
-	   node */
-	fsck_log ("bad_path: The left delimiting key %k of the node (%lu) must "
-	    "be equal to the first element's key %k within the node.\n", dk, 
-	    path[h]->b_blocknr, B_N_PKEY (path[h], 0));
-	one_more_corruption (fs, FATAL);
-	return 1;
-    }
-    
-    dk = rkey (path, h);
-    if (dk && comp_keys (dk, B_N_PKEY (path[h],
-       get_blkh_nr_items (B_BLK_HEAD (path[h])) - 1)) != 1) {
-	/* right delimiting key must be gt the key of the last item in the node */
-	fsck_log ("bad_path: The right delimiting key %k of the node (%lu) must "
-	    "be greater than the last (%d) element's key %k within the node.\n", 
-	    dk, path[h]->b_blocknr, get_blkh_nr_items (B_BLK_HEAD (path[h])) - 1, 
-	    B_N_PKEY (path[h], get_blkh_nr_items (B_BLK_HEAD (path[h])) - 1));
-	one_more_corruption (fs, FATAL);
-	return 1;
-    }
+	int h = 0;
+	struct reiserfs_key *dk;
+	int pos = 0;
+
+	while (path[h])
+		h++;
+
+	h--;
+
+	// path[h] is leaf
+	if (h != h1)
+		die("bad_path: The leaf is expected as the last element in the path");
+
+	if (h)
+		pos = get_pos(path[h - 1], path[h]->b_blocknr);
+
+	dk = lkey(path, h);
+	if (dk && comp_keys(dk, B_N_PKEY(path[h], 0))) {
+		/* left delimiting key must be equal to the key of 0-th item in the
+		   node */
+		fsck_log
+		    ("bad_path: The left delimiting key %k of the node (%lu) must "
+		     "be equal to the first element's key %k within the node.\n",
+		     dk, path[h]->b_blocknr, B_N_PKEY(path[h], 0));
+		one_more_corruption(fs, FATAL);
+		return 1;
+	}
 
-    if (h && (get_dc_child_size (B_N_CHILD(path[h-1],pos)) +
-    	get_blkh_free_space ((struct block_head *)path[h]->b_data) +
-    	BLKH_SIZE != path[h]->b_size))
-    {
-	/* wrong dc_size */
-	fsck_log ("bad_path: block %lu, pointer %d: The used space (%d) of the "
-	    "child block (%lu)", path[h-1]->b_blocknr, pos, 
-	    get_dc_child_size(B_N_CHILD(path[h-1],pos)), path[h]->b_blocknr);
-	fsck_log (" is not equal to the (blocksize (4096) - free space (%d) - "
-	    "header size (%u))", 
-	    get_blkh_free_space((struct block_head *)path[h]->b_data), BLKH_SIZE);
-	
-	if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-	    set_dc_child_size (B_N_CHILD(path[h-1],pos), path[h]->b_size -
-			       get_blkh_free_space ((struct block_head *)path[h]->b_data) 
-			       - BLKH_SIZE);
-	    fsck_log (" - corrected to (%lu)\n", 
-		      get_dc_child_size (B_N_CHILD(path[h-1], pos)));
-	    
-	    mark_buffer_dirty (path[h-1]);
-	} else {
-	    one_more_corruption (fs, FIXABLE);
-	    fsck_log ("\n");
-	    return 1;
+	dk = rkey(path, h);
+	if (dk && comp_keys(dk, B_N_PKEY(path[h],
+					 get_blkh_nr_items(B_BLK_HEAD(path[h]))
+					 - 1)) != 1) {
+		/* right delimiting key must be gt the key of the last item in the node */
+		fsck_log
+		    ("bad_path: The right delimiting key %k of the node (%lu) must "
+		     "be greater than the last (%d) element's key %k within the node.\n",
+		     dk, path[h]->b_blocknr,
+		     get_blkh_nr_items(B_BLK_HEAD(path[h])) - 1,
+		     B_N_PKEY(path[h],
+			      get_blkh_nr_items(B_BLK_HEAD(path[h])) - 1));
+		one_more_corruption(fs, FATAL);
+		return 1;
+	}
+
+	if (h && (get_dc_child_size(B_N_CHILD(path[h - 1], pos)) +
+		  get_blkh_free_space((struct block_head *)path[h]->b_data) +
+		  BLKH_SIZE != path[h]->b_size)) {
+		/* wrong dc_size */
+		fsck_log
+		    ("bad_path: block %lu, pointer %d: The used space (%d) of the "
+		     "child block (%lu)", path[h - 1]->b_blocknr, pos,
+		     get_dc_child_size(B_N_CHILD(path[h - 1], pos)),
+		     path[h]->b_blocknr);
+		fsck_log
+		    (" is not equal to the (blocksize (4096) - free space (%d) - "
+		     "header size (%u))",
+		     get_blkh_free_space((struct block_head *)path[h]->b_data),
+		     BLKH_SIZE);
+
+		if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+			set_dc_child_size(B_N_CHILD(path[h - 1], pos),
+					  path[h]->b_size -
+					  get_blkh_free_space((struct block_head
+							       *)path[h]->
+							      b_data)
+					  - BLKH_SIZE);
+			fsck_log(" - corrected to (%lu)\n",
+				 get_dc_child_size(B_N_CHILD
+						   (path[h - 1], pos)));
+
+			mark_buffer_dirty(path[h - 1]);
+		} else {
+			one_more_corruption(fs, FIXABLE);
+			fsck_log("\n");
+			return 1;
+		}
 	}
-    }
 
-    return 0;
+	return 0;
 }
 
-static void before_check_fs_tree (reiserfs_filsys_t * fs) {
-    init_control_bitmap (fs);
+static void before_check_fs_tree(reiserfs_filsys_t *fs)
+{
+	init_control_bitmap(fs);
 
-    source_bitmap = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (source_bitmap, fs->fs_bitmap2);
+	source_bitmap =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(source_bitmap, fs->fs_bitmap2);
 
-    proper_id_map (fs) = id_map_init();
+	proper_id_map(fs) = id_map_init();
 }
 
-static void after_check_fs_tree (reiserfs_filsys_t * fs) {
-    if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
-        reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs);
-        reiserfs_flush (fs);
-        fs->fs_dirt = 1;
-	reiserfs_bitmap_delta (source_bitmap, control_bitmap);
-	fsck_deallocate_bitmap(fs) = source_bitmap;
-    } else 
-	reiserfs_delete_bitmap (source_bitmap);
-    
-    reiserfs_delete_bitmap (control_bitmap);
-    flush_buffers (fs->fs_dev);
+static void after_check_fs_tree(reiserfs_filsys_t *fs)
+{
+	if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+		reiserfs_flush_to_ondisk_bitmap(fs->fs_bitmap2, fs);
+		reiserfs_flush(fs);
+		fs->fs_dirt = 1;
+		reiserfs_bitmap_delta(source_bitmap, control_bitmap);
+		fsck_deallocate_bitmap(fs) = source_bitmap;
+	} else
+		reiserfs_delete_bitmap(source_bitmap);
+
+	reiserfs_delete_bitmap(control_bitmap);
+	flush_buffers(fs->fs_dev);
 }
 
 /* pass internal tree of filesystem */
-void check_fs_tree (reiserfs_filsys_t * fs)
+void check_fs_tree(reiserfs_filsys_t *fs)
 {
-    before_check_fs_tree (fs);
-    
-    fsck_progress ("Checking internal tree..  ");
-    pass_through_tree (fs, bad_node, bad_path, fsck_mode(fs) == FSCK_AUTO ? 2 : -1);
-    /* internal tree is correct (including all objects have correct
-       sequences of items) */
-    fsck_progress ("finished\n");
-    
-    /* compare created bitmap with the original */
-    if (fsck_mode(fs) == FSCK_AUTO) {
-	if (auto_handle_bitmaps(fs)) {
-	    fprintf(stderr, "The on-disk bitmap looks corrupted.");
-	    one_more_corruption(fs, FIXABLE);
-	}
-	id_map_free(proper_id_map(fs));
-    } else
-	handle_bitmaps (fs);
-    
-    after_check_fs_tree (fs);
+	before_check_fs_tree(fs);
+
+	fsck_progress("Checking internal tree..  ");
+	pass_through_tree(fs, bad_node, bad_path,
+			  fsck_mode(fs) == FSCK_AUTO ? 2 : -1);
+	/* internal tree is correct (including all objects have correct
+	   sequences of items) */
+	fsck_progress("finished\n");
+
+	/* compare created bitmap with the original */
+	if (fsck_mode(fs) == FSCK_AUTO) {
+		if (auto_handle_bitmaps(fs)) {
+			fprintf(stderr, "The on-disk bitmap looks corrupted.");
+			one_more_corruption(fs, FIXABLE);
+		}
+		id_map_free(proper_id_map(fs));
+	} else
+		handle_bitmaps(fs);
+
+	after_check_fs_tree(fs);
 }
 
-static int clean_attributes_handler (reiserfs_filsys_t * fs, 
-				     struct buffer_head ** path, 
-				     int h) 
+static int clean_attributes_handler(reiserfs_filsys_t *fs,
+				    struct buffer_head **path, int h)
 {
-    struct buffer_head * bh = path[h];
-    int i;
-
-    if (B_LEVEL (bh) != h_to_level (fs, h)) {
-       	reiserfs_panic ("The node (%lu) with wrong level (%d) found in the "
-			"tree, (%d) expected\n", bh->b_blocknr, B_LEVEL (bh), 
-			h_to_level (fs, h));
-    }
+	struct buffer_head *bh = path[h];
+	int i;
+
+	if (B_LEVEL(bh) != h_to_level(fs, h)) {
+		reiserfs_panic
+		    ("The node (%lu) with wrong level (%d) found in the "
+		     "tree, (%d) expected\n", bh->b_blocknr, B_LEVEL(bh),
+		     h_to_level(fs, h));
+	}
 
-    if (!is_leaf_node (bh))
-        return 0;
+	if (!is_leaf_node(bh))
+		return 0;
 
-    for (i = 0; i < B_NR_ITEMS (bh); i ++) {
-        if (is_stat_data_ih (B_N_PITEM_HEAD (bh, i)) &&
-            get_ih_item_len (B_N_PITEM_HEAD (bh, i)) == SD_SIZE) {
-	    set_sd_v2_sd_attrs((struct stat_data *)B_N_PITEM(bh, i), 0);
-	    mark_buffer_dirty (bh);
+	for (i = 0; i < B_NR_ITEMS(bh); i++) {
+		if (is_stat_data_ih(B_N_PITEM_HEAD(bh, i)) &&
+		    get_ih_item_len(B_N_PITEM_HEAD(bh, i)) == SD_SIZE) {
+			set_sd_v2_sd_attrs((struct stat_data *)B_N_PITEM(bh, i),
+					   0);
+			mark_buffer_dirty(bh);
+		}
 	}
-    }
 
-    return 0;
+	return 0;
 }
 
-void do_clean_attributes (reiserfs_filsys_t * fs) {
-    pass_through_tree (fs, clean_attributes_handler, NULL, -1);
-    set_sb_v2_flag (fs->fs_ondisk_sb, reiserfs_attrs_cleared);
-    mark_buffer_dirty (fs->fs_super_bh);
+void do_clean_attributes(reiserfs_filsys_t *fs)
+{
+	pass_through_tree(fs, clean_attributes_handler, NULL, -1);
+	set_sb_v2_flag(fs->fs_ondisk_sb, reiserfs_attrs_cleared);
+	mark_buffer_dirty(fs->fs_super_bh);
 }
diff --git a/fsck/fsck.h b/fsck/fsck.h
index feaf9a5..ac2a809 100644
--- a/fsck/fsck.h
+++ b/fsck/fsck.h
@@ -21,8 +21,8 @@
 #include "../version.h"
 
 /* main.c */
-extern reiserfs_filsys_t * fs;
-int main (int argc, char * argv []);
+extern reiserfs_filsys_t *fs;
+int main(int argc, char *argv[]);
 
 /* Exit codes. */
 #define EXIT_OK		0
@@ -30,7 +30,7 @@ int main (int argc, char * argv []);
 #define EXIT_REBOOT	2
 #define EXIT_FATAL	4
 #define EXIT_FIXABLE	6
-#define EXIT_OPER	8   /* Some operation returns error. */
+#define EXIT_OPER	8	/* Some operation returns error. */
 #define EXIT_USER	16
 
 /*
@@ -43,7 +43,7 @@ int main (int argc, char * argv []);
 #define FSCK_REBUILD            4
 #define FSCK_ROLLBACK_CHANGES   5
 #define FSCK_CLEAN_ATTRIBUTES	7
-#define FSCK_AUTO               8 /* -a || -p specified */
+#define FSCK_AUTO               8	/* -a || -p specified */
 
 /* temporary */
 #define DO_TEST                 9
@@ -65,90 +65,91 @@ int main (int argc, char * argv []);
 #define BADBLOCKS_FILE			1 << 10
 #define OPT_FORCE			1 << 11
 
-
 /* pass0.c */
-void pass_0 (reiserfs_filsys_t *);
-void load_pass_0_result (FILE *, reiserfs_filsys_t *);
+void pass_0(reiserfs_filsys_t *);
+void load_pass_0_result(FILE *, reiserfs_filsys_t *);
 
-int leaf_structure_check(reiserfs_filsys_t * fs, struct buffer_head * bh);
+int leaf_structure_check(reiserfs_filsys_t *fs, struct buffer_head *bh);
 
-int is_used_leaf (unsigned long block);
-int is_good_unformatted (unsigned long block);
-void mark_good_unformatted (unsigned long block);
-int is_bad_unformatted (unsigned long block);
+int is_used_leaf(unsigned long block);
+int is_good_unformatted(unsigned long block);
+void mark_good_unformatted(unsigned long block);
+int is_bad_unformatted(unsigned long block);
 
-int are_there_allocable_blocks (unsigned int amout_needed);
-unsigned long alloc_block (void);
-void make_allocable (unsigned long block);
-void register_uninsertable (unsigned long block);
-void register_saved_item (void);
-int still_bad_unfm_ptr_1 (unsigned long block);
-int still_bad_unfm_ptr_2 (unsigned long block);
-void make_alloc_bitmap (reiserfs_filsys_t *);
+int are_there_allocable_blocks(unsigned int amout_needed);
+unsigned long alloc_block(void);
+void make_allocable(unsigned long block);
+void register_uninsertable(unsigned long block);
+void register_saved_item(void);
+int still_bad_unfm_ptr_1(unsigned long block);
+int still_bad_unfm_ptr_2(unsigned long block);
+void make_alloc_bitmap(reiserfs_filsys_t *);
 
-void delete_aux_bitmaps ();
-void set_aux_bitmaps(reiserfs_bitmap_t * leaves, reiserfs_bitmap_t * good, reiserfs_bitmap_t * bad);
+void delete_aux_bitmaps();
+void set_aux_bitmaps(reiserfs_bitmap_t *leaves, reiserfs_bitmap_t *good,
+		     reiserfs_bitmap_t *bad);
 
 #define __is_marked(name,block) reiserfs_bitmap_test_bit (name##_bitmap, block)
 #define __mark(name,block) reiserfs_bitmap_set_bit (name##_bitmap, block)
 #define __unmark(name,block) reiserfs_bitmap_clear_bit (name##_bitmap, block)
 
 /* unformatted in tree */
-extern reiserfs_bitmap_t * bad_unfm_in_tree_once_bitmap;
+extern reiserfs_bitmap_t *bad_unfm_in_tree_once_bitmap;
 #define is_bad_unfm_in_tree_once(block) __is_marked (bad_unfm_in_tree_once, block)
 #define mark_bad_unfm_in_tree_once(block) __mark (bad_unfm_in_tree_once, block)
 
-
-
 /* pass1.c */
-void pass_1 (reiserfs_filsys_t *);
-void load_pass_1_result (FILE *, reiserfs_filsys_t *);
-struct buffer_head * make_buffer (int dev, unsigned long blocknr, int size, char * data);
-void build_the_tree (void);
+void pass_1(reiserfs_filsys_t *);
+void load_pass_1_result(FILE *, reiserfs_filsys_t *);
+struct buffer_head *make_buffer(int dev, unsigned long blocknr, int size,
+				char *data);
+void build_the_tree(void);
 extern int g_unaccessed_items;
-int is_item_reachable (struct item_head * ih);
-void mark_item_reachable (struct item_head * ih, struct buffer_head * bh);
-void mark_item_unreachable (struct item_head * ih);
-
-struct si * remove_saved_item (struct si * si);
-int tree_is_empty (void);
-void make_single_leaf_tree (struct buffer_head * bh);
+int is_item_reachable(struct item_head *ih);
+void mark_item_reachable(struct item_head *ih, struct buffer_head *bh);
+void mark_item_unreachable(struct item_head *ih);
 
+struct si *remove_saved_item(struct si *si);
+int tree_is_empty(void);
+void make_single_leaf_tree(struct buffer_head *bh);
 
 /* pass2.c */
-void pass_2 (reiserfs_filsys_t *);
-void load_pass_2_result (reiserfs_filsys_t *);
-void insert_item_separately (struct item_head * ih, char * item, int was_in_tree);
-void save_item (struct si ** head, struct item_head * ih, char * item, __u32 blocknr);
-struct si * save_and_delete_file_item (struct si * si, struct reiserfs_path *path);
-void take_bad_blocks_put_into_tree (void);
-void rewrite_object (struct item_head * ih, int do_remap);
-void pass_2_take_bad_blocks_put_into_tree (void);
+void pass_2(reiserfs_filsys_t *);
+void load_pass_2_result(reiserfs_filsys_t *);
+void insert_item_separately(struct item_head *ih, char *item, int was_in_tree);
+void save_item(struct si **head, struct item_head *ih, char *item,
+	       __u32 blocknr);
+struct si *save_and_delete_file_item(struct si *si, struct reiserfs_path *path);
+void take_bad_blocks_put_into_tree(void);
+void rewrite_object(struct item_head *ih, int do_remap);
+void pass_2_take_bad_blocks_put_into_tree(void);
 /*int is_remapped (struct item_head * ih);*/
-void link_relocated_files (void);
-int should_relocate (struct item_head * ih);
-void relocate_dir (struct item_head * ih, int change_ih);
+void link_relocated_files(void);
+int should_relocate(struct item_head *ih);
+void relocate_dir(struct item_head *ih, int change_ih);
 
-extern __u32 objectid_for_relocation (struct reiserfs_key *key);
+extern __u32 objectid_for_relocation(struct reiserfs_key *key);
 extern void linked_already(struct reiserfs_key *new_key);
 
 /* file.c */
 struct si {
-    struct item_head si_ih;
-    char * si_dnm_data;
-    struct si * si_next;
-    __u32 si_blocknr;
+	struct item_head si_ih;
+	char *si_dnm_data;
+	struct si *si_next;
+	__u32 si_blocknr;
 
-    // changed by XB;
-    struct si * last_known;
+	// changed by XB;
+	struct si *last_known;
 };
-void put_saved_items_into_tree (struct si *);
-int reiserfsck_file_write (struct item_head * ih, char * item, int was_in_tree);
-int are_file_items_correct (struct item_head * sd_ih, void * sd, __u64 * size, __u32 * blocks, int mark_passed_items, int * symlink);
-int delete_N_items_after_key(struct reiserfs_key *start_key, struct si ** save_here, int skip_dir_items, int n_to_delete);
-void rewrite_file (struct item_head * ih, int should_relocate, int should_change_ih);
-
-
+void put_saved_items_into_tree(struct si *);
+int reiserfsck_file_write(struct item_head *ih, char *item, int was_in_tree);
+int are_file_items_correct(struct item_head *sd_ih, void *sd, __u64 * size,
+			   __u32 * blocks, int mark_passed_items, int *symlink);
+int delete_N_items_after_key(struct reiserfs_key *start_key,
+			     struct si **save_here, int skip_dir_items,
+			     int n_to_delete);
+void rewrite_file(struct item_head *ih, int should_relocate,
+		  int should_change_ih);
 
 /* semantic.c */
 
@@ -159,64 +160,64 @@ void rewrite_file (struct item_head * ih, int should_relocate, int should_change
 #define RELOCATED -3
 #define LOOP_FOUND -4
 
-void load_semantic_result (FILE *, reiserfs_filsys_t *);
-
-void pass_3_semantic (reiserfs_filsys_t *);
-void semantic_check (void);
-int check_semantic_tree (struct reiserfs_key *key, struct reiserfs_key *parent, int is_dot_dot, int lost_found, struct item_head * new_ih);
-void zero_nlink (struct item_head * ih, void * sd);
-int not_a_directory (void * sd);
-int not_a_regfile (void * sd);
-int fix_obviously_wrong_sd_mode (struct reiserfs_path *path);
-int is_dot_dot (char * name, int namelen);
-int is_dot (char * name, int namelen);
-/*void create_dir_sd (reiserfs_filsys_t * fs, 
+void load_semantic_result(FILE *, reiserfs_filsys_t *);
+
+void pass_3_semantic(reiserfs_filsys_t *);
+void semantic_check(void);
+int check_semantic_tree(struct reiserfs_key *key, struct reiserfs_key *parent,
+			int is_dot_dot, int lost_found,
+			struct item_head *new_ih);
+void zero_nlink(struct item_head *ih, void *sd);
+int not_a_directory(void *sd);
+int not_a_regfile(void *sd);
+int fix_obviously_wrong_sd_mode(struct reiserfs_path *path);
+int is_dot_dot(char *name, int namelen);
+int is_dot(char *name, int namelen);
+/*void create_dir_sd (reiserfs_filsys_t *fs, 
   struct reiserfs_path *path, struct reiserfs_key *key);*/
-int rebuild_check_regular_file (struct reiserfs_path *path, void * sd,
-				struct item_head * new_ih);
-int rebuild_semantic_pass (struct reiserfs_key *key, struct reiserfs_key *parent, int is_dot_dot,
-			   struct item_head * new_ih);
-
-
-
+int rebuild_check_regular_file(struct reiserfs_path *path, void *sd,
+			       struct item_head *new_ih);
+int rebuild_semantic_pass(struct reiserfs_key *key, struct reiserfs_key *parent,
+			  int is_dot_dot, struct item_head *new_ih);
 
 /* lost+found.c */
-void pass_3a_look_for_lost (reiserfs_filsys_t *);
+void pass_3a_look_for_lost(reiserfs_filsys_t *);
 
-void load_lost_found_result (reiserfs_filsys_t *);
+void load_lost_found_result(reiserfs_filsys_t *);
 
 /* pass4.c */
-void pass_4_check_unaccessed_items (void);
+void pass_4_check_unaccessed_items(void);
 
 /* check.c */
-int is_leaf_bad (struct buffer_head * bh);
-int is_bad_item (struct buffer_head * bh, struct item_head *, char *);
+int is_leaf_bad(struct buffer_head *bh);
+int is_bad_item(struct buffer_head *bh, struct item_head *, char *);
 /*int check_file_system (void);*/
-void reiserfsck_check_pass1 (void);
+void reiserfsck_check_pass1(void);
 /*char * bad_name (char * name, int namelen);*/
 /* to test result of direcotry item recovering on pass 0 */
-int is_bad_directory (struct item_head * ih, char * item, int dev, int blocksize);
-
+int is_bad_directory(struct item_head *ih, char *item, int dev, int blocksize);
 
 //extern int bad_block_number (struct super_block * s, blocknr_t block);
 
 /* check_tree.c */
-void check_fs_tree (reiserfs_filsys_t *);
-void do_clean_attributes (reiserfs_filsys_t * fs);
-int bad_pair (reiserfs_filsys_t *, struct buffer_head * bh, int i);
-int bad_leaf_2 (reiserfs_filsys_t *, struct buffer_head * bh);
+void check_fs_tree(reiserfs_filsys_t *);
+void do_clean_attributes(reiserfs_filsys_t *fs);
+int bad_pair(reiserfs_filsys_t *, struct buffer_head *bh, int i);
+int bad_leaf_2(reiserfs_filsys_t *, struct buffer_head *bh);
 
 #if 0
-extern int should_be_relocated (struct reiserfs_key *key);
-extern void to_be_relocated (struct reiserfs_key *key);
+extern int should_be_relocated(struct reiserfs_key *key);
+extern void to_be_relocated(struct reiserfs_key *key);
 extern void clear_relocated_list(void);
 #endif
 
 /* ustree.c */
-void reiserfsck_paste_into_item (struct reiserfs_path *path, const char * body, int size);
-void reiserfsck_insert_item (struct reiserfs_path *path, struct item_head * ih, const char * body);
-void reiserfsck_delete_item (struct reiserfs_path *path, int temporary);
-void reiserfsck_cut_from_item (struct reiserfs_path *path, int cut_size);
+void reiserfsck_paste_into_item(struct reiserfs_path *path, const char *body,
+				int size);
+void reiserfsck_insert_item(struct reiserfs_path *path, struct item_head *ih,
+			    const char *body);
+void reiserfsck_delete_item(struct reiserfs_path *path, int temporary);
+void reiserfsck_cut_from_item(struct reiserfs_path *path, int cut_size);
 /*typedef	int (comp3_function_t)(void * key1, void * key2, int version);*/
 /*typedef int (comp_function_t)(struct reiserfs_key *key1, struct reiserfs_key *key2);*/
 /*int ubin_search_id(__u32 * id, __u32 * base, __u32 number, __u32 * pos);*/
@@ -225,29 +226,29 @@ void reiserfsck_cut_from_item (struct reiserfs_path *path, int cut_size);
 		      comp3_function_t comp_func, int version);		
 		      int usearch_by_entry_key (struct super_block * s, struct reiserfs_key *key, struct reiserfs_path *path);*/
 
-typedef int do_after_read_t (reiserfs_filsys_t *, struct buffer_head **, int h);
-typedef int do_on_full_path_t (reiserfs_filsys_t *, struct buffer_head **, int);
-void pass_through_tree (reiserfs_filsys_t *, do_after_read_t, do_on_full_path_t, int depth);
+typedef int do_after_read_t(reiserfs_filsys_t *, struct buffer_head **, int h);
+typedef int do_on_full_path_t(reiserfs_filsys_t *, struct buffer_head **, int);
+void pass_through_tree(reiserfs_filsys_t *, do_after_read_t, do_on_full_path_t,
+		       int depth);
 
 /* bitmap.c */
-int reiserfsck_reiserfs_new_blocknrs (reiserfs_filsys_t * fs,
-				      unsigned long * pblocknrs,
-				      unsigned long start_from,
-				      int amount_needed);
-int reiserfsck_reiserfs_free_block (reiserfs_filsys_t * fs, unsigned long block);
-struct buffer_head * reiserfsck_get_new_buffer (unsigned long start);
-int is_block_used (unsigned long block);
-void mark_block_used (unsigned long block, int check_hardware);
-void mark_block_uninsertable (unsigned long block);
-int is_block_uninsertable (unsigned long block);
-
+int reiserfsck_reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
+				     unsigned long *pblocknrs,
+				     unsigned long start_from,
+				     int amount_needed);
+int reiserfsck_reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block);
+struct buffer_head *reiserfsck_get_new_buffer(unsigned long start);
+int is_block_used(unsigned long block);
+void mark_block_used(unsigned long block, int check_hardware);
+void mark_block_uninsertable(unsigned long block);
+int is_block_uninsertable(unsigned long block);
 
 /* objectid.c */
 int comp_ids(const void *p1, const void *p2);
 
 typedef struct id_map {
-    void **index;
-    __u32 count, last_used;
+	void **index;
+	__u32 count, last_used;
 } id_map_t;
 
 id_map_t *id_map_init();
@@ -255,174 +256,165 @@ void id_map_free(id_map_t *);
 int id_map_test(id_map_t *map, __u32 id);
 int id_map_mark(id_map_t *map, __u32 id);
 __u32 id_map_alloc(id_map_t *map);
-void id_map_flush(struct id_map * map, reiserfs_filsys_t * fs);
-    
+void id_map_flush(struct id_map *map, reiserfs_filsys_t *fs);
+
 /* FIXME: Needs to be implemented
-void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t * fs);
+void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t *fs);
 
 void reiserfs_objectid_map_save (FILE * fp, struct id_map * id_map);
 struct id_map * reiserfs_objectid_map_load (FILE * fp);
 */
 
-void mark_formatted_pointed_by_indirect (__u32);
-int is_formatted_pointed_by_indirect (__u32);
+void mark_formatted_pointed_by_indirect(__u32);
+int is_formatted_pointed_by_indirect(__u32);
 
 #define MAP_NOT_PACKED	0
 #define MAP_PACKED	1
 
 struct pass0_stat {
-    unsigned long dealt_with; /* number of blocks read during pass 0 */
-    unsigned long leaves; /* blocks looking like reiserfs leaves found */
-    unsigned long leaves_corrected;
-    unsigned long all_contents_removed;
-    unsigned long too_old_leaves; /* these are leaves which contains
-                                     direntries with different hash from the
-                                     one specified with -h */
-    unsigned long wrong_pointers; /* pointers in indirect items pointing to
-                                     wrong area */
-    unsigned long pointed; /* pointers blocks of device pointed by all
-                              indirect items */
+	unsigned long dealt_with;	/* number of blocks read during pass 0 */
+	unsigned long leaves;	/* blocks looking like reiserfs leaves found */
+	unsigned long leaves_corrected;
+	unsigned long all_contents_removed;
+	unsigned long too_old_leaves;	/* these are leaves which contains
+					   direntries with different hash from the
+					   one specified with -h */
+	unsigned long wrong_pointers;	/* pointers in indirect items pointing to
+					   wrong area */
+	unsigned long pointed;	/* pointers blocks of device pointed by all
+				   indirect items */
 };
 
-
 struct pass1_stat {
-    unsigned long leaves; /* leaves found in pass0 to build tree off */
-    unsigned long inserted_leaves; /* number of leaves inserted by pointers */
-    unsigned long pointed_leaves; /* pointers in indirect items which pointed
-				     to leaves (zeroed) */
-    unsigned long uninsertable_leaves;
-    unsigned long non_unique_pointers; /* pointers to already pointed unformatted nodes */
-    unsigned long correct_pointers;
-    unsigned long saved_items; /* items saved on pass1: should be 0 */
-    unsigned long allocable_blocks; /* allocable blocks before pass 1 starts */
+	unsigned long leaves;	/* leaves found in pass0 to build tree off */
+	unsigned long inserted_leaves;	/* number of leaves inserted by pointers */
+	unsigned long pointed_leaves;	/* pointers in indirect items which pointed
+					   to leaves (zeroed) */
+	unsigned long uninsertable_leaves;
+	unsigned long non_unique_pointers;	/* pointers to already pointed unformatted nodes */
+	unsigned long correct_pointers;
+	unsigned long saved_items;	/* items saved on pass1: should be 0 */
+	unsigned long allocable_blocks;	/* allocable blocks before pass 1 starts */
 };
 
-
 struct pass2_stat {
-    unsigned long leaves; /* leaves inserted item by item */
-    unsigned long safe_non_unique_pointers; /* these are just the same pointers */
-    unsigned long relocated;
-    unsigned long shared_objectids;
-    unsigned long rewritten;
+	unsigned long leaves;	/* leaves inserted item by item */
+	unsigned long safe_non_unique_pointers;	/* these are just the same pointers */
+	unsigned long relocated;
+	unsigned long shared_objectids;
+	unsigned long rewritten;
 };
 
-
 struct semantic_stat {
-    unsigned long oid_sharing_files_relocated;
-    unsigned long regular_files;
-    unsigned long directories;
-    unsigned long symlinks;
-    unsigned long broken_files;
-    unsigned long others;
-    unsigned long fixed_sizes;
-    unsigned long oid_sharing;
-    unsigned long oid_sharing_dirs_relocated;
-    unsigned long deleted_entries;
+	unsigned long oid_sharing_files_relocated;
+	unsigned long regular_files;
+	unsigned long directories;
+	unsigned long symlinks;
+	unsigned long broken_files;
+	unsigned long others;
+	unsigned long fixed_sizes;
+	unsigned long oid_sharing;
+	unsigned long oid_sharing_dirs_relocated;
+	unsigned long deleted_entries;
 };
 
-
 struct lost_found_stat {
-    unsigned long dir_recovered;
-    unsigned long empty_lost_dirs;
-    unsigned long lost_found;
-    unsigned long lost_found_files;
-    unsigned long lost_found_dirs;
-    unsigned long oid_sharing;
-    unsigned long oid_sharing_dirs_relocated;    
-    unsigned long oid_sharing_files_relocated;    
+	unsigned long dir_recovered;
+	unsigned long empty_lost_dirs;
+	unsigned long lost_found;
+	unsigned long lost_found_files;
+	unsigned long lost_found_dirs;
+	unsigned long oid_sharing;
+	unsigned long oid_sharing_dirs_relocated;
+	unsigned long oid_sharing_files_relocated;
 };
 
-
 struct pass_4_stat {
-    unsigned long deleted_items;
+	unsigned long deleted_items;
 };
 
-
 struct rebuild_info {
-    union {
-	struct pass0_stat pass0;
-	struct pass1_stat pass1;
-	struct pass2_stat pass2;
-	struct {
-	    struct semantic_stat semantic;
-	    struct lost_found_stat lost_found;
-	} tree;
-	struct pass_4_stat pass4;
-    } pass_u;
-
-    /* bitmaps */
-    reiserfs_bitmap_t * source_bitmap;
-    reiserfs_bitmap_t * new_bitmap;
-    reiserfs_bitmap_t * allocable_bitmap;
-    reiserfs_bitmap_t * uninsertables;
-
-    char * bitmap_file_name;
-    /*char * new_bitmap_file_name;*/
-    char * passes_dump_file_name; /* after pass 0, 1 or 2 reiserfsck can store
-                                     data with which it will be able to start
-                                     from the point it stopped last time at */
-
-    unsigned short mode;
-    unsigned long options;
-
-    /* rollback file */
-    char * rollback_file;
-  
-    /* hash hits stat */
-    int hash_amount;
-    unsigned long * hash_hits;
-    char * defined_hash;
+	union {
+		struct pass0_stat pass0;
+		struct pass1_stat pass1;
+		struct pass2_stat pass2;
+		struct {
+			struct semantic_stat semantic;
+			struct lost_found_stat lost_found;
+		} tree;
+		struct pass_4_stat pass4;
+	} pass_u;
+
+	/* bitmaps */
+	reiserfs_bitmap_t *source_bitmap;
+	reiserfs_bitmap_t *new_bitmap;
+	reiserfs_bitmap_t *allocable_bitmap;
+	reiserfs_bitmap_t *uninsertables;
+
+	char *bitmap_file_name;
+	/*char * new_bitmap_file_name; */
+	char *passes_dump_file_name;	/* after pass 0, 1 or 2 reiserfsck can store
+					   data with which it will be able to start
+					   from the point it stopped last time at */
+
+	unsigned short mode;
+	unsigned long options;
+
+	/* rollback file */
+	char *rollback_file;
+
+	/* hash hits stat */
+	int hash_amount;
+	unsigned long *hash_hits;
+	char *defined_hash;
 
 #define USED_BLOCKS 1
 #define EXTERN_BITMAP 2
 #define ALL_BLOCKS 3
-    int scan_area;
-    int use_journal_area;
-    int test;
+	int scan_area;
+	int use_journal_area;
+	int test;
 };
 
-
 struct check_info {
-    unsigned long bad_nodes;
-    unsigned long fatal_corruptions;
-    unsigned long fixable_corruptions;
+	unsigned long bad_nodes;
+	unsigned long fatal_corruptions;
+	unsigned long fixable_corruptions;
 //    unsigned long badblocks_corruptions;
-    unsigned long leaves;
-    unsigned long internals;
-    unsigned long dirs;
-    unsigned long files;
-    unsigned long safe;
-    unsigned long unfm_pointers;
-    unsigned long zero_unfm_pointers;
-    reiserfs_bitmap_t * deallocate_bitmap;
+	unsigned long leaves;
+	unsigned long internals;
+	unsigned long dirs;
+	unsigned long files;
+	unsigned long safe;
+	unsigned long unfm_pointers;
+	unsigned long zero_unfm_pointers;
+	reiserfs_bitmap_t *deallocate_bitmap;
 };
 
-
 struct fsck_data {
-    unsigned short mode; /* check, rebuild, etc*/
-    unsigned long options;
-    unsigned long mounted;
-
-    struct rebuild_info rebuild;
-    struct check_info check;
-
-    char * journal_dev_name; 
-    /* log file name and handle */
-    char * log_file_name;
-    FILE * log;
-
-    /* this is a file where reiserfsck will explain what it is doing. This is
-       usually stderr. But when -g is specified - reiserfsck runs in the
-       background and append progress information into 'fsck.run' */
-    FILE * progress;
-
-    /* objectid maps */
-    id_map_t * proper_id_map;
-    id_map_t * semantic_id_map; /* this objectid map is used to
-                                        cure objectid sharing problem */
+	unsigned short mode;	/* check, rebuild, etc */
+	unsigned long options;
+	unsigned long mounted;
+
+	struct rebuild_info rebuild;
+	struct check_info check;
+
+	char *journal_dev_name;
+	/* log file name and handle */
+	char *log_file_name;
+	FILE *log;
+
+	/* this is a file where reiserfsck will explain what it is doing. This is
+	   usually stderr. But when -g is specified - reiserfsck runs in the
+	   background and append progress information into 'fsck.run' */
+	FILE *progress;
+
+	/* objectid maps */
+	id_map_t *proper_id_map;
+	id_map_t *semantic_id_map;	/* this objectid map is used to
+					   cure objectid sharing problem */
 };
 
-
 #define fsck_data(fs) ((struct fsck_data *)((fs)->fs_vp))
 #define pass_0_stat(fs) (&(fsck_data(fs)->rebuild.pass_u.pass0))
 #define pass_1_stat(fs) (&(fsck_data(fs)->rebuild.pass_u.pass1))
@@ -433,7 +425,6 @@ struct fsck_data {
 
 #define fsck_check_stat(fs) (&(fsck_data(fs)->check))
 
-
 #define proper_id_map(s) fsck_data(s)->proper_id_map
 #define semantic_id_map(s) fsck_data(s)->semantic_id_map
 
@@ -464,7 +455,6 @@ struct fsck_data {
 #define fsck_skip_journal(fs) (fsck_data(fs)->options & OPT_SKIP_JOURNAL)
 #define fsck_yes_all(fs) (fsck_data(fs)->options & OPT_YES)
 
-
 #define fsck_mode(fs) (fsck_data(fs)->mode)
 #define fsck_log_file(fs) (fsck_data(fs)->log)
 #define fsck_progress_file(fs) ((fs && fsck_data(fs)->progress) ? fsck_data(fs)->progress : stderr)
@@ -475,15 +465,15 @@ struct fsck_data {
 /* name of file where we store rollback data */
 #define state_rollback_file(fs) fsck_data(fs)->rebuild.rollback_file
 
-int fsck_user_confirmed (reiserfs_filsys_t * fs, char * q, char * a, int default_answer);
-void stage_report (int, reiserfs_filsys_t *);
+int fsck_user_confirmed(reiserfs_filsys_t *fs, char *q, char *a,
+			int default_answer);
+void stage_report(int, reiserfs_filsys_t *);
 
 /* journal.c */
-int replay_journal (reiserfs_filsys_t *);
+int replay_journal(reiserfs_filsys_t *);
 
 /*pass1: rebuild super block*/
-void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * data);
-
+void rebuild_sb(reiserfs_filsys_t *fs, char *filename, struct fsck_data *data);
 
 #define fsck_log(fmt, list...) \
 {\
diff --git a/fsck/info.c b/fsck/info.c
index d5621dd..3f7f8ed 100644
--- a/fsck/info.c
+++ b/fsck/info.c
@@ -5,172 +5,210 @@
 
 #include "fsck.h"
 
-
-int fsck_user_confirmed (reiserfs_filsys_t * fs, char * q, char * a, int default_answer)
+int fsck_user_confirmed(reiserfs_filsys_t *fs, char *q, char *a,
+			int default_answer)
 {
-    if (!fsck_interactive (fs))
-	return default_answer;
-    
-    return user_confirmed (fsck_progress_file (fs), q, a);
-}
+	if (!fsck_interactive(fs))
+		return default_answer;
 
+	return user_confirmed(fsck_progress_file(fs), q, a);
+}
 
-void stage_report (int pass, reiserfs_filsys_t * fs)
+void stage_report(int pass, reiserfs_filsys_t *fs)
 {
-    switch (pass) {
-    case 0: 
-    {
-	struct pass0_stat * stat;
-
-	/* what has been done on pass 0 */	
-	stat = pass_0_stat (fs);
-	fsck_progress ("\tRead blocks (but not data blocks) %lu\n", stat->dealt_with);
-	fsck_progress ("\t\tLeaves among those %lu\n", stat->leaves);
-	if (stat->leaves_corrected)
-	    fsck_progress ("\t\t\t- corrected leaves %lu\n", stat->leaves_corrected);
-	if (stat->all_contents_removed)
-	    fsck_progress ("\t\t\t- leaves all contents of which could not be saved and deleted %lu\n",
-			   stat->all_contents_removed);
-	if (stat->too_old_leaves)
-	    fsck_progress ("\t\t\t- too old leaves %lu (skipped)\n", stat->too_old_leaves);
-	if (stat->wrong_pointers)
-	    fsck_progress ("\t\tpointers in indirect items to wrong area %lu (zeroed)\n",
-			   stat->wrong_pointers);
-	fsck_progress ("\t\tObjectids found %lu\n", proper_id_map(fs)->count);
-    }
-    break;
-	
-    case 1:
-    {
-	struct pass1_stat * stat;
-
-	/* what has been done on pass 1 */
-	stat = pass_1_stat (fs);
-	fsck_progress ("\t%lu leaves read\n", stat->leaves);
-	fsck_progress ("\t\t%lu inserted\n", stat->inserted_leaves);
-	if (stat->pointed_leaves)
-	    fsck_progress ("\t\t\t- pointers in indirect items pointing to metadata %lu (zeroed)\n",
-			   stat->pointed_leaves);
-	if (stat->saved_items)
-	    fsck_progress ("\tSaved %lu items\n", stat->saved_items);
-	if (stat->uninsertable_leaves)
-	    fsck_progress ("\t\t%lu not inserted\n", stat->uninsertable_leaves);
-	if (stat->non_unique_pointers)
-	    fsck_progress ("\tnon-unique pointers in indirect items (zeroed) %lu\n",
-			   stat->non_unique_pointers);
-    }
-    break;
-
-    case 2:
-    {
-	struct pass2_stat * stat;
-
-	/* what has been done on pass 2 */
-	stat = pass_2_stat (fs);
-	if (stat->leaves)
-	    fsck_progress ("\tLeaves inserted item by item %lu\n", stat->leaves);
-	if (stat->safe_non_unique_pointers)
-	    fsck_progress ("\t%lu \n",
-			   stat->safe_non_unique_pointers);
-	if (stat->shared_objectids)
-	    fsck_progress ("\t%lu shared objectids\n", stat->shared_objectids);
-	if (stat->relocated)
-	    fsck_progress ("\tFiles relocated because of key conflicts with a directory %lu\n",
-			   stat->relocated);
-	if (stat->rewritten)
-	    fsck_progress ("\tFiles rewritten %lu\n", stat->rewritten);
-    }
-    break;
-
-    case 3: /* semantic */
-    {
-	struct semantic_stat * stat;
-
-	/* what has been done on the semantic pass */
-	stat = sem_pass_stat (fs);
-	fsck_progress ("\tFiles found: %ld\n", stat->regular_files);
-	fsck_progress ("\tDirectories found: %ld\n", stat->directories);
-	if (stat->symlinks)
-	    fsck_progress ("\tSymlinks found: %ld\n", stat->symlinks);
-	if (stat->others)
-	    fsck_progress ("\tOthers: %ld\n", stat->others);
-	if (stat->broken_files)
-	    fsck_progress ("\tBroken (of files/symlinks/others): %ld\n", stat->broken_files);
-	if (stat->fixed_sizes)
-	    fsck_progress ("\tFiles with fixed size: %ld\n", stat->fixed_sizes);
-	if (stat->deleted_entries)
-	    fsck_progress ("\tNames pointing to nowhere (removed): %ld\n", stat->deleted_entries);
-	if (stat->oid_sharing)
-	    fsck_progress ("\tObjects having used objectids: %lu\n", stat->oid_sharing);
-	if (stat->oid_sharing_files_relocated)
-	    fsck_progress ("\t\tfiles fixed %lu\n", stat->oid_sharing_files_relocated);
-	if (stat->oid_sharing_dirs_relocated)
-	    fsck_progress ("\t\tdirs fixed %lu\n", stat->oid_sharing_dirs_relocated);
-    }
-    break;
-    
-    case 0x3a: /* lost+found pass */
-    {
-	struct lost_found_stat * stat;
-
-	/* what has been done on the semantic pass */
-	stat = lost_found_pass_stat (fs);
-	if (stat->lost_found)
-	    fsck_progress ("\tObjects without names %lu\n",
-			   stat->lost_found);
-	if (stat->empty_lost_dirs)
-	    fsck_progress ("\tEmpty lost dirs removed %lu\n",
-			   stat->empty_lost_dirs);
-	if (stat->lost_found_dirs)
-	    fsck_progress ("\tDirs linked to /lost+found: %lu\n",
-			   stat->lost_found_dirs);
-	if (stat->dir_recovered)
-	    fsck_progress ("\t\tDirs without stat data found %lu\n",
-			   stat->dir_recovered);
-
-	if (stat->lost_found_files)
-	    fsck_progress ("\tFiles linked to /lost+found %lu\n",
-			   stat->lost_found_files);
-	if (stat->oid_sharing)
-	    fsck_progress ("\tObjects having used objectids: %lu\n", stat->oid_sharing);
-	if (stat->oid_sharing_files_relocated)
-	    fsck_progress ("\t\tfiles fixed %lu\n", stat->oid_sharing_files_relocated);
-	if (stat->oid_sharing_dirs_relocated)
-	    fsck_progress ("\t\tdirs fixed %lu\n", stat->oid_sharing_dirs_relocated);
-    }
-    break;
-
-    case 4: /* removing of unreachable */
-    {
-	struct pass_4_stat * stat;
-
-	/* what has been done on the semantic pass */
-	stat = pass_4_stat (fs);
-	if (stat->deleted_items)
-	    fsck_progress ("\tDeleted unreachable items %lu\n",
-			   stat->deleted_items);
-    }
-    break;
-
-    case 5:
-	fsck_progress ("There are on the filesystem:\n"
-		       "\tLeaves %lu\n\tInternal nodes %lu\n"
-		       "\tDirectories %lu\n\tOther files %lu\n"
-		       "\tData block pointers %lu (%lu of them are zero)\n"
-		       "\tSafe links %lu\n",
-		       fsck_check_stat (fs)->leaves,
-		       fsck_check_stat (fs)->internals,
-		       fsck_check_stat (fs)->dirs,
-		       fsck_check_stat (fs)->files,
-		       fsck_check_stat (fs)->unfm_pointers,
-		       fsck_check_stat (fs)->zero_unfm_pointers,
-		       fsck_check_stat (fs)->safe);
-	
-	
-    } /* switch */
-
-    memset (&fsck_data (fs)->rebuild.pass_u, 0, sizeof (fsck_data (fs)->rebuild.pass_u));
+	switch (pass) {
+	case 0:
+		{
+			struct pass0_stat *stat;
+
+			/* what has been done on pass 0 */
+			stat = pass_0_stat(fs);
+			fsck_progress
+			    ("\tRead blocks (but not data blocks) %lu\n",
+			     stat->dealt_with);
+			fsck_progress("\t\tLeaves among those %lu\n",
+				      stat->leaves);
+			if (stat->leaves_corrected)
+				fsck_progress("\t\t\t- corrected leaves %lu\n",
+					      stat->leaves_corrected);
+			if (stat->all_contents_removed)
+				fsck_progress
+				    ("\t\t\t- leaves all contents of which could not be saved and deleted %lu\n",
+				     stat->all_contents_removed);
+			if (stat->too_old_leaves)
+				fsck_progress
+				    ("\t\t\t- too old leaves %lu (skipped)\n",
+				     stat->too_old_leaves);
+			if (stat->wrong_pointers)
+				fsck_progress
+				    ("\t\tpointers in indirect items to wrong area %lu (zeroed)\n",
+				     stat->wrong_pointers);
+			fsck_progress("\t\tObjectids found %lu\n",
+				      proper_id_map(fs)->count);
+		}
+		break;
+
+	case 1:
+		{
+			struct pass1_stat *stat;
+
+			/* what has been done on pass 1 */
+			stat = pass_1_stat(fs);
+			fsck_progress("\t%lu leaves read\n", stat->leaves);
+			fsck_progress("\t\t%lu inserted\n",
+				      stat->inserted_leaves);
+			if (stat->pointed_leaves)
+				fsck_progress
+				    ("\t\t\t- pointers in indirect items pointing to metadata %lu (zeroed)\n",
+				     stat->pointed_leaves);
+			if (stat->saved_items)
+				fsck_progress("\tSaved %lu items\n",
+					      stat->saved_items);
+			if (stat->uninsertable_leaves)
+				fsck_progress("\t\t%lu not inserted\n",
+					      stat->uninsertable_leaves);
+			if (stat->non_unique_pointers)
+				fsck_progress
+				    ("\tnon-unique pointers in indirect items (zeroed) %lu\n",
+				     stat->non_unique_pointers);
+		}
+		break;
+
+	case 2:
+		{
+			struct pass2_stat *stat;
+
+			/* what has been done on pass 2 */
+			stat = pass_2_stat(fs);
+			if (stat->leaves)
+				fsck_progress
+				    ("\tLeaves inserted item by item %lu\n",
+				     stat->leaves);
+			if (stat->safe_non_unique_pointers)
+				fsck_progress("\t%lu \n",
+					      stat->safe_non_unique_pointers);
+			if (stat->shared_objectids)
+				fsck_progress("\t%lu shared objectids\n",
+					      stat->shared_objectids);
+			if (stat->relocated)
+				fsck_progress
+				    ("\tFiles relocated because of key conflicts with a directory %lu\n",
+				     stat->relocated);
+			if (stat->rewritten)
+				fsck_progress("\tFiles rewritten %lu\n",
+					      stat->rewritten);
+		}
+		break;
+
+	case 3:		/* semantic */
+		{
+			struct semantic_stat *stat;
+
+			/* what has been done on the semantic pass */
+			stat = sem_pass_stat(fs);
+			fsck_progress("\tFiles found: %ld\n",
+				      stat->regular_files);
+			fsck_progress("\tDirectories found: %ld\n",
+				      stat->directories);
+			if (stat->symlinks)
+				fsck_progress("\tSymlinks found: %ld\n",
+					      stat->symlinks);
+			if (stat->others)
+				fsck_progress("\tOthers: %ld\n", stat->others);
+			if (stat->broken_files)
+				fsck_progress
+				    ("\tBroken (of files/symlinks/others): %ld\n",
+				     stat->broken_files);
+			if (stat->fixed_sizes)
+				fsck_progress("\tFiles with fixed size: %ld\n",
+					      stat->fixed_sizes);
+			if (stat->deleted_entries)
+				fsck_progress
+				    ("\tNames pointing to nowhere (removed): %ld\n",
+				     stat->deleted_entries);
+			if (stat->oid_sharing)
+				fsck_progress
+				    ("\tObjects having used objectids: %lu\n",
+				     stat->oid_sharing);
+			if (stat->oid_sharing_files_relocated)
+				fsck_progress("\t\tfiles fixed %lu\n",
+					      stat->
+					      oid_sharing_files_relocated);
+			if (stat->oid_sharing_dirs_relocated)
+				fsck_progress("\t\tdirs fixed %lu\n",
+					      stat->oid_sharing_dirs_relocated);
+		}
+		break;
+
+	case 0x3a:		/* lost+found pass */
+		{
+			struct lost_found_stat *stat;
+
+			/* what has been done on the semantic pass */
+			stat = lost_found_pass_stat(fs);
+			if (stat->lost_found)
+				fsck_progress("\tObjects without names %lu\n",
+					      stat->lost_found);
+			if (stat->empty_lost_dirs)
+				fsck_progress("\tEmpty lost dirs removed %lu\n",
+					      stat->empty_lost_dirs);
+			if (stat->lost_found_dirs)
+				fsck_progress
+				    ("\tDirs linked to /lost+found: %lu\n",
+				     stat->lost_found_dirs);
+			if (stat->dir_recovered)
+				fsck_progress
+				    ("\t\tDirs without stat data found %lu\n",
+				     stat->dir_recovered);
+
+			if (stat->lost_found_files)
+				fsck_progress
+				    ("\tFiles linked to /lost+found %lu\n",
+				     stat->lost_found_files);
+			if (stat->oid_sharing)
+				fsck_progress
+				    ("\tObjects having used objectids: %lu\n",
+				     stat->oid_sharing);
+			if (stat->oid_sharing_files_relocated)
+				fsck_progress("\t\tfiles fixed %lu\n",
+					      stat->
+					      oid_sharing_files_relocated);
+			if (stat->oid_sharing_dirs_relocated)
+				fsck_progress("\t\tdirs fixed %lu\n",
+					      stat->oid_sharing_dirs_relocated);
+		}
+		break;
+
+	case 4:		/* removing of unreachable */
+		{
+			struct pass_4_stat *stat;
+
+			/* what has been done on the semantic pass */
+			stat = pass_4_stat(fs);
+			if (stat->deleted_items)
+				fsck_progress
+				    ("\tDeleted unreachable items %lu\n",
+				     stat->deleted_items);
+		}
+		break;
+
+	case 5:
+		fsck_progress("There are on the filesystem:\n"
+			      "\tLeaves %lu\n\tInternal nodes %lu\n"
+			      "\tDirectories %lu\n\tOther files %lu\n"
+			      "\tData block pointers %lu (%lu of them are zero)\n"
+			      "\tSafe links %lu\n",
+			      fsck_check_stat(fs)->leaves,
+			      fsck_check_stat(fs)->internals,
+			      fsck_check_stat(fs)->dirs,
+			      fsck_check_stat(fs)->files,
+			      fsck_check_stat(fs)->unfm_pointers,
+			      fsck_check_stat(fs)->zero_unfm_pointers,
+			      fsck_check_stat(fs)->safe);
+
+	}			/* switch */
+
+	memset(&fsck_data(fs)->rebuild.pass_u, 0,
+	       sizeof(fsck_data(fs)->rebuild.pass_u));
 
 }
-
-
diff --git a/fsck/lost+found.c b/fsck/lost+found.c
index 729bde2..ed4156e 100644
--- a/fsck/lost+found.c
+++ b/fsck/lost+found.c
@@ -5,368 +5,415 @@
 
 #include "fsck.h"
 
+void erase_name(int len);
+void print_name(char *name, int len);
 
-void erase_name (int len);
-void print_name (char * name, int len);
-
-void modify_item (struct item_head * ih, void * item);
+void modify_item(struct item_head *ih, void *item);
 
 /* fixme: search_by_key is not needed after any add_entry */
-static __u64 _look_for_lost (reiserfs_filsys_t * fs, int link_lost_dirs)
+static __u64 _look_for_lost(reiserfs_filsys_t *fs, int link_lost_dirs)
 {
-    struct reiserfs_key key, prev_key, * rdkey;
-    INITIALIZE_REISERFS_PATH(path);
-    int item_pos;
-    struct buffer_head * bh;
-    struct item_head * ih;
-    unsigned long leaves;
-    int is_it_dir;
-    static int lost_files = 0; /* looking for lost dirs we calculate amount of
-				  lost files, so that when we will look for
-				  lost files we will be able to stop when
-				  there are no lost files anymore */
-    int retval;
-    __u64 size;
-
-    key = root_dir_key;
-
-    if (!link_lost_dirs && !lost_files) {
-	/* we have to look for lost files but we know already that there are
-           no any */
-	return 0;
-    }
-	
-    fsck_progress ("Looking for lost %s:\n", link_lost_dirs ? "directories" : "files");
-    leaves = 0;
-
-    /* total size of added entries */
-    size = 0;
-    while (1) {
-	retval = reiserfs_search_by_key_4 (fs, &key, &path);
-	/* fixme: we assume path ends up with a leaf */
-	bh = get_bh (&path);
-	item_pos = get_item_pos (&path);
-	if (retval != ITEM_FOUND) {
-	    if (item_pos == get_blkh_nr_items (B_BLK_HEAD (bh))) {
-		rdkey = uget_rkey (&path);
-		if (!rdkey) {
-		    pathrelse (&path);
-		    break;
-		}
-		key = *rdkey;
-		pathrelse (&path);
-		continue;
-	    }
-	    /* we are on the item in the buffer */
+	struct reiserfs_key key, prev_key, *rdkey;
+	INITIALIZE_REISERFS_PATH(path);
+	int item_pos;
+	struct buffer_head *bh;
+	struct item_head *ih;
+	unsigned long leaves;
+	int is_it_dir;
+	static int lost_files = 0;	/* looking for lost dirs we calculate amount of
+					   lost files, so that when we will look for
+					   lost files we will be able to stop when
+					   there are no lost files anymore */
+	int retval;
+	__u64 size;
+
+	key = root_dir_key;
+
+	if (!link_lost_dirs && !lost_files) {
+		/* we have to look for lost files but we know already that there are
+		   no any */
+		return 0;
 	}
 
-	/* print ~ how many leaves were scanned and how fast it was */
-	if (!fsck_quiet (fs))
-	    print_how_fast (leaves++, 0, 50, 0);
-
-	for (ih = get_ih (&path); item_pos < get_blkh_nr_items (B_BLK_HEAD (bh)); item_pos ++, ih ++, PATH_LAST_POSITION(&path)++) {
-	    if (is_item_reachable (ih))
-		continue;
-
-	    /* found item which can not be reached */
-	    if (!is_direntry_ih (ih) && !is_stat_data_ih (ih)) {
-		continue;
-	    }
-
-	    if (is_direntry_ih (ih)) {
-		/* if this directory has no stat data - try to recover it */
-		struct reiserfs_key sd;
-		struct reiserfs_path tmp;
-
-		sd = ih->ih_key;
-		set_type_and_offset (KEY_FORMAT_1, &sd, SD_OFFSET, TYPE_STAT_DATA);
-		if (reiserfs_search_by_key_4 (fs, &sd, &tmp) == ITEM_FOUND) {
-		    /* should not happen - because if there were a stat data -
-                       we would have done with the whole directory */
-		    pathrelse (&tmp);
-		    continue;
-		}
-		lost_found_pass_stat (fs)->dir_recovered ++;
-		create_dir_sd (fs, &tmp, &sd, modify_item);
-                id_map_mark(proper_id_map (fs), get_key_objectid (&sd));
-		key = sd;
-		pathrelse (&path);
-		goto cont;
-	    }
-
-
-	    /* stat data marked "not having name" found */
-	    if (is_stat_data_ih (get_ih(&path)))
-		fix_obviously_wrong_sd_mode (&path);
-		
-    	    is_it_dir = ((not_a_directory (B_I_PITEM (bh,ih))) ? 0 : 1);
-
-	    if (is_it_dir) {
-		struct reiserfs_key tmp_key;
-		INITIALIZE_REISERFS_PATH(tmp_path);
-		struct item_head * tmp_ih;
-
-		/* there is no need to link empty lost directories into /lost+found */
-		tmp_key = ih->ih_key;
-		set_type_and_offset (KEY_FORMAT_1, &tmp_key, 0xffffffff, TYPE_DIRENTRY);
-		reiserfs_search_by_key_4 (fs, &tmp_key, &tmp_path);
-		tmp_ih = get_ih (&tmp_path);
-		tmp_ih --;
-		if (not_of_one_file (&tmp_key, tmp_ih))
-		    reiserfs_panic ("not directory found");
-		if (!is_direntry_ih (tmp_ih) ||
-		    (get_deh_offset (B_I_DEH (get_bh (&tmp_path), tmp_ih) + 
-				     get_ih_entry_count (tmp_ih) - 1) == DOT_DOT_OFFSET)) {
-		    /* last directory item is either stat data or empty
-                       directory item - do not link this dir into lost+found */
-		    lost_found_pass_stat (fs)->empty_lost_dirs ++;
-		    pathrelse (&tmp_path);
-		    continue;
-		}
-		pathrelse (&tmp_path);
-	    }
-
-	    if (link_lost_dirs && !is_it_dir) {
-		/* we are looking for directories and it is not a dir */
-		lost_files ++;
-		continue;
-	    }
-
-	    lost_found_pass_stat (fs)->lost_found ++;
-
-	    {
-		struct reiserfs_key obj_key = {0, 0, {{0, 0},}};
-		char * lost_name;
-		struct item_head tmp_ih;
-
-		/* key to continue */
-		key = ih->ih_key;
-		set_key_objectid (&key, get_key_objectid (&key) + 1);
-
-		tmp_ih = *ih;
-		if (id_map_test(semantic_id_map (fs), get_key_objectid (&ih->ih_key))) {
-		    /* objectid is used, relocate an object */
-		    lost_found_pass_stat (fs)->oid_sharing ++;
-		    
-		    if (is_it_dir) {
-			relocate_dir (&tmp_ih, 1);
-			lost_found_pass_stat (fs)->oid_sharing_dirs_relocated ++;
-		    } else {
-			rewrite_file (&tmp_ih, 1, 1);
-			lost_found_pass_stat (fs)->oid_sharing_files_relocated ++;
-		    }		    
-		    
-		    linked_already(&tmp_ih.ih_key);
-		} else {
-		    if (!is_it_dir)
-			id_map_mark(semantic_id_map (fs), get_key_objectid (&ih->ih_key));
+	fsck_progress("Looking for lost %s:\n",
+		      link_lost_dirs ? "directories" : "files");
+	leaves = 0;
+
+	/* total size of added entries */
+	size = 0;
+	while (1) {
+		retval = reiserfs_search_by_key_4(fs, &key, &path);
+		/* fixme: we assume path ends up with a leaf */
+		bh = get_bh(&path);
+		item_pos = get_item_pos(&path);
+		if (retval != ITEM_FOUND) {
+			if (item_pos == get_blkh_nr_items(B_BLK_HEAD(bh))) {
+				rdkey = uget_rkey(&path);
+				if (!rdkey) {
+					pathrelse(&path);
+					break;
+				}
+				key = *rdkey;
+				pathrelse(&path);
+				continue;
+			}
+			/* we are on the item in the buffer */
 		}
 
-		asprintf (&lost_name, "%u_%u", get_key_dirid (&tmp_ih.ih_key),
-			  get_key_objectid (&tmp_ih.ih_key));
-
-		/* entry in lost+found directory will point to this key */
-		set_key_dirid (&obj_key, get_key_dirid (&tmp_ih.ih_key));
-		set_key_objectid (&obj_key, get_key_objectid (&tmp_ih.ih_key));
-
-		pathrelse (&path);
-		
-		/* 0 does not mean anyting - item with "." and ".." already
-		   exists and reached, so only name will be added */
-		size += reiserfs_add_entry (fs, &lost_found_dir_key, lost_name,
-			name_length (lost_name, lost_found_dir_format), &obj_key, 0/*fsck_need*/);
-
-		
-		if (is_it_dir) {
-		    /* fixme: we hope that if we will try to pull all the
-		       directory right now - then there will be less
-		       lost_found things */
-		    print_name (lost_name, strlen (lost_name));
-		    /*fsck_progress ("\tChecking lost dir \"%s\":", lost_name);*/
-		    rebuild_semantic_pass (&obj_key, &lost_found_dir_key, /*dot_dot*/0, /*reloc_ih*/0);
-		    erase_name (strlen (lost_name));
-		    /*fsck_progress ("finished\n");*/
-		    
-		    lost_found_pass_stat (fs)->lost_found_dirs ++;
-		} else {
-		    if (reiserfs_search_by_key_4 (fs, &obj_key, &path) != ITEM_FOUND)
-			reiserfs_panic ("look_for_lost: lost file stat data %K not found",
-					&obj_key);
-
-		    /* check_regular_file does not mark stat data reachable */
-		    mark_item_reachable (get_ih (&path), get_bh (&path));
-
-		    rebuild_check_regular_file (&path, get_item (&path), 0/*reloc_ih*/);
-		    pathrelse (&path);
-
-		    lost_found_pass_stat (fs)->lost_found_files ++;
-		    lost_files --;
+		/* print ~ how many leaves were scanned and how fast it was */
+		if (!fsck_quiet(fs))
+			print_how_fast(leaves++, 0, 50, 0);
+
+		for (ih = get_ih(&path);
+		     item_pos < get_blkh_nr_items(B_BLK_HEAD(bh));
+		     item_pos++, ih++, PATH_LAST_POSITION(&path)++) {
+			if (is_item_reachable(ih))
+				continue;
+
+			/* found item which can not be reached */
+			if (!is_direntry_ih(ih) && !is_stat_data_ih(ih)) {
+				continue;
+			}
+
+			if (is_direntry_ih(ih)) {
+				/* if this directory has no stat data - try to recover it */
+				struct reiserfs_key sd;
+				struct reiserfs_path tmp;
+
+				sd = ih->ih_key;
+				set_type_and_offset(KEY_FORMAT_1, &sd,
+						    SD_OFFSET, TYPE_STAT_DATA);
+				if (reiserfs_search_by_key_4(fs, &sd, &tmp) ==
+				    ITEM_FOUND) {
+					/* should not happen - because if there were a stat data -
+					   we would have done with the whole directory */
+					pathrelse(&tmp);
+					continue;
+				}
+				lost_found_pass_stat(fs)->dir_recovered++;
+				create_dir_sd(fs, &tmp, &sd, modify_item);
+				id_map_mark(proper_id_map(fs),
+					    get_key_objectid(&sd));
+				key = sd;
+				pathrelse(&path);
+				goto cont;
+			}
+
+			/* stat data marked "not having name" found */
+			if (is_stat_data_ih(get_ih(&path)))
+				fix_obviously_wrong_sd_mode(&path);
+
+			is_it_dir =
+			    ((not_a_directory(B_I_PITEM(bh, ih))) ? 0 : 1);
+
+			if (is_it_dir) {
+				struct reiserfs_key tmp_key;
+				INITIALIZE_REISERFS_PATH(tmp_path);
+				struct item_head *tmp_ih;
+
+				/* there is no need to link empty lost directories into /lost+found */
+				tmp_key = ih->ih_key;
+				set_type_and_offset(KEY_FORMAT_1, &tmp_key,
+						    0xffffffff, TYPE_DIRENTRY);
+				reiserfs_search_by_key_4(fs, &tmp_key,
+							 &tmp_path);
+				tmp_ih = get_ih(&tmp_path);
+				tmp_ih--;
+				if (not_of_one_file(&tmp_key, tmp_ih))
+					reiserfs_panic("not directory found");
+				if (!is_direntry_ih(tmp_ih) ||
+				    (get_deh_offset
+				     (B_I_DEH(get_bh(&tmp_path), tmp_ih) +
+				      get_ih_entry_count(tmp_ih) - 1) ==
+				     DOT_DOT_OFFSET)) {
+					/* last directory item is either stat data or empty
+					   directory item - do not link this dir into lost+found */
+					lost_found_pass_stat(fs)->
+					    empty_lost_dirs++;
+					pathrelse(&tmp_path);
+					continue;
+				}
+				pathrelse(&tmp_path);
+			}
+
+			if (link_lost_dirs && !is_it_dir) {
+				/* we are looking for directories and it is not a dir */
+				lost_files++;
+				continue;
+			}
+
+			lost_found_pass_stat(fs)->lost_found++;
+
+			{
+				struct reiserfs_key obj_key =
+				    { 0, 0, {{0, 0},} };
+				char *lost_name;
+				struct item_head tmp_ih;
+
+				/* key to continue */
+				key = ih->ih_key;
+				set_key_objectid(&key,
+						 get_key_objectid(&key) + 1);
+
+				tmp_ih = *ih;
+				if (id_map_test
+				    (semantic_id_map(fs),
+				     get_key_objectid(&ih->ih_key))) {
+					/* objectid is used, relocate an object */
+					lost_found_pass_stat(fs)->oid_sharing++;
+
+					if (is_it_dir) {
+						relocate_dir(&tmp_ih, 1);
+						lost_found_pass_stat(fs)->
+						    oid_sharing_dirs_relocated++;
+					} else {
+						rewrite_file(&tmp_ih, 1, 1);
+						lost_found_pass_stat(fs)->
+						    oid_sharing_files_relocated++;
+					}
+
+					linked_already(&tmp_ih.ih_key);
+				} else {
+					if (!is_it_dir)
+						id_map_mark(semantic_id_map(fs),
+							    get_key_objectid
+							    (&ih->ih_key));
+				}
+
+				asprintf(&lost_name, "%u_%u",
+					 get_key_dirid(&tmp_ih.ih_key),
+					 get_key_objectid(&tmp_ih.ih_key));
+
+				/* entry in lost+found directory will point to this key */
+				set_key_dirid(&obj_key,
+					      get_key_dirid(&tmp_ih.ih_key));
+				set_key_objectid(&obj_key,
+						 get_key_objectid(&tmp_ih.
+								  ih_key));
+
+				pathrelse(&path);
+
+				/* 0 does not mean anyting - item with "." and ".." already
+				   exists and reached, so only name will be added */
+				size +=
+				    reiserfs_add_entry(fs, &lost_found_dir_key,
+						       lost_name,
+						       name_length(lost_name,
+								   lost_found_dir_format),
+						       &obj_key,
+						       0 /*fsck_need */ );
+
+				if (is_it_dir) {
+					/* fixme: we hope that if we will try to pull all the
+					   directory right now - then there will be less
+					   lost_found things */
+					print_name(lost_name,
+						   strlen(lost_name));
+					/*fsck_progress ("\tChecking lost dir \"%s\":", lost_name); */
+					rebuild_semantic_pass(&obj_key,
+							      &lost_found_dir_key,
+							      /*dot_dot */ 0,
+							      /*reloc_ih */ 0);
+					erase_name(strlen(lost_name));
+					/*fsck_progress ("finished\n"); */
+
+					lost_found_pass_stat(fs)->
+					    lost_found_dirs++;
+				} else {
+					if (reiserfs_search_by_key_4
+					    (fs, &obj_key, &path) != ITEM_FOUND)
+						reiserfs_panic
+						    ("look_for_lost: lost file stat data %K not found",
+						     &obj_key);
+
+					/* check_regular_file does not mark stat data reachable */
+					mark_item_reachable(get_ih(&path),
+							    get_bh(&path));
+
+					rebuild_check_regular_file(&path,
+								   get_item
+								   (&path),
+								   0
+								   /*reloc_ih */
+								   );
+					pathrelse(&path);
+
+					lost_found_pass_stat(fs)->
+					    lost_found_files++;
+					lost_files--;
+				}
+
+				free(lost_name);
+				goto cont;
+			}
+		}		/* for */
+
+		prev_key = key;
+
+		PATH_LAST_POSITION(&path) = item_pos - 1;
+		rdkey = reiserfs_next_key(&path);
+		if (rdkey)
+			key = *rdkey;
+		else
+			break;
+
+		if (comp_keys(&prev_key, &key) != -1)
+			reiserfs_panic
+			    ("pass_3a: key must grow 2: prev=%k next=%k",
+			     &prev_key, &key);
+		pathrelse(&path);
+
+cont:
+		if (!link_lost_dirs && !lost_files) {
+			break;
 		}
-
-		free (lost_name);
-		goto cont;
-	    }
-	} /* for */
-
-	prev_key = key;
-	
-	PATH_LAST_POSITION(&path) = item_pos - 1;
-	rdkey = reiserfs_next_key (&path);
-	if (rdkey)
-	    key = *rdkey;
-	else
-	    break;
-	    	
-	if (comp_keys (&prev_key, &key) != -1)
-	    reiserfs_panic ("pass_3a: key must grow 2: prev=%k next=%k",
-			    &prev_key, &key);
-	pathrelse (&path);
-
-    cont:
-	if (!link_lost_dirs && !lost_files) {
-	    break;
 	}
-    }
 
-    pathrelse (&path);
+	pathrelse(&path);
 
 #if 0
-    /* check names added we just have added to/lost+found. Those names are
-       marked DEH_Lost_found flag */
-    fsck_progress ("Checking lost+found directory.."); fflush (stdout);
-    check_semantic_tree (&lost_found_dir_key, &root_dir_key, 0, 1/* lost+found*/);
-    fsck_progress ("finished\n");
+	/* check names added we just have added to/lost+found. Those names are
+	   marked DEH_Lost_found flag */
+	fsck_progress("Checking lost+found directory..");
+	fflush(stdout);
+	check_semantic_tree(&lost_found_dir_key, &root_dir_key, 0,
+			    1 /* lost+found */ );
+	fsck_progress("finished\n");
 #endif
 
-    return size;
+	return size;
 
 }
 
-static void save_lost_found_result (reiserfs_filsys_t * fs)
+static void save_lost_found_result(reiserfs_filsys_t *fs)
 {
-    FILE * file;
-    int retval;
-
-    /* save bitmaps with which we will be able start reiserfs from
-       pass 1 */
-    file = open_file ("temp_fsck_file.deleteme", "w+");
-    if (!file)
-	return;
-
-    reiserfs_begin_stage_info_save (file, LOST_FOUND_DONE);
-    reiserfs_end_stage_info_save (file);
-    close_file (file);
-
-    retval = rename ("temp_fsck_file.deleteme", state_dump_file (fs));
-    if (retval != 0)
-	fsck_progress ("pass 0: Could not rename the temporary file temp_fsck_file.deleteme to %s",
-		       state_dump_file (fs));
+	FILE *file;
+	int retval;
+
+	/* save bitmaps with which we will be able start reiserfs from
+	   pass 1 */
+	file = open_file("temp_fsck_file.deleteme", "w+");
+	if (!file)
+		return;
+
+	reiserfs_begin_stage_info_save(file, LOST_FOUND_DONE);
+	reiserfs_end_stage_info_save(file);
+	close_file(file);
+
+	retval = rename("temp_fsck_file.deleteme", state_dump_file(fs));
+	if (retval != 0)
+		fsck_progress
+		    ("pass 0: Could not rename the temporary file temp_fsck_file.deleteme to %s",
+		     state_dump_file(fs));
 }
 
 /* we have nothing to load from a state file, but we have to fetch
    on-disk bitmap, copy it to allocable bitmap, and fetch objectid
    map */
-void load_lost_found_result (reiserfs_filsys_t * fs)
-{
-    fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_new_bitmap (fs), fs->fs_bitmap2);
-
-    fsck_allocable_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_allocable_bitmap (fs), fs->fs_bitmap2);
-
-    fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
-    fs->block_deallocator = reiserfsck_reiserfs_free_block;
-
-    /* we need objectid map on semantic pass to be able to relocate files */
-    proper_id_map (fs) = id_map_init();
-    /* Not implemented yet.
-    fetch_objectid_map (proper_id_map (fs), fs);
-    */
-}
-
-void after_lost_found (reiserfs_filsys_t * fs)
+void load_lost_found_result(reiserfs_filsys_t *fs)
 {
-    /* update super block: objectid map, fsck state */
-    set_sb_fs_state (fs->fs_ondisk_sb, LOST_FOUND_DONE);
-    mark_buffer_dirty (fs->fs_super_bh);
-
-    /* write all dirty blocks */
-    fsck_progress ("Flushing..");
-    id_map_flush(proper_id_map (fs), fs);
-    fs->fs_dirt = 1;
-    reiserfs_flush_to_ondisk_bitmap (fsck_new_bitmap(fs), fs);
-    reiserfs_flush (fs);
-    fsck_progress ("finished\n");
-
-    stage_report (0x3a, fs);
-
-    if (!fsck_run_one_step (fs)) {
-	if (fsck_user_confirmed (fs, "Continue? (Yes):", "Yes\n", 1))
-	    /* reiserfsck continues */
-	    return;
-    }
-
-    save_lost_found_result (fs);
-
-    id_map_free(proper_id_map (fs));
-    proper_id_map (fs) = 0;
-
-    fs->fs_dirt = 1;
-    reiserfs_close (fs);
-    exit(EXIT_OK);
+	fsck_new_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_new_bitmap(fs), fs->fs_bitmap2);
+
+	fsck_allocable_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_allocable_bitmap(fs), fs->fs_bitmap2);
+
+	fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
+	fs->block_deallocator = reiserfsck_reiserfs_free_block;
+
+	/* we need objectid map on semantic pass to be able to relocate files */
+	proper_id_map(fs) = id_map_init();
+	/* Not implemented yet.
+	   fetch_objectid_map (proper_id_map (fs), fs);
+	 */
 }
 
-void pass_3a_look_for_lost (reiserfs_filsys_t * fs)
+void after_lost_found(reiserfs_filsys_t *fs)
 {
-    INITIALIZE_REISERFS_PATH(path);
-    struct item_head * ih;
-    void * sd;
-    __u64 size, sd_size;
-    __u32 blocks;
-    __u16 mode;
-    __u32 objectid;
-    unsigned int gen_counter;
-    fsck_progress ("Pass 3a (looking for lost dir/files):\n");
-
-    /* when warnings go not to stderr - separate them in the log */
-    if (fsck_log_file (fs) != stderr)
-	fsck_log ("####### Pass 3a (lost+found pass) #########\n");
-
-
-    /* look for lost dirs first */
-    size = _look_for_lost (fs, 1);
+	/* update super block: objectid map, fsck state */
+	set_sb_fs_state(fs->fs_ondisk_sb, LOST_FOUND_DONE);
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	/* write all dirty blocks */
+	fsck_progress("Flushing..");
+	id_map_flush(proper_id_map(fs), fs);
+	fs->fs_dirt = 1;
+	reiserfs_flush_to_ondisk_bitmap(fsck_new_bitmap(fs), fs);
+	reiserfs_flush(fs);
+	fsck_progress("finished\n");
+
+	stage_report(0x3a, fs);
+
+	if (!fsck_run_one_step(fs)) {
+		if (fsck_user_confirmed(fs, "Continue? (Yes):", "Yes\n", 1))
+			/* reiserfsck continues */
+			return;
+	}
 
-    /* link files which are still lost */
-    size += _look_for_lost (fs, 0);
+	save_lost_found_result(fs);
 
-    /* update /lost+found sd_size and sd_blocks (nlink is correct already) */
+	id_map_free(proper_id_map(fs));
+	proper_id_map(fs) = 0;
 
-    objectid = reiserfs_find_entry (fs, &root_dir_key, "lost+found",
-                                       &gen_counter, &lost_found_dir_key);
+	fs->fs_dirt = 1;
+	reiserfs_close(fs);
+	exit(EXIT_OK);
+}
 
-    if (!objectid) {
-       reiserfs_panic ("look_for_lost: The entry 'lost+found' could not be found in the root directory.");
-    }
+void pass_3a_look_for_lost(reiserfs_filsys_t *fs)
+{
+	INITIALIZE_REISERFS_PATH(path);
+	struct item_head *ih;
+	void *sd;
+	__u64 size, sd_size;
+	__u32 blocks;
+	__u16 mode;
+	__u32 objectid;
+	unsigned int gen_counter;
+	fsck_progress("Pass 3a (looking for lost dir/files):\n");
+
+	/* when warnings go not to stderr - separate them in the log */
+	if (fsck_log_file(fs) != stderr)
+		fsck_log("####### Pass 3a (lost+found pass) #########\n");
+
+	/* look for lost dirs first */
+	size = _look_for_lost(fs, 1);
+
+	/* link files which are still lost */
+	size += _look_for_lost(fs, 0);
+
+	/* update /lost+found sd_size and sd_blocks (nlink is correct already) */
+
+	objectid = reiserfs_find_entry(fs, &root_dir_key, "lost+found",
+				       &gen_counter, &lost_found_dir_key);
+
+	if (!objectid) {
+		reiserfs_panic
+		    ("look_for_lost: The entry 'lost+found' could not be found in the root directory.");
+	}
 
-    if (reiserfs_search_by_key_4 (fs, &lost_found_dir_key, &path) != ITEM_FOUND)
-	reiserfs_panic ("look_for_lost: The StatData of the 'lost+found' directory %K could not be found",
-			&lost_found_dir_key);
-    ih = get_ih (&path);
-    sd = get_item (&path);
-    get_sd_size (ih, sd, &sd_size);
-    size += sd_size;
-    blocks = dir_size2st_blocks (size);
+	if (reiserfs_search_by_key_4(fs, &lost_found_dir_key, &path) !=
+	    ITEM_FOUND)
+		reiserfs_panic
+		    ("look_for_lost: The StatData of the 'lost+found' directory %K could not be found",
+		     &lost_found_dir_key);
+	ih = get_ih(&path);
+	sd = get_item(&path);
+	get_sd_size(ih, sd, &sd_size);
+	size += sd_size;
+	blocks = dir_size2st_blocks(size);
 
-    set_sd_size (ih, sd, &size);
-    set_sd_blocks (ih, sd, &blocks);
+	set_sd_size(ih, sd, &size);
+	set_sd_blocks(ih, sd, &blocks);
 
-    /* make lost+found to be drwx------ */
-    mode = S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR;
-    set_sd_mode (ih, sd, &mode);
+	/* make lost+found to be drwx------ */
+	mode = S_IFDIR | S_IRUSR | S_IWUSR | S_IXUSR;
+	set_sd_mode(ih, sd, &mode);
 
-    mark_buffer_dirty (get_bh (&path));
-    pathrelse (&path);
+	mark_buffer_dirty(get_bh(&path));
+	pathrelse(&path);
 
-    after_lost_found (fs);
+	after_lost_found(fs);
 }
-
diff --git a/fsck/main.c b/fsck/main.c
index a689d4f..2ef216c 100644
--- a/fsck/main.c
+++ b/fsck/main.c
@@ -14,8 +14,8 @@ extern int screen_width;
 extern int screen_savebuffer_len;
 extern char *screen_savebuffer;
 
-reiserfs_filsys_t * fs;
-char * badblocks_file;
+reiserfs_filsys_t *fs;
+char *badblocks_file;
 
 #define print_usage_and_exit() {						\
 fsck_progress ("Usage: %s [mode] [options] "					\
@@ -78,230 +78,233 @@ Options:
 "  -t \t\tdo test\n"\
 */
 
-
 /* fsck is called with one non-optional argument - file name of device
    containing reiserfs. This function parses other options, sets flags
    based on parsing and returns non-optional argument */
-static char * parse_options (struct fsck_data * data, int argc, char * argv [])
+static char *parse_options(struct fsck_data *data, int argc, char *argv[])
 {
-    int c;
-    static int mode = FSCK_CHECK;
-    static int flag;
-
-    data->rebuild.scan_area = USED_BLOCKS;
-    while (1) {
-	static struct option options[] = {
-	    /* modes */
-	    {"check", no_argument, &mode, FSCK_CHECK},
-	    {"fix-fixable", no_argument, &mode, FSCK_FIX_FIXABLE},
-	    {"rebuild-sb", no_argument, &mode, FSCK_SB},
-	    {"rebuild-tree", no_argument, &mode, FSCK_REBUILD},
-	    {"rollback-fsck-changes", no_argument, &mode, FSCK_ROLLBACK_CHANGES},
-	    {"clean-attributes", no_argument, &mode, FSCK_CLEAN_ATTRIBUTES},
-	    /* options */
-	    {"logfile", required_argument, 0, 'l'},
-	    {"badblocks", required_argument, 0, 'B'},
-	    {"interactive", no_argument, 0, 'i'},
-	    {"adjust-size", no_argument, 0, 'z'},
-	    {"quiet", no_argument, 0, 'q'},
-	    {"yes", no_argument, 0, 'y'},
-	    {"force", no_argument, 0, 'f'},
-	    {"nolog", no_argument, 0, 'n'},
-	    
-	    /* if file exists ad reiserfs can be load of it - only
-               blocks marked used in that bitmap will be read */
-	    {"scan-marked-in-bitmap", required_argument, 0, 'b'},
-
-	    {"create-passes-dump", required_argument, 0, 'd'},
-	
-	    /* all blocks will be read */
-	    {"scan-whole-partition", no_argument, 0, 'S'},
-	    /* useful for -S */
-	    {"hash", required_argument, 0, 'h'},
-
-            /* preparing rollback data*/
-	    {"rollback-data", required_argument, 0, 'R'},
-	    
-	    {"journal", required_argument, 0, 'j'},
-	    {"no-journal-available", no_argument, &flag, OPT_SKIP_JOURNAL},
-	    
-	    {"bad-block-file", required_argument, 0, 'B'},
-
-	    /* start reiserfsck in background and exit */
-	    {"background", no_argument, 0, 'g'},
-
-	    {0, 0, 0, 0}
-	};
-	int option_index;
-      
-	c = getopt_long (argc, argv, "iql:nb:Szd:R:h:j:gafVrpyt:B:",
-			 options, &option_index);
-	if (c == -1)
-	    break;
-	
-	switch (c) {
-	case 0:
-	    /* long-only options */
-	    if (flag == OPT_SKIP_JOURNAL) {
-		/* no journal available */
-		data->options |= OPT_SKIP_JOURNAL;
-		flag = 0;
-	    }
-	    break; 
-
-	case 'i': /* --interactive */
-	    data->options |= OPT_INTERACTIVE;
-	    break;
-
-	case 'q': /* --quiet */
-	    data->options |= OPT_QUIET;
-	    break;
-
-	case 'y': /* --quiet */
-	    data->options |= OPT_YES;
-	    break;
-
-	case 'l': /* --logfile */
-	    data->log_file_name = optarg;
-	    /*asprintf (&data->log_file_name, "%s", optarg);*/
-	    data->log = fopen (optarg, "w");
-	    if (!data->log)
-		fprintf (stderr, "reiserfsck: Cannot not open \'%s\': %s", 
-		    optarg, strerror(errno));	    
-	    break;
-
-	case 'n': /* --nolog */
-	    data->options |= OPT_SILENT;
-	    break;
-
-	case 'b': /* --scan-marked-in-bitmap */
-	    /* will try to load a bitmap from a file and read only
-               blocks marked in it. That bitmap could be created by
-               previous run of reiserfsck with -c */
-	    data->rebuild.bitmap_file_name = optarg;
-	    /*asprintf (&data->rebuild.bitmap_file_name, "%s", optarg);*/
-	    data->rebuild.scan_area = EXTERN_BITMAP;
-	    break;
-
-	case 'S': /* --scan-whole-partition */
-	    data->rebuild.scan_area = ALL_BLOCKS;
-	    break;
+	int c;
+	static int mode = FSCK_CHECK;
+	static int flag;
+
+	data->rebuild.scan_area = USED_BLOCKS;
+	while (1) {
+		static struct option options[] = {
+			/* modes */
+			{"check", no_argument, &mode, FSCK_CHECK},
+			{"fix-fixable", no_argument, &mode, FSCK_FIX_FIXABLE},
+			{"rebuild-sb", no_argument, &mode, FSCK_SB},
+			{"rebuild-tree", no_argument, &mode, FSCK_REBUILD},
+			{"rollback-fsck-changes", no_argument, &mode,
+			 FSCK_ROLLBACK_CHANGES},
+			{"clean-attributes", no_argument, &mode,
+			 FSCK_CLEAN_ATTRIBUTES},
+			/* options */
+			{"logfile", required_argument, 0, 'l'},
+			{"badblocks", required_argument, 0, 'B'},
+			{"interactive", no_argument, 0, 'i'},
+			{"adjust-size", no_argument, 0, 'z'},
+			{"quiet", no_argument, 0, 'q'},
+			{"yes", no_argument, 0, 'y'},
+			{"force", no_argument, 0, 'f'},
+			{"nolog", no_argument, 0, 'n'},
+
+			/* if file exists ad reiserfs can be load of it - only
+			   blocks marked used in that bitmap will be read */
+			{"scan-marked-in-bitmap", required_argument, 0, 'b'},
+
+			{"create-passes-dump", required_argument, 0, 'd'},
+
+			/* all blocks will be read */
+			{"scan-whole-partition", no_argument, 0, 'S'},
+			/* useful for -S */
+			{"hash", required_argument, 0, 'h'},
+
+			/* preparing rollback data */
+			{"rollback-data", required_argument, 0, 'R'},
+
+			{"journal", required_argument, 0, 'j'},
+			{"no-journal-available", no_argument, &flag,
+			 OPT_SKIP_JOURNAL},
+
+			{"bad-block-file", required_argument, 0, 'B'},
+
+			/* start reiserfsck in background and exit */
+			{"background", no_argument, 0, 'g'},
+
+			{0, 0, 0, 0}
+		};
+		int option_index;
+
+		c = getopt_long(argc, argv, "iql:nb:Szd:R:h:j:gafVrpyt:B:",
+				options, &option_index);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 0:
+			/* long-only options */
+			if (flag == OPT_SKIP_JOURNAL) {
+				/* no journal available */
+				data->options |= OPT_SKIP_JOURNAL;
+				flag = 0;
+			}
+			break;
+
+		case 'i':	/* --interactive */
+			data->options |= OPT_INTERACTIVE;
+			break;
+
+		case 'q':	/* --quiet */
+			data->options |= OPT_QUIET;
+			break;
+
+		case 'y':	/* --quiet */
+			data->options |= OPT_YES;
+			break;
+
+		case 'l':	/* --logfile */
+			data->log_file_name = optarg;
+			/*asprintf (&data->log_file_name, "%s", optarg); */
+			data->log = fopen(optarg, "w");
+			if (!data->log)
+				fprintf(stderr,
+					"reiserfsck: Cannot not open \'%s\': %s",
+					optarg, strerror(errno));
+			break;
+
+		case 'n':	/* --nolog */
+			data->options |= OPT_SILENT;
+			break;
+
+		case 'b':	/* --scan-marked-in-bitmap */
+			/* will try to load a bitmap from a file and read only
+			   blocks marked in it. That bitmap could be created by
+			   previous run of reiserfsck with -c */
+			data->rebuild.bitmap_file_name = optarg;
+			/*asprintf (&data->rebuild.bitmap_file_name, "%s", optarg); */
+			data->rebuild.scan_area = EXTERN_BITMAP;
+			break;
+
+		case 'S':	/* --scan-whole-partition */
+			data->rebuild.scan_area = ALL_BLOCKS;
+			break;
 
 #if 0
-	case 'J': /* take all blocks which are leaves in journal area and put
-                     them into tree item by item (DO NOT USE IT UNTIL YOU KNOW
-                     WHAT ARE YOU DOING) */
-	    data->rebuild.use_journal_area = 1;
-	    break;
+		case 'J':	/* take all blocks which are leaves in journal area and put
+				   them into tree item by item (DO NOT USE IT UNTIL YOU KNOW
+				   WHAT ARE YOU DOING) */
+			data->rebuild.use_journal_area = 1;
+			break;
 #endif
-	case 'd': /* --create-passes-dump */
-	    asprintf (&data->rebuild.passes_dump_file_name, "%s", optarg);
-	    data->options |= OPT_SAVE_PASSES_DUMP;
-	    break;
-	
-	case 'z': /* --adjust-file-size */
-	    data->options |= OPT_ADJUST_FILE_SIZE;
-	    break;
-
-	case 'h': /* --hash: suppose that this hash was used on a filesystem */
-	    asprintf (&data->rebuild.defined_hash, "%s", optarg);
-	    if (name2func (data->rebuild.defined_hash) == 0)
-		reiserfs_panic ("reiserfsck: Unknown hash is specified: %s",
-				data->rebuild.defined_hash);
-	    data->options |= OPT_HASH_DEFINED;
-	    break;
-
-	case 'j': /* specified relocated journal device */
-	    data->journal_dev_name = optarg;
-	    break;
-
-	case 'R': /* preparing rollback data */
-	    asprintf (&data->rebuild.rollback_file, "%s", optarg);
-	    data->options |= OPT_SAVE_ROLLBACK;
-	    break;
-	
-	case 'B': /* list of phisically corrupted blocks */
-	    asprintf (&badblocks_file, "%s", optarg);
-	    data->options |= BADBLOCKS_FILE;
-	    break;
-
-	case 'g': /* --background */
-	    data->options |= OPT_BACKGROUND;
-	    break;
-
-	case 'a':
-	case 'p':
-		data->options |= OPT_QUIET;
-		mode = FSCK_AUTO;
-		break;
-	
-	case 'f':
-		data->options |= OPT_FORCE;
-		break;
-	case 'r': /* ignored */
-	    break;
-	    
-	case 'V': /* cause fsck to do nothing */
-	    mode = DO_NOTHING;
-	    break;
-	
-	case 't':
-	    mode = DO_TEST;
-	    data->rebuild.test = atoi (optarg);
-	    break;
-
-
-	default:
-	    print_usage_and_exit();
+		case 'd':	/* --create-passes-dump */
+			asprintf(&data->rebuild.passes_dump_file_name, "%s",
+				 optarg);
+			data->options |= OPT_SAVE_PASSES_DUMP;
+			break;
+
+		case 'z':	/* --adjust-file-size */
+			data->options |= OPT_ADJUST_FILE_SIZE;
+			break;
+
+		case 'h':	/* --hash: suppose that this hash was used on a filesystem */
+			asprintf(&data->rebuild.defined_hash, "%s", optarg);
+			if (name2func(data->rebuild.defined_hash) == 0)
+				reiserfs_panic
+				    ("reiserfsck: Unknown hash is specified: %s",
+				     data->rebuild.defined_hash);
+			data->options |= OPT_HASH_DEFINED;
+			break;
+
+		case 'j':	/* specified relocated journal device */
+			data->journal_dev_name = optarg;
+			break;
+
+		case 'R':	/* preparing rollback data */
+			asprintf(&data->rebuild.rollback_file, "%s", optarg);
+			data->options |= OPT_SAVE_ROLLBACK;
+			break;
+
+		case 'B':	/* list of phisically corrupted blocks */
+			asprintf(&badblocks_file, "%s", optarg);
+			data->options |= BADBLOCKS_FILE;
+			break;
+
+		case 'g':	/* --background */
+			data->options |= OPT_BACKGROUND;
+			break;
+
+		case 'a':
+		case 'p':
+			data->options |= OPT_QUIET;
+			mode = FSCK_AUTO;
+			break;
+
+		case 'f':
+			data->options |= OPT_FORCE;
+			break;
+		case 'r':	/* ignored */
+			break;
+
+		case 'V':	/* cause fsck to do nothing */
+			mode = DO_NOTHING;
+			break;
+
+		case 't':
+			mode = DO_TEST;
+			data->rebuild.test = atoi(optarg);
+			break;
+
+		default:
+			print_usage_and_exit();
+		}
 	}
-    }
 
-    if (optind != argc - 1 && mode != DO_NOTHING)
-	/* only one non-option argument is permitted */
-	print_usage_and_exit();
+	if (optind != argc - 1 && mode != DO_NOTHING)
+		/* only one non-option argument is permitted */
+		print_usage_and_exit();
 
-    if (mode != FSCK_REBUILD && 
-               (data->rebuild.scan_area == EXTERN_BITMAP ||
-                data->rebuild.scan_area == ALL_BLOCKS || 
-                data->options & OPT_SAVE_PASSES_DUMP))
-	/* wrong options for this mode */
-	print_usage_and_exit();
+	if (mode != FSCK_REBUILD &&
+	    (data->rebuild.scan_area == EXTERN_BITMAP ||
+	     data->rebuild.scan_area == ALL_BLOCKS ||
+	     data->options & OPT_SAVE_PASSES_DUMP))
+		/* wrong options for this mode */
+		print_usage_and_exit();
 
 /*
     if (data->options & OPT_ADJUST_FILE_SIZE) {
         if ((mode != FSCK_REBUILD) && (mode != FSCK_FIX_FIXABLE)) 
             print_usage_and_exit();
     }
-*/    
-    
-    if (data->options & OPT_SAVE_ROLLBACK) {
-        if (mode == FSCK_SB)
-            print_usage_and_exit();        
-    }
+*/
 
-    if (mode == FSCK_ROLLBACK_CHANGES) {
-        if ((data->options & OPT_SAVE_ROLLBACK) == 0)
-            print_usage_and_exit();        
-    }
+	if (data->options & OPT_SAVE_ROLLBACK) {
+		if (mode == FSCK_SB)
+			print_usage_and_exit();
+	}
 
-    if ((data->options & BADBLOCKS_FILE) && mode != FSCK_REBUILD && 
-	mode != FSCK_FIX_FIXABLE)
-    {
-	fprintf(stderr, "Badblocks can be specified with --fix-fixable or "
-		"--rebuild-tree only.\n");
-	print_usage_and_exit();
-    }
+	if (mode == FSCK_ROLLBACK_CHANGES) {
+		if ((data->options & OPT_SAVE_ROLLBACK) == 0)
+			print_usage_and_exit();
+	}
 
-    if ((mode == FSCK_REBUILD) && (data->options & OPT_YES))
-	data->options &= ~OPT_YES;
-    
-    data->mode = mode;
-    if (!data->log)
-	data->log = stdout;   
+	if ((data->options & BADBLOCKS_FILE) && mode != FSCK_REBUILD &&
+	    mode != FSCK_FIX_FIXABLE) {
+		fprintf(stderr,
+			"Badblocks can be specified with --fix-fixable or "
+			"--rebuild-tree only.\n");
+		print_usage_and_exit();
+	}
 
-    return argv[optind];
-}
+	if ((mode == FSCK_REBUILD) && (data->options & OPT_YES))
+		data->options &= ~OPT_YES;
+
+	data->mode = mode;
+	if (!data->log)
+		data->log = stdout;
 
+	return argv[optind];
+}
 
 #define REBUILD_WARNING \
 "*************************************************************\n\
@@ -314,175 +317,210 @@ static char * parse_options (struct fsck_data * data, int argc, char * argv [])
 ** that -- and only then run this program.                 **\n\
 *************************************************************\n\
 \nWill rebuild the filesystem (%s) tree\n"
-
-void warn_what_will_be_done (char * file_name, struct fsck_data * data)
+void warn_what_will_be_done(char *file_name, struct fsck_data *data)
 {
-    FILE * warn_to;
-
-    warn_to = (data->progress ? data->progress : stderr);
-
-    if (data->mode == FSCK_REBUILD)
-	reiserfs_warning (warn_to, REBUILD_WARNING, file_name);
-    
-    /* warn about fsck mode */
-    switch (data->mode) {
-    case FSCK_CHECK:
-	reiserfs_warning (warn_to, "Will read-only check consistency of the "
-	    "filesystem on %s\n", file_name);
-	
-	break;
-
-    case FSCK_FIX_FIXABLE:
-        
-	reiserfs_warning (warn_to, "Will check consistency of the filesystem "
-	    "on %s\n", file_name);
-        reiserfs_warning (warn_to, "and will fix what can be fixed without "
-	    "--rebuild-tree\n");
-	
-	break;
-
-    case FSCK_SB:
-	reiserfs_warning (warn_to, "Will check superblock and rebuild it if "
-	    "needed\n");
-	
-	break;
-
-    case FSCK_REBUILD:
-	if (data->options & OPT_SAVE_PASSES_DUMP) {
-	    reiserfs_warning (warn_to, "Will run only 1 step of the rebuilding, "
-		"write state file '%s' and exit\n", 
-		data->rebuild.passes_dump_file_name);
-	} else if (data->options & OPT_INTERACTIVE)
-	    reiserfs_warning (warn_to, "Will stop after every stage and ask for "
-                "confirmation before continuing\n");
-
-	if (data->rebuild.bitmap_file_name)
-	    reiserfs_warning (warn_to, "Will try to load a bitmap--of all "
-		"ReiserFS leaves in the partition--from the file \n'%s'\n",
-		data->rebuild.bitmap_file_name);
-
-	if (data->options & OPT_ADJUST_FILE_SIZE)
-	    reiserfs_warning (warn_to, "\tWill set file sizes in their metadata "
-		"to real file sizes actually found by fsck.\n");
-
-	if (data->options & OPT_HASH_DEFINED)
-	    reiserfs_warning (warn_to, "\tSuppose \"%s\" hash is in use\n",
-		data->rebuild.defined_hash);
-	
-	break;
-	
-    case FSCK_ROLLBACK_CHANGES:
-	reiserfs_warning (warn_to, "Will rollback all data saved in %s into %s\n",
-	    data->rebuild.rollback_file, file_name);
-	
-        break;
-    case FSCK_CLEAN_ATTRIBUTES:
-	reiserfs_warning (warn_to, "Will clean file attributes on %s\n", 
-	    file_name);
-        break;
-    case FSCK_AUTO:
-	return;
-    }
+	FILE *warn_to;
+
+	warn_to = (data->progress ? data->progress : stderr);
+
+	if (data->mode == FSCK_REBUILD)
+		reiserfs_warning(warn_to, REBUILD_WARNING, file_name);
+
+	/* warn about fsck mode */
+	switch (data->mode) {
+	case FSCK_CHECK:
+		reiserfs_warning(warn_to,
+				 "Will read-only check consistency of the "
+				 "filesystem on %s\n", file_name);
+
+		break;
 
-    if (data->options & OPT_SAVE_ROLLBACK && data->mode != FSCK_ROLLBACK_CHANGES)
-        reiserfs_warning (warn_to, "Will save all blocks to be changed into "
-	    "file '%s'\n", data->rebuild.rollback_file);
-
-    if (data->options & BADBLOCKS_FILE)
-        reiserfs_warning (warn_to,
-            "Bad block list will contain only blocks specified in '%s' "
-	    "file\n", badblocks_file);
-
-    reiserfs_warning (warn_to, "Will put log info to '%s'\n", 
-	(data->log == stdout) ? "stdout" : 
-	(data->log_file_name ? data->log_file_name : "fsck.run"));
-    
-    if (!(data->options & OPT_YES) && !(data->options & OPT_SILENT) &&
-	!user_confirmed (warn_to, "\nDo you want to run this program?[N/Yes] "
-	"(note need to type Yes if you do):", "Yes\n"))
-	exit (EXIT_USER);
+	case FSCK_FIX_FIXABLE:
+
+		reiserfs_warning(warn_to,
+				 "Will check consistency of the filesystem "
+				 "on %s\n", file_name);
+		reiserfs_warning(warn_to,
+				 "and will fix what can be fixed without "
+				 "--rebuild-tree\n");
+
+		break;
+
+	case FSCK_SB:
+		reiserfs_warning(warn_to,
+				 "Will check superblock and rebuild it if "
+				 "needed\n");
+
+		break;
+
+	case FSCK_REBUILD:
+		if (data->options & OPT_SAVE_PASSES_DUMP) {
+			reiserfs_warning(warn_to,
+					 "Will run only 1 step of the rebuilding, "
+					 "write state file '%s' and exit\n",
+					 data->rebuild.passes_dump_file_name);
+		} else if (data->options & OPT_INTERACTIVE)
+			reiserfs_warning(warn_to,
+					 "Will stop after every stage and ask for "
+					 "confirmation before continuing\n");
+
+		if (data->rebuild.bitmap_file_name)
+			reiserfs_warning(warn_to,
+					 "Will try to load a bitmap--of all "
+					 "ReiserFS leaves in the partition--from the file \n'%s'\n",
+					 data->rebuild.bitmap_file_name);
+
+		if (data->options & OPT_ADJUST_FILE_SIZE)
+			reiserfs_warning(warn_to,
+					 "\tWill set file sizes in their metadata "
+					 "to real file sizes actually found by fsck.\n");
+
+		if (data->options & OPT_HASH_DEFINED)
+			reiserfs_warning(warn_to,
+					 "\tSuppose \"%s\" hash is in use\n",
+					 data->rebuild.defined_hash);
+
+		break;
+
+	case FSCK_ROLLBACK_CHANGES:
+		reiserfs_warning(warn_to,
+				 "Will rollback all data saved in %s into %s\n",
+				 data->rebuild.rollback_file, file_name);
+
+		break;
+	case FSCK_CLEAN_ATTRIBUTES:
+		reiserfs_warning(warn_to, "Will clean file attributes on %s\n",
+				 file_name);
+		break;
+	case FSCK_AUTO:
+		return;
+	}
+
+	if (data->options & OPT_SAVE_ROLLBACK
+	    && data->mode != FSCK_ROLLBACK_CHANGES)
+		reiserfs_warning(warn_to,
+				 "Will save all blocks to be changed into "
+				 "file '%s'\n", data->rebuild.rollback_file);
+
+	if (data->options & BADBLOCKS_FILE)
+		reiserfs_warning(warn_to,
+				 "Bad block list will contain only blocks specified in '%s' "
+				 "file\n", badblocks_file);
+
+	reiserfs_warning(warn_to, "Will put log info to '%s'\n",
+			 (data->log == stdout) ? "stdout" :
+			 (data->log_file_name ? data->
+			  log_file_name : "fsck.run"));
+
+	if (!(data->options & OPT_YES) && !(data->options & OPT_SILENT) &&
+	    !user_confirmed(warn_to,
+			    "\nDo you want to run this program?[N/Yes] "
+			    "(note need to type Yes if you do):", "Yes\n"))
+		exit(EXIT_USER);
 }
 
 static dma_info_t dma_info;
 static dma_info_t old_dma_info;
 
-void check_dma() {
-    old_dma_info = dma_info;
-    if (get_dma_info(&dma_info) == -1) {
-	fsck_log("get_dma_info failed %s\n", strerror (errno));
-	return;
-    }
-    
-    if (dma_info.dma != old_dma_info.dma) {
-	if (dma_info.dma == 0) {
-	    printf("\n********************************************************************\n");
-	    printf("* Warning: It was just detected that dma mode was turned off while *\n");
-	    printf("* operating -- probably  due  to some  problem with your hardware. *\n");
-	    printf("* Please check your hardware and have a look into the syslog file. *\n");
-	    printf("* Note: running with --rebuild-tree on faulty hardware may destroy *\n");
-	    printf("* your data.                                                       *\n");
-	    printf("********************************************************************\n");
-	    if (fsck_log_file (fs) != stdout)
-		fsck_log("WARNING: dma mode has been turned off.\n");
+void check_dma()
+{
+	old_dma_info = dma_info;
+	if (get_dma_info(&dma_info) == -1) {
+		fsck_log("get_dma_info failed %s\n", strerror(errno));
+		return;
 	}
-    }
-    if (dma_info.speed != old_dma_info.speed) {
-	if (dma_info.speed < old_dma_info.speed) {
-	    printf("\n********************************************************************\n");
-	    printf("* Warning: It was just detected that dma speed was descreased while*\n");
-	    printf("* operating -- probably  due  to some  problem with your hardware. *\n");
-	    printf("* Please check your hardware and have a look into the syslog file. *\n");
-	    printf("* Note: running with --rebuild-tree on faulty hardware may destroy *\n");
-	    printf("* your data.                                                       *\n");
-	    printf("********************************************************************\n");
-	    if (fsck_log_file (fs) != stdout)
-		fsck_log("WARNING: dma speed has been descreased.\n");	    
+
+	if (dma_info.dma != old_dma_info.dma) {
+		if (dma_info.dma == 0) {
+			printf
+			    ("\n********************************************************************\n");
+			printf
+			    ("* Warning: It was just detected that dma mode was turned off while *\n");
+			printf
+			    ("* operating -- probably  due  to some  problem with your hardware. *\n");
+			printf
+			    ("* Please check your hardware and have a look into the syslog file. *\n");
+			printf
+			    ("* Note: running with --rebuild-tree on faulty hardware may destroy *\n");
+			printf
+			    ("* your data.                                                       *\n");
+			printf
+			    ("********************************************************************\n");
+			if (fsck_log_file(fs) != stdout)
+				fsck_log
+				    ("WARNING: dma mode has been turned off.\n");
+		}
 	}
-    }
-    
-    alarm(1);
+	if (dma_info.speed != old_dma_info.speed) {
+		if (dma_info.speed < old_dma_info.speed) {
+			printf
+			    ("\n********************************************************************\n");
+			printf
+			    ("* Warning: It was just detected that dma speed was descreased while*\n");
+			printf
+			    ("* operating -- probably  due  to some  problem with your hardware. *\n");
+			printf
+			    ("* Please check your hardware and have a look into the syslog file. *\n");
+			printf
+			    ("* Note: running with --rebuild-tree on faulty hardware may destroy *\n");
+			printf
+			    ("* your data.                                                       *\n");
+			printf
+			    ("********************************************************************\n");
+			if (fsck_log_file(fs) != stdout)
+				fsck_log
+				    ("WARNING: dma speed has been descreased.\n");
+		}
+	}
+
+	alarm(1);
 }
 
-void register_timer() {
-    memset(&dma_info, 0, sizeof(dma_info));
-    memset(&old_dma_info, 0, sizeof(old_dma_info));
-    
-    dma_info.fd = fs->fs_dev;
+void register_timer()
+{
+	memset(&dma_info, 0, sizeof(dma_info));
+	memset(&old_dma_info, 0, sizeof(old_dma_info));
 
-    if (prepare_dma_check(&dma_info) != 0)
-	return;
+	dma_info.fd = fs->fs_dev;
 
-    if (get_dma_info(&dma_info) == -1) {
-	fsck_log("get_dma_info failed %s\n", strerror (errno));
-	return;
-    }
+	if (prepare_dma_check(&dma_info) != 0)
+		return;
+
+	if (get_dma_info(&dma_info) == -1) {
+		fsck_log("get_dma_info failed %s\n", strerror(errno));
+		return;
+	}
+
+	if (dma_info.dma == 0) {
+		printf
+		    ("\n******************************************************\n");
+		printf
+		    ("* Warning: The dma on your hard drive is turned off. *\n");
+		printf
+		    ("* This may really slow down the fsck process.        *\n");
+		printf
+		    ("******************************************************\n");
+		if (fsck_log_file(fs) != stdout)
+			fsck_log("WARNING: DMA is turned off\n");
+	}
 
-    if (dma_info.dma == 0) {
-	printf("\n******************************************************\n");
-	printf("* Warning: The dma on your hard drive is turned off. *\n");
-	printf("* This may really slow down the fsck process.        *\n");
-	printf("******************************************************\n");
-	if (fsck_log_file (fs) != stdout)
-	    fsck_log("WARNING: DMA is turned off\n");
-    } 
-    
-    signal(SIGALRM, check_dma);
-    alarm(1);
+	signal(SIGALRM, check_dma);
+	alarm(1);
 }
 
-static void reset_super_block (reiserfs_filsys_t * fs)
+static void reset_super_block(reiserfs_filsys_t *fs)
 {
-    struct reiserfs_super_block * sb;
-    struct reiserfs_journal_header * jh;
-    
-    sb = fs->fs_ondisk_sb;
+	struct reiserfs_super_block *sb;
+	struct reiserfs_journal_header *jh;
+
+	sb = fs->fs_ondisk_sb;
 
-    set_sb_free_blocks (sb, get_sb_block_count (sb));
-    set_sb_root_block (sb, 0);
-    set_sb_tree_height (sb, ~0);
+	set_sb_free_blocks(sb, get_sb_block_count(sb));
+	set_sb_root_block(sb, 0);
+	set_sb_tree_height(sb, ~0);
 
-    /* make file system invalid unless fsck finished () */
-    set_sb_fs_state (sb, get_sb_fs_state (sb) | FS_FATAL);
+	/* make file system invalid unless fsck finished () */
+	set_sb_fs_state(sb, get_sb_fs_state(sb) | FS_FATAL);
 
 /*
     if ( is_reiser2fs_jr_magic_string (sb) ) {???
@@ -495,65 +533,91 @@ static void reset_super_block (reiserfs_filsys_t * fs)
 	set_sb_version (sb, REISERFS_FORMAT_3_5);
     }
 */
-    /* make sure that hash code in super block match to set hash function */
-    set_sb_hash_code (sb, func2code (fs->fs_hash_function));
-    
-    if (fsck_hash_defined (fs)) {
-	/* --hash was specifed */
-	fs->fs_hash_function = name2func (fsck_data (fs)->rebuild.defined_hash);
-	set_sb_hash_code (sb, func2code (fs->fs_hash_function));
-    }
-    
-    if (reiserfs_journal_opened (fs)) {	
-	jh = (struct reiserfs_journal_header *)fs->fs_jh_bh->b_data;
-    
-	/* reset journal params if needed. */
-	if (memcmp(sb_jp(sb), &jh->jh_journal, sizeof (struct journal_params))) {
-	    if (is_reiserfs_jr_magic_string (sb)) 
-		memcpy (sb_jp(sb), &jh->jh_journal, sizeof (struct journal_params));
-	    else {
-		set_sb_reserved_for_journal (sb, 0);
-	    
-		set_jp_journal_dev (sb_jp(sb), 0);
-		set_jp_journal_magic (sb_jp(sb), get_random());
-		set_jp_journal_1st_block (sb_jp(sb), get_journal_start_must (fs));
-		set_jp_journal_size (sb_jp(sb),
-		    journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize));	    
-		set_jp_journal_max_trans_len (sb_jp(sb),
-		    advise_journal_max_trans_len(
-			get_jp_journal_max_trans_len (sb_jp(sb)),
-			get_jp_journal_size (sb_jp(sb)),
-			fs->fs_blocksize, 0));
-		set_jp_journal_max_batch (sb_jp(sb), 
-		    advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
-		set_jp_journal_max_commit_age (sb_jp(sb), advise_journal_max_commit_age());
-		set_jp_journal_max_trans_age (sb_jp(sb), advise_journal_max_trans_age());
-		
-		set_jp_journal_dev (&jh->jh_journal, 0);
-		set_jp_journal_magic (&jh->jh_journal, 
-				      get_jp_journal_magic(sb_jp(sb)));
-		set_jp_journal_1st_block (&jh->jh_journal, 
-		    get_jp_journal_1st_block(sb_jp(sb)));
-		set_jp_journal_size (&jh->jh_journal, get_jp_journal_size(sb_jp(sb)));
-		set_jp_journal_max_trans_len (&jh->jh_journal, 
-		    get_jp_journal_max_trans_len(sb_jp(sb)));
-		set_jp_journal_max_batch (&jh->jh_journal, 
-		    get_jp_journal_max_batch(sb_jp(sb)));
-		set_jp_journal_max_commit_age (&jh->jh_journal, 
-		    get_jp_journal_max_commit_age(sb_jp(sb)));
-		set_jp_journal_max_trans_age (&jh->jh_journal, 
-		    get_jp_journal_max_trans_age(sb_jp(sb))); 
-	    }
+	/* make sure that hash code in super block match to set hash function */
+	set_sb_hash_code(sb, func2code(fs->fs_hash_function));
+
+	if (fsck_hash_defined(fs)) {
+		/* --hash was specifed */
+		fs->fs_hash_function =
+		    name2func(fsck_data(fs)->rebuild.defined_hash);
+		set_sb_hash_code(sb, func2code(fs->fs_hash_function));
 	}
-    }
 
-    /* objectid map is not touched */
-    mark_buffer_dirty (fs->fs_super_bh);
-    bwrite (fs->fs_super_bh);
-    if (!(fsck_data(fs)->options & OPT_SAVE_PASSES_DUMP))
-        mark_buffer_do_not_flush (fs->fs_super_bh);
-}
+	if (reiserfs_journal_opened(fs)) {
+		jh = (struct reiserfs_journal_header *)fs->fs_jh_bh->b_data;
+
+		/* reset journal params if needed. */
+		if (memcmp
+		    (sb_jp(sb), &jh->jh_journal,
+		     sizeof(struct journal_params))) {
+			if (is_reiserfs_jr_magic_string(sb))
+				memcpy(sb_jp(sb), &jh->jh_journal,
+				       sizeof(struct journal_params));
+			else {
+				set_sb_reserved_for_journal(sb, 0);
+
+				set_jp_journal_dev(sb_jp(sb), 0);
+				set_jp_journal_magic(sb_jp(sb), get_random());
+				set_jp_journal_1st_block(sb_jp(sb),
+							 get_journal_start_must
+							 (fs));
+				set_jp_journal_size(sb_jp(sb),
+						    journal_default_size(fs->
+									 fs_super_bh->
+									 b_blocknr,
+									 fs->
+									 fs_blocksize));
+				set_jp_journal_max_trans_len(sb_jp(sb),
+							     advise_journal_max_trans_len
+							     (get_jp_journal_max_trans_len
+							      (sb_jp(sb)),
+							      get_jp_journal_size
+							      (sb_jp(sb)),
+							      fs->fs_blocksize,
+							      0));
+				set_jp_journal_max_batch(sb_jp(sb),
+							 advise_journal_max_batch
+							 (get_jp_journal_max_trans_len
+							  (sb_jp(sb))));
+				set_jp_journal_max_commit_age(sb_jp(sb),
+							      advise_journal_max_commit_age
+							      ());
+				set_jp_journal_max_trans_age(sb_jp(sb),
+							     advise_journal_max_trans_age
+							     ());
+
+				set_jp_journal_dev(&jh->jh_journal, 0);
+				set_jp_journal_magic(&jh->jh_journal,
+						     get_jp_journal_magic(sb_jp
+									  (sb)));
+				set_jp_journal_1st_block(&jh->jh_journal,
+							 get_jp_journal_1st_block
+							 (sb_jp(sb)));
+				set_jp_journal_size(&jh->jh_journal,
+						    get_jp_journal_size(sb_jp
+									(sb)));
+				set_jp_journal_max_trans_len(&jh->jh_journal,
+							     get_jp_journal_max_trans_len
+							     (sb_jp(sb)));
+				set_jp_journal_max_batch(&jh->jh_journal,
+							 get_jp_journal_max_batch
+							 (sb_jp(sb)));
+				set_jp_journal_max_commit_age(&jh->jh_journal,
+							      get_jp_journal_max_commit_age
+							      (sb_jp(sb)));
+				set_jp_journal_max_trans_age(&jh->jh_journal,
+							     get_jp_journal_max_trans_age
+							     (sb_jp(sb)));
+			}
+		}
+	}
 
+	/* objectid map is not touched */
+	mark_buffer_dirty(fs->fs_super_bh);
+	bwrite(fs->fs_super_bh);
+	if (!(fsck_data(fs)->options & OPT_SAVE_PASSES_DUMP))
+		mark_buffer_do_not_flush(fs->fs_super_bh);
+}
 
 #define START_FROM_THE_BEGINNING 	1
 #define START_FROM_PASS_1 		2
@@ -563,94 +627,97 @@ static void reset_super_block (reiserfs_filsys_t * fs)
 #define START_FROM_PASS_4 		6
 
 /* this decides where to start from  */
-static int where_to_start_from (reiserfs_filsys_t * fs)
+static int where_to_start_from(reiserfs_filsys_t *fs)
 {
-    int ret;
-    FILE * fp = 0;
-    int last_run_state;
-    
-    last_run_state = get_sb_fs_state (fs->fs_ondisk_sb);
-    if (last_run_state == 0 || !fsck_run_one_step (fs))
-	/**/
-	return START_FROM_THE_BEGINNING;
-    
-    /* We are able to perform the next step only if there is a file with the previous 
-     * step results. */
-    fp = open_file (state_dump_file (fs), "r");
-    if (fp == 0) {
-	set_sb_fs_state (fs->fs_ondisk_sb, 0);
-	return START_FROM_THE_BEGINNING;
-    }
-
-    /* check start and end magics of dump file */
-    ret = is_stage_magic_correct (fp);
-    
-    if (ret <= 0 || ret != last_run_state)
-	return START_FROM_THE_BEGINNING;
-
-
-    switch (last_run_state) {
-    case PASS_0_DONE:
-	/* skip pass 0 */
-	if (!fsck_user_confirmed (fs, "Pass 0 seems finished. Start from pass 1?(Yes)",
-				  "Yes\n", 1))
-	    fsck_exit ("Run without -d then\n");
-	
-	load_pass_0_result (fp, fs);
-	fclose (fp);
-	return START_FROM_PASS_1;
-	
-    case PASS_1_DONE:
-	/* skip pass 1 */
-	if (!fsck_user_confirmed (fs, "Passes 0 and 1 seems finished. Start from "
-	    "pass 2?(Yes)", "Yes\n", 1)) 
-	{
-	    fsck_exit ("Run without -d then\n");
+	int ret;
+	FILE *fp = 0;
+	int last_run_state;
+
+	last_run_state = get_sb_fs_state(fs->fs_ondisk_sb);
+	if (last_run_state == 0 || !fsck_run_one_step(fs))
+		/**/ return START_FROM_THE_BEGINNING;
+
+	/* We are able to perform the next step only if there is a file with the previous 
+	 * step results. */
+	fp = open_file(state_dump_file(fs), "r");
+	if (fp == 0) {
+		set_sb_fs_state(fs->fs_ondisk_sb, 0);
+		return START_FROM_THE_BEGINNING;
 	}
-	
-	load_pass_1_result (fp, fs);
-	fclose (fp);
-	return START_FROM_PASS_2;
-	
-    case TREE_IS_BUILT:
-	if (!fsck_user_confirmed (fs, "Internal tree of filesystem looks built. "
-	    "Skip rebuilding?(Yes)", "Yes\n", 1))
-	{
-	    fsck_exit ("Run without -d then\n");
-	}
-	
-	load_pass_2_result (fs);
-	fclose (fp);
-	return START_FROM_SEMANTIC;
-    case SEMANTIC_DONE:
-	if (!fsck_user_confirmed (fs, "Passes 0 and 1 seems finished. Start from "
-	    "pass 2?(Yes)", "Yes\n", 1))
-	{
-	    fsck_exit ("Run without -d then\n");
-	}
-	
-	load_semantic_result (fp, fs);
-	fclose (fp);
-	return START_FROM_LOST_FOUND;
-    case LOST_FOUND_DONE:
-	if (!fsck_user_confirmed (fs, "Passes 0 and 1 seems finished. Start from "
-	    "pass 2?(Yes)", "Yes\n", 1))
-	{
-	    fsck_exit ("Run without -d then\n");
+
+	/* check start and end magics of dump file */
+	ret = is_stage_magic_correct(fp);
+
+	if (ret <= 0 || ret != last_run_state)
+		return START_FROM_THE_BEGINNING;
+
+	switch (last_run_state) {
+	case PASS_0_DONE:
+		/* skip pass 0 */
+		if (!fsck_user_confirmed
+		    (fs, "Pass 0 seems finished. Start from pass 1?(Yes)",
+		     "Yes\n", 1))
+			fsck_exit("Run without -d then\n");
+
+		load_pass_0_result(fp, fs);
+		fclose(fp);
+		return START_FROM_PASS_1;
+
+	case PASS_1_DONE:
+		/* skip pass 1 */
+		if (!fsck_user_confirmed
+		    (fs,
+		     "Passes 0 and 1 seems finished. Start from "
+		     "pass 2?(Yes)", "Yes\n", 1)) {
+			fsck_exit("Run without -d then\n");
+		}
+
+		load_pass_1_result(fp, fs);
+		fclose(fp);
+		return START_FROM_PASS_2;
+
+	case TREE_IS_BUILT:
+		if (!fsck_user_confirmed
+		    (fs,
+		     "Internal tree of filesystem looks built. "
+		     "Skip rebuilding?(Yes)", "Yes\n", 1)) {
+			fsck_exit("Run without -d then\n");
+		}
+
+		load_pass_2_result(fs);
+		fclose(fp);
+		return START_FROM_SEMANTIC;
+	case SEMANTIC_DONE:
+		if (!fsck_user_confirmed
+		    (fs,
+		     "Passes 0 and 1 seems finished. Start from "
+		     "pass 2?(Yes)", "Yes\n", 1)) {
+			fsck_exit("Run without -d then\n");
+		}
+
+		load_semantic_result(fp, fs);
+		fclose(fp);
+		return START_FROM_LOST_FOUND;
+	case LOST_FOUND_DONE:
+		if (!fsck_user_confirmed
+		    (fs,
+		     "Passes 0 and 1 seems finished. Start from "
+		     "pass 2?(Yes)", "Yes\n", 1)) {
+			fsck_exit("Run without -d then\n");
+		}
+
+		load_lost_found_result(fs);
+		fclose(fp);
+		return START_FROM_PASS_4;
 	}
-	
-	load_lost_found_result (fs);
-	fclose (fp);
-	return START_FROM_PASS_4;
-    }
-    
-    return START_FROM_THE_BEGINNING;
+
+	return START_FROM_THE_BEGINNING;
 }
 
 static void reiserfs_update_interval_fields(reiserfs_filsys_t *fs)
 {
 	/* Not supported on v3.5 */
-	if (get_sb_version (fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
+	if (get_sb_version(fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
 		return;
 
 	set_sb_v2_lastcheck(fs->fs_ondisk_sb, time(NULL));
@@ -658,265 +725,275 @@ static void reiserfs_update_interval_fields(reiserfs_filsys_t *fs)
 
 	if (get_sb_v2_max_mnt_count(fs->fs_ondisk_sb) == 0)
 		set_sb_v2_max_mnt_count(fs->fs_ondisk_sb,
-					      DEFAULT_MAX_MNT_COUNT);
+					DEFAULT_MAX_MNT_COUNT);
 	if (get_sb_v2_check_interval(fs->fs_ondisk_sb) == 0)
 		set_sb_v2_check_interval(fs->fs_ondisk_sb,
-					       DEFAULT_CHECK_INTERVAL);
+					 DEFAULT_CHECK_INTERVAL);
 }
 
-static void mark_filesystem_consistent (reiserfs_filsys_t * fs)
+static void mark_filesystem_consistent(reiserfs_filsys_t *fs)
 {
-    if (!is_opened_rw (fs))
-        return;
-
-    if (!reiserfs_journal_opened (fs)) {
-	/* make sure journal is not standard */
-	if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
-	    reiserfs_exit(EXIT_OPER, "Filesystem with default journal "
-			  "must be opened.");
-	
-	fsck_progress ("WARNING: You must use reiserfstune to specify a new "
-	    "journal before mounting it.\n");
-	
-	/* mark filesystem such that it is not mountable until 
-	 * new journaldevice is defined */	
-	set_jp_journal_magic (sb_jp (fs->fs_ondisk_sb), NEED_TUNE);
-    }
+	if (!is_opened_rw(fs))
+		return;
 
-    set_sb_umount_state (fs->fs_ondisk_sb, FS_CLEANLY_UMOUNTED);
-    set_sb_fs_state (fs->fs_ondisk_sb, FS_CONSISTENT);
-    reiserfs_update_interval_fields(fs);
-    
-    mark_buffer_dirty (fs->fs_super_bh);
+	if (!reiserfs_journal_opened(fs)) {
+		/* make sure journal is not standard */
+		if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
+			reiserfs_exit(EXIT_OPER,
+				      "Filesystem with default journal "
+				      "must be opened.");
+
+		fsck_progress
+		    ("WARNING: You must use reiserfstune to specify a new "
+		     "journal before mounting it.\n");
+
+		/* mark filesystem such that it is not mountable until 
+		 * new journaldevice is defined */
+		set_jp_journal_magic(sb_jp(fs->fs_ondisk_sb), NEED_TUNE);
+	}
+
+	set_sb_umount_state(fs->fs_ondisk_sb, FS_CLEANLY_UMOUNTED);
+	set_sb_fs_state(fs->fs_ondisk_sb, FS_CONSISTENT);
+	reiserfs_update_interval_fields(fs);
+
+	mark_buffer_dirty(fs->fs_super_bh);
 }
 
-static void reiserfsck_replay_journal (reiserfs_filsys_t * fs) {
-    struct reiserfs_super_block *on_place_sb;
-    int sb_size = reiserfs_super_block_size(fs->fs_ondisk_sb);
-    
-    /* keep the super_block in the separate memory to avoid problems with replaying 
-     * broken parameters. */
-    on_place_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
-    fs->fs_ondisk_sb = getmem (sb_size);
-    memcpy (fs->fs_ondisk_sb, on_place_sb, sb_size);
-
-    replay_journal (fs);
-
-    /* Copy checked reliable sb fields from backed up sb to a new one. */
-    set_sb_block_count(on_place_sb, get_sb_block_count(fs->fs_ondisk_sb));
-    memcpy(sb_jp(on_place_sb), sb_jp(fs->fs_ondisk_sb), 
-	sizeof(struct journal_params));    
-    set_sb_block_size(on_place_sb, get_sb_block_size(fs->fs_ondisk_sb));
-    set_sb_oid_maxsize(on_place_sb, get_sb_oid_maxsize(fs->fs_ondisk_sb));
-    memcpy(on_place_sb->s_v1.s_magic, fs->fs_ondisk_sb->s_v1.s_magic, 10);
-    set_sb_hash_code(on_place_sb, get_sb_hash_code(fs->fs_ondisk_sb));
-    set_sb_bmap_nr(on_place_sb, get_sb_bmap_nr(fs->fs_ondisk_sb));
-    set_sb_version(on_place_sb, get_sb_version(fs->fs_ondisk_sb));
-    set_sb_reserved_for_journal(on_place_sb, 
-	get_sb_reserved_for_journal(fs->fs_ondisk_sb));
-    
-    if (sb_size == SB_SIZE) {
-	set_sb_v2_flags(on_place_sb, get_sb_v2_flags(fs->fs_ondisk_sb));
-	memcpy(on_place_sb->s_uuid, fs->fs_ondisk_sb->s_uuid, 16);
-	memcpy(on_place_sb->s_label, fs->fs_ondisk_sb->s_label, 16);
-    }
+static void reiserfsck_replay_journal(reiserfs_filsys_t *fs)
+{
+	struct reiserfs_super_block *on_place_sb;
+	int sb_size = reiserfs_super_block_size(fs->fs_ondisk_sb);
+
+	/* keep the super_block in the separate memory to avoid problems with replaying 
+	 * broken parameters. */
+	on_place_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
+	fs->fs_ondisk_sb = getmem(sb_size);
+	memcpy(fs->fs_ondisk_sb, on_place_sb, sb_size);
+
+	replay_journal(fs);
+
+	/* Copy checked reliable sb fields from backed up sb to a new one. */
+	set_sb_block_count(on_place_sb, get_sb_block_count(fs->fs_ondisk_sb));
+	memcpy(sb_jp(on_place_sb), sb_jp(fs->fs_ondisk_sb),
+	       sizeof(struct journal_params));
+	set_sb_block_size(on_place_sb, get_sb_block_size(fs->fs_ondisk_sb));
+	set_sb_oid_maxsize(on_place_sb, get_sb_oid_maxsize(fs->fs_ondisk_sb));
+	memcpy(on_place_sb->s_v1.s_magic, fs->fs_ondisk_sb->s_v1.s_magic, 10);
+	set_sb_hash_code(on_place_sb, get_sb_hash_code(fs->fs_ondisk_sb));
+	set_sb_bmap_nr(on_place_sb, get_sb_bmap_nr(fs->fs_ondisk_sb));
+	set_sb_version(on_place_sb, get_sb_version(fs->fs_ondisk_sb));
+	set_sb_reserved_for_journal(on_place_sb,
+				    get_sb_reserved_for_journal(fs->
+								fs_ondisk_sb));
+
+	if (sb_size == SB_SIZE) {
+		set_sb_v2_flags(on_place_sb, get_sb_v2_flags(fs->fs_ondisk_sb));
+		memcpy(on_place_sb->s_uuid, fs->fs_ondisk_sb->s_uuid, 16);
+		memcpy(on_place_sb->s_label, fs->fs_ondisk_sb->s_label, 16);
+	}
 
-    /* get rid of SB copy */
-    freemem (fs->fs_ondisk_sb);
-    fs->fs_ondisk_sb = on_place_sb;
+	/* get rid of SB copy */
+	freemem(fs->fs_ondisk_sb);
+	fs->fs_ondisk_sb = on_place_sb;
 }
 
-static int the_end (reiserfs_filsys_t * fs)
+static int the_end(reiserfs_filsys_t *fs)
 {
-    int ret = EXIT_FIXED;
+	int ret = EXIT_FIXED;
 
-    /* put bitmap and objectid map on place */
-    reiserfs_delete_bitmap (fs->fs_bitmap2);
-    fs->fs_bitmap2 = fsck_new_bitmap (fs);
-    if (!fs->fs_bitmap2->bm_dirty)
-	die ("Bitmap not dirty");
+	/* put bitmap and objectid map on place */
+	reiserfs_delete_bitmap(fs->fs_bitmap2);
+	fs->fs_bitmap2 = fsck_new_bitmap(fs);
+	if (!fs->fs_bitmap2->bm_dirty)
+		die("Bitmap not dirty");
 
 //    id_map_flush(proper_id_map (fs), fs);
-    id_map_flush(semantic_id_map (fs), fs);
-    id_map_free(proper_id_map (fs));
-    id_map_free(semantic_id_map (fs));
+	id_map_flush(semantic_id_map(fs), fs);
+	id_map_free(proper_id_map(fs));
+	id_map_free(semantic_id_map(fs));
 
 /*    set_sb_free_blocks (sb, reiserfs_bitmap_zeros (fsck_new_bitmap (fs)));*/
 
-    mark_filesystem_consistent (fs);
-    clear_buffer_do_not_flush (fs->fs_super_bh);
+	mark_filesystem_consistent(fs);
+	clear_buffer_do_not_flush(fs->fs_super_bh);
 
-    if (fsck_data(fs)->mounted == MF_RO) {
-	reiserfs_warning(stderr, "\nThe partition is mounted ro. It "
-			 "is better to umount and mount it again.\n\n");
-	ret = EXIT_REBOOT;
-    }
+	if (fsck_data(fs)->mounted == MF_RO) {
+		reiserfs_warning(stderr, "\nThe partition is mounted ro. It "
+				 "is better to umount and mount it again.\n\n");
+		ret = EXIT_REBOOT;
+	}
 
-    /* write all dirty blocks */
-    fsck_progress ("Syncing..");
-    fs->fs_dirt = 1;
-    clean_after_dma_check(fs->fs_dev, &dma_info);
-    fsck_progress ("finished\n");
-    reiserfs_close (fs);
+	/* write all dirty blocks */
+	fsck_progress("Syncing..");
+	fs->fs_dirt = 1;
+	clean_after_dma_check(fs->fs_dev, &dma_info);
+	fsck_progress("finished\n");
+	reiserfs_close(fs);
 
-    return ret;
+	return ret;
 }
 
 /* check umounted or read-only mounted filesystems only */
-static void prepare_fs_for_check(reiserfs_filsys_t * fs) {
-    /* The method could be called from auto_check already. */
-    if (fs->fs_flags == O_RDWR) 
-	return;
-
-    reiserfs_reopen (fs, O_RDWR);
-    
-    fsck_data(fs)->mounted = misc_device_mounted(fs->fs_file_name);
-    
-    if (fsck_data(fs)->mounted > 0) {
-	if (fsck_data(fs)->mounted == MF_RW) {
-	    fsck_progress ("Partition %s is mounted with write permissions, "
-		"cannot check it\n", fs->fs_file_name);
-	    reiserfs_close(fs);
-	    exit(EXIT_USER);
-	}
-	
-	/* If not CHECK mode, lock the process in the memory. */
-	if (fsck_mode (fs) != FSCK_CHECK) {
-	    if (mlockall(MCL_CURRENT)) {
-		    reiserfs_exit(EXIT_OPER, "Failed to lock the process to "
-				  "fsck the mounted ro partition. %s.\n", 
-				  strerror(errno));
-	    }
-	}
-	
-	if (fsck_skip_journal (fs)) {
-		reiserfs_exit(EXIT_USER, "Jounrnal of the mounted "
-			      "filesystem must be specified.\n");
+static void prepare_fs_for_check(reiserfs_filsys_t *fs)
+{
+	/* The method could be called from auto_check already. */
+	if (fs->fs_flags == O_RDWR)
+		return;
+
+	reiserfs_reopen(fs, O_RDWR);
+
+	fsck_data(fs)->mounted = misc_device_mounted(fs->fs_file_name);
+
+	if (fsck_data(fs)->mounted > 0) {
+		if (fsck_data(fs)->mounted == MF_RW) {
+			fsck_progress
+			    ("Partition %s is mounted with write permissions, "
+			     "cannot check it\n", fs->fs_file_name);
+			reiserfs_close(fs);
+			exit(EXIT_USER);
+		}
+
+		/* If not CHECK mode, lock the process in the memory. */
+		if (fsck_mode(fs) != FSCK_CHECK) {
+			if (mlockall(MCL_CURRENT)) {
+				reiserfs_exit(EXIT_OPER,
+					      "Failed to lock the process to "
+					      "fsck the mounted ro partition. %s.\n",
+					      strerror(errno));
+			}
+		}
+
+		if (fsck_skip_journal(fs)) {
+			reiserfs_exit(EXIT_USER, "Jounrnal of the mounted "
+				      "filesystem must be specified.\n");
+		}
+
+		if (!reiserfs_journal_opened(fs)) {
+			/* just to make sure */
+			reiserfs_panic("Journal is not opened");
+		} else if (reiserfs_journal_params_check(fs)) {
+			reiserfs_close(fs);
+			exit(EXIT_FATAL);
+		}
+
+		fsck_progress
+		    ("Filesystem seems mounted read-only. Skipping journal "
+		     "replay.\n");
+	} else if (!fsck_skip_journal(fs)) {
+		if (reiserfs_journal_params_check(fs)) {
+			reiserfs_close(fs);
+			exit(EXIT_FATAL);
+		}
+
+		/* filesystem is not mounted, replay journal before checking */
+		reiserfsck_replay_journal(fs);
 	}
-	
-	if (!reiserfs_journal_opened (fs)) {
-	    /* just to make sure */
-	    reiserfs_panic ("Journal is not opened");
-	} else if (reiserfs_journal_params_check(fs)) {
-	    reiserfs_close (fs);
-	    exit(EXIT_FATAL);
+}
+
+static void rebuild_tree(reiserfs_filsys_t *fs)
+{
+	time_t t;
+	int ret;
+
+	init_rollback_file(state_rollback_file(fs), &fs->fs_blocksize,
+			   fsck_data(fs)->log);
+
+	prepare_fs_for_check(fs);
+
+	ret = reiserfs_open_ondisk_bitmap(fs);
+	if (ret < 0) {
+		fsck_progress("reiserfsck: Could not open bitmap\n");
+		reiserfs_close(fs);
+		exit(EXIT_OPER);
+	} else if (ret > 0) {
+		fsck_log
+		    ("Zero bit found in on-disk bitmap after the last valid bit. "
+		     "Fixed.\n");
 	}
-	
-	fsck_progress ("Filesystem seems mounted read-only. Skipping journal "
-	    "replay.\n");
-    } else if (!fsck_skip_journal (fs)) {
-	if (reiserfs_journal_params_check(fs)) {
-	    reiserfs_close (fs);
-	    exit(EXIT_FATAL);
+
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck --rebuild-tree started at %s"
+		      "###########\n", ctime(&t));
+
+	switch (where_to_start_from(fs)) {
+	case START_FROM_THE_BEGINNING:
+		reset_super_block(fs);
+		pass_0(fs);
+
+	case START_FROM_PASS_1:
+		reset_super_block(fs);
+		pass_1(fs);
+
+	case START_FROM_PASS_2:
+		pass_2(fs);
+
+	case START_FROM_SEMANTIC:
+		pass_3_semantic(fs);
+
+		/* if --lost+found is set - link unaccessed directories to lost+found
+		   directory */
+	case START_FROM_LOST_FOUND:
+		pass_3a_look_for_lost(fs);
+
+	case START_FROM_PASS_4:
+		/* 4. look for unaccessed items in the leaves */
+		pass_4_check_unaccessed_items();
+
+		ret = the_end(fs);
 	}
-	
-	/* filesystem is not mounted, replay journal before checking */
-        reiserfsck_replay_journal (fs);
-    }
-}
 
-static void rebuild_tree (reiserfs_filsys_t * fs) {
-    time_t t;
-    int ret;
-
-    init_rollback_file (state_rollback_file(fs), &fs->fs_blocksize, 
-	fsck_data(fs)->log);
-    
-    prepare_fs_for_check(fs);
-    
-    ret = reiserfs_open_ondisk_bitmap (fs);
-    if (ret < 0) {
-        fsck_progress ("reiserfsck: Could not open bitmap\n");
-	reiserfs_close (fs);
-	exit(EXIT_OPER);
-    } else if (ret > 0) {
-	fsck_log("Zero bit found in on-disk bitmap after the last valid bit. "
-	    "Fixed.\n");
-    }
- 
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck --rebuild-tree started at %s"
-		   "###########\n", ctime (&t));
-
-    switch (where_to_start_from (fs)) {
-    case START_FROM_THE_BEGINNING:
-	reset_super_block (fs);
-	pass_0 (fs);
-
-    case START_FROM_PASS_1:
-	reset_super_block (fs);
-	pass_1 (fs);
-	
-    case START_FROM_PASS_2:
-	pass_2 (fs);
-
-    case START_FROM_SEMANTIC:
-	pass_3_semantic (fs);
-
-	/* if --lost+found is set - link unaccessed directories to lost+found
-	   directory */
-    case START_FROM_LOST_FOUND:	
-	pass_3a_look_for_lost (fs);
-	
-    case START_FROM_PASS_4:
-	/* 4. look for unaccessed items in the leaves */
-	pass_4_check_unaccessed_items ();
-	
-	ret = the_end (fs);
-    }
+	close_rollback_file();
 
-    close_rollback_file ();
-       
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck finished at %s"
-		   "###########\n", ctime (&t));
-    exit (ret);
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck finished at %s" "###########\n", ctime(&t));
+	exit(ret);
 }
 
-static void clean_attributes (reiserfs_filsys_t * fs) {
-    time_t t;
+static void clean_attributes(reiserfs_filsys_t *fs)
+{
+	time_t t;
+
+	time(&t);
 
-    time (&t);
+	if (get_sb_umount_state(fs->fs_ondisk_sb) != FS_CLEANLY_UMOUNTED) {
+		fsck_progress("Filesystem is not clean\n"
+			      "Check consistency of the partition first.\n");
+		exit(EXIT_USER);
+	}
+	if (get_sb_fs_state(fs->fs_ondisk_sb) != FS_CONSISTENT) {
+		fsck_progress("Filesystem seems to be in unconsistent state.\n"
+			      "Check consistency of the partition first.\n");
+		exit(EXIT_USER);
+	}
 
-    if (get_sb_umount_state (fs->fs_ondisk_sb) != FS_CLEANLY_UMOUNTED) {
-        fsck_progress ("Filesystem is not clean\n"
-	    "Check consistency of the partition first.\n");
-        exit(EXIT_USER);
-    }
-    if (get_sb_fs_state (fs->fs_ondisk_sb) != FS_CONSISTENT) {
-        fsck_progress ("Filesystem seems to be in unconsistent state.\n"
-	    "Check consistency of the partition first.\n");
-        exit(EXIT_USER);
-    }
+	if (get_reiserfs_format(fs->fs_ondisk_sb) != REISERFS_FORMAT_3_6) {
+		fsck_progress
+		    ("Filesystems of 3_5 format do not support extended "
+		     "attributes.\n");
 
-    if (get_reiserfs_format (fs->fs_ondisk_sb) != REISERFS_FORMAT_3_6) {
-        fsck_progress ("Filesystems of 3_5 format do not support extended "
-	    "attributes.\n");
-	
-        exit(EXIT_USER);
-    }
-    fsck_progress ("###########\n"
-	           "reiserfsck --clean-attributes started at %s"
-                   "###########\n", ctime (&t));
+		exit(EXIT_USER);
+	}
+	fsck_progress("###########\n"
+		      "reiserfsck --clean-attributes started at %s"
+		      "###########\n", ctime(&t));
 
-    init_rollback_file (state_rollback_file(fs), &fs->fs_blocksize, 
-	fsck_data(fs)->log);
+	init_rollback_file(state_rollback_file(fs), &fs->fs_blocksize,
+			   fsck_data(fs)->log);
 
-    prepare_fs_for_check(fs);
+	prepare_fs_for_check(fs);
 
-    do_clean_attributes (fs);
+	do_clean_attributes(fs);
 
-    clean_after_dma_check(fs->fs_dev, &dma_info);
+	clean_after_dma_check(fs->fs_dev, &dma_info);
 
-    fsck_progress ("###########\n"
-		   "reiserfsck finished at %s"
-		   "###########\n", ctime (&t));
-    reiserfs_close (fs);
-    close_rollback_file ();
+	fsck_progress("###########\n"
+		      "reiserfsck finished at %s" "###########\n", ctime(&t));
+	reiserfs_close(fs);
+	close_rollback_file();
 
-    exit (EXIT_FIXED);
+	exit(EXIT_FIXED);
 
 }
 
@@ -926,23 +1003,23 @@ static int reiserfs_check_auto_state(reiserfs_filsys_t *fs)
 	time_t lastcheck = get_sb_v2_lastcheck(fs->fs_ondisk_sb);
 	unsigned int mnt_count = get_sb_v2_mnt_count(fs->fs_ondisk_sb);
 	unsigned int max_mnt_count = get_sb_v2_max_mnt_count(fs->fs_ondisk_sb);
-	unsigned int interval =  get_sb_v2_check_interval(fs->fs_ondisk_sb);
+	unsigned int interval = get_sb_v2_check_interval(fs->fs_ondisk_sb);
 
 	/* v3.5 file systems don't have the superblock fields for this */
-	if (get_sb_version (fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
+	if (get_sb_version(fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
 		return 1;
 
 	if (lastcheck == 0 || mnt_count == 0 || max_mnt_count == 0 ||
 	    interval == 0) {
 		fprintf(stderr, "File system hasn't been enabled for faster "
-		        "boot-time checking. It will be enabled after a "
+			"boot-time checking. It will be enabled after a "
 			"successful run.\n");
 		return 1;
 	}
 
 	if (interval != UINT_MAX && now > lastcheck + interval) {
 		fprintf(stderr, "File system hasn't been checked in %lu days. "
-		        "Checking now.\n", (now - lastcheck) / (60*60*24));
+			"Checking now.\n", (now - lastcheck) / (60 * 60 * 24));
 		return 1;
 	}
 
@@ -954,420 +1031,449 @@ static int reiserfs_check_auto_state(reiserfs_filsys_t *fs)
 
 	if (mnt_count > max_mnt_count && max_mnt_count != USHRT_MAX) {
 		fprintf(stderr, "File system has been mounted %u times "
-		        "without being checked. Checking now.\n", mnt_count);
+			"without being checked. Checking now.\n", mnt_count);
 		return 1;
 	}
 
 	return 0;
 }
 
-static int auto_check (reiserfs_filsys_t *fs) {
-    __u16 state;
-    int retval = 0;
-    int force = fsck_data(fs)->options & OPT_FORCE;
-    
-    print_super_block (stdout, fs, fs->fs_file_name, fs->fs_super_bh, 1);
-    
-    state = get_sb_fs_state (fs->fs_ondisk_sb);
-    if ((state & FS_FATAL) == FS_FATAL) {
-	fprintf(stderr, "Filesystem seems to have fatal corruptions. Running "
-	    "with --rebuild-tree is required.\n");
-	goto error;
-    }
+static int auto_check(reiserfs_filsys_t *fs)
+{
+	__u16 state;
+	int retval = 0;
+	int force = fsck_data(fs)->options & OPT_FORCE;
+
+	print_super_block(stdout, fs, fs->fs_file_name, fs->fs_super_bh, 1);
+
+	state = get_sb_fs_state(fs->fs_ondisk_sb);
+	if ((state & FS_FATAL) == FS_FATAL) {
+		fprintf(stderr,
+			"Filesystem seems to have fatal corruptions. Running "
+			"with --rebuild-tree is required.\n");
+		goto error;
+	}
 
-    if ((state & FS_ERROR) == FS_ERROR) {
-	fprintf(stderr, "Some corruptions on the filesystem were detected. Switching to "
-	    "the --fix-fixable mode.\n");
-	/* run fixable pass. */
-	return 0;
-    }
-    
-    if (state != FS_CONSISTENT)
-	fprintf(stderr, "Some strange state was specified in the super block. "
-	    "Do usual check.\n");
-
-    if (get_sb_umount_state (fs->fs_ondisk_sb) == FS_CLEANLY_UMOUNTED &&
-	!force && !reiserfs_check_auto_state(fs))
-	    exit(EXIT_OK);
-    prepare_fs_for_check(fs);
-    if (!force && !reiserfs_check_auto_state(fs))
-	    exit(EXIT_OK);
-
-    /* Check bitmaps. */
-    retval = reiserfs_open_ondisk_bitmap (fs);
-    
-    if (retval > 0) {
-	fsck_log("Zero bit found in on-disk bitmap after the last valid bit. "
-	    "Switching to --fix-fixable mode.\n");
-	/* run fixable pass. */
-	return 0;
-    } else if (retval < 0) {
-        fsck_progress ("reiserfsck: Could not open bitmap\n");
-	goto error;
-    }
-    
-    if (get_sb_block_count (fs->fs_ondisk_sb) - 
-	get_sb_free_blocks(fs->fs_ondisk_sb) != 
-	fs->fs_bitmap2->bm_set_bits)
-    {
-	fsck_log("Wrong amount of used blocks. Switching to the --fix-fixable mode.\n");
-	/* run fixable pass. */
-	return 0;
-    }
+	if ((state & FS_ERROR) == FS_ERROR) {
+		fprintf(stderr,
+			"Some corruptions on the filesystem were detected. Switching to "
+			"the --fix-fixable mode.\n");
+		/* run fixable pass. */
+		return 0;
+	}
 
-    check_fs_tree (fs);
-    
-    if (fsck_data (fs)->check.fatal_corruptions) {		
-	fprintf(stderr, "%lu fatal corruption(s) found in the root block. Running "
-	    "with the --rebuild-tree is required.\n", 
-	    fsck_data (fs)->check.fatal_corruptions);
-	goto fatal_error;
-    } else if (fsck_data (fs)->check.fixable_corruptions) {
-        /* seems that this cannot happen. */
-	fprintf(stderr, "%lu fixable corruption(s) found. Switching to "
-	    "the --fix-fixable mode.\n", fsck_data (fs)->check.fixable_corruptions);
-	fsck_data (fs)->check.fixable_corruptions = 0;
-	/* run fixable pass. */
-	return 0;
-    }
+	if (state != FS_CONSISTENT)
+		fprintf(stderr,
+			"Some strange state was specified in the super block. "
+			"Do usual check.\n");
+
+	if (get_sb_umount_state(fs->fs_ondisk_sb) == FS_CLEANLY_UMOUNTED &&
+	    !force && !reiserfs_check_auto_state(fs))
+		exit(EXIT_OK);
+	prepare_fs_for_check(fs);
+	if (!force && !reiserfs_check_auto_state(fs))
+		exit(EXIT_OK);
+
+	/* Check bitmaps. */
+	retval = reiserfs_open_ondisk_bitmap(fs);
+
+	if (retval > 0) {
+		fsck_log
+		    ("Zero bit found in on-disk bitmap after the last valid bit. "
+		     "Switching to --fix-fixable mode.\n");
+		/* run fixable pass. */
+		return 0;
+	} else if (retval < 0) {
+		fsck_progress("reiserfsck: Could not open bitmap\n");
+		goto error;
+	}
 
-    reiserfs_update_interval_fields(fs);
-    mark_buffer_dirty(fs->fs_super_bh);
-    bwrite(fs->fs_super_bh);
-    fs->fs_dirt = 1;
+	if (get_sb_block_count(fs->fs_ondisk_sb) -
+	    get_sb_free_blocks(fs->fs_ondisk_sb) !=
+	    fs->fs_bitmap2->bm_set_bits) {
+		fsck_log
+		    ("Wrong amount of used blocks. Switching to the --fix-fixable mode.\n");
+		/* run fixable pass. */
+		return 0;
+	}
 
-    clean_after_dma_check(fs->fs_dev, &dma_info);
-    
-    reiserfs_close (fs);
-    /* do not do anything else. */    
-    exit (EXIT_OK);
+	check_fs_tree(fs);
+
+	if (fsck_data(fs)->check.fatal_corruptions) {
+		fprintf(stderr,
+			"%lu fatal corruption(s) found in the root block. Running "
+			"with the --rebuild-tree is required.\n",
+			fsck_data(fs)->check.fatal_corruptions);
+		goto fatal_error;
+	} else if (fsck_data(fs)->check.fixable_corruptions) {
+		/* seems that this cannot happen. */
+		fprintf(stderr, "%lu fixable corruption(s) found. Switching to "
+			"the --fix-fixable mode.\n",
+			fsck_data(fs)->check.fixable_corruptions);
+		fsck_data(fs)->check.fixable_corruptions = 0;
+		/* run fixable pass. */
+		return 0;
+	}
+
+	reiserfs_update_interval_fields(fs);
+	mark_buffer_dirty(fs->fs_super_bh);
+	bwrite(fs->fs_super_bh);
+	fs->fs_dirt = 1;
+
+	clean_after_dma_check(fs->fs_dev, &dma_info);
+
+	reiserfs_close(fs);
+	/* do not do anything else. */
+	exit(EXIT_OK);
 
 fatal_error:
-    set_sb_fs_state(fs->fs_ondisk_sb, FS_FATAL);
-    mark_buffer_dirty (fs->fs_super_bh);
-    bwrite(fs->fs_super_bh);	
+	set_sb_fs_state(fs->fs_ondisk_sb, FS_FATAL);
+	mark_buffer_dirty(fs->fs_super_bh);
+	bwrite(fs->fs_super_bh);
 error:
-    clean_after_dma_check(fs->fs_dev, &dma_info);
-    reiserfs_close(fs);
-    exit(EXIT_FATAL);
+	clean_after_dma_check(fs->fs_dev, &dma_info);
+	reiserfs_close(fs);
+	exit(EXIT_FATAL);
 }
 
 /* check umounted or read-only mounted filesystems only */
-static void check_fs (reiserfs_filsys_t * fs)
+static void check_fs(reiserfs_filsys_t *fs)
 {
-    int retval = EXIT_OK;
-    time_t t;
-
-    time (&t);
-
-    if (fsck_mode (fs) != FSCK_FIX_FIXABLE) {
-        fsck_progress ("###########\n"
-	               "reiserfsck --check started at %s"
-                       "###########\n", ctime (&t));
-    } else {
-        fsck_progress ("###########\n"
-	               "reiserfsck --fix-fixable started at %s"
-                       "###########\n", ctime (&t));
-    }
-
-    init_rollback_file (state_rollback_file(fs), &fs->fs_blocksize, 
-	fsck_data(fs)->log);
-    
-    prepare_fs_for_check (fs);
+	int retval = EXIT_OK;
+	time_t t;
 
-    if (!fs->fs_bitmap2)
-	/* It could be done on auto_check already. */
-	retval = reiserfs_open_ondisk_bitmap (fs);
+	time(&t);
 
-    if (retval > 0) {
 	if (fsck_mode(fs) != FSCK_FIX_FIXABLE) {
-	    fsck_log("Zero bit found in on-disk bitmap after the last valid "
-		"bit.\n");
-	    
-	    one_more_corruption(fs, FIXABLE);
+		fsck_progress("###########\n"
+			      "reiserfsck --check started at %s"
+			      "###########\n", ctime(&t));
 	} else {
-	    fsck_log("Zero bit found in on-disk bitmap after the last valid "
-		"bit. Fixed.\n");
+		fsck_progress("###########\n"
+			      "reiserfsck --fix-fixable started at %s"
+			      "###########\n", ctime(&t));
 	}
-    } else if (retval < 0) {
-        fsck_progress ("reiserfsck: Could not open bitmap\n");
-	reiserfs_close (fs);
-	exit(EXIT_OPER);
-    }
 
-    check_fs_tree (fs);
-
-    semantic_check ();
-    
-    if (fsck_data (fs)->check.fatal_corruptions) {
-	fsck_progress ("%lu found corruptions can be fixed only when running with "
-	    "--rebuild-tree\n", fsck_data (fs)->check.fatal_corruptions);
-	
-        set_sb_fs_state (fs->fs_ondisk_sb, FS_FATAL);
-        mark_buffer_dirty (fs->fs_super_bh);
-	retval = EXIT_FATAL;
-    } else if (fsck_data (fs)->check.fixable_corruptions) {
-        /* fixable corruptions found */
-	if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-            /* fixable corruptions found and fix-fixable has not fixed them, 
-	     * do rebuild-tree */
-	    
-            fsck_progress ("Fatal error: %lu fixable corruptions found after "
-		"--fix-fixable.\n", fsck_data (fs)->check.fixable_corruptions);
-	    retval = EXIT_OPER;
-        } else {
-	    fsck_progress ("%lu found corruptions can be fixed when running with "
-		"--fix-fixable\n", fsck_data (fs)->check.fixable_corruptions);
-	    
-	    retval = EXIT_FIXABLE;
-        }
-        set_sb_fs_state (fs->fs_ondisk_sb, FS_ERROR);
-        mark_buffer_dirty (fs->fs_super_bh);
-    } else {
-	fsck_progress ("No corruptions found\n");
-	stage_report (5, fs);
-
-	if (fsck_mode(fs) != FSCK_CHECK) {
-		if (misc_device_mounted(fs->fs_file_name) == MF_RO) {
-			reiserfs_warning(stderr, "\nThe partition is mounted ro. It is better "
-					 "to umount and mount it again.\n\n");
-			retval = EXIT_REBOOT;
-		} else 
-			retval = EXIT_FIXED;
-	} else
-		retval = EXIT_OK;
-
-	mark_filesystem_consistent (fs);
-    }
-   
-    if (fsck_mode (fs) == FSCK_FIX_FIXABLE && !fsck_data (fs)->check.fatal_corruptions)
-        id_map_flush(proper_id_map (fs), fs);
-        
-    id_map_free(proper_id_map (fs));
-    clean_after_dma_check(fs->fs_dev, &dma_info);
-    
-    //clear_relocated_list();    
-    
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck finished at %s"
-		   "###########\n", ctime (&t));
-
-    reiserfs_close (fs);
-    close_rollback_file ();
-    exit(retval);
+	init_rollback_file(state_rollback_file(fs), &fs->fs_blocksize,
+			   fsck_data(fs)->log);
+
+	prepare_fs_for_check(fs);
+
+	if (!fs->fs_bitmap2)
+		/* It could be done on auto_check already. */
+		retval = reiserfs_open_ondisk_bitmap(fs);
+
+	if (retval > 0) {
+		if (fsck_mode(fs) != FSCK_FIX_FIXABLE) {
+			fsck_log
+			    ("Zero bit found in on-disk bitmap after the last valid "
+			     "bit.\n");
+
+			one_more_corruption(fs, FIXABLE);
+		} else {
+			fsck_log
+			    ("Zero bit found in on-disk bitmap after the last valid "
+			     "bit. Fixed.\n");
+		}
+	} else if (retval < 0) {
+		fsck_progress("reiserfsck: Could not open bitmap\n");
+		reiserfs_close(fs);
+		exit(EXIT_OPER);
+	}
+
+	check_fs_tree(fs);
+
+	semantic_check();
+
+	if (fsck_data(fs)->check.fatal_corruptions) {
+		fsck_progress
+		    ("%lu found corruptions can be fixed only when running with "
+		     "--rebuild-tree\n",
+		     fsck_data(fs)->check.fatal_corruptions);
+
+		set_sb_fs_state(fs->fs_ondisk_sb, FS_FATAL);
+		mark_buffer_dirty(fs->fs_super_bh);
+		retval = EXIT_FATAL;
+	} else if (fsck_data(fs)->check.fixable_corruptions) {
+		/* fixable corruptions found */
+		if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+			/* fixable corruptions found and fix-fixable has not fixed them, 
+			 * do rebuild-tree */
+
+			fsck_progress
+			    ("Fatal error: %lu fixable corruptions found after "
+			     "--fix-fixable.\n",
+			     fsck_data(fs)->check.fixable_corruptions);
+			retval = EXIT_OPER;
+		} else {
+			fsck_progress
+			    ("%lu found corruptions can be fixed when running with "
+			     "--fix-fixable\n",
+			     fsck_data(fs)->check.fixable_corruptions);
+
+			retval = EXIT_FIXABLE;
+		}
+		set_sb_fs_state(fs->fs_ondisk_sb, FS_ERROR);
+		mark_buffer_dirty(fs->fs_super_bh);
+	} else {
+		fsck_progress("No corruptions found\n");
+		stage_report(5, fs);
+
+		if (fsck_mode(fs) != FSCK_CHECK) {
+			if (misc_device_mounted(fs->fs_file_name) == MF_RO) {
+				reiserfs_warning(stderr,
+						 "\nThe partition is mounted ro. It is better "
+						 "to umount and mount it again.\n\n");
+				retval = EXIT_REBOOT;
+			} else
+				retval = EXIT_FIXED;
+		} else
+			retval = EXIT_OK;
+
+		mark_filesystem_consistent(fs);
+	}
+
+	if (fsck_mode(fs) == FSCK_FIX_FIXABLE
+	    && !fsck_data(fs)->check.fatal_corruptions)
+		id_map_flush(proper_id_map(fs), fs);
+
+	id_map_free(proper_id_map(fs));
+	clean_after_dma_check(fs->fs_dev, &dma_info);
+
+	//clear_relocated_list();    
+
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck finished at %s" "###########\n", ctime(&t));
+
+	reiserfs_close(fs);
+	close_rollback_file();
+	exit(retval);
 }
 
-static int open_devices_for_rollback (char * file_name, 
-    struct fsck_data * data) 
+static int open_devices_for_rollback(char *file_name, struct fsck_data *data)
 {
-    int fd;
+	int fd;
 
-    fd = open (file_name, O_RDWR | O_LARGEFILE);
+	fd = open(file_name, O_RDWR | O_LARGEFILE);
 
-    if (fd == -1) {
-        reiserfs_warning (stderr, "reiserfsck: Cannot not open the fs "
-	    "partition %s\n", file_name);
+	if (fd == -1) {
+		reiserfs_warning(stderr, "reiserfsck: Cannot not open the fs "
+				 "partition %s\n", file_name);
 
-        return -1;
-    }
+		return -1;
+	}
 
-    fs = getmem (sizeof (*fs));
-    fs->fs_dev = fd;
-    fs->fs_vp = data;
-    asprintf (&fs->fs_file_name, "%s", file_name);
-
-    if (data->journal_dev_name && 
-	strcmp (data->journal_dev_name, file_name)) 
-    {
-	fs->fs_journal_dev = open (data->journal_dev_name, 
-	    O_RDWR | O_LARGEFILE);
-	if (fs->fs_journal_dev == -1) {
-	    reiserfs_warning (stderr, "Cannot open journal partition\n");
-     	    return -1;
+	fs = getmem(sizeof(*fs));
+	fs->fs_dev = fd;
+	fs->fs_vp = data;
+	asprintf(&fs->fs_file_name, "%s", file_name);
+
+	if (data->journal_dev_name && strcmp(data->journal_dev_name, file_name)) {
+		fs->fs_journal_dev = open(data->journal_dev_name,
+					  O_RDWR | O_LARGEFILE);
+		if (fs->fs_journal_dev == -1) {
+			reiserfs_warning(stderr,
+					 "Cannot open journal partition\n");
+			return -1;
+		}
 	}
-    }
 
-    if (open_rollback_file (state_rollback_file(fs), fsck_data(fs)->log))
-        return -1;
+	if (open_rollback_file(state_rollback_file(fs), fsck_data(fs)->log))
+		return -1;
 
-    return 0;    	
+	return 0;
 }
 
-static void fsck_rollback (reiserfs_filsys_t * fs) {
-    time_t t;
+static void fsck_rollback(reiserfs_filsys_t *fs)
+{
+	time_t t;
 
-    time (&t);
-    fsck_progress ("###########\n"
-	           "reiserfsck --rollback-fsck-changes started at %s"
-                   "###########\n", ctime (&t));
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck --rollback-fsck-changes started at %s"
+		      "###########\n", ctime(&t));
 
-    do_fsck_rollback (fs->fs_dev, fs->fs_journal_dev, fsck_progress_file (fs));
-    close_rollback_file ();
+	do_fsck_rollback(fs->fs_dev, fs->fs_journal_dev,
+			 fsck_progress_file(fs));
+	close_rollback_file();
 
-    close (fs->fs_journal_dev);
-    free (fs->fs_file_name);
-    fs->fs_file_name = 0;
-    close (fs->fs_dev);
-    freemem (fs);
+	close(fs->fs_journal_dev);
+	free(fs->fs_file_name);
+	fs->fs_file_name = 0;
+	close(fs->fs_dev);
+	freemem(fs);
 
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck finished at %s"
-		   "###########\n", ctime (&t));
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck finished at %s" "###########\n", ctime(&t));
 
-    exit(EXIT_FIXED);
+	exit(EXIT_FIXED);
 }
 
-int main (int argc, char * argv [])
+int main(int argc, char *argv[])
 {
-    char * file_name;
-    struct fsck_data * data;
-    struct rlimit rlim = {RLIM_INFINITY, RLIM_INFINITY};
-    char *width;
-    int retval;
-    int error;
-    
-    width = getenv("COLUMNS");
-    if ( width )
-	screen_width = atoi(width);
-    
-    if (screen_width == 0)
-	screen_width = 80; // We default to 80 characters wide screen
-    screen_width--;
-    screen_savebuffer_len=screen_width;
-    screen_savebuffer=getmem(screen_width+1);
-    memset(screen_savebuffer,0,screen_savebuffer_len+1);
-    
-    lost_found_dir_key.k2_dir_id = cpu_to_le32(lost_found_dir_key.k2_dir_id);
-    lost_found_dir_key.k2_objectid = cpu_to_le32(lost_found_dir_key.k2_objectid);
-    /* this is only needed (and works) when running under 2.4 on regular files */
-    if (setrlimit (RLIMIT_FSIZE, &rlim) == -1) {
-	reiserfs_warning (stderr, "Cannot change the system limit for file size "
-	    "with setrlimit: %s\n", strerror(errno));
-    }
+	char *file_name;
+	struct fsck_data *data;
+	struct rlimit rlim = { RLIM_INFINITY, RLIM_INFINITY };
+	char *width;
+	int retval;
+	int error;
+
+	width = getenv("COLUMNS");
+	if (width)
+		screen_width = atoi(width);
+
+	if (screen_width == 0)
+		screen_width = 80;	// We default to 80 characters wide screen
+	screen_width--;
+	screen_savebuffer_len = screen_width;
+	screen_savebuffer = getmem(screen_width + 1);
+	memset(screen_savebuffer, 0, screen_savebuffer_len + 1);
+
+	lost_found_dir_key.k2_dir_id =
+	    cpu_to_le32(lost_found_dir_key.k2_dir_id);
+	lost_found_dir_key.k2_objectid =
+	    cpu_to_le32(lost_found_dir_key.k2_objectid);
+	/* this is only needed (and works) when running under 2.4 on regular files */
+	if (setrlimit(RLIMIT_FSIZE, &rlim) == -1) {
+		reiserfs_warning(stderr,
+				 "Cannot change the system limit for file size "
+				 "with setrlimit: %s\n", strerror(errno));
+	}
 
-    data = getmem (sizeof (struct fsck_data));
+	data = getmem(sizeof(struct fsck_data));
 
-    file_name = parse_options (data, argc, argv);
+	file_name = parse_options(data, argc, argv);
 
-    if (data->mode != FSCK_AUTO)
-	print_banner ("reiserfsck");
+	if (data->mode != FSCK_AUTO)
+		print_banner("reiserfsck");
 
-    if (data->mode == DO_NOTHING) {
-	freemem (data);
-	exit(EXIT_OK);
-    }
+	if (data->mode == DO_NOTHING) {
+		freemem(data);
+		exit(EXIT_OK);
+	}
 
-    if (data->options & OPT_BACKGROUND) {
-	/* running in background reiserfsck appends progress information into
-           'fsck.run'. Logs get there if log file was not specified*/
-	data->options |= OPT_QUIET;
-	data->progress = fopen ("fsck.run", "a+");
-	if (!data->progress) {
-	    reiserfs_exit(EXIT_OPER, "reiserfsck: Cannot not open \"fsck.run\"");
+	if (data->options & OPT_BACKGROUND) {
+		/* running in background reiserfsck appends progress information into
+		   'fsck.run'. Logs get there if log file was not specified */
+		data->options |= OPT_QUIET;
+		data->progress = fopen("fsck.run", "a+");
+		if (!data->progress) {
+			reiserfs_exit(EXIT_OPER,
+				      "reiserfsck: Cannot not open \"fsck.run\"");
+		}
+
+		if (data->log == stdout)
+			/* no log file specifed - redirect log into 'fsck.run' */
+			data->log = data->progress;
+
+		retval = fork();
+		if (retval == -1) {
+			reiserfs_panic("reiserfsck: Fork failed: %s",
+				       strerror(errno));
+		} else if (retval != 0) {
+			exit(EXIT_OPER);
+		}
+		reiserfs_warning(stderr,
+				 "\nReiserfsck is running in background as "
+				 "[%d],\nmake sure that it gets all the confirmations from stdin "
+				 "that it requests.\n\n", getpid());
 	}
 
-	if (data->log == stdout)
-	    /* no log file specifed - redirect log into 'fsck.run' */
-	    data->log = data->progress;
+	/* This asks for confirmation also. */
+	if (data->mode != FSCK_AUTO)
+		warn_what_will_be_done(file_name, data);
 
-	retval = fork ();
-	if (retval == -1) {
-	    reiserfs_panic ("reiserfsck: Fork failed: %s", strerror(errno));
-	} else if (retval != 0) {
-	    exit(EXIT_OPER);
+	if (data->mode == FSCK_ROLLBACK_CHANGES) {
+		if (open_devices_for_rollback(file_name, data) == -1)
+			exit(EXIT_OPER);
+	} else {
+		fs = reiserfs_open(file_name, O_RDONLY, &error, data,
+				   data->mode != FSCK_SB);
+
+		if (error) {
+			reiserfs_exit(EXIT_OPER, "Failed to open the device "
+				      "'%s': %s\n\n", file_name,
+				      strerror(error));
+		}
+
+		if (data->mode != FSCK_SB) {
+			if (no_reiserfs_found(fs)) {
+				reiserfs_exit(EXIT_OPER,
+					      "Failed to open the filesystem.\n\n"
+					      "If the partition table has not been changed, "
+					      "and the partition is\nvalid  and  it really  "
+					      "contains  a reiserfs  partition,  then the\n"
+					      "superblock  is corrupted and you need to run "
+					      "this utility with\n--rebuild-sb.\n");
+			}
+			if (fsck_skip_journal(fs) &&
+			    !is_reiserfs_jr_magic_string(fs->fs_ondisk_sb)) {
+				reiserfs_warning(stderr,
+						 "Filesystem with default journal found, "
+						 "--no-journal-available is ignored\n");
+				fsck_data(fs)->options &= ~OPT_SKIP_JOURNAL;
+			}
+
+			if (!fsck_skip_journal(fs)) {
+				retval =
+				    reiserfs_open_journal(fs,
+							  data->
+							  journal_dev_name,
+							  O_RDONLY);
+
+				if (retval) {
+					fsck_progress
+					    ("Failed to open the journal device (%s).\n",
+					     data->journal_dev_name);
+
+					if (retval == 1) {
+						fsck_progress
+						    ("Run --rebuild-sb to rebuild journal parameters.\n");
+					}
+
+					reiserfs_close(fs);
+					exit(EXIT_OPER);
+				}
+			}
+
+			if (data->options & BADBLOCKS_FILE) {
+				if (create_badblock_bitmap(fs, badblocks_file)
+				    != 0)
+					exit(EXIT_OPER);
+			}
+
+			register_timer();
+		}
 	}
-	reiserfs_warning (stderr, "\nReiserfsck is running in background as "
-	    "[%d],\nmake sure that it gets all the confirmations from stdin "
-	    "that it requests.\n\n", getpid ());
-    }
 
-    /* This asks for confirmation also. */
-    if (data->mode != FSCK_AUTO)
-	warn_what_will_be_done(file_name, data);
-
-    if (data->mode == FSCK_ROLLBACK_CHANGES) {
-    	if (open_devices_for_rollback (file_name, data) == -1)
-    	    exit(EXIT_OPER);
-    } else {
-	fs = reiserfs_open (file_name, O_RDONLY, &error, data, 
-	    data->mode != FSCK_SB);
-		
-	if (error) {
-		reiserfs_exit(EXIT_OPER, "Failed to open the device "
-			      "'%s': %s\n\n", file_name, strerror(error));
-	} 
-	
-	if (data->mode != FSCK_SB) {
-	    if (no_reiserfs_found (fs)) {
-		reiserfs_exit(EXIT_OPER, "Failed to open the filesystem.\n\n"
-			      "If the partition table has not been changed, "
-			      "and the partition is\nvalid  and  it really  "
-			      "contains  a reiserfs  partition,  then the\n"
-			      "superblock  is corrupted and you need to run "
-			      "this utility with\n--rebuild-sb.\n");
-	    }
-	    if (fsck_skip_journal (fs) && 
-		!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb)) 
-	    {
-		reiserfs_warning (stderr, "Filesystem with default journal found, "
-			"--no-journal-available is ignored\n");
-		fsck_data(fs)->options &= ~OPT_SKIP_JOURNAL;
-	    }
-	
-	    if (!fsck_skip_journal (fs)) {
-		retval = reiserfs_open_journal(fs, data->journal_dev_name, O_RDONLY);
-		
-		if (retval) {
-	            fsck_progress ("Failed to open the journal device (%s).\n", 
-			data->journal_dev_name);
-		    
-		    if (retval == 1) {
-			    fsck_progress ("Run --rebuild-sb to rebuild journal parameters.\n");
-		    }
-		    
-		    reiserfs_close (fs);
-		    exit(EXIT_OPER);
-	        }
-	    }
-	
-	    if (data->options & BADBLOCKS_FILE) {
-		if (create_badblock_bitmap (fs, badblocks_file) != 0) 
-		    exit(EXIT_OPER);
-	    }
-	    
-	    register_timer();
-    	}
-    }
+	switch (data->mode) {
+	case FSCK_SB:
+		rebuild_sb(fs, file_name, data);
+		break;
 
-    switch (data->mode) {
-    case FSCK_SB:
-	rebuild_sb (fs, file_name, data);
-	break;
-    
-    case FSCK_AUTO:
-	/* perform some light-weight checks. If error, do fixable job. */
-	if (auto_check (fs))
-	    break;
-	data->mode = FSCK_FIX_FIXABLE;
-    case FSCK_CHECK:
-    case FSCK_FIX_FIXABLE:
-	check_fs (fs);
-	break;
-
-    case FSCK_REBUILD:
-    case DO_TEST:
-	rebuild_tree (fs);
-	break;
-
-    case FSCK_ROLLBACK_CHANGES:
-	fsck_rollback (fs);
- 	break;
-    case FSCK_CLEAN_ATTRIBUTES:
-	clean_attributes (fs);
-    }
-    
-    exit(EXIT_OPER);
-}
+	case FSCK_AUTO:
+		/* perform some light-weight checks. If error, do fixable job. */
+		if (auto_check(fs))
+			break;
+		data->mode = FSCK_FIX_FIXABLE;
+	case FSCK_CHECK:
+	case FSCK_FIX_FIXABLE:
+		check_fs(fs);
+		break;
+
+	case FSCK_REBUILD:
+	case DO_TEST:
+		rebuild_tree(fs);
+		break;
 
+	case FSCK_ROLLBACK_CHANGES:
+		fsck_rollback(fs);
+		break;
+	case FSCK_CLEAN_ATTRIBUTES:
+		clean_attributes(fs);
+	}
+
+	exit(EXIT_OPER);
+}
diff --git a/fsck/pass0.c b/fsck/pass0.c
index dd91699..8084494 100644
--- a/fsck/pass0.c
+++ b/fsck/pass0.c
@@ -5,8 +5,6 @@
 
 #include "fsck.h"
 
-
-
 /* 
  * Pass0 scans the used part of the partition. It creates two maps which will 
  * be used on the pass 1. These are a map of nodes looking like leaves and 
@@ -14,315 +12,314 @@
  * node pointers pointing to leaves. 
  */
 
-
 /* leaves */
-reiserfs_bitmap_t * leaves_bitmap;
+reiserfs_bitmap_t *leaves_bitmap;
 #define pass0_is_leaf(block) __is_marked (leaves, block)
 #define pass0_mark_leaf(block) __mark (leaves, block)
 
 /* nodes which are referred to from only one indirect item */
-reiserfs_bitmap_t * good_unfm_bitmap;
+reiserfs_bitmap_t *good_unfm_bitmap;
 #define pass0_is_good_unfm(block) __is_marked (good_unfm, block)
 #define pass0_mark_good_unfm(block) __mark (good_unfm, block)
 #define pass0_unmark_good_unfm(block) __unmark (good_unfm, block)
 
 /* nodes which are referred to from more than one indirect item */
-reiserfs_bitmap_t * bad_unfm_bitmap;
+reiserfs_bitmap_t *bad_unfm_bitmap;
 #define pass0_is_bad_unfm(block) __is_marked (bad_unfm, block)
 #define pass0_mark_bad_unfm(block) __mark (bad_unfm, block)
 #define pass0_unmark_bad_unfm(block) __unmark (bad_unfm, block)
 
-static int correct_direct_item_offset (__u64 offset, int format) {
-    if (format == KEY_FORMAT_2) {
-        return (offset && ((offset - 1) % 8 == 0));
-    } else {
-	return (offset);
-    }
-    return 0;
+static int correct_direct_item_offset(__u64 offset, int format)
+{
+	if (format == KEY_FORMAT_2) {
+		return (offset && ((offset - 1) % 8 == 0));
+	} else {
+		return (offset);
+	}
+	return 0;
 }
 
 /* bitmaps which are built on pass 0 and are used on pass 1 */
-static void make_aux_bitmaps (reiserfs_filsys_t * fs)
+static void make_aux_bitmaps(reiserfs_filsys_t *fs)
 {
-    struct reiserfs_super_block * sb;
+	struct reiserfs_super_block *sb;
 
-    sb = fs->fs_ondisk_sb;
+	sb = fs->fs_ondisk_sb;
 
-    /* bitmap of leaves found on the device */
-    leaves_bitmap = reiserfs_create_bitmap (get_sb_block_count (sb));
+	/* bitmap of leaves found on the device */
+	leaves_bitmap = reiserfs_create_bitmap(get_sb_block_count(sb));
 
-    good_unfm_bitmap = reiserfs_create_bitmap (get_sb_block_count (sb));
+	good_unfm_bitmap = reiserfs_create_bitmap(get_sb_block_count(sb));
 
-    bad_unfm_bitmap = reiserfs_create_bitmap (get_sb_block_count (sb));
+	bad_unfm_bitmap = reiserfs_create_bitmap(get_sb_block_count(sb));
 }
 
-
-void delete_aux_bitmaps (void)
+void delete_aux_bitmaps(void)
 {
-    reiserfs_delete_bitmap (leaves_bitmap);
-    reiserfs_delete_bitmap (good_unfm_bitmap);
-    reiserfs_delete_bitmap (bad_unfm_bitmap);
+	reiserfs_delete_bitmap(leaves_bitmap);
+	reiserfs_delete_bitmap(good_unfm_bitmap);
+	reiserfs_delete_bitmap(bad_unfm_bitmap);
 }
 
-
 /* register block some indirect item points to */
-static void register_unfm (unsigned long block)
+static void register_unfm(unsigned long block)
 {
-    if (!pass0_is_good_unfm (block) && !pass0_is_bad_unfm (block)) {
-	/* this block was not pointed by other indirect items yet */
-	pass0_mark_good_unfm (block);
-	return;
-    }
+	if (!pass0_is_good_unfm(block) && !pass0_is_bad_unfm(block)) {
+		/* this block was not pointed by other indirect items yet */
+		pass0_mark_good_unfm(block);
+		return;
+	}
 
-    if (pass0_is_good_unfm (block)) {
-	/* block was pointed once already, unmark it in bitmap of good
-           unformatted nodes and mark in bitmap of bad pointers */
-	pass0_unmark_good_unfm (block);
-	pass0_mark_bad_unfm (block);
-	return;
-    }
+	if (pass0_is_good_unfm(block)) {
+		/* block was pointed once already, unmark it in bitmap of good
+		   unformatted nodes and mark in bitmap of bad pointers */
+		pass0_unmark_good_unfm(block);
+		pass0_mark_bad_unfm(block);
+		return;
+	}
 
-    assert (pass0_is_bad_unfm (block));
+	assert(pass0_is_bad_unfm(block));
 }
 
-
 /* 'upper' item is correct if 'upper + 2' exists and its key is greater than
    key of 'upper' */
-static int upper_correct (struct buffer_head * bh, struct item_head * upper,
-			  int upper_item_num)
+static int upper_correct(struct buffer_head *bh, struct item_head *upper,
+			 int upper_item_num)
 {
-    if (upper_item_num + 2 < B_NR_ITEMS (bh)) {
-	if (comp_keys (&upper->ih_key, &(upper + 2)->ih_key) != -1)
-	    /* item-num's item is out of order of order */
-	    return 0;
-	return 1;
-    }
-    
-    /* there is no item above the "bad pair" */
-    return 2;
-}
+	if (upper_item_num + 2 < B_NR_ITEMS(bh)) {
+		if (comp_keys(&upper->ih_key, &(upper + 2)->ih_key) != -1)
+			/* item-num's item is out of order of order */
+			return 0;
+		return 1;
+	}
 
+	/* there is no item above the "bad pair" */
+	return 2;
+}
 
 /* 'lower' item is correct if 'lower - 2' exists and its key is smaller than
    key of 'lower' */
-static int lower_correct (struct buffer_head * bh, struct item_head * lower,
-			  int lower_item_num)
+static int lower_correct(struct buffer_head *bh, struct item_head *lower,
+			 int lower_item_num)
 {
-    if (lower_item_num - 2 >= 0) {
-	if (comp_keys (&(lower - 2)->ih_key, &lower->ih_key) != -1)
-	    return 0;
-	return 1;
-    }
-    return 2;
+	if (lower_item_num - 2 >= 0) {
+		if (comp_keys(&(lower - 2)->ih_key, &lower->ih_key) != -1)
+			return 0;
+		return 1;
+	}
+	return 2;
 }
 
-
 /* return 1 if something was changed */
-static int correct_key_format (struct item_head * ih, int symlink)
+static int correct_key_format(struct item_head *ih, int symlink)
 {
-    int dirty = 0;
-
-    if (is_stat_data_ih (ih)) {
-	/* for stat data we have no way to check whether key format in item
-	   head matches to the key format found from the key directly */
-	if (get_ih_item_len (ih) == SD_V1_SIZE) {
-	    if (get_ih_key_format (ih) != KEY_FORMAT_1) {
-		/*fsck_log ("correct_key_format: ih_key_format of (%H) is set to format 1\n",
-		  ih);*/
-		set_ih_key_format (ih, KEY_FORMAT_1);
-		return 1;
-	    }
-	    return 0;
+	int dirty = 0;
+
+	if (is_stat_data_ih(ih)) {
+		/* for stat data we have no way to check whether key format in item
+		   head matches to the key format found from the key directly */
+		if (get_ih_item_len(ih) == SD_V1_SIZE) {
+			if (get_ih_key_format(ih) != KEY_FORMAT_1) {
+				/*fsck_log ("correct_key_format: ih_key_format of (%H) is set to format 1\n",
+				   ih); */
+				set_ih_key_format(ih, KEY_FORMAT_1);
+				return 1;
+			}
+			return 0;
+		}
+		if (get_ih_item_len(ih) == SD_SIZE) {
+			if (get_ih_key_format(ih) != KEY_FORMAT_2) {
+				/*fsck_log ("correct_key_format: ih_key_format of (%H) is set to format 2\n",
+				   ih); */
+				set_ih_key_format(ih, KEY_FORMAT_2);
+				return 1;
+			}
+			return 0;
+		}
+
+		die("stat_data item of the wrong length");
 	}
-	if (get_ih_item_len (ih) == SD_SIZE) {
-	    if (get_ih_key_format (ih) != KEY_FORMAT_2) {
-		/*fsck_log ("correct_key_format: ih_key_format of (%H) is set to format 2\n",
-		  ih);*/
-		set_ih_key_format (ih, KEY_FORMAT_2);
-		return 1;
-	    }
-	    return 0;
+
+	if (symlink && is_direct_ih(ih)
+	    && (key_format(&ih->ih_key) != KEY_FORMAT_1)) {
+		/* All symlinks are of 3.5 format */
+		/*fsck_log ("correct_key_format: Symlink keys should be of 3.5 format. %k - fixed.\n", &ih->ih_key); */
+		set_type_and_offset(KEY_FORMAT_1, &ih->ih_key,
+				    get_offset(&ih->ih_key),
+				    get_type(&ih->ih_key));
 	}
-	
-	die ("stat_data item of the wrong length");
-    }
-    
-    if (symlink && is_direct_ih(ih) && (key_format(&ih->ih_key) != KEY_FORMAT_1)) {	
-	/* All symlinks are of 3.5 format */
-	/*fsck_log ("correct_key_format: Symlink keys should be of 3.5 format. %k - fixed.\n", &ih->ih_key); */
-	set_type_and_offset(KEY_FORMAT_1, &ih->ih_key, get_offset(&ih->ih_key), get_type(&ih->ih_key));
-    }
-	
-    if (key_format (&ih->ih_key) != get_ih_key_format (ih)) {
-	/*fsck_log ("correct_key_format: ih_key_format of (%H) is set to format found in the key\n",
-	  ih);*/
-	set_ih_key_format (ih, key_format (&ih->ih_key));
-	dirty = 1;
-    }
-    
-    if (is_direct_ih (ih) && get_offset (&ih->ih_key) > fs->fs_blocksize * 4) {
-	/*fsck_log ("correct_key_format: %H made of indirect type\n", ih);*/
-	set_type (key_format (&ih->ih_key), &ih->ih_key, TYPE_INDIRECT);
-	if (get_offset (&ih->ih_key) % fs->fs_blocksize != 1)
-	    fsck_log ("correct_key_format: Item header's key has the wrong offset %H\n", ih);
-	dirty = 1;
-    }
-    
-    return dirty;
+
+	if (key_format(&ih->ih_key) != get_ih_key_format(ih)) {
+		/*fsck_log ("correct_key_format: ih_key_format of (%H) is set to format found in the key\n",
+		   ih); */
+		set_ih_key_format(ih, key_format(&ih->ih_key));
+		dirty = 1;
+	}
+
+	if (is_direct_ih(ih) && get_offset(&ih->ih_key) > fs->fs_blocksize * 4) {
+		/*fsck_log ("correct_key_format: %H made of indirect type\n", ih); */
+		set_type(key_format(&ih->ih_key), &ih->ih_key, TYPE_INDIRECT);
+		if (get_offset(&ih->ih_key) % fs->fs_blocksize != 1)
+			fsck_log
+			    ("correct_key_format: Item header's key has the wrong offset %H\n",
+			     ih);
+		dirty = 1;
+	}
+
+	return dirty;
 }
 
 #if 0
 /* fixme: we might try all available hashes */
-static int prob_name (reiserfs_filsys_t * fs,
-		      char ** name, int max_len, __u32 deh_offset)
+static int prob_name(reiserfs_filsys_t *fs,
+		     char **name, int max_len, __u32 deh_offset)
 {
-    int start; /* */
-    int len;
-
-    for (start = 0; start < max_len; start ++) {
-	for (len = 0; len < max_len - start; len ++) {
-	    if (is_properly_hashed (fs, *name + start, len + 1, deh_offset)) {
-		*name = *name + start;
-		return len + 1;
-	    }
+	int start;		/* */
+	int len;
+
+	for (start = 0; start < max_len; start++) {
+		for (len = 0; len < max_len - start; len++) {
+			if (is_properly_hashed
+			    (fs, *name + start, len + 1, deh_offset)) {
+				*name = *name + start;
+				return len + 1;
+			}
+		}
 	}
-    }
-    return 0;
+	return 0;
 }
 #endif
 
-
-static void hash_hits_init (reiserfs_filsys_t * fs)
+static void hash_hits_init(reiserfs_filsys_t *fs)
 {
-    fsck_data (fs)->rebuild.hash_amount = known_hashes ();
-    fsck_data (fs)->rebuild.hash_hits = getmem (sizeof (unsigned long) * fsck_data (fs)->rebuild.hash_amount);
-    return;
+	fsck_data(fs)->rebuild.hash_amount = known_hashes();
+	fsck_data(fs)->rebuild.hash_hits =
+	    getmem(sizeof(unsigned long) * fsck_data(fs)->rebuild.hash_amount);
+	return;
 }
 
-
-static void add_hash_hit (reiserfs_filsys_t * fs, int hash_code)
+static void add_hash_hit(reiserfs_filsys_t *fs, int hash_code)
 {
-    fsck_data (fs)->rebuild.hash_hits [hash_code] ++;
+	fsck_data(fs)->rebuild.hash_hits[hash_code]++;
 }
 
-
 /* deh_location look reasonable, try to find name length. return 0 if
    we failed */
-static int try_to_get_name_length (struct item_head * ih, struct reiserfs_de_head * deh,
-				int i)
+static int try_to_get_name_length(struct item_head *ih,
+				  struct reiserfs_de_head *deh, int i)
 {
-    int len;
+	int len;
 
-    if (i == 0 || !de_bad_location (deh - 1)) {
-	len = name_in_entry_length (ih, deh, i);
-	return (len > 0) ? len : 0;
-    }
+	if (i == 0 || !de_bad_location(deh - 1)) {
+		len = name_in_entry_length(ih, deh, i);
+		return (len > 0) ? len : 0;
+	}
 
-    /* previous entry had bad location so we had no way to find
-       name length */
-    return 0;
+	/* previous entry had bad location so we had no way to find
+	   name length */
+	return 0;
 }
 
-
-
 /* define this if you are using -t to debug recovering of corrupted directory
    item */
 #define DEBUG_VERIFY_DENTRY
 #undef DEBUG_VERIFY_DENTRY
 
-
 /* check directory item and try to recover something */
-static int verify_directory_item (reiserfs_filsys_t * fs, struct buffer_head * bh,
-				  int item_num)
+static int verify_directory_item(reiserfs_filsys_t *fs, struct buffer_head *bh,
+				 int item_num)
 {
-    struct item_head * ih;
-    struct item_head tmp;
-    char * item;
-    struct reiserfs_de_head * deh;
-    char * name;
-    int name_len;
-    int bad, lost_found;
-    int i, j;
-    char buf[4096];
-    int hash_code;
-    int min_entry_size = 1;
+	struct item_head *ih;
+	struct item_head tmp;
+	char *item;
+	struct reiserfs_de_head *deh;
+	char *name;
+	int name_len;
+	int bad, lost_found;
+	int i, j;
+	char buf[4096];
+	int hash_code;
+	int min_entry_size = 1;
 
 #ifdef DEBUG_VERIFY_DENTRY
-    char * direntries;
+	char *direntries;
 #endif
 
+	ih = B_N_PITEM_HEAD(bh, item_num);
+	item = B_I_PITEM(bh, ih);
+	deh = (struct reiserfs_de_head *)item;
+
+	if ((get_ih_entry_count(ih) >
+	     (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size)))
+	    || (get_ih_entry_count(ih) == 0)) {
+		set_ih_entry_count(ih,
+				   (int)get_ih_item_len(ih) / (DEH_SIZE +
+							       min_entry_size));
+		mark_buffer_dirty(bh);
+	}
 
-    ih = B_N_PITEM_HEAD (bh, item_num);
-    item = B_I_PITEM (bh,ih);
-    deh = (struct reiserfs_de_head *)item;
-
-    if ( (get_ih_entry_count (ih) > (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size))) ||
-          (get_ih_entry_count (ih) == 0))
-    {
-        set_ih_entry_count (ih, (int)get_ih_item_len(ih) / (DEH_SIZE + min_entry_size));
-        mark_buffer_dirty (bh);
-    }
-
-    if (get_ih_entry_count (ih) == 0) {
-	delete_item (fs, bh, item_num);
-	return -1;
-    }
-
+	if (get_ih_entry_count(ih) == 0) {
+		delete_item(fs, bh, item_num);
+		return -1;
+	}
 
-    /* check deh_location */
-    for (i = 0; i < get_ih_entry_count (ih); i ++) {
-	/* silently fix deh_state */
-	if (get_deh_state (deh + i) != (1 << DEH_Visible2)) {
-	    set_deh_state (deh + i, (1 << DEH_Visible2));
-	    mark_buffer_dirty (bh);
+	/* check deh_location */
+	for (i = 0; i < get_ih_entry_count(ih); i++) {
+		/* silently fix deh_state */
+		if (get_deh_state(deh + i) != (1 << DEH_Visible2)) {
+			set_deh_state(deh + i, (1 << DEH_Visible2));
+			mark_buffer_dirty(bh);
+		}
+		if (dir_entry_bad_location(deh + i, ih, !i))
+			mark_de_bad_location(deh + i);
 	}
-	if (dir_entry_bad_location (deh + i, ih, !i))
-	    mark_de_bad_location (deh + i);
-    }    
 
 #ifdef DEBUG_VERIFY_DENTRY
-    direntries = getmem (ih_entry_count (ih) * sizeof (int));
-
-    printf ("Entries with bad locations within the directory: ");
-    for (i = 0; i < ih_entry_count (ih); i ++) {
-	if (de_bad_location (deh + i))
-	    printf ("%d ", i);
-    }
-    printf ("\n");
-#endif /* DEBUG_VERIFY_DENTRY */
+	direntries = getmem(ih_entry_count(ih) * sizeof(int));
 
+	printf("Entries with bad locations within the directory: ");
+	for (i = 0; i < ih_entry_count(ih); i++) {
+		if (de_bad_location(deh + i))
+			printf("%d ", i);
+	}
+	printf("\n");
+#endif /* DEBUG_VERIFY_DENTRY */
 
-    /* find entries names in which have mismatching deh_offset */
-    for (i = get_ih_entry_count (ih) - 1; i >= 0; i --) {
-	if (de_bad (deh + i))
-	    /* bad location */
-	    continue;
+	/* find entries names in which have mismatching deh_offset */
+	for (i = get_ih_entry_count(ih) - 1; i >= 0; i--) {
+		if (de_bad(deh + i))
+			/* bad location */
+			continue;
 
-	if (i) {
-	    if (get_deh_location (deh + i - 1) < get_deh_location (deh + i))
-		mark_de_bad_location (deh + i - 1);
-	}
+		if (i) {
+			if (get_deh_location(deh + i - 1) <
+			    get_deh_location(deh + i))
+				mark_de_bad_location(deh + i - 1);
+		}
 
-	name = name_in_entry (deh + i, i);
-	/* Although we found a name, we not always can get its length as
-           it depends on deh_location of previous entry. */
-	name_len = try_to_get_name_length (ih, deh + i, i);
+		name = name_in_entry(deh + i, i);
+		/* Although we found a name, we not always can get its length as
+		   it depends on deh_location of previous entry. */
+		name_len = try_to_get_name_length(ih, deh + i, i);
 
 #ifdef DEBUG_VERIFY_DENTRY
-	if (name_len == 0)
-	    printf ("Trying to find the name length for %d-th entry\n", i);
+		if (name_len == 0)
+			printf
+			    ("Trying to find the name length for %d-th entry\n",
+			     i);
 #endif /* DEBUG_VERIFY_DENTRY */
-	if (is_dot (name, name_len)) {
-	    if (i != 0)
-		fsck_log ("block %lu: item %d: \".\" must be the first entry, but it is the %d-th entry\n",
-			  bh->b_blocknr, item_num, i);
-	    /* check and fix "." */
-	    
-	    if (get_deh_offset (deh + i) != DOT_OFFSET) {
-		set_deh_offset (deh + i, DOT_OFFSET);
-		mark_buffer_dirty (bh);
-	    }
-	    /* "." must point to the directory it is in */
+		if (is_dot(name, name_len)) {
+			if (i != 0)
+				fsck_log
+				    ("block %lu: item %d: \".\" must be the first entry, but it is the %d-th entry\n",
+				     bh->b_blocknr, item_num, i);
+			/* check and fix "." */
+
+			if (get_deh_offset(deh + i) != DOT_OFFSET) {
+				set_deh_offset(deh + i, DOT_OFFSET);
+				mark_buffer_dirty(bh);
+			}
+			/* "." must point to the directory it is in */
 /*
 	    if (not_of_one_file (&(deh[i].deh2_dir_id), &(ih->ih_key))) {
 		fsck_log ("verify_direntry: block %lu, item %H has entry \".\" "
@@ -334,364 +331,413 @@ static int verify_directory_item (reiserfs_filsys_t * fs, struct buffer_head * b
 		mark_buffer_dirty (bh);
 	    }
 */
-	} else if (is_dot_dot (name, name_len)) {
-	    if (i != 1)
-		fsck_log ("block %lu: item %d: \"..\" is %d-th entry\n",
-			  bh->b_blocknr, item_num, i);
-	    
-	    /* check and fix ".." */
-	    if (get_deh_offset (deh + i) != DOT_DOT_OFFSET) {
-		set_deh_offset (deh + i, DOT_DOT_OFFSET);
-		mark_buffer_dirty (bh);
-	    }
-	} else {
-	    int min_length, max_length;
-
-	    /* check other name */
-
-	    if (name_len == 0) {
-		/* we do not know the length of name - we will try to find it */
-		min_length = 1;
-		max_length = item + get_ih_item_len (ih) - name;
-	    } else
-		/* we kow name length, so we will try only one name length */
-		min_length = max_length = name_len;
-
-	    hash_code = 0;
-
-	    for (j = min_length; j <= max_length; j ++) {
-		hash_code = find_hash_in_use (name, j, get_deh_offset (deh + i),
-					      get_sb_hash_code (fs->fs_ondisk_sb));
+		} else if (is_dot_dot(name, name_len)) {
+			if (i != 1)
+				fsck_log
+				    ("block %lu: item %d: \"..\" is %d-th entry\n",
+				     bh->b_blocknr, item_num, i);
+
+			/* check and fix ".." */
+			if (get_deh_offset(deh + i) != DOT_DOT_OFFSET) {
+				set_deh_offset(deh + i, DOT_DOT_OFFSET);
+				mark_buffer_dirty(bh);
+			}
+		} else {
+			int min_length, max_length;
+
+			/* check other name */
+
+			if (name_len == 0) {
+				/* we do not know the length of name - we will try to find it */
+				min_length = 1;
+				max_length = item + get_ih_item_len(ih) - name;
+			} else
+				/* we kow name length, so we will try only one name length */
+				min_length = max_length = name_len;
+
+			hash_code = 0;
+
+			for (j = min_length; j <= max_length; j++) {
+				hash_code =
+				    find_hash_in_use(name, j,
+						     get_deh_offset(deh + i),
+						     get_sb_hash_code(fs->
+								      fs_ondisk_sb));
 /*		add_hash_hit (fs, hash_code);*/
-		if (code2func (hash_code) != 0) {
-		    /* deh_offset matches to some hash of the name */
-		    if (fsck_hash_defined (fs) && 
-			hash_code != func2code (fs->fs_hash_function)) {
-			/* wrong hash selected - so we can skip this leaf */
-			return 1;
-		    }
-
-		    if (!name_len) {
-			fsck_log ("%s: block %lu, item %H: Found a name \"%.*s\" for %d-th entry "
-				  "matching to the hash %u.\n", __FUNCTION__,
-				  bh->b_blocknr, ih, j, name, i, get_deh_offset (deh + i));
-			/* FIXME: if next byte is 0 we think that the name is aligned to 8 byte boundary */
-			if (i) {
-			    set_deh_location (&deh[i - 1], get_deh_location (deh + i) +
-					    ((name[j] || fs->fs_format == REISERFS_FORMAT_3_5) ? j : ROUND_UP (j)));
-			    mark_de_good_location (deh + i - 1);
-			    mark_buffer_dirty (bh);
+				if (code2func(hash_code) != 0) {
+					/* deh_offset matches to some hash of the name */
+					if (fsck_hash_defined(fs) &&
+					    hash_code !=
+					    func2code(fs->fs_hash_function)) {
+						/* wrong hash selected - so we can skip this leaf */
+						return 1;
+					}
+
+					if (!name_len) {
+						fsck_log
+						    ("%s: block %lu, item %H: Found a name \"%.*s\" for %d-th entry "
+						     "matching to the hash %u.\n",
+						     __FUNCTION__,
+						     bh->b_blocknr, ih, j, name,
+						     i,
+						     get_deh_offset(deh + i));
+						/* FIXME: if next byte is 0 we think that the name is aligned to 8 byte boundary */
+						if (i) {
+							set_deh_location(&deh
+									 [i -
+									  1],
+									 get_deh_location
+									 (deh +
+									  i) +
+									 ((name
+									   [j]
+									   ||
+									   fs->
+									   fs_format
+									   ==
+									   REISERFS_FORMAT_3_5)
+									  ? j :
+									  ROUND_UP
+									  (j)));
+							mark_de_good_location
+							    (deh + i - 1);
+							mark_buffer_dirty(bh);
+						}
+					}
+					break;
+				}
 			}
-		    }
-		    break;
-		}
-	    }
 
-	    add_hash_hit (fs, hash_code);
+			add_hash_hit(fs, hash_code);
 
-	    if (j == max_length + 1) {
-		/* deh_offset does not match to anything. it will be
-		   deleted for now, but maybe we could just fix a
-		   deh_offset if it is in ordeer */
-		mark_de_bad_offset (deh + i);
-	    }
-	}
-    } /* for */
+			if (j == max_length + 1) {
+				/* deh_offset does not match to anything. it will be
+				   deleted for now, but maybe we could just fix a
+				   deh_offset if it is in ordeer */
+				mark_de_bad_offset(deh + i);
+			}
+		}
+	}			/* for */
 
 #ifdef DEBUG_VERIFY_DENTRY
-    printf ("Entries with mismatching hash: ");
-    for (i = 0; i < ih_entry_count (ih); i ++) {
-	if (de_bad_offset (deh + i))
-	    printf ("%d ", i);
-    }
-    printf ("\n");
+	printf("Entries with mismatching hash: ");
+	for (i = 0; i < ih_entry_count(ih); i++) {
+		if (de_bad_offset(deh + i))
+			printf("%d ", i);
+	}
+	printf("\n");
 #endif /* DEBUG_VERIFY_DENTRY */
 
-
-    /* correct deh_locations such that code cutting entries will not get
-       screwed up */
-    {
-	int prev_loc;
+	/* correct deh_locations such that code cutting entries will not get
+	   screwed up */
+	{
+		int prev_loc;
 #ifdef DEBUG_VERIFY_DENTRY
-	int loc_fixed;
+		int loc_fixed;
 #endif
 
-
-	prev_loc = get_ih_item_len (ih);
-	for (i = 0; i < get_ih_entry_count (ih); i ++) {
+		prev_loc = get_ih_item_len(ih);
+		for (i = 0; i < get_ih_entry_count(ih); i++) {
 #ifdef DEBUG_VERIFY_DENTRY
-	    loc_fixed = 0;
+			loc_fixed = 0;
 #endif
-	    if (de_bad_location (deh + i)) {
-		set_deh_location (deh + i, prev_loc/* - 1*/);
-		mark_buffer_dirty (bh);
+			if (de_bad_location(deh + i)) {
+				set_deh_location(deh + i, prev_loc /* - 1 */ );
+				mark_buffer_dirty(bh);
 #ifdef DEBUG_VERIFY_DENTRY
-		loc_fixed = 1;
+				loc_fixed = 1;
 #endif
-	    } else {
-		if (get_deh_location (deh + i) >= prev_loc) {
-		    set_deh_location (deh + i, prev_loc/* - 1*/);
-		    mark_buffer_dirty (bh);
+			} else {
+				if (get_deh_location(deh + i) >= prev_loc) {
+					set_deh_location(deh + i,
+							 prev_loc /* - 1 */ );
+					mark_buffer_dirty(bh);
 #ifdef DEBUG_VERIFY_DENTRY
-		    loc_fixed = 1;
+					loc_fixed = 1;
 #endif
-		}
-	    }
+				}
+			}
 
-	    prev_loc = get_deh_location (deh + i);
-	    
-	    if (i == get_ih_entry_count (ih) - 1) {
-		/* last entry starts right after an array of dir entry headers */
-		if (!de_bad (deh + i) &&
-		    get_deh_location (deh + i) != (DEH_SIZE * get_ih_entry_count (ih))) {
-		    /* free space in the directory item */
-		    fsck_log ("%s: block %lu, item %H: Directory item has a free space - deleting\n", 
-			__FUNCTION__, bh->b_blocknr, ih);
-		    cut_entry (fs, bh, item_num, get_ih_entry_count (ih), 0);
-		}
-		if (get_deh_location (deh + i) != (DEH_SIZE * get_ih_entry_count (ih))) {
-		    set_deh_location (&deh[i], (DEH_SIZE * get_ih_entry_count (ih)));
+			prev_loc = get_deh_location(deh + i);
+
+			if (i == get_ih_entry_count(ih) - 1) {
+				/* last entry starts right after an array of dir entry headers */
+				if (!de_bad(deh + i) &&
+				    get_deh_location(deh + i) !=
+				    (DEH_SIZE * get_ih_entry_count(ih))) {
+					/* free space in the directory item */
+					fsck_log
+					    ("%s: block %lu, item %H: Directory item has a free space - deleting\n",
+					     __FUNCTION__, bh->b_blocknr, ih);
+					cut_entry(fs, bh, item_num,
+						  get_ih_entry_count(ih), 0);
+				}
+				if (get_deh_location(deh + i) !=
+				    (DEH_SIZE * get_ih_entry_count(ih))) {
+					set_deh_location(&deh[i],
+							 (DEH_SIZE *
+							  get_ih_entry_count
+							  (ih)));
 #ifdef DEBUG_VERIFY_DENTRY
-		    loc_fixed = 1;
+					loc_fixed = 1;
 #endif
-		    mark_buffer_dirty (bh);
-		}
-	    }
-
+					mark_buffer_dirty(bh);
+				}
+			}
 #ifdef DEBUG_VERIFY_DENTRY
-	    if (loc_fixed)
-		direntries [i] = 1;
+			if (loc_fixed)
+				direntries[i] = 1;
 #endif
-	} /* for */
+		}		/* for */
 
 #ifdef DEBUG_VERIFY_DENTRY
-	printf ("Entries with fixed deh_locations: ");
-	for (i = 0; i < ih_entry_count (ih); i ++) {
-	    if (direntries [i])
-		printf ("%d ", i);
-	}
-	printf ("\n");
+		printf("Entries with fixed deh_locations: ");
+		for (i = 0; i < ih_entry_count(ih); i++) {
+			if (direntries[i])
+				printf("%d ", i);
+		}
+		printf("\n");
 #endif /* DEBUG_VERIFY_DENTRY */
 
-    }
+	}
 
 #ifdef DEBUG_VERIFY_DENTRY
-    printf (" N  location name\n");
-    for (i = 0; i < ih_entry_count (ih); i ++) {
-	if (de_bad (deh + i) ||
-	    (i && de_bad (deh + i - 1)) || /* previous entry marked bad */
-	    (i < ih_entry_count (ih) - 1 && de_bad (deh + i + 1))) { /* next entry is marked bad */
-	    /* print only entries to be deleted and their nearest neighbors */
-	    printf ("%3d: %8d ", i, deh_location (deh + i));
-	    if (de_bad (deh + i))
-		printf ("will be deleted\n");
-	    else
-		printf ("\"%.*s\"\n", name_in_entry_length (ih, deh + i, i),
-			name_in_entry (deh + i, i));
+	printf(" N  location name\n");
+	for (i = 0; i < ih_entry_count(ih); i++) {
+		if (de_bad(deh + i) || (i && de_bad(deh + i - 1)) ||	/* previous entry marked bad */
+		    (i < ih_entry_count(ih) - 1 && de_bad(deh + i + 1))) {	/* next entry is marked bad */
+			/* print only entries to be deleted and their nearest neighbors */
+			printf("%3d: %8d ", i, deh_location(deh + i));
+			if (de_bad(deh + i))
+				printf("will be deleted\n");
+			else
+				printf("\"%.*s\"\n",
+				       name_in_entry_length(ih, deh + i, i),
+				       name_in_entry(deh + i, i));
+		}
 	}
-    }
 #endif
 
-    bad = lost_found = 0;
-    tmp = *ih;
-
-    /* mark enries of /lost+found as bad */
-    deh = B_I_DEH (bh, ih);
-    for (i = 0; i < get_ih_entry_count (ih); i ++, deh ++) {
-	unsigned int dirid, objectid;
-
-	if (de_bad (deh))
-	    continue;
-
-	sprintf (buf, "%.*s", name_in_entry_length (ih, deh, i), name_in_entry (deh, i));
-	if (sscanf (buf, "%d_%d", &dirid, &objectid) != 2)
-	    continue;
-	
-	if (get_deh_dirid (deh) != dirid || get_deh_objectid (deh) != objectid)
-	    continue;
-	
-	/* entry in lost+found */
-//	printf ("%s - will be deleted\n", buf);
-	lost_found++;
-	mark_de_bad_offset (deh);
-    }
-
-    /* delete entries which are marked bad */
-    for (i = 0; i < get_ih_entry_count (ih); i ++) {
-	deh = B_I_DEH (bh, ih) + i;
-	if (de_bad (deh)) {
-	    bad ++;
-	    if (get_ih_entry_count (ih) == 1) {
-		delete_item (fs, bh, item_num);
-		break;
-	    } else {
-		cut_entry (fs, bh, item_num, i, 1);
-	    }
-	    i --;
+	bad = lost_found = 0;
+	tmp = *ih;
+
+	/* mark enries of /lost+found as bad */
+	deh = B_I_DEH(bh, ih);
+	for (i = 0; i < get_ih_entry_count(ih); i++, deh++) {
+		unsigned int dirid, objectid;
+
+		if (de_bad(deh))
+			continue;
+
+		sprintf(buf, "%.*s", name_in_entry_length(ih, deh, i),
+			name_in_entry(deh, i));
+		if (sscanf(buf, "%d_%d", &dirid, &objectid) != 2)
+			continue;
+
+		if (get_deh_dirid(deh) != dirid
+		    || get_deh_objectid(deh) != objectid)
+			continue;
+
+		/* entry in lost+found */
+//      printf ("%s - will be deleted\n", buf);
+		lost_found++;
+		mark_de_bad_offset(deh);
 	}
-    }
-    
-    if (bad == get_ih_entry_count (&tmp)) {
-	if (lost_found != bad) {
-	    fsck_log ("%s: block %lu, item %H: All entries were deleted from the directory\n", 
-		      __FUNCTION__, bh->b_blocknr, &tmp);	
+
+	/* delete entries which are marked bad */
+	for (i = 0; i < get_ih_entry_count(ih); i++) {
+		deh = B_I_DEH(bh, ih) + i;
+		if (de_bad(deh)) {
+			bad++;
+			if (get_ih_entry_count(ih) == 1) {
+				delete_item(fs, bh, item_num);
+				break;
+			} else {
+				cut_entry(fs, bh, item_num, i, 1);
+			}
+			i--;
+		}
 	}
-	return -1;
-    }
-
-    deh = B_I_DEH (bh, ih);
-    if (get_offset (&ih->ih_key) != get_deh_offset (deh)) {
-	fsck_log ("verify_direntry: block %lu, item %H: Key's offset %k must match the directory's hash (%u) - changed.\n",
-		  bh->b_blocknr, ih, &ih->ih_key, get_deh_offset (deh));
-	set_offset (key_format (&ih->ih_key), &ih->ih_key, get_deh_offset (deh));
-	mark_buffer_dirty (bh);
-    }
-    
-    if (bad > lost_found)
-	fsck_log ("pass0: block %lu, item %H: %d entries were deleted\n",
-		  bh->b_blocknr, &tmp, bad - lost_found);
-	
-    return 0;
 
-}
+	if (bad == get_ih_entry_count(&tmp)) {
+		if (lost_found != bad) {
+			fsck_log
+			    ("%s: block %lu, item %H: All entries were deleted from the directory\n",
+			     __FUNCTION__, bh->b_blocknr, &tmp);
+		}
+		return -1;
+	}
+
+	deh = B_I_DEH(bh, ih);
+	if (get_offset(&ih->ih_key) != get_deh_offset(deh)) {
+		fsck_log
+		    ("verify_direntry: block %lu, item %H: Key's offset %k must match the directory's hash (%u) - changed.\n",
+		     bh->b_blocknr, ih, &ih->ih_key, get_deh_offset(deh));
+		set_offset(key_format(&ih->ih_key), &ih->ih_key,
+			   get_deh_offset(deh));
+		mark_buffer_dirty(bh);
+	}
+
+	if (bad > lost_found)
+		fsck_log("pass0: block %lu, item %H: %d entries were deleted\n",
+			 bh->b_blocknr, &tmp, bad - lost_found);
+
+	return 0;
 
+}
 
-static __inline__ int does_it_fit_into_dev (__u64 offset, __u64 fs_size) {
+static __inline__ int does_it_fit_into_dev(__u64 offset, __u64 fs_size)
+{
 /* 
    Count of unformatted pointers - offset / blocksize
    Count of blocks to store them - UNFM_P_SIZE * offset / blocksize / MAX_ITEM_LEN
    Size to store it              - blocksize * UNFM_P_SIZE * offset / blocksize / MAX_ITEM_LEN
 */
-   return ( UNFM_P_SIZE * offset / MAX_ITEM_LEN(fs->fs_blocksize) < fs_size) ? 1 : 0;
+	return (UNFM_P_SIZE * offset / MAX_ITEM_LEN(fs->fs_blocksize) <
+		fs_size) ? 1 : 0;
 }
 
+static int is_wrong_short_key(struct reiserfs_key *key)
+{
+	if (get_key_dirid(key) == 0 || get_key_objectid(key) == 0
+	    || get_key_objectid(key) == 1 || get_key_dirid(key) == ~(__u32) 0
+	    || get_key_objectid(key) == ~(__u32) 0
+	    || get_key_dirid(key) == get_key_objectid(key) ||
+	    /* the alloc=packing_groups used to allow dirid = 1
+	       (get_key_dirid (key) == 1 && get_key_objectid (key) != 2) || */
+	    (get_key_dirid(key) != 1 && get_key_objectid(key) == 2))
+		return 1;
 
-static int is_wrong_short_key (struct reiserfs_key *key) {
-    if (get_key_dirid (key) == 0 || get_key_objectid (key) == 0 || get_key_objectid (key) == 1 ||
-	get_key_dirid (key) == ~(__u32)0 || get_key_objectid (key) == ~(__u32)0 ||
-	get_key_dirid (key) == get_key_objectid (key) ||
-	/* the alloc=packing_groups used to allow dirid = 1
-	(get_key_dirid (key) == 1 && get_key_objectid (key) != 2) || */
-	(get_key_dirid (key) != 1 && get_key_objectid (key) == 2) )
-	return 1;
-
-    return 0;
+	return 0;
 }
 
 /* 1 if some of fields in the block head of bh look bad */
-int leaf_structure_check (reiserfs_filsys_t * fs, struct buffer_head * bh) {
-    struct block_head * blkh;
-    int free_space, counted;
-
-    blkh = B_BLK_HEAD (bh);
-    
-    if (!is_leaf_block_head(bh->b_data)) {
-	/* We should not get here on rebuild. */
-	fsck_log ("block %lu: The block does not look like a leaf.\n", bh->b_blocknr);
-        one_more_corruption (fs, FATAL);
-	return 1;
-    }
+int leaf_structure_check(reiserfs_filsys_t *fs, struct buffer_head *bh)
+{
+	struct block_head *blkh;
+	int free_space, counted;
 
-    if (get_blkh_nr_items (blkh) == 0)
-	return 0;
-    
-    counted = leaf_count_ih(bh->b_data, bh->b_size);
-
-    if (counted < get_blkh_nr_items (blkh)) {
-	fsck_log ("block %lu: The number of items (%lu) is incorrect, should be (%lu)",
-		bh->b_blocknr, get_blkh_nr_items(blkh), counted);
-	if (fsck_mode(fs) == FSCK_REBUILD) {
-	    set_blkh_nr_items(blkh, counted);	    
-	    fsck_log (" - corrected\n");
-	    mark_buffer_dirty (bh);
-	} else {
-	    fsck_log ("\n");
-	    one_more_corruption (fs, FATAL);
-	    return 1;
+	blkh = B_BLK_HEAD(bh);
+
+	if (!is_leaf_block_head(bh->b_data)) {
+		/* We should not get here on rebuild. */
+		fsck_log("block %lu: The block does not look like a leaf.\n",
+			 bh->b_blocknr);
+		one_more_corruption(fs, FATAL);
+		return 1;
 	}
-    }
-    
-    free_space = leaf_free_space_estimate(bh->b_data, bh->b_size);
-    if (get_blkh_free_space (blkh) != free_space) {
-	fsck_log ("block %lu: The free space (%lu) is incorrect, should be (%lu)",
-		bh->b_blocknr, get_blkh_free_space (blkh), free_space);
-	
-	if (fsck_mode(fs) != FSCK_CHECK && fsck_mode(fs) != FSCK_AUTO) {
-	    set_blkh_free_space (blkh, free_space);	    
-	    fsck_log (" - corrected\n");
-	    mark_buffer_dirty (bh);
-	} else {
-	    fsck_log ("\n");
-	    one_more_corruption (fs, FIXABLE);
-	    return 1;
+
+	if (get_blkh_nr_items(blkh) == 0)
+		return 0;
+
+	counted = leaf_count_ih(bh->b_data, bh->b_size);
+
+	if (counted < get_blkh_nr_items(blkh)) {
+		fsck_log
+		    ("block %lu: The number of items (%lu) is incorrect, should be (%lu)",
+		     bh->b_blocknr, get_blkh_nr_items(blkh), counted);
+		if (fsck_mode(fs) == FSCK_REBUILD) {
+			set_blkh_nr_items(blkh, counted);
+			fsck_log(" - corrected\n");
+			mark_buffer_dirty(bh);
+		} else {
+			fsck_log("\n");
+			one_more_corruption(fs, FATAL);
+			return 1;
+		}
+	}
+
+	free_space = leaf_free_space_estimate(bh->b_data, bh->b_size);
+	if (get_blkh_free_space(blkh) != free_space) {
+		fsck_log
+		    ("block %lu: The free space (%lu) is incorrect, should be (%lu)",
+		     bh->b_blocknr, get_blkh_free_space(blkh), free_space);
+
+		if (fsck_mode(fs) != FSCK_CHECK && fsck_mode(fs) != FSCK_AUTO) {
+			set_blkh_free_space(blkh, free_space);
+			fsck_log(" - corrected\n");
+			mark_buffer_dirty(bh);
+		} else {
+			fsck_log("\n");
+			one_more_corruption(fs, FIXABLE);
+			return 1;
+		}
 	}
-    }
 
-    return 0;
+	return 0;
 }
 
 /* do this on pass 0 with every leaf marked used */
 
 /* FIXME: we can improve fixing of broken keys: we can ssfe direct items which
    go after stat data and have broken keys */
-static void pass0_correct_leaf (reiserfs_filsys_t * fs,
-				struct buffer_head * bh)
+static void pass0_correct_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    int file_format = KEY_FORMAT_UNDEFINED;
-    struct item_head * ih;
-    
-    __u32 * ind_item;
-    __u64 fs_size;
-    __u64 offset;
-    int symlnk = 0;
-    
-    unsigned long unfm_ptr;
+	int file_format = KEY_FORMAT_UNDEFINED;
+	struct item_head *ih;
+
+	__u32 *ind_item;
+	__u64 fs_size;
+	__u64 offset;
+	int symlnk = 0;
+
+	unsigned long unfm_ptr;
 //    unsigned int nr_items;
-    int i, j, nr_items;
-    int dirty = 0;
+	int i, j, nr_items;
+	int dirty = 0;
 
-    leaf_structure_check(fs, bh);
+	leaf_structure_check(fs, bh);
 
-    /* Delete all safe links. */
-    for (i = get_blkh_nr_items (B_BLK_HEAD (bh)) - 1; i >= 0; i--) {
-	if (get_key_dirid (&B_N_PITEM_HEAD (bh, i)->ih_key) == ~(__u32)0) {
-	    delete_item (fs, bh, i);
-	}
-	if (get_key_dirid (&B_N_PITEM_HEAD (bh, i)->ih_key) == BADBLOCK_DIRID && 
-	    get_key_objectid (&B_N_PITEM_HEAD (bh, i)->ih_key) == BADBLOCK_OBJID) {
-		delete_item (fs, bh, i);
+	/* Delete all safe links. */
+	for (i = get_blkh_nr_items(B_BLK_HEAD(bh)) - 1; i >= 0; i--) {
+		if (get_key_dirid(&B_N_PITEM_HEAD(bh, i)->ih_key) == ~(__u32) 0) {
+			delete_item(fs, bh, i);
+		}
+		if (get_key_dirid(&B_N_PITEM_HEAD(bh, i)->ih_key) ==
+		    BADBLOCK_DIRID
+		    && get_key_objectid(&B_N_PITEM_HEAD(bh, i)->ih_key) ==
+		    BADBLOCK_OBJID) {
+			delete_item(fs, bh, i);
+		}
 	}
-    }
 
-    fs_size = (__u64)fs->fs_blocksize * get_sb_block_count (fs->fs_ondisk_sb);
+	fs_size =
+	    (__u64) fs->fs_blocksize * get_sb_block_count(fs->fs_ondisk_sb);
 
- start_again:
+start_again:
 
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < (nr_items = get_blkh_nr_items (B_BLK_HEAD (bh))); i ++, ih ++) {
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < (nr_items = get_blkh_nr_items(B_BLK_HEAD(bh)));
+	     i++, ih++) {
 
-	if (is_indirect_ih(ih) && (get_ih_item_len (ih) % 4 != 0)) {
-	    set_type(get_ih_key_format(ih), &ih->ih_key, TYPE_UNKNOWN);
-	    dirty = 1;
-	}
-	    
-        if (type_unknown (&ih->ih_key)) {
-            if ((get_ih_item_len (ih) == SD_SIZE) || (get_ih_item_len (ih) == SD_V1_SIZE)) {
-                set_type_and_offset (KEY_FORMAT_1, &ih->ih_key, SD_OFFSET, TYPE_STAT_DATA);
-		dirty = 1;
-                fsck_log("pass0: vpf-10100: block %lu, item (%d): Unknown item type of StatData size,"
-                    " type set to StatData %k\n", bh->b_blocknr, i, &ih->ih_key);
-            } else {            
-                fsck_log("pass0: vpf-10110: block %lu, item (%d): Unknown item type found %k - deleted\n",
-                        bh->b_blocknr, i, &ih->ih_key);
-                delete_item (fs, bh, i);
-                goto start_again;
-            }
-        }
+		if (is_indirect_ih(ih) && (get_ih_item_len(ih) % 4 != 0)) {
+			set_type(get_ih_key_format(ih), &ih->ih_key,
+				 TYPE_UNKNOWN);
+			dirty = 1;
+		}
+
+		if (type_unknown(&ih->ih_key)) {
+			if ((get_ih_item_len(ih) == SD_SIZE)
+			    || (get_ih_item_len(ih) == SD_V1_SIZE)) {
+				set_type_and_offset(KEY_FORMAT_1, &ih->ih_key,
+						    SD_OFFSET, TYPE_STAT_DATA);
+				dirty = 1;
+				fsck_log
+				    ("pass0: vpf-10100: block %lu, item (%d): Unknown item type of StatData size,"
+				     " type set to StatData %k\n",
+				     bh->b_blocknr, i, &ih->ih_key);
+			} else {
+				fsck_log
+				    ("pass0: vpf-10110: block %lu, item (%d): Unknown item type found %k - deleted\n",
+				     bh->b_blocknr, i, &ih->ih_key);
+				delete_item(fs, bh, i);
+				goto start_again;
+			}
+		}
+
+		if (is_wrong_short_key(&ih->ih_key)) {
+			/* sometimes stat datas get k_objectid==0 or k_dir_id==0 */
 
-	if (is_wrong_short_key (&ih->ih_key)) {
-	    /* sometimes stat datas get k_objectid==0 or k_dir_id==0 */
-	    
 /*	    if (i == (nr_items - 1)) {
 		
 		if (i == 0) {
@@ -707,199 +753,312 @@ static void pass0_correct_leaf (reiserfs_filsys_t * fs,
 	    }
 */
 
-            /* FIXME:
-		18842 19034    0x1 IND  (2)
-		19035 19035    0x0 SD   (0)
-		18842     1    0x1 IND  (1)
-		18842     1 0x1001 DRCT (2)
-             */
-	    /* there is next item: if it is not stat data - take its k_dir_id
-               and k_objectid. if key order will be still wrong - the changed
-               item will be deleted */
-
-	    if (i && !is_stat_data_ih (ih)) {
-	        /* previous item has a wrong short_key */
-		fsck_log ("pass0: vpf-10120: block %lu: item %d: Wrong key %k, corrected to ", 
-		    bh->b_blocknr, i, &ih->ih_key);
-		set_key_dirid (&ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		fsck_log ("%k\n", &ih->ih_key);
-		dirty = 1;
-	    } else if ((i < nr_items - 1) && !is_stat_data_ih (ih + 1)) {
-	        if (!is_wrong_short_key(&(ih + 1)->ih_key)) {
-		    fsck_log ("pass0: vpf-10130: block %lu: item %d: Wrong key %k, corrected to ", 
-			bh->b_blocknr, i, &ih->ih_key);
-		    set_key_dirid (&ih->ih_key, get_key_dirid (&(ih + 1)->ih_key));
-		    set_key_objectid (&ih->ih_key, get_key_objectid (&(ih + 1)->ih_key));
+			/* FIXME:
+			   18842 19034    0x1 IND  (2)
+			   19035 19035    0x0 SD   (0)
+			   18842     1    0x1 IND  (1)
+			   18842     1 0x1001 DRCT (2)
+			 */
+			/* there is next item: if it is not stat data - take its k_dir_id
+			   and k_objectid. if key order will be still wrong - the changed
+			   item will be deleted */
+
+			if (i && !is_stat_data_ih(ih)) {
+				/* previous item has a wrong short_key */
+				fsck_log
+				    ("pass0: vpf-10120: block %lu: item %d: Wrong key %k, corrected to ",
+				     bh->b_blocknr, i, &ih->ih_key);
+				set_key_dirid(&ih->ih_key,
+					      get_key_dirid(&(ih - 1)->ih_key));
+				set_key_objectid(&ih->ih_key,
+						 get_key_objectid(&(ih - 1)->
+								  ih_key));
+				fsck_log("%k\n", &ih->ih_key);
+				dirty = 1;
+			} else if ((i < nr_items - 1)
+				   && !is_stat_data_ih(ih + 1)) {
+				if (!is_wrong_short_key(&(ih + 1)->ih_key)) {
+					fsck_log
+					    ("pass0: vpf-10130: block %lu: item %d: Wrong key %k, corrected to ",
+					     bh->b_blocknr, i, &ih->ih_key);
+					set_key_dirid(&ih->ih_key,
+						      get_key_dirid(&(ih + 1)->
+								    ih_key));
+					set_key_objectid(&ih->ih_key,
+							 get_key_objectid(&
+									  (ih +
+									   1)->
+									  ih_key));
 /*		    set_offset (KEY_FORMAT_1, &ih->ih_key, 0);
 		    set_type (KEY_FORMAT_1, &ih->ih_key, TYPE_STAT_DATA);*/
-		    fsck_log ("%k\n", &ih->ih_key);
-		    dirty = 1;
-		    goto start_again;
-		} else {
-	            fsck_log ("pass0: vpf-10140: block %lu: items %d and %d have bad short keys %k, %k, both deleted\n",
-			      bh->b_blocknr, i, i+1, &ih->ih_key, &(ih + 1)->ih_key);
-		    delete_item (fs, bh, i);
-		    delete_item (fs, bh, i);
-		    goto start_again;
+					fsck_log("%k\n", &ih->ih_key);
+					dirty = 1;
+					goto start_again;
+				} else {
+					fsck_log
+					    ("pass0: vpf-10140: block %lu: items %d and %d have bad short keys %k, %k, both deleted\n",
+					     bh->b_blocknr, i, i + 1,
+					     &ih->ih_key, &(ih + 1)->ih_key);
+					delete_item(fs, bh, i);
+					delete_item(fs, bh, i);
+					goto start_again;
+				}
+			} else {
+				fsck_log
+				    ("pass0: vpf-10150: block %lu: item %d: Wrong key %k, deleted\n",
+				     bh->b_blocknr, i, &ih->ih_key);
+				delete_item(fs, bh, i);
+				goto start_again;
+			}
 		}
-	    } else {
-                fsck_log ("pass0: vpf-10150: block %lu: item %d: Wrong key %k, deleted\n",
-			      bh->b_blocknr, i, &ih->ih_key);
-		delete_item (fs, bh, i);
-		goto start_again;
-	    } 
-	}
-
 
-	if (i && i + 1 < nr_items) {
-            if (is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih) &&
-                !is_direct_ih (ih + 1) && !is_stat_data_ih (ih + 1)) {
-                /* i or i+1 item should be SD or i+1 should be direct item */
-                if ((get_ih_item_len (ih) == SD_SIZE) || (get_ih_item_len (ih) == SD_V1_SIZE)) {
-                    /* make i as SD */
-                    fsck_log("pass0: vpf-10400: block %lu, item %d: Wrong order of items - "
-			"change the type of the key %k to StatData\n",  bh->b_blocknr, i, &ih->ih_key);
-                    set_type_and_offset (KEY_FORMAT_1, &ih->ih_key, SD_OFFSET, TYPE_STAT_DATA);
-		    dirty = 1;
-                } else if ((get_ih_item_len (ih+1) == SD_SIZE) || (get_ih_item_len (ih+1) == SD_V1_SIZE)) {
-                    /* make i+1 as SD */
-                    fsck_log("pass0: vpf-10410: block %lu, item %d: Wrong order of items - "
-			"change the type of the key %k to StatData\n", bh->b_blocknr, i + 1, &(ih + 1)->ih_key);
-                    set_type_and_offset (KEY_FORMAT_1, &(ih + 1)->ih_key, SD_OFFSET, TYPE_STAT_DATA);
-		    dirty = 1;
-                } else if (is_indirect_ih(ih)) {
-                    fsck_log("pass0: vpf-10420: block %lu, item %d: Wrong order of items - "
-			"change the type of the key %k to Direct\n", bh->b_blocknr, i+1, &(ih + 1)->ih_key);
-                    set_type (get_ih_key_format(ih+1), &(ih + 1)->ih_key, TYPE_DIRECT);
-		    dirty = 1;
-                }
-            }
-        }
-
-	if (i && ((is_stat_data_ih (ih - 1) &&
- 		   !is_stat_data_ih (ih) &&
-	           (get_key_dirid (&(ih - 1)->ih_key) != get_key_dirid (&ih->ih_key))) ||
-	          (is_stat_data_ih (ih) &&
-	           (get_key_dirid (&(ih - 1)->ih_key) > get_key_dirid (&ih->ih_key)))))
-        {
-            /* not the same dir_id of the same file or not increasing dir_id of different files */
-            if ((i > 1) && get_key_dirid (&(ih - 2)->ih_key) == get_key_dirid (&(ih - 1)->ih_key)) {
-                /* fix i-th */
-                if (!is_stat_data_ih (ih)) {
-                    fsck_log("pass0: vpf-10430: block %lu, item %d: Wrong order of items - "
-			"change the dir_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i, &ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		    set_key_dirid (&ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		    dirty = 1;
-                } else if (i + 1 < nr_items) {
-                    fsck_log("pass0: vpf-10440: block %lu, item %d: Wrong order of items - "
-			"change the dir_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i, &ih->ih_key, get_key_dirid (&(ih + 1)->ih_key));
-		    set_key_dirid (&ih->ih_key, get_key_dirid (&(ih + 1)->ih_key));
-		    dirty = 1;
-                }
-            } else 	
-            if ((i + 1 < nr_items) && get_key_dirid (&ih->ih_key) == get_key_dirid (&(ih + 1)->ih_key)) {
-                fsck_log("pass0: vpf-10450: block %lu, item %d: Wrong order of items - "
-		    "change the dir_id of the key %k to %lu\n",
-                    bh->b_blocknr, i - 1, &(ih - 1)->ih_key, get_key_dirid (&ih->ih_key));
-                /* fix (i - 1)-th */
-		set_key_dirid (&(ih - 1)->ih_key, get_key_dirid (&ih->ih_key));
-		dirty = 1;
-            }	
-        }
-
- 	if (i && i + 1 < nr_items) {
-      	    /* there is a previous and a next items */
-	    if ((get_key_dirid (&(ih - 1)->ih_key) == get_key_dirid (&(ih + 1)->ih_key)) &&
-		(get_key_dirid (&(ih - 1)->ih_key) != get_key_dirid (&ih->ih_key)))
-	    {
-                fsck_log("pass0: vpf-10460: block %lu, item %d: Wrong order of items - "
-		    "change the dir_id of the key %k to %lu\n",
-                    bh->b_blocknr, i, &ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		set_key_dirid (&ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		dirty = 1;
-            }
-            if (is_stat_data_ih (ih - 1) && is_indirect_ih (ih) && is_direct_ih (ih + 1)) {
-	    	if ((get_key_objectid (&(ih - 1)->ih_key) == get_key_objectid (&(ih + 1)->ih_key)) &&
-		    (get_key_objectid (&(ih - 1)->ih_key) != get_key_objectid (&ih->ih_key)))
-            	{
-		    fsck_log("pass0: vpf-10470: block %lu, item %d: Wrong order of items - "
-			"change the object_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i, &ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		    set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		    dirty = 1;
-		}
-	    	if ((get_key_objectid (&(ih - 1)->ih_key) == get_key_objectid (&ih->ih_key)) &&
-		    (get_key_objectid (&(ih - 1)->ih_key) != get_key_objectid (&(ih + 1)->ih_key)))
-            	{
-		    fsck_log("pass0: vpf-10480: block %lu, item %d: Wrong order of items - "
-			"change the object_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i + 1, &(ih+1)->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		    set_key_objectid (&(ih + 1)->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		    dirty = 1;
-		}
-	    	if ((get_key_objectid (&ih->ih_key) == get_key_objectid (&(ih + 1)->ih_key)) &&
-		    (get_key_objectid (&(ih - 1)->ih_key) != get_key_objectid (&(ih + 1)->ih_key)))
-            	{
-		    fsck_log("pass0: vpf-10490: block %lu, item %d: Wrong order of items - "
-			"change the object_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i - 1, &(ih-1)->ih_key, get_key_objectid (&(ih + 1)->ih_key));
-		    set_key_objectid (&(ih - 1)->ih_key, get_key_objectid (&(ih + 1)->ih_key));
-		    dirty = 1;
+		if (i && i + 1 < nr_items) {
+			if (is_stat_data_ih(ih - 1) && !is_stat_data_ih(ih) &&
+			    !is_direct_ih(ih + 1) && !is_stat_data_ih(ih + 1)) {
+				/* i or i+1 item should be SD or i+1 should be direct item */
+				if ((get_ih_item_len(ih) == SD_SIZE)
+				    || (get_ih_item_len(ih) == SD_V1_SIZE)) {
+					/* make i as SD */
+					fsck_log
+					    ("pass0: vpf-10400: block %lu, item %d: Wrong order of items - "
+					     "change the type of the key %k to StatData\n",
+					     bh->b_blocknr, i, &ih->ih_key);
+					set_type_and_offset(KEY_FORMAT_1,
+							    &ih->ih_key,
+							    SD_OFFSET,
+							    TYPE_STAT_DATA);
+					dirty = 1;
+				} else if ((get_ih_item_len(ih + 1) == SD_SIZE)
+					   || (get_ih_item_len(ih + 1) ==
+					       SD_V1_SIZE)) {
+					/* make i+1 as SD */
+					fsck_log
+					    ("pass0: vpf-10410: block %lu, item %d: Wrong order of items - "
+					     "change the type of the key %k to StatData\n",
+					     bh->b_blocknr, i + 1,
+					     &(ih + 1)->ih_key);
+					set_type_and_offset(KEY_FORMAT_1,
+							    &(ih + 1)->ih_key,
+							    SD_OFFSET,
+							    TYPE_STAT_DATA);
+					dirty = 1;
+				} else if (is_indirect_ih(ih)) {
+					fsck_log
+					    ("pass0: vpf-10420: block %lu, item %d: Wrong order of items - "
+					     "change the type of the key %k to Direct\n",
+					     bh->b_blocknr, i + 1,
+					     &(ih + 1)->ih_key);
+					set_type(get_ih_key_format(ih + 1),
+						 &(ih + 1)->ih_key,
+						 TYPE_DIRECT);
+					dirty = 1;
+				}
+			}
 		}
-		if ((get_key_dirid (&(ih - 1)->ih_key) == get_key_dirid (&ih->ih_key)) &&
-		    (get_key_dirid (&(ih - 1)->ih_key) != get_key_dirid (&(ih + 1)->ih_key)))
-	    	{
-		    fsck_log("pass0: vpf-10500: block %lu, item %d: Wrong order of items - "
-			"change the dir_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i + 1, &(ih+1)->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		    set_key_dirid (&(ih + 1)->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		    dirty = 1;
+
+		if (i && ((is_stat_data_ih(ih - 1) &&
+			   !is_stat_data_ih(ih) &&
+			   (get_key_dirid(&(ih - 1)->ih_key) !=
+			    get_key_dirid(&ih->ih_key))) || (is_stat_data_ih(ih)
+							     &&
+							     (get_key_dirid
+							      (&(ih - 1)->
+							       ih_key) >
+							      get_key_dirid
+							      (&ih->
+							       ih_key))))) {
+			/* not the same dir_id of the same file or not increasing dir_id of different files */
+			if ((i > 1)
+			    && get_key_dirid(&(ih - 2)->ih_key) ==
+			    get_key_dirid(&(ih - 1)->ih_key)) {
+				/* fix i-th */
+				if (!is_stat_data_ih(ih)) {
+					fsck_log
+					    ("pass0: vpf-10430: block %lu, item %d: Wrong order of items - "
+					     "change the dir_id of the key %k to %lu\n",
+					     bh->b_blocknr, i, &ih->ih_key,
+					     get_key_dirid(&(ih - 1)->ih_key));
+					set_key_dirid(&ih->ih_key,
+						      get_key_dirid(&(ih - 1)->
+								    ih_key));
+					dirty = 1;
+				} else if (i + 1 < nr_items) {
+					fsck_log
+					    ("pass0: vpf-10440: block %lu, item %d: Wrong order of items - "
+					     "change the dir_id of the key %k to %lu\n",
+					     bh->b_blocknr, i, &ih->ih_key,
+					     get_key_dirid(&(ih + 1)->ih_key));
+					set_key_dirid(&ih->ih_key,
+						      get_key_dirid(&(ih + 1)->
+								    ih_key));
+					dirty = 1;
+				}
+			} else
+			    if ((i + 1 < nr_items)
+				&& get_key_dirid(&ih->ih_key) ==
+				get_key_dirid(&(ih + 1)->ih_key)) {
+				fsck_log
+				    ("pass0: vpf-10450: block %lu, item %d: Wrong order of items - "
+				     "change the dir_id of the key %k to %lu\n",
+				     bh->b_blocknr, i - 1, &(ih - 1)->ih_key,
+				     get_key_dirid(&ih->ih_key));
+				/* fix (i - 1)-th */
+				set_key_dirid(&(ih - 1)->ih_key,
+					      get_key_dirid(&ih->ih_key));
+				dirty = 1;
+			}
 		}
-		if ((get_key_dirid (&ih->ih_key) == get_key_dirid (&(ih + 1)->ih_key)) &&
-		    (get_key_dirid (&(ih - 1)->ih_key) != get_key_dirid (&(ih + 1)->ih_key)))
-	    	{
-		    fsck_log("pass0: vpf-10510: block %lu, item %d: Wrong order of items - " 
-			"change the dir_id of the key %k to %lu\n",
-                    	bh->b_blocknr, i - 1, &(ih-1)->ih_key, get_key_dirid (&(ih + 1)->ih_key));
-		    set_key_dirid (&(ih - 1)->ih_key, get_key_dirid (&(ih + 1)->ih_key));
-		    dirty = 1;
+
+		if (i && i + 1 < nr_items) {
+			/* there is a previous and a next items */
+			if ((get_key_dirid(&(ih - 1)->ih_key) ==
+			     get_key_dirid(&(ih + 1)->ih_key))
+			    && (get_key_dirid(&(ih - 1)->ih_key) !=
+				get_key_dirid(&ih->ih_key))) {
+				fsck_log
+				    ("pass0: vpf-10460: block %lu, item %d: Wrong order of items - "
+				     "change the dir_id of the key %k to %lu\n",
+				     bh->b_blocknr, i, &ih->ih_key,
+				     get_key_dirid(&(ih - 1)->ih_key));
+				set_key_dirid(&ih->ih_key,
+					      get_key_dirid(&(ih - 1)->ih_key));
+				dirty = 1;
+			}
+			if (is_stat_data_ih(ih - 1) && is_indirect_ih(ih)
+			    && is_direct_ih(ih + 1)) {
+				if ((get_key_objectid(&(ih - 1)->ih_key) ==
+				     get_key_objectid(&(ih + 1)->ih_key))
+				    && (get_key_objectid(&(ih - 1)->ih_key) !=
+					get_key_objectid(&ih->ih_key))) {
+					fsck_log
+					    ("pass0: vpf-10470: block %lu, item %d: Wrong order of items - "
+					     "change the object_id of the key %k to %lu\n",
+					     bh->b_blocknr, i, &ih->ih_key,
+					     get_key_objectid(&(ih - 1)->
+							      ih_key));
+					set_key_objectid(&ih->ih_key,
+							 get_key_objectid(&
+									  (ih -
+									   1)->
+									  ih_key));
+					dirty = 1;
+				}
+				if ((get_key_objectid(&(ih - 1)->ih_key) ==
+				     get_key_objectid(&ih->ih_key))
+				    && (get_key_objectid(&(ih - 1)->ih_key) !=
+					get_key_objectid(&(ih + 1)->ih_key))) {
+					fsck_log
+					    ("pass0: vpf-10480: block %lu, item %d: Wrong order of items - "
+					     "change the object_id of the key %k to %lu\n",
+					     bh->b_blocknr, i + 1,
+					     &(ih + 1)->ih_key,
+					     get_key_objectid(&(ih - 1)->
+							      ih_key));
+					set_key_objectid(&(ih + 1)->ih_key,
+							 get_key_objectid(&
+									  (ih -
+									   1)->
+									  ih_key));
+					dirty = 1;
+				}
+				if ((get_key_objectid(&ih->ih_key) ==
+				     get_key_objectid(&(ih + 1)->ih_key))
+				    && (get_key_objectid(&(ih - 1)->ih_key) !=
+					get_key_objectid(&(ih + 1)->ih_key))) {
+					fsck_log
+					    ("pass0: vpf-10490: block %lu, item %d: Wrong order of items - "
+					     "change the object_id of the key %k to %lu\n",
+					     bh->b_blocknr, i - 1,
+					     &(ih - 1)->ih_key,
+					     get_key_objectid(&(ih + 1)->
+							      ih_key));
+					set_key_objectid(&(ih - 1)->ih_key,
+							 get_key_objectid(&
+									  (ih +
+									   1)->
+									  ih_key));
+					dirty = 1;
+				}
+				if ((get_key_dirid(&(ih - 1)->ih_key) ==
+				     get_key_dirid(&ih->ih_key))
+				    && (get_key_dirid(&(ih - 1)->ih_key) !=
+					get_key_dirid(&(ih + 1)->ih_key))) {
+					fsck_log
+					    ("pass0: vpf-10500: block %lu, item %d: Wrong order of items - "
+					     "change the dir_id of the key %k to %lu\n",
+					     bh->b_blocknr, i + 1,
+					     &(ih + 1)->ih_key,
+					     get_key_dirid(&(ih - 1)->ih_key));
+					set_key_dirid(&(ih + 1)->ih_key,
+						      get_key_dirid(&(ih - 1)->
+								    ih_key));
+					dirty = 1;
+				}
+				if ((get_key_dirid(&ih->ih_key) ==
+				     get_key_dirid(&(ih + 1)->ih_key))
+				    && (get_key_dirid(&(ih - 1)->ih_key) !=
+					get_key_dirid(&(ih + 1)->ih_key))) {
+					fsck_log
+					    ("pass0: vpf-10510: block %lu, item %d: Wrong order of items - "
+					     "change the dir_id of the key %k to %lu\n",
+					     bh->b_blocknr, i - 1,
+					     &(ih - 1)->ih_key,
+					     get_key_dirid(&(ih + 1)->ih_key));
+					set_key_dirid(&(ih - 1)->ih_key,
+						      get_key_dirid(&(ih + 1)->
+								    ih_key));
+					dirty = 1;
+				}
+			}
 		}
-            }
-     	}
-
-	if (i && is_stat_data_ih (ih) &&
-	    get_key_dirid (&(ih - 1)->ih_key) == get_key_dirid (&ih->ih_key) &&
-	    get_key_objectid (&(ih - 1)->ih_key) >= get_key_objectid (&ih->ih_key)) {
-	    if ((i + 1 < nr_items) && !is_stat_data_ih (ih + 1)) {
-         	if (get_key_objectid (&(ih - 1)->ih_key) < get_key_objectid (&(ih + 1)->ih_key)) {
-		    fsck_log("pass0: vpf-10520: block %lu, item %d: Wrong order of items - "
-			"change the object_id of the key %k to %lu\n",
-			bh->b_blocknr, i - 1, &(ih-1)->ih_key, get_key_objectid (&(ih + 1)->ih_key));
-		    set_key_objectid (&ih->ih_key, get_key_objectid (&(ih + 1)->ih_key));
-		    dirty = 1;
+
+		if (i && is_stat_data_ih(ih) &&
+		    get_key_dirid(&(ih - 1)->ih_key) ==
+		    get_key_dirid(&ih->ih_key)
+		    && get_key_objectid(&(ih - 1)->ih_key) >=
+		    get_key_objectid(&ih->ih_key)) {
+			if ((i + 1 < nr_items) && !is_stat_data_ih(ih + 1)) {
+				if (get_key_objectid(&(ih - 1)->ih_key) <
+				    get_key_objectid(&(ih + 1)->ih_key)) {
+					fsck_log
+					    ("pass0: vpf-10520: block %lu, item %d: Wrong order of items - "
+					     "change the object_id of the key %k to %lu\n",
+					     bh->b_blocknr, i - 1,
+					     &(ih - 1)->ih_key,
+					     get_key_objectid(&(ih + 1)->
+							      ih_key));
+					set_key_objectid(&ih->ih_key,
+							 get_key_objectid(&
+									  (ih +
+									   1)->
+									  ih_key));
+					dirty = 1;
+				}
+			}
 		}
-	    }
-	}
 
-        if (i && is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih) &&
-	    (get_key_objectid (&(ih - 1)->ih_key) != get_key_objectid (&ih->ih_key)))
-        {
-            int err = 0;
-            if (i > 1) {
-                if (comp_short_keys (&(ih - 2)->ih_key, &(ih - 1)->ih_key) != -1)
-                    misc_set_bit (1, &err);
-                if (comp_short_keys (&(ih - 2)->ih_key, &ih->ih_key) != -1)
-                    misc_set_bit (2, &err);
-            }
-            if (i + 1 < nr_items) {
-                if (comp_short_keys (&(ih - 1)->ih_key, &(ih + 1)->ih_key) != -1)
-                    misc_set_bit (3, &err);
-                if (comp_short_keys (&ih->ih_key, &(ih + 1)->ih_key) != -1)
-                    misc_set_bit (4, &err);
-            }
+		if (i && is_stat_data_ih(ih - 1) && !is_stat_data_ih(ih) &&
+		    (get_key_objectid(&(ih - 1)->ih_key) !=
+		     get_key_objectid(&ih->ih_key))) {
+			int err = 0;
+			if (i > 1) {
+				if (comp_short_keys
+				    (&(ih - 2)->ih_key,
+				     &(ih - 1)->ih_key) != -1)
+					misc_set_bit(1, &err);
+				if (comp_short_keys
+				    (&(ih - 2)->ih_key, &ih->ih_key) != -1)
+					misc_set_bit(2, &err);
+			}
+			if (i + 1 < nr_items) {
+				if (comp_short_keys
+				    (&(ih - 1)->ih_key,
+				     &(ih + 1)->ih_key) != -1)
+					misc_set_bit(3, &err);
+				if (comp_short_keys
+				    (&ih->ih_key, &(ih + 1)->ih_key) != -1)
+					misc_set_bit(4, &err);
+			}
 /*
             if ((test_bit (1, err) || test_bit (3, err)) &&
 		(test_bit (2, err) || test_bit (4, err))) {
@@ -909,375 +1068,529 @@ static void pass0_correct_leaf (reiserfs_filsys_t * fs,
                 goto start_again;
       	    }
 */
-            if (!misc_test_bit (1, &err) && !misc_test_bit (3, &err) &&
-		!misc_test_bit (2, &err) && !misc_test_bit (4, &err)) {
-      		if (i <= 1) {
-            	    /* take bigger */
-                    if (comp_short_keys (&(ih - 1)->ih_key, &ih->ih_key) == 1) {
-			fsck_log("pass0: vpf-10530: block %lu, item %d: Wrong order of items - "
-			    "change the object_id of the key %k to %lu\n",
-                    	    bh->b_blocknr, i, &ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-			set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-                    } else {
-			fsck_log("pass0: vpf-10540: block %lu, item %d: Wrong order of items - "
-			    "change the object_id of the key %k to %lu\n",
-                    	    bh->b_blocknr, i - 1, &(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-                        set_key_objectid (&(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-                    }
-            	} else {
-                    /* take smaller */
-                    if (comp_short_keys (&(ih - 1)->ih_key, &ih->ih_key) == 1) {
-			fsck_log("pass0: vpf-10550: block %lu, item %d: Wrong order of items - "
-			    "change the object_id of the key %k to %lu\n",
-                    	    bh->b_blocknr, i - 1, &(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-                        set_key_objectid (&(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-                    } else {
-			fsck_log("pass0: vpf-10560: block %lu, item %d: Wrong order of items - "
-			    "change the object_id of the key %k to %lu\n",
-                    	    bh->b_blocknr, i, &ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-			set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-                    }
-                }
-		dirty = 1;
-	    } else if (!misc_test_bit (1, &err) && !misc_test_bit (3, &err)) {
-      		/* take i - 1 */
-		fsck_log("pass0: vpf-10590: block %lu, item %d: Wrong order of items - "
-		    "change the object_id of the key %k to %lu\n",
-                    bh->b_blocknr, i, &ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		dirty = 1;
- 	    } else if (!misc_test_bit (2, &err) && !misc_test_bit (4, &err)) {
-      		/* take i */
-		fsck_log("pass0: vpf-10600: block %lu, item %d: Wrong order of items - "
-		    "change the object_id of the key %k to %lu\n",
-              	    bh->b_blocknr, i - 1, &(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-                set_key_objectid (&(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-		dirty = 1;
-	    }
-        }
-
-	/* this recovers corruptions like the below: 
-	   1774 1732 0 0
-	   116262638 1732 1 3
-	   1774 1736 0 0 */
-	if (i && is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih)) {
-	    if (get_key_objectid (&ih->ih_key) != get_key_objectid (&(ih - 1)->ih_key) ||
-		get_key_dirid (&ih->ih_key) != get_key_dirid (&(ih - 1)->ih_key) ||
-		get_offset (&ih->ih_key) != 1) {
-		if (is_direntry_ih (ih)) {
-		    fsck_log ("pass0: vpf-10160: block %lu: item %d: No \".\" entry found in "
-			      "the first item of a directory\n", bh->b_blocknr, i);
-		    set_key_dirid (&ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		    set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		    dirty = 1;
-		} else {
-		    fsck_log ("pass0: vpf-10170: block %lu: item %d: Wrong order of items - "
-			"the item \n\t%H fixed to ", bh->b_blocknr, i, ih);
-		    
-		    set_key_dirid (&ih->ih_key, get_key_dirid (&(ih - 1)->ih_key));
-		    set_key_objectid (&ih->ih_key, get_key_objectid (&(ih - 1)->ih_key));
-		    
-		    if (get_ih_item_len (ih - 1) == SD_SIZE) {
-			/* stat data is new, therefore this item is new too */
-			set_offset (KEY_FORMAT_2, &(ih->ih_key), 1);
-			if ((get_ih_entry_count (ih) != 0xffff) && (get_ih_item_len (ih) % 4 == 0))
-			    set_type (KEY_FORMAT_2, &(ih->ih_key), TYPE_INDIRECT);
-			else
-			    set_type (KEY_FORMAT_2, &(ih->ih_key), TYPE_DIRECT);
-			set_ih_key_format (ih, KEY_FORMAT_2);
-		    } else {
-			/* stat data is old, therefore this item is old too */
-			set_offset (KEY_FORMAT_1, &(ih->ih_key), 1);
-			if ((get_ih_entry_count (ih) != 0xffff) && (get_ih_item_len (ih) % 4 == 0))
-			    set_type (KEY_FORMAT_1, &(ih->ih_key), TYPE_INDIRECT);
-			else {
-			    set_type (KEY_FORMAT_1, &(ih->ih_key), TYPE_DIRECT);
-			    set_ih_free_space (ih, 0xffff);
+			if (!misc_test_bit(1, &err) && !misc_test_bit(3, &err)
+			    && !misc_test_bit(2, &err)
+			    && !misc_test_bit(4, &err)) {
+				if (i <= 1) {
+					/* take bigger */
+					if (comp_short_keys
+					    (&(ih - 1)->ih_key,
+					     &ih->ih_key) == 1) {
+						fsck_log
+						    ("pass0: vpf-10530: block %lu, item %d: Wrong order of items - "
+						     "change the object_id of the key %k to %lu\n",
+						     bh->b_blocknr, i,
+						     &ih->ih_key,
+						     get_key_objectid(&
+								      (ih -
+								       1)->
+								      ih_key));
+						set_key_objectid(&ih->ih_key,
+								 get_key_objectid
+								 (&(ih - 1)->
+								  ih_key));
+					} else {
+						fsck_log
+						    ("pass0: vpf-10540: block %lu, item %d: Wrong order of items - "
+						     "change the object_id of the key %k to %lu\n",
+						     bh->b_blocknr, i - 1,
+						     &(ih - 1)->ih_key,
+						     get_key_objectid(&ih->
+								      ih_key));
+						set_key_objectid(&(ih - 1)->
+								 ih_key,
+								 get_key_objectid
+								 (&ih->ih_key));
+					}
+				} else {
+					/* take smaller */
+					if (comp_short_keys
+					    (&(ih - 1)->ih_key,
+					     &ih->ih_key) == 1) {
+						fsck_log
+						    ("pass0: vpf-10550: block %lu, item %d: Wrong order of items - "
+						     "change the object_id of the key %k to %lu\n",
+						     bh->b_blocknr, i - 1,
+						     &(ih - 1)->ih_key,
+						     get_key_objectid(&ih->
+								      ih_key));
+						set_key_objectid(&(ih - 1)->
+								 ih_key,
+								 get_key_objectid
+								 (&ih->ih_key));
+					} else {
+						fsck_log
+						    ("pass0: vpf-10560: block %lu, item %d: Wrong order of items - "
+						     "change the object_id of the key %k to %lu\n",
+						     bh->b_blocknr, i,
+						     &ih->ih_key,
+						     get_key_objectid(&
+								      (ih -
+								       1)->
+								      ih_key));
+						set_key_objectid(&ih->ih_key,
+								 get_key_objectid
+								 (&(ih - 1)->
+								  ih_key));
+					}
+				}
+				dirty = 1;
+			} else if (!misc_test_bit(1, &err)
+				   && !misc_test_bit(3, &err)) {
+				/* take i - 1 */
+				fsck_log
+				    ("pass0: vpf-10590: block %lu, item %d: Wrong order of items - "
+				     "change the object_id of the key %k to %lu\n",
+				     bh->b_blocknr, i, &ih->ih_key,
+				     get_key_objectid(&(ih - 1)->ih_key));
+				set_key_objectid(&ih->ih_key,
+						 get_key_objectid(&(ih - 1)->
+								  ih_key));
+				dirty = 1;
+			} else if (!misc_test_bit(2, &err)
+				   && !misc_test_bit(4, &err)) {
+				/* take i */
+				fsck_log
+				    ("pass0: vpf-10600: block %lu, item %d: Wrong order of items - "
+				     "change the object_id of the key %k to %lu\n",
+				     bh->b_blocknr, i - 1, &(ih - 1)->ih_key,
+				     get_key_objectid(&ih->ih_key));
+				set_key_objectid(&(ih - 1)->ih_key,
+						 get_key_objectid(&ih->ih_key));
+				dirty = 1;
 			}
-			set_ih_key_format (ih, KEY_FORMAT_1);
-		    }
-		    fsck_log ("\n\t%H\n", ih);
-		    dirty = 1;
 		}
-	    }
-	}
 
-	/* FIXME: corruptions like:
-	   56702 66802 1 2
-	   56702 65536 0 0
-	   56702 66803 1 2
-	   do not get recovered (both last items will be deleted) */
-	/* delete item if it is not in correct order of object items */
-	if (i && not_of_one_file (&ih->ih_key, &(ih - 1)->ih_key) &&
-	    !is_stat_data_ih (ih)) {
-	    fsck_log ("pass0: vpf-10180: block %lu: item %d: The item %k, which follows non StatData item %k, is deleted\n",
-		      bh->b_blocknr, i, &ih->ih_key, &(ih - 1)->ih_key);
-	    delete_item (fs, bh, i);
-	    goto start_again;
-	}
-	
-	if (is_stat_data_ih (ih)) {
-            if (get_offset (&ih->ih_key) != 0) {
-                set_offset(KEY_FORMAT_1, &ih->ih_key, 0);
-                dirty = 1;
-            }
-	} else if (!is_direntry_ih (ih)) {
-	    /* not SD, not direntry */
-            if (i && comp_short_keys (&(ih - 1)->ih_key, &ih->ih_key) == 0) {
-                if (is_stat_data_ih (ih - 1)) {
-        	    if (get_offset (&ih->ih_key) != 1) {
-                        set_offset(key_format(&ih->ih_key), &ih->ih_key, 1);
-                        dirty = 1;
-                    }
-                } else if (is_indirect_ih (ih - 1) && is_direct_ih (ih)) {
-        	    if (get_offset (&ih->ih_key) != 
-        	        get_offset(&(ih - 1)->ih_key) + I_UNFM_NUM (ih - 1) * fs->fs_blocksize) 
-        	    {
-                        set_offset(key_format(&ih->ih_key), &ih->ih_key,
-                            get_offset(&(ih - 1)->ih_key) + I_UNFM_NUM (ih - 1) * fs->fs_blocksize);
-                        dirty = 1;
-        	    }
-                } else {
-                    /* if indirect item or not the first direct item in the leaf */
-                    fsck_log("pass0: vpf-10250: block %lu, item %d: The item %k with wrong type is deleted\n",
-                         bh->b_blocknr, i, &ih->ih_key);
-                    delete_item (fs, bh, i);
-                    goto start_again;
-                }
-		
-		/* Check the lenght of the direct item; offset should be ok already. */
-		if (is_direct_ih (ih)) {
-		    if (STORE_TAIL_IN_UNFM (get_offset (&ih->ih_key) + get_ih_item_len (ih) - 1, 
-			    get_ih_item_len (ih), bh->b_size)) 
-		    {
-                            fsck_log("pass0: vpf-10700: block %lu, item %d: The item with wrong offset"
-				" or length found %k, len % lu - deleted\n", bh->b_blocknr, i, &ih->ih_key, 
-				get_ih_item_len (ih));
-                            delete_item (fs, bh, i);
-                            goto start_again;
-		    }
-  		}
-            } else {
-		/*first item in the node or first item of the file */
-		
-  		if (i) {
-        	    /* first item of the file, but not SD - delete */
-		    fsck_log("pass0: vpf-10190: block %lu, item %d: The item %k, which follows non StatData"
-			" item %k, is deleted\n", bh->b_blocknr, i, &ih->ih_key, &(ih - 1)->ih_key );
-			delete_item (fs, bh, i);
-			goto start_again;
-        	}
-
-		/* indirect or direct is the first in the leaf */
-		offset = (__u64)get_offset (&ih->ih_key);
-		if (is_indirect_ih (ih)) {
-		    if (offset % fs->fs_blocksize != 1) {
-			fsck_log("pass0: vpf-10200: block %lu, item %d: The item %k with wrong offset is deleted\n",
-			    bh->b_blocknr, i, &ih->ih_key);
-			delete_item (fs, bh, i);
-			goto start_again;
-		    }
-		} else if (is_direct_ih (ih)) {
-		    if (!correct_direct_item_offset (get_offset (&ih->ih_key), key_format (&ih->ih_key)) ||
-			((get_offset (&ih->ih_key) % bh->b_size - 1) + get_ih_item_len (ih) > bh->b_size) || 
-          		STORE_TAIL_IN_UNFM (offset + get_ih_item_len (ih) - 1, get_ih_item_len (ih), bh->b_size)) 
-		    {
-                            fsck_log("pass0: vpf-10210: block %lu, item %d: The item with wrong offset ", 
-                                bh->b_blocknr, i);
-                            fsck_log("or length found %k, len % lu - deleted\n", &ih->ih_key, get_ih_item_len (ih));
-                            delete_item (fs, bh, i);
-                            goto start_again;
-		    }
-  		}
-		
-		offset += get_bytes_number (ih, fs->fs_blocksize);
-		if (!does_it_fit_into_dev (offset, fs_size)) {
-                    fsck_log("pass0: vpf-10230: block %lu, item %d: The item offset is is too big %k - deleted\n",
-                                        bh->b_blocknr, i, &ih->ih_key);
-                    delete_item (fs, bh, i);
-                    goto start_again;
-		}
-		
-	    }
-        }
-        
-
-        
-	if (i &&  comp_keys (&(ih - 1)->ih_key, &ih->ih_key) != -1) {
-	    /* previous item has key not smaller than the key of currect item */
-	    if (is_stat_data_ih (ih - 1) && !is_stat_data_ih (ih)) {
-		/* fix key of stat data such as if it was stat data of that item */
-		fsck_log ("pass0: block %lu, items %d, %d: Wrong order of items - make the StatData item %k of the file %k\n",
-		    bh->b_blocknr, i - 1, i, &(ih - 1)->ih_key, &ih->ih_key);
-		set_key_dirid (&(ih - 1)->ih_key, get_key_dirid (&ih->ih_key));
-		set_key_objectid (&(ih - 1)->ih_key, get_key_objectid (&ih->ih_key));
-		set_offset (KEY_FORMAT_1, &(ih - 1)->ih_key, 0);
-		set_type (KEY_FORMAT_1, &(ih - 1)->ih_key, TYPE_STAT_DATA);
-		dirty = 1;
-	    } else {
-		/* ok, we have to delete one of these two - decide which one */
-		int retval;
-
-		/* something will be deleted */
-		dirty = 1;
-		retval = upper_correct (bh, ih - 1, i - 1);
-		switch (retval) {
-		case 0:
-		    /* delete upper item */
-		    fsck_log ("pass0: block %lu, item %d (upper): Item %k is out of order - deleted\n",
-			      bh->b_blocknr, i - 1, &(ih - 1)->ih_key);
-		    delete_item (fs, bh, i - 1);
-		    goto start_again;
-
-		case 1:
-		    /* delete lower item */
-		    fsck_log ("pass0: block %lu, item %d (lower): Item %k is out of order - deleted\n",
-			      bh->b_blocknr, i, &ih->ih_key);
-		    delete_item (fs, bh, i);
-		    goto start_again;
-
-		default:
-		    /* upper item was the first item of a node */
-		    /* to make gcc 3.2 do not sware here */;
+		/* this recovers corruptions like the below: 
+		   1774 1732 0 0
+		   116262638 1732 1 3
+		   1774 1736 0 0 */
+		if (i && is_stat_data_ih(ih - 1) && !is_stat_data_ih(ih)) {
+			if (get_key_objectid(&ih->ih_key) !=
+			    get_key_objectid(&(ih - 1)->ih_key)
+			    || get_key_dirid(&ih->ih_key) !=
+			    get_key_dirid(&(ih - 1)->ih_key)
+			    || get_offset(&ih->ih_key) != 1) {
+				if (is_direntry_ih(ih)) {
+					fsck_log
+					    ("pass0: vpf-10160: block %lu: item %d: No \".\" entry found in "
+					     "the first item of a directory\n",
+					     bh->b_blocknr, i);
+					set_key_dirid(&ih->ih_key,
+						      get_key_dirid(&(ih - 1)->
+								    ih_key));
+					set_key_objectid(&ih->ih_key,
+							 get_key_objectid(&
+									  (ih -
+									   1)->
+									  ih_key));
+					dirty = 1;
+				} else {
+					fsck_log
+					    ("pass0: vpf-10170: block %lu: item %d: Wrong order of items - "
+					     "the item \n\t%H fixed to ",
+					     bh->b_blocknr, i, ih);
+
+					set_key_dirid(&ih->ih_key,
+						      get_key_dirid(&(ih - 1)->
+								    ih_key));
+					set_key_objectid(&ih->ih_key,
+							 get_key_objectid(&
+									  (ih -
+									   1)->
+									  ih_key));
+
+					if (get_ih_item_len(ih - 1) == SD_SIZE) {
+						/* stat data is new, therefore this item is new too */
+						set_offset(KEY_FORMAT_2,
+							   &(ih->ih_key), 1);
+						if ((get_ih_entry_count(ih) !=
+						     0xffff)
+						    && (get_ih_item_len(ih) %
+							4 == 0))
+							set_type(KEY_FORMAT_2,
+								 &(ih->ih_key),
+								 TYPE_INDIRECT);
+						else
+							set_type(KEY_FORMAT_2,
+								 &(ih->ih_key),
+								 TYPE_DIRECT);
+						set_ih_key_format(ih,
+								  KEY_FORMAT_2);
+					} else {
+						/* stat data is old, therefore this item is old too */
+						set_offset(KEY_FORMAT_1,
+							   &(ih->ih_key), 1);
+						if ((get_ih_entry_count(ih) !=
+						     0xffff)
+						    && (get_ih_item_len(ih) %
+							4 == 0))
+							set_type(KEY_FORMAT_1,
+								 &(ih->ih_key),
+								 TYPE_INDIRECT);
+						else {
+							set_type(KEY_FORMAT_1,
+								 &(ih->ih_key),
+								 TYPE_DIRECT);
+							set_ih_free_space(ih,
+									  0xffff);
+						}
+						set_ih_key_format(ih,
+								  KEY_FORMAT_1);
+					}
+					fsck_log("\n\t%H\n", ih);
+					dirty = 1;
+				}
+			}
 		}
 
-		retval = lower_correct (bh, ih, i);
-		switch (retval) {
-		case 0:
-		    /* delete lower item */
-		    fsck_log ("pass0: block %lu, item %d (lower): Item %k is out of order - deleted\n",
-			      bh->b_blocknr, i, &ih->ih_key);
-		    delete_item (fs, bh, i);
-		    goto start_again;
-
-		case 1:
-		    /* delete upper item */
-		    fsck_log ("pass0: block %lu, %d (upper): Item %k is out of order - deleted\n",
-			      bh->b_blocknr, i - 1, &(ih - 1)->ih_key);
-		    delete_item (fs, bh, i - 1);
-		    goto start_again;
-
-		default:
-		    /* only 2 items in the node, how to decide what to delete, go and ask user */
-		    /* to make gcc 3.2 do not sware here */;
+		/* FIXME: corruptions like:
+		   56702 66802 1 2
+		   56702 65536 0 0
+		   56702 66803 1 2
+		   do not get recovered (both last items will be deleted) */
+		/* delete item if it is not in correct order of object items */
+		if (i && not_of_one_file(&ih->ih_key, &(ih - 1)->ih_key) &&
+		    !is_stat_data_ih(ih)) {
+			fsck_log
+			    ("pass0: vpf-10180: block %lu: item %d: The item %k, which follows non StatData item %k, is deleted\n",
+			     bh->b_blocknr, i, &ih->ih_key, &(ih - 1)->ih_key);
+			delete_item(fs, bh, i);
+			goto start_again;
 		}
-		fsck_log ("pass0: block %lu, items %d and %d: Which of these items looks better (the other will be deleted.)?\n"
-			  "%k\n%k\n", bh->b_blocknr, i-1, i, &(ih - 1)->ih_key, &ih->ih_key);
-		if (fsck_user_confirmed (fs, "1 or 2?", "1\n", 1))
-		    delete_item (fs, bh, i - 1);
-		else
-		    delete_item (fs, bh, i);
-		goto start_again;
-	    }
-	}
 
-	if (is_stat_data_ih (ih) && (get_ih_item_len (ih) != SD_SIZE &&
-				     get_ih_item_len (ih) != SD_V1_SIZE)) {
-	    fsck_log ("pass0: block %lu, item %d: StatData item of wrong length found %H - deleted\n",
-		      bh->b_blocknr, i, ih);
-	    delete_item (fs, bh, i);
-	    goto start_again;
-	}
-
-	dirty += correct_key_format (ih, symlnk);
-	
-	if (is_stat_data_ih (ih)) {
-	    __u16 mode;
-
-            file_format = get_ih_key_format (ih);
-	
-	    get_sd_mode (ih, B_N_PITEM(bh,i), &mode);
-            symlnk = ( S_ISLNK(mode) ? 1 : 0);
-	    ;/*correct_stat_data (fs, bh, i);*/
-        } else if ( !is_direntry_ih(ih) &&
-                    !(symlnk && is_direct_ih(ih)) &&
-        	    (file_format != KEY_FORMAT_UNDEFINED) &&
-        	    (file_format != get_ih_key_format (ih)))
-        {
-            fsck_log("pass0: vpf-10240: block %lu, item (%d): Item %k, which format (%d) is not equal to StatData "
-		"format (%d), is deleted\n", bh->b_blocknr, i, &ih->ih_key, get_ih_key_format(ih), file_format);
-            delete_item (fs, bh, i);
-            goto start_again;
-        } else {
-	    file_format = KEY_FORMAT_UNDEFINED;
-	    symlnk = 0;
-	}
+		if (is_stat_data_ih(ih)) {
+			if (get_offset(&ih->ih_key) != 0) {
+				set_offset(KEY_FORMAT_1, &ih->ih_key, 0);
+				dirty = 1;
+			}
+		} else if (!is_direntry_ih(ih)) {
+			/* not SD, not direntry */
+			if (i
+			    && comp_short_keys(&(ih - 1)->ih_key,
+					       &ih->ih_key) == 0) {
+				if (is_stat_data_ih(ih - 1)) {
+					if (get_offset(&ih->ih_key) != 1) {
+						set_offset(key_format
+							   (&ih->ih_key),
+							   &ih->ih_key, 1);
+						dirty = 1;
+					}
+				} else if (is_indirect_ih(ih - 1)
+					   && is_direct_ih(ih)) {
+					if (get_offset(&ih->ih_key) !=
+					    get_offset(&(ih - 1)->ih_key) +
+					    I_UNFM_NUM(ih -
+						       1) * fs->fs_blocksize) {
+						set_offset(key_format
+							   (&ih->ih_key),
+							   &ih->ih_key,
+							   get_offset(&
+								      (ih -
+								       1)->
+								      ih_key) +
+							   I_UNFM_NUM(ih -
+								      1) *
+							   fs->fs_blocksize);
+						dirty = 1;
+					}
+				} else {
+					/* if indirect item or not the first direct item in the leaf */
+					fsck_log
+					    ("pass0: vpf-10250: block %lu, item %d: The item %k with wrong type is deleted\n",
+					     bh->b_blocknr, i, &ih->ih_key);
+					delete_item(fs, bh, i);
+					goto start_again;
+				}
+
+				/* Check the lenght of the direct item; offset should be ok already. */
+				if (is_direct_ih(ih)) {
+					if (STORE_TAIL_IN_UNFM
+					    (get_offset(&ih->ih_key) +
+					     get_ih_item_len(ih) - 1,
+					     get_ih_item_len(ih), bh->b_size)) {
+						fsck_log
+						    ("pass0: vpf-10700: block %lu, item %d: The item with wrong offset"
+						     " or length found %k, len % lu - deleted\n",
+						     bh->b_blocknr, i,
+						     &ih->ih_key,
+						     get_ih_item_len(ih));
+						delete_item(fs, bh, i);
+						goto start_again;
+					}
+				}
+			} else {
+				/*first item in the node or first item of the file */
+
+				if (i) {
+					/* first item of the file, but not SD - delete */
+					fsck_log
+					    ("pass0: vpf-10190: block %lu, item %d: The item %k, which follows non StatData"
+					     " item %k, is deleted\n",
+					     bh->b_blocknr, i, &ih->ih_key,
+					     &(ih - 1)->ih_key);
+					delete_item(fs, bh, i);
+					goto start_again;
+				}
+
+				/* indirect or direct is the first in the leaf */
+				offset = (__u64) get_offset(&ih->ih_key);
+				if (is_indirect_ih(ih)) {
+					if (offset % fs->fs_blocksize != 1) {
+						fsck_log
+						    ("pass0: vpf-10200: block %lu, item %d: The item %k with wrong offset is deleted\n",
+						     bh->b_blocknr, i,
+						     &ih->ih_key);
+						delete_item(fs, bh, i);
+						goto start_again;
+					}
+				} else if (is_direct_ih(ih)) {
+					if (!correct_direct_item_offset
+					    (get_offset(&ih->ih_key),
+					     key_format(&ih->ih_key))
+					    ||
+					    ((get_offset(&ih->ih_key) %
+					      bh->b_size - 1) +
+					     get_ih_item_len(ih) > bh->b_size)
+					    || STORE_TAIL_IN_UNFM(offset +
+								  get_ih_item_len
+								  (ih) - 1,
+								  get_ih_item_len
+								  (ih),
+								  bh->b_size)) {
+						fsck_log
+						    ("pass0: vpf-10210: block %lu, item %d: The item with wrong offset ",
+						     bh->b_blocknr, i);
+						fsck_log
+						    ("or length found %k, len % lu - deleted\n",
+						     &ih->ih_key,
+						     get_ih_item_len(ih));
+						delete_item(fs, bh, i);
+						goto start_again;
+					}
+				}
+
+				offset +=
+				    get_bytes_number(ih, fs->fs_blocksize);
+				if (!does_it_fit_into_dev(offset, fs_size)) {
+					fsck_log
+					    ("pass0: vpf-10230: block %lu, item %d: The item offset is is too big %k - deleted\n",
+					     bh->b_blocknr, i, &ih->ih_key);
+					delete_item(fs, bh, i);
+					goto start_again;
+				}
 
+			}
+		}
 
-	if (i && is_stat_data_ih (ih - 1) && !not_of_one_file (&ih->ih_key, &(ih - 1)->ih_key)) {
-	    __u16 mode;
+		if (i && comp_keys(&(ih - 1)->ih_key, &ih->ih_key) != -1) {
+			/* previous item has key not smaller than the key of currect item */
+			if (is_stat_data_ih(ih - 1) && !is_stat_data_ih(ih)) {
+				/* fix key of stat data such as if it was stat data of that item */
+				fsck_log
+				    ("pass0: block %lu, items %d, %d: Wrong order of items - make the StatData item %k of the file %k\n",
+				     bh->b_blocknr, i - 1, i, &(ih - 1)->ih_key,
+				     &ih->ih_key);
+				set_key_dirid(&(ih - 1)->ih_key,
+					      get_key_dirid(&ih->ih_key));
+				set_key_objectid(&(ih - 1)->ih_key,
+						 get_key_objectid(&ih->ih_key));
+				set_offset(KEY_FORMAT_1, &(ih - 1)->ih_key, 0);
+				set_type(KEY_FORMAT_1, &(ih - 1)->ih_key,
+					 TYPE_STAT_DATA);
+				dirty = 1;
+			} else {
+				/* ok, we have to delete one of these two - decide which one */
+				int retval;
+
+				/* something will be deleted */
+				dirty = 1;
+				retval = upper_correct(bh, ih - 1, i - 1);
+				switch (retval) {
+				case 0:
+					/* delete upper item */
+					fsck_log
+					    ("pass0: block %lu, item %d (upper): Item %k is out of order - deleted\n",
+					     bh->b_blocknr, i - 1,
+					     &(ih - 1)->ih_key);
+					delete_item(fs, bh, i - 1);
+					goto start_again;
+
+				case 1:
+					/* delete lower item */
+					fsck_log
+					    ("pass0: block %lu, item %d (lower): Item %k is out of order - deleted\n",
+					     bh->b_blocknr, i, &ih->ih_key);
+					delete_item(fs, bh, i);
+					goto start_again;
+
+				default:
+					/* upper item was the first item of a node */
+					/* to make gcc 3.2 do not sware here */
+					    ;
+				}
+
+				retval = lower_correct(bh, ih, i);
+				switch (retval) {
+				case 0:
+					/* delete lower item */
+					fsck_log
+					    ("pass0: block %lu, item %d (lower): Item %k is out of order - deleted\n",
+					     bh->b_blocknr, i, &ih->ih_key);
+					delete_item(fs, bh, i);
+					goto start_again;
+
+				case 1:
+					/* delete upper item */
+					fsck_log
+					    ("pass0: block %lu, %d (upper): Item %k is out of order - deleted\n",
+					     bh->b_blocknr, i - 1,
+					     &(ih - 1)->ih_key);
+					delete_item(fs, bh, i - 1);
+					goto start_again;
+
+				default:
+					/* only 2 items in the node, how to decide what to delete, go and ask user */
+					/* to make gcc 3.2 do not sware here */
+					    ;
+				}
+				fsck_log
+				    ("pass0: block %lu, items %d and %d: Which of these items looks better (the other will be deleted.)?\n"
+				     "%k\n%k\n", bh->b_blocknr, i - 1, i,
+				     &(ih - 1)->ih_key, &ih->ih_key);
+				if (fsck_user_confirmed
+				    (fs, "1 or 2?", "1\n", 1))
+					delete_item(fs, bh, i - 1);
+				else
+					delete_item(fs, bh, i);
+				goto start_again;
+			}
+		}
 
-	    get_sd_mode (ih - 1, B_I_PITEM (bh, ih - 1), &mode);	
-	    if (not_a_directory (B_I_PITEM (bh, ih - 1)) && is_direntry_ih (ih)) {
-		/* make SD mode SD of dir */
-		fsck_log ("pass0: block %lu, item %d: The directory %K has the wrong mode (%M), corrected to ",
-			bh->b_blocknr, i, &ih->ih_key, mode);
-		mode &= ~S_IFMT;
-		mode |= S_IFDIR;
-		fsck_log ("(%M)\n", mode);
-		set_sd_mode (ih - 1, B_I_PITEM (bh, ih - 1), &mode);
-		dirty = 1;
-	    } else if (!not_a_directory (B_I_PITEM (bh, ih - 1)) && !is_direntry_ih (ih)) {
-		/* make SD mode SD of regular file */
-		fsck_log ("pass0: block %lu, item %d: Not the directory %K has the wrong mode (%M), corrected to ",
-			bh->b_blocknr, i, &ih->ih_key, mode);
-		mode &= ~S_IFMT;
-		mode |= S_IFREG;
-		fsck_log ("(%M)\n", mode);
-		set_sd_mode (ih - 1, B_I_PITEM (bh, ih - 1), &mode);
-		dirty = 1;
-	    }
-	    if (not_a_regfile (B_I_PITEM (bh, ih - 1)) && is_indirect_ih (ih)) {
-		fsck_log ("pass0: block %lu, item %d: The file %K has the wrong mode (%M), corrected to ",
-			  bh->b_blocknr, i, &ih->ih_key, mode);
-		mode &= ~S_IFMT;
-		mode |= S_IFREG;
-		fsck_log ("(%M)\n", mode);
-		set_sd_mode (ih - 1, B_I_PITEM (bh, ih - 1), &mode);
-		dirty = 1;
-	    }
-	}
+		if (is_stat_data_ih(ih) && (get_ih_item_len(ih) != SD_SIZE &&
+					    get_ih_item_len(ih) !=
+					    SD_V1_SIZE)) {
+			fsck_log
+			    ("pass0: block %lu, item %d: StatData item of wrong length found %H - deleted\n",
+			     bh->b_blocknr, i, ih);
+			delete_item(fs, bh, i);
+			goto start_again;
+		}
 
-	if (is_direntry_ih (ih)) {
-	    j = verify_directory_item (fs, bh, i);
-	
-	    if (j == 1) {
-	        /* wrong hash, skip the leaf */
-		pass_0_stat (fs)->too_old_leaves ++;
-		mark_buffer_clean (bh);
-		return;
-	    } else if (j == -1) {
-		/* item was deleted */
-		goto start_again;
-	    }
-	    continue;
-	}
+		dirty += correct_key_format(ih, symlnk);
+
+		if (is_stat_data_ih(ih)) {
+			__u16 mode;
+
+			file_format = get_ih_key_format(ih);
+
+			get_sd_mode(ih, B_N_PITEM(bh, i), &mode);
+			symlnk = (S_ISLNK(mode) ? 1 : 0);
+			;	/*correct_stat_data (fs, bh, i); */
+		} else if (!is_direntry_ih(ih) &&
+			   !(symlnk && is_direct_ih(ih)) &&
+			   (file_format != KEY_FORMAT_UNDEFINED) &&
+			   (file_format != get_ih_key_format(ih))) {
+			fsck_log
+			    ("pass0: vpf-10240: block %lu, item (%d): Item %k, which format (%d) is not equal to StatData "
+			     "format (%d), is deleted\n", bh->b_blocknr, i,
+			     &ih->ih_key, get_ih_key_format(ih), file_format);
+			delete_item(fs, bh, i);
+			goto start_again;
+		} else {
+			file_format = KEY_FORMAT_UNDEFINED;
+			symlnk = 0;
+		}
 
-	/*DEBUG*/
-        if (!is_stat_data_ih (ih) && get_offset (&ih->ih_key) == 0)
-            reiserfs_panic ("block %lu, item %d: Zero offset can have StatData items only, but found %k\n", 
-		bh->b_blocknr, i, &ih->ih_key);	
-	
-	if (!is_indirect_ih (ih))
-	    continue;
+		if (i && is_stat_data_ih(ih - 1)
+		    && !not_of_one_file(&ih->ih_key, &(ih - 1)->ih_key)) {
+			__u16 mode;
+
+			get_sd_mode(ih - 1, B_I_PITEM(bh, ih - 1), &mode);
+			if (not_a_directory(B_I_PITEM(bh, ih - 1))
+			    && is_direntry_ih(ih)) {
+				/* make SD mode SD of dir */
+				fsck_log
+				    ("pass0: block %lu, item %d: The directory %K has the wrong mode (%M), corrected to ",
+				     bh->b_blocknr, i, &ih->ih_key, mode);
+				mode &= ~S_IFMT;
+				mode |= S_IFDIR;
+				fsck_log("(%M)\n", mode);
+				set_sd_mode(ih - 1, B_I_PITEM(bh, ih - 1),
+					    &mode);
+				dirty = 1;
+			} else if (!not_a_directory(B_I_PITEM(bh, ih - 1))
+				   && !is_direntry_ih(ih)) {
+				/* make SD mode SD of regular file */
+				fsck_log
+				    ("pass0: block %lu, item %d: Not the directory %K has the wrong mode (%M), corrected to ",
+				     bh->b_blocknr, i, &ih->ih_key, mode);
+				mode &= ~S_IFMT;
+				mode |= S_IFREG;
+				fsck_log("(%M)\n", mode);
+				set_sd_mode(ih - 1, B_I_PITEM(bh, ih - 1),
+					    &mode);
+				dirty = 1;
+			}
+			if (not_a_regfile(B_I_PITEM(bh, ih - 1))
+			    && is_indirect_ih(ih)) {
+				fsck_log
+				    ("pass0: block %lu, item %d: The file %K has the wrong mode (%M), corrected to ",
+				     bh->b_blocknr, i, &ih->ih_key, mode);
+				mode &= ~S_IFMT;
+				mode |= S_IFREG;
+				fsck_log("(%M)\n", mode);
+				set_sd_mode(ih - 1, B_I_PITEM(bh, ih - 1),
+					    &mode);
+				dirty = 1;
+			}
+		}
 
-	/* Darko Palic's filesystem had item: [20079 17328 0xfffb1001 IND, len 4048], format old */
-	{
-	    struct reiserfs_key tmp_key;
+		if (is_direntry_ih(ih)) {
+			j = verify_directory_item(fs, bh, i);
+
+			if (j == 1) {
+				/* wrong hash, skip the leaf */
+				pass_0_stat(fs)->too_old_leaves++;
+				mark_buffer_clean(bh);
+				return;
+			} else if (j == -1) {
+				/* item was deleted */
+				goto start_again;
+			}
+			continue;
+		}
 
-	    tmp_key = ih->ih_key;
-	    set_offset (key_format (&tmp_key), &tmp_key,
-			get_offset (&tmp_key) + get_bytes_number (ih, bh->b_size) - 1);
+		/*DEBUG*/
+		    if (!is_stat_data_ih(ih) && get_offset(&ih->ih_key) == 0)
+			reiserfs_panic
+			    ("block %lu, item %d: Zero offset can have StatData items only, but found %k\n",
+			     bh->b_blocknr, i, &ih->ih_key);
+
+		if (!is_indirect_ih(ih))
+			continue;
+
+		/* Darko Palic's filesystem had item: [20079 17328 0xfffb1001 IND, len 4048], format old */
+		{
+			struct reiserfs_key tmp_key;
+
+			tmp_key = ih->ih_key;
+			set_offset(key_format(&tmp_key), &tmp_key,
+				   get_offset(&tmp_key) + get_bytes_number(ih,
+									   bh->
+									   b_size)
+				   - 1);
+
+			if (get_offset(&tmp_key) < get_offset(&ih->ih_key)) {
+				fsck_log
+				    ("pass0: block %lu, item %d: The item, which has wrong offset %k, is deleted\n",
+				     bh->b_blocknr, i, &ih->ih_key);
+				delete_item(fs, bh, i);
+				goto start_again;
+			}
+		}
 
-	    if (get_offset (&tmp_key) <	get_offset (&ih->ih_key)) {
-		fsck_log ("pass0: block %lu, item %d: The item, which has wrong offset %k, is deleted\n",
-		    bh->b_blocknr, i, &ih->ih_key);
-		delete_item (fs, bh, i);
-		goto start_again;
-	    }
-	}
-	
-	/* temporary ugly fix */
+		/* temporary ugly fix */
 /*
 	if (i && is_stat_data_ih (ih - 1) && !not_of_one_file (&ih->ih_key, &(ih - 1)->ih_key)) {
 	    __u16 mode;
@@ -1294,319 +1607,334 @@ static void pass0_correct_leaf (reiserfs_filsys_t * fs,
 	    }
 	}
 */
-	ind_item = (__u32 *)B_I_PITEM (bh, ih);
-	for (j = 0; j < (int)I_UNFM_NUM (ih); j ++) {
-	    unfm_ptr = d32_get (ind_item, j);
-	    if (!unfm_ptr)
-		continue;
+		ind_item = (__u32 *) B_I_PITEM(bh, ih);
+		for (j = 0; j < (int)I_UNFM_NUM(ih); j++) {
+			unfm_ptr = d32_get(ind_item, j);
+			if (!unfm_ptr)
+				continue;
 #if 0
-	    if (fsck_mode (fs) == FSCK_ZERO_FILES) {
-		/* FIXME: this is temporary mode of fsck */
-		ind_item [j] = 0;
-		reiserfs_bitmap_clear_bit (fsck_new_bitmap(fs), unfm_ptr);
-		tmp_zeroed ++;
-		dirty = 1;
-		continue;
-	    }
+			if (fsck_mode(fs) == FSCK_ZERO_FILES) {
+				/* FIXME: this is temporary mode of fsck */
+				ind_item[j] = 0;
+				reiserfs_bitmap_clear_bit(fsck_new_bitmap(fs),
+							  unfm_ptr);
+				tmp_zeroed++;
+				dirty = 1;
+				continue;
+			}
 #endif
 
-	    if (not_data_block (fs, unfm_ptr) || /* journal area or bitmap or super block */
-		unfm_ptr >= get_sb_block_count (fs->fs_ondisk_sb) || /* garbage in pointer */
-		(fs->fs_badblocks_bm && /* bad block */
-		reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, unfm_ptr))) {
-
-		pass_0_stat (fs)->wrong_pointers ++;
-		/*
-		fsck_log ("pass0: %d-th pointer (%lu) in item %k (leaf block %lu) is wrong\n",
-			  j, unfm_ptr, &ih->ih_key, bh->b_blocknr);
-		*/
-		d32_put(ind_item, j, 0);
-		dirty = 1;
-		continue;
-	    }
-	    /* mark block in bitmaps of unformatted nodes */
-	    register_unfm (unfm_ptr);
+			if (not_data_block(fs, unfm_ptr) ||	/* journal area or bitmap or super block */
+			    unfm_ptr >= get_sb_block_count(fs->fs_ondisk_sb) ||	/* garbage in pointer */
+			    (fs->fs_badblocks_bm &&	/* bad block */
+			     reiserfs_bitmap_test_bit(fs->fs_badblocks_bm,
+						      unfm_ptr))) {
+
+				pass_0_stat(fs)->wrong_pointers++;
+				/*
+				   fsck_log ("pass0: %d-th pointer (%lu) in item %k (leaf block %lu) is wrong\n",
+				   j, unfm_ptr, &ih->ih_key, bh->b_blocknr);
+				 */
+				d32_put(ind_item, j, 0);
+				dirty = 1;
+				continue;
+			}
+			/* mark block in bitmaps of unformatted nodes */
+			register_unfm(unfm_ptr);
+		}
 	}
-    }
-
-    /* mark all objectids in use */
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < get_blkh_nr_items (B_BLK_HEAD (bh)); i ++, ih ++) {
-	struct reiserfs_de_head * deh;
-
-	id_map_mark(proper_id_map (fs), get_key_dirid (&ih->ih_key));
-	id_map_mark(proper_id_map (fs), get_key_objectid (&ih->ih_key));
-	if (is_direntry_ih(ih)) {
-	    for (j = 0, deh = B_I_DEH (bh, ih); j < get_ih_entry_count (ih); j ++, deh++) 
-		id_map_mark(proper_id_map(fs), get_deh_objectid(deh));	    
+
+	/* mark all objectids in use */
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
+		struct reiserfs_de_head *deh;
+
+		id_map_mark(proper_id_map(fs), get_key_dirid(&ih->ih_key));
+		id_map_mark(proper_id_map(fs), get_key_objectid(&ih->ih_key));
+		if (is_direntry_ih(ih)) {
+			for (j = 0, deh = B_I_DEH(bh, ih);
+			     j < get_ih_entry_count(ih); j++, deh++)
+				id_map_mark(proper_id_map(fs),
+					    get_deh_objectid(deh));
+		}
+	}
+
+	if (get_blkh_nr_items(B_BLK_HEAD(bh)) < 1) {
+		/* pass 1 will skip this */
+		pass_0_stat(fs)->all_contents_removed++;
+//      fsck_log ("pass0: block %lu: All items were deleted.\n", bh->b_blocknr);
+		dirty = 0;
+		mark_buffer_clean(bh);
+	} else {
+		/* pass1 will use this bitmap */
+		pass0_mark_leaf(bh->b_blocknr);
+		/*fsck_data (fs)->rebuild.leaves ++; */
 	}
-    }
-
-    if (get_blkh_nr_items (B_BLK_HEAD (bh)) < 1) {
-	/* pass 1 will skip this */
-	pass_0_stat (fs)->all_contents_removed ++;
-//	fsck_log ("pass0: block %lu: All items were deleted.\n", bh->b_blocknr);
-	dirty = 0;
-	mark_buffer_clean (bh);
-    } else {
-	/* pass1 will use this bitmap */
-	pass0_mark_leaf (bh->b_blocknr);
-	/*fsck_data (fs)->rebuild.leaves ++;*/
-    }
-    
-    if (dirty) {
-	pass_0_stat (fs)->leaves_corrected ++;
-	mark_buffer_dirty (bh);
-    }
-}
 
+	if (dirty) {
+		pass_0_stat(fs)->leaves_corrected++;
+		mark_buffer_dirty(bh);
+	}
+}
 
-static int is_bad_sd (struct item_head * ih, char * item)
+static int is_bad_sd(struct item_head *ih, char *item)
 {
-    struct stat_data * sd = (struct stat_data *)item;
+	struct stat_data *sd = (struct stat_data *)item;
 
-    if (get_key_offset_v1 (&ih->ih_key) || get_key_uniqueness (&ih->ih_key)) {
-	fsck_log ("vpf-10610: StatData item %k has non zero offset found.\n", 
-	    &ih->ih_key);
-	return 1;
-    }
+	if (get_key_offset_v1(&ih->ih_key) || get_key_uniqueness(&ih->ih_key)) {
+		fsck_log
+		    ("vpf-10610: StatData item %k has non zero offset found.\n",
+		     &ih->ih_key);
+		return 1;
+	}
 
-    if (get_ih_item_len (ih) == SD_V1_SIZE) {
-	/* looks like old stat data */
-	if (get_ih_key_format (ih) != KEY_FORMAT_1)
-	    fsck_log ("vpf-10620: StatData item %k has wrong format.\n", 
-		&ih->ih_key);
+	if (get_ih_item_len(ih) == SD_V1_SIZE) {
+		/* looks like old stat data */
+		if (get_ih_key_format(ih) != KEY_FORMAT_1)
+			fsck_log
+			    ("vpf-10620: StatData item %k has wrong format.\n",
+			     &ih->ih_key);
+		return 0;
+	}
+
+	if (!S_ISDIR(sd_v2_mode(sd)) && !S_ISREG(sd_v2_mode(sd)) &&
+	    !S_ISCHR(sd_v2_mode(sd)) && !S_ISBLK(sd_v2_mode(sd)) &&
+	    !S_ISLNK(sd_v2_mode(sd)) && !S_ISFIFO(sd_v2_mode(sd)) &&
+	    !S_ISSOCK(sd_v2_mode(sd))) {
+		/*fsck_log ("file %k unexpected mode encountered 0%o\n", &ih->ih_key, sd_v2_mode(sd)) */
+		    ;
+	}
 	return 0;
-    }
-
-    if (!S_ISDIR (sd_v2_mode(sd)) && !S_ISREG(sd_v2_mode(sd)) &&
-	!S_ISCHR (sd_v2_mode(sd)) && !S_ISBLK(sd_v2_mode(sd)) &&
-	!S_ISLNK (sd_v2_mode(sd)) && !S_ISFIFO(sd_v2_mode(sd)) &&
-	!S_ISSOCK(sd_v2_mode(sd))) {	
-	/*fsck_log ("file %k unexpected mode encountered 0%o\n", &ih->ih_key, sd_v2_mode(sd))*/;
-    }
-    return 0;
 }
 
-
-int is_bad_directory (struct item_head * ih, char * item, int dev, int blocksize)
+int is_bad_directory(struct item_head *ih, char *item, int dev, int blocksize)
 {
-    int i;
-    char * name;
-    int namelen, entrylen;
-    struct reiserfs_de_head * deh = (struct reiserfs_de_head *)item;
-    __u32 prev_offset = 0;
-    __u16 prev_location = get_ih_item_len (ih);
-    int min_entry_size = 1;/* we have no way to understand whether the
-                              filesystem wes created in 3.6 format or
-                              converted to it. So, we assume that minimal name
-                              length is 1 */
-
-    if (get_ih_item_len (ih) / (DEH_SIZE + min_entry_size) < get_ih_entry_count (ih))
-	/* entry count is too big */
-	return 1;
+	int i;
+	char *name;
+	int namelen, entrylen;
+	struct reiserfs_de_head *deh = (struct reiserfs_de_head *)item;
+	__u32 prev_offset = 0;
+	__u16 prev_location = get_ih_item_len(ih);
+	int min_entry_size = 1;	/* we have no way to understand whether the
+				   filesystem wes created in 3.6 format or
+				   converted to it. So, we assume that minimal name
+				   length is 1 */
+
+	if (get_ih_item_len(ih) / (DEH_SIZE + min_entry_size) <
+	    get_ih_entry_count(ih))
+		/* entry count is too big */
+		return 1;
 
-    for (i = 0; i < get_ih_entry_count (ih); i ++, deh ++) {
-	entrylen = entry_length(ih, deh, i);
-	if (entrylen > (int)REISERFS_MAX_NAME_LEN (blocksize))
-	    return 1;
-	
-	if (get_deh_offset (deh) <= prev_offset)
-	    return 1;
-	
-	prev_offset = get_deh_offset (deh);
-
-	if (get_deh_location(deh) + entrylen != prev_location)
-	    return 1;
-	
-	prev_location = get_deh_location (deh);
-
-	namelen = name_in_entry_length (ih, deh, i);
-	name = name_in_entry (deh, i);
-	if (!is_properly_hashed (fs, name, namelen, get_deh_offset (deh)))
-	    return 1;
-    }
-    return 0;
-}
+	for (i = 0; i < get_ih_entry_count(ih); i++, deh++) {
+		entrylen = entry_length(ih, deh, i);
+		if (entrylen > (int)REISERFS_MAX_NAME_LEN(blocksize))
+			return 1;
+
+		if (get_deh_offset(deh) <= prev_offset)
+			return 1;
+
+		prev_offset = get_deh_offset(deh);
+
+		if (get_deh_location(deh) + entrylen != prev_location)
+			return 1;
+
+		prev_location = get_deh_location(deh);
 
+		namelen = name_in_entry_length(ih, deh, i);
+		name = name_in_entry(deh, i);
+		if (!is_properly_hashed(fs, name, namelen, get_deh_offset(deh)))
+			return 1;
+	}
+	return 0;
+}
 
 /* change incorrect block adresses by 0. Do not consider such item as incorrect */
-static int is_bad_indirect (struct item_head * ih, char * item, int dev, int blocksize)
+static int is_bad_indirect(struct item_head *ih, char *item, int dev,
+			   int blocksize)
 {
-    unsigned long blocks;
-    unsigned int i;
-    int bad = 0;
+	unsigned long blocks;
+	unsigned int i;
+	int bad = 0;
+
+	if (get_ih_item_len(ih) % UNFM_P_SIZE) {
+		fsck_log
+		    ("is_bad_indirect: indirect item of %H of invalid length\n",
+		     ih);
+		return 1;
+	}
 
-    if (get_ih_item_len(ih) % UNFM_P_SIZE) {
-	fsck_log ("is_bad_indirect: indirect item of %H of invalid length\n", ih);
-	return 1;
-    }
-
-    blocks = get_sb_block_count (fs->fs_ondisk_sb);
-  
-    for (i = 0; i < I_UNFM_NUM (ih); i ++) {
-	__u32 * ind = (__u32 *)item;
-
-	if (d32_get (ind, i) >= blocks) {
-	    bad ++;
-	    fsck_log ("is_bad_indirect: %d-th pointer of item %H looks bad (%lu)\n",
-		      i, ih, d32_get (ind, i));
-	    continue;
+	blocks = get_sb_block_count(fs->fs_ondisk_sb);
+
+	for (i = 0; i < I_UNFM_NUM(ih); i++) {
+		__u32 *ind = (__u32 *) item;
+
+		if (d32_get(ind, i) >= blocks) {
+			bad++;
+			fsck_log
+			    ("is_bad_indirect: %d-th pointer of item %H looks bad (%lu)\n",
+			     i, ih, d32_get(ind, i));
+			continue;
+		}
 	}
-    }
-    return bad;
+	return bad;
 }
 
-
 /* this is used by pass1.c:save_item and check.c:is_leaf_bad */
-int is_bad_item (struct buffer_head * bh, struct item_head * ih, char * item)
+int is_bad_item(struct buffer_head *bh, struct item_head *ih, char *item)
 {
-    int blocksize, dev;
+	int blocksize, dev;
 
-    blocksize = bh->b_size;
-    dev = bh->b_dev;
+	blocksize = bh->b_size;
+	dev = bh->b_dev;
 
-    // FIXME: refuse transparently bad items
-    if (get_key_dirid (&ih->ih_key) == get_key_objectid (&ih->ih_key))
-	return 1;
-    if (!get_key_dirid (&ih->ih_key) || !get_key_objectid (&ih->ih_key))
-	return 1;
+	// FIXME: refuse transparently bad items
+	if (get_key_dirid(&ih->ih_key) == get_key_objectid(&ih->ih_key))
+		return 1;
+	if (!get_key_dirid(&ih->ih_key) || !get_key_objectid(&ih->ih_key))
+		return 1;
 
-    if (is_stat_data_ih(ih))
-	return is_bad_sd (ih, item);
+	if (is_stat_data_ih(ih))
+		return is_bad_sd(ih, item);
 
-    if (is_direntry_ih (ih))
-	return is_bad_directory (ih, item, dev, blocksize);
+	if (is_direntry_ih(ih))
+		return is_bad_directory(ih, item, dev, blocksize);
 
-    if (is_indirect_ih (ih))
-	return is_bad_indirect (ih, item, dev, blocksize);
+	if (is_indirect_ih(ih))
+		return is_bad_indirect(ih, item, dev, blocksize);
 
-    if (is_direct_ih (ih))
-	return 0;
+	if (is_direct_ih(ih))
+		return 0;
 
-    return 1;
+	return 1;
 }
 
-
-int is_leaf_bad (struct buffer_head * bh)
+int is_leaf_bad(struct buffer_head *bh)
 {
-    int i;
-    struct item_head * ih;
-    int bad = 0;
-
-    assert (is_leaf_node (bh));
-
-    for (i = 0, ih = B_N_PITEM_HEAD (bh,  0); i < B_NR_ITEMS (bh); i ++, ih ++) {
-	if (is_bad_item (bh, ih, B_I_PITEM (bh, ih))) {
-	    fsck_log ("is_leaf_bad: block %lu, item %d: The corrupted item found (%H)\n",
-		      bh->b_blocknr, i, ih);
-	    bad = 1;
-	    continue;
-	}
+	int i;
+	struct item_head *ih;
+	int bad = 0;
+
+	assert(is_leaf_node(bh));
+
+	for (i = 0, ih = B_N_PITEM_HEAD(bh, 0); i < B_NR_ITEMS(bh); i++, ih++) {
+		if (is_bad_item(bh, ih, B_I_PITEM(bh, ih))) {
+			fsck_log
+			    ("is_leaf_bad: block %lu, item %d: The corrupted item found (%H)\n",
+			     bh->b_blocknr, i, ih);
+			bad = 1;
+			continue;
+		}
 
-	if (i && bad_pair (fs, bh, i)) {
-	    fsck_log ("is_leaf_bad: block %lu items %d and %d: Wrong order of items:"
-		"\n\t%H\n\t%H\n", bh->b_blocknr, i - 1, i, ih - 1, ih);
-	    bad = 1;
+		if (i && bad_pair(fs, bh, i)) {
+			fsck_log
+			    ("is_leaf_bad: block %lu items %d and %d: Wrong order of items:"
+			     "\n\t%H\n\t%H\n", bh->b_blocknr, i - 1, i, ih - 1,
+			     ih);
+			bad = 1;
+		}
 	}
-    }
 
-    return bad;
+	return bad;
 }
 
-
-static int is_to_be_read (reiserfs_filsys_t * fs, unsigned long block)
+static int is_to_be_read(reiserfs_filsys_t *fs, unsigned long block)
 {
-    return reiserfs_bitmap_test_bit (fsck_source_bitmap (fs), block);
+	return reiserfs_bitmap_test_bit(fsck_source_bitmap(fs), block);
 }
 
-
-
-static void do_pass_0 (reiserfs_filsys_t * fs)
+static void do_pass_0(reiserfs_filsys_t *fs)
 {
-    struct buffer_head * bh;
-    unsigned long i;
-    int what_node;
-    unsigned long done = 0, total;
-
-
-    if (fsck_mode (fs) == DO_TEST) {
-	/* just to test pass0_correct_leaf */
-	bh = bread (fs->fs_dev, fsck_data (fs)->rebuild.test, fs->fs_blocksize);
-
-	if (!bh) {
-	    /* we were reading one block at time, and failed, so mark block bad */
-	    fsck_progress ("%s: Reading of the block %lu failed\n", __FUNCTION__, 
-		fsck_data (fs)->rebuild.test);
-	    reiserfs_free (fs);
-	    exit(0);
-	}
+	struct buffer_head *bh;
+	unsigned long i;
+	int what_node;
+	unsigned long done = 0, total;
+
+	if (fsck_mode(fs) == DO_TEST) {
+		/* just to test pass0_correct_leaf */
+		bh = bread(fs->fs_dev, fsck_data(fs)->rebuild.test,
+			   fs->fs_blocksize);
+
+		if (!bh) {
+			/* we were reading one block at time, and failed, so mark block bad */
+			fsck_progress("%s: Reading of the block %lu failed\n",
+				      __FUNCTION__,
+				      fsck_data(fs)->rebuild.test);
+			reiserfs_free(fs);
+			exit(0);
+		}
 
-	if (is_leaf_bad (bh)) {
-	    fsck_progress ("###############  bad #################\n");
-	}
+		if (is_leaf_bad(bh)) {
+			fsck_progress
+			    ("###############  bad #################\n");
+		}
+
+		pass0_correct_leaf(fs, bh);
 
-	pass0_correct_leaf (fs, bh);
-	
-	print_block (stdout, fs, bh, 3, -1, -1);
+		print_block(stdout, fs, bh, 3, -1, -1);
 
-	if (is_leaf_bad (bh)) {
-	    fsck_progress ("############### still bad #################\n");
+		if (is_leaf_bad(bh)) {
+			fsck_progress
+			    ("############### still bad #################\n");
+		}
+		brelse(bh);
+		reiserfs_free(fs);
+		exit(0);
 	}
-	brelse (bh);
-	reiserfs_free (fs);
-	exit(0);
-    }
 
+	total = reiserfs_bitmap_ones(fsck_source_bitmap(fs));
 
-    total = reiserfs_bitmap_ones (fsck_source_bitmap (fs));
-	
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	if (!is_to_be_read (fs, i))
-	    continue;
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (!is_to_be_read(fs, i))
+			continue;
 
-	print_how_far (fsck_progress_file (fs), &done, total, 1, fsck_quiet (fs));
+		print_how_far(fsck_progress_file(fs), &done, total, 1,
+			      fsck_quiet(fs));
 
-	bh = bread (fs->fs_dev, i, fs->fs_blocksize);
-	if (!bh) {
-	    /* we were reading one block at time, and failed, so mark block bad */
-	    fsck_progress ("%s: Reading of the block %lu failed\n", __FUNCTION__, i);
-	    continue;
-	}
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
+		if (!bh) {
+			/* we were reading one block at time, and failed, so mark block bad */
+			fsck_progress("%s: Reading of the block %lu failed\n",
+				      __FUNCTION__, i);
+			continue;
+		}
 
-	if (fs->fs_badblocks_bm && reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))
-	    reiserfs_panic ("The block (%lu), specified in badblock list, was read.", i);
-	
-	if (not_data_block (fs, i)) {
-	    /* block which could not be pointed by indirect item */
-	    if (!(block_of_journal (fs, i) && fsck_data(fs)->rebuild.use_journal_area))
-		reiserfs_panic ("The block (%lu) from non data area was read.", i);
-	}
+		if (fs->fs_badblocks_bm
+		    && reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i))
+			reiserfs_panic
+			    ("The block (%lu), specified in badblock list, was read.",
+			     i);
+
+		if (not_data_block(fs, i)) {
+			/* block which could not be pointed by indirect item */
+			if (!
+			    (block_of_journal(fs, i)
+			     && fsck_data(fs)->rebuild.use_journal_area))
+				reiserfs_panic
+				    ("The block (%lu) from non data area was read.",
+				     i);
+		}
 
-	pass_0_stat (fs)->dealt_with ++;
-	what_node = who_is_this (bh->b_data, bh->b_size);
-	if ( what_node != THE_LEAF && what_node != HAS_IH_ARRAY ) {
-	    brelse (bh);
-	    continue;
-	}
-	
-	pass_0_stat (fs)->leaves ++;
-	pass0_correct_leaf (fs, bh);
-	brelse (bh);
-    }
-    fsck_progress ("\n");
+		pass_0_stat(fs)->dealt_with++;
+		what_node = who_is_this(bh->b_data, bh->b_size);
+		if (what_node != THE_LEAF && what_node != HAS_IH_ARRAY) {
+			brelse(bh);
+			continue;
+		}
 
+		pass_0_stat(fs)->leaves++;
+		pass0_correct_leaf(fs, bh);
+		brelse(bh);
+	}
+	fsck_progress("\n");
 
-    /* just in case */
-    id_map_mark(proper_id_map (fs), REISERFS_ROOT_OBJECTID);
+	/* just in case */
+	id_map_mark(proper_id_map(fs), REISERFS_ROOT_OBJECTID);
 
 }
 
-
-
-int is_used_leaf (unsigned long block)
+int is_used_leaf(unsigned long block)
 {
-    return pass0_is_leaf (block);
+	return pass0_is_leaf(block);
 }
 
 /*
@@ -1617,386 +1945,396 @@ int how_many_leaves_were_there (void)
 */
 
 /* these are used to correct uformatted node pointers */
-int is_bad_unformatted (unsigned long block)
+int is_bad_unformatted(unsigned long block)
 {
-    return pass0_is_bad_unfm (block);
+	return pass0_is_bad_unfm(block);
 }
 
 /* these are used to correct uformatted node pointers */
-int is_good_unformatted (unsigned long block)
+int is_good_unformatted(unsigned long block)
 {
-    return pass0_is_good_unfm (block);
+	return pass0_is_good_unfm(block);
 }
 
-
 /* this is for check only. With this we make sure that all pointers we
    put into tree on pass 1 do not point to leaves (FIXME), do not
    point to journal, bitmap, etc, do not point out of fs boundary (and
    are marked used in on-disk bitmap - this condition skipped for now). */
-int still_bad_unfm_ptr_1 (unsigned long block)
+int still_bad_unfm_ptr_1(unsigned long block)
 {
-    if (!block)
+	if (!block)
+		return 0;
+	if (pass0_is_leaf(block))
+		return 1;
+	if (pass0_is_bad_unfm(block) && !is_bad_unfm_in_tree_once(block))
+		return 2;
+	if (not_data_block(fs, block))
+		return 3;
+	/*
+	   if (!was_block_used (block))
+	   return 4;
+	 */
+	if (block >= get_sb_block_count(fs->fs_ondisk_sb))
+		return 5;
 	return 0;
-    if (pass0_is_leaf (block))
-	return 1;
-    if (pass0_is_bad_unfm (block) && !is_bad_unfm_in_tree_once (block))
-	return 2;
-    if (not_data_block (fs, block))
-	return 3;
-    /*
-    if (!was_block_used (block))
-	return 4;
-    */
-    if (block >= get_sb_block_count (fs->fs_ondisk_sb))
-	return 5;
-    return 0;
-    
-}
 
+}
 
 /* pointers to data block which get into tree are checked with this */
-int still_bad_unfm_ptr_2 (unsigned long block)
+int still_bad_unfm_ptr_2(unsigned long block)
 {
-    if (!block)
+	if (!block)
+		return 0;
+	if (is_block_used(block))
+		return 1;
+	if (block >= get_sb_block_count(fs->fs_ondisk_sb))
+		return 1;
 	return 0;
-    if (is_block_used (block))
-	return 1;
-    if (block >= get_sb_block_count (fs->fs_ondisk_sb))
-	return 1;
-    return 0;
 }
 
-
 /* these are used to allocate blocks for tree building */
-int are_there_allocable_blocks (unsigned int amout_needed) {
-    if (reiserfs_bitmap_zeros (fsck_allocable_bitmap (fs)) < amout_needed) {
-	unsigned int zeros = 0, i;
-	
-	fsck_progress ("Not enough allocable blocks, checking bitmap...");
-	for (i = 0; i < fsck_allocable_bitmap (fs)->bm_bit_size; i ++) {
-	    if (!reiserfs_bitmap_test_bit (fsck_allocable_bitmap (fs), i))
-		zeros ++;
+int are_there_allocable_blocks(unsigned int amout_needed)
+{
+	if (reiserfs_bitmap_zeros(fsck_allocable_bitmap(fs)) < amout_needed) {
+		unsigned int zeros = 0, i;
+
+		fsck_progress
+		    ("Not enough allocable blocks, checking bitmap...");
+		for (i = 0; i < fsck_allocable_bitmap(fs)->bm_bit_size; i++) {
+			if (!reiserfs_bitmap_test_bit
+			    (fsck_allocable_bitmap(fs), i))
+				zeros++;
+		}
+		fsck_progress("there are %u allocable blocks, btw\n", zeros);
+		return 0;
 	}
-	fsck_progress ("there are %u allocable blocks, btw\n", zeros);
-	return 0;
-    }
-    return 1;
+	return 1;
 }
 
-
-unsigned long alloc_block (void)
+unsigned long alloc_block(void)
 {
-    unsigned long block = 0; /* FIXME: start point could be used */
+	unsigned long block = 0;	/* FIXME: start point could be used */
 
-    if (reiserfs_bitmap_find_zero_bit (fsck_allocable_bitmap (fs), &block)) {
-	die ("alloc_block: Allocable blocks counter is wrong");
-	return 0;
-    }
-    reiserfs_bitmap_set_bit (fsck_allocable_bitmap (fs), block);
-    return block;
+	if (reiserfs_bitmap_find_zero_bit(fsck_allocable_bitmap(fs), &block)) {
+		die("alloc_block: Allocable blocks counter is wrong");
+		return 0;
+	}
+	reiserfs_bitmap_set_bit(fsck_allocable_bitmap(fs), block);
+	return block;
 }
 
-
-void make_allocable (unsigned long block)
+void make_allocable(unsigned long block)
 {
-    reiserfs_bitmap_clear_bit (fsck_allocable_bitmap (fs), block);
+	reiserfs_bitmap_clear_bit(fsck_allocable_bitmap(fs), block);
 }
 
-static void choose_hash_function (reiserfs_filsys_t * fs)
+static void choose_hash_function(reiserfs_filsys_t *fs)
 {
-    unsigned long max;
-    unsigned int hash_code;
-    int i;
+	unsigned long max;
+	unsigned int hash_code;
+	int i;
 
-    if (fsck_hash_defined (fs))
-	return;
+	if (fsck_hash_defined(fs))
+		return;
+
+	max = 0;
+	hash_code = func2code(0);
 
-    max = 0;
-    hash_code = func2code (0);
+	for (i = 0; i < fsck_data(fs)->rebuild.hash_amount; i++) {
+		/* remember hash whihc got more hits */
+		if (fsck_data(fs)->rebuild.hash_hits[i] > max) {
+			hash_code = i;
+			max = fsck_data(fs)->rebuild.hash_hits[i];
+		}
 
-    for (i = 0; i < fsck_data (fs)->rebuild.hash_amount; i ++) {
-	/* remember hash whihc got more hits */
-	if (fsck_data (fs)->rebuild.hash_hits [i] > max) {
-	    hash_code = i;
-	    max = fsck_data (fs)->rebuild.hash_hits [i];
+		if (fsck_data(fs)->rebuild.hash_hits[i])
+			fsck_log
+			    ("%lu directory entries were hashed with %s hash.\n",
+			     fsck_data(fs)->rebuild.hash_hits[i], code2name(i));
 	}
 
-	if (fsck_data (fs)->rebuild.hash_hits [i])
-	    fsck_log ("%lu directory entries were hashed with %s hash.\n", 
-		      fsck_data (fs)->rebuild.hash_hits [i], code2name(i));
-    }
-
-    if (max == 0 || hash_code == 0) {
-	/* no names were found. take either super block value or
-           default */
-        hash_code = get_sb_hash_code (fs->fs_ondisk_sb);
-	if (!hash_code)
-	    hash_code = DEFAULT_HASH;
-        fsck_log ("Could not find a hash in use. Using %s\n",
-		  code2name (hash_code));
-    }
-    /* compare the most appropriate hash with the hash set in super block */
-    if (hash_code != get_sb_hash_code (fs->fs_ondisk_sb)) {
-        fsck_progress ("Selected hash (%s) does not match to the hash set in the super block (%s).\n",
-		code2name (hash_code), code2name (get_sb_hash_code (fs->fs_ondisk_sb)));
-        set_sb_hash_code (fs->fs_ondisk_sb, hash_code);
-    } 
-    fsck_progress ("\t%s hash is selected\n", code2name (hash_code));
-    
-    reiserfs_hash (fs) = code2func (hash_code);
+	if (max == 0 || hash_code == 0) {
+		/* no names were found. take either super block value or
+		   default */
+		hash_code = get_sb_hash_code(fs->fs_ondisk_sb);
+		if (!hash_code)
+			hash_code = DEFAULT_HASH;
+		fsck_log("Could not find a hash in use. Using %s\n",
+			 code2name(hash_code));
+	}
+	/* compare the most appropriate hash with the hash set in super block */
+	if (hash_code != get_sb_hash_code(fs->fs_ondisk_sb)) {
+		fsck_progress
+		    ("Selected hash (%s) does not match to the hash set in the super block (%s).\n",
+		     code2name(hash_code),
+		     code2name(get_sb_hash_code(fs->fs_ondisk_sb)));
+		set_sb_hash_code(fs->fs_ondisk_sb, hash_code);
+	}
+	fsck_progress("\t%s hash is selected\n", code2name(hash_code));
+
+	reiserfs_hash(fs) = code2func(hash_code);
 }
 
 /* create bitmap of blocks the tree is to be built off */
 /* debugreiserfs and pass0 should share this code -s should show
 the same as we could recover - test: zero first 32M */
-static void init_source_bitmap (reiserfs_filsys_t * fs)
+static void init_source_bitmap(reiserfs_filsys_t *fs)
 {
-    FILE * fp;
-    unsigned long block_count = get_sb_block_count (fs->fs_ondisk_sb);
-    unsigned long i, j;
-    unsigned long tmp;
-    unsigned long block, reserved, bits_amount;
-
-
-    switch (fsck_data (fs)->rebuild.scan_area) {
-    case ALL_BLOCKS:
-	fsck_source_bitmap (fs) = reiserfs_create_bitmap (block_count);
-	reiserfs_bitmap_fill (fsck_source_bitmap (fs));
-	fsck_progress ("The whole partition (%u blocks) is to be scanned\n",
-		       reiserfs_bitmap_ones (fsck_source_bitmap (fs)));	
-	break;
-
-    case USED_BLOCKS:
-	fsck_progress ("Loading on-disk bitmap .. ");
-	fsck_source_bitmap (fs) = reiserfs_create_bitmap (block_count);	
-	reiserfs_bitmap_copy (fsck_source_bitmap (fs), fs->fs_bitmap2);
-	
-	fsck_progress ("ok, %u blocks marked used\n",
-		       reiserfs_bitmap_ones (fsck_source_bitmap (fs)));
-	break;
-
-    case EXTERN_BITMAP:
-	fp = fopen (fsck_data (fs)->rebuild.bitmap_file_name, "r");
-	
-	if (!fp) {
-	    reiserfs_exit (EXIT_OPER, "Could not load bitmap: %s\n", 
-			   strerror(errno));
+	FILE *fp;
+	unsigned long block_count = get_sb_block_count(fs->fs_ondisk_sb);
+	unsigned long i, j;
+	unsigned long tmp;
+	unsigned long block, reserved, bits_amount;
+
+	switch (fsck_data(fs)->rebuild.scan_area) {
+	case ALL_BLOCKS:
+		fsck_source_bitmap(fs) = reiserfs_create_bitmap(block_count);
+		reiserfs_bitmap_fill(fsck_source_bitmap(fs));
+		fsck_progress
+		    ("The whole partition (%u blocks) is to be scanned\n",
+		     reiserfs_bitmap_ones(fsck_source_bitmap(fs)));
+		break;
+
+	case USED_BLOCKS:
+		fsck_progress("Loading on-disk bitmap .. ");
+		fsck_source_bitmap(fs) = reiserfs_create_bitmap(block_count);
+		reiserfs_bitmap_copy(fsck_source_bitmap(fs), fs->fs_bitmap2);
+
+		fsck_progress("ok, %u blocks marked used\n",
+			      reiserfs_bitmap_ones(fsck_source_bitmap(fs)));
+		break;
+
+	case EXTERN_BITMAP:
+		fp = fopen(fsck_data(fs)->rebuild.bitmap_file_name, "r");
+
+		if (!fp) {
+			reiserfs_exit(EXIT_OPER, "Could not load bitmap: %s\n",
+				      strerror(errno));
+		}
+
+		fsck_source_bitmap(fs) = reiserfs_bitmap_load(fp);
+
+		if (!fsck_source_bitmap(fs)) {
+			reiserfs_exit(EXIT_OPER,
+				      "Could not load fitmap from \"%s\"",
+				      fsck_data(fs)->rebuild.bitmap_file_name);
+		}
+
+		fsck_progress("%u blocks marked used in extern bitmap\n",
+			      reiserfs_bitmap_ones(fsck_source_bitmap(fs)));
+		fclose(fp);
+		break;
+
+	default:
+		reiserfs_panic("No area to scan specified");
 	}
-	
-	fsck_source_bitmap (fs) = reiserfs_bitmap_load (fp);
-	
-	if (!fsck_source_bitmap (fs)) {
-	    reiserfs_exit (EXIT_OPER, "Could not load fitmap from \"%s\"", 
-			   fsck_data (fs)->rebuild.bitmap_file_name);
+
+	tmp = 0;
+
+	/* unmark bitmaps */
+	block = fs->fs_super_bh->b_blocknr + 1;
+
+	reserved = fsck_source_bitmap(fs)->bm_bit_size;
+	for (i = 0; i < reiserfs_fs_bmap_nr(fs); i++) {
+		if (!reiserfs_bitmap_test_bit(fsck_source_bitmap(fs), block)) {
+			/* bitmap is definitely broken, mark all blocks of this bitmap block as used */
+
+			bits_amount =
+			    (reserved <
+			     fs->fs_blocksize *
+			     8) ? reserved : fs->fs_blocksize * 8;
+			fsck_log
+			    ("%s: Bitmap %lu (of %lu bits) is wrong - mark all blocks [%lu - %lu] as used\n",
+			     __FUNCTION__, i, bits_amount,
+			     i * fs->fs_blocksize * 8,
+			     fs->fs_blocksize * 8 * i + bits_amount);
+
+			for (j = i * fs->fs_blocksize * 8;
+			     j < i * fs->fs_blocksize * 8 + bits_amount; j++) {
+				if (!reiserfs_bitmap_test_bit
+				    (fsck_source_bitmap(fs), j))
+					reiserfs_bitmap_set_bit
+					    (fsck_source_bitmap(fs), j);
+			}
+		}
+		reiserfs_bitmap_clear_bit(fsck_source_bitmap(fs), block);
+
+		reserved -= fs->fs_blocksize * 8;
+		tmp++;
+		/* next block fo bitmap */
+		if (spread_bitmaps(fs))
+			block =
+			    (block / (fs->fs_blocksize * 8) +
+			     1) * (fs->fs_blocksize * 8);
+		else
+			block++;
 	}
 
-	fsck_progress ("%u blocks marked used in extern bitmap\n",
-		       reiserfs_bitmap_ones (fsck_source_bitmap (fs)));
-	fclose (fp);
-	break;
-
-    default:
-	reiserfs_panic ("No area to scan specified");
-    }
-
-    tmp = 0;
-
-    /* unmark bitmaps */
-    block = fs->fs_super_bh->b_blocknr + 1;
-
-    reserved = fsck_source_bitmap(fs)->bm_bit_size;
-    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
-	if (!reiserfs_bitmap_test_bit (fsck_source_bitmap (fs), block)) {
-	    /* bitmap is definitely broken, mark all blocks of this bitmap block as used */
-	
-	    bits_amount = (reserved < fs->fs_blocksize * 8) ? reserved : fs->fs_blocksize * 8;
-	    fsck_log("%s: Bitmap %lu (of %lu bits) is wrong - mark all blocks [%lu - %lu] as used\n",
-		__FUNCTION__, i, bits_amount, i * fs->fs_blocksize * 8,
-		fs->fs_blocksize * 8 * i + bits_amount); 	
-				
-	    for (j = i * fs->fs_blocksize * 8; j < i * fs->fs_blocksize * 8 + bits_amount; j++) {
-	        if (!reiserfs_bitmap_test_bit (fsck_source_bitmap(fs), j))
-		    reiserfs_bitmap_set_bit (fsck_source_bitmap(fs), j);
-	    }
-        }
-        reiserfs_bitmap_clear_bit (fsck_source_bitmap (fs), block);
-
-	reserved -= fs->fs_blocksize * 8;
-	tmp ++;
-	/* next block fo bitmap */
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8);
-	else
-	    block ++;
-    }
-
-    /* pass 0 will skip super block and journal areas and bitmap blocks, find
-       how many blocks have to be read */
-    for (i = 0; i <= fs->fs_super_bh->b_blocknr; i ++) {
-	if (!reiserfs_bitmap_test_bit (fsck_source_bitmap (fs), i))
-	    continue;
-	reiserfs_bitmap_clear_bit (fsck_source_bitmap (fs), i);
-	tmp ++;
-    }
-
-    /* unmark journal area as used if journal is standard or it is non standard
-       and initialy has been created on a main device */
-
-    reserved = get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb);
-    /* where does journal area (or reserved journal area) start from */
-
-    if (!is_new_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) &&
-    	!is_old_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
-	die ("init_source_bitmap: Wrong super block location, you must run --rebuild-sb.");
-
-    block = get_journal_start_must (fs);
-
-    for (i = block; i < reserved + block; i ++) {
-	if (!reiserfs_bitmap_test_bit (fsck_source_bitmap (fs), i))
-	    continue;
-	reiserfs_bitmap_clear_bit (fsck_source_bitmap (fs), i);
-	tmp ++;	
-    }
-
-    if (fs->fs_badblocks_bm)
-    	for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	    if (reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))
-		reiserfs_bitmap_clear_bit (fsck_source_bitmap (fs), i);
-    	}
-
-    fsck_source_bitmap (fs)->bm_set_bits = reiserfs_bitmap_ones (fsck_source_bitmap (fs));
-
-    fsck_progress ("Skipping %u blocks (super block, journal, "
-		   "bitmaps) %u blocks will be read\n", tmp, fsck_source_bitmap (fs)->bm_set_bits);
-		
-}
+	/* pass 0 will skip super block and journal areas and bitmap blocks, find
+	   how many blocks have to be read */
+	for (i = 0; i <= fs->fs_super_bh->b_blocknr; i++) {
+		if (!reiserfs_bitmap_test_bit(fsck_source_bitmap(fs), i))
+			continue;
+		reiserfs_bitmap_clear_bit(fsck_source_bitmap(fs), i);
+		tmp++;
+	}
 
+	/* unmark journal area as used if journal is standard or it is non standard
+	   and initialy has been created on a main device */
 
-static void before_pass_0 (reiserfs_filsys_t * fs)
-{
-    /* bitmap of blocks to be read */
-    init_source_bitmap (fs);
+	reserved = get_size_of_journal_or_reserved_area(fs->fs_ondisk_sb);
+	/* where does journal area (or reserved journal area) start from */
 
-    /* bitmap of leaves, good and bad unformatted */
-    make_aux_bitmaps (fs);
+	if (!is_new_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) &&
+	    !is_old_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
+		die("init_source_bitmap: Wrong super block location, you must run --rebuild-sb.");
 
-    /* on pass0 all objectids will be marked here as used */
-    proper_id_map (fs) = id_map_init();
+	block = get_journal_start_must(fs);
 
-    /* pass0 gathers statistics about hash hits */
-    hash_hits_init (fs);
-}
+	for (i = block; i < reserved + block; i++) {
+		if (!reiserfs_bitmap_test_bit(fsck_source_bitmap(fs), i))
+			continue;
+		reiserfs_bitmap_clear_bit(fsck_source_bitmap(fs), i);
+		tmp++;
+	}
+
+	if (fs->fs_badblocks_bm)
+		for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+			if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i))
+				reiserfs_bitmap_clear_bit(fsck_source_bitmap
+							  (fs), i);
+		}
+
+	fsck_source_bitmap(fs)->bm_set_bits =
+	    reiserfs_bitmap_ones(fsck_source_bitmap(fs));
+
+	fsck_progress("Skipping %u blocks (super block, journal, "
+		      "bitmaps) %u blocks will be read\n", tmp,
+		      fsck_source_bitmap(fs)->bm_set_bits);
 
+}
 
-static void save_pass_0_result (reiserfs_filsys_t * fs)
+static void before_pass_0(reiserfs_filsys_t *fs)
 {
-    FILE * file;
-    int retval;
+	/* bitmap of blocks to be read */
+	init_source_bitmap(fs);
 
-    /* save bitmaps with which we will be able start reiserfs from
-       pass 1 */
-    file = open_file ("temp_fsck_file.deleteme", "w+");
-    if (!file)
-	return;
+	/* bitmap of leaves, good and bad unformatted */
+	make_aux_bitmaps(fs);
+
+	/* on pass0 all objectids will be marked here as used */
+	proper_id_map(fs) = id_map_init();
 
-    reiserfs_begin_stage_info_save (file, PASS_0_DONE);
-    reiserfs_bitmap_save (file,  leaves_bitmap);
-    reiserfs_bitmap_save (file,  good_unfm_bitmap);
-    reiserfs_bitmap_save (file,  bad_unfm_bitmap);
-    reiserfs_end_stage_info_save (file);
-    close_file (file);
-    retval = rename ("temp_fsck_file.deleteme", state_dump_file (fs));
-    if (retval != 0)
-	fsck_progress ("%s: Could not rename the temporary file temp_fsck_file.deleteme to %s",
-	    __FUNCTION__, state_dump_file (fs));
+	/* pass0 gathers statistics about hash hits */
+	hash_hits_init(fs);
 }
 
+static void save_pass_0_result(reiserfs_filsys_t *fs)
+{
+	FILE *file;
+	int retval;
+
+	/* save bitmaps with which we will be able start reiserfs from
+	   pass 1 */
+	file = open_file("temp_fsck_file.deleteme", "w+");
+	if (!file)
+		return;
+
+	reiserfs_begin_stage_info_save(file, PASS_0_DONE);
+	reiserfs_bitmap_save(file, leaves_bitmap);
+	reiserfs_bitmap_save(file, good_unfm_bitmap);
+	reiserfs_bitmap_save(file, bad_unfm_bitmap);
+	reiserfs_end_stage_info_save(file);
+	close_file(file);
+	retval = rename("temp_fsck_file.deleteme", state_dump_file(fs));
+	if (retval != 0)
+		fsck_progress
+		    ("%s: Could not rename the temporary file temp_fsck_file.deleteme to %s",
+		     __FUNCTION__, state_dump_file(fs));
+}
 
 /* file 'fp' must contain 3 bitmaps saved during last pass 0: bitmap
    of leaves, bitmaps of good and bad unfms*/
-void load_pass_0_result (FILE * fp, reiserfs_filsys_t * fs)
+void load_pass_0_result(FILE * fp, reiserfs_filsys_t *fs)
 {
-    leaves_bitmap = reiserfs_bitmap_load (fp);
-    good_unfm_bitmap = reiserfs_bitmap_load (fp);
-    bad_unfm_bitmap = reiserfs_bitmap_load (fp);
-    if (!leaves_bitmap || !good_unfm_bitmap || !bad_unfm_bitmap)
-	fsck_exit ("State dump file seems corrupted. Run without -d");
+	leaves_bitmap = reiserfs_bitmap_load(fp);
+	good_unfm_bitmap = reiserfs_bitmap_load(fp);
+	bad_unfm_bitmap = reiserfs_bitmap_load(fp);
+	if (!leaves_bitmap || !good_unfm_bitmap || !bad_unfm_bitmap)
+		fsck_exit("State dump file seems corrupted. Run without -d");
 
-    fsck_source_bitmap (fs) = leaves_bitmap;
+	fsck_source_bitmap(fs) = leaves_bitmap;
 
-    /* on pass 1 we do not need proper objectid map */
+	/* on pass 1 we do not need proper objectid map */
 
-    fsck_progress ("Pass 0 result loaded. %d leaves, %d/%d good/bad data blocks\n",
-		   reiserfs_bitmap_ones (leaves_bitmap),
-		   reiserfs_bitmap_ones (good_unfm_bitmap),
-		   reiserfs_bitmap_ones (bad_unfm_bitmap));
+	fsck_progress
+	    ("Pass 0 result loaded. %d leaves, %d/%d good/bad data blocks\n",
+	     reiserfs_bitmap_ones(leaves_bitmap),
+	     reiserfs_bitmap_ones(good_unfm_bitmap),
+	     reiserfs_bitmap_ones(bad_unfm_bitmap));
 }
 
-
-static void after_pass_0 (reiserfs_filsys_t * fs)
+static void after_pass_0(reiserfs_filsys_t *fs)
 {
-    time_t t;
-
-    /* update super block: hash, objectid map, fsck state */
-    choose_hash_function (fs);
-    id_map_flush(proper_id_map (fs), fs);
-    set_sb_fs_state (fs->fs_ondisk_sb, PASS_0_DONE);
-    mark_buffer_dirty (fs->fs_super_bh);
-
-    /* write all dirty blocks */
-    fsck_progress ("Flushing..");
-    fs->fs_dirt = 1;
-    reiserfs_flush (fs);
-    fsck_progress ("finished\n");
-
-    stage_report (0, fs);
-
-    /* free what we do not need anymore */
-    reiserfs_delete_bitmap (fsck_source_bitmap (fs));
-    fsck_source_bitmap (fs) = 0;
-
-    if (!fsck_run_one_step (fs)) {
-	if (fsck_user_confirmed (fs, "Continue? (Yes):", "Yes\n", 1)) {
-	    /* reiserfsck continues */
-	    fsck_source_bitmap (fs) = leaves_bitmap;
-	    return;
-	}
-    } else
-	save_pass_0_result (fs);
-
-    id_map_free(proper_id_map (fs));
-    proper_id_map (fs) = 0;
-    
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck finished pass 0 at %s"
-		   "###########\n", ctime (&t));
-    fs->fs_dirt = 1;
-    reiserfs_close (fs);
-    exit(0);
+	time_t t;
+
+	/* update super block: hash, objectid map, fsck state */
+	choose_hash_function(fs);
+	id_map_flush(proper_id_map(fs), fs);
+	set_sb_fs_state(fs->fs_ondisk_sb, PASS_0_DONE);
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	/* write all dirty blocks */
+	fsck_progress("Flushing..");
+	fs->fs_dirt = 1;
+	reiserfs_flush(fs);
+	fsck_progress("finished\n");
+
+	stage_report(0, fs);
+
+	/* free what we do not need anymore */
+	reiserfs_delete_bitmap(fsck_source_bitmap(fs));
+	fsck_source_bitmap(fs) = 0;
+
+	if (!fsck_run_one_step(fs)) {
+		if (fsck_user_confirmed(fs, "Continue? (Yes):", "Yes\n", 1)) {
+			/* reiserfsck continues */
+			fsck_source_bitmap(fs) = leaves_bitmap;
+			return;
+		}
+	} else
+		save_pass_0_result(fs);
+
+	id_map_free(proper_id_map(fs));
+	proper_id_map(fs) = 0;
+
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck finished pass 0 at %s"
+		      "###########\n", ctime(&t));
+	fs->fs_dirt = 1;
+	reiserfs_close(fs);
+	exit(0);
 }
 
-
-void pass_0 (reiserfs_filsys_t * fs)
+void pass_0(reiserfs_filsys_t *fs)
 {
-    if (get_reiserfs_format (fs->fs_ondisk_sb) != fs->fs_format || 
-        get_reiserfs_format (fs->fs_ondisk_sb) == REISERFS_FORMAT_UNKNOWN)
-    {
-	reiserfs_exit (EXIT_OPER, "pass 0: ReiserFS format version mismatch "
-		       "found, you should run --rebuild-sb");
-    }
-  
-    fsck_progress ("\nPass 0:\n");
-    if (fsck_log_file (fs) != stderr)
-	/* this is just to separate warnings in the log file */
-	fsck_log ("####### Pass 0 #######\n");
+	if (get_reiserfs_format(fs->fs_ondisk_sb) != fs->fs_format ||
+	    get_reiserfs_format(fs->fs_ondisk_sb) == REISERFS_FORMAT_UNKNOWN) {
+		reiserfs_exit(EXIT_OPER,
+			      "pass 0: ReiserFS format version mismatch "
+			      "found, you should run --rebuild-sb");
+	}
 
+	fsck_progress("\nPass 0:\n");
+	if (fsck_log_file(fs) != stderr)
+		/* this is just to separate warnings in the log file */
+		fsck_log("####### Pass 0 #######\n");
 
-    before_pass_0 (fs);
+	before_pass_0(fs);
 
-    /* scan the partition, find leaves and correct them */
-    do_pass_0 (fs);
+	/* scan the partition, find leaves and correct them */
+	do_pass_0(fs);
 
-    after_pass_0 (fs);
+	after_pass_0(fs);
 }
-
diff --git a/fsck/pass1.c b/fsck/pass1.c
index 4297623..fa8ed1f 100644
--- a/fsck/pass1.c
+++ b/fsck/pass1.c
@@ -5,328 +5,329 @@
 
 #include "fsck.h"
 
-reiserfs_bitmap_t * bad_unfm_in_tree_once_bitmap;
-
+reiserfs_bitmap_t *bad_unfm_in_tree_once_bitmap;
 
 //int step = 0; // 0 - find stat_data or any item ; 1 - find item ; 2 - already found
 
-
 /* allocates buffer head and copy buffer content */
-struct buffer_head * make_buffer (int dev, unsigned long blocknr, int size, char * data)
+struct buffer_head *make_buffer(int dev, unsigned long blocknr, int size,
+				char *data)
 {
-    struct buffer_head * bh;
-    
-    bh = getblk (dev, blocknr, size);
-    if (buffer_uptodate (bh))
-	return bh;
+	struct buffer_head *bh;
+
+	bh = getblk(dev, blocknr, size);
+	if (buffer_uptodate(bh))
+		return bh;
 //    die ("make_buffer: uptodate buffer found");
-    memcpy (bh->b_data, data, size);
-    misc_set_bit (BH_Uptodate, (char *)&bh->b_state);
-    return bh;
+	memcpy(bh->b_data, data, size);
+	misc_set_bit(BH_Uptodate, (char *)&bh->b_state);
+	return bh;
 }
 
-
-int find_not_of_one_file(struct reiserfs_key *to_find, struct reiserfs_key *key) {
-    if ((get_key_objectid (to_find) != ~(__u32)0) &&
-        (get_key_objectid (to_find) != get_key_objectid (key)))
-        return 1;
-    if ((get_key_dirid (to_find) != ~(__u32)0) &&
-        (get_key_dirid (to_find) != get_key_dirid (key)))
-        return 1;
-    return 0;
+int find_not_of_one_file(struct reiserfs_key *to_find, struct reiserfs_key *key)
+{
+	if ((get_key_objectid(to_find) != ~(__u32) 0) &&
+	    (get_key_objectid(to_find) != get_key_objectid(key)))
+		return 1;
+	if ((get_key_dirid(to_find) != ~(__u32) 0) &&
+	    (get_key_dirid(to_find) != get_key_dirid(key)))
+		return 1;
+	return 0;
 }
 
-
-int is_item_reachable (struct item_head * ih)
+int is_item_reachable(struct item_head *ih)
 {
-    return ih_reachable (ih) ? 1 : 0;
+	return ih_reachable(ih) ? 1 : 0;
 }
 
-
-void mark_item_unreachable (struct item_head * ih)
+void mark_item_unreachable(struct item_head *ih)
 {
-    clean_ih_flags (ih);
-    mark_ih_unreachable (ih);
+	clean_ih_flags(ih);
+	mark_ih_unreachable(ih);
 
-    if (is_indirect_ih (ih))
-	set_ih_free_space (ih, 0);
+	if (is_indirect_ih(ih))
+		set_ih_free_space(ih, 0);
 }
 
-
-void mark_item_reachable (struct item_head * ih, struct buffer_head * bh)
+void mark_item_reachable(struct item_head *ih, struct buffer_head *bh)
 {
-    mark_ih_reachable (ih);
-    mark_buffer_dirty (bh);
+	mark_ih_reachable(ih);
+	mark_buffer_dirty(bh);
 }
 
-static void stat_data_in_tree (struct buffer_head *bh,
-			       struct item_head * ih)
+static void stat_data_in_tree(struct buffer_head *bh, struct item_head *ih)
 {
 #if 0
-    __u32 objectid;
-    
-    objectid = get_key_objectid (&ih->ih_key);
-    
-    if (mark_objectid_really_used (proper_id_map (fs), objectid)) {
-	stat_shared_objectid_found (fs);
-	mark_objectid_really_used (shared_id_map (fs), objectid);
-    }
+	__u32 objectid;
+
+	objectid = get_key_objectid(&ih->ih_key);
+
+	if (mark_objectid_really_used(proper_id_map(fs), objectid)) {
+		stat_shared_objectid_found(fs);
+		mark_objectid_really_used(shared_id_map(fs), objectid);
+	}
 #endif
-    
-    zero_nlink (ih, B_I_PITEM (bh, ih));
+
+	zero_nlink(ih, B_I_PITEM(bh, ih));
 }
 
-static char *still_bad_unfm_ptr_to_string (int val) {
-    switch (val) {
+static char *still_bad_unfm_ptr_to_string(int val)
+{
+	switch (val) {
 	case 1:
-	    return "a leaf";
+		return "a leaf";
 	case 2:
-	    return "shared between a few files";
+		return "shared between a few files";
 	case 3:
-	    return "not a data block";
+		return "not a data block";
 	case 4:
-	    return "not used in on-disk bitmap";
+		return "not used in on-disk bitmap";
 	case 5:
-	    return "out of partition boundary";
-    }
-    return "";
+		return "out of partition boundary";
+	}
+	return "";
 }
 
 /* this just marks blocks pointed by an indirect item as used in the
    new bitmap */
-static void indirect_in_tree (struct buffer_head * bh,
-			      struct item_head * ih)
+static void indirect_in_tree(struct buffer_head *bh, struct item_head *ih)
 {
-    unsigned int i;
-    __u32 * unp;
-    __u32 unfm_ptr;
-    int ret;
-
-    unp = (__u32 *)B_I_PITEM (bh, ih);
-    
-    for (i = 0; i < I_UNFM_NUM (ih); i ++) {
-	unfm_ptr = d32_get (unp, i);
-	if (unfm_ptr == 0)
-	    continue;
-	if ((ret = still_bad_unfm_ptr_1 (unfm_ptr)))
-	    reiserfs_panic ("%s: block %lu: The file %k points to the block (%u) which is %s", 
-		__FUNCTION__, bh->b_blocknr, &ih->ih_key, unfm_ptr, still_bad_unfm_ptr_to_string(ret));
-
-	mark_block_used (unfm_ptr, 1);
-    }
-}
+	unsigned int i;
+	__u32 *unp;
+	__u32 unfm_ptr;
+	int ret;
+
+	unp = (__u32 *) B_I_PITEM(bh, ih);
 
+	for (i = 0; i < I_UNFM_NUM(ih); i++) {
+		unfm_ptr = d32_get(unp, i);
+		if (unfm_ptr == 0)
+			continue;
+		if ((ret = still_bad_unfm_ptr_1(unfm_ptr)))
+			reiserfs_panic
+			    ("%s: block %lu: The file %k points to the block (%u) which is %s",
+			     __FUNCTION__, bh->b_blocknr, &ih->ih_key, unfm_ptr,
+			     still_bad_unfm_ptr_to_string(ret));
+
+		mark_block_used(unfm_ptr, 1);
+	}
+}
 
-static void leaf_is_in_tree_now (struct buffer_head * bh)
+static void leaf_is_in_tree_now(struct buffer_head *bh)
 {
-    item_action_t actions[] = {stat_data_in_tree, indirect_in_tree, 0, 0};
+	item_action_t actions[] = { stat_data_in_tree, indirect_in_tree, 0, 0 };
 
-    mark_block_used ((bh)->b_blocknr, 1);
+	mark_block_used((bh)->b_blocknr, 1);
 
-    for_every_item (bh, mark_item_unreachable, actions);
+	for_every_item(bh, mark_item_unreachable, actions);
 
-    pass_1_stat (fs)->inserted_leaves ++;
+	pass_1_stat(fs)->inserted_leaves++;
 
-    mark_buffer_dirty (bh);
+	mark_buffer_dirty(bh);
 }
 
-
-static void insert_pointer (struct buffer_head * bh, struct reiserfs_path *path)
+static void insert_pointer(struct buffer_head *bh, struct reiserfs_path *path)
 {
-    struct item_head * ih;
-    char * body;
-    int retval;
-    struct tree_balance tb;
-    
-    init_tb_struct (&tb, fs, path, 0x7fff);
-
-    /* fix_nodes & do_balance must work for internal nodes only */
-    ih = 0;
-
-    retval = fix_nodes (/*tb.transaction_handle,*/ M_INTERNAL, &tb, ih);
-    if (retval != CARRY_ON)
-	die ("insert_pointer: fix_nodes failed with retval == %d", retval);
-    
-    /* child_pos: we insert after position child_pos: this feature of the insert_child */
-    /* there is special case: we insert pointer after
-       (-1)-st key (before 0-th key) in the parent */
-    if (PATH_LAST_POSITION (path) == 0 && path->pos_in_item == 0)
-	PATH_H_B_ITEM_ORDER (path, 0) = -1;
-    else {
-	if (PATH_H_PPARENT (path, 0) == 0)
-	    PATH_H_B_ITEM_ORDER (path, 0) = 0;
+	struct item_head *ih;
+	char *body;
+	int retval;
+	struct tree_balance tb;
+
+	init_tb_struct(&tb, fs, path, 0x7fff);
+
+	/* fix_nodes & do_balance must work for internal nodes only */
+	ih = 0;
+
+	retval = fix_nodes( /*tb.transaction_handle, */ M_INTERNAL, &tb, ih);
+	if (retval != CARRY_ON)
+		die("insert_pointer: fix_nodes failed with retval == %d",
+		    retval);
+
+	/* child_pos: we insert after position child_pos: this feature of the insert_child */
+	/* there is special case: we insert pointer after
+	   (-1)-st key (before 0-th key) in the parent */
+	if (PATH_LAST_POSITION(path) == 0 && path->pos_in_item == 0)
+		PATH_H_B_ITEM_ORDER(path, 0) = -1;
+	else {
+		if (PATH_H_PPARENT(path, 0) == 0)
+			PATH_H_B_ITEM_ORDER(path, 0) = 0;
 /*    PATH_H_B_ITEM_ORDER (path, 0) = PATH_H_PPARENT (path, 0) ? PATH_H_B_ITEM_ORDER (path, 0) : 0;*/
-    }
-    
-    ih = 0;
-    body = (char *)bh;
-    //memmode = 0;
+	}
 
-    do_balance (&tb, ih, body, M_INTERNAL, 0);
+	ih = 0;
+	body = (char *)bh;
+	//memmode = 0;
 
-    leaf_is_in_tree_now (bh);
-}
+	do_balance(&tb, ih, body, M_INTERNAL, 0);
 
+	leaf_is_in_tree_now(bh);
+}
 
 /* return 1 if left and right can be joined. 0 otherwise */
-int balance_condition_fails (struct buffer_head * left, struct buffer_head * right)
+int balance_condition_fails(struct buffer_head *left, struct buffer_head *right)
 {
-    if (B_FREE_SPACE (left) >= B_CHILD_SIZE (right) -
-	(are_items_mergeable (B_N_PITEM_HEAD (left, B_NR_ITEMS (left) - 1), B_N_PITEM_HEAD (right, 0), left->b_size) ? IH_SIZE : 0))
-	return 1;
-    return 0;
+	if (B_FREE_SPACE(left) >= B_CHILD_SIZE(right) -
+	    (are_items_mergeable
+	     (B_N_PITEM_HEAD(left, B_NR_ITEMS(left) - 1),
+	      B_N_PITEM_HEAD(right, 0), left->b_size) ? IH_SIZE : 0))
+		return 1;
+	return 0;
 }
 
-
 /* return 1 if new can be joined with last node on the path or with
    its right neighbor, 0 otherwise */
-int balance_condition_2_fails (struct buffer_head * new, struct reiserfs_path *path)
+int balance_condition_2_fails(struct buffer_head *new,
+			      struct reiserfs_path *path)
 {
-    struct buffer_head * bh;
-    struct reiserfs_key *right_dkey;
-    int pos, used_space;
-    
-    bh = PATH_PLAST_BUFFER (path);
-    
-
-    if (balance_condition_fails (bh, new))
-	/* new node can be joined with last buffer on the path */
-	return 1;
-    
-    /* new node can not be joined with its left neighbor */
-    
-    right_dkey = uget_rkey (path);
-    if (right_dkey == 0)
-	/* there is no right neighbor */
+	struct buffer_head *bh;
+	struct reiserfs_key *right_dkey;
+	int pos, used_space;
+
+	bh = PATH_PLAST_BUFFER(path);
+
+	if (balance_condition_fails(bh, new))
+		/* new node can be joined with last buffer on the path */
+		return 1;
+
+	/* new node can not be joined with its left neighbor */
+
+	right_dkey = uget_rkey(path);
+	if (right_dkey == 0)
+		/* there is no right neighbor */
+		return 0;
+
+	pos = PATH_H_POSITION(path, 1);
+	if (pos == B_NR_ITEMS(bh = PATH_H_PBUFFER(path, 1))) {
+		/* we have to read parent of right neighbor. For simplicity we
+		   call search_by_key, which will read right neighbor as well */
+		INITIALIZE_REISERFS_PATH(path_to_right_neighbor);
+
+		if (reiserfs_search_by_key_4
+		    (fs, right_dkey, &path_to_right_neighbor) != ITEM_FOUND)
+			reiserfs_panic
+			    ("%s: block %lu, pointer %d: The left delimiting key %k of the block (%lu) is wrong,"
+			     "the item cannot be found", __FUNCTION__,
+			     PATH_H_PBUFFER(path, 1)->b_blocknr, pos,
+			     right_dkey,
+			     get_dc_child_blocknr(B_N_CHILD(bh, pos + 1)));
+
+		used_space =
+		    B_CHILD_SIZE(PATH_PLAST_BUFFER(&path_to_right_neighbor));
+		pathrelse(&path_to_right_neighbor);
+	} else
+		used_space = get_dc_child_size(B_N_CHILD(bh, pos + 1));
+
+	if (B_FREE_SPACE(new) >= used_space -
+	    (are_items_mergeable
+	     (B_N_PITEM_HEAD(new, B_NR_ITEMS(new) - 1),
+	      (struct item_head *)right_dkey, new->b_size) ? IH_SIZE : 0))
+		return 1;
+
 	return 0;
-    
-    pos = PATH_H_POSITION (path, 1);
-    if (pos == B_NR_ITEMS (bh = PATH_H_PBUFFER (path, 1))) {
-	/* we have to read parent of right neighbor. For simplicity we
-	   call search_by_key, which will read right neighbor as well */
-	INITIALIZE_REISERFS_PATH(path_to_right_neighbor);
-	
-	if (reiserfs_search_by_key_4 (fs, right_dkey, &path_to_right_neighbor) != ITEM_FOUND)
-	    reiserfs_panic ("%s: block %lu, pointer %d: The left delimiting key %k of the block (%lu) is wrong,"
-		"the item cannot be found", __FUNCTION__, PATH_H_PBUFFER(path, 1)->b_blocknr, pos, 
-		right_dkey, get_dc_child_blocknr(B_N_CHILD (bh, pos + 1)));
-
-	used_space =  B_CHILD_SIZE (PATH_PLAST_BUFFER (&path_to_right_neighbor));
-	pathrelse (&path_to_right_neighbor);
-    }
-    else
-	used_space = get_dc_child_size (B_N_CHILD (bh, pos + 1));
-    
-    if (B_FREE_SPACE (new) >= used_space -
-	(are_items_mergeable (B_N_PITEM_HEAD (new, B_NR_ITEMS (new) - 1), (struct item_head *)right_dkey, new->b_size) ? IH_SIZE : 0))
-	return 1;
-
-    return 0;
 }
 
-
-static void get_max_buffer_key (struct buffer_head * bh, struct reiserfs_key *key)
+static void get_max_buffer_key(struct buffer_head *bh, struct reiserfs_key *key)
 {
-    struct item_head * ih;
-
-    ih = B_N_PITEM_HEAD (bh, B_NR_ITEMS (bh) - 1);
-    copy_key (key, &(ih->ih_key));
-
-    if (is_direntry_key (key)) {
-	/* copy deh_offset 3-rd and 4-th key components of the last entry */
-	set_offset (KEY_FORMAT_1, key, 
-		    get_deh_offset (B_I_DEH (bh, ih) + get_ih_entry_count (ih) - 1));
-
-    } else if (!is_stat_data_key (key))
-	/* get key of the last byte, which is contained in the item */
-	set_offset (key_format (key), key, get_offset (key) + get_bytes_number (ih, bh->b_size) - 1);
+	struct item_head *ih;
+
+	ih = B_N_PITEM_HEAD(bh, B_NR_ITEMS(bh) - 1);
+	copy_key(key, &(ih->ih_key));
+
+	if (is_direntry_key(key)) {
+		/* copy deh_offset 3-rd and 4-th key components of the last entry */
+		set_offset(KEY_FORMAT_1, key,
+			   get_deh_offset(B_I_DEH(bh, ih) +
+					  get_ih_entry_count(ih) - 1));
+
+	} else if (!is_stat_data_key(key))
+		/* get key of the last byte, which is contained in the item */
+		set_offset(key_format(key), key,
+			   get_offset(key) + get_bytes_number(ih,
+							      bh->b_size) - 1);
 }
 
-
-int tree_is_empty (void)
+int tree_is_empty(void)
 {
-    return (get_sb_root_block (fs->fs_ondisk_sb) == ~(__u32)0 || 
-	    get_sb_root_block (fs->fs_ondisk_sb) == 0) ? 1 : 0;
+	return (get_sb_root_block(fs->fs_ondisk_sb) == ~(__u32) 0 ||
+		get_sb_root_block(fs->fs_ondisk_sb) == 0) ? 1 : 0;
 }
 
-
-void make_single_leaf_tree (struct buffer_head * bh)
+void make_single_leaf_tree(struct buffer_head *bh)
 {
-    /* tree is empty, make tree root */
-    set_sb_root_block (fs->fs_ondisk_sb, bh->b_blocknr);
-    set_sb_tree_height (fs->fs_ondisk_sb, 2);
-    mark_buffer_dirty (fs->fs_super_bh);
-    leaf_is_in_tree_now (bh);
+	/* tree is empty, make tree root */
+	set_sb_root_block(fs->fs_ondisk_sb, bh->b_blocknr);
+	set_sb_tree_height(fs->fs_ondisk_sb, 2);
+	mark_buffer_dirty(fs->fs_super_bh);
+	leaf_is_in_tree_now(bh);
 }
 
-
 /* inserts pointer to leaf into tree if possible. If not, marks node as
    uninsertable in special bitmap */
-static void try_to_insert_pointer_to_leaf (struct buffer_head * new_bh)
+static void try_to_insert_pointer_to_leaf(struct buffer_head *new_bh)
 {
-    INITIALIZE_REISERFS_PATH(path);
-    struct buffer_head * bh;			/* last path buffer */
-    struct reiserfs_key *first_bh_key, last_bh_key;	/* first and last keys of new buffer */
-    struct reiserfs_key last_path_buffer_last_key, * right_dkey;
-    int ret_value;
-
-    if (tree_is_empty () == 1) {
-	make_single_leaf_tree (new_bh);
-	return;
-    }
-
-    first_bh_key = B_N_PKEY (new_bh, 0);
-    
-    /* try to find place in the tree for the first key of the coming node */
-    ret_value = reiserfs_search_by_key_4 (fs, first_bh_key, &path);
-    if (ret_value == ITEM_FOUND)
-	goto cannot_insert;
-
-    /* get max key in the new node */
-    get_max_buffer_key (new_bh, &last_bh_key);
-
-    bh = PATH_PLAST_BUFFER (&path);
-    if (comp_keys (B_N_PKEY (bh, 0), &last_bh_key) == 1/* first is greater*/) {
-	/* new buffer falls before the leftmost leaf */
-	if (balance_condition_fails (new_bh, bh))
-	    goto cannot_insert;
-	
-	if (uget_lkey (&path) != 0 || PATH_LAST_POSITION (&path) != 0)
-	    die ("try_to_insert_pointer_to_leaf: bad search result");
-	
-	path.pos_in_item = 0;
-	goto insert;
-    }
-    
-    /* get max key of buffer, that is in tree */
-    get_max_buffer_key (bh, &last_path_buffer_last_key);
-    if (comp_keys (&last_path_buffer_last_key, first_bh_key) != -1/* second is greater */)
-	/* first key of new buffer falls in the middle of node that is in tree */
-	goto cannot_insert;
-    
-    right_dkey = uget_rkey (&path);
-    if (right_dkey && comp_keys (right_dkey, &last_bh_key) != 1 /* first is greater */)
-	goto cannot_insert;
-    
-    if (balance_condition_2_fails (new_bh, &path))
-	goto cannot_insert;
-
-
- insert:
-    insert_pointer (new_bh, &path);
-    goto out;
-    
- cannot_insert:
-    /* statistic */
-
-    mark_block_uninsertable (new_bh->b_blocknr);
-    
- out:
-    pathrelse (&path);
-    return;
-}
+	INITIALIZE_REISERFS_PATH(path);
+	struct buffer_head *bh;	/* last path buffer */
+	struct reiserfs_key *first_bh_key, last_bh_key;	/* first and last keys of new buffer */
+	struct reiserfs_key last_path_buffer_last_key, *right_dkey;
+	int ret_value;
+
+	if (tree_is_empty() == 1) {
+		make_single_leaf_tree(new_bh);
+		return;
+	}
+
+	first_bh_key = B_N_PKEY(new_bh, 0);
 
+	/* try to find place in the tree for the first key of the coming node */
+	ret_value = reiserfs_search_by_key_4(fs, first_bh_key, &path);
+	if (ret_value == ITEM_FOUND)
+		goto cannot_insert;
 
+	/* get max key in the new node */
+	get_max_buffer_key(new_bh, &last_bh_key);
+
+	bh = PATH_PLAST_BUFFER(&path);
+	if (comp_keys(B_N_PKEY(bh, 0), &last_bh_key) ==
+	    1 /* first is greater */ ) {
+		/* new buffer falls before the leftmost leaf */
+		if (balance_condition_fails(new_bh, bh))
+			goto cannot_insert;
+
+		if (uget_lkey(&path) != 0 || PATH_LAST_POSITION(&path) != 0)
+			die("try_to_insert_pointer_to_leaf: bad search result");
+
+		path.pos_in_item = 0;
+		goto insert;
+	}
+
+	/* get max key of buffer, that is in tree */
+	get_max_buffer_key(bh, &last_path_buffer_last_key);
+	if (comp_keys(&last_path_buffer_last_key, first_bh_key) !=
+	    -1 /* second is greater */ )
+		/* first key of new buffer falls in the middle of node that is in tree */
+		goto cannot_insert;
+
+	right_dkey = uget_rkey(&path);
+	if (right_dkey
+	    && comp_keys(right_dkey, &last_bh_key) != 1 /* first is greater */ )
+		goto cannot_insert;
+
+	if (balance_condition_2_fails(new_bh, &path))
+		goto cannot_insert;
+
+insert:
+	insert_pointer(new_bh, &path);
+	goto out;
+
+cannot_insert:
+	/* statistic */
+
+	mark_block_uninsertable(new_bh->b_blocknr);
+
+out:
+	pathrelse(&path);
+	return;
+}
 
 /* everything should be correct already in the leaf but contents of indirect
    items. So we only
@@ -335,487 +336,501 @@ static void try_to_insert_pointer_to_leaf (struct buffer_head * new_bh)
    3. what we should do with directory entries hashed by another hash?
    they are deleted for now
 */
-static void pass1_correct_leaf (reiserfs_filsys_t * fs,
-				struct buffer_head * bh)
+static void pass1_correct_leaf(reiserfs_filsys_t *fs, struct buffer_head *bh)
 {
-    unsigned int i, j;
-    struct item_head * ih;
-    __u32 * ind_item;
-    __u32 unfm_ptr;
-    int dirty = 0;
-
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < B_NR_ITEMS (bh); i ++, ih ++) {
-	if (is_direntry_ih (ih)) {
-	    struct reiserfs_de_head * deh;
-	    __u32 offset;
-	    char * name;
-	    int name_len;
-	    unsigned int hash_code;
-
-	    deh = B_I_DEH (bh, ih);
-	    offset = 0;
-	    for (j = 0; j < get_ih_entry_count (ih); j ++) {
-		name = name_in_entry (deh + j, j);
-		name_len = name_in_entry_length (ih, deh + j, j);
-
-		if ((j == 0 && is_dot (name, name_len)) ||
-		    (j == 1 && is_dot_dot (name, name_len))) {
-		    continue;
-		}
-
-		hash_code = find_hash_in_use (name, name_len, get_deh_offset (deh + j),
-					      get_sb_hash_code (fs->fs_ondisk_sb));
-		if (hash_code != get_sb_hash_code (fs->fs_ondisk_sb)) {
-		    fsck_log ("pass1: block %lu, item %d, entry %d: The entry \"%.*s\" of the %k is hashed with %s "
-			"whereas proper hash is %s", bh->b_blocknr, i, j, name_len, name, &ih->ih_key,
-			      code2name (hash_code), code2name (get_sb_hash_code (fs->fs_ondisk_sb)));
-		    if (get_ih_entry_count (ih) == 1) {
-			delete_item (fs, bh, i);
-			fsck_log(" - the only entry - item was deleted\n");
-			i --;
-			ih --;
-			break;
-		    } else {
-			cut_entry (fs, bh, i, j, 1);
-			fsck_log(" - deleted\n");
-			j --;
-			deh = B_I_DEH (bh, ih);
+	unsigned int i, j;
+	struct item_head *ih;
+	__u32 *ind_item;
+	__u32 unfm_ptr;
+	int dirty = 0;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < B_NR_ITEMS(bh); i++, ih++) {
+		if (is_direntry_ih(ih)) {
+			struct reiserfs_de_head *deh;
+			__u32 offset;
+			char *name;
+			int name_len;
+			unsigned int hash_code;
+
+			deh = B_I_DEH(bh, ih);
+			offset = 0;
+			for (j = 0; j < get_ih_entry_count(ih); j++) {
+				name = name_in_entry(deh + j, j);
+				name_len = name_in_entry_length(ih, deh + j, j);
+
+				if ((j == 0 && is_dot(name, name_len)) ||
+				    (j == 1 && is_dot_dot(name, name_len))) {
+					continue;
+				}
+
+				hash_code =
+				    find_hash_in_use(name, name_len,
+						     get_deh_offset(deh + j),
+						     get_sb_hash_code(fs->
+								      fs_ondisk_sb));
+				if (hash_code !=
+				    get_sb_hash_code(fs->fs_ondisk_sb)) {
+					fsck_log
+					    ("pass1: block %lu, item %d, entry %d: The entry \"%.*s\" of the %k is hashed with %s "
+					     "whereas proper hash is %s",
+					     bh->b_blocknr, i, j, name_len,
+					     name, &ih->ih_key,
+					     code2name(hash_code),
+					     code2name(get_sb_hash_code
+						       (fs->fs_ondisk_sb)));
+					if (get_ih_entry_count(ih) == 1) {
+						delete_item(fs, bh, i);
+						fsck_log
+						    (" - the only entry - item was deleted\n");
+						i--;
+						ih--;
+						break;
+					} else {
+						cut_entry(fs, bh, i, j, 1);
+						fsck_log(" - deleted\n");
+						j--;
+						deh = B_I_DEH(bh, ih);
+						continue;
+					}
+				}
+
+				if (j && offset >= get_deh_offset(deh + j)) {
+					fsck_log
+					    ("pass1: block %lu, item %d, entry %d: The entry "
+					     "\"%.*s\" of the %k has hash offset %lu not "
+					     "larger smaller than the previous one %lu. The "
+					     "entry is deleted.\n",
+					     bh->b_blocknr, i, j, name_len,
+					     name, &ih->ih_key,
+					     get_deh_offset(deh + j), offset);
+					cut_entry(fs, bh, i, j, 1);
+					j--;
+					deh = B_I_DEH(bh, ih);
+					continue;
+				}
+
+				offset = get_deh_offset(deh + j);
+			}
 			continue;
-		    }
-		}
-
-		if (j && offset >= get_deh_offset (deh + j)) {
-		    fsck_log ("pass1: block %lu, item %d, entry %d: The entry "
-			      "\"%.*s\" of the %k has hash offset %lu not "
-			      "larger smaller than the previous one %lu. The "
-			      "entry is deleted.\n", bh->b_blocknr, 
-			      i, j, name_len, name, &ih->ih_key, 
-			      get_deh_offset(deh + j), offset);
-		    cut_entry (fs, bh, i, j, 1);
-		    j --;
-		    deh = B_I_DEH (bh, ih);
-		    continue;
 		}
 
-		offset = get_deh_offset (deh + j);
-	    }
-	    continue;
-	}
-
+		if (!is_indirect_ih(ih))
+			continue;
 
-	if (!is_indirect_ih (ih))
-	    continue;
-
-	/* correct indirect items */
-	ind_item = (__u32 *)B_I_PITEM (bh, ih);
-
-	for (j = 0; j < I_UNFM_NUM (ih); j ++) {
-	    unfm_ptr = d32_get (ind_item, j);
-
-	    if (!unfm_ptr)
-		continue;
-
-	    /* this corruption of indirect item had to be fixed in pass0 */
-	    if (not_data_block (fs, unfm_ptr) || unfm_ptr >= get_sb_block_count (fs->fs_ondisk_sb))
-		/*!was_block_used (unfm_ptr))*/
-		reiserfs_panic ("%s: block %lu, item %d, pointer %d: The wrong pointer (%u) in the file %K. "
-		    "Must be fixed on pass0.",  __FUNCTION__, bh->b_blocknr, i, j, unfm_ptr, &ih->ih_key);
-
-	    /* 1. zero slots pointing to a leaf */
-	    if (is_used_leaf (unfm_ptr)) {
-		dirty ++;
-		d32_put (ind_item, j, 0);
-		pass_1_stat (fs)->pointed_leaves ++;
-		continue;
-	    }
-
-	    /* 2. zero pointers to blocks which are pointed already */
-	    if (is_bad_unformatted (unfm_ptr)) {
-		/* this unformatted pointed more than once. Did we see it already? */
-		if (!is_bad_unfm_in_tree_once (unfm_ptr))
-		    /* keep first reference to it and mark about that in
-                       special bitmap */
-		    mark_bad_unfm_in_tree_once (unfm_ptr);
-		else {
-		    /* Yes, we have seen this pointer already, zero other pointers to it. */
-		    dirty ++;
-		    d32_put (ind_item, j, 0);
-		    pass_1_stat (fs)->non_unique_pointers ++;
-		    continue;
+		/* correct indirect items */
+		ind_item = (__u32 *) B_I_PITEM(bh, ih);
+
+		for (j = 0; j < I_UNFM_NUM(ih); j++) {
+			unfm_ptr = d32_get(ind_item, j);
+
+			if (!unfm_ptr)
+				continue;
+
+			/* this corruption of indirect item had to be fixed in pass0 */
+			if (not_data_block(fs, unfm_ptr)
+			    || unfm_ptr >= get_sb_block_count(fs->fs_ondisk_sb))
+				/*!was_block_used (unfm_ptr)) */
+				reiserfs_panic
+				    ("%s: block %lu, item %d, pointer %d: The wrong pointer (%u) in the file %K. "
+				     "Must be fixed on pass0.", __FUNCTION__,
+				     bh->b_blocknr, i, j, unfm_ptr,
+				     &ih->ih_key);
+
+			/* 1. zero slots pointing to a leaf */
+			if (is_used_leaf(unfm_ptr)) {
+				dirty++;
+				d32_put(ind_item, j, 0);
+				pass_1_stat(fs)->pointed_leaves++;
+				continue;
+			}
+
+			/* 2. zero pointers to blocks which are pointed already */
+			if (is_bad_unformatted(unfm_ptr)) {
+				/* this unformatted pointed more than once. Did we see it already? */
+				if (!is_bad_unfm_in_tree_once(unfm_ptr))
+					/* keep first reference to it and mark about that in
+					   special bitmap */
+					mark_bad_unfm_in_tree_once(unfm_ptr);
+				else {
+					/* Yes, we have seen this pointer already, zero other pointers to it. */
+					dirty++;
+					d32_put(ind_item, j, 0);
+					pass_1_stat(fs)->non_unique_pointers++;
+					continue;
+				}
+			} else
+				pass_1_stat(fs)->correct_pointers++;
 		}
-	    } else
-		pass_1_stat (fs)->correct_pointers ++;
 	}
-    }
 
-    if (dirty)
-	mark_buffer_dirty (bh);
+	if (dirty)
+		mark_buffer_dirty(bh);
 }
 
-struct si * remove_saved_item (struct si * si)
+struct si *remove_saved_item(struct si *si)
 {
-    struct si * tmp = si->si_next;
-    
-    freemem (si->si_dnm_data);
-    freemem (si);
-    return tmp;
+	struct si *tmp = si->si_next;
+
+	freemem(si->si_dnm_data);
+	freemem(si);
+	return tmp;
 }
 
 /* fsck starts creating of this bitmap on pass 1. It will then become
    on-disk bitmap */
-static void init_new_bitmap (reiserfs_filsys_t * fs)
+static void init_new_bitmap(reiserfs_filsys_t *fs)
 {
-    unsigned int i;
-    unsigned long block;
-    unsigned long reserved;
-    
-
-    fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-
-    /* mark_block_used skips 0, set the bit explicitly */
-    reiserfs_bitmap_set_bit (fsck_new_bitmap (fs), 0);
-
-    /* mark other skipped blocks and super block used */
-    for (i = 1; i <= fs->fs_super_bh->b_blocknr; i ++)
-	mark_block_used (i, 1);
-
-    /* mark bitmap blocks as used */
-    block = fs->fs_super_bh->b_blocknr + 1;
-    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
-	mark_block_used (block, 1);
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8);
-	else
-	    block ++;
-    }
-
-    reserved = get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb);
-    /* where does journal area (or reserved journal area) start from */
-
-    if (!is_new_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) &&
-    	!is_old_sb_location (fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
-	die ("init_new_bitmap: Wrong super block location, you must run --rebuild-sb.");
-
-    block = get_journal_start_must (fs);
-
-    for (i = block; i < reserved + block; i ++)
-	mark_block_used (i, 1);
-	
-
-    if (fs->fs_badblocks_bm)
-    	for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	    if (reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i)) {
-	    	if (reiserfs_bitmap_test_bit (fsck_new_bitmap (fs), i))
-	    	    reiserfs_panic ("%s: The block pointer to not data area, must be fixed on the pass0.\n",
-	    	    	__FUNCTION__);	    	
-		reiserfs_bitmap_set_bit (fsck_new_bitmap (fs), i);
-	    }
-    	}
+	unsigned int i;
+	unsigned long block;
+	unsigned long reserved;
+
+	fsck_new_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+
+	/* mark_block_used skips 0, set the bit explicitly */
+	reiserfs_bitmap_set_bit(fsck_new_bitmap(fs), 0);
+
+	/* mark other skipped blocks and super block used */
+	for (i = 1; i <= fs->fs_super_bh->b_blocknr; i++)
+		mark_block_used(i, 1);
+
+	/* mark bitmap blocks as used */
+	block = fs->fs_super_bh->b_blocknr + 1;
+	for (i = 0; i < reiserfs_fs_bmap_nr(fs); i++) {
+		mark_block_used(block, 1);
+		if (spread_bitmaps(fs))
+			block =
+			    (block / (fs->fs_blocksize * 8) +
+			     1) * (fs->fs_blocksize * 8);
+		else
+			block++;
+	}
+
+	reserved = get_size_of_journal_or_reserved_area(fs->fs_ondisk_sb);
+	/* where does journal area (or reserved journal area) start from */
+
+	if (!is_new_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) &&
+	    !is_old_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
+		die("init_new_bitmap: Wrong super block location, you must run --rebuild-sb.");
+
+	block = get_journal_start_must(fs);
 
+	for (i = block; i < reserved + block; i++)
+		mark_block_used(i, 1);
+
+	if (fs->fs_badblocks_bm)
+		for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+			if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i)) {
+				if (reiserfs_bitmap_test_bit
+				    (fsck_new_bitmap(fs), i))
+					reiserfs_panic
+					    ("%s: The block pointer to not data area, must be fixed on the pass0.\n",
+					     __FUNCTION__);
+				reiserfs_bitmap_set_bit(fsck_new_bitmap(fs), i);
+			}
+		}
 #if 0
-    /* mark journal area as used if journal is standard or it is non standard
-       and initialy has been created on a main device */
-    reserved = 0;
-    if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
-	reserved = get_jp_journal_size (sb_jp (fs->fs_ondisk_sb));
-    if (get_sb_reserved_for_journal (fs->fs_ondisk_sb))
-	reserved = get_sb_reserved_for_journal (fs->fs_ondisk_sb);
-    if (reserved) {
-	for (i = 0; i <= reserved; i ++)
-	    mark_block_used (i + get_jp_journal_1st_block (sb_jp
-							   (fs->fs_ondisk_sb)));
-    }
+	/* mark journal area as used if journal is standard or it is non standard
+	   and initialy has been created on a main device */
+	reserved = 0;
+	if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
+		reserved = get_jp_journal_size(sb_jp(fs->fs_ondisk_sb));
+	if (get_sb_reserved_for_journal(fs->fs_ondisk_sb))
+		reserved = get_sb_reserved_for_journal(fs->fs_ondisk_sb);
+	if (reserved) {
+		for (i = 0; i <= reserved; i++)
+			mark_block_used(i + get_jp_journal_1st_block(sb_jp
+								     (fs->
+								      fs_ondisk_sb)));
+	}
 #endif
 }
 
-
 /* this makes a map of blocks which can be allocated when fsck will
    continue */
-static void find_allocable_blocks (reiserfs_filsys_t * fs)
+static void find_allocable_blocks(reiserfs_filsys_t *fs)
 {
-    unsigned long i;
+	unsigned long i;
 
-    fsck_progress ("Looking for allocable blocks .. ");
+	fsck_progress("Looking for allocable blocks .. ");
 
-    fsck_allocable_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_fill (fsck_allocable_bitmap (fs));
+	fsck_allocable_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_fill(fsck_allocable_bitmap(fs));
 
+	/* find how many leaves are not pointed by any indirect items */
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (not_data_block(fs, i))
+			/* journal (or reserved for it area), bitmaps, super block and
+			   blocks before it */
+			continue;
 
-    /* find how many leaves are not pointed by any indirect items */
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	if (not_data_block (fs, i))
-	    /* journal (or reserved for it area), bitmaps, super block and
-	       blocks before it */
-	    continue;
-
-	if (is_good_unformatted (i) && is_bad_unformatted (i))
-	    die ("find_allocable_blocks: The block (%lu) is masr as good and as bad at once.", i);
+		if (is_good_unformatted(i) && is_bad_unformatted(i))
+			die("find_allocable_blocks: The block (%lu) is masr as good and as bad at once.", i);
 
-	if (is_good_unformatted (i) || is_bad_unformatted (i)) {
-	    /* blocks which were pointed once or more thn onec from indirect
-	       items - they will not be allocated */
-	    continue;
-	}
+		if (is_good_unformatted(i) || is_bad_unformatted(i)) {
+			/* blocks which were pointed once or more thn onec from indirect
+			   items - they will not be allocated */
+			continue;
+		}
 
-	/* make allocable not leaves, not bad blocks */
-	if (!is_used_leaf (i) && (!fs->fs_badblocks_bm || 
-				  !reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))) 
-	{
-	    /* this is not leaf and it is not pointed by found indirect items,
-               so it does not contains anything valuable */
-	    make_allocable (i);
-	    pass_1_stat (fs)->allocable_blocks ++;
+		/* make allocable not leaves, not bad blocks */
+		if (!is_used_leaf(i) && (!fs->fs_badblocks_bm ||
+					 !reiserfs_bitmap_test_bit(fs->
+								   fs_badblocks_bm,
+								   i))) {
+			/* this is not leaf and it is not pointed by found indirect items,
+			   so it does not contains anything valuable */
+			make_allocable(i);
+			pass_1_stat(fs)->allocable_blocks++;
+		}
 	}
-    }
-    fsck_progress ("finished\n");
+	fsck_progress("finished\n");
 
-    fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
-    fs->block_deallocator = reiserfsck_reiserfs_free_block;
+	fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
+	fs->block_deallocator = reiserfsck_reiserfs_free_block;
 }
 
-
-static void before_pass_1 (reiserfs_filsys_t * fs)
+static void before_pass_1(reiserfs_filsys_t *fs)
 {
-    /* this will become an on-disk bitmap */
-    init_new_bitmap (fs);
+	/* this will become an on-disk bitmap */
+	init_new_bitmap(fs);
 
-    /* bitmap of leaves which could not be inserted on pass 1. FIXME:
-       no need to have 1 bit per block */
-    fsck_uninsertables (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_fill (fsck_uninsertables (fs));
-    
-    /* find blocks which can be allocated */
-    find_allocable_blocks (fs);
+	/* bitmap of leaves which could not be inserted on pass 1. FIXME:
+	   no need to have 1 bit per block */
+	fsck_uninsertables(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_fill(fsck_uninsertables(fs));
 
-    /* bitmap of bad unformatted nodes which are in the tree already */
-    bad_unfm_in_tree_once_bitmap = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
+	/* find blocks which can be allocated */
+	find_allocable_blocks(fs);
 
-    /* pass 1 does not deal with objectid */
-}
+	/* bitmap of bad unformatted nodes which are in the tree already */
+	bad_unfm_in_tree_once_bitmap =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
 
+	/* pass 1 does not deal with objectid */
+}
 
-static void save_pass_1_result (reiserfs_filsys_t * fs)
+static void save_pass_1_result(reiserfs_filsys_t *fs)
 {
-    FILE * file;
-    int retval;
-
-    file = open_file("temp_fsck_file.deleteme", "w+");
-    if (!file)
-	return;
-
-    /* to be able to get a new bitmap on pass2 we should flush it on disk
-       new_bitmap should not be flushed on disk if run without -d option, as
-       if fsck fails on pass1 we get wrong bitmap on the next fsck start */
-    reiserfs_flush_to_ondisk_bitmap (fsck_new_bitmap (fs), fs);
-    
-    /* to be able to restart with pass 2 we need bitmap of
-       uninsertable blocks and bitmap of alocable blocks */
-    reiserfs_begin_stage_info_save(file, PASS_1_DONE);
-    reiserfs_bitmap_save (file,  fsck_uninsertables (fs));
-    reiserfs_bitmap_save (file,  fsck_allocable_bitmap(fs));
-    reiserfs_end_stage_info_save (file);
-    close_file (file);
-    retval = rename ("temp_fsck_file.deleteme", state_dump_file (fs));
-    if (retval != 0)
-	fsck_progress ("pass 1: Could not rename the temporary file temp_fsck_file.deleteme to %s",
-		       state_dump_file (fs));
+	FILE *file;
+	int retval;
+
+	file = open_file("temp_fsck_file.deleteme", "w+");
+	if (!file)
+		return;
+
+	/* to be able to get a new bitmap on pass2 we should flush it on disk
+	   new_bitmap should not be flushed on disk if run without -d option, as
+	   if fsck fails on pass1 we get wrong bitmap on the next fsck start */
+	reiserfs_flush_to_ondisk_bitmap(fsck_new_bitmap(fs), fs);
+
+	/* to be able to restart with pass 2 we need bitmap of
+	   uninsertable blocks and bitmap of alocable blocks */
+	reiserfs_begin_stage_info_save(file, PASS_1_DONE);
+	reiserfs_bitmap_save(file, fsck_uninsertables(fs));
+	reiserfs_bitmap_save(file, fsck_allocable_bitmap(fs));
+	reiserfs_end_stage_info_save(file);
+	close_file(file);
+	retval = rename("temp_fsck_file.deleteme", state_dump_file(fs));
+	if (retval != 0)
+		fsck_progress
+		    ("pass 1: Could not rename the temporary file temp_fsck_file.deleteme to %s",
+		     state_dump_file(fs));
 }
 
-
-void load_pass_1_result (FILE * fp, reiserfs_filsys_t * fs)
+void load_pass_1_result(FILE * fp, reiserfs_filsys_t *fs)
 {
-    fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_new_bitmap (fs), fs->fs_bitmap2);
-    
-    fsck_uninsertables (fs) = reiserfs_bitmap_load (fp);
-    fsck_allocable_bitmap (fs) = reiserfs_bitmap_load (fp);
-    
-    fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
-    fs->block_deallocator = reiserfsck_reiserfs_free_block;
-
-    if (!fsck_new_bitmap (fs) || !fsck_allocable_bitmap (fs) ||
-	!fsck_allocable_bitmap (fs))
-	fsck_exit ("State dump file seems corrupted. Run without -d");
-
-
-    /* we need objectid map on pass 2 to be able to relocate files */
-    proper_id_map (fs) = id_map_init();
-    /* Not implemented yet.
-    fetch_objectid_map (proper_id_map (fs), fs);
-    */
-
-    fsck_progress ("Pass 1 result loaded. %u blocks used, %u allocable, "
-		   "still to be inserted %u\n",
-		   reiserfs_bitmap_ones (fsck_new_bitmap (fs)),
-		   reiserfs_bitmap_zeros (fsck_allocable_bitmap (fs)),
-		   reiserfs_bitmap_zeros (fsck_uninsertables (fs)));
+	fsck_new_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_new_bitmap(fs), fs->fs_bitmap2);
+
+	fsck_uninsertables(fs) = reiserfs_bitmap_load(fp);
+	fsck_allocable_bitmap(fs) = reiserfs_bitmap_load(fp);
+
+	fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
+	fs->block_deallocator = reiserfsck_reiserfs_free_block;
+
+	if (!fsck_new_bitmap(fs) || !fsck_allocable_bitmap(fs) ||
+	    !fsck_allocable_bitmap(fs))
+		fsck_exit("State dump file seems corrupted. Run without -d");
+
+	/* we need objectid map on pass 2 to be able to relocate files */
+	proper_id_map(fs) = id_map_init();
+	/* Not implemented yet.
+	   fetch_objectid_map (proper_id_map (fs), fs);
+	 */
+
+	fsck_progress("Pass 1 result loaded. %u blocks used, %u allocable, "
+		      "still to be inserted %u\n",
+		      reiserfs_bitmap_ones(fsck_new_bitmap(fs)),
+		      reiserfs_bitmap_zeros(fsck_allocable_bitmap(fs)),
+		      reiserfs_bitmap_zeros(fsck_uninsertables(fs)));
 }
 
-
-extern reiserfs_bitmap_t * leaves_bitmap;
+extern reiserfs_bitmap_t *leaves_bitmap;
 
 /* reads blocks marked in leaves_bitmap and tries to insert them into
    tree */
-static void do_pass_1 (reiserfs_filsys_t * fs)
+static void do_pass_1(reiserfs_filsys_t *fs)
 {
-    struct buffer_head * bh;
-    unsigned long i; 
-    int what_node;
-    unsigned long done = 0, total;
+	struct buffer_head *bh;
+	unsigned long i;
+	int what_node;
+	unsigned long done = 0, total;
 
+	/* on pass0 we have found that amount of leaves */
+	total = reiserfs_bitmap_ones(leaves_bitmap);
 
-    /* on pass0 we have found that amount of leaves */
-    total = reiserfs_bitmap_ones (leaves_bitmap);
+	/* read all leaves found on the pass 0 */
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (!is_used_leaf(i))
+			continue;
 
-    /* read all leaves found on the pass 0 */
-    for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	if (!is_used_leaf (i))
-	    continue;
+		print_how_far(fsck_progress_file(fs), &done, total, 1,
+			      fsck_quiet(fs));
 
-	print_how_far (fsck_progress_file (fs), &done, total, 1, fsck_quiet (fs));
+		/* at least one of nr_to_read blocks is to be checked */
+		bh = bread(fs->fs_dev, i, fs->fs_blocksize);
+		if (!bh) {
+			/* we were reading one block at time, and failed, so mark
+			   block bad */
+			fsck_progress
+			    ("pass1: Reading of the block %lu failed\n", i);
+			continue;
+		}
 
-	/* at least one of nr_to_read blocks is to be checked */
-	bh = bread (fs->fs_dev, i, fs->fs_blocksize);
-	if (!bh) {
-	    /* we were reading one block at time, and failed, so mark
-	       block bad */
-	    fsck_progress ("pass1: Reading of the block %lu failed\n", i);
-	    continue;
-	}
+		what_node = who_is_this(bh->b_data, bh->b_size);
+		if (what_node != THE_LEAF) {
+			check_memory_msg();
+			die("build_the_tree: Nothing but leaves are expected. Block %lu - %s\n", i, which_block(what_node));
+		}
 
-	what_node = who_is_this (bh->b_data, bh->b_size);
-	if ( what_node != THE_LEAF ) {
-	    check_memory_msg();
-	    die ("build_the_tree: Nothing but leaves are expected. Block %lu - %s\n", 
-		i, which_block(what_node));
-	}
-	
-	if (is_block_used (i) && !(block_of_journal (fs, i) &&
-				   fsck_data(fs)->rebuild.use_journal_area))
-	    /* block is in new tree already */
-	    die ("build_the_tree: The leaf (%lu) is in the tree already\n", i);
-		    
-	/* fprintf (block_list, "leaf %d\n", i + j);*/
-	pass_1_stat (fs)->leaves ++;
-
-	/* the leaf may still contain indirect items with wrong
-	   slots. Fix that */
-	pass1_correct_leaf (fs, bh);
-
-	if (get_blkh_nr_items (B_BLK_HEAD (bh)) == 0) {
-	    /* all items were deleted on pass 0 or pass 1 */
-	    mark_buffer_clean (bh);
-	    brelse (bh);
-	    continue;
-	}
+		if (is_block_used(i) && !(block_of_journal(fs, i) &&
+					  fsck_data(fs)->rebuild.
+					  use_journal_area))
+			/* block is in new tree already */
+			die("build_the_tree: The leaf (%lu) is in the tree already\n", i);
 
-	if (is_leaf_bad (bh)) {
-	    /* FIXME: will die */
-	    fsck_log ("is_leaf_bad: WARNING: The leaf (%lu) is formatted badly. Will be handled on the the pass2.\n", 
-		bh->b_blocknr);
-	    mark_block_uninsertable (bh->b_blocknr);
-	    brelse (bh);
-	    continue;
-	}
-	
-	if (block_of_journal (fs, i) && fsck_data(fs)->rebuild.use_journal_area) {
-	    /* FIXME: temporary thing */
-	    if (tree_is_empty ()) {
-		/* we insert inot tree only first leaf of journal */
-		unsigned long block;
-		struct buffer_head * new_bh;
-		
-		block = alloc_block ();
-		if (!block)
-		    die ("could not allocate block");
-		new_bh = getblk (bh->b_dev, block, bh->b_size);
-		memcpy (new_bh->b_data, bh->b_data, bh->b_size);
-		mark_buffer_uptodate (new_bh, 1);
-		mark_buffer_dirty (new_bh);
-		make_single_leaf_tree (new_bh);
-		brelse (new_bh);
-		brelse (bh);
-		continue;
-	    }
-
-	    /* other blocks of journal will be inserted in pass 2 */
-	    mark_block_uninsertable (bh->b_blocknr);
-	    brelse (bh);
-	    continue;
+		/* fprintf (block_list, "leaf %d\n", i + j); */
+		pass_1_stat(fs)->leaves++;
+
+		/* the leaf may still contain indirect items with wrong
+		   slots. Fix that */
+		pass1_correct_leaf(fs, bh);
+
+		if (get_blkh_nr_items(B_BLK_HEAD(bh)) == 0) {
+			/* all items were deleted on pass 0 or pass 1 */
+			mark_buffer_clean(bh);
+			brelse(bh);
+			continue;
+		}
+
+		if (is_leaf_bad(bh)) {
+			/* FIXME: will die */
+			fsck_log
+			    ("is_leaf_bad: WARNING: The leaf (%lu) is formatted badly. Will be handled on the the pass2.\n",
+			     bh->b_blocknr);
+			mark_block_uninsertable(bh->b_blocknr);
+			brelse(bh);
+			continue;
+		}
+
+		if (block_of_journal(fs, i)
+		    && fsck_data(fs)->rebuild.use_journal_area) {
+			/* FIXME: temporary thing */
+			if (tree_is_empty()) {
+				/* we insert inot tree only first leaf of journal */
+				unsigned long block;
+				struct buffer_head *new_bh;
+
+				block = alloc_block();
+				if (!block)
+					die("could not allocate block");
+				new_bh = getblk(bh->b_dev, block, bh->b_size);
+				memcpy(new_bh->b_data, bh->b_data, bh->b_size);
+				mark_buffer_uptodate(new_bh, 1);
+				mark_buffer_dirty(new_bh);
+				make_single_leaf_tree(new_bh);
+				brelse(new_bh);
+				brelse(bh);
+				continue;
+			}
+
+			/* other blocks of journal will be inserted in pass 2 */
+			mark_block_uninsertable(bh->b_blocknr);
+			brelse(bh);
+			continue;
+		}
+
+		try_to_insert_pointer_to_leaf(bh);
+		brelse(bh);
 	}
-	
-	try_to_insert_pointer_to_leaf (bh);
-	brelse (bh);
-    }
 
-    fsck_progress ("\n");
+	fsck_progress("\n");
 
 }
 
-
-static void after_pass_1 (reiserfs_filsys_t * fs)
+static void after_pass_1(reiserfs_filsys_t *fs)
 {
-    time_t t;
-
-    /* update fsck_state */
-    
-    /* we  should not flush bitmaps on disk after pass1, because
-       new_bitmap contains only those blocks which are good leaves or 
-       just allocated internal blocks. */
-       
-    set_sb_fs_state (fs->fs_ondisk_sb, PASS_1_DONE);
-    mark_buffer_dirty (fs->fs_super_bh);
-
-    /* write all dirty blocks */
-    fsck_progress ("Flushing..");
-    fs->fs_dirt = 1;
-    reiserfs_flush (fs);
-    fsck_progress ("finished\n");
-
-    stage_report (1, fs);
-
-    /* we do not need this anymore */
-    delete_aux_bitmaps ();
-    reiserfs_delete_bitmap (bad_unfm_in_tree_once_bitmap);
-
-    if (!fsck_run_one_step (fs)) {
-	if (fsck_user_confirmed (fs, "Continue? (Yes):", "Yes\n", 1))
-	    /* reiserfsck continues */
-	    return;
-    } else
-	save_pass_1_result (fs);
-
-    if (proper_id_map (fs)) {
-	/* when we run pass 1 only - we do not have proper_id_map */
-	id_map_free(proper_id_map (fs));
-	proper_id_map (fs) = 0;
-    }
-    
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck finished pass 1 at %s"
-		   "###########\n", ctime (&t));
-    fs->fs_dirt = 1;
-    reiserfs_close (fs);
-    exit(0);
-}
+	time_t t;
 
+	/* update fsck_state */
 
-void pass_1 (reiserfs_filsys_t * fs)
-{
-    fsck_progress ("\nPass 1 (will try to insert %lu leaves):\n",
-		   reiserfs_bitmap_ones (fsck_source_bitmap (fs)));
-    if (fsck_log_file (fs) != stderr)
-	fsck_log ("####### Pass 1 #######\n");
+	/* we  should not flush bitmaps on disk after pass1, because
+	   new_bitmap contains only those blocks which are good leaves or 
+	   just allocated internal blocks. */
+
+	set_sb_fs_state(fs->fs_ondisk_sb, PASS_1_DONE);
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	/* write all dirty blocks */
+	fsck_progress("Flushing..");
+	fs->fs_dirt = 1;
+	reiserfs_flush(fs);
+	fsck_progress("finished\n");
 
+	stage_report(1, fs);
 
-    before_pass_1 (fs);
+	/* we do not need this anymore */
+	delete_aux_bitmaps();
+	reiserfs_delete_bitmap(bad_unfm_in_tree_once_bitmap);
 
-    /* try to insert leaves found during pass 0 */
-    do_pass_1 (fs);
+	if (!fsck_run_one_step(fs)) {
+		if (fsck_user_confirmed(fs, "Continue? (Yes):", "Yes\n", 1))
+			/* reiserfsck continues */
+			return;
+	} else
+		save_pass_1_result(fs);
 
-    after_pass_1 (fs);
+	if (proper_id_map(fs)) {
+		/* when we run pass 1 only - we do not have proper_id_map */
+		id_map_free(proper_id_map(fs));
+		proper_id_map(fs) = 0;
+	}
+
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck finished pass 1 at %s"
+		      "###########\n", ctime(&t));
+	fs->fs_dirt = 1;
+	reiserfs_close(fs);
+	exit(0);
 }
 
+void pass_1(reiserfs_filsys_t *fs)
+{
+	fsck_progress("\nPass 1 (will try to insert %lu leaves):\n",
+		      reiserfs_bitmap_ones(fsck_source_bitmap(fs)));
+	if (fsck_log_file(fs) != stderr)
+		fsck_log("####### Pass 1 #######\n");
+
+	before_pass_1(fs);
+
+	/* try to insert leaves found during pass 0 */
+	do_pass_1(fs);
+
+	after_pass_1(fs);
+}
diff --git a/fsck/pass2.c b/fsck/pass2.c
index 0358638..75bcb85 100644
--- a/fsck/pass2.c
+++ b/fsck/pass2.c
@@ -5,7 +5,6 @@
 
 #include "fsck.h"
 
-
 /* on pass2 we take leaves which could not be inserted into tree
    during pass1 and insert each item separately. It is possible that
    items of different objects with the same key can be found. We treat
@@ -20,619 +19,621 @@
    key is remapped. Object can be only remapped if it is not a piece
    of directory */
 
-
 /* in list of this structures we store what has been relocated. */
 struct relocated {
-    unsigned long old_dir_id;
-    unsigned long old_objectid;
-    
-    unsigned long new_objectid;
-    
-    struct relocated * next;
+	unsigned long old_dir_id;
+	unsigned long old_objectid;
+
+	unsigned long new_objectid;
+
+	struct relocated *next;
 };
 
 /* all relocated files will be linked into lost+found directory at the
    beginning of semantic pass */
-static struct relocated * relocated_list = NULL;
-
-static __u32 get_relocated_objectid_from_list (struct reiserfs_key *key) {
-    struct relocated *cur = relocated_list;
+static struct relocated *relocated_list = NULL;
 
-    while (cur) {
-	if (cur->old_dir_id == get_key_dirid (key) &&
-	    cur->old_objectid == get_key_objectid (key))
-	    /* object is relocated already */
-	    return cur->new_objectid;
-	cur = cur->next;
-    }
-    return 0;
+static __u32 get_relocated_objectid_from_list(struct reiserfs_key *key)
+{
+	struct relocated *cur = relocated_list;
+
+	while (cur) {
+		if (cur->old_dir_id == get_key_dirid(key) &&
+		    cur->old_objectid == get_key_objectid(key))
+			/* object is relocated already */
+			return cur->new_objectid;
+		cur = cur->next;
+	}
+	return 0;
 }
 
 /* return objectid the object has to be remapped with */
-__u32 objectid_for_relocation (struct reiserfs_key *key)
+__u32 objectid_for_relocation(struct reiserfs_key * key)
 {
-    struct relocated * cur;
-    __u32 cur_id;
-
-    if ((cur_id = get_relocated_objectid_from_list (key)) != 0)
-    	return cur_id;
-
-    cur = getmem (sizeof (struct relocated));
-    cur->old_dir_id = get_key_dirid (key);
-    cur->old_objectid = get_key_objectid (key);
-    cur->new_objectid = id_map_alloc(proper_id_map(fs));
-    cur->next = relocated_list;
-    relocated_list = cur;
+	struct relocated *cur;
+	__u32 cur_id;
+
+	if ((cur_id = get_relocated_objectid_from_list(key)) != 0)
+		return cur_id;
+
+	cur = getmem(sizeof(struct relocated));
+	cur->old_dir_id = get_key_dirid(key);
+	cur->old_objectid = get_key_objectid(key);
+	cur->new_objectid = id_map_alloc(proper_id_map(fs));
+	cur->next = relocated_list;
+	relocated_list = cur;
 /*    fsck_log ("relocation: (%K) is relocated to (%lu, %lu)\n",
 	      key, get_key_dirid (key), cur->new_objectid);*/
-    return cur->new_objectid;
+	return cur->new_objectid;
 }
 
 /* relocated files get added into lost+found with slightly different names */
-static __u64 link_one (struct relocated * file) {
-    char * name;
-    struct reiserfs_key obj_key;
-    __u64 len = 0;
-
-    asprintf (&name, "%lu,%lu", file->old_dir_id, file->new_objectid);
-    set_key_dirid (&obj_key, file->old_dir_id);
-    set_key_objectid (&obj_key, file->new_objectid);
-
-    /* 0 for fsck_need does not mean too much - it would make effect if there 
-     * were no this directory yet. But /lost_found is there already */
-    len = reiserfs_add_entry (fs, &lost_found_dir_key, name, 
-	name_length(name, lost_found_dir_format), &obj_key, 0/*fsck_need*/);
-    pass_2_stat (fs)->relocated ++;
-    free (name);
-
-    return len;
+static __u64 link_one(struct relocated *file)
+{
+	char *name;
+	struct reiserfs_key obj_key;
+	__u64 len = 0;
+
+	asprintf(&name, "%lu,%lu", file->old_dir_id, file->new_objectid);
+	set_key_dirid(&obj_key, file->old_dir_id);
+	set_key_objectid(&obj_key, file->new_objectid);
+
+	/* 0 for fsck_need does not mean too much - it would make effect if there 
+	 * were no this directory yet. But /lost_found is there already */
+	len = reiserfs_add_entry(fs, &lost_found_dir_key, name,
+				 name_length(name, lost_found_dir_format),
+				 &obj_key, 0 /*fsck_need */ );
+	pass_2_stat(fs)->relocated++;
+	free(name);
+
+	return len;
 }
 
-void linked_already(struct reiserfs_key *new_key /*, link_func_t link_func*/) {
-    struct relocated *cur = relocated_list;
-    struct relocated *prev = NULL;
+void linked_already(struct reiserfs_key *new_key /*, link_func_t link_func */ )
+{
+	struct relocated *cur = relocated_list;
+	struct relocated *prev = NULL;
 
-    while (cur) {
-	if (cur->old_dir_id == get_key_dirid(new_key) && 
-	    cur->new_objectid == get_key_objectid(new_key))
-	    break;
+	while (cur) {
+		if (cur->old_dir_id == get_key_dirid(new_key) &&
+		    cur->new_objectid == get_key_objectid(new_key))
+			break;
 
-	prev = cur;
-	cur = cur->next;
-    }
+		prev = cur;
+		cur = cur->next;
+	}
 
-    if (cur) {	
-	/* len = link_func(cur); */
+	if (cur) {
+		/* len = link_func(cur); */
 
-	if (prev) 
-	    prev->next = cur->next;
-	else
-	    relocated_list = cur->next;
+		if (prev)
+			prev->next = cur->next;
+		else
+			relocated_list = cur->next;
 
-	freemem (cur);
-    }
+		freemem(cur);
+	}
 }
 
-void link_relocated_files (void)
+void link_relocated_files(void)
 {
-    struct relocated * tmp;
-    int count;
-    
-    count = 0;
-    while (relocated_list) {
-	link_one (relocated_list);
-	tmp = relocated_list;
-	relocated_list = relocated_list->next;
-	freemem (tmp);
-	count ++;
-    }
+	struct relocated *tmp;
+	int count;
+
+	count = 0;
+	while (relocated_list) {
+		link_one(relocated_list);
+		tmp = relocated_list;
+		relocated_list = relocated_list->next;
+		freemem(tmp);
+		count++;
+	}
 }
 
 /* this item is in tree. All unformatted pointer are correct. Do not
    check them */
-void save_item (struct si ** head, struct item_head * ih, char * item, __u32 blocknr)
+void save_item(struct si **head, struct item_head *ih, char *item,
+	       __u32 blocknr)
 {
-    struct si * si, * cur;
-
-    si = getmem (sizeof (*si));
-    si->si_dnm_data = getmem (get_ih_item_len(ih));
-    /*si->si_blocknr = blocknr;*/
-    memcpy (&(si->si_ih), ih, IH_SIZE);
-    memcpy (si->si_dnm_data, item, get_ih_item_len(ih));
-
-    if (*head == 0)
-	*head = si;
-    else {
-	cur = *head;
-	while (cur->si_next)
-	    cur = cur->si_next;
-	cur->si_next = si;
-    }
-    return;
+	struct si *si, *cur;
+
+	si = getmem(sizeof(*si));
+	si->si_dnm_data = getmem(get_ih_item_len(ih));
+	/*si->si_blocknr = blocknr; */
+	memcpy(&(si->si_ih), ih, IH_SIZE);
+	memcpy(si->si_dnm_data, item, get_ih_item_len(ih));
+
+	if (*head == 0)
+		*head = si;
+	else {
+		cur = *head;
+		while (cur->si_next)
+			cur = cur->si_next;
+		cur->si_next = si;
+	}
+	return;
 }
 
-
-struct si * save_and_delete_file_item (struct si * si, struct reiserfs_path *path)
+struct si *save_and_delete_file_item(struct si *si, struct reiserfs_path *path)
 {
-    struct buffer_head * bh = PATH_PLAST_BUFFER (path);
-    struct item_head * ih = PATH_PITEM_HEAD (path);
+	struct buffer_head *bh = PATH_PLAST_BUFFER(path);
+	struct item_head *ih = PATH_PITEM_HEAD(path);
 
-    save_item (&si, ih, B_I_PITEM (bh, ih), bh->b_blocknr);
+	save_item(&si, ih, B_I_PITEM(bh, ih), bh->b_blocknr);
 
-    /* delete item temporary - do not free unformatted nodes */
-    reiserfsck_delete_item (path, 1/*temporary*/);
-    return si;
+	/* delete item temporary - do not free unformatted nodes */
+	reiserfsck_delete_item(path, 1 /*temporary */ );
+	return si;
 }
 
-
 /* check whether there are any directory items with this key */
-int should_relocate (struct item_head * ih)
+int should_relocate(struct item_head *ih)
 {
-    struct reiserfs_key key;
-    struct reiserfs_key *rkey;
-    struct reiserfs_path path;
-    struct item_head * path_ih;
-
-
-    /* starting with the leftmost item with this key */
-    key = ih->ih_key;
-    set_type_and_offset (KEY_FORMAT_1, &key, SD_OFFSET, TYPE_STAT_DATA);
-
-    while (1) {
-	reiserfs_search_by_key_4 (fs, &key, &path);
-	
-	if (get_item_pos (&path) == B_NR_ITEMS (get_bh (&path))) {
-	    rkey = uget_rkey (&path);
-	    if (rkey && !not_of_one_file (&key, rkey)) {
-		/* file continues in the right neighbor */
-		key = *rkey;
-		pathrelse (&path);
-		continue;
-	    }
-	    /* there is no more items with this key */
-	    pathrelse (&path);
-	    break;
-	}
-
-	path_ih = get_ih (&path);
-	if (not_of_one_file (&key, &(path_ih->ih_key))) {
-	    /* there are no more item with this key */
-	    pathrelse (&path);
-	    break;
+	struct reiserfs_key key;
+	struct reiserfs_key *rkey;
+	struct reiserfs_path path;
+	struct item_head *path_ih;
+
+	/* starting with the leftmost item with this key */
+	key = ih->ih_key;
+	set_type_and_offset(KEY_FORMAT_1, &key, SD_OFFSET, TYPE_STAT_DATA);
+
+	while (1) {
+		reiserfs_search_by_key_4(fs, &key, &path);
+
+		if (get_item_pos(&path) == B_NR_ITEMS(get_bh(&path))) {
+			rkey = uget_rkey(&path);
+			if (rkey && !not_of_one_file(&key, rkey)) {
+				/* file continues in the right neighbor */
+				key = *rkey;
+				pathrelse(&path);
+				continue;
+			}
+			/* there is no more items with this key */
+			pathrelse(&path);
+			break;
+		}
+
+		path_ih = get_ih(&path);
+		if (not_of_one_file(&key, &(path_ih->ih_key))) {
+			/* there are no more item with this key */
+			pathrelse(&path);
+			break;
+		}
+
+		if (is_stat_data_ih(path_ih)) {
+			fix_obviously_wrong_sd_mode(&path);
+			if (ih_checked(path_ih)) {
+				/* we have checked it already */
+				pathrelse(&path);
+
+				if (get_relocated_objectid_from_list
+				    (&path_ih->ih_key))
+					return 1;	/* it was relocated */
+				break;
+			} else {
+				mark_ih_checked(path_ih);
+				mark_buffer_dirty(get_bh(&path));
+			}
+		}
+
+		/* ok, item found, but make sure that it is not a directory one */
+		if ((is_stat_data_ih(path_ih)
+		     && !not_a_directory(get_item(&path)))
+		    || (is_direntry_ih(path_ih))) {
+			/* item of directory found. so, we have to relocate the file */
+			pathrelse(&path);
+			return 1;
+		}
+		key = path_ih->ih_key;
+		set_offset(KEY_FORMAT_1, &key, get_offset(&key) + 1);
+		pathrelse(&path);
 	}
-
-	if (is_stat_data_ih (path_ih)) {
-	    fix_obviously_wrong_sd_mode (&path);
-	    if (ih_checked (path_ih)) {
-		/* we have checked it already */
-		pathrelse (&path);
-
-		if (get_relocated_objectid_from_list (&path_ih->ih_key))
-		    return 1; /* it was relocated */
-		break;
-	    } else {
-		mark_ih_checked (path_ih);
-		mark_buffer_dirty (get_bh(&path));
-	    }
-	}
-	
-	/* ok, item found, but make sure that it is not a directory one */
-	if ((is_stat_data_ih (path_ih) && !not_a_directory (get_item (&path))) ||
-	    (is_direntry_ih (path_ih))) {
-	    /* item of directory found. so, we have to relocate the file */
-	    pathrelse (&path);
-	    return 1;
-	}
-	key = path_ih->ih_key;
-	set_offset (KEY_FORMAT_1, &key, get_offset (&key) + 1);
-	pathrelse (&path);
-    }
-    return 0;
+	return 0;
 }
 
-
 /* this works for both new and old stat data */
 #define st_mode(sd) le16_to_cpu(((struct stat_data *)(sd))->sd_mode)
 
 #define st_mtime_v1(sd) le32_to_cpu(((struct stat_data_v1 *)(sd))->sd_mtime)
 #define st_mtime_v2(sd) le32_to_cpu(((struct stat_data *)(sd))->sd_mtime)
 
-
 /* either both sd-s are new of both are old */
-static void overwrite_stat_data (struct item_head * new_ih,
-				 void * new_item, struct reiserfs_path *path)
+static void overwrite_stat_data(struct item_head *new_ih,
+				void *new_item, struct reiserfs_path *path)
 {
-    __u16 new_mode, old_mode;
+	__u16 new_mode, old_mode;
 
-    get_sd_mode (new_ih, new_item, &new_mode);
-    get_sd_mode (get_ih (path), get_item (path), &old_mode);
+	get_sd_mode(new_ih, new_item, &new_mode);
+	get_sd_mode(get_ih(path), get_item(path), &old_mode);
 
+	if (S_ISREG(new_mode) && !S_ISREG(old_mode)) {
+		/* in tree we have not regular file - overwrite its stat data
+		   with stat data of regular file */
+		memcpy(get_item(path), new_item, get_ih_item_len(get_ih(path)));
+		mark_buffer_dirty(get_bh(path));
+		return;
+	}
 
-    if (S_ISREG (new_mode) && !S_ISREG (old_mode)) {
-	/* in tree we have not regular file - overwrite its stat data
-           with stat data of regular file */
-	memcpy (get_item (path), new_item, get_ih_item_len (get_ih (path)));
-	mark_buffer_dirty (get_bh (path));
-	return;
-    }
-
-    if (S_ISREG (old_mode) && !S_ISREG (new_mode)) {
-	/* new stat data is not a stat data of regular file, keep
-           regular file stat data in tree */
-	return;
-    }
-    
-    /* if coming stat data has newer mtime - use that */
-    if (stat_data_v1 (new_ih)) {	
-	if (st_mtime_v1 (new_item) > st_mtime_v1 (get_item (path))) {
-	    memcpy (get_item (path), new_item, SD_V1_SIZE);
-	    mark_buffer_dirty (get_bh (path));
+	if (S_ISREG(old_mode) && !S_ISREG(new_mode)) {
+		/* new stat data is not a stat data of regular file, keep
+		   regular file stat data in tree */
+		return;
 	}
-    } else {
-	if (st_mtime_v2 (new_item) > st_mtime_v2 (get_item (path))) {
-	    memcpy (get_item (path), new_item, SD_SIZE);
-	    mark_buffer_dirty (get_bh (path));
+
+	/* if coming stat data has newer mtime - use that */
+	if (stat_data_v1(new_ih)) {
+		if (st_mtime_v1(new_item) > st_mtime_v1(get_item(path))) {
+			memcpy(get_item(path), new_item, SD_V1_SIZE);
+			mark_buffer_dirty(get_bh(path));
+		}
+	} else {
+		if (st_mtime_v2(new_item) > st_mtime_v2(get_item(path))) {
+			memcpy(get_item(path), new_item, SD_SIZE);
+			mark_buffer_dirty(get_bh(path));
+		}
 	}
-    }
-    return;
+	return;
 }
 
-
 /* insert sd item if it does not exist, overwrite it otherwise */
-static void put_sd_into_tree (struct item_head * new_ih, char * new_item)
+static void put_sd_into_tree(struct item_head *new_ih, char *new_item)
 {
-    struct reiserfs_path path;
-
-    if (!not_a_directory (new_item)) {
-	/* new item is a stat data of a directory. So we have to
-           relocate all items which have the same short key and are of
-           not a directory */
-	rewrite_file (new_ih, 1, 0/*do not change new_ih*/);
-    } else {
-	/* new item is a stat data of something else but directory. If
-           there are items of directory - we have to relocate the file */
-	if (should_relocate (new_ih))
-	    rewrite_file (new_ih, 1, 1/*change new_ih*/);
-    }
-    
-    /* if we will have to insert item into tree - it is ready */
-    zero_nlink (new_ih, new_item);
-    mark_item_unreachable (new_ih);
-    
-    /* we are sure now that if we are inserting stat data of a
-       directory - there are no items with the same key which are not
-       items of a directory, and that if we are inserting stat data is
-       of not a directory - it either has new key already or there are
-       no items with this key which are items of a directory */
-    if (reiserfs_search_by_key_4 (fs, &(new_ih->ih_key), &path) == ITEM_FOUND) {
-	/* this stat data is found */
-        if (get_ih_key_format (get_ih(&path)) != get_ih_key_format (new_ih)) {
-	    /* in tree stat data and a new one are of different
-               formats */
-	    fsck_log ("put_sd_into_tree: Inserting the StatData %K, mode (%M)...",
-		      &(new_ih->ih_key), st_mode (new_item));
-	    if (stat_data_v1 (new_ih)) {
-		/* sd to be inserted is of V1, where as sd in the tree
-                   is of V2 */
-		fsck_log ("found newer in the tree, mode (%M), insersion was skipped.\n",
-			  st_mode (get_item (&path)));
-	    	pathrelse (&path);
-	    } else {
-		/* the stat data in the tree is sd_v1 */
-		fsck_log ("older sd, mode (%M), is replaced with it.\n",
-			  st_mode (get_item (&path)));
-		reiserfsck_delete_item (&path, 0/*not temporary*/);
-		
-		reiserfs_search_by_key_4 (fs, &new_ih->ih_key, &path);
-		reiserfsck_insert_item (&path, new_ih, new_item);
-	    }
+	struct reiserfs_path path;
+
+	if (!not_a_directory(new_item)) {
+		/* new item is a stat data of a directory. So we have to
+		   relocate all items which have the same short key and are of
+		   not a directory */
+		rewrite_file(new_ih, 1, 0 /*do not change new_ih */ );
 	} else {
-	    /* both stat data are of the same version */
-	    overwrite_stat_data (new_ih, new_item, &path);
-	    pathrelse (&path);
+		/* new item is a stat data of something else but directory. If
+		   there are items of directory - we have to relocate the file */
+		if (should_relocate(new_ih))
+			rewrite_file(new_ih, 1, 1 /*change new_ih */ );
 	}
-	return;
-    }
-    
-    /* item not found, insert a new one */
-    reiserfsck_insert_item (&path, new_ih, new_item);
-}
 
+	/* if we will have to insert item into tree - it is ready */
+	zero_nlink(new_ih, new_item);
+	mark_item_unreachable(new_ih);
+
+	/* we are sure now that if we are inserting stat data of a
+	   directory - there are no items with the same key which are not
+	   items of a directory, and that if we are inserting stat data is
+	   of not a directory - it either has new key already or there are
+	   no items with this key which are items of a directory */
+	if (reiserfs_search_by_key_4(fs, &(new_ih->ih_key), &path) ==
+	    ITEM_FOUND) {
+		/* this stat data is found */
+		if (get_ih_key_format(get_ih(&path)) !=
+		    get_ih_key_format(new_ih)) {
+			/* in tree stat data and a new one are of different
+			   formats */
+			fsck_log
+			    ("put_sd_into_tree: Inserting the StatData %K, mode (%M)...",
+			     &(new_ih->ih_key), st_mode(new_item));
+			if (stat_data_v1(new_ih)) {
+				/* sd to be inserted is of V1, where as sd in the tree
+				   is of V2 */
+				fsck_log
+				    ("found newer in the tree, mode (%M), insersion was skipped.\n",
+				     st_mode(get_item(&path)));
+				pathrelse(&path);
+			} else {
+				/* the stat data in the tree is sd_v1 */
+				fsck_log
+				    ("older sd, mode (%M), is replaced with it.\n",
+				     st_mode(get_item(&path)));
+				reiserfsck_delete_item(&path,
+						       0 /*not temporary */ );
+
+				reiserfs_search_by_key_4(fs, &new_ih->ih_key,
+							 &path);
+				reiserfsck_insert_item(&path, new_ih, new_item);
+			}
+		} else {
+			/* both stat data are of the same version */
+			overwrite_stat_data(new_ih, new_item, &path);
+			pathrelse(&path);
+		}
+		return;
+	}
+
+	/* item not found, insert a new one */
+	reiserfsck_insert_item(&path, new_ih, new_item);
+}
 
 /* this tries to put each item entry to the tree, if there is no items
    of the directory, insert item containing 1 entry */
-static void put_directory_item_into_tree (struct item_head * comingih, char * item)
+static void put_directory_item_into_tree(struct item_head *comingih, char *item)
 {
-    struct reiserfs_de_head * deh;
-    int i;
-    char * buf;
-    char * name;
-    int namelen;
-
-    /* if there are anything with this key but a directory - move it
-       somewhere else */
-    rewrite_file (comingih, 1, 0/* do not change ih */);
-
-    deh = (struct reiserfs_de_head *)item;
-
-    for (i = 0; i < get_ih_entry_count (comingih); i ++, deh ++) {
-	name = name_in_entry (deh, i);
-	namelen = name_in_entry_length (comingih, deh, i);
-
-	if (!is_properly_hashed (fs, name, namelen, get_deh_offset (deh)))
-	    reiserfs_panic ("put_directory_item_into_tree: The entry (%d) \"%.*s\" of the directory %k has"
-		" badly hashed entry", i, namelen, name, &comingih->ih_key);
-
-	asprintf (&buf, "%.*s", namelen, name);
-	/* 1 for fsck is important: if there is no any items of this
-           directory in the tree yet - new item will be inserted
-           marked not reached */
-	reiserfs_add_entry (fs, &(comingih->ih_key), buf, entry_length (comingih, deh, i),
-			(struct reiserfs_key *)&(deh->deh2_dir_id), 1 << IH_Unreachable);
-	free (buf);
-    }
+	struct reiserfs_de_head *deh;
+	int i;
+	char *buf;
+	char *name;
+	int namelen;
+
+	/* if there are anything with this key but a directory - move it
+	   somewhere else */
+	rewrite_file(comingih, 1, 0 /* do not change ih */ );
+
+	deh = (struct reiserfs_de_head *)item;
+
+	for (i = 0; i < get_ih_entry_count(comingih); i++, deh++) {
+		name = name_in_entry(deh, i);
+		namelen = name_in_entry_length(comingih, deh, i);
+
+		if (!is_properly_hashed(fs, name, namelen, get_deh_offset(deh)))
+			reiserfs_panic
+			    ("put_directory_item_into_tree: The entry (%d) \"%.*s\" of the directory %k has"
+			     " badly hashed entry", i, namelen, name,
+			     &comingih->ih_key);
+
+		asprintf(&buf, "%.*s", namelen, name);
+		/* 1 for fsck is important: if there is no any items of this
+		   directory in the tree yet - new item will be inserted
+		   marked not reached */
+		reiserfs_add_entry(fs, &(comingih->ih_key), buf,
+				   entry_length(comingih, deh, i),
+				   (struct reiserfs_key *)&(deh->deh2_dir_id),
+				   1 << IH_Unreachable);
+		free(buf);
+	}
 }
 
-
-
-void insert_item_separately (struct item_head * ih,
-			     char * item, int was_in_tree)
+void insert_item_separately(struct item_head *ih, char *item, int was_in_tree)
 {
-    if (get_key_dirid (&ih->ih_key) == get_key_objectid (&ih->ih_key))
-	reiserfs_panic ("insert_item_separately: The item being inserted has the bad key %H", ih);
-    
-    if (is_stat_data_ih (ih)) {
-	put_sd_into_tree (ih, item);
-    } else if (is_direntry_ih (ih)) {
-	put_directory_item_into_tree (ih, item);
-    } else {
-	reiserfsck_file_write (ih, item, was_in_tree);
-    }
+	if (get_key_dirid(&ih->ih_key) == get_key_objectid(&ih->ih_key))
+		reiserfs_panic
+		    ("insert_item_separately: The item being inserted has the bad key %H",
+		     ih);
+
+	if (is_stat_data_ih(ih)) {
+		put_sd_into_tree(ih, item);
+	} else if (is_direntry_ih(ih)) {
+		put_directory_item_into_tree(ih, item);
+	} else {
+		reiserfsck_file_write(ih, item, was_in_tree);
+	}
 }
 
-
-static void put_stat_data_items (struct buffer_head * bh) 
+static void put_stat_data_items(struct buffer_head *bh)
 {
-    int i;
-    struct item_head * ih;
-
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < B_NR_ITEMS (bh); i ++, ih ++) {
-
-        /* this check instead of saved_items */
-        if (!is_stat_data_ih (ih) || is_bad_item (bh, ih, B_I_PITEM (bh, ih))) {
-	    continue;
-        }
-	insert_item_separately (ih, B_I_PITEM (bh, ih), 0/*was in tree*/);
-    }
+	int i;
+	struct item_head *ih;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < B_NR_ITEMS(bh); i++, ih++) {
+
+		/* this check instead of saved_items */
+		if (!is_stat_data_ih(ih)
+		    || is_bad_item(bh, ih, B_I_PITEM(bh, ih))) {
+			continue;
+		}
+		insert_item_separately(ih, B_I_PITEM(bh, ih),
+				       0 /*was in tree */ );
+	}
 }
 
-static void put_not_stat_data_items (struct buffer_head * bh)
+static void put_not_stat_data_items(struct buffer_head *bh)
 {
-    int i;
-    struct item_head * ih;
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < B_NR_ITEMS (bh); i ++, ih ++) {
-
-        if (is_stat_data_ih (ih) || is_bad_item (bh, ih, B_I_PITEM (bh, ih))) {
-	    continue;
+	int i;
+	struct item_head *ih;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < B_NR_ITEMS(bh); i++, ih++) {
+
+		if (is_stat_data_ih(ih)
+		    || is_bad_item(bh, ih, B_I_PITEM(bh, ih))) {
+			continue;
+		}
+		insert_item_separately(ih, B_I_PITEM(bh, ih),
+				       0 /*was in tree */ );
 	}
-	insert_item_separately (ih, B_I_PITEM (bh, ih), 0/*was in tree*/);
-    }
 }
 
-
-static void before_pass_2 (reiserfs_filsys_t * fs)
+static void before_pass_2(reiserfs_filsys_t *fs)
 {
-    /* anything specific for pass 2 ? */
+	/* anything specific for pass 2 ? */
 }
 
-
-static void save_pass_2_result (reiserfs_filsys_t * fs)
+static void save_pass_2_result(reiserfs_filsys_t *fs)
 {
-    FILE * file;
-    int retval;
-
-    file = open_file("temp_fsck_file.deleteme", "w+");
-    if (!file)
-	return;
-    
-    /* to be able to restart from semantic we do not need to save
-       anything here, but two magic values */
-    reiserfs_begin_stage_info_save(file, TREE_IS_BUILT);
-    reiserfs_end_stage_info_save (file);
-    close_file (file);
-    retval = rename ("temp_fsck_file.deleteme", state_dump_file (fs));
-    if (retval != 0)
-	fsck_progress ("%s: Could not rename the temporary file temp_fsck_file.deleteme to %s",
-	    __FUNCTION__, state_dump_file (fs));
+	FILE *file;
+	int retval;
+
+	file = open_file("temp_fsck_file.deleteme", "w+");
+	if (!file)
+		return;
+
+	/* to be able to restart from semantic we do not need to save
+	   anything here, but two magic values */
+	reiserfs_begin_stage_info_save(file, TREE_IS_BUILT);
+	reiserfs_end_stage_info_save(file);
+	close_file(file);
+	retval = rename("temp_fsck_file.deleteme", state_dump_file(fs));
+	if (retval != 0)
+		fsck_progress
+		    ("%s: Could not rename the temporary file temp_fsck_file.deleteme to %s",
+		     __FUNCTION__, state_dump_file(fs));
 }
 
-
 /* we have nothing to load from a state file, but we have to fetch
    on-disk bitmap, copy it to allocable bitmap, and fetch objectid
    map */
-void load_pass_2_result (reiserfs_filsys_t * fs)
+void load_pass_2_result(reiserfs_filsys_t *fs)
 {
-    fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_new_bitmap (fs), fs->fs_bitmap2);
-    
-    fsck_allocable_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_allocable_bitmap (fs), fs->fs_bitmap2);
-
-    fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
-    fs->block_deallocator = reiserfsck_reiserfs_free_block;
-
-    /* we need objectid map on semantic pass to be able to relocate files */
-    proper_id_map (fs) = id_map_init();
-    /* Not implemented yet.
-    fetch_objectid_map (proper_id_map (fs), fs);    
-    */
+	fsck_new_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_new_bitmap(fs), fs->fs_bitmap2);
+
+	fsck_allocable_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_allocable_bitmap(fs), fs->fs_bitmap2);
+
+	fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
+	fs->block_deallocator = reiserfsck_reiserfs_free_block;
+
+	/* we need objectid map on semantic pass to be able to relocate files */
+	proper_id_map(fs) = id_map_init();
+	/* Not implemented yet.
+	   fetch_objectid_map (proper_id_map (fs), fs);    
+	 */
 }
 
-    
 /* uninsertable blocks are marked by 0s in uninsertable_leaf_bitmap
    during the pass 1. They must be not in the tree */
-static void do_pass_2 (reiserfs_filsys_t * fs) {
-
-    struct buffer_head * bh;
-    unsigned long j;
-    int i, what_node;
-    unsigned long done = 0, total;
-
-
-    total = reiserfs_bitmap_zeros(fsck_uninsertables(fs)) * 2;
-    if (!total)
-	return;
+static void do_pass_2(reiserfs_filsys_t *fs)
+{
 
-    fsck_progress ("\nPass 2:\n");
-
-    for (i = 0; i < 2; i++) {
-        j = 0;
-        while ((j < fsck_uninsertables(fs)->bm_bit_size) && 
-	       reiserfs_bitmap_find_zero_bit(fsck_uninsertables(fs), &j) == 0) 
-	{
-	    bh = bread (fs->fs_dev, j, fs->fs_blocksize);
-	    if (bh == 0) {
-	        fsck_log ("pass_2: Reading of the block (%lu) failed on the device 0x%x\n",
-		      j, fs->fs_dev);
-                goto cont;
-            }
-	
-            if (is_block_used (bh->b_blocknr) && !(block_of_journal (fs, bh->b_blocknr) &&
-					       fsck_data(fs)->rebuild.use_journal_area)) {
-		fsck_log("%s: The block (%lu) is in the tree already. Should not happen.\n", 
-		    __FUNCTION__, bh->b_blocknr);
-		goto cont;
-            }
-            /* this must be leaf */
-            what_node = who_is_this (bh->b_data, bh->b_size);
-	    if (what_node != THE_LEAF) { // || B_IS_KEYS_LEVEL(bh)) {
-	        fsck_log ("%s: The block (%b), marked as a leaf on the first two passes, "
-			  "is not a leaf! Will be skipped.\n", __FUNCTION__, bh);
-	        goto cont;
-	    }
+	struct buffer_head *bh;
+	unsigned long j;
+	int i, what_node;
+	unsigned long done = 0, total;
+
+	total = reiserfs_bitmap_zeros(fsck_uninsertables(fs)) * 2;
+	if (!total)
+		return;
+
+	fsck_progress("\nPass 2:\n");
+
+	for (i = 0; i < 2; i++) {
+		j = 0;
+		while ((j < fsck_uninsertables(fs)->bm_bit_size) &&
+		       reiserfs_bitmap_find_zero_bit(fsck_uninsertables(fs),
+						     &j) == 0) {
+			bh = bread(fs->fs_dev, j, fs->fs_blocksize);
+			if (bh == 0) {
+				fsck_log
+				    ("pass_2: Reading of the block (%lu) failed on the device 0x%x\n",
+				     j, fs->fs_dev);
+				goto cont;
+			}
+
+			if (is_block_used(bh->b_blocknr)
+			    && !(block_of_journal(fs, bh->b_blocknr)
+				 && fsck_data(fs)->rebuild.use_journal_area)) {
+				fsck_log
+				    ("%s: The block (%lu) is in the tree already. Should not happen.\n",
+				     __FUNCTION__, bh->b_blocknr);
+				goto cont;
+			}
+			/* this must be leaf */
+			what_node = who_is_this(bh->b_data, bh->b_size);
+			if (what_node != THE_LEAF) {	// || B_IS_KEYS_LEVEL(bh)) {
+				fsck_log
+				    ("%s: The block (%b), marked as a leaf on the first two passes, "
+				     "is not a leaf! Will be skipped.\n",
+				     __FUNCTION__, bh);
+				goto cont;
+			}
 /*	
 	    fsck_log ("block %lu is being inserted\n", bh->b_blocknr);
 	    check_buffers_mem(fsck_log_file (fs));
 	    fflush(fsck_log_file (fs));
-*/	
-	    if (i) {
-                /* insert all not SD items */
-                put_not_stat_data_items (bh);
-                pass_2_stat (fs)->leaves ++;
-                make_allocable (j);
-            } else
-                /* insert SD items only */
-                put_stat_data_items (bh);
-
-            print_how_far (fsck_progress_file (fs), &done, total, 1, fsck_quiet (fs));
-        cont:
-	    brelse (bh);
-	    j ++;
-        }
-    }
+*/
+			if (i) {
+				/* insert all not SD items */
+				put_not_stat_data_items(bh);
+				pass_2_stat(fs)->leaves++;
+				make_allocable(j);
+			} else
+				/* insert SD items only */
+				put_stat_data_items(bh);
+
+			print_how_far(fsck_progress_file(fs), &done, total, 1,
+				      fsck_quiet(fs));
+cont:
+			brelse(bh);
+			j++;
+		}
+	}
 
-    fsck_progress ("\n");
+	fsck_progress("\n");
 }
 
-
-static void after_pass_2 (reiserfs_filsys_t * fs)
+static void after_pass_2(reiserfs_filsys_t *fs)
 {
-    time_t t;
-
-    /* we can now flush new_bitmap on disk as tree is built and 
-       contains all data, which were found on dik at start in 
-       used bitmaps */
-    reiserfs_bitmap_copy (fs->fs_bitmap2, fsck_new_bitmap (fs));
-    
-    /* we should copy new_bitmap to allocable bitmap, becuase evth what is used 
-       for now (marked as used in new_bitmap) should not be allocablel;
-       and what is not in tree for now should be allocable.
-       these bitmaps differ because on pass2 we skip those blocks, whose SD's 
-       are not in the tree, and therefore indirect items of such bad leaves points 
-       to not used and not allocable blocks.       
-     */
-
-
-    /* DEBUG only */
+	time_t t;
+
+	/* we can now flush new_bitmap on disk as tree is built and 
+	   contains all data, which were found on dik at start in 
+	   used bitmaps */
+	reiserfs_bitmap_copy(fs->fs_bitmap2, fsck_new_bitmap(fs));
+
+	/* we should copy new_bitmap to allocable bitmap, becuase evth what is used 
+	   for now (marked as used in new_bitmap) should not be allocablel;
+	   and what is not in tree for now should be allocable.
+	   these bitmaps differ because on pass2 we skip those blocks, whose SD's 
+	   are not in the tree, and therefore indirect items of such bad leaves points 
+	   to not used and not allocable blocks.       
+	 */
+
+	/* DEBUG only */
 /*    if (reiserfs_bitmap_compare (fsck_allocable_bitmap (fs), fsck_new_bitmap(fs))) {
         fsck_log ("Allocable bitmap differs from the new bitmap after pass2\n");
 	reiserfs_bitmap_copy (fsck_allocable_bitmap(fs), fsck_new_bitmap (fs));
     }
 */
 
-    /* update super block: objectid map, fsck state */
-    set_sb_fs_state (fs->fs_ondisk_sb, TREE_IS_BUILT);
-    mark_buffer_dirty (fs->fs_super_bh);
-  
-    /* write all dirty blocks */
-    fsck_progress ("Flushing..");
-    id_map_flush(proper_id_map (fs), fs);
-    fs->fs_dirt = 1;
-    reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs);
-    reiserfs_flush (fs);
-    fsck_progress ("finished\n");
-    
-    /* fixme: should be optional */
+	/* update super block: objectid map, fsck state */
+	set_sb_fs_state(fs->fs_ondisk_sb, TREE_IS_BUILT);
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	/* write all dirty blocks */
+	fsck_progress("Flushing..");
+	id_map_flush(proper_id_map(fs), fs);
+	fs->fs_dirt = 1;
+	reiserfs_flush_to_ondisk_bitmap(fs->fs_bitmap2, fs);
+	reiserfs_flush(fs);
+	fsck_progress("finished\n");
+
+	/* fixme: should be optional */
 /*    fsck_progress ("Tree is built. Checking it - ");
     reiserfsck_check_pass1 ();
     fsck_progress ("finished\n");*/
 
-    stage_report (2, fs);
-
-    /* free what we do not need anymore */
-    reiserfs_delete_bitmap (fsck_uninsertables (fs));
-
-    if (!fsck_run_one_step (fs)) {
-	if (fsck_user_confirmed (fs, "Continue? (Yes):", "Yes\n", 1))
-	    /* reiserfsck continues */
-	    return;
-    } else
-	save_pass_2_result (fs);
-
-    
-    id_map_free(proper_id_map (fs));
-    proper_id_map (fs) = 0;
-    
-    reiserfs_delete_bitmap (fsck_new_bitmap (fs));
-    reiserfs_delete_bitmap (fsck_allocable_bitmap (fs));
-    
-    time (&t);
-    fsck_progress ("###########\n"
-		   "reiserfsck finished pass 2 at %s"
-		   "###########\n", ctime (&t));
-    fs->fs_dirt = 1;
-    reiserfs_close (fs);
-    exit(0);
-}
+	stage_report(2, fs);
 
+	/* free what we do not need anymore */
+	reiserfs_delete_bitmap(fsck_uninsertables(fs));
 
+	if (!fsck_run_one_step(fs)) {
+		if (fsck_user_confirmed(fs, "Continue? (Yes):", "Yes\n", 1))
+			/* reiserfsck continues */
+			return;
+	} else
+		save_pass_2_result(fs);
 
-void pass_2 (reiserfs_filsys_t * fs)
+	id_map_free(proper_id_map(fs));
+	proper_id_map(fs) = 0;
+
+	reiserfs_delete_bitmap(fsck_new_bitmap(fs));
+	reiserfs_delete_bitmap(fsck_allocable_bitmap(fs));
+
+	time(&t);
+	fsck_progress("###########\n"
+		      "reiserfsck finished pass 2 at %s"
+		      "###########\n", ctime(&t));
+	fs->fs_dirt = 1;
+	reiserfs_close(fs);
+	exit(0);
+}
+
+void pass_2(reiserfs_filsys_t *fs)
 {
-    if (fsck_log_file (fs) != stderr)
-	fsck_log ("####### Pass 2 #######\n");
-    
-    before_pass_2 (fs);
-    
-    /* take blocks which were not inserted into tree yet and put each
-	item separately */
-    do_pass_2 (fs);
-    
-    after_pass_2 (fs);
-
-    if (get_sb_root_block (fs->fs_ondisk_sb) == ~(__u32)0 || 
-	get_sb_root_block (fs->fs_ondisk_sb) == 0)
-	die ( "\nNo reiserfs metadata found.  If you are sure that you had the reiserfs\n"
-		"on this partition,  then the start  of the partition  might be changed\n"
-		"or all data were wiped out. The start of the partition may get changed\n"
-		"by a partitioner  if you have used one.  Then you probably rebuilt the\n"
-		"superblock as there was no one.  Zero the block at 64K offset from the\n"
-		"start of the partition (a new super block you have just built) and try\n"
-	        "to move the start of the partition a few cylinders aside  and check if\n" 
-		"debugreiserfs /dev/xxx detects a reiserfs super block. If it does this\n"
-	        "is likely to be the right super block version.\n");
+	if (fsck_log_file(fs) != stderr)
+		fsck_log("####### Pass 2 #######\n");
+
+	before_pass_2(fs);
+
+	/* take blocks which were not inserted into tree yet and put each
+	   item separately */
+	do_pass_2(fs);
+
+	after_pass_2(fs);
+
+	if (get_sb_root_block(fs->fs_ondisk_sb) == ~(__u32) 0 ||
+	    get_sb_root_block(fs->fs_ondisk_sb) == 0)
+		die("\nNo reiserfs metadata found.  If you are sure that you had the reiserfs\n" "on this partition,  then the start  of the partition  might be changed\n" "or all data were wiped out. The start of the partition may get changed\n" "by a partitioner  if you have used one.  Then you probably rebuilt the\n" "superblock as there was no one.  Zero the block at 64K offset from the\n" "start of the partition (a new super block you have just built) and try\n" "to move the start of the partition a few cylinders aside  and check if\n" "debugreiserfs /dev/xxx detects a reiserfs super block. If it does this\n" "is likely to be the right super block version.                        \n" "If this makes you nervous, try  www.namesys.com/support.html,  and for\n" "$25 the author of fsck,  or a colleague  if he is out,  will  step you\n" "through it all.\n");
 }
diff --git a/fsck/pass4.c b/fsck/pass4.c
index ede3ce4..724c093 100644
--- a/fsck/pass4.c
+++ b/fsck/pass4.c
@@ -5,86 +5,87 @@
 
 #include "fsck.h"
 
-void pass_4_check_unaccessed_items (void)
+void pass_4_check_unaccessed_items(void)
 {
-    struct reiserfs_key key;
-    struct reiserfs_path path;
-    int i;
-    struct buffer_head * bh;
-    struct item_head * ih;
-    unsigned long items;
-    struct reiserfs_key *rdkey;
-
-    path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
-    key = root_dir_key;
-    
-    fsck_progress ("Pass 4 - ");
-    items = 0;
-
-    while (reiserfs_search_by_key_4 (fs, &key, &path) == ITEM_FOUND) {
-	bh = PATH_PLAST_BUFFER (&path);
-
-	/* print ~ how many leaves were scanned and how fast it was */
-	if (!fsck_quiet (fs))
-	    print_how_fast (items++, 0, 50, 0);
-
-	for (i = get_item_pos (&path), ih = get_ih (&path); i < B_NR_ITEMS (bh); i ++, ih ++) {
-	    if (!is_item_reachable (ih)) {
-		PATH_LAST_POSITION (&path) = i;
+	struct reiserfs_key key;
+	struct reiserfs_path path;
+	int i;
+	struct buffer_head *bh;
+	struct item_head *ih;
+	unsigned long items;
+	struct reiserfs_key *rdkey;
+
+	path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
+	key = root_dir_key;
+
+	fsck_progress("Pass 4 - ");
+	items = 0;
+
+	while (reiserfs_search_by_key_4(fs, &key, &path) == ITEM_FOUND) {
+		bh = PATH_PLAST_BUFFER(&path);
+
+		/* print ~ how many leaves were scanned and how fast it was */
+		if (!fsck_quiet(fs))
+			print_how_fast(items++, 0, 50, 0);
+
+		for (i = get_item_pos(&path), ih = get_ih(&path);
+		     i < B_NR_ITEMS(bh); i++, ih++) {
+			if (!is_item_reachable(ih)) {
+				PATH_LAST_POSITION(&path) = i;
+				rdkey = reiserfs_next_key(&path);
+				if (rdkey)
+					key = *rdkey;
+				else
+					memset(&key, 0xff, KEY_SIZE);
+
+				pass_4_stat(fs)->deleted_items++;
+
+				reiserfsck_delete_item(&path, 0);
+
+				goto cont;
+			}
+
+			if (get_ih_flags(ih) != 0) {
+				clean_ih_flags(ih);
+				mark_buffer_dirty(bh);
+			}
+
+		}
+		PATH_LAST_POSITION(&path) = i - 1;
 		rdkey = reiserfs_next_key(&path);
 		if (rdkey)
-		    key = *rdkey;
+			key = *rdkey;
 		else
-		    memset (&key, 0xff, KEY_SIZE);	
-		
-		pass_4_stat (fs)->deleted_items ++;
-	
-		reiserfsck_delete_item (&path, 0);
-
-		goto cont;
-	    }
-	
-	    if (get_ih_flags(ih) != 0) {
-		clean_ih_flags(ih);
-		mark_buffer_dirty(bh);
-	    }
-	    
+			memset(&key, 0xff, KEY_SIZE);
+
+		pathrelse(&path);
+
+cont:
+		/* to make gcc 3.2 do not sware here */ ;
 	}
-	PATH_LAST_POSITION(&path) = i - 1;
-	rdkey = reiserfs_next_key (&path);
-	if (rdkey)
-	    key = *rdkey;
-	else
-	    memset (&key, 0xff, KEY_SIZE);	
-	
-	pathrelse (&path);
-
-    cont:
-	/* to make gcc 3.2 do not sware here */;
-    }
-
-    pathrelse (&path);
-
-    fsck_progress ("finished\n");
-    stage_report (4, fs);
-
-    /* after pass 4 */
-
-    /* put bitmap on place */
-    reiserfs_bitmap_copy (fs->fs_bitmap2, fsck_new_bitmap (fs));
-
-    /* update super block */
-    set_sb_free_blocks (fs->fs_ondisk_sb, reiserfs_bitmap_zeros (fsck_new_bitmap (fs)));
-    mark_buffer_dirty (fs->fs_super_bh);
-
-    /* write all dirty blocks */
-    fsck_progress ("Flushing..");
-    fs->fs_dirt = 1;
-    id_map_flush(proper_id_map (fs), fs);
-    reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs);
-    reiserfs_flush (fs);
-    fsck_progress ("finished\n");
-
-    
-    return;
+
+	pathrelse(&path);
+
+	fsck_progress("finished\n");
+	stage_report(4, fs);
+
+	/* after pass 4 */
+
+	/* put bitmap on place */
+	reiserfs_bitmap_copy(fs->fs_bitmap2, fsck_new_bitmap(fs));
+
+	/* update super block */
+	set_sb_free_blocks(fs->fs_ondisk_sb,
+			   reiserfs_bitmap_zeros(fsck_new_bitmap(fs)));
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	/* write all dirty blocks */
+	fsck_progress("Flushing..");
+	fs->fs_dirt = 1;
+	id_map_flush(proper_id_map(fs), fs);
+	reiserfs_flush_to_ondisk_bitmap(fs->fs_bitmap2, fs);
+	reiserfs_flush(fs);
+	fsck_progress("finished\n");
+
+	return;
 }
diff --git a/fsck/semantic_check.c b/fsck/semantic_check.c
index 3509020..8e0d084 100644
--- a/fsck/semantic_check.c
+++ b/fsck/semantic_check.c
@@ -7,134 +7,131 @@
 static struct reiserfs_key *trunc_links = NULL;
 static __u32 links_num = 0;
 
-int wrong_mode (struct reiserfs_key *key, __u16 * mode, __u64 real_size, int symlink);
-int wrong_st_blocks(struct reiserfs_key *key, __u32 * blocks, __u32 sd_blocks, __u16 mode, 
-		    int new_format);
-int wrong_st_size (struct reiserfs_key *key, unsigned long long max_file_size, int blocksize,
-		   __u64 * size, __u64 sd_size, int type);
-int wrong_first_direct_byte (struct reiserfs_key *key, int blocksize, __u32 * first_direct_byte,
-			     __u32 sd_first_direct_byte, __u32 size);
-void get_object_key (struct reiserfs_de_head * deh, struct reiserfs_key *key, 
-		     struct reiserfs_key *entry_key, struct item_head * ih);
-void print_name (char * name, int len);
-void erase_name (int len);
-
-
-struct reiserfs_path_key
-{
-    struct short_key
-    {
-        __u32 k_dir_id;
-        __u32 k_objectid;
-    } key;
-    struct reiserfs_path_key * next, * prev;
+int wrong_mode(struct reiserfs_key *key, __u16 * mode, __u64 real_size,
+	       int symlink);
+int wrong_st_blocks(struct reiserfs_key *key, __u32 * blocks, __u32 sd_blocks,
+		    __u16 mode, int new_format);
+int wrong_st_size(struct reiserfs_key *key, unsigned long long max_file_size,
+		  int blocksize, __u64 * size, __u64 sd_size, int type);
+int wrong_first_direct_byte(struct reiserfs_key *key, int blocksize,
+			    __u32 * first_direct_byte,
+			    __u32 sd_first_direct_byte, __u32 size);
+void get_object_key(struct reiserfs_de_head *deh, struct reiserfs_key *key,
+		    struct reiserfs_key *entry_key, struct item_head *ih);
+void print_name(char *name, int len);
+void erase_name(int len);
+
+struct reiserfs_path_key {
+	struct short_key {
+		__u32 k_dir_id;
+		__u32 k_objectid;
+	} key;
+	struct reiserfs_path_key *next, *prev;
 };
 
-struct reiserfs_path_key * head_key = NULL;
-struct reiserfs_path_key * tail_key = NULL;
+struct reiserfs_path_key *head_key = NULL;
+struct reiserfs_path_key *tail_key = NULL;
 
 static int check_path_key(struct reiserfs_key *key)
 {
-    struct reiserfs_path_key * cur = head_key;
-
-    while(cur != NULL)
-    {
-        if (!comp_short_keys(&cur->key, key)) {
-            fsck_log("\nsemantic check: The directory %k has 2 names.", key);
-            return LOOP_FOUND;
-        }
-        cur = cur->next;
-    }
-    return 0;
+	struct reiserfs_path_key *cur = head_key;
+
+	while (cur != NULL) {
+		if (!comp_short_keys(&cur->key, key)) {
+			fsck_log
+			    ("\nsemantic check: The directory %k has 2 names.",
+			     key);
+			return LOOP_FOUND;
+		}
+		cur = cur->next;
+	}
+	return 0;
 }
 
 static int add_path_key(struct reiserfs_key *key)
 {
-    if (check_path_key(key))
-    	return LOOP_FOUND;
-
-    if (tail_key == NULL)
-    {
-        tail_key = getmem(sizeof(struct reiserfs_path_key));
-        head_key = tail_key;
-        tail_key->prev = NULL;
-    }else{
-        tail_key->next = getmem(sizeof(struct reiserfs_path_key));
-        tail_key->next->prev = tail_key;
-        tail_key = tail_key->next;
-    }
-    copy_short_key (&tail_key->key, key);
-    tail_key->next = NULL;
+	if (check_path_key(key))
+		return LOOP_FOUND;
 
-    return 0;
+	if (tail_key == NULL) {
+		tail_key = getmem(sizeof(struct reiserfs_path_key));
+		head_key = tail_key;
+		tail_key->prev = NULL;
+	} else {
+		tail_key->next = getmem(sizeof(struct reiserfs_path_key));
+		tail_key->next->prev = tail_key;
+		tail_key = tail_key->next;
+	}
+	copy_short_key(&tail_key->key, key);
+	tail_key->next = NULL;
+
+	return 0;
 }
 
 void del_path_key()
 {
-    if (tail_key == NULL)
-        die("Wrong path_key structure");
-
-    if (tail_key->prev == NULL)
-    {
-        freemem(tail_key);
-        tail_key = head_key = NULL;
-    }else{
-        tail_key = tail_key->prev;
-        freemem(tail_key->next);
-        tail_key->next = NULL;
-    }
+	if (tail_key == NULL)
+		die("Wrong path_key structure");
+
+	if (tail_key->prev == NULL) {
+		freemem(tail_key);
+		tail_key = head_key = NULL;
+	} else {
+		tail_key = tail_key->prev;
+		freemem(tail_key->next);
+		tail_key->next = NULL;
+	}
 }
 
 /* path is path to stat data. If file will be relocated - new_ih will contain
    a key file was relocated with */
-static int check_check_regular_file (struct reiserfs_path *path, void * sd,
-                                     struct item_head * new_ih)
+static int check_check_regular_file(struct reiserfs_path *path, void *sd,
+				    struct item_head *new_ih)
 {
-    int is_new_file;
+	int is_new_file;
 //    struct reiserfs_key key, sd_key;
-    __u16 mode;
-    __u32 nlink;
-    __u64 real_size, sd_size;
-    __u32 blocks, sd_blocks;	/* proper values and value in stat data */
-    __u32 first_direct_byte, sd_first_direct_byte;
-
-    struct item_head * ih, sd_ih;
-    int fix_sd;
-    int symlnk = 0;
-    int retval = OK;
-    __u32 tmp_position;
-
-
-    ih = get_ih (path);
-
-    if (new_ih) {
-	/* this objectid is used already */
-	*new_ih = *ih;
-	pathrelse (path);
-	rewrite_file (new_ih, 1, 1);
-	linked_already(&new_ih->ih_key);
-	one_less_corruption (fs, FIXABLE);
-	sem_pass_stat (fs)->oid_sharing_files_relocated ++;
-	retval = RELOCATED;
-	if (reiserfs_search_by_key_4 (fs, &(new_ih->ih_key), path) == ITEM_NOT_FOUND)
-	    reiserfs_panic ("check_check_regular_file: Could not find a StatData of "
-		"the relocated file %K", &new_ih->ih_key);
-	/* stat data is marked unreachable again due to relocation, fix that */
-	ih = get_ih (path);
-	sd = get_item (path);
-    }
-    
-
-    if (get_ih_item_len (ih) == SD_SIZE)
-	is_new_file = 1;
-    else
-	is_new_file = 0;
+	__u16 mode;
+	__u32 nlink;
+	__u64 real_size, sd_size;
+	__u32 blocks, sd_blocks;	/* proper values and value in stat data */
+	__u32 first_direct_byte, sd_first_direct_byte;
+
+	struct item_head *ih, sd_ih;
+	int fix_sd;
+	int symlnk = 0;
+	int retval = OK;
+	__u32 tmp_position;
+
+	ih = get_ih(path);
+
+	if (new_ih) {
+		/* this objectid is used already */
+		*new_ih = *ih;
+		pathrelse(path);
+		rewrite_file(new_ih, 1, 1);
+		linked_already(&new_ih->ih_key);
+		one_less_corruption(fs, FIXABLE);
+		sem_pass_stat(fs)->oid_sharing_files_relocated++;
+		retval = RELOCATED;
+		if (reiserfs_search_by_key_4(fs, &(new_ih->ih_key), path) ==
+		    ITEM_NOT_FOUND)
+			reiserfs_panic
+			    ("check_check_regular_file: Could not find a StatData of "
+			     "the relocated file %K", &new_ih->ih_key);
+		/* stat data is marked unreachable again due to relocation, fix that */
+		ih = get_ih(path);
+		sd = get_item(path);
+	}
 
+	if (get_ih_item_len(ih) == SD_SIZE)
+		is_new_file = 1;
+	else
+		is_new_file = 0;
 
-    get_sd_nlink (ih, sd, &nlink);
-    get_sd_mode (ih, sd, &mode);
-    get_sd_size (ih, sd, &sd_size);
-    get_sd_blocks (ih, sd, &sd_blocks);
+	get_sd_nlink(ih, sd, &nlink);
+	get_sd_mode(ih, sd, &mode);
+	get_sd_size(ih, sd, &sd_size);
+	get_sd_blocks(ih, sd, &sd_blocks);
 
 /*	
     if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
@@ -148,123 +145,149 @@ static int check_check_regular_file (struct reiserfs_path *path, void * sd,
     }
 */
 
-    if (!is_new_file)
-	get_sd_first_direct_byte (ih, sd, &sd_first_direct_byte);
+	if (!is_new_file)
+		get_sd_first_direct_byte(ih, sd, &sd_first_direct_byte);
+
+	if (S_ISLNK(mode))
+		symlnk = 1;
 
-    if (S_ISLNK (mode)) 	
-	symlnk = 1;
-    
-    sd_ih = *ih;
+	sd_ih = *ih;
 //    sd_key = sd_ih.ih_key;
-    pathrelse (path);
-
-    if (are_file_items_correct (&sd_ih, sd, &real_size, &blocks, 0/* do not mark reachable */,
-	&symlnk) != 1) 
-    {
-	one_more_corruption (fs, FATAL);
-	fsck_log ("check_regular_file: The file %K with the corrupted structure found\n", 
-	    &sd_ih.ih_key);
-    } else {
-	fix_sd = 0;
-    
-	fix_sd += wrong_mode (&sd_ih.ih_key, &mode, real_size, symlnk);
-	if (!is_new_file)
-	    fix_sd += wrong_first_direct_byte (&sd_ih.ih_key, fs->fs_blocksize,
-		&first_direct_byte, sd_first_direct_byte, real_size);
-	
-	if (reiserfs_bin_search(&sd_ih.ih_key, trunc_links, links_num, sizeof(sd_ih.ih_key), 
-	    &tmp_position, comp_short_keys) != POSITION_FOUND) 
-	{
-	    fix_sd += wrong_st_size (&sd_ih.ih_key, is_new_file ? MAX_FILE_SIZE_V2 : 
-		MAX_FILE_SIZE_V1, fs->fs_blocksize, &real_size, sd_size, 
-		symlnk ? TYPE_SYMLINK : 0);
+	pathrelse(path);
+
+	if (are_file_items_correct
+	    (&sd_ih, sd, &real_size, &blocks, 0 /* do not mark reachable */ ,
+	     &symlnk) != 1) {
+		one_more_corruption(fs, FATAL);
+		fsck_log
+		    ("check_regular_file: The file %K with the corrupted structure found\n",
+		     &sd_ih.ih_key);
 	} else {
-	    real_size = sd_size;
-	}
-	
-	fix_sd += wrong_st_blocks (&sd_ih.ih_key, &blocks, sd_blocks, mode, is_new_file);
+		fix_sd = 0;
+
+		fix_sd += wrong_mode(&sd_ih.ih_key, &mode, real_size, symlnk);
+		if (!is_new_file)
+			fix_sd +=
+			    wrong_first_direct_byte(&sd_ih.ih_key,
+						    fs->fs_blocksize,
+						    &first_direct_byte,
+						    sd_first_direct_byte,
+						    real_size);
+
+		if (reiserfs_bin_search
+		    (&sd_ih.ih_key, trunc_links, links_num,
+		     sizeof(sd_ih.ih_key), &tmp_position,
+		     comp_short_keys) != POSITION_FOUND) {
+			fix_sd +=
+			    wrong_st_size(&sd_ih.ih_key,
+					  is_new_file ? MAX_FILE_SIZE_V2 :
+					  MAX_FILE_SIZE_V1, fs->fs_blocksize,
+					  &real_size, sd_size,
+					  symlnk ? TYPE_SYMLINK : 0);
+		} else {
+			real_size = sd_size;
+		}
 
-	if (fix_sd) {
-	    if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-    		struct buffer_head * bh;
-  	        /* find stat data and correct it */
-  	        set_type_and_offset (KEY_FORMAT_1, &sd_ih.ih_key, SD_OFFSET, TYPE_STAT_DATA);
-	        if (reiserfs_search_by_key_4 (fs, &sd_ih.ih_key, path) != ITEM_FOUND) {
-		    fsck_log ("check_regular_file: A StatData of the file %K cannot be "
-			"found\n", &sd_ih.ih_key);
-                    one_more_corruption (fs, FATAL);
-                    return STAT_DATA_NOT_FOUND;
-	        }
-	    
-	        bh = get_bh (path);
-	        ih = get_ih (path);
-	        sd = get_item (path);
-	        set_sd_size (ih, sd, &real_size);
-	        set_sd_blocks (ih, sd, &blocks);
-	        set_sd_mode (ih, sd, &mode);
-	        if (!is_new_file)
-		    set_sd_first_direct_byte (ih, sd, &first_direct_byte);
-		mark_buffer_dirty (bh);
-	    } else {
-		fsck_check_stat (fs)->fixable_corruptions += fix_sd;
-	    }
+		fix_sd +=
+		    wrong_st_blocks(&sd_ih.ih_key, &blocks, sd_blocks, mode,
+				    is_new_file);
+
+		if (fix_sd) {
+			if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+				struct buffer_head *bh;
+				/* find stat data and correct it */
+				set_type_and_offset(KEY_FORMAT_1, &sd_ih.ih_key,
+						    SD_OFFSET, TYPE_STAT_DATA);
+				if (reiserfs_search_by_key_4
+				    (fs, &sd_ih.ih_key, path) != ITEM_FOUND) {
+					fsck_log
+					    ("check_regular_file: A StatData of the file %K cannot be "
+					     "found\n", &sd_ih.ih_key);
+					one_more_corruption(fs, FATAL);
+					return STAT_DATA_NOT_FOUND;
+				}
+
+				bh = get_bh(path);
+				ih = get_ih(path);
+				sd = get_item(path);
+				set_sd_size(ih, sd, &real_size);
+				set_sd_blocks(ih, sd, &blocks);
+				set_sd_mode(ih, sd, &mode);
+				if (!is_new_file)
+					set_sd_first_direct_byte(ih, sd,
+								 &first_direct_byte);
+				mark_buffer_dirty(bh);
+			} else {
+				fsck_check_stat(fs)->fixable_corruptions +=
+				    fix_sd;
+			}
+		}
 	}
-    }    
-    return retval;
+	return retval;
 }
 
 /* returns buffer, containing found directory item.*/
-static char * get_next_directory_item (
-	struct reiserfs_key *key, /* on return this will contain key of next item in the tree */
-	struct reiserfs_key *parent, struct item_head * ih, __u32 * pos_in_item, int dir_format)
+static char *get_next_directory_item(struct reiserfs_key *key,	/* on return this will contain key of next item in the tree */
+				     struct reiserfs_key *parent,
+				     struct item_head *ih, __u32 * pos_in_item,
+				     int dir_format)
 {
-    INITIALIZE_REISERFS_PATH(path);
-    char * dir_item;
-    struct reiserfs_key *rdkey;
-    struct buffer_head * bh;
-    struct reiserfs_de_head * deh;
-    int i;
-    int retval;
-
+	INITIALIZE_REISERFS_PATH(path);
+	char *dir_item;
+	struct reiserfs_key *rdkey;
+	struct buffer_head *bh;
+	struct reiserfs_de_head *deh;
+	int i;
+	int retval;
 
 start_again:
 
-    retval = reiserfs_search_by_entry_key (fs, key, &path);
-
-    if (retval != POSITION_FOUND && get_offset (key) != DOT_OFFSET)
-	reiserfs_panic ("get_next_directory_item: The current directory %k cannot be found", 
-	    key);
-
-    /* leaf containing directory item */
-    bh = PATH_PLAST_BUFFER (&path);
-    *pos_in_item = path.pos_in_item;
-    *ih = *get_ih (&path);
-    deh = B_I_DEH (bh, ih);
-
-    /* position was not found for '.' or there is no '..' */
-    if (retval != POSITION_FOUND || ((get_offset (key) == DOT_OFFSET) &&
-	(get_ih_entry_count (ih) < 2 || name_in_entry_length (ih, deh + 1, 1) != 2 ||
-	 strncmp (name_in_entry (deh + 1, 1), "..", 2)))) {
-
-	fsck_log ("get_next_directory_item: The %s %k cannot be found in %k", 
-	    (retval == POSITION_NOT_FOUND) ? "entry" : "directory", key, &ih->ih_key);
-	
-	if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-	    /* add "." and ".." exist */
-	    pathrelse (&path);
-	    reiserfs_add_entry (fs, key, ".",  name_length (".", dir_format), key, 0);
-	    reiserfs_add_entry (fs, key, "..", name_length ("..", dir_format), parent, 0);
-	    fsck_log (" - entry was added\n");
-	    goto start_again;
-	} else {
-	    one_more_corruption (fs, FIXABLE);
-	    fsck_log ("\n");
-	    if (retval == DIRECTORY_NOT_FOUND)
-	        return 0;
+	retval = reiserfs_search_by_entry_key(fs, key, &path);
+
+	if (retval != POSITION_FOUND && get_offset(key) != DOT_OFFSET)
+		reiserfs_panic
+		    ("get_next_directory_item: The current directory %k cannot be found",
+		     key);
+
+	/* leaf containing directory item */
+	bh = PATH_PLAST_BUFFER(&path);
+	*pos_in_item = path.pos_in_item;
+	*ih = *get_ih(&path);
+	deh = B_I_DEH(bh, ih);
+
+	/* position was not found for '.' or there is no '..' */
+	if (retval != POSITION_FOUND || ((get_offset(key) == DOT_OFFSET) &&
+					 (get_ih_entry_count(ih) < 2
+					  || name_in_entry_length(ih, deh + 1,
+								  1) != 2
+					  || strncmp(name_in_entry(deh + 1, 1),
+						     "..", 2)))) {
+
+		fsck_log
+		    ("get_next_directory_item: The %s %k cannot be found in %k",
+		     (retval == POSITION_NOT_FOUND) ? "entry" : "directory",
+		     key, &ih->ih_key);
+
+		if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+			/* add "." and ".." exist */
+			pathrelse(&path);
+			reiserfs_add_entry(fs, key, ".",
+					   name_length(".", dir_format), key,
+					   0);
+			reiserfs_add_entry(fs, key, "..",
+					   name_length("..", dir_format),
+					   parent, 0);
+			fsck_log(" - entry was added\n");
+			goto start_again;
+		} else {
+			one_more_corruption(fs, FIXABLE);
+			fsck_log("\n");
+			if (retval == DIRECTORY_NOT_FOUND)
+				return 0;
+		}
 	}
-    }
 
-    /* make sure, that ".." exists as well */
+	/* make sure, that ".." exists as well */
 /*
     if (get_offset (key) == DOT_OFFSET) {
 	if (get_ih_entry_count (ih) < 2 ||
@@ -277,9 +300,9 @@ start_again:
 	}
     }
 */
-    /* mark hidden entries as visible, set "." and ".." correctly */
-    deh += *pos_in_item;
-    for (i = *pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
+	/* mark hidden entries as visible, set "." and ".." correctly */
+	deh += *pos_in_item;
+	for (i = *pos_in_item; i < get_ih_entry_count(ih); i++, deh++) {
 /*	int namelen;
 	char * name;
 
@@ -290,143 +313,158 @@ start_again:
 			    key, i, namelen, name);
 */
 
-	if (get_deh_offset (deh) == DOT_OFFSET) {
-	    if (not_of_one_file (&(deh->deh2_dir_id), key)) {
-		/* "." must point to the directory it is in */
-		
-		//deh->deh_objectid != REISERFS_ROOT_PARENT_OBJECTID)/*????*/ {
-		fsck_log ("get_next_directory_item: The entry \".\" of the directory %K "
-		    "pointes to %K, instead of %K", key, (struct reiserfs_key *)(&(deh->deh2_dir_id)), 
-		    key);
-		if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-		    set_deh_dirid (deh, get_key_dirid (key));
-		    set_deh_objectid (deh, get_key_objectid (key));
-		    mark_buffer_dirty (bh);
-		    fsck_log (" - corrected\n");
-		} else {
-		    one_more_corruption (fs, FIXABLE);
-		    fsck_log ("\n");
+		if (get_deh_offset(deh) == DOT_OFFSET) {
+			if (not_of_one_file(&(deh->deh2_dir_id), key)) {
+				/* "." must point to the directory it is in */
+
+				//deh->deh_objectid != REISERFS_ROOT_PARENT_OBJECTID)/*????*/ {
+				fsck_log
+				    ("get_next_directory_item: The entry \".\" of the directory %K "
+				     "pointes to %K, instead of %K", key,
+				     (struct reiserfs_key
+				      *)(&(deh->deh2_dir_id)), key);
+				if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+					set_deh_dirid(deh, get_key_dirid(key));
+					set_deh_objectid(deh,
+							 get_key_objectid(key));
+					mark_buffer_dirty(bh);
+					fsck_log(" - corrected\n");
+				} else {
+					one_more_corruption(fs, FIXABLE);
+					fsck_log("\n");
+				}
+			}
 		}
-	    }
-	}
 
-	if (get_deh_offset (deh) == DOT_DOT_OFFSET) {
-	    /* set ".." so that it points to the correct parent directory */
-	    if (comp_short_keys (&(deh->deh2_dir_id), parent)) {
-		fsck_log ("get_next_directory_item: The entry \"..\" of the directory %K "
-		    "pointes to %K, instead of %K", key, (struct reiserfs_key *)(&(deh->deh2_dir_id)));
-		if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-		    set_deh_dirid (deh, get_key_dirid (parent));
-		    set_deh_objectid (deh, get_key_objectid (parent));
-		    mark_buffer_dirty (bh);
-		    fsck_log (" - corrected\n");
-		} else {
-		    one_more_corruption (fs, FIXABLE);
-		    fsck_log ("\n");
+		if (get_deh_offset(deh) == DOT_DOT_OFFSET) {
+			/* set ".." so that it points to the correct parent directory */
+			if (comp_short_keys(&(deh->deh2_dir_id), parent)) {
+				fsck_log
+				    ("get_next_directory_item: The entry \"..\" of the directory %K "
+				     "pointes to %K, instead of %K", key,
+				     (struct reiserfs_key
+				      *)(&(deh->deh2_dir_id)));
+				if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+					set_deh_dirid(deh,
+						      get_key_dirid(parent));
+					set_deh_objectid(deh,
+							 get_key_objectid
+							 (parent));
+					mark_buffer_dirty(bh);
+					fsck_log(" - corrected\n");
+				} else {
+					one_more_corruption(fs, FIXABLE);
+					fsck_log("\n");
+				}
+			}
 		}
-	    }
 	}
-    }
-
-    /* copy directory item to the temporary buffer */
-    dir_item = getmem (get_ih_item_len (ih));
-    memcpy (dir_item, B_I_PITEM (bh, ih), get_ih_item_len (ih));
-
 
-    /* next item key */
-    if (PATH_LAST_POSITION (&path) == (B_NR_ITEMS (bh) - 1) &&
-	(rdkey = uget_rkey (&path)))
-	copy_key (key, rdkey);
-    else {
-	set_key_dirid (key, 0);
-	set_key_objectid (key, 0);
-    }
+	/* copy directory item to the temporary buffer */
+	dir_item = getmem(get_ih_item_len(ih));
+	memcpy(dir_item, B_I_PITEM(bh, ih), get_ih_item_len(ih));
+
+	/* next item key */
+	if (PATH_LAST_POSITION(&path) == (B_NR_ITEMS(bh) - 1) &&
+	    (rdkey = uget_rkey(&path)))
+		copy_key(key, rdkey);
+	else {
+		set_key_dirid(key, 0);
+		set_key_objectid(key, 0);
+	}
 
-    if (fsck_mode (fs) == FSCK_REBUILD)
-        mark_item_reachable (get_ih (&path), bh);
-    pathrelse (&path);
+	if (fsck_mode(fs) == FSCK_REBUILD)
+		mark_item_reachable(get_ih(&path), bh);
+	pathrelse(&path);
 
-    return dir_item;
+	return dir_item;
 }
 
 /* semantic pass of --check */
-static int check_semantic_pass (struct reiserfs_key *key, struct reiserfs_key *parent, int dot_dot, 
-    struct item_head * new_ih)
+static int check_semantic_pass(struct reiserfs_key *key,
+			       struct reiserfs_key *parent, int dot_dot,
+			       struct item_head *new_ih)
 {
-    struct reiserfs_path path;
-    void * sd;
-    __u32 nlink;
-    int is_new_dir;
-    struct buffer_head * bh;
-    struct item_head * ih;
-    int retval;
-    char * dir_item;
-    __u32 pos_in_item;
-    struct item_head tmp_ih;
-    struct reiserfs_key next_item_key, entry_key, object_key;
-    __u64 dir_size = 0;
-    __u32 blocks;
-    __u64 sd_size;
-    __u32 sd_blocks;
-    int fix_sd;
-    /*int relocate;*/
-    int dir_format = 0;
-    __u16 mode;
-    	
-    retval = OK;
-
- /* start_again: when directory was relocated */
-
-    if (!KEY_IS_STAT_DATA_KEY (key)) {
-	fsck_log ("check_semantic_pass: The key %k must be key of a StatData\n", key);
-	one_more_corruption (fs, FATAL);
-        return STAT_DATA_NOT_FOUND;
-    }
+	struct reiserfs_path path;
+	void *sd;
+	__u32 nlink;
+	int is_new_dir;
+	struct buffer_head *bh;
+	struct item_head *ih;
+	int retval;
+	char *dir_item;
+	__u32 pos_in_item;
+	struct item_head tmp_ih;
+	struct reiserfs_key next_item_key, entry_key, object_key;
+	__u64 dir_size = 0;
+	__u32 blocks;
+	__u64 sd_size;
+	__u32 sd_blocks;
+	int fix_sd;
+	/*int relocate; */
+	int dir_format = 0;
+	__u16 mode;
+
+	retval = OK;
+
+	/* start_again: when directory was relocated */
+
+	if (!KEY_IS_STAT_DATA_KEY(key)) {
+		fsck_log
+		    ("check_semantic_pass: The key %k must be key of a StatData\n",
+		     key);
+		one_more_corruption(fs, FATAL);
+		return STAT_DATA_NOT_FOUND;
+	}
 
-    /* look for stat data of an object */
-    if (reiserfs_search_by_key_4 (fs, key, &path) == ITEM_NOT_FOUND) {
-	pathrelse (&path);
-	return STAT_DATA_NOT_FOUND;
-    }
+	/* look for stat data of an object */
+	if (reiserfs_search_by_key_4(fs, key, &path) == ITEM_NOT_FOUND) {
+		pathrelse(&path);
+		return STAT_DATA_NOT_FOUND;
+	}
 
-    /* stat data has been found */
-    ih = get_ih (&path);
-    sd = get_item(&path);
+	/* stat data has been found */
+	ih = get_ih(&path);
+	sd = get_item(&path);
 
-    get_sd_nlink (ih, sd, &nlink);
+	get_sd_nlink(ih, sd, &nlink);
 
-    /* It seems quite difficult to relocate objects on fix-fixable - 
-     * rewrite_file calls reiserfs_file_write which can convert tails 
-     * to unfm, plus unreachable, was_tail flags, etc. */
+	/* It seems quite difficult to relocate objects on fix-fixable - 
+	 * rewrite_file calls reiserfs_file_write which can convert tails 
+	 * to unfm, plus unreachable, was_tail flags, etc. */
 #if 0
-    if ((/* relocate = */ should_be_relocated(&ih->ih_key))) {
-	/*
-	if (fsck_mode(fs) == FSCK_CHECK)
-	    relocate = 0;
-	*/
-	one_more_corruption(fs, FATAL);
-    }
+	if (( /* relocate = */ should_be_relocated(&ih->ih_key))) {
+		/*
+		   if (fsck_mode(fs) == FSCK_CHECK)
+		   relocate = 0;
+		 */
+		one_more_corruption(fs, FATAL);
+	}
 #endif
 
-    if (fix_obviously_wrong_sd_mode (&path)) {
-        one_more_corruption (fs, FIXABLE);
-	pathrelse (&path);
-        return OK;
-    }
-    
-    if (nlink == 0) {
-	fsck_log ("%s: block %lu: The StatData %k has bad nlink number (%u)\n",
-            __FUNCTION__, get_bh(&path)->b_blocknr, &ih->ih_key, nlink);
-	one_more_corruption (fs, FATAL); 
-    }
-    
-    if (not_a_directory (sd)) {
-	fsck_check_stat (fs)->files ++;
-	
-	retval = check_check_regular_file (&path, sd, /* relocate ? new_ih : */ 0);
-	pathrelse (&path);
-	return retval;
-    }
+	if (fix_obviously_wrong_sd_mode(&path)) {
+		one_more_corruption(fs, FIXABLE);
+		pathrelse(&path);
+		return OK;
+	}
+
+	if (nlink == 0) {
+		fsck_log
+		    ("%s: block %lu: The StatData %k has bad nlink number (%u)\n",
+		     __FUNCTION__, get_bh(&path)->b_blocknr, &ih->ih_key,
+		     nlink);
+		one_more_corruption(fs, FATAL);
+	}
+
+	if (not_a_directory(sd)) {
+		fsck_check_stat(fs)->files++;
+
+		retval =
+		    check_check_regular_file(&path, sd,
+					     /* relocate ? new_ih : */ 0);
+		pathrelse(&path);
+		return retval;
+	}
 
 /*
     if (relocate) {
@@ -472,345 +510,415 @@ static int check_semantic_pass (struct reiserfs_key *key, struct reiserfs_key *p
     }
 */
 
-    /* directory stat data found */
-    if (get_ih_item_len (ih) == SD_SIZE)
-	is_new_dir = 1;
-    else
-	is_new_dir = 0;
+	/* directory stat data found */
+	if (get_ih_item_len(ih) == SD_SIZE)
+		is_new_dir = 1;
+	else
+		is_new_dir = 0;
+
+	/* save stat data's size and st_blocks */
+	get_sd_size(ih, sd, &sd_size);
+	get_sd_blocks(ih, sd, &sd_blocks);
+	get_sd_mode(ih, sd, &mode);
+
+	dir_format =
+	    (get_ih_item_len(get_ih(&path)) ==
+	     SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
+
+	/* release path pointing to stat data */
+	pathrelse(&path);
+
+	fsck_check_stat(fs)->dirs++;
+
+	set_key_dirid(&next_item_key, get_key_dirid(key));
+	set_key_objectid(&next_item_key, get_key_objectid(key));
+	set_key_offset_v1(&next_item_key, DOT_OFFSET);
+	set_key_uniqueness(&next_item_key, DIRENTRY_UNIQUENESS);
+
+	dir_size = 0;
+	while ((dir_item =
+		get_next_directory_item(&next_item_key, parent, &tmp_ih,
+					&pos_in_item, dir_format)) != 0) {
+		/* dir_item is copy of the item in separately allocated memory,
+		   item_key is a key of next item in the tree */
+		int i;
+		char *name = 0;
+		int namelen, entry_len;
+		struct reiserfs_de_head *deh =
+		    (struct reiserfs_de_head *)dir_item + pos_in_item;
+
+		for (i = pos_in_item; i < get_ih_entry_count(&tmp_ih);
+		     i++, deh++) {
+			struct item_head relocated_ih;
+			int ret = OK;
+
+			if (name) {
+				free(name);
+				name = 0;
+			}
+
+			namelen = name_in_entry_length(&tmp_ih, deh, i);
+			asprintf(&name, "%.*s", namelen, name_in_entry(deh, i));
+			entry_len = entry_length(&tmp_ih, deh, i);
+
+			get_object_key(deh, &object_key, &entry_key, &tmp_ih);
+
+			if ((dir_format == KEY_FORMAT_2)
+			    && (entry_len % 8 != 0)) {
+				/* not alighed directory of new format - delete it */
+				if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+					fsck_log
+					    ("Entry %K (\"%.*s\") in the directory %K is not formated "
+					     "properly - deleted\n",
+					     (struct reiserfs_key *)&(deh->
+								      deh2_dir_id),
+					     namelen, name, &tmp_ih.ih_key);
+					reiserfs_remove_entry(fs, &entry_key);
+					entry_len =
+					    name_length(name, dir_format);
+					reiserfs_add_entry(fs, key, name,
+							   entry_len,
+							   (struct reiserfs_key
+							    *)&(deh->
+								deh2_dir_id),
+							   0);
+				} else {
+					fsck_log
+					    ("Entry %K (\"%.*s\") in the directory %K is not formated "
+					     "properly.\n",
+					     (struct reiserfs_key *)&(deh->
+								      deh2_dir_id),
+					     namelen, name, &tmp_ih.ih_key);
+					one_more_corruption(fs, FIXABLE);
+				}
+			}
+
+			print_name(name, namelen);
+
+			if (!is_properly_hashed
+			    (fs, name, namelen, get_deh_offset(deh))) {
+				one_more_corruption(fs, FATAL);
+				fsck_log
+				    ("check_semantic_pass: Hash mismatch detected for (%.*s) in "
+				     "directory %K\n", namelen, name,
+				     &tmp_ih.ih_key);
+			}
+
+			if (is_dot(name, namelen)
+			    || (is_dot_dot(name, namelen))) {
+				/* do not go through "." and ".." */
+				ret = OK;
+			} else {
+				if ((ret = add_path_key(&object_key)) == 0) {
+					ret =
+					    check_semantic_pass(&object_key,
+								key,
+								is_dot_dot(name,
+									   namelen),
+								&relocated_ih);
+					del_path_key();
+				}
+			}
+
+			erase_name(namelen);
+
+			/* check what check_semantic_tree returned */
+			switch (ret) {
+			case OK:
+				dir_size += DEH_SIZE + entry_len;
+				break;
+
+			case STAT_DATA_NOT_FOUND:
+				fsck_log
+				    ("check_semantic_pass: Name \"%.*s\" in directory %K points to "
+				     "nowhere\n", namelen, name,
+				     &tmp_ih.ih_key);
+			case LOOP_FOUND:
+				if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+					reiserfs_remove_entry(fs, &entry_key);
+					fsck_log(" - removed");
+				} else {
+					one_more_corruption(fs, FIXABLE);
+				}
+				fsck_log("\n");
+				break;
+
+			case DIRECTORY_HAS_NO_ITEMS:
+				fsck_log
+				    ("check_semantic_pass: Name \"%.*s\" in directory %K points a "
+				     "directory without body\n", namelen, name,
+				     &tmp_ih.ih_key);
+
+				/* fixme: stat data should be deleted as well */
+				/*
+				   if (fsck_fix_fixable (fs)) {
+				   reiserfs_remove_entry (fs, &entry_key);
+				   fsck_data(fs)->deleted_entries ++;
+				   fsck_log (" - removed");
+				   }
+				   fsck_log ("\n"); */
+				break;
+
+			case RELOCATED:
+				/* file was relocated, update key in corresponding directory entry */
+				if (reiserfs_search_by_entry_key
+				    (fs, &entry_key, &path) != POSITION_FOUND) {
+					fsck_log
+					    ("Cannot find a name of the relocated file %K in the directory "
+					     "%K\n", &entry_key,
+					     &tmp_ih.ih_key);
+				} else {
+					/* update key dir entry points to */
+					struct reiserfs_de_head *tmp_deh;
+
+					tmp_deh =
+					    B_I_DEH(get_bh(&path),
+						    get_ih(&path)) +
+					    path.pos_in_item;
+					fsck_log
+					    ("The directory %K pointing to %K (\"%.*s\") updated to point "
+					     "to ", &tmp_ih.ih_key,
+					     &tmp_deh->deh2_dir_id, namelen,
+					     name);
+					set_deh_dirid(tmp_deh,
+						      get_key_dirid
+						      (&relocated_ih.ih_key));
+					set_deh_objectid(tmp_deh,
+							 get_key_objectid
+							 (&relocated_ih.
+							  ih_key));
+
+					fsck_log("%K (\"%.*s\")\n",
+						 &tmp_deh->deh2_dir_id, namelen,
+						 name);
+					mark_buffer_dirty(get_bh(&path));
+				}
+				dir_size += DEH_SIZE + entry_len;
+				pathrelse(&path);
+				break;
+			}
+		}		/* for */
+
+		freemem(dir_item);
+		free(name);
+		name = 0;
 
-    /* save stat data's size and st_blocks */
-    get_sd_size (ih, sd, &sd_size);
-    get_sd_blocks (ih, sd, &sd_blocks);
-    get_sd_mode (ih, sd, &mode);
+		if (not_of_one_file(&next_item_key, key))
+			/* next key is not of this directory */
+			break;
 
-    dir_format = (get_ih_item_len (get_ih (&path)) == SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
+	}			/* while (dir_item) */
 
-    /* release path pointing to stat data */
-    pathrelse (&path);
+	if (dir_size == 0)
+		/* FIXME: is it possible? */
+		return DIRECTORY_HAS_NO_ITEMS;
 
-    fsck_check_stat (fs)->dirs ++;
+	/* calc correct value of sd_blocks field of stat data */
+	blocks = dir_size2st_blocks(dir_size);
 
-    set_key_dirid (&next_item_key, get_key_dirid (key));
-    set_key_objectid (&next_item_key, get_key_objectid (key));
-    set_key_offset_v1 (&next_item_key, DOT_OFFSET);
-    set_key_uniqueness (&next_item_key, DIRENTRY_UNIQUENESS);
+	fix_sd = 0;
+	fix_sd += wrong_st_blocks(key, &blocks, sd_blocks, mode, is_new_dir);
+	fix_sd +=
+	    wrong_st_size(key, is_new_dir ? MAX_FILE_SIZE_V2 : MAX_FILE_SIZE_V1,
+			  fs->fs_blocksize, &dir_size, sd_size, TYPE_DIRENTRY);
 
-    dir_size = 0;
-    while ((dir_item = get_next_directory_item (&next_item_key, parent, &tmp_ih, 
-	&pos_in_item, dir_format)) != 0) 
-    {
-	/* dir_item is copy of the item in separately allocated memory,
-	   item_key is a key of next item in the tree */
-	int i;
-	char * name = 0;
-	int namelen, entry_len;
-	struct reiserfs_de_head * deh = (struct reiserfs_de_head *)dir_item + pos_in_item;
-	
-	
-	for (i = pos_in_item; i < get_ih_entry_count (&tmp_ih); i ++, deh ++) {
-	    struct item_head relocated_ih;
-	    int ret = OK;
-	    
-	    if (name) {
-		free (name);
-		name = 0;
-	    }
-	
-	    namelen = name_in_entry_length (&tmp_ih, deh, i);
-	    asprintf (&name, "%.*s", namelen, name_in_entry (deh, i));	
-	    entry_len = entry_length (&tmp_ih, deh, i);
-	
-	    get_object_key (deh, &object_key, &entry_key, &tmp_ih);
-
-	    if ((dir_format == KEY_FORMAT_2) && (entry_len % 8 != 0)) {
-		/* not alighed directory of new format - delete it */
-		if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-		    fsck_log ("Entry %K (\"%.*s\") in the directory %K is not formated "
-			"properly - deleted\n",	(struct reiserfs_key *)&(deh->deh2_dir_id), 
-			namelen, name, &tmp_ih.ih_key);
-		    reiserfs_remove_entry (fs, &entry_key);
-		    entry_len = name_length (name, dir_format);
-		    reiserfs_add_entry (fs, key, name, entry_len, 
-			(struct reiserfs_key *)&(deh->deh2_dir_id), 0);
-		} else {
-		    fsck_log ("Entry %K (\"%.*s\") in the directory %K is not formated "
-			"properly.\n", (struct reiserfs_key *)&(deh->deh2_dir_id), namelen, name, 
-			&tmp_ih.ih_key);
-		    one_more_corruption (fs, FIXABLE);
-		}
-	    }
-	
-	
-	    print_name (name, namelen);
-	    
-	    if (!is_properly_hashed (fs, name, namelen, get_deh_offset (deh))) {
-		one_more_corruption (fs, FATAL);
-		fsck_log ("check_semantic_pass: Hash mismatch detected for (%.*s) in "
-		    "directory %K\n", namelen, name, &tmp_ih.ih_key);
-	    }
-	
-	    if (is_dot (name, namelen) || (is_dot_dot (name, namelen))) {
-		/* do not go through "." and ".." */
-		ret = OK;
-	    } else {
-		if ((ret = add_path_key (&object_key)) == 0) {
-		    ret = check_semantic_pass (&object_key, key, 
-			is_dot_dot(name, namelen), &relocated_ih);
-		    del_path_key ();
-		}
-	    }
-	    
-	    erase_name (namelen);
-	    
-	    /* check what check_semantic_tree returned */
-	    switch (ret) {
-	    case OK:
-		dir_size += DEH_SIZE + entry_len;
-		break;
-		
-	    case STAT_DATA_NOT_FOUND:
-		fsck_log ("check_semantic_pass: Name \"%.*s\" in directory %K points to "
-		    "nowhere\n", namelen, name, &tmp_ih.ih_key);
-	    case LOOP_FOUND:
-		if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-		    reiserfs_remove_entry (fs, &entry_key);
-		    fsck_log (" - removed");
-		} else {
-		    one_more_corruption (fs, FIXABLE);
-		}
-		fsck_log ("\n");
-		break;
-		    
-	    case DIRECTORY_HAS_NO_ITEMS:
-		fsck_log ("check_semantic_pass: Name \"%.*s\" in directory %K points a "
-		    "directory without body\n", namelen, name, &tmp_ih.ih_key);
-		
-		/* fixme: stat data should be deleted as well */
-		/*
-		  if (fsck_fix_fixable (fs)) {
-		  reiserfs_remove_entry (fs, &entry_key);
-		  fsck_data(fs)->deleted_entries ++;
-		  fsck_log (" - removed");
-		  }
-		  fsck_log ("\n");*/
-		break;
-		
-	    case RELOCATED:
-		/* file was relocated, update key in corresponding directory entry */
-		if (reiserfs_search_by_entry_key (fs, &entry_key, &path) != POSITION_FOUND) {
-		    fsck_log("Cannot find a name of the relocated file %K in the directory "
-			"%K\n", &entry_key, &tmp_ih.ih_key);
+	if (fix_sd) {
+		if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+			/* we have to fix either sd_size or sd_blocks, so look for stat data again */
+			if (reiserfs_search_by_key_4(fs, key, &path) !=
+			    ITEM_FOUND) {
+				fsck_log
+				    ("check_semantic_tree: The StatData of the file %K was not found\n",
+				     key);
+				one_more_corruption(fs, FATAL);
+				return STAT_DATA_NOT_FOUND;
+			}
+
+			bh = get_bh(&path);
+			ih = get_ih(&path);
+			sd = get_item(&path);
+
+			set_sd_size(ih, sd, &dir_size);
+			set_sd_blocks(ih, sd, &blocks);
+			mark_buffer_dirty(bh);
+			pathrelse(&path);
 		} else {
-		    /* update key dir entry points to */
-		    struct reiserfs_de_head * tmp_deh;
-		    
-		    tmp_deh = B_I_DEH (get_bh (&path), get_ih (&path)) + path.pos_in_item;
-		    fsck_log ("The directory %K pointing to %K (\"%.*s\") updated to point "
-			"to ",	&tmp_ih.ih_key, &tmp_deh->deh2_dir_id, namelen, name);
-		    set_deh_dirid (tmp_deh, get_key_dirid (&relocated_ih.ih_key));
-		    set_deh_objectid (tmp_deh, get_key_objectid (&relocated_ih.ih_key));
-
-		    fsck_log ("%K (\"%.*s\")\n",  &tmp_deh->deh2_dir_id, namelen, name);
-		    mark_buffer_dirty (get_bh (&path));
+			fsck_check_stat(fs)->fixable_corruptions += fix_sd;
 		}
-		dir_size += DEH_SIZE + entry_len;
-		pathrelse (&path);
-		break;
-	    }
-	} /* for */
-	
-	freemem (dir_item);
-	free (name);
-	name = 0;
-
-	if (not_of_one_file (&next_item_key, key))
-	    /* next key is not of this directory */
-	    break;
-	
-    } /* while (dir_item) */
-    
-    
-    if (dir_size == 0)
-	/* FIXME: is it possible? */
-	return DIRECTORY_HAS_NO_ITEMS;
-    
-    /* calc correct value of sd_blocks field of stat data */
-    blocks = dir_size2st_blocks (dir_size);
-    
-    fix_sd = 0;
-    fix_sd += wrong_st_blocks (key, &blocks, sd_blocks, mode, is_new_dir);
-    fix_sd += wrong_st_size (key, is_new_dir ? MAX_FILE_SIZE_V2 : MAX_FILE_SIZE_V1,
-			     fs->fs_blocksize, &dir_size, sd_size, TYPE_DIRENTRY);
-
-    if (fix_sd) {
-	if (fsck_mode (fs) == FSCK_FIX_FIXABLE) {
-	    /* we have to fix either sd_size or sd_blocks, so look for stat data again */
-	    if (reiserfs_search_by_key_4 (fs, key, &path) != ITEM_FOUND) {
-		fsck_log ("check_semantic_tree: The StatData of the file %K was not found\n", 
-		    key);
-		one_more_corruption(fs, FATAL);
-                return STAT_DATA_NOT_FOUND;
-	    }
-	
-	    bh = get_bh (&path);
-	    ih = get_ih (&path);
-	    sd = get_item (&path);
-	
-	    set_sd_size (ih, sd, &dir_size);
-	    set_sd_blocks (ih, sd, &blocks);
-	    mark_buffer_dirty (bh);
-	    pathrelse (&path);
-	} else {
-	    fsck_check_stat (fs)->fixable_corruptions += fix_sd;
 	}
-    }
-    
-    return retval;
+
+	return retval;
 }
 
-int check_safe_links ()
+int check_safe_links()
 {
-    struct reiserfs_path safe_link_path, path;
-    struct reiserfs_key safe_link_key = {-1, 0, {{0, 0}}};
-    struct reiserfs_key key = {0, 0, {{0, 0}}};
-    struct reiserfs_key *rkey;
-    struct item_head * tmp_ih;
-
-    while (1) {
-        if (get_key_dirid (&safe_link_key) == 0)
-            break;
-
-	reiserfs_search_by_key_4 (fs, &safe_link_key, &safe_link_path);
-	
-	if (get_blkh_nr_items ( B_BLK_HEAD (get_bh(&safe_link_path))) <= 
-	    PATH_LAST_POSITION (&safe_link_path)) 
-	{
-	    pathrelse (&safe_link_path);
-            break;
-	}	
-	
-	tmp_ih = get_ih(&safe_link_path);
-	
-        if (get_key_dirid(&tmp_ih->ih_key) != (__u32)-1 ||
-	    get_key_objectid(&tmp_ih->ih_key) == (__u32)-1) {
-	    pathrelse (&safe_link_path);
-            break;
-	}
+	struct reiserfs_path safe_link_path, path;
+	struct reiserfs_key safe_link_key = { -1, 0, {{0, 0}} };
+	struct reiserfs_key key = { 0, 0, {{0, 0}} };
+	struct reiserfs_key *rkey;
+	struct item_head *tmp_ih;
+
+	while (1) {
+		if (get_key_dirid(&safe_link_key) == 0)
+			break;
+
+		reiserfs_search_by_key_4(fs, &safe_link_key, &safe_link_path);
+
+		if (get_blkh_nr_items(B_BLK_HEAD(get_bh(&safe_link_path))) <=
+		    PATH_LAST_POSITION(&safe_link_path)) {
+			pathrelse(&safe_link_path);
+			break;
+		}
 
-        if (get_ih_item_len (tmp_ih) != 4)
-	    reiserfs_panic ("Safe Link %k cannot be of the size %d", 
-		&tmp_ih->ih_key, get_ih_item_len (tmp_ih));
-	
-	set_key_dirid(&key, d32_get((__u32 *)get_item(&safe_link_path), 0));
-	set_key_objectid(&key, get_key_objectid(&tmp_ih->ih_key));
-	if ((rkey = reiserfs_next_key(&safe_link_path)) == NULL)
-	    set_key_dirid (&safe_link_key, 0);
-	else
-	    safe_link_key = *rkey;
-	
-	if (reiserfs_search_by_key_4 (fs, &key, &path) == ITEM_NOT_FOUND) {
-	    /*sware on check, delete on fix-fixable*/
-	    if (fsck_mode(fs) == FSCK_CHECK) {
-		fsck_log ("Invalid safe link %k: cannot find the pointed object (%K)\n", 
-		    &tmp_ih->ih_key, &key);
-		one_more_corruption (fs, FIXABLE);
-	    } else if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
-		fsck_log ("Invalid safe link %k: cannot find the pointed object (%K) - "
-		    "safe link was deleted\n", &tmp_ih->ih_key, &key);
-		d32_put((__u32 *)get_item(&safe_link_path), 0, 0);
-		pathrelse (&path);
-		reiserfsck_delete_item (&safe_link_path, 0);		
-		continue;
-	    }
-	} else if (get_offset(&tmp_ih->ih_key) == 0x1) {
-	    /* Truncate */
-	    if (!not_a_directory (get_item(&path))) {
-		/*truncate on directory should not happen*/
-		/*sware on check, delete on fix-fixable*/
-		if (fsck_mode(fs) == FSCK_CHECK) {
-		    fsck_log ("Invalid 'truncate' safe link %k, cannot happen for "
-			"directory (%K)\n", &tmp_ih->ih_key, &key);
-		    one_more_corruption (fs, FIXABLE);
-		} else if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
-		    fsck_log ("Invalid 'truncate' safe link %k, cannot happen for "
-			"a directory (%K) - safe link was deleted\n", &tmp_ih->ih_key, &key);
-		    d32_put((__u32 *)get_item(&safe_link_path), 0, 0);
-		    pathrelse (&path);
-		    reiserfsck_delete_item (&safe_link_path, 0);		
-		    continue;
+		tmp_ih = get_ih(&safe_link_path);
+
+		if (get_key_dirid(&tmp_ih->ih_key) != (__u32) - 1 ||
+		    get_key_objectid(&tmp_ih->ih_key) == (__u32) - 1) {
+			pathrelse(&safe_link_path);
+			break;
 		}
-	    } else {
-		/* save 'safe truncate links' to avoid swaring on wrong sizes. */
-		__u32 position;
-		
-		if (reiserfs_bin_search (&key, trunc_links, links_num, sizeof(key), 
-		    &position, comp_short_keys) != POSITION_FOUND) 
-		{
-		    blocklist__insert_in_position(&key, (void *)&trunc_links, &links_num, 
-			sizeof(key), &position);
-		}		
-	    }
+
+		if (get_ih_item_len(tmp_ih) != 4)
+			reiserfs_panic("Safe Link %k cannot be of the size %d",
+				       &tmp_ih->ih_key,
+				       get_ih_item_len(tmp_ih));
+
+		set_key_dirid(&key,
+			      d32_get((__u32 *) get_item(&safe_link_path), 0));
+		set_key_objectid(&key, get_key_objectid(&tmp_ih->ih_key));
+		if ((rkey = reiserfs_next_key(&safe_link_path)) == NULL)
+			set_key_dirid(&safe_link_key, 0);
+		else
+			safe_link_key = *rkey;
+
+		if (reiserfs_search_by_key_4(fs, &key, &path) == ITEM_NOT_FOUND) {
+			/*sware on check, delete on fix-fixable */
+			if (fsck_mode(fs) == FSCK_CHECK) {
+				fsck_log
+				    ("Invalid safe link %k: cannot find the pointed object (%K)\n",
+				     &tmp_ih->ih_key, &key);
+				one_more_corruption(fs, FIXABLE);
+			} else if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+				fsck_log
+				    ("Invalid safe link %k: cannot find the pointed object (%K) - "
+				     "safe link was deleted\n", &tmp_ih->ih_key,
+				     &key);
+				d32_put((__u32 *) get_item(&safe_link_path), 0,
+					0);
+				pathrelse(&path);
+				reiserfsck_delete_item(&safe_link_path, 0);
+				continue;
+			}
+		} else if (get_offset(&tmp_ih->ih_key) == 0x1) {
+			/* Truncate */
+			if (!not_a_directory(get_item(&path))) {
+				/*truncate on directory should not happen */
+				/*sware on check, delete on fix-fixable */
+				if (fsck_mode(fs) == FSCK_CHECK) {
+					fsck_log
+					    ("Invalid 'truncate' safe link %k, cannot happen for "
+					     "directory (%K)\n",
+					     &tmp_ih->ih_key, &key);
+					one_more_corruption(fs, FIXABLE);
+				} else if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+					fsck_log
+					    ("Invalid 'truncate' safe link %k, cannot happen for "
+					     "a directory (%K) - safe link was deleted\n",
+					     &tmp_ih->ih_key, &key);
+					d32_put((__u32 *)
+						get_item(&safe_link_path), 0,
+						0);
+					pathrelse(&path);
+					reiserfsck_delete_item(&safe_link_path,
+							       0);
+					continue;
+				}
+			} else {
+				/* save 'safe truncate links' to avoid swaring on wrong sizes. */
+				__u32 position;
+
+				if (reiserfs_bin_search
+				    (&key, trunc_links, links_num, sizeof(key),
+				     &position,
+				     comp_short_keys) != POSITION_FOUND) {
+					blocklist__insert_in_position(&key,
+								      (void *)
+								      &trunc_links,
+								      &links_num,
+								      sizeof
+								      (key),
+								      &position);
+				}
+			}
+		}
+		pathrelse(&path);
+		pathrelse(&safe_link_path);
 	}
-	pathrelse (&path);
-	pathrelse (&safe_link_path);
-    }
 
-    return OK;
+	return OK;
 }
 
-void release_safe_links () {
-    freemem(trunc_links);
+void release_safe_links()
+{
+	freemem(trunc_links);
 }
 
 /* called when --check is given */
-void semantic_check (void)
+void semantic_check(void)
 {
-    if (fsck_data (fs)->check.bad_nodes) {
-        fsck_progress ("Bad nodes were found, Semantic pass skipped\n");
-        goto clean;
-    }
+	if (fsck_data(fs)->check.bad_nodes) {
+		fsck_progress("Bad nodes were found, Semantic pass skipped\n");
+		goto clean;
+	}
 
-    if (fsck_data (fs)->check.fatal_corruptions) {
-        fsck_progress ("Fatal corruptions were found, Semantic pass skipped\n");
-        goto clean;
-    }
- 
-    fsck_progress ("Checking Semantic tree:\n");
-
-    if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
-        /*create new_bitmap, and initialize new_bitmap & allocable bitmap*/
-        fsck_new_bitmap (fs) = reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
-        reiserfs_bitmap_copy (fsck_new_bitmap (fs), fs->fs_bitmap2);
-        fsck_allocable_bitmap (fs) = reiserfs_create_bitmap(get_sb_block_count
-	    (fs->fs_ondisk_sb));
-        reiserfs_bitmap_copy (fsck_allocable_bitmap (fs), fs->fs_bitmap2);
-	fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
-	fs->block_deallocator = reiserfsck_reiserfs_free_block;
-    }
-    
-    check_safe_links ();
-    
-    if (check_semantic_pass (&root_dir_key, &parent_root_dir_key, 0, 0) != OK) {
-        fsck_log ("check_semantic_tree: No root directory found");
-        one_more_corruption (fs, FATAL);
-    }
+	if (fsck_data(fs)->check.fatal_corruptions) {
+		fsck_progress
+		    ("Fatal corruptions were found, Semantic pass skipped\n");
+		goto clean;
+	}
+
+	fsck_progress("Checking Semantic tree:\n");
+
+	if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+		/*create new_bitmap, and initialize new_bitmap & allocable bitmap */
+		fsck_new_bitmap(fs) =
+		    reiserfs_create_bitmap(get_sb_block_count
+					   (fs->fs_ondisk_sb));
+		reiserfs_bitmap_copy(fsck_new_bitmap(fs), fs->fs_bitmap2);
+		fsck_allocable_bitmap(fs) =
+		    reiserfs_create_bitmap(get_sb_block_count
+					   (fs->fs_ondisk_sb));
+		reiserfs_bitmap_copy(fsck_allocable_bitmap(fs), fs->fs_bitmap2);
+		fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
+		fs->block_deallocator = reiserfsck_reiserfs_free_block;
+	}
+
+	check_safe_links();
+
+	if (check_semantic_pass(&root_dir_key, &parent_root_dir_key, 0, 0) !=
+	    OK) {
+		fsck_log("check_semantic_tree: No root directory found");
+		one_more_corruption(fs, FATAL);
+	}
+
+	release_safe_links();
+
+	if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
+		reiserfs_delete_bitmap(fs->fs_bitmap2);
+		reiserfs_bitmap_delta(fsck_new_bitmap(fs),
+				      fsck_deallocate_bitmap(fs));
+		fs->fs_bitmap2 = fsck_new_bitmap(fs);
+		reiserfs_delete_bitmap(fsck_allocable_bitmap(fs));
+		fsck_allocable_bitmap(fs) = NULL;
+		set_sb_free_blocks(fs->fs_ondisk_sb,
+				   reiserfs_bitmap_zeros(fs->fs_bitmap2));
+		mark_buffer_dirty(fs->fs_super_bh);
+		add_badblock_list(fs, 1);
+	}
+
+	fsck_progress("finished\n");
 
-    release_safe_links ();
-
-    if (fsck_mode(fs) == FSCK_FIX_FIXABLE) {
-        reiserfs_delete_bitmap (fs->fs_bitmap2);
-	reiserfs_bitmap_delta (fsck_new_bitmap (fs), fsck_deallocate_bitmap (fs));	
-        fs->fs_bitmap2 = fsck_new_bitmap (fs);
-        reiserfs_delete_bitmap (fsck_allocable_bitmap (fs));	
-        fsck_allocable_bitmap (fs) = NULL;
-        set_sb_free_blocks (fs->fs_ondisk_sb, reiserfs_bitmap_zeros (fs->fs_bitmap2));
-        mark_buffer_dirty (fs->fs_super_bh);
-	add_badblock_list(fs, 1);
-    }
-    
-    fsck_progress ("finished\n");
-    
 clean:
-    if (fsck_deallocate_bitmap (fs))
-	reiserfs_delete_bitmap (fsck_deallocate_bitmap (fs));
+	if (fsck_deallocate_bitmap(fs))
+		reiserfs_delete_bitmap(fsck_deallocate_bitmap(fs));
 }
diff --git a/fsck/semantic_rebuild.c b/fsck/semantic_rebuild.c
index 2ae20c0..9cb2476 100644
--- a/fsck/semantic_rebuild.c
+++ b/fsck/semantic_rebuild.c
@@ -13,146 +13,155 @@ int screen_savebuffer_len;
 #define MIN(a, b) (((a)>(b))?(b):(a))
 
 /* semantic pass progress */
-void print_name (char * name, int len)
+void print_name(char *name, int len)
 {
-    int i;
+	int i;
 
-    if (fsck_quiet (fs))
-	return;
+	if (fsck_quiet(fs))
+		return;
 
-    if ( len + screen_curr_pos + 1 > screen_savebuffer_len) {
-	char *t;
-	
-	t = expandmem(screen_savebuffer, screen_savebuffer_len + 1, 
-	    len + screen_curr_pos - screen_savebuffer_len + 1);
-	if (!t) {
-	    fsck_progress("\nOut of memory\n");
-	    return; // ????
+	if (len + screen_curr_pos + 1 > screen_savebuffer_len) {
+		char *t;
+
+		t = expandmem(screen_savebuffer, screen_savebuffer_len + 1,
+			      len + screen_curr_pos - screen_savebuffer_len +
+			      1);
+		if (!t) {
+			fsck_progress("\nOut of memory\n");
+			return;	// ????
+		}
+		screen_savebuffer = t;
+		screen_savebuffer_len = len + screen_curr_pos + 1;
 	}
-	screen_savebuffer = t;
-	screen_savebuffer_len = len + screen_curr_pos + 1;
-    }
-    strcat(screen_savebuffer,"/");
-    strncat(screen_savebuffer,name,len);
-    i = screen_curr_pos;
-    screen_curr_pos += len+1;
-    for ( ; i<screen_curr_pos; i++)
-	if ( screen_savebuffer[i] < 32 )
-	    screen_savebuffer[i] = '?';
-    screen_savebuffer[screen_curr_pos]=0;
-
-    if ( screen_width < screen_curr_pos ) {
-	printf("\r... %.*s",screen_width - 4, 
-	    screen_savebuffer + ( screen_curr_pos - (screen_width - 4)));
-    } else
-	printf("/%.*s", len, screen_savebuffer + screen_curr_pos - len);
-
-    fflush (stdout);
+	strcat(screen_savebuffer, "/");
+	strncat(screen_savebuffer, name, len);
+	i = screen_curr_pos;
+	screen_curr_pos += len + 1;
+	for (; i < screen_curr_pos; i++)
+		if (screen_savebuffer[i] < 32)
+			screen_savebuffer[i] = '?';
+	screen_savebuffer[screen_curr_pos] = 0;
+
+	if (screen_width < screen_curr_pos) {
+		printf("\r... %.*s", screen_width - 4,
+		       screen_savebuffer + (screen_curr_pos -
+					    (screen_width - 4)));
+	} else
+		printf("/%.*s", len, screen_savebuffer + screen_curr_pos - len);
+
+	fflush(stdout);
 }
 
-
-void erase_name (int len)
+void erase_name(int len)
 {
-    int i;
+	int i;
 
-    if (fsck_quiet (fs))
-	return;
+	if (fsck_quiet(fs))
+		return;
 
-    if ( screen_curr_pos < screen_width ) {
-
-	screen_curr_pos-=len+1;
-	screen_savebuffer[screen_curr_pos]=0;
-
-	for (i = 0; i<=len; i++)
-	    printf("\b");
-	for (i = 0; i<=len+1; i++)
-	    printf(" ");
-	for (i = 0; i<=len+1; i++)
-	    printf("\b");
-    } else {
-	screen_curr_pos-=len+1;
-	if (screen_curr_pos < 0 )
-	    die("%s: Get out of buffer's data!\n", __FUNCTION__);
-
-	screen_savebuffer[screen_curr_pos]=0;
-	printf("\r");
-	if (screen_curr_pos >= screen_width ) {
-	    int t_preface=MIN(screen_curr_pos-screen_width,4);
-	    printf("%.*s%.*s", t_preface, "... ", screen_width-t_preface - 1, 
-		screen_savebuffer + ( screen_curr_pos - (screen_width - t_preface)) + 1);
+	if (screen_curr_pos < screen_width) {
+
+		screen_curr_pos -= len + 1;
+		screen_savebuffer[screen_curr_pos] = 0;
+
+		for (i = 0; i <= len; i++)
+			printf("\b");
+		for (i = 0; i <= len + 1; i++)
+			printf(" ");
+		for (i = 0; i <= len + 1; i++)
+			printf("\b");
 	} else {
-	    int space_used=printf("%s", screen_savebuffer);
-	    for ( i=space_used; i < screen_width; i++)
-		printf(" ");
-	    for ( i=space_used; i < screen_width; i++)
-		printf("\b");
+		screen_curr_pos -= len + 1;
+		if (screen_curr_pos < 0)
+			die("%s: Get out of buffer's data!\n", __FUNCTION__);
+
+		screen_savebuffer[screen_curr_pos] = 0;
+		printf("\r");
+		if (screen_curr_pos >= screen_width) {
+			int t_preface = MIN(screen_curr_pos - screen_width, 4);
+			printf("%.*s%.*s", t_preface, "... ",
+			       screen_width - t_preface - 1,
+			       screen_savebuffer + (screen_curr_pos -
+						    (screen_width -
+						     t_preface)) + 1);
+		} else {
+			int space_used = printf("%s", screen_savebuffer);
+			for (i = space_used; i < screen_width; i++)
+				printf(" ");
+			for (i = space_used; i < screen_width; i++)
+				printf("\b");
+		}
 	}
-    }
-	    
-    fflush (stdout);
-}
-
 
+	fflush(stdout);
+}
 
 /* *size is "real" file size, sd_size - size from stat data */
-int wrong_st_size (struct reiserfs_key *key, unsigned long long max_file_size, 
-    int blocksize, __u64 * size, __u64 sd_size, int type)
+int wrong_st_size(struct reiserfs_key *key, unsigned long long max_file_size,
+		  int blocksize, __u64 * size, __u64 sd_size, int type)
 {
-    if (sd_size <= max_file_size) {
-	if (sd_size == *size)
-	    return 0;
-
-	if (type == TYPE_DIRENTRY) {
-	    /* directory size must match to the sum of length of its entries */
-	    fsck_log ("vpf-10650: The directory %K has the wrong size in the StatData "
-		"(%Lu)%s(%Lu)\n", key, sd_size, fsck_mode(fs) == FSCK_CHECK ? 
-		", should be " : " - corrected to ", *size);
-	    return 1;
-	}
-	
-	if (sd_size > *size) {
-	    /* size in stat data can be bigger than size calculated by items */
-	    if (fsck_adjust_file_size (fs) || type == TYPE_SYMLINK) {
-		/* but it -o is given - fix that */
-		fsck_log ("vpf-10660: The file %K has too big size in the StatData "
-		    "(%Lu)%s(%Lu)\n", key, sd_size, fsck_mode(fs) == FSCK_CHECK ? 
-		    ", should be " : " - corrected to ", *size);
-		sem_pass_stat (fs)->fixed_sizes ++;
-		return 1;
-	    }
-	    *size = sd_size;
-	    return 0;
-	}
-	
-	if (!(*size % blocksize)) {
-	    /* last item is indirect */
-	    if (((sd_size & ~(blocksize - 1)) == (*size - blocksize)) && 
-		sd_size % blocksize) 
-	    {
-		/* size in stat data is correct */
-		*size = sd_size;
-		return 0;
-	    }
-	} else {
-	    /* last item is a direct one */
-	    if (!(*size % 8)) {
-		if (((sd_size & ~7) == (*size - 8)) && sd_size % 8) {
-		    /* size in stat data is correct */
-		    *size = sd_size;
-		    return 0;
+	if (sd_size <= max_file_size) {
+		if (sd_size == *size)
+			return 0;
+
+		if (type == TYPE_DIRENTRY) {
+			/* directory size must match to the sum of length of its entries */
+			fsck_log
+			    ("vpf-10650: The directory %K has the wrong size in the StatData "
+			     "(%Lu)%s(%Lu)\n", key, sd_size,
+			     fsck_mode(fs) ==
+			     FSCK_CHECK ? ", should be " : " - corrected to ",
+			     *size);
+			return 1;
+		}
+
+		if (sd_size > *size) {
+			/* size in stat data can be bigger than size calculated by items */
+			if (fsck_adjust_file_size(fs) || type == TYPE_SYMLINK) {
+				/* but it -o is given - fix that */
+				fsck_log
+				    ("vpf-10660: The file %K has too big size in the StatData "
+				     "(%Lu)%s(%Lu)\n", key, sd_size,
+				     fsck_mode(fs) ==
+				     FSCK_CHECK ? ", should be " :
+				     " - corrected to ", *size);
+				sem_pass_stat(fs)->fixed_sizes++;
+				return 1;
+			}
+			*size = sd_size;
+			return 0;
+		}
+
+		if (!(*size % blocksize)) {
+			/* last item is indirect */
+			if (((sd_size & ~(blocksize - 1)) ==
+			     (*size - blocksize)) && sd_size % blocksize) {
+				/* size in stat data is correct */
+				*size = sd_size;
+				return 0;
+			}
+		} else {
+			/* last item is a direct one */
+			if (!(*size % 8)) {
+				if (((sd_size & ~7) == (*size - 8))
+				    && sd_size % 8) {
+					/* size in stat data is correct */
+					*size = sd_size;
+					return 0;
+				}
+			}
 		}
-	    }
 	}
-    }
 
-    fsck_log ("vpf-10670: The file %K has the wrong size in the StatData (%Lu)%s(%Lu)\n", key, 
-	sd_size, fsck_mode(fs) == FSCK_CHECK ? ", should be " : " - corrected to ", 
-	*size);
-    sem_pass_stat (fs)->fixed_sizes ++;
-    return 1;
+	fsck_log
+	    ("vpf-10670: The file %K has the wrong size in the StatData (%Lu)%s(%Lu)\n",
+	     key, sd_size,
+	     fsck_mode(fs) == FSCK_CHECK ? ", should be " : " - corrected to ",
+	     *size);
+	sem_pass_stat(fs)->fixed_sizes++;
+	return 1;
 }
 
-
 /* sd_blocks is 32 bit only */
 /* old stat data shares sd_block and sd_dev - do not wipe sd_rdev out */
 /* we should fix it as following:
@@ -166,31 +175,41 @@ int wrong_st_size (struct reiserfs_key *key, unsigned long long max_file_size,
 |   file, dir, link  |  blocks |    generation      |   blocks     |
 |------------------------------------------------------------------|
 */
-int wrong_st_blocks (struct reiserfs_key *key, __u32 * blocks, __u32 sd_blocks, __u16 mode, 
-    int new_format)
+int wrong_st_blocks(struct reiserfs_key *key, __u32 * blocks, __u32 sd_blocks,
+		    __u16 mode, int new_format)
 {
-    int ret = 0;
-
-    if (S_ISREG (mode) || S_ISLNK (mode) || S_ISDIR (mode)) {
-	if ((!S_ISLNK(mode) && *blocks != sd_blocks) ||
-	    (S_ISLNK(mode) && *blocks != sd_blocks && (ROUND_UP(*blocks) != sd_blocks))) {
-	    fsck_log ("vpf-10680: The %s %K has the wrong block count in the StatData "
-		"(%u)%s(%u)\n", S_ISDIR (mode) ? "directory" : S_ISREG (mode) ? "file" : "link",  key, sd_blocks, 
-		fsck_mode(fs) == FSCK_CHECK ? ", should be " : " - corrected to ", *blocks);
-	    ret = 1;
-	}
-    } else if (new_format || (S_ISFIFO (mode) || S_ISSOCK (mode))) {
-	if (sd_blocks != 0) {
-	    fsck_log ("vpf-10690: The object %K has the wrong block count in the StatData "
-		"(%u)%s(%u)\n",	key, sd_blocks, fsck_mode(fs) == FSCK_CHECK ? 
-		", should be " : " - corrected to ", 0);
-	    *blocks = 0;	
-	    ret = 1;
+	int ret = 0;
+
+	if (S_ISREG(mode) || S_ISLNK(mode) || S_ISDIR(mode)) {
+		if ((!S_ISLNK(mode) && *blocks != sd_blocks) ||
+		    (S_ISLNK(mode) && *blocks != sd_blocks
+		     && (ROUND_UP(*blocks) != sd_blocks))) {
+			fsck_log
+			    ("vpf-10680: The %s %K has the wrong block count in the StatData "
+			     "(%u)%s(%u)\n",
+			     S_ISDIR(mode) ? "directory" : S_ISREG(mode) ?
+			     "file" : "link", key, sd_blocks,
+			     fsck_mode(fs) ==
+			     FSCK_CHECK ? ", should be " : " - corrected to ",
+			     *blocks);
+			ret = 1;
+		}
+	} else if (new_format || (S_ISFIFO(mode) || S_ISSOCK(mode))) {
+		if (sd_blocks != 0) {
+			fsck_log
+			    ("vpf-10690: The object %K has the wrong block count in the StatData "
+			     "(%u)%s(%u)\n", key, sd_blocks,
+			     fsck_mode(fs) ==
+			     FSCK_CHECK ? ", should be " : " - corrected to ",
+			     0);
+			*blocks = 0;
+			ret = 1;
+		}
 	}
-    }
 
-    return ret;
+	return ret;
 }
+
 /*
 int wrong_st_rdev (struct reiserfs_key *key, __u32 * sd_rdev, __u16 mode, int new_format)
 {
@@ -212,593 +231,622 @@ int wrong_st_rdev (struct reiserfs_key *key, __u32 * sd_rdev, __u16 mode, int ne
 */
 /* only regular files and symlinks may have items but stat
    data. Symlink should have body */
-int wrong_mode (struct reiserfs_key *key, __u16 * mode, __u64 real_size, int symlink)
+int wrong_mode(struct reiserfs_key *key, __u16 * mode, __u64 real_size,
+	       int symlink)
 {
-    int retval = 0;
-    if (S_ISLNK (*mode) && !symlink) {
-	fsck_log ("The file %K (%M) is too big to be the symlink%s regfile\n", 
-	    key, *mode, fsck_mode(fs) == FSCK_CHECK ? ", should be the" : " - corrected "
-	    "to the");
-	*mode &= ~S_IFMT;
-	*mode |= S_IFREG;
-	retval = 1;
-    }
-
-    if (ftypelet (*mode) != '?') {
-	/* mode looks reasonable */
-	if (S_ISREG (*mode) || S_ISLNK (*mode))
-	    return retval;
-	
-	/* device, pipe, socket have no items */
-	if (!real_size)
-	    return retval;
-    }
-    /* there are items, so change file mode to regular file. Otherwise
-       - file bodies do not get deleted */
-    if (fsck_mode(fs) == FSCK_CHECK) {
-	fsck_log ("The object %K has wrong mode (%M)\n", key, *mode);
-    } else {
-	fsck_log("The object %K has wrong mode (%M) - corrected to %M\n", 
-	    key, *mode, (S_IFREG | 0600));
-    }
-    *mode = (S_IFREG | 0600);
-    return 1;
-}
+	int retval = 0;
+	if (S_ISLNK(*mode) && !symlink) {
+		fsck_log
+		    ("The file %K (%M) is too big to be the symlink%s regfile\n",
+		     key, *mode,
+		     fsck_mode(fs) ==
+		     FSCK_CHECK ? ", should be the" : " - corrected " "to the");
+		*mode &= ~S_IFMT;
+		*mode |= S_IFREG;
+		retval = 1;
+	}
 
+	if (ftypelet(*mode) != '?') {
+		/* mode looks reasonable */
+		if (S_ISREG(*mode) || S_ISLNK(*mode))
+			return retval;
 
-/* key is a key of last file item */
-int wrong_first_direct_byte (struct reiserfs_key *key, int blocksize, 
-			     __u32 * first_direct_byte,
-			     __u32 sd_first_direct_byte, __u32 size)
-{
-    if (!size || is_indirect_key (key)) {
-	/* there is no direct item */
-	*first_direct_byte = NO_BYTES_IN_DIRECT_ITEM;
-	if (sd_first_direct_byte != NO_BYTES_IN_DIRECT_ITEM) {
-	    if (fsck_mode(fs) == FSCK_CHECK) {
-		fsck_log ("The file %K: The wrong info about the tail in the StatData, "
-		    "first_direct_byte (%d) - should be (%d)\n", key, 
-		    sd_first_direct_byte, *first_direct_byte);
-	    } else {
-		fsck_log ("The file %K: The wrong info about the tail in the StatData, "
-		    "first_direct_byte (%d) - corrected to (%d)\n", key, 
-		    sd_first_direct_byte, *first_direct_byte);
-	    }
-	    return 1;
+		/* device, pipe, socket have no items */
+		if (!real_size)
+			return retval;
 	}
-	return 0;
-    }
-
-    /* there is direct item */
-    *first_direct_byte = (get_offset (key) & ~(blocksize - 1)) + 1;
-    if (*first_direct_byte != sd_first_direct_byte) {
+	/* there are items, so change file mode to regular file. Otherwise
+	   - file bodies do not get deleted */
 	if (fsck_mode(fs) == FSCK_CHECK) {
-	    fsck_log ("The file %K: The wrong info about the tail in the StatData, "
-		"first_direct_byte (%d) - should be (%d)\n", key, sd_first_direct_byte, 
-		*first_direct_byte);
+		fsck_log("The object %K has wrong mode (%M)\n", key, *mode);
 	} else {
-	    fsck_log ("The file %K: The wrong info about the tail in the StatData, "
-		"first_direct_byte (%d) - corrected to (%d)\n", key, sd_first_direct_byte, 
-		*first_direct_byte);
+		fsck_log
+		    ("The object %K has wrong mode (%M) - corrected to %M\n",
+		     key, *mode, (S_IFREG | 0600));
 	}
-	    
+	*mode = (S_IFREG | 0600);
 	return 1;
-    }
-    return 0;
 }
 
-
-/* delete all items (but directory ones) with the same key 'ih' has
-   (including stat data of not a directory) and put them back at the
-   other place */
-void relocate_dir (struct item_head * ih, int change_ih)
+/* key is a key of last file item */
+int wrong_first_direct_byte(struct reiserfs_key *key, int blocksize,
+			    __u32 * first_direct_byte,
+			    __u32 sd_first_direct_byte, __u32 size)
 {
-    struct reiserfs_key key;
-    struct reiserfs_key *rkey;
-    struct reiserfs_path path;
-    struct item_head * path_ih;
-    struct si * si;
-    __u32 new_objectid;
-
-    /* starting with the leftmost one - look for all items of file,
-       store them and delete */
-    key = ih->ih_key;
-    set_type_and_offset (KEY_FORMAT_1, &key, SD_OFFSET, TYPE_STAT_DATA);
-
-    si = 0;
-    while (1) {
-	reiserfs_search_by_key_4 (fs, &key, &path);
-	
-	if (get_item_pos (&path) == B_NR_ITEMS (get_bh (&path))) {
-	    rkey = uget_rkey (&path);
-	    if (rkey && !not_of_one_file (&key, rkey)) {
-		/* file continues in the right neighbor */
-		key = *rkey;
-		pathrelse (&path);
-		continue;
-	    }
-	    /* there is no more items of a directory */
-	    pathrelse (&path);
-	    break;
+	if (!size || is_indirect_key(key)) {
+		/* there is no direct item */
+		*first_direct_byte = NO_BYTES_IN_DIRECT_ITEM;
+		if (sd_first_direct_byte != NO_BYTES_IN_DIRECT_ITEM) {
+			if (fsck_mode(fs) == FSCK_CHECK) {
+				fsck_log
+				    ("The file %K: The wrong info about the tail in the StatData, "
+				     "first_direct_byte (%d) - should be (%d)\n",
+				     key, sd_first_direct_byte,
+				     *first_direct_byte);
+			} else {
+				fsck_log
+				    ("The file %K: The wrong info about the tail in the StatData, "
+				     "first_direct_byte (%d) - corrected to (%d)\n",
+				     key, sd_first_direct_byte,
+				     *first_direct_byte);
+			}
+			return 1;
+		}
+		return 0;
 	}
 
-	if (is_stat_data_ih (get_ih(&path)))
-	    fix_obviously_wrong_sd_mode (&path);
-	
-	path_ih = get_ih (&path);
-	if (not_of_one_file (&key, &(path_ih->ih_key))) {
-	    /* there are no more item with this key */
-	    pathrelse (&path);
-	    break;
-	}
+	/* there is direct item */
+	*first_direct_byte = (get_offset(key) & ~(blocksize - 1)) + 1;
+	if (*first_direct_byte != sd_first_direct_byte) {
+		if (fsck_mode(fs) == FSCK_CHECK) {
+			fsck_log
+			    ("The file %K: The wrong info about the tail in the StatData, "
+			     "first_direct_byte (%d) - should be (%d)\n", key,
+			     sd_first_direct_byte, *first_direct_byte);
+		} else {
+			fsck_log
+			    ("The file %K: The wrong info about the tail in the StatData, "
+			     "first_direct_byte (%d) - corrected to (%d)\n",
+			     key, sd_first_direct_byte, *first_direct_byte);
+		}
 
-	/* ok, item found, but make sure that it is not a directory one */
-	if ((is_stat_data_ih (path_ih) && not_a_directory (get_item (&path))) ||
-	    is_direct_ih (path_ih) || is_indirect_ih (path_ih)) {
-	    /* item of not a directory found. Leave it in the
-               tree. FIXME: should not happen */
-	    key = path_ih->ih_key;
-	    set_offset (KEY_FORMAT_1, &key, get_offset (&key) + 1);
-	    pathrelse (&path);
-	    continue;
+		return 1;
 	}
+	return 0;
+}
 
-	/* directory stat data ro directory item */
-	si = save_and_delete_file_item (si, &path);
-    }
+/* delete all items (but directory ones) with the same key 'ih' has
+   (including stat data of not a directory) and put them back at the
+   other place */
+void relocate_dir(struct item_head *ih, int change_ih)
+{
+	struct reiserfs_key key;
+	struct reiserfs_key *rkey;
+	struct reiserfs_path path;
+	struct item_head *path_ih;
+	struct si *si;
+	__u32 new_objectid;
+
+	/* starting with the leftmost one - look for all items of file,
+	   store them and delete */
+	key = ih->ih_key;
+	set_type_and_offset(KEY_FORMAT_1, &key, SD_OFFSET, TYPE_STAT_DATA);
+
+	si = 0;
+	while (1) {
+		reiserfs_search_by_key_4(fs, &key, &path);
+
+		if (get_item_pos(&path) == B_NR_ITEMS(get_bh(&path))) {
+			rkey = uget_rkey(&path);
+			if (rkey && !not_of_one_file(&key, rkey)) {
+				/* file continues in the right neighbor */
+				key = *rkey;
+				pathrelse(&path);
+				continue;
+			}
+			/* there is no more items of a directory */
+			pathrelse(&path);
+			break;
+		}
 
+		if (is_stat_data_ih(get_ih(&path)))
+			fix_obviously_wrong_sd_mode(&path);
 
-    if (!si) {
-	fsck_log ("relocate_dir: WARNING: No one item of the directory %K found\n", &key);
-	return;
-    }
+		path_ih = get_ih(&path);
+		if (not_of_one_file(&key, &(path_ih->ih_key))) {
+			/* there are no more item with this key */
+			pathrelse(&path);
+			break;
+		}
 
+		/* ok, item found, but make sure that it is not a directory one */
+		if ((is_stat_data_ih(path_ih)
+		     && not_a_directory(get_item(&path)))
+		    || is_direct_ih(path_ih) || is_indirect_ih(path_ih)) {
+			/* item of not a directory found. Leave it in the
+			   tree. FIXME: should not happen */
+			key = path_ih->ih_key;
+			set_offset(KEY_FORMAT_1, &key, get_offset(&key) + 1);
+			pathrelse(&path);
+			continue;
+		}
 
-    /* get new objectid for relocation or get objectid with which file
-       was relocated already */
-    new_objectid = objectid_for_relocation (&ih->ih_key);
-    set_key_objectid (&ih->ih_key, new_objectid);
+		/* directory stat data ro directory item */
+		si = save_and_delete_file_item(si, &path);
+	}
 
-    /* put all items removed back into tree */
-    while (si) {
-	fsck_log ("relocate_dir: Moving %k to ", &si->si_ih.ih_key);	
-	set_key_objectid (&si->si_ih.ih_key, new_objectid);
-	fsck_log ("%k\n", &si->si_ih.ih_key);
-	if (get_offset (&(si->si_ih.ih_key)) == DOT_OFFSET) {
-	    /* fix "." entry to point to a directtory properly */
-	    struct reiserfs_de_head * deh;
+	if (!si) {
+		fsck_log
+		    ("relocate_dir: WARNING: No one item of the directory %K found\n",
+		     &key);
+		return;
+	}
 
-	    deh = (struct reiserfs_de_head *)si->si_dnm_data;
-	    set_deh_objectid (deh, new_objectid);
+	/* get new objectid for relocation or get objectid with which file
+	   was relocated already */
+	new_objectid = objectid_for_relocation(&ih->ih_key);
+	set_key_objectid(&ih->ih_key, new_objectid);
+
+	/* put all items removed back into tree */
+	while (si) {
+		fsck_log("relocate_dir: Moving %k to ", &si->si_ih.ih_key);
+		set_key_objectid(&si->si_ih.ih_key, new_objectid);
+		fsck_log("%k\n", &si->si_ih.ih_key);
+		if (get_offset(&(si->si_ih.ih_key)) == DOT_OFFSET) {
+			/* fix "." entry to point to a directtory properly */
+			struct reiserfs_de_head *deh;
+
+			deh = (struct reiserfs_de_head *)si->si_dnm_data;
+			set_deh_objectid(deh, new_objectid);
+		}
+		insert_item_separately(&(si->si_ih), si->si_dnm_data,
+				       1 /*was in tree */ );
+		si = remove_saved_item(si);
 	}
-	insert_item_separately (&(si->si_ih), si->si_dnm_data, 1/*was in tree*/);
-	si = remove_saved_item (si);
-    }
 }
 
-
-
 /* path is path to stat data. If file will be relocated - new_ih will contain
    a key file was relocated with */
-int rebuild_check_regular_file (struct reiserfs_path *path, void * sd,
-				struct item_head * new_ih)
+int rebuild_check_regular_file(struct reiserfs_path *path, void *sd,
+			       struct item_head *new_ih)
 {
-    int is_new_file;
+	int is_new_file;
 //    struct reiserfs_key sd_key;
-    __u16 mode;
-    __u32 nlink;
-    __u64 real_size, saved_size;
-    __u32 blocks, saved_blocks;	/* proper values and value in stat data */
-    __u32 first_direct_byte, saved_first_direct_byte;
-
-    struct buffer_head * bh;
-    struct item_head * ih, sd_ih;
-    int fix_sd;
-    int symlnk = 0;
-    int retval;
-
-    retval = OK;
-
-    /* stat data of a file */
-    ih = get_ih (path);
-    bh = get_bh (path);
-
-    if (new_ih) {
-	/* this objectid is used already */
-	*new_ih = *ih;
-	pathrelse (path);
-	rewrite_file (new_ih, 1, 1);
-	linked_already(&new_ih->ih_key);
-	sem_pass_stat (fs)->oid_sharing_files_relocated ++;
-	retval = RELOCATED;
-	if (reiserfs_search_by_key_4 (fs, &(new_ih->ih_key), path) == ITEM_NOT_FOUND)
-	    reiserfs_panic ("%s: Could not find the StatData of the relocated file %k", 
-		__FUNCTION__, &(new_ih->ih_key));
-	/* stat data is marked unreachable again due to relocation, fix that */
-	ih = get_ih (path);
-	bh = get_bh (path);
-	mark_item_reachable (ih, bh);
-	sd = get_item (path);
-	
-    }
-	
-    id_map_mark(semantic_id_map(fs), get_key_objectid (&ih->ih_key));
+	__u16 mode;
+	__u32 nlink;
+	__u64 real_size, saved_size;
+	__u32 blocks, saved_blocks;	/* proper values and value in stat data */
+	__u32 first_direct_byte, saved_first_direct_byte;
+
+	struct buffer_head *bh;
+	struct item_head *ih, sd_ih;
+	int fix_sd;
+	int symlnk = 0;
+	int retval;
+
+	retval = OK;
+
+	/* stat data of a file */
+	ih = get_ih(path);
+	bh = get_bh(path);
+
+	if (new_ih) {
+		/* this objectid is used already */
+		*new_ih = *ih;
+		pathrelse(path);
+		rewrite_file(new_ih, 1, 1);
+		linked_already(&new_ih->ih_key);
+		sem_pass_stat(fs)->oid_sharing_files_relocated++;
+		retval = RELOCATED;
+		if (reiserfs_search_by_key_4(fs, &(new_ih->ih_key), path) ==
+		    ITEM_NOT_FOUND)
+			reiserfs_panic
+			    ("%s: Could not find the StatData of the relocated file %k",
+			     __FUNCTION__, &(new_ih->ih_key));
+		/* stat data is marked unreachable again due to relocation, fix that */
+		ih = get_ih(path);
+		bh = get_bh(path);
+		mark_item_reachable(ih, bh);
+		sd = get_item(path);
 
-    /* check and set nlink first */
-    get_sd_nlink (ih, sd, &nlink);
-    nlink ++;
-    set_sd_nlink (ih, sd, &nlink);
-    mark_buffer_dirty (bh);
+	}
 
-    if (nlink > 1)
-	return retval;
+	id_map_mark(semantic_id_map(fs), get_key_objectid(&ih->ih_key));
 
-    /* firts name of a file found */
-    if (get_ih_item_len (ih) == SD_SIZE)
-	is_new_file = 1;
-    else
-	is_new_file = 0;
-
-    get_sd_mode (ih, sd, &mode);
-    get_sd_size (ih, sd, &saved_size);
-    get_sd_blocks (ih, sd, &saved_blocks);
-    if (!is_new_file)
-	get_sd_first_direct_byte (ih, sd, &saved_first_direct_byte);
-    
-    /* we met this file first time */
-    if (S_ISREG (mode)) {
-	sem_pass_stat(fs)->regular_files ++;
-    } else if (S_ISLNK (mode)) {
-	symlnk = 1;
-	sem_pass_stat (fs)->symlinks ++;
-    } else {
-	sem_pass_stat (fs)->others ++;
-    }
+	/* check and set nlink first */
+	get_sd_nlink(ih, sd, &nlink);
+	nlink++;
+	set_sd_nlink(ih, sd, &nlink);
+	mark_buffer_dirty(bh);
+
+	if (nlink > 1)
+		return retval;
 
+	/* firts name of a file found */
+	if (get_ih_item_len(ih) == SD_SIZE)
+		is_new_file = 1;
+	else
+		is_new_file = 0;
 
-    sd_ih = *ih;
+	get_sd_mode(ih, sd, &mode);
+	get_sd_size(ih, sd, &saved_size);
+	get_sd_blocks(ih, sd, &saved_blocks);
+	if (!is_new_file)
+		get_sd_first_direct_byte(ih, sd, &saved_first_direct_byte);
+
+	/* we met this file first time */
+	if (S_ISREG(mode)) {
+		sem_pass_stat(fs)->regular_files++;
+	} else if (S_ISLNK(mode)) {
+		symlnk = 1;
+		sem_pass_stat(fs)->symlinks++;
+	} else {
+		sem_pass_stat(fs)->others++;
+	}
+
+	sd_ih = *ih;
 //    sd_key = sd_ih.ih_key;
-    pathrelse (path);
-    
-    if (are_file_items_correct (&sd_ih, sd, &real_size, &blocks, 1/*mark items reachable*/, 
-	&symlnk) != 1) 
-    {
-	/* unpassed items will be deleted in pass 4 as they left unaccessed */
-	sem_pass_stat (fs)->broken_files ++;
-    }
-    
-    fix_sd = 0;
-    
-    fix_sd += wrong_mode (/*&sd_key, */ &sd_ih.ih_key, &mode, real_size, symlnk);
-
-    if (!is_new_file)
-	fix_sd += wrong_first_direct_byte (&sd_ih.ih_key, fs->fs_blocksize,
-	    &first_direct_byte, saved_first_direct_byte, real_size);
-
-    fix_sd += wrong_st_size (/*&sd_key,*/ &sd_ih.ih_key, 
-	is_new_file ? MAX_FILE_SIZE_V2 : MAX_FILE_SIZE_V1,
-	fs->fs_blocksize, &real_size, saved_size, symlnk ? TYPE_SYMLINK : 0);
-
-    fix_sd += wrong_st_blocks (&sd_ih.ih_key, &blocks, saved_blocks, mode, is_new_file);
-
-    if (fix_sd) {
-	/* find stat data and correct it */
-	set_type_and_offset (KEY_FORMAT_1, &sd_ih.ih_key, SD_OFFSET, TYPE_STAT_DATA);
-	if (reiserfs_search_by_key_4 (fs, &sd_ih.ih_key, path) != ITEM_FOUND)
-	    reiserfs_panic ("%s: The StatData of the file %k could not be found", 
-		__FUNCTION__, &sd_ih.ih_key);
-	
-	bh = get_bh (path);
-	ih = get_ih (path);
-	sd = get_item (path);
-	set_sd_size (ih, sd, &real_size);
-	set_sd_blocks (ih, sd, &blocks);
-	set_sd_mode (ih, sd, &mode);
+	pathrelse(path);
+
+	if (are_file_items_correct
+	    (&sd_ih, sd, &real_size, &blocks, 1 /*mark items reachable */ ,
+	     &symlnk) != 1) {
+		/* unpassed items will be deleted in pass 4 as they left unaccessed */
+		sem_pass_stat(fs)->broken_files++;
+	}
+
+	fix_sd = 0;
+
+	fix_sd +=
+	    wrong_mode( /*&sd_key, */ &sd_ih.ih_key, &mode, real_size, symlnk);
+
 	if (!is_new_file)
-	    set_sd_first_direct_byte (ih, sd, &first_direct_byte);
-	mark_buffer_dirty (bh);
-    }
+		fix_sd +=
+		    wrong_first_direct_byte(&sd_ih.ih_key, fs->fs_blocksize,
+					    &first_direct_byte,
+					    saved_first_direct_byte, real_size);
+
+	fix_sd += wrong_st_size( /*&sd_key, */ &sd_ih.ih_key,
+				is_new_file ? MAX_FILE_SIZE_V2 :
+				MAX_FILE_SIZE_V1, fs->fs_blocksize, &real_size,
+				saved_size, symlnk ? TYPE_SYMLINK : 0);
+
+	fix_sd +=
+	    wrong_st_blocks(&sd_ih.ih_key, &blocks, saved_blocks, mode,
+			    is_new_file);
+
+	if (fix_sd) {
+		/* find stat data and correct it */
+		set_type_and_offset(KEY_FORMAT_1, &sd_ih.ih_key, SD_OFFSET,
+				    TYPE_STAT_DATA);
+		if (reiserfs_search_by_key_4(fs, &sd_ih.ih_key, path) !=
+		    ITEM_FOUND)
+			reiserfs_panic
+			    ("%s: The StatData of the file %k could not be found",
+			     __FUNCTION__, &sd_ih.ih_key);
+
+		bh = get_bh(path);
+		ih = get_ih(path);
+		sd = get_item(path);
+		set_sd_size(ih, sd, &real_size);
+		set_sd_blocks(ih, sd, &blocks);
+		set_sd_mode(ih, sd, &mode);
+		if (!is_new_file)
+			set_sd_first_direct_byte(ih, sd, &first_direct_byte);
+		mark_buffer_dirty(bh);
+	}
 
-    return retval;
+	return retval;
 }
 
-
-static int is_rootdir_key (struct reiserfs_key *key)
+static int is_rootdir_key(struct reiserfs_key *key)
 {
-    if (comp_keys (key, &root_dir_key))
-	return 0;
-    return 1;
+	if (comp_keys(key, &root_dir_key))
+		return 0;
+	return 1;
 }
 
-
 /* returns buffer, containing found directory item.*/
-static char * get_next_directory_item (struct reiserfs_key *key, /* on return this will
-						     contain key of next item
-						     in the tree */
-				struct reiserfs_key *parent,
-				struct item_head * ih,/*not in tree*/
-				__u32 * pos_in_item)
+static char *get_next_directory_item(struct reiserfs_key *key,	/* on return this will
+								   contain key of next item
+								   in the tree */
+				     struct reiserfs_key *parent, struct item_head *ih,	/*not in tree */
+				     __u32 * pos_in_item)
 {
-    INITIALIZE_REISERFS_PATH(path);
-    char * dir_item;
-    struct reiserfs_key *rdkey;
-    struct buffer_head * bh;
-    struct reiserfs_de_head * deh;
-    int i;
-    int retval;
-
-
-    if ((retval = reiserfs_search_by_entry_key (fs, key, &path)) != POSITION_FOUND)
-	reiserfs_panic ("get_next_directory_item: The current directory %k cannot be "
-	    "found", key);
-
-    /* leaf containing directory item */
-    bh = PATH_PLAST_BUFFER (&path);
-    *pos_in_item = path.pos_in_item;
-    *ih = *get_ih (&path);
-    deh = B_I_DEH (bh, ih);
-
-    /* make sure, that ".." exists as well */
-    if (get_offset (key) == DOT_OFFSET) {
-	if (get_ih_entry_count (ih) < 2 ||
-	    name_in_entry_length (ih, deh + 1, 1) != 2 ||
-	    strncmp (name_in_entry (deh + 1, 1), "..", 2))
-	{
-	    fsck_log ("get_next_directory_item: The entry \"..\" cannot be found in %k\n", &ih->ih_key);
-	    pathrelse (&path);
-	    return 0;
+	INITIALIZE_REISERFS_PATH(path);
+	char *dir_item;
+	struct reiserfs_key *rdkey;
+	struct buffer_head *bh;
+	struct reiserfs_de_head *deh;
+	int i;
+	int retval;
+
+	if ((retval =
+	     reiserfs_search_by_entry_key(fs, key, &path)) != POSITION_FOUND)
+		reiserfs_panic
+		    ("get_next_directory_item: The current directory %k cannot be "
+		     "found", key);
+
+	/* leaf containing directory item */
+	bh = PATH_PLAST_BUFFER(&path);
+	*pos_in_item = path.pos_in_item;
+	*ih = *get_ih(&path);
+	deh = B_I_DEH(bh, ih);
+
+	/* make sure, that ".." exists as well */
+	if (get_offset(key) == DOT_OFFSET) {
+		if (get_ih_entry_count(ih) < 2 ||
+		    name_in_entry_length(ih, deh + 1, 1) != 2 ||
+		    strncmp(name_in_entry(deh + 1, 1), "..", 2)) {
+			fsck_log
+			    ("get_next_directory_item: The entry \"..\" cannot be found in %k\n",
+			     &ih->ih_key);
+			pathrelse(&path);
+			return 0;
+		}
 	}
-    }
 
-    /* mark hidden entries as visible, set "." and ".." correctly */
-    deh += *pos_in_item; 
-    for (i = *pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
-	int namelen;
-	char * name;
-
-	name = name_in_entry (deh, i);
-	namelen = name_in_entry_length (ih, deh, i);
-	if (de_hidden (deh))
-	    reiserfs_panic ("get_next_directory_item: item %k: hidden entry %d \'%.*s\'\n",
-			    key, i, namelen, name);
-
-	if (get_deh_offset (deh) == DOT_OFFSET) {
-	    if (not_of_one_file (&(deh->deh2_dir_id), key)) {
-		/* "." must point to the directory it is in */
-		
-		//deh->deh_objectid != REISERFS_ROOT_PARENT_OBJECTID)/*????*/ {
-		fsck_log ("get_next_directory_item: The entry \".\" of the directory %K pointes to %K, instead of %K", 
-		    key, (struct reiserfs_key *)(&(deh->deh2_dir_id)), key);
-		set_deh_dirid (deh, get_key_dirid (key));
-		set_deh_objectid (deh, get_key_objectid (key));
-		mark_buffer_dirty (bh);
-		fsck_log (" - corrected\n");
-	    }
-	}
+	/* mark hidden entries as visible, set "." and ".." correctly */
+	deh += *pos_in_item;
+	for (i = *pos_in_item; i < get_ih_entry_count(ih); i++, deh++) {
+		int namelen;
+		char *name;
+
+		name = name_in_entry(deh, i);
+		namelen = name_in_entry_length(ih, deh, i);
+		if (de_hidden(deh))
+			reiserfs_panic
+			    ("get_next_directory_item: item %k: hidden entry %d \'%.*s\'\n",
+			     key, i, namelen, name);
+
+		if (get_deh_offset(deh) == DOT_OFFSET) {
+			if (not_of_one_file(&(deh->deh2_dir_id), key)) {
+				/* "." must point to the directory it is in */
+
+				//deh->deh_objectid != REISERFS_ROOT_PARENT_OBJECTID)/*????*/ {
+				fsck_log
+				    ("get_next_directory_item: The entry \".\" of the directory %K pointes to %K, instead of %K",
+				     key,
+				     (struct reiserfs_key
+				      *)(&(deh->deh2_dir_id)), key);
+				set_deh_dirid(deh, get_key_dirid(key));
+				set_deh_objectid(deh, get_key_objectid(key));
+				mark_buffer_dirty(bh);
+				fsck_log(" - corrected\n");
+			}
+		}
 
-	if (get_deh_offset (deh) == DOT_DOT_OFFSET) {
-	    /* set ".." so that it points to the correct parent directory */
-	    if (comp_short_keys (&(deh->deh2_dir_id), parent)) {
-		fsck_log ("get_next_directory_item: The entry \"..\" of the directory %K pointes to %K, instead of %K", 
-		    key, (struct reiserfs_key *)(&(deh->deh2_dir_id)), parent);
-		set_deh_dirid (deh, get_key_dirid (parent));
-		set_deh_objectid (deh, get_key_objectid (parent));
-		mark_buffer_dirty (bh);
-		fsck_log (" - corrected\n");
-	    }
+		if (get_deh_offset(deh) == DOT_DOT_OFFSET) {
+			/* set ".." so that it points to the correct parent directory */
+			if (comp_short_keys(&(deh->deh2_dir_id), parent)) {
+				fsck_log
+				    ("get_next_directory_item: The entry \"..\" of the directory %K pointes to %K, instead of %K",
+				     key,
+				     (struct reiserfs_key
+				      *)(&(deh->deh2_dir_id)), parent);
+				set_deh_dirid(deh, get_key_dirid(parent));
+				set_deh_objectid(deh, get_key_objectid(parent));
+				mark_buffer_dirty(bh);
+				fsck_log(" - corrected\n");
+			}
+		}
 	}
-    }
-
-    /* copy directory item to the temporary buffer */
-    dir_item = getmem (get_ih_item_len (ih)); 
-    memcpy (dir_item, B_I_PITEM (bh, ih), get_ih_item_len (ih));
-
 
-    /* next item key */
-    if (PATH_LAST_POSITION (&path) == (B_NR_ITEMS (bh) - 1) &&
-	(rdkey = uget_rkey (&path)))
-	copy_key (key, rdkey);
-    else {
-	set_key_dirid (key, 0);
-	set_key_objectid (key, 0);
-    }
+	/* copy directory item to the temporary buffer */
+	dir_item = getmem(get_ih_item_len(ih));
+	memcpy(dir_item, B_I_PITEM(bh, ih), get_ih_item_len(ih));
+
+	/* next item key */
+	if (PATH_LAST_POSITION(&path) == (B_NR_ITEMS(bh) - 1) &&
+	    (rdkey = uget_rkey(&path)))
+		copy_key(key, rdkey);
+	else {
+		set_key_dirid(key, 0);
+		set_key_objectid(key, 0);
+	}
 
-    if (fsck_mode (fs) == FSCK_REBUILD)
-        mark_item_reachable (get_ih (&path), bh);
-    pathrelse (&path);
+	if (fsck_mode(fs) == FSCK_REBUILD)
+		mark_item_reachable(get_ih(&path), bh);
+	pathrelse(&path);
 
-    return dir_item;
+	return dir_item;
 }
 
-
 // get key of an object pointed by direntry and the key of the entry itself
-void get_object_key (struct reiserfs_de_head * deh, struct reiserfs_key *key, 
-		     struct reiserfs_key *entry_key, struct item_head * ih)
+void get_object_key(struct reiserfs_de_head *deh, struct reiserfs_key *key,
+		    struct reiserfs_key *entry_key, struct item_head *ih)
 {
-    /* entry points to this key */
-    set_key_dirid (key, get_deh_dirid (deh));
-    set_key_objectid (key, get_deh_objectid (deh));
-    set_key_offset_v1 (key, SD_OFFSET);
-    set_key_uniqueness (key, 0);
-
-    /* key of entry */
-    set_key_dirid (entry_key, get_key_dirid (&ih->ih_key));
-    set_key_objectid (entry_key, get_key_objectid (&ih->ih_key));
-    set_key_offset_v1 (entry_key, get_deh_offset (deh));
-    set_key_uniqueness (entry_key, DIRENTRY_UNIQUENESS);
+	/* entry points to this key */
+	set_key_dirid(key, get_deh_dirid(deh));
+	set_key_objectid(key, get_deh_objectid(deh));
+	set_key_offset_v1(key, SD_OFFSET);
+	set_key_uniqueness(key, 0);
+
+	/* key of entry */
+	set_key_dirid(entry_key, get_key_dirid(&ih->ih_key));
+	set_key_objectid(entry_key, get_key_objectid(&ih->ih_key));
+	set_key_offset_v1(entry_key, get_deh_offset(deh));
+	set_key_uniqueness(entry_key, DIRENTRY_UNIQUENESS);
 }
 
-int fix_obviously_wrong_sd_mode (struct reiserfs_path *path) {
-    struct reiserfs_key *next_key = NULL;
-    __u16 mode;
-    int retval = 0;
+int fix_obviously_wrong_sd_mode(struct reiserfs_path *path)
+{
+	struct reiserfs_key *next_key = NULL;
+	__u16 mode;
+	int retval = 0;
 
-    next_key = reiserfs_next_key (path);
+	next_key = reiserfs_next_key(path);
 
-    if (!next_key || not_of_one_file (next_key, &get_ih(path)->ih_key))
-    	return 0;
-    	
-    /* next item exists and of the same file. Fix the SD mode */
+	if (!next_key || not_of_one_file(next_key, &get_ih(path)->ih_key))
+		return 0;
 
-    if (not_a_directory (get_item (path)) && is_direntry_key (next_key)) {
-        /* make SD mode SD of dir */
-	get_sd_mode (get_ih (path), get_item (path), &mode);
-	fsck_log ("The directory %K had wrong mode %M", &get_ih(path)->ih_key, mode);
+	/* next item exists and of the same file. Fix the SD mode */
+
+	if (not_a_directory(get_item(path)) && is_direntry_key(next_key)) {
+		/* make SD mode SD of dir */
+		get_sd_mode(get_ih(path), get_item(path), &mode);
+		fsck_log("The directory %K had wrong mode %M",
+			 &get_ih(path)->ih_key, mode);
+
+		if (fsck_mode(fs) != FSCK_CHECK) {
+			mode &= ~S_IFMT;
+			mode |= S_IFDIR;
+			fsck_log(" - corrected to %M\n", mode);
+			set_sd_mode(get_ih(path), get_item(path), &mode);
+			mark_buffer_dirty(get_bh(path));
+		} else {
+			fsck_log("\n");
+			retval = 1;
+		}
+	} else if (!not_a_directory(get_item(path))
+		   && !is_direntry_key(next_key)) {
+		/* make SD mode SD of regular file */
+		get_sd_mode(get_ih(path), get_item(path), &mode);
+		fsck_log("The file %K had wrong mode %M", &get_ih(path)->ih_key,
+			 mode);
+		if (fsck_mode(fs) != FSCK_CHECK) {
+			mode &= ~S_IFMT;
+			mode |= S_IFREG;
+			fsck_log(" - corrected to %M\n", mode);
+			set_sd_mode(get_ih(path), get_item(path), &mode);
+			mark_buffer_dirty(get_bh(path));
+		} else {
+			fsck_log("\n");
+			retval = 1;
+		}
 
-	if (fsck_mode(fs) != FSCK_CHECK) {
-	    mode &= ~S_IFMT;
-	    mode |= S_IFDIR;
-	    fsck_log (" - corrected to %M\n", mode);	
-	    set_sd_mode (get_ih (path), get_item (path), &mode);
-	    mark_buffer_dirty (get_bh(path));
-	} else {
-	    fsck_log ("\n");
-	    retval = 1;
-	}
-    } else if (!not_a_directory (get_item (path)) && !is_direntry_key (next_key)) {
-        /* make SD mode SD of regular file */
-	get_sd_mode (get_ih (path), get_item (path), &mode);
-	fsck_log ("The file %K had wrong mode %M", &get_ih(path)->ih_key, mode);
-	if (fsck_mode(fs) != FSCK_CHECK) {
-	    mode &= ~S_IFMT;
-	    mode |= S_IFREG;
-	    fsck_log (" - corrected to %M\n", mode);
-	    set_sd_mode (get_ih (path), get_item (path), &mode);
-	    mark_buffer_dirty (get_bh(path));
-	} else {
-	    fsck_log ("\n");
-	    retval = 1;
 	}
-	    
-    }
 
-    return retval;
+	return retval;
 }
 
 /* check recursively the semantic tree. Returns OK if entry points to good
    object, STAT_DATA_NOT_FOUND if stat data was not found or RELOCATED when
    file was relocated because its objectid was already marked as used by
    another file */
-int rebuild_semantic_pass (struct reiserfs_key *key, struct reiserfs_key *parent, int dot_dot,
-			   struct item_head * new_ih)
+int rebuild_semantic_pass(struct reiserfs_key *key, struct reiserfs_key *parent,
+			  int dot_dot, struct item_head *new_ih)
 {
-    struct reiserfs_path path;
-    void * sd;
-    int is_new_dir;
-    __u32 nlink;
-    struct buffer_head * bh;
-    struct item_head * ih;
-    int retval, retval1;
-    char * dir_item;
-    __u32 pos_in_item;
-    struct item_head tmp_ih;
-    struct reiserfs_key item_key, entry_key, object_key;
-    __u64 dir_size;
-    __u32 blocks;
-    __u64 saved_size;
-    __u32 saved_blocks;
-    int fix_sd;
-    int relocate;
-    int dir_format = 0;
-    __u16 mode;
-
-
-    retval = OK;
-
- start_again: /* when directory was relocated */
-
-    if (!KEY_IS_STAT_DATA_KEY (key))
-	reiserfs_panic ("rebuild_semantic_pass: The key %k must be key of a StatData", key);
-
-    /* look for stat data of an object */
-    if (reiserfs_search_by_key_4 (fs, key, &path) == ITEM_NOT_FOUND) {
-	pathrelse (&path);
-	if (is_rootdir_key (key))
-	    /* root directory has to exist at this point */
-	    reiserfs_panic ("rebuild_semantic_pass: The root directory StatData was not found");
-
-	return STAT_DATA_NOT_FOUND;
-    }
-
-
-    /* stat data has been found */
-    bh = get_bh (&path);
-    ih = get_ih (&path);
-    sd = get_item(&path);
-
-    /* */
-    get_sd_nlink (ih, sd, &nlink);
+	struct reiserfs_path path;
+	void *sd;
+	int is_new_dir;
+	__u32 nlink;
+	struct buffer_head *bh;
+	struct item_head *ih;
+	int retval, retval1;
+	char *dir_item;
+	__u32 pos_in_item;
+	struct item_head tmp_ih;
+	struct reiserfs_key item_key, entry_key, object_key;
+	__u64 dir_size;
+	__u32 blocks;
+	__u64 saved_size;
+	__u32 saved_blocks;
+	int fix_sd;
+	int relocate;
+	int dir_format = 0;
+	__u16 mode;
+
+	retval = OK;
+
+start_again:			/* when directory was relocated */
+
+	if (!KEY_IS_STAT_DATA_KEY(key))
+		reiserfs_panic
+		    ("rebuild_semantic_pass: The key %k must be key of a StatData",
+		     key);
+
+	/* look for stat data of an object */
+	if (reiserfs_search_by_key_4(fs, key, &path) == ITEM_NOT_FOUND) {
+		pathrelse(&path);
+		if (is_rootdir_key(key))
+			/* root directory has to exist at this point */
+			reiserfs_panic
+			    ("rebuild_semantic_pass: The root directory StatData was not found");
+
+		return STAT_DATA_NOT_FOUND;
+	}
 
-    relocate = 0;
-    if (!nlink) {
-	/* we reached the stat data for the first time */
-	if (id_map_mark(semantic_id_map(fs), get_key_objectid (&ih->ih_key))) {
-	    /* calculate number of found files/dirs who are using objectid
-	       which is used by another file */
-	    sem_pass_stat (fs)->oid_sharing ++;
-	    if (1/*fsck_adjust_file_size (fs)*/)
-		/* this works for files only */
-		relocate = 1;
-	} 
+	/* stat data has been found */
+	bh = get_bh(&path);
+	ih = get_ih(&path);
+	sd = get_item(&path);
 
-	mark_item_reachable (ih, bh);
-    }
+	/* */
+	get_sd_nlink(ih, sd, &nlink);
+
+	relocate = 0;
+	if (!nlink) {
+		/* we reached the stat data for the first time */
+		if (id_map_mark
+		    (semantic_id_map(fs), get_key_objectid(&ih->ih_key))) {
+			/* calculate number of found files/dirs who are using objectid
+			   which is used by another file */
+			sem_pass_stat(fs)->oid_sharing++;
+			if (1 /*fsck_adjust_file_size (fs) */ )
+				/* this works for files only */
+				relocate = 1;
+		}
 
-    fix_obviously_wrong_sd_mode (&path);
+		mark_item_reachable(ih, bh);
+	}
 
-    if (not_a_directory (sd)) {
-	retval = rebuild_check_regular_file (&path, sd, relocate ? new_ih : 0);
-	pathrelse (&path);
-	return retval;
-    }
+	fix_obviously_wrong_sd_mode(&path);
 
-    if (relocate) {
-	if (!new_ih)
-	    reiserfs_panic ("rebuild_semantic_pass: Memory is not prepared for relocation of %K",
-		   &ih->ih_key);
-	*new_ih = *ih;
-	pathrelse (&path);
-	sem_pass_stat (fs)->oid_sharing_dirs_relocated ++;
-	relocate_dir (new_ih, 1);
-	linked_already(&new_ih->ih_key);
-	*key = new_ih->ih_key;	
-	retval = RELOCATED;
-	
-	goto start_again;
-    }
+	if (not_a_directory(sd)) {
+		retval =
+		    rebuild_check_regular_file(&path, sd,
+					       relocate ? new_ih : 0);
+		pathrelse(&path);
+		return retval;
+	}
 
-    /* it looks like stat data of a directory found */
-    if (nlink) {
-	/* we saw this directory already */
-	if (!dot_dot) {
-	    /* this name is not ".."  - and hard links are not allowed on
-               directories */
-	    pathrelse (&path);
-	    return STAT_DATA_NOT_FOUND;
-	} else {
-	    /* ".." found */
-	    nlink ++;
-	    set_sd_nlink (ih, sd, &nlink);
-	    mark_buffer_dirty (bh);
-	    pathrelse (&path);
-	    return OK;
+	if (relocate) {
+		if (!new_ih)
+			reiserfs_panic
+			    ("rebuild_semantic_pass: Memory is not prepared for relocation of %K",
+			     &ih->ih_key);
+		*new_ih = *ih;
+		pathrelse(&path);
+		sem_pass_stat(fs)->oid_sharing_dirs_relocated++;
+		relocate_dir(new_ih, 1);
+		linked_already(&new_ih->ih_key);
+		*key = new_ih->ih_key;
+		retval = RELOCATED;
+
+		goto start_again;
 	}
-    }
 
+	/* it looks like stat data of a directory found */
+	if (nlink) {
+		/* we saw this directory already */
+		if (!dot_dot) {
+			/* this name is not ".."  - and hard links are not allowed on
+			   directories */
+			pathrelse(&path);
+			return STAT_DATA_NOT_FOUND;
+		} else {
+			/* ".." found */
+			nlink++;
+			set_sd_nlink(ih, sd, &nlink);
+			mark_buffer_dirty(bh);
+			pathrelse(&path);
+			return OK;
+		}
+	}
 
-    /* we see the directory first time */
-    sem_pass_stat (fs)->directories ++;
-    nlink = 2;
-    if (get_key_objectid (key) == REISERFS_ROOT_OBJECTID)
-	nlink ++;
-    set_sd_nlink (ih, sd, &nlink);
-    mark_buffer_dirty (bh);
-    
-    if (get_ih_item_len (ih) == SD_SIZE)
-	is_new_dir = 1;
-    else
-	is_new_dir = 0;
+	/* we see the directory first time */
+	sem_pass_stat(fs)->directories++;
+	nlink = 2;
+	if (get_key_objectid(key) == REISERFS_ROOT_OBJECTID)
+		nlink++;
+	set_sd_nlink(ih, sd, &nlink);
+	mark_buffer_dirty(bh);
 
+	if (get_ih_item_len(ih) == SD_SIZE)
+		is_new_dir = 1;
+	else
+		is_new_dir = 0;
 
 /*
     {
@@ -828,59 +876,69 @@ int rebuild_semantic_pass (struct reiserfs_key *key, struct reiserfs_key *parent
     }
 */
 
-
-    dir_format = (get_ih_item_len (get_ih (&path)) == SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
-    /* save stat data's size and st_blocks */
-    get_sd_size (ih, sd, &saved_size);
-    get_sd_blocks (ih, sd, &saved_blocks);	
-    get_sd_mode (ih, sd, &mode);
-
-    /* release path pointing to stat data */
-    pathrelse (&path);
-
-    /* make sure that "." and ".." exist */
-    reiserfs_add_entry (fs, key, ".",  name_length (".", dir_format), key, 1 << IH_Unreachable);
-    reiserfs_add_entry (fs, key, "..", name_length ("..", dir_format), parent, 1 << IH_Unreachable);
-
-    set_key_dirid (&item_key, get_key_dirid (key));
-    set_key_objectid (&item_key, get_key_objectid (key));
-    set_key_offset_v1 (&item_key, DOT_OFFSET);
-    set_key_uniqueness (&item_key, DIRENTRY_UNIQUENESS);
-
-
-    dir_size = 0;
-    while ((dir_item = get_next_directory_item (&item_key, parent, &tmp_ih, &pos_in_item)) != 0) {
-	/* dir_item is copy of the item in separately allocated memory,
-	   item_key is a key of next item in the tree */
-	int i;
-	char * name = 0;
-	int namelen, entry_len;
-	struct reiserfs_de_head * deh = (struct reiserfs_de_head *)dir_item + pos_in_item;	
-	
-	for (i = pos_in_item; i < get_ih_entry_count (&tmp_ih); i ++, deh ++) {
-	    struct item_head relocated_ih;
-	
-	    if (name) {
-	    	free (name);
-	    	name = 0;
-	    }
-	
-	    namelen = name_in_entry_length (&tmp_ih, deh, i);
-	    asprintf (&name, "%.*s", namelen, name_in_entry (deh, i));
-	
-	    entry_len = entry_length (&tmp_ih, deh, i);
-	
-	    get_object_key (deh, &object_key, &entry_key, &tmp_ih);
-	
-	    if ((dir_format == KEY_FORMAT_2) && (entry_len % 8 != 0)) {
-	    	/* not alighed directory of new format - delete it */
-		fsck_log ("Entry %K (\"%.*s\") in the directory %K is not formated properly - fixed.\n",
-			  (struct reiserfs_key *)&(deh->deh2_dir_id), namelen, name, &tmp_ih.ih_key);
-		reiserfs_remove_entry (fs, &entry_key);
-		entry_len = name_length (name, dir_format);
-		reiserfs_add_entry (fs, key, name, entry_len,
-                                (struct reiserfs_key *)&(deh->deh2_dir_id), 0);
-	    }
+	dir_format =
+	    (get_ih_item_len(get_ih(&path)) ==
+	     SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
+	/* save stat data's size and st_blocks */
+	get_sd_size(ih, sd, &saved_size);
+	get_sd_blocks(ih, sd, &saved_blocks);
+	get_sd_mode(ih, sd, &mode);
+
+	/* release path pointing to stat data */
+	pathrelse(&path);
+
+	/* make sure that "." and ".." exist */
+	reiserfs_add_entry(fs, key, ".", name_length(".", dir_format), key,
+			   1 << IH_Unreachable);
+	reiserfs_add_entry(fs, key, "..", name_length("..", dir_format), parent,
+			   1 << IH_Unreachable);
+
+	set_key_dirid(&item_key, get_key_dirid(key));
+	set_key_objectid(&item_key, get_key_objectid(key));
+	set_key_offset_v1(&item_key, DOT_OFFSET);
+	set_key_uniqueness(&item_key, DIRENTRY_UNIQUENESS);
+
+	dir_size = 0;
+	while ((dir_item =
+		get_next_directory_item(&item_key, parent, &tmp_ih,
+					&pos_in_item)) != 0) {
+		/* dir_item is copy of the item in separately allocated memory,
+		   item_key is a key of next item in the tree */
+		int i;
+		char *name = 0;
+		int namelen, entry_len;
+		struct reiserfs_de_head *deh =
+		    (struct reiserfs_de_head *)dir_item + pos_in_item;
+
+		for (i = pos_in_item; i < get_ih_entry_count(&tmp_ih);
+		     i++, deh++) {
+			struct item_head relocated_ih;
+
+			if (name) {
+				free(name);
+				name = 0;
+			}
+
+			namelen = name_in_entry_length(&tmp_ih, deh, i);
+			asprintf(&name, "%.*s", namelen, name_in_entry(deh, i));
+
+			entry_len = entry_length(&tmp_ih, deh, i);
+
+			get_object_key(deh, &object_key, &entry_key, &tmp_ih);
+
+			if ((dir_format == KEY_FORMAT_2)
+			    && (entry_len % 8 != 0)) {
+				/* not alighed directory of new format - delete it */
+				fsck_log
+				    ("Entry %K (\"%.*s\") in the directory %K is not formated properly - fixed.\n",
+				     (struct reiserfs_key *)&(deh->deh2_dir_id),
+				     namelen, name, &tmp_ih.ih_key);
+				reiserfs_remove_entry(fs, &entry_key);
+				entry_len = name_length(name, dir_format);
+				reiserfs_add_entry(fs, key, name, entry_len,
+						   (struct reiserfs_key *)
+						   &(deh->deh2_dir_id), 0);
+			}
 /*	
 	    if ((dir_format == KEY_FORMAT_1) && (namelen != entry_len)) {
 	    	// aligned entry in directory of old format - remove and insert it back
@@ -891,360 +949,393 @@ int rebuild_semantic_pass (struct reiserfs_key *key, struct reiserfs_key *parent
 		reiserfs_add_entry (fs, key, name, entry_len,
 				(struct reiserfs_key *)&(deh->deh2_dir_id), 0);
 	    }
-*/	
-	    if (is_dot (name, namelen)) {
-		dir_size += DEH_SIZE + entry_len;
-		continue;
-	    }
-	
-	    print_name (name, namelen);
-	    
-	    if (!is_properly_hashed (fs, name, namelen, get_deh_offset (deh)))
-		reiserfs_panic ("rebuild_semantic_pass: Hash mismatch detected for (\"%.*s\") in directory %K\n", 
-		    namelen, name, &tmp_ih.ih_key);
-	    
-	
-	    retval1 = rebuild_semantic_pass (&object_key, key, is_dot_dot (name, namelen), &relocated_ih);
-    
-	    erase_name (namelen);
-	    
-	    switch (retval1) {
-	    case OK:
-		dir_size += DEH_SIZE + entry_len;
-		break;
-
-	    case STAT_DATA_NOT_FOUND:
-	    case DIRECTORY_HAS_NO_ITEMS:
-		if (get_offset (&entry_key) == DOT_DOT_OFFSET && 
-		    get_key_objectid (&object_key) == REISERFS_ROOT_PARENT_OBJECTID) {
-		    /* ".." of root directory can not be found */
-		    dir_size += DEH_SIZE + entry_len;
-		    continue;
-		}
-		fsck_log ("%s: The entry %K (\"%.*s\") in directory %K points to nowhere - is removed\n",
-		    __FUNCTION__, &object_key, namelen, name, &tmp_ih.ih_key);
-		reiserfs_remove_entry (fs, &entry_key);
-		sem_pass_stat (fs)->deleted_entries ++;
-		break;
-		
-	    case RELOCATED:
-		/* file was relocated, update key in corresponding directory entry */
-		if (reiserfs_search_by_entry_key (fs, &entry_key, &path) != POSITION_FOUND) {
-		    fsck_log ("WARNING: Cannot find the name of the relocated file %K in the directory %K\n", 
-			&object_key, &tmp_ih.ih_key);
-		} else {
-		    /* update key dir entry points to */
-		    struct reiserfs_de_head * tmp_deh;
-		    
-		    tmp_deh = B_I_DEH (get_bh (&path), get_ih (&path)) + path.pos_in_item;
-		    fsck_log ("The entry %K (\"%.*s\") in directory %K updated to point to ",
-			&object_key, namelen, name, &tmp_ih.ih_key);
-		    set_deh_dirid (tmp_deh, get_key_dirid (&relocated_ih.ih_key));
-		    set_deh_objectid (tmp_deh, get_key_objectid (&relocated_ih.ih_key));
-
-		    fsck_log ("%K\n",  &tmp_deh->deh2_dir_id);
-		    mark_buffer_dirty (get_bh (&path));
-		}
-		dir_size += DEH_SIZE + entry_len;
-		pathrelse (&path);
-		break;
-	    }
-	} /* for */
-	
-	freemem (dir_item);
-    	free (name);
-    	name = 0;
-	
-	if (not_of_one_file (&item_key, key))
-	    /* next key is not of this directory */
-	    break;
-	
-    } /* while (dir_item) */
-    
-    
-    if (dir_size == 0)
-	/* FIXME: is it possible? */
-	return DIRECTORY_HAS_NO_ITEMS;
-    
-    /* calc correct value of sd_blocks field of stat data */
-    blocks = dir_size2st_blocks (dir_size);
-    
-    fix_sd = 0;
-    fix_sd += wrong_st_blocks (key, &blocks, saved_blocks, mode, is_new_dir);
-    fix_sd += wrong_st_size (key, is_new_dir ? MAX_FILE_SIZE_V2 : MAX_FILE_SIZE_V1,
-			     fs->fs_blocksize, &dir_size, saved_size, TYPE_DIRENTRY);
-
-    if (fix_sd) {
-	/* we have to fix either sd_size or sd_blocks, so look for stat data again */
-	if (reiserfs_search_by_key_4 (fs, key, &path) != ITEM_FOUND)
-	    reiserfs_panic ("rebuild_semantic_pass: The StatData of the file %K was not found", key);
-	    
-	bh = get_bh (&path);
-	ih = get_ih (&path);
-	sd = get_item (&path);
-	
-	set_sd_size (ih, sd, &dir_size);
-	set_sd_blocks (ih, sd, &blocks);
-	mark_buffer_dirty (bh);
-	pathrelse (&path);
-    }
-    
-    return retval;
-}
+*/
+			if (is_dot(name, namelen)) {
+				dir_size += DEH_SIZE + entry_len;
+				continue;
+			}
+
+			print_name(name, namelen);
+
+			if (!is_properly_hashed
+			    (fs, name, namelen, get_deh_offset(deh)))
+				reiserfs_panic
+				    ("rebuild_semantic_pass: Hash mismatch detected for (\"%.*s\") in directory %K\n",
+				     namelen, name, &tmp_ih.ih_key);
+
+			retval1 =
+			    rebuild_semantic_pass(&object_key, key,
+						  is_dot_dot(name, namelen),
+						  &relocated_ih);
+
+			erase_name(namelen);
+
+			switch (retval1) {
+			case OK:
+				dir_size += DEH_SIZE + entry_len;
+				break;
+
+			case STAT_DATA_NOT_FOUND:
+			case DIRECTORY_HAS_NO_ITEMS:
+				if (get_offset(&entry_key) == DOT_DOT_OFFSET &&
+				    get_key_objectid(&object_key) ==
+				    REISERFS_ROOT_PARENT_OBJECTID) {
+					/* ".." of root directory can not be found */
+					dir_size += DEH_SIZE + entry_len;
+					continue;
+				}
+				fsck_log
+				    ("%s: The entry %K (\"%.*s\") in directory %K points to nowhere - is removed\n",
+				     __FUNCTION__, &object_key, namelen, name,
+				     &tmp_ih.ih_key);
+				reiserfs_remove_entry(fs, &entry_key);
+				sem_pass_stat(fs)->deleted_entries++;
+				break;
+
+			case RELOCATED:
+				/* file was relocated, update key in corresponding directory entry */
+				if (reiserfs_search_by_entry_key
+				    (fs, &entry_key, &path) != POSITION_FOUND) {
+					fsck_log
+					    ("WARNING: Cannot find the name of the relocated file %K in the directory %K\n",
+					     &object_key, &tmp_ih.ih_key);
+				} else {
+					/* update key dir entry points to */
+					struct reiserfs_de_head *tmp_deh;
+
+					tmp_deh =
+					    B_I_DEH(get_bh(&path),
+						    get_ih(&path)) +
+					    path.pos_in_item;
+					fsck_log
+					    ("The entry %K (\"%.*s\") in directory %K updated to point to ",
+					     &object_key, namelen, name,
+					     &tmp_ih.ih_key);
+					set_deh_dirid(tmp_deh,
+						      get_key_dirid
+						      (&relocated_ih.ih_key));
+					set_deh_objectid(tmp_deh,
+							 get_key_objectid
+							 (&relocated_ih.
+							  ih_key));
+
+					fsck_log("%K\n", &tmp_deh->deh2_dir_id);
+					mark_buffer_dirty(get_bh(&path));
+				}
+				dir_size += DEH_SIZE + entry_len;
+				pathrelse(&path);
+				break;
+			}
+		}		/* for */
+
+		freemem(dir_item);
+		free(name);
+		name = 0;
+
+		if (not_of_one_file(&item_key, key))
+			/* next key is not of this directory */
+			break;
+
+	}			/* while (dir_item) */
+
+	if (dir_size == 0)
+		/* FIXME: is it possible? */
+		return DIRECTORY_HAS_NO_ITEMS;
+
+	/* calc correct value of sd_blocks field of stat data */
+	blocks = dir_size2st_blocks(dir_size);
+
+	fix_sd = 0;
+	fix_sd += wrong_st_blocks(key, &blocks, saved_blocks, mode, is_new_dir);
+	fix_sd +=
+	    wrong_st_size(key, is_new_dir ? MAX_FILE_SIZE_V2 : MAX_FILE_SIZE_V1,
+			  fs->fs_blocksize, &dir_size, saved_size,
+			  TYPE_DIRENTRY);
+
+	if (fix_sd) {
+		/* we have to fix either sd_size or sd_blocks, so look for stat data again */
+		if (reiserfs_search_by_key_4(fs, key, &path) != ITEM_FOUND)
+			reiserfs_panic
+			    ("rebuild_semantic_pass: The StatData of the file %K was not found",
+			     key);
+
+		bh = get_bh(&path);
+		ih = get_ih(&path);
+		sd = get_item(&path);
+
+		set_sd_size(ih, sd, &dir_size);
+		set_sd_blocks(ih, sd, &blocks);
+		mark_buffer_dirty(bh);
+		pathrelse(&path);
+	}
 
+	return retval;
+}
 
-int is_dot (char * name, int namelen)
+int is_dot(char *name, int namelen)
 {
-    return (namelen == 1 && name[0] == '.') ? 1 : 0;
+	return (namelen == 1 && name[0] == '.') ? 1 : 0;
 }
 
-
-int is_dot_dot (char * name, int namelen)
+int is_dot_dot(char *name, int namelen)
 {
-    return (namelen == 2 && name[0] == '.' && name[1] == '.') ? 1 : 0;
+	return (namelen == 2 && name[0] == '.' && name[1] == '.') ? 1 : 0;
 }
 
-
-int not_a_directory (void * sd)
+int not_a_directory(void *sd)
 {
-    /* mode is at the same place and of the same size in both stat
-       datas (v1 and v2) */
-    struct stat_data_v1 * sd_v1 = sd;
+	/* mode is at the same place and of the same size in both stat
+	   datas (v1 and v2) */
+	struct stat_data_v1 *sd_v1 = sd;
 
-    return !(S_ISDIR (le16_to_cpu (sd_v1->sd_mode)));
+	return !(S_ISDIR(le16_to_cpu(sd_v1->sd_mode)));
 }
 
-int not_a_regfile (void * sd)
+int not_a_regfile(void *sd)
 {
-    /* mode is at the same place and of the same size in both stat
-       datas (v1 and v2) */
-    struct stat_data_v1 * sd_v1 = sd;
+	/* mode is at the same place and of the same size in both stat
+	   datas (v1 and v2) */
+	struct stat_data_v1 *sd_v1 = sd;
 
-    return !(S_ISREG (le16_to_cpu (sd_v1->sd_mode)));
+	return !(S_ISREG(le16_to_cpu(sd_v1->sd_mode)));
 }
 
-
-
-void zero_nlink (struct item_head * ih, void * sd)
+void zero_nlink(struct item_head *ih, void *sd)
 {
-    int zero = 0;
-
-    if (get_ih_item_len (ih) == SD_V1_SIZE && get_ih_key_format (ih) != KEY_FORMAT_1) {
-	fsck_log ("zero_nlink: The StatData %k of the wrong format version (%d) - corrected to (%d)\n",
-	    ih, get_ih_key_format (ih), KEY_FORMAT_1);
-	set_ih_key_format (ih, KEY_FORMAT_1);
-    }
-    if (get_ih_item_len (ih) == SD_SIZE && get_ih_key_format (ih) != KEY_FORMAT_2) {
-	fsck_log ("zero_nlink: The StatData %k of the wrong format version (%d) - corrected to (%d)\n",
-	    ih, get_ih_key_format (ih), KEY_FORMAT_2);
-	set_ih_key_format (ih, KEY_FORMAT_2);
-    }
+	int zero = 0;
+
+	if (get_ih_item_len(ih) == SD_V1_SIZE
+	    && get_ih_key_format(ih) != KEY_FORMAT_1) {
+		fsck_log
+		    ("zero_nlink: The StatData %k of the wrong format version (%d) - corrected to (%d)\n",
+		     ih, get_ih_key_format(ih), KEY_FORMAT_1);
+		set_ih_key_format(ih, KEY_FORMAT_1);
+	}
+	if (get_ih_item_len(ih) == SD_SIZE
+	    && get_ih_key_format(ih) != KEY_FORMAT_2) {
+		fsck_log
+		    ("zero_nlink: The StatData %k of the wrong format version (%d) - corrected to (%d)\n",
+		     ih, get_ih_key_format(ih), KEY_FORMAT_2);
+		set_ih_key_format(ih, KEY_FORMAT_2);
+	}
 
-    set_sd_nlink (ih, sd, &zero);
+	set_sd_nlink(ih, sd, &zero);
 }
 
-
-
-void modify_item (struct item_head * ih, void * item)
+void modify_item(struct item_head *ih, void *item)
 {
-    zero_nlink (ih, item);
-    mark_item_unreachable (ih);    
+	zero_nlink(ih, item);
+	mark_item_unreachable(ih);
 }
 
-
 /* mkreiserfs should have created this */
-static void make_sure_lost_found_exists (reiserfs_filsys_t * fs)
+static void make_sure_lost_found_exists(reiserfs_filsys_t *fs)
 {
-    int retval;
-    INITIALIZE_REISERFS_PATH(path);
-    unsigned int gen_counter;
-    __u32 objectid;
-    __u64 sd_size;
-    __u32 sd_blocks;
-    struct buffer_head * bh;
-    struct item_head * ih;
-    void * sd;
-    int item_len;
-
-
-    /* look for "lost+found" in the root directory */
-    retval = reiserfs_find_entry (fs, &root_dir_key,
-				  "lost+found", &gen_counter,
-				  &lost_found_dir_key);
-    if (!retval) {
-	objectid = id_map_alloc(proper_id_map(fs));
-	if (!objectid) {
-	    fsck_progress ("Could not allocate an objectid for \"/lost+found\", \
+	int retval;
+	INITIALIZE_REISERFS_PATH(path);
+	unsigned int gen_counter;
+	__u32 objectid;
+	__u64 sd_size;
+	__u32 sd_blocks;
+	struct buffer_head *bh;
+	struct item_head *ih;
+	void *sd;
+	int item_len;
+
+	/* look for "lost+found" in the root directory */
+	retval = reiserfs_find_entry(fs, &root_dir_key,
+				     "lost+found", &gen_counter,
+				     &lost_found_dir_key);
+	if (!retval) {
+		objectid = id_map_alloc(proper_id_map(fs));
+		if (!objectid) {
+			fsck_progress
+			    ("Could not allocate an objectid for \"/lost+found\", \
 		lost files will not be linked\n");
-	    return;
+			return;
+		}
+		set_key_dirid(&lost_found_dir_key, REISERFS_ROOT_OBJECTID);
+		set_key_objectid(&lost_found_dir_key, objectid);
 	}
-	set_key_dirid (&lost_found_dir_key, REISERFS_ROOT_OBJECTID);
-	set_key_objectid (&lost_found_dir_key, objectid);
-    }
 
+	/* look for stat data of "lost+found" */
+	retval = reiserfs_search_by_key_4(fs, &lost_found_dir_key, &path);
+	if (retval == ITEM_NOT_FOUND)
+		lost_found_dir_format =
+		    create_dir_sd(fs, &path, &lost_found_dir_key, modify_item);
+	else {
+		struct item_head *ih = get_ih(&path);
 
-    /* look for stat data of "lost+found" */
-    retval = reiserfs_search_by_key_4 (fs, &lost_found_dir_key, &path);
-    if (retval == ITEM_NOT_FOUND)
-	lost_found_dir_format = create_dir_sd (fs, &path, &lost_found_dir_key, modify_item);
-    else {
-    	struct item_head * ih = get_ih (&path);
-	
-    	if (!is_stat_data_ih (ih))
-	    reiserfs_panic ("It must be lost+found's stat data %k\n", &ih->ih_key);
-	
-	fix_obviously_wrong_sd_mode (&path);
-	
-	if (not_a_directory (get_item (&path))) {
-	    fsck_progress ("\"/lost+found\" exists, but it is not a directory, \
+		if (!is_stat_data_ih(ih))
+			reiserfs_panic("It must be lost+found's stat data %k\n",
+				       &ih->ih_key);
+
+		fix_obviously_wrong_sd_mode(&path);
+
+		if (not_a_directory(get_item(&path))) {
+			fsck_progress
+			    ("\"/lost+found\" exists, but it is not a directory, \
 		lost files will not be linked\n");
-	    set_key_objectid (&lost_found_dir_key, 0);
-	    pathrelse (&path);
-	    return;
+			set_key_objectid(&lost_found_dir_key, 0);
+			pathrelse(&path);
+			return;
+		}
+
+		lost_found_dir_format =
+		    (get_ih_item_len(get_ih(&path)) ==
+		     SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
+
+		pathrelse(&path);
 	}
-    	
-        lost_found_dir_format = (get_ih_item_len (get_ih (&path)) == SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
-        	
-	pathrelse (&path);
-    }
 
-    /* add "." and ".." if any of them do not exist */
-    reiserfs_add_entry (fs, &lost_found_dir_key, ".", name_length (".", lost_found_dir_format),
-    		&lost_found_dir_key, 1 << IH_Unreachable);    		
-    reiserfs_add_entry (fs, &lost_found_dir_key, "..", name_length ("..", lost_found_dir_format),
-    		&root_dir_key, 1 << IH_Unreachable);
-
-    item_len = reiserfs_add_entry (fs, &root_dir_key, "lost+found",
-    		name_length ("lost+found", root_dir_format), &lost_found_dir_key, 1 << IH_Unreachable);
-
-    if (item_len) {
-	if (reiserfs_search_by_key_4 (fs, &root_dir_key, &path) == ITEM_NOT_FOUND)
-	    reiserfs_panic ("%s: StatData of the root directory must exists", __FUNCTION__);
-	
-	bh = get_bh (&path);
-	ih = get_ih (&path);
-	sd = get_item(&path);
-	
-	get_sd_size (ih, sd, &sd_size);
-	sd_size += item_len;
-	set_sd_size (ih, sd, &sd_size);
-	sd_blocks = dir_size2st_blocks (sd_size);
-	set_sd_blocks (ih, sd, &sd_blocks);
-	mark_buffer_dirty (bh);
-	pathrelse (&path);
-    }
-			
-    return;
+	/* add "." and ".." if any of them do not exist */
+	reiserfs_add_entry(fs, &lost_found_dir_key, ".",
+			   name_length(".", lost_found_dir_format),
+			   &lost_found_dir_key, 1 << IH_Unreachable);
+	reiserfs_add_entry(fs, &lost_found_dir_key, "..",
+			   name_length("..", lost_found_dir_format),
+			   &root_dir_key, 1 << IH_Unreachable);
+
+	item_len = reiserfs_add_entry(fs, &root_dir_key, "lost+found",
+				      name_length("lost+found",
+						  root_dir_format),
+				      &lost_found_dir_key, 1 << IH_Unreachable);
+
+	if (item_len) {
+		if (reiserfs_search_by_key_4(fs, &root_dir_key, &path) ==
+		    ITEM_NOT_FOUND)
+			reiserfs_panic
+			    ("%s: StatData of the root directory must exists",
+			     __FUNCTION__);
+
+		bh = get_bh(&path);
+		ih = get_ih(&path);
+		sd = get_item(&path);
+
+		get_sd_size(ih, sd, &sd_size);
+		sd_size += item_len;
+		set_sd_size(ih, sd, &sd_size);
+		sd_blocks = dir_size2st_blocks(sd_size);
+		set_sd_blocks(ih, sd, &sd_blocks);
+		mark_buffer_dirty(bh);
+		pathrelse(&path);
+	}
+
+	return;
 }
 
 /* Result of the rebuild pass will be saved in the state file which is needed to start 
  * fsck again from the next pass. */
-static void save_rebuild_semantic_result (reiserfs_filsys_t * fs) {
-    FILE * file;
-    int retval;
-
-    file = open_file ("temp_fsck_file.deleteme", "w+");
-    if (!file)
-	return;
-
-    reiserfs_begin_stage_info_save (file, SEMANTIC_DONE);
-    /*  Method not implemented yet.
-    reiserfs_objectid_map_save (file, semantic_id_map (fs));
-    */
-    reiserfs_end_stage_info_save (file);
-    close_file (file);
-    retval = rename ("temp_fsck_file.deleteme", state_dump_file (fs));
-    if (retval != 0)
-	fsck_progress ("%s: Could not rename the temporary file temp_fsck_file.deleteme to %s",
-	    __FUNCTION__, state_dump_file (fs));
+static void save_rebuild_semantic_result(reiserfs_filsys_t *fs)
+{
+	FILE *file;
+	int retval;
+
+	file = open_file("temp_fsck_file.deleteme", "w+");
+	if (!file)
+		return;
+
+	reiserfs_begin_stage_info_save(file, SEMANTIC_DONE);
+	/*  Method not implemented yet.
+	   reiserfs_objectid_map_save (file, semantic_id_map (fs));
+	 */
+	reiserfs_end_stage_info_save(file);
+	close_file(file);
+	retval = rename("temp_fsck_file.deleteme", state_dump_file(fs));
+	if (retval != 0)
+		fsck_progress
+		    ("%s: Could not rename the temporary file temp_fsck_file.deleteme to %s",
+		     __FUNCTION__, state_dump_file(fs));
 }
 
 /* we have nothing to load from a state file, but we have to fetch
    on-disk bitmap, copy it to allocable bitmap, and fetch objectid
    map */
-void load_semantic_result (FILE * file, reiserfs_filsys_t * fs)
+void load_semantic_result(FILE * file, reiserfs_filsys_t *fs)
 {
-    fsck_new_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_new_bitmap (fs), fs->fs_bitmap2);
-
-    fsck_allocable_bitmap (fs) = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    reiserfs_bitmap_copy (fsck_allocable_bitmap (fs), fs->fs_bitmap2);
-
-    fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
-    fs->block_deallocator = reiserfsck_reiserfs_free_block;
-
-    /* we need objectid map on semantic pass to be able to relocate files */
-    proper_id_map (fs) = id_map_init();
-    /* Not implemented yet.    
-    fetch_objectid_map (proper_id_map (fs), fs);
-    semantic_id_map (fs) = reiserfs_objectid_map_load (file);
-    */
+	fsck_new_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_new_bitmap(fs), fs->fs_bitmap2);
+
+	fsck_allocable_bitmap(fs) =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_copy(fsck_allocable_bitmap(fs), fs->fs_bitmap2);
+
+	fs->block_allocator = reiserfsck_reiserfs_new_blocknrs;
+	fs->block_deallocator = reiserfsck_reiserfs_free_block;
+
+	/* we need objectid map on semantic pass to be able to relocate files */
+	proper_id_map(fs) = id_map_init();
+	/* Not implemented yet.    
+	   fetch_objectid_map (proper_id_map (fs), fs);
+	   semantic_id_map (fs) = reiserfs_objectid_map_load (file);
+	 */
 }
 
-static void before_pass_3 (reiserfs_filsys_t * fs)
+static void before_pass_3(reiserfs_filsys_t *fs)
 {
-    semantic_id_map (fs) = id_map_init();
+	semantic_id_map(fs) = id_map_init();
 }
 
-static void after_pass_3 (reiserfs_filsys_t * fs)
+static void after_pass_3(reiserfs_filsys_t *fs)
 {
-    /* update super block: objectid map, fsck state */
-    set_sb_fs_state (fs->fs_ondisk_sb, SEMANTIC_DONE);
-    mark_buffer_dirty (fs->fs_super_bh);
-
-    /* write all dirty blocks */
-    fsck_progress ("Flushing..");
-    id_map_flush(proper_id_map (fs), fs);
-    fs->fs_dirt = 1;
-    reiserfs_flush_to_ondisk_bitmap (fsck_new_bitmap(fs), fs);
-    reiserfs_flush (fs);
-    fsck_progress ("finished\n");
-
-    stage_report (3, fs);
-
-    if (!fsck_run_one_step (fs)) {
-	if (fsck_user_confirmed (fs, "Continue? (Yes):", "Yes\n", 1))
-	    /* reiserfsck continues */
-	    return;
-    }
+	/* update super block: objectid map, fsck state */
+	set_sb_fs_state(fs->fs_ondisk_sb, SEMANTIC_DONE);
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	/* write all dirty blocks */
+	fsck_progress("Flushing..");
+	id_map_flush(proper_id_map(fs), fs);
+	fs->fs_dirt = 1;
+	reiserfs_flush_to_ondisk_bitmap(fsck_new_bitmap(fs), fs);
+	reiserfs_flush(fs);
+	fsck_progress("finished\n");
+
+	stage_report(3, fs);
+
+	if (!fsck_run_one_step(fs)) {
+		if (fsck_user_confirmed(fs, "Continue? (Yes):", "Yes\n", 1))
+			/* reiserfsck continues */
+			return;
+	}
 
-    save_rebuild_semantic_result (fs);
+	save_rebuild_semantic_result(fs);
 
-    id_map_free(proper_id_map (fs));
-    proper_id_map (fs) = 0;
+	id_map_free(proper_id_map(fs));
+	proper_id_map(fs) = 0;
 
-    fs->fs_dirt = 1;
-    reiserfs_close (fs);
-    exit(0);
+	fs->fs_dirt = 1;
+	reiserfs_close(fs);
+	exit(0);
 }
 
 /* this is part of rebuild tree */
-void pass_3_semantic (reiserfs_filsys_t * fs)
+void pass_3_semantic(reiserfs_filsys_t *fs)
 {
-    before_pass_3 (fs);
+	before_pass_3(fs);
 
-    fsck_progress ("Pass 3 (semantic):\n");
+	fsck_progress("Pass 3 (semantic):\n");
 
-    /* when warnings go not to stderr - separate them in the log */
-    if (fsck_log_file (fs) != stderr)
-	fsck_log ("####### Pass 3 #########\n");
+	/* when warnings go not to stderr - separate them in the log */
+	if (fsck_log_file(fs) != stderr)
+		fsck_log("####### Pass 3 #########\n");
 
+	if (!fs->fs_hash_function)
+		reiserfs_panic("Hash function should be selected already");
 
-    if (!fs->fs_hash_function)
-	reiserfs_panic ("Hash function should be selected already");
+	make_sure_root_dir_exists(fs, modify_item, 1 << IH_Unreachable);
+	make_sure_lost_found_exists(fs);
 
-    make_sure_root_dir_exists (fs, modify_item, 1 << IH_Unreachable);
-    make_sure_lost_found_exists (fs);
+	id_map_mark(proper_id_map(fs), get_key_objectid(&root_dir_key));
+	id_map_mark(proper_id_map(fs), get_key_objectid(&lost_found_dir_key));
 
-    id_map_mark(proper_id_map(fs), get_key_objectid(&root_dir_key));
-    id_map_mark(proper_id_map(fs), get_key_objectid(&lost_found_dir_key));
-    
-    /* link all relocated files into /lost+found directory */
-    link_relocated_files ();
+	/* link all relocated files into /lost+found directory */
+	link_relocated_files();
 
-    rebuild_semantic_pass (&root_dir_key, &parent_root_dir_key, 0/*!dot_dot*/, 0/*reloc_ih*/);
+	rebuild_semantic_pass(&root_dir_key, &parent_root_dir_key,
+			      0 /*!dot_dot */ , 0 /*reloc_ih */ );
 
-    add_badblock_list(fs, 1);
+	add_badblock_list(fs, 1);
 
-    after_pass_3 (fs);
+	after_pass_3(fs);
 }
diff --git a/fsck/super.c b/fsck/super.c
index d34310b..230bb1c 100644
--- a/fsck/super.c
+++ b/fsck/super.c
@@ -14,22 +14,22 @@
     	fsck_log(fmt, ## list);				\
 }
 
-int what_fs_version ()
+int what_fs_version()
 {
-    size_t n = 0;
-    char * answer = 0;
-    int version;
-    printf("\nwhat the version of ReiserFS do you use[1-4]\n"
-        "\t(1)   3.6.x\n"
-        "\t(2) >=3.5.9 (introduced in the middle of 1999) (if you use linux 2.2, choose this one)\n"
-        "\t(3) < 3.5.9 converted to new format (don't choose if unsure)\n"
-        "\t(4) < 3.5.9 (this is very old format, don't choose if unsure)\n"
-        "\t(X)   exit\n");
-    getline (&answer, &n, stdin);
-    version = atoi (answer);
-    if (version < 1 || version > 4)
-        die ("rebuild_sb: wrong version");
-    return version;
+	size_t n = 0;
+	char *answer = 0;
+	int version;
+	printf("\nwhat the version of ReiserFS do you use[1-4]\n"
+	       "\t(1)   3.6.x\n"
+	       "\t(2) >=3.5.9 (introduced in the middle of 1999) (if you use linux 2.2, choose this one)\n"
+	       "\t(3) < 3.5.9 converted to new format (don't choose if unsure)\n"
+	       "\t(4) < 3.5.9 (this is very old format, don't choose if unsure)\n"
+	       "\t(X)   exit\n");
+	getline(&answer, &n, stdin);
+	version = atoi(answer);
+	if (version < 1 || version > 4)
+		die("rebuild_sb: wrong version");
+	return version;
 }
 
 /*
@@ -38,7 +38,7 @@ int what_fs_version ()
     return exit_code;			\
 }
     
-int check_sb (reiserfs_filsys_t * fs) {
+int check_sb (reiserfs_filsys_t *fs) {
     int magic = 0, version = 0;
     
     if (!is_blocksize_correct (fs->fs_blocksize)) 
@@ -168,684 +168,804 @@ int check_sb (reiserfs_filsys_t * fs) {
 }
 */
 
-void rebuild_sb (reiserfs_filsys_t * fs, char * filename, struct fsck_data * data)
+void rebuild_sb(reiserfs_filsys_t *fs, char *filename, struct fsck_data *data)
 {
-    int version = 0;
-    struct reiserfs_super_block * ondisk_sb = 0;
-    struct reiserfs_super_block * sb = 0;
-    struct reiserfs_journal_header *j_head;
-
-    int magic_was_found = 0;
-    unsigned long block_count = 0;
-    __u16 p_oid_maxsize;
-    unsigned int bmap_nr;
-    __u32 p_jp_journal_1st_block = 0;
-    __u32 p_jp_dev_size = 0;
-    int standard_journal = -1;
-    char * journal_dev_name = 0;
-    char * tmp;
-    int sb_size;
-
-    char * answer = 0;
-    size_t n = 0;
-    struct stat stat_buf;
-    int retval, exit_code = EXIT_OK;
-
-    if (!no_reiserfs_found (fs)) {
-        sb = getmem (sizeof (*sb));
-        if (!is_opened_rw (fs)) {
-            close (fs->fs_dev);
-            fs->fs_dev = open (fs->fs_file_name, O_RDWR | O_LARGEFILE);
-        }
+	int version = 0;
+	struct reiserfs_super_block *ondisk_sb = 0;
+	struct reiserfs_super_block *sb = 0;
+	struct reiserfs_journal_header *j_head;
+
+	int magic_was_found = 0;
+	unsigned long block_count = 0;
+	__u16 p_oid_maxsize;
+	unsigned int bmap_nr;
+	__u32 p_jp_journal_1st_block = 0;
+	__u32 p_jp_dev_size = 0;
+	int standard_journal = -1;
+	char *journal_dev_name = 0;
+	char *tmp;
+	int sb_size;
+
+	char *answer = 0;
+	size_t n = 0;
+	struct stat stat_buf;
+	int retval, exit_code = EXIT_OK;
+
+	if (!no_reiserfs_found(fs)) {
+		sb = getmem(sizeof(*sb));
+		if (!is_opened_rw(fs)) {
+			close(fs->fs_dev);
+			fs->fs_dev =
+			    open(fs->fs_file_name, O_RDWR | O_LARGEFILE);
+		}
 
-	if (!is_blocksize_correct (fs->fs_blocksize)) {
-	    printf("\nCannot find a proper blocksize, enter block size [4096]: \n");
-	    getline (&answer, &n, stdin);
-	    if (strcmp(answer, "\n")) {
-		retval = (int) strtol (answer, &tmp, 0);
-		if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
-		    reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified\n");
-		if (!is_blocksize_correct (retval))
-		    reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified, "
-			"only power of 2 from 512-8192 interval are supported.\n");
-	    } else
-		retval = 4096;
-	
-	    fs->fs_blocksize = retval;
+		if (!is_blocksize_correct(fs->fs_blocksize)) {
+			printf
+			    ("\nCannot find a proper blocksize, enter block size [4096]: \n");
+			getline(&answer, &n, stdin);
+			if (strcmp(answer, "\n")) {
+				retval = (int)strtol(answer, &tmp, 0);
+				if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: wrong block size specified\n");
+				if (!is_blocksize_correct(retval))
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: wrong block size specified, "
+						      "only power of 2 from 512-8192 interval are supported.\n");
+			} else
+				retval = 4096;
+
+			fs->fs_blocksize = retval;
+		}
+
+		if (!(block_count = count_blocks(filename, fs->fs_blocksize)))
+			exit(EXIT_OPER);
+
+		/* save ondisk_sb somewhere and work in temp area */
+		ondisk_sb = fs->fs_ondisk_sb;
+		memcpy(sb, fs->fs_ondisk_sb, sizeof(*sb));
+		fs->fs_ondisk_sb = sb;
+
+		if (is_reiserfs_3_6_magic_string(sb)) {
+			/* 3_6 magic */
+			if (fsck_data(fs)->journal_dev_name)
+				/* journal dev must not be specified with standard journal */
+				reiserfs_exit(EXIT_USER,
+					      "ReiserFS with default journal "
+					      "is found, but there was specified a journal device.");
+
+			if (fs->fs_super_bh->b_blocknr ==
+			    REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
+				version = 1;
+			else if (fs->fs_super_bh->b_blocknr ==
+				 REISERFS_OLD_DISK_OFFSET_IN_BYTES /
+				 fs->fs_blocksize)
+				version = 3;
+
+			magic_was_found = 2;
+		} else if (is_reiserfs_3_5_magic_string(sb)) {
+			if (fsck_data(fs)->journal_dev_name)
+				/* journal dev must not be specified with standard journal */
+				reiserfs_exit(EXIT_USER,
+					      "ReiserFS with default journal "
+					      "is found, but there was specified a journal device.");
+
+			/* 3_5 magic */
+			if (fs->fs_super_bh->b_blocknr ==
+			    REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
+				version = 2;
+			else if (fs->fs_super_bh->b_blocknr ==
+				 REISERFS_OLD_DISK_OFFSET_IN_BYTES /
+				 fs->fs_blocksize)
+				version = 4;
+
+			magic_was_found = 1;
+		} else if (is_reiserfs_jr_magic_string(sb)) {
+			if (!fsck_data(fs)->journal_dev_name
+			    && !fsck_skip_journal(fs))
+				/* journal dev must be specified with non standard journal */
+				reiserfs_exit(EXIT_USER,
+					      "ReiserFS with non default journal "
+					      "is found, but there was not specified any journal device.");
+
+			if (get_sb_version(sb) == REISERFS_FORMAT_3_6) {
+				/*non-standard magic + sb_format == 3_6 */
+				if (fs->fs_super_bh->b_blocknr ==
+				    REISERFS_DISK_OFFSET_IN_BYTES /
+				    fs->fs_blocksize)
+					version = 1;
+				else if (fs->fs_super_bh->b_blocknr ==
+					 REISERFS_OLD_DISK_OFFSET_IN_BYTES /
+					 fs->fs_blocksize)
+					version = 3;
+
+				magic_was_found = 3;
+			} else if (get_sb_version(sb) == REISERFS_FORMAT_3_5) {
+				/* non-standard magic + sb_format == 3_5 */
+				if (fs->fs_super_bh->b_blocknr ==
+				    REISERFS_DISK_OFFSET_IN_BYTES /
+				    fs->fs_blocksize)
+					version = 2;
+				else if (fs->fs_super_bh->b_blocknr ==
+					 REISERFS_OLD_DISK_OFFSET_IN_BYTES /
+					 fs->fs_blocksize)
+					version = 4;
+
+				magic_was_found = 3;
+			} else {
+				/* non-standard magic + bad sb_format */
+				version = 0;
+				magic_was_found = 3;
+			}
+		} else
+			reiserfs_exit(EXIT_USER,
+				      "We opened device but there is no magic "
+				      "and there is no correct superblock format found.");
+
+		if (magic_was_found == 1 || magic_was_found == 2)
+			standard_journal = 1;
+		else
+			standard_journal = 0;
+
+		if (version == 0)
+			version = what_fs_version();
+
+		if (get_sb_block_count(sb) != block_count) {
+			do {
+				printf("\nDid you use resizer(y/n)[n]: ");
+				getline(&answer, &n, stdin);
+			} while (strcmp("y\n", answer) &&
+				 strcmp("n\n", answer) && strcmp("\n", answer));
+
+			if (!strcmp("y\n", answer)) {
+				printf("\nEnter partition size [%lu]: ",
+				       block_count);
+				getline(&answer, &n, stdin);
+				if (strcmp("\n", answer))
+					block_count = atoi(answer);
+			} else {
+				fsck_conditional_log(magic_was_found,
+						     "rebuild-sb: wrong block count "
+						     "occured (%lu), fixed (%lu)\n",
+						     get_sb_block_count(sb),
+						     block_count);
+			}
+
+			set_sb_block_count(sb, block_count);
+		}
+
+		if (get_sb_block_size(sb) != fs->fs_blocksize) {
+			fsck_log
+			    ("rebuild-sb: wrong block size occured (%lu), fixed (%lu)\n",
+			     get_sb_block_size(sb), fs->fs_blocksize);
+			set_sb_block_size(sb, fs->fs_blocksize);
+		}
 	}
 
-        if (!(block_count = count_blocks (filename, fs->fs_blocksize)))
-		exit(EXIT_OPER);
-
-        /* save ondisk_sb somewhere and work in temp area */
-        ondisk_sb = fs->fs_ondisk_sb;
-        memcpy (sb, fs->fs_ondisk_sb, sizeof (*sb));
-        fs->fs_ondisk_sb = sb;
-
-        if (is_reiserfs_3_6_magic_string (sb)) {
-            /* 3_6 magic */
-            if (fsck_data (fs)->journal_dev_name)
-                /* journal dev must not be specified with standard journal */
-                reiserfs_exit (EXIT_USER, "ReiserFS with default journal "
-		    "is found, but there was specified a journal device.");
-
-            if (fs->fs_super_bh->b_blocknr ==
-		REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                version = 1;
-	    else if (fs->fs_super_bh->b_blocknr ==
-		REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                version = 3;
-	    
-            magic_was_found = 2;
-        } else if (is_reiserfs_3_5_magic_string (sb)) {
-            if (fsck_data (fs)->journal_dev_name)
-                /* journal dev must not be specified with standard journal */
-                reiserfs_exit (EXIT_USER, "ReiserFS with default journal "
-		    "is found, but there was specified a journal device.");
-
-            /* 3_5 magic */
-            if (fs->fs_super_bh->b_blocknr ==
-		REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                version = 2;
-	    else if (fs->fs_super_bh->b_blocknr ==
-		REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                version = 4;
-	    
-	    magic_was_found = 1;
-        } else if (is_reiserfs_jr_magic_string (sb)) {
-            if (!fsck_data (fs)->journal_dev_name && !fsck_skip_journal(fs))
-                /* journal dev must be specified with non standard journal */
-                reiserfs_exit (EXIT_USER, "ReiserFS with non default journal "
-		    "is found, but there was not specified any journal device.");
-
-            if (get_sb_version (sb) == REISERFS_FORMAT_3_6) {
-                /*non-standard magic + sb_format == 3_6*/
-		if (fs->fs_super_bh->b_blocknr ==
-		    REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                    version = 1;
-		else if (fs->fs_super_bh->b_blocknr == 
-		    REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                    version = 3;
-		
-                magic_was_found = 3;
-            } else if (get_sb_version (sb) == REISERFS_FORMAT_3_5) {
-                /* non-standard magic + sb_format == 3_5 */
-                if (fs->fs_super_bh->b_blocknr ==
-		    REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                    version = 2;
-		else if (fs->fs_super_bh->b_blocknr ==
-		    REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize)
-                    version = 4;
-		
-                magic_was_found = 3;
-            } else {
-                /* non-standard magic + bad sb_format */
-                version = 0;
-                magic_was_found = 3;
-            }
-        } else
-            reiserfs_exit (EXIT_USER, "We opened device but there is no magic "
-		"and there is no correct superblock format found.");
-
-        if (magic_was_found == 1 || magic_was_found == 2)
-            standard_journal = 1;
-        else
-            standard_journal = 0;
-
-        if (version == 0)
-            version = what_fs_version ();
-
-        if (get_sb_block_count (sb) != block_count) {
-            do {
-                printf("\nDid you use resizer(y/n)[n]: ");
-                getline (&answer, &n, stdin);
-            } while(strcmp ("y\n", answer) && 
-		    strcmp ("n\n", answer) && 
-		    strcmp ("\n", answer));
-
-            if (!strcmp ("y\n", answer)) {
-                printf("\nEnter partition size [%lu]: ", block_count);
-                getline (&answer, &n, stdin);
-                if (strcmp ("\n", answer))
-                    block_count = atoi (answer);
-            } else {
-                fsck_conditional_log (magic_was_found, "rebuild-sb: wrong block count "
-		    "occured (%lu), fixed (%lu)\n", get_sb_block_count(sb), block_count);
-            }
-
-	    set_sb_block_count (sb, block_count);
-        }
+	/* if no reiserfs_found or bad data found in that SB, what was checked in previous 
+	 * clause */
+	if (no_reiserfs_found(fs)) {
+		int fd;
 
-        if (get_sb_block_size (sb) != fs->fs_blocksize) {
-            fsck_log("rebuild-sb: wrong block size occured (%lu), fixed (%lu)\n", 
-		    get_sb_block_size (sb), fs->fs_blocksize);
-  	    set_sb_block_size (sb, fs->fs_blocksize);
-        }
-    }
+		fd = open(filename, O_RDWR | O_LARGEFILE);
 
-    /* if no reiserfs_found or bad data found in that SB, what was checked in previous 
-     * clause */
-    if (no_reiserfs_found (fs)) {
-        int fd;
+		if (fd == -1) {
+			reiserfs_exit(EXIT_OPER,
+				      "rebuils_sb: cannot open device %s",
+				      filename);
+		}
 
-        fd = open (filename, O_RDWR | O_LARGEFILE);
+		version = what_fs_version();
+
+		if (version == 3 || version == 4) {
+			retval = 4096;
+		} else {
+			printf("\nEnter block size [4096]: \n");
+			getline(&answer, &n, stdin);
+			if (strcmp(answer, "\n")) {
+				retval = (int)strtol(answer, &tmp, 0);
+				if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: wrong block size specified\n");
+				if (!is_blocksize_correct(retval))
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: wrong block size specified, "
+						      "only divisible by 1024 are supported currently\n");
+			} else
+				retval = 4096;
+		}
 
-        if (fd == -1) {
-            reiserfs_exit (EXIT_OPER, "rebuils_sb: cannot open device %s", 
-		filename);
-	}
+		if (!(block_count = count_blocks(filename, retval)))
+			exit(EXIT_OPER);
+
+		switch (version) {
+		case 1:
+			fs = reiserfs_create(filename, REISERFS_FORMAT_3_6,
+					     block_count, retval, 1, 1);
+			break;
+		case 2:
+			fs = reiserfs_create(filename, REISERFS_FORMAT_3_5,
+					     block_count, retval, 1, 1);
+			break;
+		case 3:
+			fs = reiserfs_create(filename, REISERFS_FORMAT_3_6,
+					     block_count, retval, 1, 0);
+			break;
+		case 4:
+			fs = reiserfs_create(filename, REISERFS_FORMAT_3_5,
+					     block_count, retval, 1, 0);
+			break;
+		}
 
-        version = what_fs_version ();
-
-        if (version == 3 || version == 4) {
-            retval = 4096;
-        } else {
-	    printf("\nEnter block size [4096]: \n");
-	    getline (&answer, &n, stdin);
-	    if (strcmp(answer, "\n")) {
-		retval = (int) strtol (answer, &tmp, 0);
-		if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
-		    reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified\n");
-		if (!is_blocksize_correct (retval))
-		    reiserfs_exit (EXIT_USER, "rebuild_sb: wrong block size specified, "
-			"only divisible by 1024 are supported currently\n");
-	    } else
-		retval = 4096;
-	}
+		if (fs == NULL)
+			return;
+
+		sb = fs->fs_ondisk_sb;
+		fs->fs_vp = data;
+
+		if (!fsck_skip_journal(fs)) {
+			if (!fsck_data(fs)->journal_dev_name) {
+				do {
+					printf
+					    ("\nNo journal device was specified. (If journal is not "
+					     "available, re-run with --no-journal-available option specified).\n"
+					     "Is journal default? (y/n)[y]: ");
+
+					getline(&answer, &n, stdin);
+				} while (strcmp("y\n", answer) &&
+					 strcmp("n\n", answer) &&
+					 strcmp("\n", answer));
+
+				if (!strcmp("n\n", answer)) {
+					printf
+					    ("\nSpecify journal device with -j option.\n");
+					exit(EXIT_USER);
+				}
+				standard_journal = 1;
+			} else {
+				standard_journal = 0;
+				memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+				       REISERFS_JR_SUPER_MAGIC_STRING,
+				       strlen(REISERFS_JR_SUPER_MAGIC_STRING));
+			}
+		}
 
-        if (!(block_count = count_blocks (filename, retval)))
-		exit(EXIT_OPER);
-
-        switch(version){
-        case 1:
-            fs = reiserfs_create (filename, REISERFS_FORMAT_3_6, block_count, retval, 1, 1);
-            break;
-        case 2:
-            fs = reiserfs_create (filename, REISERFS_FORMAT_3_5, block_count, retval, 1, 1);
-            break;
-        case 3:
-            fs = reiserfs_create (filename, REISERFS_FORMAT_3_6, block_count, retval, 1, 0);
-            break;
-        case 4:
-            fs = reiserfs_create (filename, REISERFS_FORMAT_3_5, block_count, retval, 1, 0);
-            break;
-        }
+		do {
+			printf("\nDid you use resizer(y/n)[n]: ");
+			getline(&answer, &n, stdin);
+		} while (strcmp("y\n", answer) && strcmp("n\n", answer)
+			 && strcmp("\n", answer));
+		if (!strcmp("y\n", answer)) {
+			printf("\nEnter partition size [%lu]: ", block_count);
+			getline(&answer, &n, stdin);
+			if (strcmp("\n", answer))
+				block_count = atoi(answer);
+			set_sb_block_count(sb, block_count);
+		}
 
-	if (fs == NULL)
-	    return;
-	
-        sb = fs->fs_ondisk_sb;
-        fs->fs_vp = data;
-
-        if (!fsck_skip_journal (fs)) {
-            if (!fsck_data (fs)->journal_dev_name) {
-                do {
-                    printf("\nNo journal device was specified. (If journal is not "
-			"available, re-run with --no-journal-available option specified).\n"
-                        "Is journal default? (y/n)[y]: ");
-		    
-                    getline (&answer, &n, stdin);
-                } while(strcmp ("y\n", answer) && 
-			strcmp ("n\n", answer) && 
-			strcmp ("\n", answer));
-		
-                if (!strcmp ("n\n", answer)) {
-                    printf("\nSpecify journal device with -j option.\n");
-                    exit(EXIT_USER);
-                }
-                standard_journal = 1;
-            } else {
-                standard_journal = 0;
-                memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING,
-                    strlen (REISERFS_JR_SUPER_MAGIC_STRING));
-            }
-        }
+		set_sb_fs_state(sb, FS_ERROR);
+	}
 
-        do {
-            printf("\nDid you use resizer(y/n)[n]: ");
-            getline (&answer, &n, stdin);
-        } while (strcmp ("y\n", answer) && strcmp ("n\n", answer) && strcmp ("\n", answer));
-        if (!strcmp ("y\n", answer)) {
-            printf("\nEnter partition size [%lu]: ", block_count);
-            getline (&answer, &n, stdin);
-            if (strcmp ("\n", answer))
-                block_count = atoi (answer);
-            set_sb_block_count (sb, block_count);
-        }
-	
-	set_sb_fs_state (sb, FS_ERROR);
-    }
+	if (version == 1 || version == 3) {
+		if (get_reiserfs_format(sb) != REISERFS_FORMAT_3_6) {
+			fsck_log
+			    ("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n",
+			     get_reiserfs_format(sb), REISERFS_FORMAT_3_6);
+			set_sb_version(sb, REISERFS_FORMAT_3_6);
+		}
+	} else if (version == 2 || version == 4) {
+		if (get_reiserfs_format(sb) != REISERFS_FORMAT_3_5) {
+			fsck_log
+			    ("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n",
+			     get_reiserfs_format(sb), REISERFS_FORMAT_3_5);
+			set_sb_version(sb, REISERFS_FORMAT_3_5);
+		}
+	}
 
+	p_oid_maxsize = (fs->fs_blocksize - reiserfs_super_block_size(sb)) /
+	    sizeof(__u32) / 2 * 2;
 
-    if (version == 1 || version == 3) {
-        if (get_reiserfs_format (sb) != REISERFS_FORMAT_3_6) {
-            fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n", 
-		    get_reiserfs_format (sb), REISERFS_FORMAT_3_6);
-            set_sb_version (sb, REISERFS_FORMAT_3_6);
-        }
-    } else if (version == 2 || version == 4) {
-        if (get_reiserfs_format (sb) != REISERFS_FORMAT_3_5) {
-            fsck_log("rebuild-sb: wrong reiserfs version occured (%lu), fixed (%lu)\n", 
-		    get_reiserfs_format (sb), REISERFS_FORMAT_3_5);
-            set_sb_version (sb, REISERFS_FORMAT_3_5);
-        }
-    }
+	if (get_sb_oid_maxsize(sb) != p_oid_maxsize) {
+		fsck_log
+		    ("rebuild-sb: wrong objectid map max size occured (%lu), fixed (%lu)\n",
+		     get_sb_oid_maxsize(sb), p_oid_maxsize);
+		set_sb_oid_maxsize(sb, p_oid_maxsize);
+	}
 
-    p_oid_maxsize = (fs->fs_blocksize - reiserfs_super_block_size (sb)) / 
-	sizeof(__u32) / 2 * 2;
-    
-    if (get_sb_oid_maxsize (sb) != p_oid_maxsize) {
-	fsck_log("rebuild-sb: wrong objectid map max size occured (%lu), fixed (%lu)\n", 
-		get_sb_oid_maxsize (sb), p_oid_maxsize);
-	set_sb_oid_maxsize (sb, p_oid_maxsize);
-    }
+	bmap_nr = reiserfs_fs_bmap_nr(fs);
+
+	if (reiserfs_bmap_over(bmap_nr) && get_sb_bmap_nr(sb) != 0) {
+		fsck_log
+		    ("rebuild-sb: wrong bitmap number occured (%u), fixed (0) "
+		     "(really %u)\n", get_sb_bmap_nr(sb), bmap_nr);
+		set_sb_bmap_nr(sb, 0);
+	} else if (get_sb_bmap_nr(sb) != bmap_nr) {
+		fsck_log("rebuild-sb: wrong bitmap number occured (%u), "
+			 "fixed (%u)\n", get_sb_bmap_nr(sb), bmap_nr);
+		set_sb_bmap_nr(sb, bmap_nr);
+	}
 
-    bmap_nr = reiserfs_fs_bmap_nr(fs);
+	if (get_sb_root_block(sb) > block_count) {
+		fsck_log("rebuild-sb: wrong root block occured (%lu), zeroed\n",
+			 get_sb_root_block(sb));
+		set_sb_root_block(sb, 0);
+	}
 
-    if (reiserfs_bmap_over(bmap_nr) && get_sb_bmap_nr(sb) != 0) {
-	fsck_log("rebuild-sb: wrong bitmap number occured (%u), fixed (0) "
-	         "(really %u)\n", get_sb_bmap_nr (sb), bmap_nr);
-	set_sb_bmap_nr (sb, 0);
-    } else if (get_sb_bmap_nr(sb) != bmap_nr) {
-	fsck_log("rebuild-sb: wrong bitmap number occured (%u), "
-		 "fixed (%u)\n", get_sb_bmap_nr (sb), bmap_nr);
-	set_sb_bmap_nr (sb, bmap_nr);
-    }
+	if (get_sb_free_blocks(sb) > block_count) {
+		fsck_log
+		    ("rebuild-sb: wrong free block count occured (%lu), zeroed\n",
+		     get_sb_free_blocks(sb));
+		set_sb_free_blocks(sb, 0);
+	}
 
-    if (get_sb_root_block (sb) > block_count) {
-	fsck_log("rebuild-sb: wrong root block occured (%lu), zeroed\n", 
-		get_sb_root_block (sb));
-	set_sb_root_block (sb, 0);
-    }
+	if (get_sb_umount_state(sb) != FS_CLEANLY_UMOUNTED &&
+	    get_sb_umount_state(sb) != FS_NOT_CLEANLY_UMOUNTED) {
+		fsck_conditional_log(magic_was_found,
+				     "rebuild-sb: wrong umount state (%u), "
+				     "fixed to (FS_NOT_CLEANLY_UMOUNTED)\n",
+				     get_sb_umount_state(sb));
+		set_sb_umount_state(sb, FS_NOT_CLEANLY_UMOUNTED);
+	}
 
-    if (get_sb_free_blocks (sb) > block_count) {
-	fsck_log ("rebuild-sb: wrong free block count occured (%lu), zeroed\n", 
-		get_sb_free_blocks (sb));
-        set_sb_free_blocks (sb, 0);
-    }
+	if (get_sb_oid_cursize(sb) == 1 ||
+	    get_sb_oid_cursize(sb) > get_sb_oid_maxsize(sb)) {
+		fsck_log
+		    ("rebuild-sb: wrong objectid map occured (%lu), zeroed\n",
+		     get_sb_oid_cursize(sb));
 
-    if (get_sb_umount_state (sb) != FS_CLEANLY_UMOUNTED && 
-	get_sb_umount_state (sb) != FS_NOT_CLEANLY_UMOUNTED) 
-    {
-	fsck_conditional_log (magic_was_found, "rebuild-sb: wrong umount state (%u), "
-	    "fixed to (FS_NOT_CLEANLY_UMOUNTED)\n", get_sb_umount_state (sb));
-        set_sb_umount_state (sb, FS_NOT_CLEANLY_UMOUNTED);
-    }
+		set_sb_oid_cursize(sb, 0);
+	}
 
-    if (get_sb_oid_cursize (sb) == 1 || 
-	get_sb_oid_cursize (sb) > get_sb_oid_maxsize (sb)) 
-    {
-        fsck_log("rebuild-sb: wrong objectid map occured (%lu), zeroed\n", 
-	    get_sb_oid_cursize (sb));
-	
-        set_sb_oid_cursize (sb, 0);
-    }
+	if (get_sb_tree_height(sb) &&
+	    ((get_sb_tree_height(sb) < DISK_LEAF_NODE_LEVEL + 1) ||
+	     (get_sb_tree_height(sb) > MAX_HEIGHT))) {
+		fsck_log("rebuild-sb: wrong tree height occured (%u), zeroed\n",
+			 get_sb_tree_height(sb));
 
-    if ( get_sb_tree_height (sb) &&
-        ((get_sb_tree_height (sb) < DISK_LEAF_NODE_LEVEL + 1) ||
-	(get_sb_tree_height (sb) > MAX_HEIGHT)) ) {
-	fsck_log("rebuild-sb: wrong tree height occured (%u), zeroed\n", 
-	    get_sb_tree_height (sb));
+		set_sb_tree_height(sb, 0);
+	}
 
-	set_sb_tree_height (sb, 0);
-    }
+	if (get_sb_hash_code(sb) && code2name(get_sb_hash_code(sb)) == 0) {
+		fsck_log("rebuild-sb: wrong hash occured (%lu), zeroed\n",
+			 get_sb_hash_code(sb));
 
-    if (get_sb_hash_code (sb) && code2name (get_sb_hash_code (sb)) == 0) {
-	fsck_log("rebuild-sb: wrong hash occured (%lu), zeroed\n", 
-	    get_sb_hash_code (sb));
-	
-	set_sb_hash_code (sb, 0);
-    }
+		set_sb_hash_code(sb, 0);
+	}
 
-    if (version == 1 || version == 3) {
+	if (version == 1 || version == 3) {
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-        if (uuid_is_null(sb->s_uuid)) {
-	    uuid_generate(sb->s_uuid);
-	    fsck_log ("rebuild-sb: no uuid found, a new uuid was "
-		      "generated (%U)\n", sb->s_uuid);
-        }
+		if (uuid_is_null(sb->s_uuid)) {
+			uuid_generate(sb->s_uuid);
+			fsck_log("rebuild-sb: no uuid found, a new uuid was "
+				 "generated (%U)\n", sb->s_uuid);
+		}
 #endif
-	if (sb->s_flags != 0 && sb->s_flags != 1) {
-	    fsck_log ("rebuild-sb: super block flags found (%u), zeroed\n",
-                  sb->s_flags);
-	    sb->s_flags = 0;
+		if (sb->s_flags != 0 && sb->s_flags != 1) {
+			fsck_log
+			    ("rebuild-sb: super block flags found (%u), zeroed\n",
+			     sb->s_flags);
+			sb->s_flags = 0;
+		}
 	}
-    }
 
+	/*
+	   if we have a standard journal
+	   reserved = 0
+	   dev - same
+	   size = journal_default_size(fs->fs_super_bh->b_blocknr, fs)
+	   offset = journal_default_size(fs)
+	   if we have a non standard journal
+	   if we found magic string
+	   try to find a jhead and comare dev, size, offset there
+	   if params are not equal move to "if we did not find a magic string" clause
+	   if we did not find a magic string
+	   ask user about his journal
+	   try to find a jhead and comare dev, size, offset there
+	   if params are not equal exit with error
+	 */
+
+	p_jp_journal_1st_block = get_journal_start_must(fs);
+
+	if (standard_journal == 1) {
+		if (get_jp_journal_dev(sb_jp(sb)) != 0) {
+			fsck_conditional_log(magic_was_found,
+					     "rebuild-sb: wrong journal device "
+					     "occured (%lu), fixed (0)\n",
+					     get_jp_journal_dev(sb_jp(sb)));
+			set_jp_journal_dev(sb_jp(sb), 0);
+		}
+		if (get_sb_reserved_for_journal(sb) != 0) {
+			fsck_log
+			    ("rebuild-sb: wrong size reserved for default journal occured "
+			     "(%lu), fixed (0)\n",
+			     get_sb_reserved_for_journal(sb));
+			set_sb_reserved_for_journal(sb, 0);
+		}
+		if (get_jp_journal_1st_block(sb_jp(sb)) !=
+		    p_jp_journal_1st_block) {
+			fsck_conditional_log(magic_was_found,
+					     "rebuild-sb: wrong journal first "
+					     "block occured (%lu), fixed (%lu)\n",
+					     get_jp_journal_1st_block(sb_jp
+								      (sb)),
+					     p_jp_journal_1st_block);
+
+			set_jp_journal_1st_block(sb_jp(sb),
+						 p_jp_journal_1st_block);
+		}
+		if (get_jp_journal_size(sb_jp(sb)) !=
+		    journal_default_size(fs->fs_super_bh->b_blocknr,
+					 fs->fs_blocksize)) {
+			fsck_conditional_log(magic_was_found,
+					     "rebuild-sb: wrong journal size "
+					     "occured (%lu), fixed (%lu)\n",
+					     get_jp_journal_size(sb_jp(sb)) + 1,
+					     journal_default_size(fs->
+								  fs_super_bh->
+								  b_blocknr,
+								  fs->
+								  fs_blocksize)
+					     + 1);
+
+			set_jp_journal_size(sb_jp(sb),
+					    journal_default_size(fs->
+								 fs_super_bh->
+								 b_blocknr,
+								 fs->
+								 fs_blocksize));
+		}
 
-    /*
-    if we have a standard journal
-        reserved = 0
-        dev - same
-        size = journal_default_size(fs->fs_super_bh->b_blocknr, fs)
-        offset = journal_default_size(fs)
-    if we have a non standard journal
-        if we found magic string
-            try to find a jhead and comare dev, size, offset there
-            if params are not equal move to "if we did not find a magic string" clause
-        if we did not find a magic string
-            ask user about his journal
-            try to find a jhead and comare dev, size, offset there
-            if params are not equal exit with error
-    */
-
-
-    p_jp_journal_1st_block = get_journal_start_must (fs);
-
-    if (standard_journal == 1) {
-	if (get_jp_journal_dev (sb_jp(sb)) != 0) {
- 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal device "
-		"occured (%lu), fixed (0)\n", get_jp_journal_dev (sb_jp(sb)));
- 	    set_jp_journal_dev (sb_jp(sb), 0);
-        }
-        if (get_sb_reserved_for_journal (sb) != 0) {
- 	    fsck_log ("rebuild-sb: wrong size reserved for default journal occured "
-		"(%lu), fixed (0)\n", get_sb_reserved_for_journal (sb));
-            set_sb_reserved_for_journal (sb, 0);
-        }
-        if (get_jp_journal_1st_block (sb_jp(sb)) != p_jp_journal_1st_block) {
-            fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal first "
-		"block occured (%lu), fixed (%lu)\n", get_jp_journal_1st_block (sb_jp(sb)),
-		p_jp_journal_1st_block);
-	    
-            set_jp_journal_1st_block (sb_jp(sb) , p_jp_journal_1st_block);
-        }
-        if (get_jp_journal_size (sb_jp(sb)) != 
-	    journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize)) 
-	{
- 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal size "
-		"occured (%lu), fixed (%lu)\n", get_jp_journal_size (sb_jp(sb)) + 1,
- 	        journal_default_size (fs->fs_super_bh->b_blocknr, 
-		fs->fs_blocksize) + 1);
-	    
-            set_jp_journal_size (sb_jp(sb), 
-		journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize));
-        }
+		if ((retval =
+		     reiserfs_open_journal(fs, filename,
+					   O_RDWR | O_LARGEFILE))) {
+			fsck_log
+			    ("\nrebuild-sb: Failed to open the journal device (%s).\n",
+			     filename);
 
-	if ((retval = reiserfs_open_journal(fs, filename, O_RDWR | O_LARGEFILE))) {
-	    fsck_log("\nrebuild-sb: Failed to open the journal device (%s).\n", 
-		filename);
-
-	    exit(retval < 0 ? EXIT_OPER : EXIT_USER);
-	}	
-    } else if (!fsck_skip_journal(fs)) {
-	/* Check that specified non-standard journal device exists. */
-	    
-	journal_dev_name = fsck_data (fs)->journal_dev_name;	    
-	retval = stat(journal_dev_name, &stat_buf);
-	    
-	if (retval == -1)
-	    reiserfs_exit (EXIT_USER, "rebuild_sb: error while detecting the "
-		"specified journal device (%s): %s\n", journal_dev_name,
-		strerror(errno));
-	
-	retval = 0;
-	if (magic_was_found) {
-	    /* Super block was found. Try to open the journal on the base of its 
-	     * journal parameters. */
-	    
-	    retval = reiserfs_open_journal(fs, journal_dev_name, 
-		O_RDWR | O_LARGEFILE);
-	    
-	    if (retval == 0) {
-		j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
-		retval = memcmp(&j_head->jh_journal, sb_jp(sb), 
-		    sizeof(struct journal_params));
-	    
-		if (retval) {
-		    /* journal parameters from the SB and from the J_Header does not 
-		     * match. Close the jouranl, ask the user about correct journal 
-		     * parameters. */
-		    reiserfs_close_journal(fs);
+			exit(retval < 0 ? EXIT_OPER : EXIT_USER);
+		}
+	} else if (!fsck_skip_journal(fs)) {
+		/* Check that specified non-standard journal device exists. */
+
+		journal_dev_name = fsck_data(fs)->journal_dev_name;
+		retval = stat(journal_dev_name, &stat_buf);
+
+		if (retval == -1)
+			reiserfs_exit(EXIT_USER,
+				      "rebuild_sb: error while detecting the "
+				      "specified journal device (%s): %s\n",
+				      journal_dev_name, strerror(errno));
+
+		retval = 0;
+		if (magic_was_found) {
+			/* Super block was found. Try to open the journal on the base of its 
+			 * journal parameters. */
+
+			retval = reiserfs_open_journal(fs, journal_dev_name,
+						       O_RDWR | O_LARGEFILE);
+
+			if (retval == 0) {
+				j_head =
+				    (struct reiserfs_journal_header *)(fs->
+								       fs_jh_bh->
+								       b_data);
+				retval =
+				    memcmp(&j_head->jh_journal, sb_jp(sb),
+					   sizeof(struct journal_params));
+
+				if (retval) {
+					/* journal parameters from the SB and from the J_Header does not 
+					 * match. Close the jouranl, ask the user about correct journal 
+					 * parameters. */
+					reiserfs_close_journal(fs);
+				}
+			}
+
+			if (!reiserfs_journal_opened(fs)) {
+				fsck_log
+				    ("Journal cannot be opened, assuming specified "
+				     "journal device is correct\n");
+			}
 		}
-	    }
 
-	    if (!reiserfs_journal_opened(fs)) {
-		fsck_log ("Journal cannot be opened, assuming specified "
-			  "journal device is correct\n");
-	    }
-	}
-	
-	if (!reiserfs_journal_opened(fs)) {
-	    __u64 default_value;
-
-	    /* journal was not found or SB and J_Header parameters does not match. */
-	    if (magic_was_found == 0)
-                default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ? 
-		    p_jp_journal_1st_block : 0;
-            else
-                default_value = get_jp_journal_1st_block (sb_jp(sb));
-
-            printf("\nEnter journal offset on %s in blocks [%Lu]: \n",
-            		journal_dev_name, (unsigned long long)default_value);
-
-            getline (&answer, &n, stdin);
-            if (strcmp(answer, "\n")) {
-                retval = (int) strtol (answer, &tmp, 0);
-                if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
-                    reiserfs_exit(EXIT_USER, "rebuild_sb: wrong offset specified\n");
-
-                set_jp_journal_1st_block (sb_jp(sb), retval);
-            } else
-                set_jp_journal_1st_block (sb_jp(sb), default_value);
-
-            if (!(p_jp_dev_size = count_blocks (journal_dev_name, fs->fs_blocksize)))
-		    exit(EXIT_OPER);
-
-            /* some checks for journal offset */
-            if (strcmp(fs->fs_file_name, journal_dev_name) != 0) {
-                if (p_jp_dev_size < get_jp_journal_1st_block (sb_jp(sb)) + 1)
-        	    reiserfs_exit(EXIT_USER, "rebuild_sb: offset is much than device size\n");
-            }
-
-            /* default size if magic was not found is device size - journal_1st_block;
-               default size if magic was found is found value + 1 block for journal 
-	       header */
-            if (magic_was_found == 0)
-                default_value = (!strcmp(fs->fs_file_name, journal_dev_name)) ?
-                    journal_default_size (fs->fs_super_bh->b_blocknr,
-					  fs->fs_blocksize) + 1 :
-                    p_jp_dev_size - get_jp_journal_1st_block (sb_jp(sb));
-            else
-                default_value = get_jp_journal_size (sb_jp(sb)) + 1;
-		
-
-            printf("\nEnter journal size (including 1 block for journal header) on "
-		"%s in blocks [%Lu]: \n", journal_dev_name, 
-		(unsigned long long)default_value);
-
-            getline (&answer, &n, stdin);
-            if (strcmp(answer, "\n")) {
-                retval = (int) strtol (answer, &tmp, 0);
-                if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
-        	    reiserfs_exit(EXIT_USER, "rebuild_sb: wrong offset specified\n");
-
-                set_jp_journal_size (sb_jp(sb), retval - 1);
-            } else {
-                set_jp_journal_size (sb_jp(sb), default_value - 1);
-            }
-
-            /* some checks for journal size */
-            if (get_jp_journal_size (sb_jp(sb)) +
-                get_jp_journal_1st_block (sb_jp(sb)) + 1 > p_jp_dev_size)
-        	    reiserfs_exit(EXIT_USER, "rebuild_sb: journal offset + journal size is "
-			"greater than device size\n");
-            
-	    /* some checks for journal size */
-            if (get_jp_journal_size (sb_jp(sb)) < JOURNAL_MIN_SIZE)
-        	    reiserfs_exit(EXIT_USER, "rebuild_sb: journal size cannot be less than "
-			"%lu blocks.\n", JOURNAL_MIN_SIZE + 1);
-
-	    if ((retval = reiserfs_open_journal(fs, journal_dev_name, 
-		O_RDWR | O_LARGEFILE)))
-	    {
-		fsck_log("\nrebuild-sb: Failed to open a journal device (%s).", 
-		    journal_dev_name);
-		
-		exit(retval < 0 ? EXIT_OPER : EXIT_USER);
-	    }
-	
-	    /* SB was found, but journal params were broken and have been recovered. 
-	     * Futher work goes as SB would not be found. */
-	    magic_was_found = 0;
-	}
-	
-	if (strcmp (fs->fs_file_name, journal_dev_name))
-	    set_jp_journal_dev (sb_jp(sb), stat_buf.st_rdev);
-	else
-	    set_jp_journal_dev (sb_jp(sb), 0);
+		if (!reiserfs_journal_opened(fs)) {
+			__u64 default_value;
+
+			/* journal was not found or SB and J_Header parameters does not match. */
+			if (magic_was_found == 0)
+				default_value =
+				    (!strcmp
+				     (fs->fs_file_name,
+				      journal_dev_name)) ?
+				    p_jp_journal_1st_block : 0;
+			else
+				default_value =
+				    get_jp_journal_1st_block(sb_jp(sb));
+
+			printf
+			    ("\nEnter journal offset on %s in blocks [%Lu]: \n",
+			     journal_dev_name,
+			     (unsigned long long)default_value);
+
+			getline(&answer, &n, stdin);
+			if (strcmp(answer, "\n")) {
+				retval = (int)strtol(answer, &tmp, 0);
+				if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: wrong offset specified\n");
+
+				set_jp_journal_1st_block(sb_jp(sb), retval);
+			} else
+				set_jp_journal_1st_block(sb_jp(sb),
+							 default_value);
+
+			if (!
+			    (p_jp_dev_size =
+			     count_blocks(journal_dev_name, fs->fs_blocksize)))
+				exit(EXIT_OPER);
+
+			/* some checks for journal offset */
+			if (strcmp(fs->fs_file_name, journal_dev_name) != 0) {
+				if (p_jp_dev_size <
+				    get_jp_journal_1st_block(sb_jp(sb)) + 1)
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: offset is much than device size\n");
+			}
+
+			/* default size if magic was not found is device size - journal_1st_block;
+			   default size if magic was found is found value + 1 block for journal 
+			   header */
+			if (magic_was_found == 0)
+				default_value =
+				    (!strcmp
+				     (fs->fs_file_name,
+				      journal_dev_name)) ?
+				    journal_default_size(fs->fs_super_bh->
+							 b_blocknr,
+							 fs->fs_blocksize) +
+				    1 : p_jp_dev_size -
+				    get_jp_journal_1st_block(sb_jp(sb));
+			else
+				default_value =
+				    get_jp_journal_size(sb_jp(sb)) + 1;
+
+			printf
+			    ("\nEnter journal size (including 1 block for journal header) on "
+			     "%s in blocks [%Lu]: \n", journal_dev_name,
+			     (unsigned long long)default_value);
+
+			getline(&answer, &n, stdin);
+			if (strcmp(answer, "\n")) {
+				retval = (int)strtol(answer, &tmp, 0);
+				if ((*tmp && strcmp(tmp, "\n")) || retval < 0)
+					reiserfs_exit(EXIT_USER,
+						      "rebuild_sb: wrong offset specified\n");
+
+				set_jp_journal_size(sb_jp(sb), retval - 1);
+			} else {
+				set_jp_journal_size(sb_jp(sb),
+						    default_value - 1);
+			}
+
+			/* some checks for journal size */
+			if (get_jp_journal_size(sb_jp(sb)) +
+			    get_jp_journal_1st_block(sb_jp(sb)) + 1 >
+			    p_jp_dev_size)
+				reiserfs_exit(EXIT_USER,
+					      "rebuild_sb: journal offset + journal size is "
+					      "greater than device size\n");
+
+			/* some checks for journal size */
+			if (get_jp_journal_size(sb_jp(sb)) < JOURNAL_MIN_SIZE)
+				reiserfs_exit(EXIT_USER,
+					      "rebuild_sb: journal size cannot be less than "
+					      "%lu blocks.\n",
+					      JOURNAL_MIN_SIZE + 1);
+
+			if ((retval =
+			     reiserfs_open_journal(fs, journal_dev_name,
+						   O_RDWR | O_LARGEFILE))) {
+				fsck_log
+				    ("\nrebuild-sb: Failed to open a journal device (%s).",
+				     journal_dev_name);
+
+				exit(retval < 0 ? EXIT_OPER : EXIT_USER);
+			}
+
+			/* SB was found, but journal params were broken and have been recovered. 
+			 * Futher work goes as SB would not be found. */
+			magic_was_found = 0;
+		}
 
-    } else {
-	fsck_log ("\nJournal was specified as not available. reiserfstune is "
-	    "needed.\n\n");
-	
-	set_jp_journal_magic (sb_jp(sb), NEED_TUNE);
-    }
+		if (strcmp(fs->fs_file_name, journal_dev_name))
+			set_jp_journal_dev(sb_jp(sb), stat_buf.st_rdev);
+		else
+			set_jp_journal_dev(sb_jp(sb), 0);
 
-    if (reiserfs_journal_opened(fs)) {
-	/* Journal was openned. Check/fix journal parameters and copy it the journal 
-	 * header. */
-	
-        if (get_jp_journal_max_trans_len (sb_jp(sb)) !=
-	    advise_journal_max_trans_len(   get_jp_journal_max_trans_len (sb_jp(sb)),
-					    get_jp_journal_size (sb_jp(sb)), 
-					    fs->fs_blocksize, 0))
-	{
- 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max "
-		"transaction length occured (%lu), fixed (%d)\n",
-		get_jp_journal_max_trans_len (sb_jp(sb)),
-		advise_journal_max_trans_len (	get_jp_journal_max_trans_len (sb_jp(sb)),
-        					get_jp_journal_size (sb_jp(sb)),
-        					fs->fs_blocksize, 0));
-	    
- 	    set_jp_journal_max_trans_len (sb_jp(sb),
- 	    	advise_journal_max_trans_len (	get_jp_journal_max_trans_len (sb_jp(sb)),
-						get_jp_journal_size (sb_jp(sb)),
- 	    					fs->fs_blocksize, 0));
-        }
-	
-        if (get_jp_journal_max_batch (sb_jp(sb)) != 
-	    advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb)))) 
-	{
- 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal max "
-		"batch size occured (%lu), fixed (%d)\n", 
-		get_jp_journal_max_batch (sb_jp(sb)), 
-		advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
-	    
- 	    set_jp_journal_max_batch (sb_jp(sb), 
-		advise_journal_max_batch(get_jp_journal_max_trans_len (sb_jp(sb))));
-        }
+	} else {
+		fsck_log
+		    ("\nJournal was specified as not available. reiserfstune is "
+		     "needed.\n\n");
 
-        if (get_jp_journal_max_commit_age (sb_jp(sb)) != 
-	    advise_journal_max_commit_age()) 
-	{
- 	    fsck_conditional_log (magic_was_found, "rebuild-sb: wrong journal "
-		"max commit age occured (%lu), fixed (%d)\n", 
- 	        get_jp_journal_max_commit_age (sb_jp(sb)), advise_journal_max_commit_age());
-	    
- 	    set_jp_journal_max_commit_age (sb_jp(sb), advise_journal_max_commit_age());
-        }
-	
-        if (get_jp_journal_max_trans_age (sb_jp(sb)) != advise_journal_max_trans_age()) {
- 	    fsck_log ("rebuild-sb: wrong journal  max commit age occured (%u), "
-		"fixed (%u)\n", get_jp_journal_max_trans_age (sb_jp(sb)), 
-		advise_journal_max_trans_age());
-	    
- 	    set_jp_journal_max_trans_age (sb_jp(sb), advise_journal_max_trans_age());
-        }
-		
-	j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
-
-	if (standard_journal == 0) {
-	    if (get_jp_journal_magic (sb_jp(sb)) == 0 || 
-		get_jp_journal_magic (sb_jp(sb)) == NEED_TUNE) 
-	    {
-		int magic;
-		
-		magic = random();
-		fsck_log ("rebuild-sb: genarate the new journal magic (%d)\n", magic);
-		set_jp_journal_magic (sb_jp(sb), magic);
-		set_jp_journal_magic (&j_head->jh_journal, magic);
-
-	    }
+		set_jp_journal_magic(sb_jp(sb), NEED_TUNE);
 	}
-	
-	retval = memcmp(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
-	
-	if (retval) {
-	    if (standard_journal == 1) {
-		fsck_log("\nrebuild-sb: You either have a corrupted journal or have just "
-		    "changed\nthe start of the partition with some partition table editor. "
-		    "If you are\nsure that the start of the partition is ok, rebuild the "
-		    "journal header.\n");
-	    } else if (!magic_was_found) {
-		fsck_log("\nrebuild-sb: journal header is not found. You either have "
-		    "a corrupted,\nbad configured(device/offset/size), not available "
-		    "journal or have just changed\nthe start of the journal partition "
-		    "with some partition table editor. In the \ncase of corrupted "
-		    "journal you need to use --no-journal-available. If you are\n"
-		    "sure that the start of the partition is ok and journal is "
-		    "available, rebuild\nthe journal header.\n");
-	    }
-	    
-	    if (standard_journal || !magic_was_found) {
-		if (!user_confirmed (stdout, "Do you want to rebuild the journal header? "
-		    "(y/n)[n]: ", "y\n"))
-		{
-		    exit(EXIT_USER);
-		} else 
-		    exit_code = EXIT_FIXED;
-	    }
-	    
-	    memcpy(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
-	    mark_buffer_dirty(fs->fs_jh_bh);
-	    bwrite (fs->fs_jh_bh);
-	}
-    }
-    
-    /*  whether journal header contains params with the same dev, offset, size will be 
-	checked in open_journal */
 
-    if (version == 1 || version == 3)
-        sb_size = SB_SIZE;
-    else
-        sb_size = SB_SIZE_V1;
+	if (reiserfs_journal_opened(fs)) {
+		/* Journal was openned. Check/fix journal parameters and copy it the journal 
+		 * header. */
+
+		if (get_jp_journal_max_trans_len(sb_jp(sb)) !=
+		    advise_journal_max_trans_len(get_jp_journal_max_trans_len
+						 (sb_jp(sb)),
+						 get_jp_journal_size(sb_jp(sb)),
+						 fs->fs_blocksize, 0)) {
+			fsck_conditional_log(magic_was_found,
+					     "rebuild-sb: wrong journal max "
+					     "transaction length occured (%lu), fixed (%d)\n",
+					     get_jp_journal_max_trans_len(sb_jp
+									  (sb)),
+					     advise_journal_max_trans_len
+					     (get_jp_journal_max_trans_len
+					      (sb_jp(sb)),
+					      get_jp_journal_size(sb_jp(sb)),
+					      fs->fs_blocksize, 0));
+
+			set_jp_journal_max_trans_len(sb_jp(sb),
+						     advise_journal_max_trans_len
+						     (get_jp_journal_max_trans_len
+						      (sb_jp(sb)),
+						      get_jp_journal_size(sb_jp
+									  (sb)),
+						      fs->fs_blocksize, 0));
+		}
 
-    if (ondisk_sb == NULL || 
-	memcmp(ondisk_sb, sb, sb_size - ((sb_size == SB_SIZE) ? 
-	    sizeof(fs->fs_ondisk_sb->s_unused) : 0))) 
-    {
-        /* smth was changed in SB or a new one has been built */
-	set_sb_fs_state (sb, get_sb_fs_state (sb) | FS_ERROR);
-	
-	if (ondisk_sb) {
-	    /* if super_block was found, we keep sb in ondisk_sb */
-	    fs->fs_ondisk_sb = ondisk_sb;
-	    memcpy (ondisk_sb, sb, sb_size);
-	    freemem(sb);
+		if (get_jp_journal_max_batch(sb_jp(sb)) !=
+		    advise_journal_max_batch(get_jp_journal_max_trans_len
+					     (sb_jp(sb)))) {
+			fsck_conditional_log(magic_was_found,
+					     "rebuild-sb: wrong journal max "
+					     "batch size occured (%lu), fixed (%d)\n",
+					     get_jp_journal_max_batch(sb_jp
+								      (sb)),
+					     advise_journal_max_batch
+					     (get_jp_journal_max_trans_len
+					      (sb_jp(sb))));
+
+			set_jp_journal_max_batch(sb_jp(sb),
+						 advise_journal_max_batch
+						 (get_jp_journal_max_trans_len
+						  (sb_jp(sb))));
+		}
+
+		if (get_jp_journal_max_commit_age(sb_jp(sb)) !=
+		    advise_journal_max_commit_age()) {
+			fsck_conditional_log(magic_was_found,
+					     "rebuild-sb: wrong journal "
+					     "max commit age occured (%lu), fixed (%d)\n",
+					     get_jp_journal_max_commit_age(sb_jp
+									   (sb)),
+					     advise_journal_max_commit_age());
+
+			set_jp_journal_max_commit_age(sb_jp(sb),
+						      advise_journal_max_commit_age
+						      ());
+		}
+
+		if (get_jp_journal_max_trans_age(sb_jp(sb)) !=
+		    advise_journal_max_trans_age()) {
+			fsck_log
+			    ("rebuild-sb: wrong journal  max commit age occured (%u), "
+			     "fixed (%u)\n",
+			     get_jp_journal_max_trans_age(sb_jp(sb)),
+			     advise_journal_max_trans_age());
+
+			set_jp_journal_max_trans_age(sb_jp(sb),
+						     advise_journal_max_trans_age
+						     ());
+		}
+
+		j_head =
+		    (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
+
+		if (standard_journal == 0) {
+			if (get_jp_journal_magic(sb_jp(sb)) == 0 ||
+			    get_jp_journal_magic(sb_jp(sb)) == NEED_TUNE) {
+				int magic;
+
+				magic = random();
+				fsck_log
+				    ("rebuild-sb: genarate the new journal magic (%d)\n",
+				     magic);
+				set_jp_journal_magic(sb_jp(sb), magic);
+				set_jp_journal_magic(&j_head->jh_journal,
+						     magic);
+
+			}
+		}
+
+		retval =
+		    memcmp(&j_head->jh_journal, sb_jp(sb),
+			   sizeof(struct journal_params));
+
+		if (retval) {
+			if (standard_journal == 1) {
+				fsck_log
+				    ("\nrebuild-sb: You either have a corrupted journal or have just "
+				     "changed\nthe start of the partition with some partition table editor. "
+				     "If you are\nsure that the start of the partition is ok, rebuild the "
+				     "journal header.\n");
+			} else if (!magic_was_found) {
+				fsck_log
+				    ("\nrebuild-sb: journal header is not found. You either have "
+				     "a corrupted,\nbad configured(device/offset/size), not available "
+				     "journal or have just changed\nthe start of the journal partition "
+				     "with some partition table editor. In the \ncase of corrupted "
+				     "journal you need to use --no-journal-available. If you are\n"
+				     "sure that the start of the partition is ok and journal is "
+				     "available, rebuild\nthe journal header.\n");
+			}
+
+			if (standard_journal || !magic_was_found) {
+				if (!user_confirmed
+				    (stdout,
+				     "Do you want to rebuild the journal header? "
+				     "(y/n)[n]: ", "y\n")) {
+					exit(EXIT_USER);
+				} else
+					exit_code = EXIT_FIXED;
+			}
+
+			memcpy(&j_head->jh_journal, sb_jp(sb),
+			       sizeof(struct journal_params));
+			mark_buffer_dirty(fs->fs_jh_bh);
+			bwrite(fs->fs_jh_bh);
+		}
 	}
 
-	fflush(stdout); 
-	print_block (stderr, fs, fs->fs_super_bh);
-	
-	if (user_confirmed (stderr, "Is this ok ? (y/n)[n]: ", "y\n")) {
-	    mark_buffer_uptodate (fs->fs_super_bh, 1);
-	    mark_buffer_dirty (fs->fs_super_bh);
-	    bwrite (fs->fs_super_bh);
-	    fsck_progress ("The fs may still be unconsistent. Run reiserfsck --check.\n\n");
-	    exit_code = EXIT_FIXED;
+	/*  whether journal header contains params with the same dev, offset, size will be 
+	   checked in open_journal */
+
+	if (version == 1 || version == 3)
+		sb_size = SB_SIZE;
+	else
+		sb_size = SB_SIZE_V1;
+
+	if (ondisk_sb == NULL ||
+	    memcmp(ondisk_sb, sb, sb_size - ((sb_size == SB_SIZE) ?
+					     sizeof(fs->fs_ondisk_sb->
+						    s_unused) : 0))) {
+		/* smth was changed in SB or a new one has been built */
+		set_sb_fs_state(sb, get_sb_fs_state(sb) | FS_ERROR);
+
+		if (ondisk_sb) {
+			/* if super_block was found, we keep sb in ondisk_sb */
+			fs->fs_ondisk_sb = ondisk_sb;
+			memcpy(ondisk_sb, sb, sb_size);
+			freemem(sb);
+		}
+
+		fflush(stdout);
+		print_block(stderr, fs, fs->fs_super_bh);
+
+		if (user_confirmed(stderr, "Is this ok ? (y/n)[n]: ", "y\n")) {
+			mark_buffer_uptodate(fs->fs_super_bh, 1);
+			mark_buffer_dirty(fs->fs_super_bh);
+			bwrite(fs->fs_super_bh);
+			fsck_progress
+			    ("The fs may still be unconsistent. Run reiserfsck --check.\n\n");
+			exit_code = EXIT_FIXED;
+		} else {
+			mark_buffer_clean(fs->fs_super_bh);
+			fsck_progress("Super block was not written\n");
+		}
 	} else {
-	    mark_buffer_clean (fs->fs_super_bh);
-	    fsck_progress ("Super block was not written\n");
+		print_block(stderr, fs, fs->fs_super_bh);
+
+		mark_buffer_clean(fs->fs_super_bh);
+		fsck_progress("\nSuper block seems to be correct\n\n");
 	}
-    } else {
-	print_block (stderr, fs, fs->fs_super_bh);
-	
-	mark_buffer_clean (fs->fs_super_bh);
-	fsck_progress ("\nSuper block seems to be correct\n\n");
-    }
 
-    exit(exit_code);
+	exit(exit_code);
 }
 
 /*	if (version == 0) {
diff --git a/fsck/ubitmap.c b/fsck/ubitmap.c
index 5d1e70a..03d7415 100644
--- a/fsck/ubitmap.c
+++ b/fsck/ubitmap.c
@@ -40,151 +40,90 @@
       
  */
 
-
-
 /* is blocks used (marked by 1 in new bitmap) in the tree which is being built
    (as leaf, internal, bitmap, or unformatted node) */
-int is_block_used (unsigned long block)
+int is_block_used(unsigned long block)
 {
-    return reiserfs_bitmap_test_bit (fsck_new_bitmap (fs), block);
+	return reiserfs_bitmap_test_bit(fsck_new_bitmap(fs), block);
 }
 
-void mark_block_used (unsigned long block, int check_hardware)
+void mark_block_used(unsigned long block, int check_hardware)
 {
-    if (!block)
-	return;
-    if (is_block_used (block)) {
-	if (check_hardware)
-	    check_memory_msg();
-	die ("mark_block_used: (%lu) used already", block);
-    }
-
-    reiserfs_bitmap_set_bit (fsck_new_bitmap (fs), block);
+	if (!block)
+		return;
+	if (is_block_used(block)) {
+		if (check_hardware)
+			check_memory_msg();
+		die("mark_block_used: (%lu) used already", block);
+	}
+
+	reiserfs_bitmap_set_bit(fsck_new_bitmap(fs), block);
 }
 
-
-void mark_block_free (unsigned long block)
+void mark_block_free(unsigned long block)
 {
-    if (!is_block_used (block))
-	die ("mark_block_free: (%lu) is free already", block);
+	if (!is_block_used(block))
+		die("mark_block_free: (%lu) is free already", block);
 
-    reiserfs_bitmap_clear_bit (fsck_new_bitmap (fs), block);
+	reiserfs_bitmap_clear_bit(fsck_new_bitmap(fs), block);
 }
 
-
-int is_block_uninsertable (unsigned long block)
+int is_block_uninsertable(unsigned long block)
 {
-    return !reiserfs_bitmap_test_bit (fsck_uninsertables (fs), block);
+	return !reiserfs_bitmap_test_bit(fsck_uninsertables(fs), block);
 }
 
-
 /* uninsertable block is marked by bit clearing */
-void mark_block_uninsertable (unsigned long block)
+void mark_block_uninsertable(unsigned long block)
 {
-    if (is_block_uninsertable (block))
-	die ("mark_block_uninsertable: (%lu) is uninsertable already", block);
+	if (is_block_uninsertable(block))
+		die("mark_block_uninsertable: (%lu) is uninsertable already",
+		    block);
 
-    reiserfs_bitmap_clear_bit (fsck_uninsertables (fs), block);
-    /* we do not need thsi actually */
-    pass_1_stat (fs)->uninsertable_leaves ++;
+	reiserfs_bitmap_clear_bit(fsck_uninsertables(fs), block);
+	/* we do not need thsi actually */
+	pass_1_stat(fs)->uninsertable_leaves++;
 }
 
-
 /* FIXME: should be able to work around no disk space */
-int reiserfsck_reiserfs_new_blocknrs (reiserfs_filsys_t * fs,
-				      unsigned long * free_blocknrs,
-				      unsigned long start, int amount_needed)
+int reiserfsck_reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
+				     unsigned long *free_blocknrs,
+				     unsigned long start, int amount_needed)
 {
-    int i;
-
-    if (!are_there_allocable_blocks (amount_needed))
-	die ("out of disk space");
-    for (i = 0; i < amount_needed; i ++) {
-	free_blocknrs[i] = alloc_block ();
-	if (!free_blocknrs[i])
-	    die ("reiserfs_new_blocknrs: 0 is allocated");
-	mark_block_used (free_blocknrs[i], 0);
-    }
-    return CARRY_ON;
+	int i;
+
+	if (!are_there_allocable_blocks(amount_needed))
+		die("out of disk space");
+	for (i = 0; i < amount_needed; i++) {
+		free_blocknrs[i] = alloc_block();
+		if (!free_blocknrs[i])
+			die("reiserfs_new_blocknrs: 0 is allocated");
+		mark_block_used(free_blocknrs[i], 0);
+	}
+	return CARRY_ON;
 }
 
-
 // FIXME: do you check readability of a block? If f_read fails - you
 // free block in bitmap or if you mark bad blocks used to avoid their
 // allocation in future you should have bad block counter in a super
 // block. Another minor issue: users of _get_new_buffer expect buffer
 // to be filled with 0s
-struct buffer_head * reiserfsck_get_new_buffer (unsigned long start)
+struct buffer_head *reiserfsck_get_new_buffer(unsigned long start)
 {
-    unsigned long blocknr = 0;
-    struct buffer_head * bh = NULL;
+	unsigned long blocknr = 0;
+	struct buffer_head *bh = NULL;
 
-    reiserfs_new_blocknrs (fs, &blocknr, start, 1);
-    bh = getblk (fs->fs_dev, blocknr, fs->fs_blocksize);
-    return bh;
+	reiserfs_new_blocknrs(fs, &blocknr, start, 1);
+	bh = getblk(fs->fs_dev, blocknr, fs->fs_blocksize);
+	return bh;
 }
 
-
 /* free block in new bitmap */
-int reiserfsck_reiserfs_free_block (reiserfs_filsys_t * fs, unsigned long block)
+int reiserfsck_reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block)
 {
-    mark_block_free (block);
+	mark_block_free(block);
 
-    /* put it back to pool of blocks for allocation */
-    make_allocable (block);
-    return 0;
+	/* put it back to pool of blocks for allocation */
+	make_allocable(block);
+	return 0;
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/fsck/ufile.c b/fsck/ufile.c
index 88c664c..548ac88 100644
--- a/fsck/ufile.c
+++ b/fsck/ufile.c
@@ -5,66 +5,72 @@
 
 #include "fsck.h"
 
-static int do_items_have_the_same_type (struct item_head * ih, struct reiserfs_key *key)
+static int do_items_have_the_same_type(struct item_head *ih,
+				       struct reiserfs_key *key)
 {
-    return (get_type (&ih->ih_key) == get_type (key)) ? 1 : 0;
+	return (get_type(&ih->ih_key) == get_type(key)) ? 1 : 0;
 }
 
-static int are_items_in_the_same_node (struct reiserfs_path *path)
+static int are_items_in_the_same_node(struct reiserfs_path *path)
 {
-  return (PATH_LAST_POSITION (path) < B_NR_ITEMS (PATH_PLAST_BUFFER (path)) - 1) ? 1 : 0;
+	return (PATH_LAST_POSITION(path) <
+		B_NR_ITEMS(PATH_PLAST_BUFFER(path)) - 1) ? 1 : 0;
 }
 
-static void cut_last_unfm_pointer (struct reiserfs_path *path, struct item_head * ih)
+static void cut_last_unfm_pointer(struct reiserfs_path *path,
+				  struct item_head *ih)
 {
-    set_ih_free_space(ih, 0);
-    if (I_UNFM_NUM (ih) == 1)
-	reiserfsck_delete_item (path, 0);
-    else
-	reiserfsck_cut_from_item (path, -((int)UNFM_P_SIZE));
+	set_ih_free_space(ih, 0);
+	if (I_UNFM_NUM(ih) == 1)
+		reiserfsck_delete_item(path, 0);
+	else
+		reiserfsck_cut_from_item(path, -((int)UNFM_P_SIZE));
 }
 
 /*
     if this is not a symlink - make it of_this_size;
     otherwise find a size and return it in symlink_size;
 */
-static unsigned long indirect_to_direct (struct reiserfs_path *path, __u64 len, int symlink)
+static unsigned long indirect_to_direct(struct reiserfs_path *path, __u64 len,
+					int symlink)
 {
-    struct buffer_head * bh = PATH_PLAST_BUFFER (path);
-    struct item_head * ih = PATH_PITEM_HEAD (path);
-    __u32 unfm_ptr;
-    struct buffer_head * unfm_bh = 0;
-    struct item_head ins_ih;
-    char * buf;
-    char bad_drct[fs->fs_blocksize];
-
-    /* direct item to insert */
-    memset (&ins_ih, 0, sizeof (ins_ih));
-    if (symlink) {
-	set_ih_key_format (&ins_ih, KEY_FORMAT_1);
-    } else {
-	set_ih_key_format (&ins_ih, get_ih_key_format (ih));
-    }
-    set_key_dirid (&ins_ih.ih_key, get_key_dirid (&ih->ih_key));
-    set_key_objectid (&ins_ih.ih_key, get_key_objectid (&ih->ih_key));
-    set_type_and_offset (get_ih_key_format (&ins_ih), &ins_ih.ih_key,
-			 get_offset (&ih->ih_key) + (I_UNFM_NUM (ih) - 1) * bh->b_size, 
-			 TYPE_DIRECT);
-
-    // we do not know what length this item should be
-    unfm_ptr = d32_get ((__u32 *)get_item (path), I_UNFM_NUM (ih) - 1);
-    if (unfm_ptr && (unfm_bh = bread (bh->b_dev, unfm_ptr, bh->b_size))) {
-        /* we can read the block */
-	buf = unfm_bh->b_data;
-	
-    } else {
-        /* we cannot read the block */
- 	if (unfm_ptr)
-	    fsck_log ("indirect_to_direct: Reading of the block (%lu), pointed to by the file %K, failed\n", 
-		unfm_ptr, &ih->ih_key);
-	memset (bad_drct, 0, fs->fs_blocksize);
-	buf = bad_drct;
-    }
+	struct buffer_head *bh = PATH_PLAST_BUFFER(path);
+	struct item_head *ih = PATH_PITEM_HEAD(path);
+	__u32 unfm_ptr;
+	struct buffer_head *unfm_bh = 0;
+	struct item_head ins_ih;
+	char *buf;
+	char bad_drct[fs->fs_blocksize];
+
+	/* direct item to insert */
+	memset(&ins_ih, 0, sizeof(ins_ih));
+	if (symlink) {
+		set_ih_key_format(&ins_ih, KEY_FORMAT_1);
+	} else {
+		set_ih_key_format(&ins_ih, get_ih_key_format(ih));
+	}
+	set_key_dirid(&ins_ih.ih_key, get_key_dirid(&ih->ih_key));
+	set_key_objectid(&ins_ih.ih_key, get_key_objectid(&ih->ih_key));
+	set_type_and_offset(get_ih_key_format(&ins_ih), &ins_ih.ih_key,
+			    get_offset(&ih->ih_key) + (I_UNFM_NUM(ih) -
+						       1) * bh->b_size,
+			    TYPE_DIRECT);
+
+	// we do not know what length this item should be
+	unfm_ptr = d32_get((__u32 *) get_item(path), I_UNFM_NUM(ih) - 1);
+	if (unfm_ptr && (unfm_bh = bread(bh->b_dev, unfm_ptr, bh->b_size))) {
+		/* we can read the block */
+		buf = unfm_bh->b_data;
+
+	} else {
+		/* we cannot read the block */
+		if (unfm_ptr)
+			fsck_log
+			    ("indirect_to_direct: Reading of the block (%lu), pointed to by the file %K, failed\n",
+			     unfm_ptr, &ih->ih_key);
+		memset(bad_drct, 0, fs->fs_blocksize);
+		buf = bad_drct;
+	}
 /*
     if (len > MAX_DIRECT_ITEM_LEN (fs->fs_blocksize)) {
 	fsck_log ("indirect_to_direct: canot create such a long item %d (%K), "
@@ -77,24 +83,28 @@ static unsigned long indirect_to_direct (struct reiserfs_path *path, __u64 len,
 	len = strlen (bad_link);
     }
 */
-    set_ih_item_len (&ins_ih, (get_ih_key_format (ih) == KEY_FORMAT_2) ? ROUND_UP(len) : len);
-    set_ih_free_space (&ins_ih, MAX_US_INT);
-
-    mark_ih_become_tail(ih);
-    mark_buffer_dirty(bh);
-    // last last unformatted node pointer
-    path->pos_in_item = I_UNFM_NUM (ih) - 1;
-    cut_last_unfm_pointer (path, ih);
-
-    /* insert direct item */
-    if (reiserfs_search_by_key_4 (fs, &(ins_ih.ih_key), path) == ITEM_FOUND)
-	reiserfs_panic ("indirect_to_direct: The direct item %k should not exist yet.", &(ins_ih.ih_key));
-    reiserfsck_insert_item (path, &ins_ih, (const char *)(buf));
-
-    brelse (unfm_bh);
-
-    /* put to stat data offset of first byte in direct item */
-    return get_offset (&ins_ih.ih_key); //offset;
+	set_ih_item_len(&ins_ih,
+			(get_ih_key_format(ih) ==
+			 KEY_FORMAT_2) ? ROUND_UP(len) : len);
+	set_ih_free_space(&ins_ih, MAX_US_INT);
+
+	mark_ih_become_tail(ih);
+	mark_buffer_dirty(bh);
+	// last last unformatted node pointer
+	path->pos_in_item = I_UNFM_NUM(ih) - 1;
+	cut_last_unfm_pointer(path, ih);
+
+	/* insert direct item */
+	if (reiserfs_search_by_key_4(fs, &(ins_ih.ih_key), path) == ITEM_FOUND)
+		reiserfs_panic
+		    ("indirect_to_direct: The direct item %k should not exist yet.",
+		     &(ins_ih.ih_key));
+	reiserfsck_insert_item(path, &ins_ih, (const char *)(buf));
+
+	brelse(unfm_bh);
+
+	/* put to stat data offset of first byte in direct item */
+	return get_offset(&ins_ih.ih_key);	//offset;
 }
 
 /*  start_key is the key after which N items need to be deleted
@@ -102,264 +112,355 @@ static unsigned long indirect_to_direct (struct reiserfs_path *path, __u64 len,
     start_key is the first undeleted item.
     return whether we are sure there is nothing else of this file
  */
-int delete_N_items_after_key(struct reiserfs_key *start_key, struct si ** save_here, int skip_dir_items, int n_to_delete) {
-    struct reiserfs_path path;
+int delete_N_items_after_key(struct reiserfs_key *start_key,
+			     struct si **save_here, int skip_dir_items,
+			     int n_to_delete)
+{
+	struct reiserfs_path path;
 //    struct reiserfs_key key = *start_key;
-    struct reiserfs_key *rkey;
-    int count = 0;
+	struct reiserfs_key *rkey;
+	int count = 0;
+
+	while (1) {
+		reiserfs_search_by_key_4(fs, start_key, &path);
+
+		if (get_item_pos(&path) == B_NR_ITEMS(get_bh(&path))) {
+			rkey = uget_rkey(&path);
+			if (rkey && !not_of_one_file(start_key, rkey)) {
+				/* file continues in the right neighbor */
+				copy_key(start_key, rkey);
+				pathrelse(&path);
+				continue;
+			}
+			/* there is no more items with this key */
+			pathrelse(&path);
+			return 1;
+		}
 
-    while (1) {
-	reiserfs_search_by_key_4 (fs, start_key, &path);
-	
-	if (get_item_pos (&path) == B_NR_ITEMS (get_bh (&path))) {
-	    rkey = uget_rkey (&path);
-	    if (rkey && !not_of_one_file (start_key, rkey)) {
-		/* file continues in the right neighbor */
-		copy_key (start_key, rkey);
-		pathrelse (&path);
-		continue;
-	    }
-	    /* there is no more items with this key */
-	    pathrelse (&path);
-	    return 1;
-	}
+		if (is_stat_data_ih(get_ih(&path)))
+			fix_obviously_wrong_sd_mode(&path);
 
-	if (is_stat_data_ih (get_ih(&path)))
-	    fix_obviously_wrong_sd_mode (&path);
-	    	
-	rkey = &(get_ih (&path))->ih_key;
-	if (not_of_one_file (start_key, rkey)) {
-	    /* there are no more item with this key */
-	    pathrelse (&path);
-	    return 1;
-	}
+		rkey = &(get_ih(&path))->ih_key;
+		if (not_of_one_file(start_key, rkey)) {
+			/* there are no more item with this key */
+			pathrelse(&path);
+			return 1;
+		}
 
-	copy_key (start_key, rkey);
-	/* ok, item found, but make sure that it is not a directory one */
-	if ((is_stat_data_key (rkey) && !not_a_directory (get_item (&path))) ||
-	    (is_direntry_key (rkey)))
-	{
-	    if (skip_dir_items) {
-	    	/* item of directory found. Leave it in the tree */
-	    	set_offset (KEY_FORMAT_1, start_key, get_offset (start_key) + 1);
-	    	pathrelse (&path);
-	    	continue;
-	    } else {
-	    	reiserfs_panic ("delete_N_items_after_key: No directory item of %K are "
-		    "expected", start_key);
-	    }
-	}
-	if (save_here != NULL)
-	    *save_here = save_and_delete_file_item (*save_here, &path);
-	else
-	    reiserfsck_delete_item (&path, 0);
+		copy_key(start_key, rkey);
+		/* ok, item found, but make sure that it is not a directory one */
+		if ((is_stat_data_key(rkey)
+		     && !not_a_directory(get_item(&path)))
+		    || (is_direntry_key(rkey))) {
+			if (skip_dir_items) {
+				/* item of directory found. Leave it in the tree */
+				set_offset(KEY_FORMAT_1, start_key,
+					   get_offset(start_key) + 1);
+				pathrelse(&path);
+				continue;
+			} else {
+				reiserfs_panic
+				    ("delete_N_items_after_key: No directory item of %K are "
+				     "expected", start_key);
+			}
+		}
+		if (save_here != NULL)
+			*save_here =
+			    save_and_delete_file_item(*save_here, &path);
+		else
+			reiserfsck_delete_item(&path, 0);
 
-     	count++;
+		count++;
 
-    	if (count == n_to_delete)
-	    break;
+		if (count == n_to_delete)
+			break;
 
-	pathrelse (&path);
-    }
+		pathrelse(&path);
+	}
 
-    return 0;
+	return 0;
 }
 
 /* returns 1 when file looks correct, -1 if directory items appeared
    there, 0 - only holes in the file found */
 /* when it returns, key->k_offset is offset of the last item of file */
 /* sd_size is zero if we do not need to convert any indirect to direct */
-int are_file_items_correct (struct item_head * sd_ih, void * sd, __u64 * size, __u32 * blocks,
-				int mark_passed_items, int * symlink)
+int are_file_items_correct(struct item_head *sd_ih, void *sd, __u64 * size,
+			   __u32 * blocks, int mark_passed_items, int *symlink)
 {
-    struct reiserfs_path path;
-    struct item_head * ih;
-    struct reiserfs_key *next_key, * key;
-    __u32 sd_first_direct_byte = 0;
-    __u64 sd_size;
-    unsigned int i;
-    int retval, was_tail = 0;
-    int had_direct = 0;
-    int key_version = get_ih_key_format (sd_ih);
-    int next_is_another_object = 0;
-    __u64 last_unfm_offset = 0;
-    int will_convert = 0;
-    int should_convert;
-
-    should_convert = (fsck_mode (fs) != FSCK_REBUILD) || mark_passed_items;
-    key = &sd_ih->ih_key;
-    get_sd_size (sd_ih, sd, &sd_size);
-
-    if (key_version == KEY_FORMAT_1)
-    	get_sd_first_direct_byte (sd_ih, sd, &sd_first_direct_byte);
-
-    set_offset (key_version, key, 1);
-    set_type (key_version, key, TYPE_DIRECT);
-
-    /* correct size and st_blocks */
-    *size = 0;
-    *blocks = 0;
-
-    path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
-
-    do {
-	retval = usearch_by_position (fs, key, key_version, &path);
-	if (retval == POSITION_FOUND && path.pos_in_item != 0)
-	    die ("are_file_items_correct: All bytes we look for must be first items byte (position 0).");
-
-	switch (retval) {
-	case POSITION_FOUND:/**/
-
-	    ih = PATH_PITEM_HEAD (&path);
-
-	    if (ih_was_tail (ih)) {
-	    	was_tail = 1;
-	    }
-	
-	    set_type (key_version, key, get_type (&ih->ih_key));
-	
-	    if (mark_passed_items == 1) {
-		mark_item_reachable (ih, PATH_PLAST_BUFFER (&path));
-	    }
-	
-	    // does not change path
-	    next_key = reiserfs_next_key(&path);
-
-	    if (next_key == 0 || not_of_one_file (key, next_key) || 
-		(!is_indirect_key (next_key) && !is_direct_key(next_key))) 
-	    {
-		next_is_another_object = 1;
-		will_convert = (is_indirect_ih (ih) && sd_size && (I_UNFM_NUM (ih) > 0));
-		if (will_convert) {
-		    last_unfm_offset = get_offset (key) + fs->fs_blocksize * (I_UNFM_NUM (ih) - 1);
-		    /* if symlink or
-		       [ 1. sd_size points somewhere into last unfm block
-		         2. one item of the file was direct before for 3_6 || FDB points to the tail correctly for 3_5
-		         3. we can have a tail in the file of a such size ] */
-		    will_convert = will_convert && (sd_size >= last_unfm_offset) && 
-			(sd_size < last_unfm_offset + fs->fs_blocksize) && 
-			!STORE_TAIL_IN_UNFM (sd_size, sd_size - last_unfm_offset + 1, fs->fs_blocksize);
-		    
-		    will_convert = will_convert && (*symlink || ((key_version == KEY_FORMAT_1) && 
-			(sd_first_direct_byte == last_unfm_offset)) || ((key_version == KEY_FORMAT_2) && was_tail));
-		}
-	    }
+	struct reiserfs_path path;
+	struct item_head *ih;
+	struct reiserfs_key *next_key, *key;
+	__u32 sd_first_direct_byte = 0;
+	__u64 sd_size;
+	unsigned int i;
+	int retval, was_tail = 0;
+	int had_direct = 0;
+	int key_version = get_ih_key_format(sd_ih);
+	int next_is_another_object = 0;
+	__u64 last_unfm_offset = 0;
+	int will_convert = 0;
+	int should_convert;
+
+	should_convert = (fsck_mode(fs) != FSCK_REBUILD) || mark_passed_items;
+	key = &sd_ih->ih_key;
+	get_sd_size(sd_ih, sd, &sd_size);
+
+	if (key_version == KEY_FORMAT_1)
+		get_sd_first_direct_byte(sd_ih, sd, &sd_first_direct_byte);
+
+	set_offset(key_version, key, 1);
+	set_type(key_version, key, TYPE_DIRECT);
+
+	/* correct size and st_blocks */
+	*size = 0;
+	*blocks = 0;
+
+	path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
+
+	do {
+		retval = usearch_by_position(fs, key, key_version, &path);
+		if (retval == POSITION_FOUND && path.pos_in_item != 0)
+			die("are_file_items_correct: All bytes we look for must be first items byte (position 0).");
+
+		switch (retval) {
+		case POSITION_FOUND:
+			/**/ ih = PATH_PITEM_HEAD(&path);
+
+			if (ih_was_tail(ih)) {
+				was_tail = 1;
+			}
 
-	    if (should_convert) {
-		*symlink = *symlink && (will_convert || is_direct_key(&ih->ih_key));
-	    
-		if (!(*symlink) && key_version != get_ih_key_format (ih)) {
-		    if (fsck_mode(fs) == FSCK_CHECK) {
-			fsck_log("are_file_items_correct: vpf-10250: block %lu, item (%d): The item format (%H)"\
-			    " is not equal to SD format (%d)\n",
-			    get_bh(&path)->b_blocknr, PATH_LAST_POSITION(&path), ih, key_version);
-			one_more_corruption (fs, FIXABLE);
-		    } else {
-			fsck_log("are_file_items_correct: vpf-10280: block %lu, item (%d): The item format (%H)"\
-			    " is not equal to SD format (%d) - fixed.\n",
-			    get_bh(&path)->b_blocknr, PATH_LAST_POSITION(&path), ih, key_version);
-		
-
-			set_type_and_offset (key_version, &ih->ih_key, get_offset (&ih->ih_key), get_type (&ih->ih_key));
-			set_ih_key_format(ih, key_version);
-			mark_buffer_dirty(get_bh(&path));
-		    }
-		}
+			set_type(key_version, key, get_type(&ih->ih_key));
 
-		if (*symlink && is_direct_key(&ih->ih_key)) {
-		    /* symlink. Check that it is of KEY_FORMAT_1 */
-		    if (fsck_mode(fs) == FSCK_CHECK) {
-			if ((get_ih_key_format(ih) != KEY_FORMAT_1) || (key_format(&ih->ih_key) != KEY_FORMAT_1)) {
-			    fsck_log("are_file_items_correct: vpf-10732: block %lu, item (%d): The symlink format (%H)"\
-				" is not equal to 3.5 format (%d)\n", get_bh(&path)->b_blocknr, PATH_LAST_POSITION(&path), 
-				ih, KEY_FORMAT_1);
-			    one_more_corruption (fs, FIXABLE);
+			if (mark_passed_items == 1) {
+				mark_item_reachable(ih,
+						    PATH_PLAST_BUFFER(&path));
 			}
-		    } else {
-			if ((get_ih_key_format(ih) != KEY_FORMAT_1) || (key_format(&ih->ih_key) != KEY_FORMAT_1)) {
-			    fsck_log("are_file_items_correct: vpf-10732: block %lu, item (%d): The symlink format (%H)"\
-				" is not equal to 3.5 format (%d)\n", get_bh(&path)->b_blocknr, PATH_LAST_POSITION(&path), 
-				ih, KEY_FORMAT_1);
-			    set_type_and_offset(KEY_FORMAT_1, &ih->ih_key, get_offset(&ih->ih_key), get_type(&ih->ih_key));
-			    set_ih_key_format(ih, KEY_FORMAT_1);
-			    mark_buffer_dirty(get_bh(&path));
+			// does not change path
+			next_key = reiserfs_next_key(&path);
+
+			if (next_key == 0 || not_of_one_file(key, next_key) ||
+			    (!is_indirect_key(next_key)
+			     && !is_direct_key(next_key))) {
+				next_is_another_object = 1;
+				will_convert = (is_indirect_ih(ih) && sd_size
+						&& (I_UNFM_NUM(ih) > 0));
+				if (will_convert) {
+					last_unfm_offset =
+					    get_offset(key) +
+					    fs->fs_blocksize * (I_UNFM_NUM(ih) -
+								1);
+					/* if symlink or
+					   [ 1. sd_size points somewhere into last unfm block
+					   2. one item of the file was direct before for 3_6 || FDB points to the tail correctly for 3_5
+					   3. we can have a tail in the file of a such size ] */
+					will_convert = will_convert
+					    && (sd_size >= last_unfm_offset)
+					    && (sd_size <
+						last_unfm_offset +
+						fs->fs_blocksize)
+					    && !STORE_TAIL_IN_UNFM(sd_size,
+								   sd_size -
+								   last_unfm_offset
+								   + 1,
+								   fs->
+								   fs_blocksize);
+
+					will_convert = will_convert && (*symlink
+									||
+									((key_version == KEY_FORMAT_1) && (sd_first_direct_byte == last_unfm_offset)) || ((key_version == KEY_FORMAT_2) && was_tail));
+				}
 			}
-			
-		    }
-		}
-		
-		if (will_convert)
-		    *size = sd_size;
-		else
-		    *size = get_offset (&ih->ih_key) + get_bytes_number (ih, fs->fs_blocksize) - 1;
-	    
-		if (get_type (&ih->ih_key) == TYPE_INDIRECT) {
-		    if (*symlink) /* symlinks must be calculated as dirs */
-			*blocks = dir_size2st_blocks (*size);
-		    else
-			for (i = 0; i < I_UNFM_NUM (ih); i ++) {
-			    __u32 * ind = (__u32 *)get_item(&path);
-
-			    if (d32_get(ind, i) != 0)
-				*blocks += (fs->fs_blocksize >> 9);
+
+			if (should_convert) {
+				*symlink = *symlink && (will_convert
+							|| is_direct_key(&ih->
+									 ih_key));
+
+				if (!(*symlink)
+				    && key_version != get_ih_key_format(ih)) {
+					if (fsck_mode(fs) == FSCK_CHECK) {
+						fsck_log
+						    ("are_file_items_correct: vpf-10250: block %lu, item (%d): The item format (%H)"
+						     " is not equal to SD format (%d)\n",
+						     get_bh(&path)->b_blocknr,
+						     PATH_LAST_POSITION(&path),
+						     ih, key_version);
+						one_more_corruption(fs,
+								    FIXABLE);
+					} else {
+						fsck_log
+						    ("are_file_items_correct: vpf-10280: block %lu, item (%d): The item format (%H)"
+						     " is not equal to SD format (%d) - fixed.\n",
+						     get_bh(&path)->b_blocknr,
+						     PATH_LAST_POSITION(&path),
+						     ih, key_version);
+
+						set_type_and_offset(key_version,
+								    &ih->ih_key,
+								    get_offset
+								    (&ih->
+								     ih_key),
+								    get_type
+								    (&ih->
+								     ih_key));
+						set_ih_key_format(ih,
+								  key_version);
+						mark_buffer_dirty(get_bh
+								  (&path));
+					}
+				}
+
+				if (*symlink && is_direct_key(&ih->ih_key)) {
+					/* symlink. Check that it is of KEY_FORMAT_1 */
+					if (fsck_mode(fs) == FSCK_CHECK) {
+						if ((get_ih_key_format(ih) !=
+						     KEY_FORMAT_1)
+						    || (key_format(&ih->ih_key)
+							!= KEY_FORMAT_1)) {
+							fsck_log
+							    ("are_file_items_correct: vpf-10732: block %lu, item (%d): The symlink format (%H)"
+							     " is not equal to 3.5 format (%d)\n",
+							     get_bh(&path)->
+							     b_blocknr,
+							     PATH_LAST_POSITION
+							     (&path), ih,
+							     KEY_FORMAT_1);
+							one_more_corruption(fs,
+									    FIXABLE);
+						}
+					} else {
+						if ((get_ih_key_format(ih) !=
+						     KEY_FORMAT_1)
+						    || (key_format(&ih->ih_key)
+							!= KEY_FORMAT_1)) {
+							fsck_log
+							    ("are_file_items_correct: vpf-10732: block %lu, item (%d): The symlink format (%H)"
+							     " is not equal to 3.5 format (%d)\n",
+							     get_bh(&path)->
+							     b_blocknr,
+							     PATH_LAST_POSITION
+							     (&path), ih,
+							     KEY_FORMAT_1);
+							set_type_and_offset
+							    (KEY_FORMAT_1,
+							     &ih->ih_key,
+							     get_offset(&ih->
+									ih_key),
+							     get_type(&ih->
+								      ih_key));
+							set_ih_key_format(ih,
+									  KEY_FORMAT_1);
+							mark_buffer_dirty(get_bh
+									  (&path));
+						}
+
+					}
+				}
+
+				if (will_convert)
+					*size = sd_size;
+				else
+					*size =
+					    get_offset(&ih->ih_key) +
+					    get_bytes_number(ih,
+							     fs->fs_blocksize) -
+					    1;
+
+				if (get_type(&ih->ih_key) == TYPE_INDIRECT) {
+					if (*symlink)	/* symlinks must be calculated as dirs */
+						*blocks =
+						    dir_size2st_blocks(*size);
+					else
+						for (i = 0; i < I_UNFM_NUM(ih);
+						     i++) {
+							__u32 *ind =
+							    (__u32 *)
+							    get_item(&path);
+
+							if (d32_get(ind, i) !=
+							    0)
+								*blocks +=
+								    (fs->
+								     fs_blocksize
+								     >> 9);
+						}
+				} else if (get_type(&ih->ih_key) == TYPE_DIRECT) {
+					if (*symlink)	/* symlinks must be calculated as dirs */
+						*blocks =
+						    dir_size2st_blocks(*size);
+					else if (!had_direct)
+						*blocks +=
+						    (fs->fs_blocksize >> 9);
+
+					/* calculate only the first direct byte */
+					had_direct++;
+				}
 			}
-		} else if (get_type (&ih->ih_key) == TYPE_DIRECT) {
-		    if (*symlink) /* symlinks must be calculated as dirs */
-			*blocks = dir_size2st_blocks (*size);
-		    else if (!had_direct)
-			*blocks += (fs->fs_blocksize >> 9);
-
-		    /* calculate only the first direct byte */
-		    had_direct++;
-		}
-	    }
 
-	    if (next_is_another_object) 
-            {
-		/* next item does not exists or is of another object,
-                   therefore all items of file are correct */
-		if (will_convert) {
-		    if (fsck_mode (fs) == FSCK_CHECK) {
-			/* here it can be symlink only */
-			fsck_log ("are_file_items_correct: The indirect item should be converted back"
-			    " to direct %K\n", &ih->ih_key);
-			one_more_corruption (fs, FIXABLE);
-			pathrelse (&path);
-		    } else {
-			__u32 * ind = (__u32 *)get_item(&path);
-			/*   DEBUG message.
-			fsck_log ("are_file_items_correct: The indirect item is converted back to direct %K\n", &ih->ih_key);
-			*/
-			if (d32_get(ind, I_UNFM_NUM (ih) - 1) == 0)
-			    *blocks += (fs->fs_blocksize >> 9);
-
-			/* path is released here. */
-			sd_first_direct_byte = indirect_to_direct (&path, sd_size - last_unfm_offset + 1, *symlink);
-			/* last item of the file is direct item */
-			set_offset (key_version, key, sd_first_direct_byte);
-			set_type (key_version, key, TYPE_DIRECT);
-		    }
-		} else 
-		    pathrelse (&path);
-		
-		return 1;
-	    }
+			if (next_is_another_object) {
+				/* next item does not exists or is of another object,
+				   therefore all items of file are correct */
+				if (will_convert) {
+					if (fsck_mode(fs) == FSCK_CHECK) {
+						/* here it can be symlink only */
+						fsck_log
+						    ("are_file_items_correct: The indirect item should be converted back"
+						     " to direct %K\n",
+						     &ih->ih_key);
+						one_more_corruption(fs,
+								    FIXABLE);
+						pathrelse(&path);
+					} else {
+						__u32 *ind =
+						    (__u32 *) get_item(&path);
+						/*   DEBUG message.
+						   fsck_log ("are_file_items_correct: The indirect item is converted back to direct %K\n", &ih->ih_key);
+						 */
+						if (d32_get
+						    (ind,
+						     I_UNFM_NUM(ih) - 1) == 0)
+							*blocks +=
+							    (fs->
+							     fs_blocksize >> 9);
+
+						/* path is released here. */
+						sd_first_direct_byte =
+						    indirect_to_direct(&path,
+								       sd_size -
+								       last_unfm_offset
+								       + 1,
+								       *symlink);
+						/* last item of the file is direct item */
+						set_offset(key_version, key,
+							   sd_first_direct_byte);
+						set_type(key_version, key,
+							 TYPE_DIRECT);
+					}
+				} else
+					pathrelse(&path);
+
+				return 1;
+			}
 
-	    /* next item is item of this file */
-	    if (get_offset (&ih->ih_key) + get_bytes_number(ih, fs->fs_blocksize) != get_offset (next_key))
-	    {		
-		/* next item has incorrect offset (hole or overlapping) */
-		pathrelse (&path);
-		return 0;
-	    }
-	    if (do_items_have_the_same_type (ih, next_key) == 1 && are_items_in_the_same_node (&path) == 1) 
-	    {
-		/* two indirect items or two direct items in the same leaf. FIXME: Second will be deleted */
-		pathrelse (&path);
-		return 0;
-	    }
+			/* next item is item of this file */
+			if (get_offset(&ih->ih_key) +
+			    get_bytes_number(ih,
+					     fs->fs_blocksize) !=
+			    get_offset(next_key)) {
+				/* next item has incorrect offset (hole or overlapping) */
+				pathrelse(&path);
+				return 0;
+			}
+			if (do_items_have_the_same_type(ih, next_key) == 1
+			    && are_items_in_the_same_node(&path) == 1) {
+				/* two indirect items or two direct items in the same leaf. FIXME: Second will be deleted */
+				pathrelse(&path);
+				return 0;
+			}
 
-	    /* items are of different types or are in different nodes */
+			/* items are of different types or are in different nodes */
 /*
 	    if (get_offset (&ih->ih_key) + get_bytes_number (ih, fs->fs_blocksize) != get_offset (next_key))
             {
@@ -375,481 +476,543 @@ int are_file_items_correct (struct item_head * sd_ih, void * sd, __u64 * size, _
         	}
 	    }
 */
-	    /* next item exists */
-	    set_type_and_offset(key_version, key, get_offset (next_key), get_type(next_key));
-	
-	    if (comp_keys (key, next_key))
-		reiserfs_panic ("are_file_items_correct: Internal tree is in inconsistent state, "
-		    "the current item key %K and the next key %K must match", key, next_key);
-	    pathrelse (&path);
-	    break;
-
-	case POSITION_NOT_FOUND:
-	    /* We always must have next key found. Exception is first byte. It does not have to exist */
-	    if (get_offset (key) != 1)
-		reiserfs_panic ("are_file_items_correct: Position (offset == %llu) in the middle of"
-		    "the file %K was not found.", get_offset(key), key);
-	    pathrelse (&path);
-	    return 0;
-      
-	case FILE_NOT_FOUND:
-	    if (get_offset (key) != 1)
-		reiserfs_panic ("are_file_items_correct: File %K must be found as we found its StatData.", key);
-	    pathrelse (&path);
-	    return 1;
-
-	case DIRECTORY_FOUND:
-	    pathrelse (&path);
-	    return -1;
-	}
-    } while (1);
+			/* next item exists */
+			set_type_and_offset(key_version, key,
+					    get_offset(next_key),
+					    get_type(next_key));
+
+			if (comp_keys(key, next_key))
+				reiserfs_panic
+				    ("are_file_items_correct: Internal tree is in inconsistent state, "
+				     "the current item key %K and the next key %K must match",
+				     key, next_key);
+			pathrelse(&path);
+			break;
+
+		case POSITION_NOT_FOUND:
+			/* We always must have next key found. Exception is first byte. It does not have to exist */
+			if (get_offset(key) != 1)
+				reiserfs_panic
+				    ("are_file_items_correct: Position (offset == %llu) in the middle of"
+				     "the file %K was not found.",
+				     get_offset(key), key);
+			pathrelse(&path);
+			return 0;
+
+		case FILE_NOT_FOUND:
+			if (get_offset(key) != 1)
+				reiserfs_panic
+				    ("are_file_items_correct: File %K must be found as we found its StatData.",
+				     key);
+			pathrelse(&path);
+			return 1;
+
+		case DIRECTORY_FOUND:
+			pathrelse(&path);
+			return -1;
+		}
+	} while (1);
 
-    die ("are_file_items_correct: Cannot reach here");
-    return 0;
+	die("are_file_items_correct: Cannot reach here");
+	return 0;
 }
 
-
 /* delete all items and put them back (after that file should have
    correct sequence of items.
    if should_relocate is specified then it relocates items to a new id.
    if should_change_ih is specified then the key in ih is changed also. */
-void rewrite_file (struct item_head * ih, int should_relocate, int should_change_ih)
+void rewrite_file(struct item_head *ih, int should_relocate,
+		  int should_change_ih)
 {
-    struct reiserfs_key key;
-    struct si * si;
-    __u32 new_objectid = 0;
-    int moved_items;
-    struct reiserfs_key old, new;
-    int nothing_else = 0;
-
-    /* starting with the leftmost one - look for all items of file,
-       store and delete and  */
-    key = ih->ih_key;
-    set_type_and_offset (KEY_FORMAT_1, &key, SD_OFFSET, TYPE_STAT_DATA);
-
-    si = 0;
-    nothing_else = 0;
-
-    nothing_else = delete_N_items_after_key (&key, &si, should_relocate /* do not skip dir items */, 10);
-
-    if (should_relocate && (si || should_change_ih)) {
-	/* get new objectid for relocation or get objectid with which file
-	   was relocated already */
-	new_objectid = objectid_for_relocation (&ih->ih_key);
-	if (should_change_ih)
-	    set_key_objectid (&ih->ih_key, new_objectid);
-	
-	if (si) {
-	   old = si->si_ih.ih_key;
-	   set_key_objectid (&(si->si_ih.ih_key), new_objectid);
-	   new = si->si_ih.ih_key;
+	struct reiserfs_key key;
+	struct si *si;
+	__u32 new_objectid = 0;
+	int moved_items;
+	struct reiserfs_key old, new;
+	int nothing_else = 0;
+
+	/* starting with the leftmost one - look for all items of file,
+	   store and delete and  */
+	key = ih->ih_key;
+	set_type_and_offset(KEY_FORMAT_1, &key, SD_OFFSET, TYPE_STAT_DATA);
+
+	si = 0;
+	nothing_else = 0;
+
+	nothing_else =
+	    delete_N_items_after_key(&key, &si,
+				     should_relocate /* do not skip dir items */
+				     , 10);
+
+	if (should_relocate && (si || should_change_ih)) {
+		/* get new objectid for relocation or get objectid with which file
+		   was relocated already */
+		new_objectid = objectid_for_relocation(&ih->ih_key);
+		if (should_change_ih)
+			set_key_objectid(&ih->ih_key, new_objectid);
+
+		if (si) {
+			old = si->si_ih.ih_key;
+			set_key_objectid(&(si->si_ih.ih_key), new_objectid);
+			new = si->si_ih.ih_key;
+		}
 	}
-    }
 
-    moved_items = 0;
+	moved_items = 0;
 
-    while (si) {
-        while (si && (nothing_else || si->si_next)) {
-            if (should_relocate) {
-	    	set_key_objectid (&(si->si_ih.ih_key), new_objectid);
-	    	moved_items ++;
-	    }
+	while (si) {
+		while (si && (nothing_else || si->si_next)) {
+			if (should_relocate) {
+				set_key_objectid(&(si->si_ih.ih_key),
+						 new_objectid);
+				moved_items++;
+			}
 
-	    insert_item_separately (&(si->si_ih), si->si_dnm_data, 1/*was in tree*/);
-	    si = remove_saved_item (si);
+			insert_item_separately(&(si->si_ih), si->si_dnm_data,
+					       1 /*was in tree */ );
+			si = remove_saved_item(si);
+		}
+		if (!nothing_else)
+			nothing_else =
+			    delete_N_items_after_key(&key, &si,
+						     should_relocate
+						     /* do not skip dir items */
+						     , 10);
 	}
-	if (!nothing_else)
-	    nothing_else = delete_N_items_after_key (&key, &si, should_relocate /* do not skip dir items */, 10);
-    }
 
-    if (moved_items)
-	fsck_log ("rewrite_file: %d items of file %K moved to %K\n",
-	      moved_items, &old, &new);
+	if (moved_items)
+		fsck_log("rewrite_file: %d items of file %K moved to %K\n",
+			 moved_items, &old, &new);
 
 }
 
 /* file must have correct sequence of items and tail must be stored in
    unformatted pointer;
    pos in bh is a position of SD */
-static int make_file_writeable (struct buffer_head * bh, int pos)
+static int make_file_writeable(struct buffer_head *bh, int pos)
 /* struct item_head * sd_ih, void * sd */
 {
-    struct item_head *sd_ih = B_N_PITEM_HEAD (bh, pos);
-    struct item_head  sd_ih_copy;
-    struct stat_data *sd = (struct stat_data *)B_N_PITEM (bh, pos);
-    struct stat_data  sd_copy;
-    __u64 size;
-    __u32 blocks;
-    __u16 mode;
-    int   retval, symlink;
-
-    sd_ih_copy = *sd_ih;
-    memcpy (&sd_copy, sd, get_ih_item_len (sd_ih));
-    get_sd_mode (sd_ih, sd, &mode);
-    symlink = S_ISLNK(mode);
-
-    if (ih_writable(sd_ih))
-	return 1;
-    else {
-    	mark_ih_writable(sd_ih);
-	mark_buffer_dirty (bh);
-    }
+	struct item_head *sd_ih = B_N_PITEM_HEAD(bh, pos);
+	struct item_head sd_ih_copy;
+	struct stat_data *sd = (struct stat_data *)B_N_PITEM(bh, pos);
+	struct stat_data sd_copy;
+	__u64 size;
+	__u32 blocks;
+	__u16 mode;
+	int retval, symlink;
 
-    retval = are_file_items_correct (&sd_ih_copy, &sd_copy, &size, &blocks, 0/*do not mark accessed*/, &symlink);
-    if (retval == 1)
-	/* file looks correct */
-	return 1;
+	sd_ih_copy = *sd_ih;
+	memcpy(&sd_copy, sd, get_ih_item_len(sd_ih));
+	get_sd_mode(sd_ih, sd, &mode);
+	symlink = S_ISLNK(mode);
 
-    rewrite_file (sd_ih, 0, 0);
-    /*fsck_data (fs)->rebuild.rewritten ++;*/
+	if (ih_writable(sd_ih))
+		return 1;
+	else {
+		mark_ih_writable(sd_ih);
+		mark_buffer_dirty(bh);
+	}
+
+	retval =
+	    are_file_items_correct(&sd_ih_copy, &sd_copy, &size, &blocks,
+				   0 /*do not mark accessed */ , &symlink);
+	if (retval == 1)
+		/* file looks correct */
+		return 1;
+
+	rewrite_file(sd_ih, 0, 0);
+	/*fsck_data (fs)->rebuild.rewritten ++; */
 
 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
-    size = 0;
+	size = 0;
 
-    if (are_file_items_correct (&sd_ih_copy, &sd_copy, &size, &blocks, 0/*do not mark accessed*/, &symlink) == 0) {
-	fsck_log("WARNING: file was rewritten but still is not correct %K\n", &sd_ih->ih_key);
-	return -1;
-    }
+	if (are_file_items_correct
+	    (&sd_ih_copy, &sd_copy, &size, &blocks,
+	     0 /*do not mark accessed */ , &symlink) == 0) {
+		fsck_log
+		    ("WARNING: file was rewritten but still is not correct %K\n",
+		     &sd_ih->ih_key);
+		return -1;
+	}
 
 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/
 
-    return 1;
+	return 1;
 }
 
-
 /* this inserts __first__ indirect item (having k_offset == 1 and only
    one unfm pointer) into tree */
-static int create_first_item_of_file (struct item_head * ih, char * item, struct reiserfs_path *path, int was_in_tree)
+static int create_first_item_of_file(struct item_head *ih, char *item,
+				     struct reiserfs_path *path,
+				     int was_in_tree)
 {
-    __u32 unfm_ptr;
-    __u32 * ni = 0;
-    struct buffer_head * unbh;
-    struct item_head indih;
-    unsigned int i;
-    int retval;
-
-    mark_item_unreachable (&indih);
-
-    copy_key (&(indih.ih_key), &(ih->ih_key));
-    set_ih_item_len (&indih, UNFM_P_SIZE);
-
-    set_ih_free_space (&indih, 0);
-    if (get_offset (&ih->ih_key) > fs->fs_blocksize) {
-	/* insert indirect item containing 0 unfm pointer */
-	unfm_ptr = 0;
-	retval = 0;
-    } else {
-	if (is_direct_ih (ih)) {
-	    /* copy direct item to new unformatted node. Save information about it */
-	    int len = get_bytes_number (ih, fs->fs_blocksize);
-
-	    unbh = reiserfsck_get_new_buffer (PATH_PLAST_BUFFER (path)->b_blocknr);
-	    memset (unbh->b_data, 0, unbh->b_size);
-	    unfm_ptr = cpu_to_le32 (unbh->b_blocknr);
-	    memcpy (unbh->b_data + get_offset (&ih->ih_key) - 1, item, len);
-
-	    set_ih_free_space (&indih, fs->fs_blocksize - 
-			       len - (get_offset (&ih->ih_key) - 1));
-	    
-	    mark_ih_was_tail (&indih);
-	    mark_buffer_dirty (unbh);
-	    mark_buffer_uptodate (unbh, 1);
-	    brelse (unbh);
-
-	    retval = len;
+	__u32 unfm_ptr;
+	__u32 *ni = 0;
+	struct buffer_head *unbh;
+	struct item_head indih;
+	unsigned int i;
+	int retval;
+
+	mark_item_unreachable(&indih);
+
+	copy_key(&(indih.ih_key), &(ih->ih_key));
+	set_ih_item_len(&indih, UNFM_P_SIZE);
+
+	set_ih_free_space(&indih, 0);
+	if (get_offset(&ih->ih_key) > fs->fs_blocksize) {
+		/* insert indirect item containing 0 unfm pointer */
+		unfm_ptr = 0;
+		retval = 0;
 	} else {
-	    /* take first unformatted pointer from an indirect item */
-	    //free_sp = ih_get_free_space(0, ih, item);
-
-	    set_ih_item_len (&indih, get_ih_item_len (ih));
-	    ni = getmem (get_ih_item_len (ih));
-	    memcpy (ni, (item), get_ih_item_len (ih));
-
-	    if (!was_in_tree) {
-		for (i = 0; i < I_UNFM_NUM (ih); i++) {
-		    if (still_bad_unfm_ptr_2 (d32_get(ni, i)))
-			reiserfs_panic ("create_first_item_of_file: The file %K has a pointer to the bad block (%u)", 
-			    &ih->ih_key, d32_get(ni, i));
-		    mark_block_used (d32_get(ni, i), 0);
-		}
-	    }
+		if (is_direct_ih(ih)) {
+			/* copy direct item to new unformatted node. Save information about it */
+			int len = get_bytes_number(ih, fs->fs_blocksize);
+
+			unbh =
+			    reiserfsck_get_new_buffer(PATH_PLAST_BUFFER(path)->
+						      b_blocknr);
+			memset(unbh->b_data, 0, unbh->b_size);
+			unfm_ptr = cpu_to_le32(unbh->b_blocknr);
+			memcpy(unbh->b_data + get_offset(&ih->ih_key) - 1, item,
+			       len);
+
+			set_ih_free_space(&indih, fs->fs_blocksize -
+					  len - (get_offset(&ih->ih_key) - 1));
+
+			mark_ih_was_tail(&indih);
+			mark_buffer_dirty(unbh);
+			mark_buffer_uptodate(unbh, 1);
+			brelse(unbh);
+
+			retval = len;
+		} else {
+			/* take first unformatted pointer from an indirect item */
+			//free_sp = ih_get_free_space(0, ih, item);
+
+			set_ih_item_len(&indih, get_ih_item_len(ih));
+			ni = getmem(get_ih_item_len(ih));
+			memcpy(ni, (item), get_ih_item_len(ih));
+
+			if (!was_in_tree) {
+				for (i = 0; i < I_UNFM_NUM(ih); i++) {
+					if (still_bad_unfm_ptr_2
+					    (d32_get(ni, i)))
+						reiserfs_panic
+						    ("create_first_item_of_file: The file %K has a pointer to the bad block (%u)",
+						     &ih->ih_key, d32_get(ni,
+									  i));
+					mark_block_used(d32_get(ni, i), 0);
+				}
+			}
 
-	    retval = fs->fs_blocksize * get_ih_item_len (ih) / UNFM_P_SIZE;
+			retval =
+			    fs->fs_blocksize * get_ih_item_len(ih) /
+			    UNFM_P_SIZE;
+		}
 	}
-    }
 
-    set_ih_key_format (&indih, get_ih_key_format (ih));
-    //ih_version(&indih) = ih_version(ih);
-    set_offset (key_format (&(ih->ih_key)), &indih.ih_key, 1);
-    set_type (key_format (&(ih->ih_key)), &indih.ih_key, TYPE_INDIRECT);
+	set_ih_key_format(&indih, get_ih_key_format(ih));
+	//ih_version(&indih) = ih_version(ih);
+	set_offset(key_format(&(ih->ih_key)), &indih.ih_key, 1);
+	set_type(key_format(&(ih->ih_key)), &indih.ih_key, TYPE_INDIRECT);
 
-    if (ni) {
-	reiserfsck_insert_item (path, &indih, (const char *)ni);
-	freemem (ni);
-    } else {
-	reiserfsck_insert_item (path, &indih, (const char *)&unfm_ptr);
-    }
+	if (ni) {
+		reiserfsck_insert_item(path, &indih, (const char *)ni);
+		freemem(ni);
+	} else {
+		reiserfsck_insert_item(path, &indih, (const char *)&unfm_ptr);
+	}
 
-    return retval;
+	return retval;
 }
 
-
 /* path points to first part of tail. Function copies file tail into unformatted node and returns
    its block number. */
 /* we convert direct item that is on the path to indirect. we need a number of free block for
    unformatted node. reiserfs_new_blocknrs will start from block number returned by this function */
-static unsigned long block_to_start (struct reiserfs_path *path)
+static unsigned long block_to_start(struct reiserfs_path *path)
 {
-  struct buffer_head * bh;
-  struct item_head * ih;
-  __u32 blk;
-
-  bh = PATH_PLAST_BUFFER (path);
-  ih = PATH_PITEM_HEAD (path);
-  if (get_offset(&ih->ih_key) == 1 || PATH_LAST_POSITION (path) == 0)
-    return bh->b_blocknr;
-
-  ih --;
-  blk = d32_get((__u32 *)B_I_PITEM(bh, ih), I_UNFM_NUM (ih) - 1);
-  return (blk ? blk : bh->b_blocknr);
+	struct buffer_head *bh;
+	struct item_head *ih;
+	__u32 blk;
+
+	bh = PATH_PLAST_BUFFER(path);
+	ih = PATH_PITEM_HEAD(path);
+	if (get_offset(&ih->ih_key) == 1 || PATH_LAST_POSITION(path) == 0)
+		return bh->b_blocknr;
+
+	ih--;
+	blk = d32_get((__u32 *) B_I_PITEM(bh, ih), I_UNFM_NUM(ih) - 1);
+	return (blk ? blk : bh->b_blocknr);
 }
 
-
-static void direct2indirect2 (unsigned long unfm, struct reiserfs_path *path)
+static void direct2indirect2(unsigned long unfm, struct reiserfs_path *path)
 {
-    struct item_head * ih;
-    struct reiserfs_key key;
-    struct buffer_head * unbh;
-    __u32 ni;
-    int copied = 0;
-    int file_format;
-
-    ih = PATH_PITEM_HEAD (path);
-    copy_key (&key, &(ih->ih_key));
-
-    file_format = key_format (&key);
-
-    if (get_offset (&key) % fs->fs_blocksize != 1) {
-	/* look for first part of tail */
-	pathrelse (path);
-	set_offset (file_format, &key, (get_offset (&key) & ~(fs->fs_blocksize - 1)) + 1);	
-	if (reiserfs_search_by_key_4 (fs, &key, path) != ITEM_FOUND)
-	    die ("direct2indirect: can not find first part of tail");
-    }
-
-    unbh = reiserfsck_get_new_buffer (unfm ? unfm : block_to_start (path));
-    memset (unbh->b_data, 0, unbh->b_size);
-
-    /* delete parts of tail coping their contents to new buffer */
-    do {
-	__u64 len;
+	struct item_head *ih;
+	struct reiserfs_key key;
+	struct buffer_head *unbh;
+	__u32 ni;
+	int copied = 0;
+	int file_format;
+
+	ih = PATH_PITEM_HEAD(path);
+	copy_key(&key, &(ih->ih_key));
+
+	file_format = key_format(&key);
+
+	if (get_offset(&key) % fs->fs_blocksize != 1) {
+		/* look for first part of tail */
+		pathrelse(path);
+		set_offset(file_format, &key,
+			   (get_offset(&key) & ~(fs->fs_blocksize - 1)) + 1);
+		if (reiserfs_search_by_key_4(fs, &key, path) != ITEM_FOUND)
+			die("direct2indirect: can not find first part of tail");
+	}
 
-	ih = PATH_PITEM_HEAD (path);
-	
-	len = get_bytes_number(ih, fs->fs_blocksize);
-	
-	memcpy (unbh->b_data + copied, B_I_PITEM (PATH_PLAST_BUFFER (path), ih), len);
+	unbh = reiserfsck_get_new_buffer(unfm ? unfm : block_to_start(path));
+	memset(unbh->b_data, 0, unbh->b_size);
 
-//	save_unfm_overwriting (unbh->b_blocknr, ih);
-	copied += len;	
-	set_offset (file_format, &key, get_offset (&key) +  len);
+	/* delete parts of tail coping their contents to new buffer */
+	do {
+		__u64 len;
 
-	reiserfsck_delete_item (path, 0);
-	
-    } while (reiserfs_search_by_key_4 (fs, &key, path) == ITEM_FOUND);
+		ih = PATH_PITEM_HEAD(path);
 
-    pathrelse (path);
+		len = get_bytes_number(ih, fs->fs_blocksize);
 
+		memcpy(unbh->b_data + copied,
+		       B_I_PITEM(PATH_PLAST_BUFFER(path), ih), len);
 
-    /* paste or insert pointer to the unformatted node */
-    set_offset (file_format, &key, get_offset (&key) - copied);
-//    set_offset (ih_key_format (ih), &key, get_offset (&key) - copied);
-//  key.k_offset -= copied;
-    ni = cpu_to_le32 (unbh->b_blocknr);
+//      save_unfm_overwriting (unbh->b_blocknr, ih);
+		copied += len;
+		set_offset(file_format, &key, get_offset(&key) + len);
 
+		reiserfsck_delete_item(path, 0);
 
-    if (usearch_by_position (fs, &key, file_format, path) == FILE_NOT_FOUND) {
-	struct item_head insih;
+	} while (reiserfs_search_by_key_4(fs, &key, path) == ITEM_FOUND);
 
-	copy_key (&(insih.ih_key), &key);
-	set_ih_key_format (&insih, file_format);
-	set_type (get_ih_key_format (&insih), &insih.ih_key, TYPE_INDIRECT);
-	set_ih_free_space (&insih, 0);
-	mark_item_unreachable (&insih);
-	set_ih_item_len (&insih, UNFM_P_SIZE);
-	mark_ih_was_tail (&insih);
-	reiserfsck_insert_item (path, &insih, (const char *)&(ni));
-    } else {
-	ih = PATH_PITEM_HEAD (path);
+	pathrelse(path);
 
-	if (!is_indirect_ih(ih))
-	    reiserfs_panic ("%s: The item, which is supposed to be deleted, found in the tree - %k", 
-		__FUNCTION__, &ih->ih_key);
-	if (get_bytes_number (ih, fs->fs_blocksize) + get_offset (&ih->ih_key) != get_offset (&key))	
-	    reiserfs_panic ("%s: The item %k with the wrong offset found in the block %lu block", 
-		__FUNCTION__, &ih->ih_key, PATH_PLAST_BUFFER(path)->b_blocknr);
-	
-	mark_ih_was_tail (ih);
-	mark_buffer_dirty (get_bh(path));
-	reiserfsck_paste_into_item (path, (const char *)&ni, UNFM_P_SIZE);
-    }
+	/* paste or insert pointer to the unformatted node */
+	set_offset(file_format, &key, get_offset(&key) - copied);
+//    set_offset (ih_key_format (ih), &key, get_offset (&key) - copied);
+//  key.k_offset -= copied;
+	ni = cpu_to_le32(unbh->b_blocknr);
+
+	if (usearch_by_position(fs, &key, file_format, path) == FILE_NOT_FOUND) {
+		struct item_head insih;
+
+		copy_key(&(insih.ih_key), &key);
+		set_ih_key_format(&insih, file_format);
+		set_type(get_ih_key_format(&insih), &insih.ih_key,
+			 TYPE_INDIRECT);
+		set_ih_free_space(&insih, 0);
+		mark_item_unreachable(&insih);
+		set_ih_item_len(&insih, UNFM_P_SIZE);
+		mark_ih_was_tail(&insih);
+		reiserfsck_insert_item(path, &insih, (const char *)&(ni));
+	} else {
+		ih = PATH_PITEM_HEAD(path);
+
+		if (!is_indirect_ih(ih))
+			reiserfs_panic
+			    ("%s: The item, which is supposed to be deleted, found in the tree - %k",
+			     __FUNCTION__, &ih->ih_key);
+		if (get_bytes_number(ih, fs->fs_blocksize) +
+		    get_offset(&ih->ih_key) != get_offset(&key))
+			reiserfs_panic
+			    ("%s: The item %k with the wrong offset found in the block %lu block",
+			     __FUNCTION__, &ih->ih_key,
+			     PATH_PLAST_BUFFER(path)->b_blocknr);
+
+		mark_ih_was_tail(ih);
+		mark_buffer_dirty(get_bh(path));
+		reiserfsck_paste_into_item(path, (const char *)&ni,
+					   UNFM_P_SIZE);
+	}
 
-    mark_buffer_dirty (unbh);
-    mark_buffer_uptodate (unbh, 1);
-    brelse (unbh);
+	mark_buffer_dirty(unbh);
+	mark_buffer_uptodate(unbh, 1);
+	brelse(unbh);
 
-    if (usearch_by_position (fs, &key, file_format, path) != POSITION_FOUND ||
-	!is_indirect_ih (PATH_PITEM_HEAD (path)))
-	reiserfs_panic ("direct2indirect: The data %k, which are supposed to be converted, are not found", &key);
-    return;
+	if (usearch_by_position(fs, &key, file_format, path) != POSITION_FOUND
+	    || !is_indirect_ih(PATH_PITEM_HEAD(path)))
+		reiserfs_panic
+		    ("direct2indirect: The data %k, which are supposed to be converted, are not found",
+		     &key);
+	return;
 }
 
-
-
-
-static int append_to_unformatted_node (struct item_head * comingih, struct item_head * ih, char * item,
-                                        struct reiserfs_path *path, unsigned int coming_len)
+static int append_to_unformatted_node(struct item_head *comingih,
+				      struct item_head *ih, char *item,
+				      struct reiserfs_path *path,
+				      unsigned int coming_len)
 {
-    struct buffer_head * bh, * unbh = NULL;
-    __u64 end_of_data, free_space;
-    __u16 offset = get_offset (&comingih->ih_key) % fs->fs_blocksize - 1;
-    __u32 unfm_ptr;
-    int zero_number;
-    
-    bh = PATH_PLAST_BUFFER (path);
-    unfm_ptr = d32_get ((__u32 *)B_I_PITEM(bh, ih), I_UNFM_NUM (ih) - 1);
-
-    /* append to free space of the last unformatted node of indirect item ih */
-    free_space = get_offset (&ih->ih_key) + fs->fs_blocksize * I_UNFM_NUM (ih) - get_offset (&comingih->ih_key);
-	
-    if (free_space < coming_len)
-	reiserfs_panic ("%s: block %lu: The unformatted node %u, pointed by the file %k, does not have enough free space"
-	    "for appending %llu bytes", __FUNCTION__, bh->b_blocknr, unfm_ptr, &ih->ih_key, coming_len);
-	
-    if (fs->fs_blocksize < free_space)
-	reiserfs_panic ("%s: block %lu: The unformatted node %u, pointed by the file %k, does not have enough free space"
-	    "for appending %llu bytes", __FUNCTION__, bh->b_blocknr, &ih->ih_key, unfm_ptr, &ih->ih_key, coming_len);	
-    
-    end_of_data = fs->fs_blocksize - free_space;
-    zero_number = offset - end_of_data;
-
-    if (unfm_ptr && !not_data_block (fs, unfm_ptr)) {
-	unbh = bread (fs->fs_dev, unfm_ptr, fs->fs_blocksize);
-	if (!is_block_used (unfm_ptr))
-	    reiserfs_panic ("%s: block %lu: The unformatted node %u, pointed by the file %k, is marked as unused", 
-		__FUNCTION__, bh->b_blocknr, unfm_ptr, &ih->ih_key);
+	struct buffer_head *bh, *unbh = NULL;
+	__u64 end_of_data, free_space;
+	__u16 offset = get_offset(&comingih->ih_key) % fs->fs_blocksize - 1;
+	__u32 unfm_ptr;
+	int zero_number;
+
+	bh = PATH_PLAST_BUFFER(path);
+	unfm_ptr = d32_get((__u32 *) B_I_PITEM(bh, ih), I_UNFM_NUM(ih) - 1);
+
+	/* append to free space of the last unformatted node of indirect item ih */
+	free_space =
+	    get_offset(&ih->ih_key) + fs->fs_blocksize * I_UNFM_NUM(ih) -
+	    get_offset(&comingih->ih_key);
+
+	if (free_space < coming_len)
+		reiserfs_panic
+		    ("%s: block %lu: The unformatted node %u, pointed by the file %k, does not have enough free space"
+		     "for appending %llu bytes", __FUNCTION__, bh->b_blocknr,
+		     unfm_ptr, &ih->ih_key, coming_len);
+
+	if (fs->fs_blocksize < free_space)
+		reiserfs_panic
+		    ("%s: block %lu: The unformatted node %u, pointed by the file %k, does not have enough free space"
+		     "for appending %llu bytes", __FUNCTION__, bh->b_blocknr,
+		     &ih->ih_key, unfm_ptr, &ih->ih_key, coming_len);
+
+	end_of_data = fs->fs_blocksize - free_space;
+	zero_number = offset - end_of_data;
+
+	if (unfm_ptr && !not_data_block(fs, unfm_ptr)) {
+		unbh = bread(fs->fs_dev, unfm_ptr, fs->fs_blocksize);
+		if (!is_block_used(unfm_ptr))
+			reiserfs_panic
+			    ("%s: block %lu: The unformatted node %u, pointed by the file %k, is marked as unused",
+			     __FUNCTION__, bh->b_blocknr, unfm_ptr,
+			     &ih->ih_key);
+
+		if (unbh == 0)
+			unfm_ptr = 0;
+	}
 
-	if (unbh == 0)
-	    unfm_ptr = 0;
-    }
-    
-    if (!unfm_ptr || not_data_block (fs, unfm_ptr)) {
-	/* indirect item points to block which can not be pointed or to 0, in
-           any case we have to allocate new node */
-	/*if (unfm_ptr == 0 || unfm_ptr >= SB_BLOCK_COUNT (fs)) {*/
-	unbh = reiserfsck_get_new_buffer (bh->b_blocknr);
-	memset (unbh->b_data, 0, unbh->b_size);
-	d32_put ((__u32 *)B_I_PITEM(bh, ih), I_UNFM_NUM (ih) - 1, unbh->b_blocknr);
-	/*mark_block_unformatted (unbh->b_blocknr);*/
-	mark_buffer_dirty (bh);
-    }
-    memset (unbh->b_data + end_of_data, 0, zero_number);
-    memcpy (unbh->b_data + offset, item, coming_len);
+	if (!unfm_ptr || not_data_block(fs, unfm_ptr)) {
+		/* indirect item points to block which can not be pointed or to 0, in
+		   any case we have to allocate new node */
+		/*if (unfm_ptr == 0 || unfm_ptr >= SB_BLOCK_COUNT (fs)) { */
+		unbh = reiserfsck_get_new_buffer(bh->b_blocknr);
+		memset(unbh->b_data, 0, unbh->b_size);
+		d32_put((__u32 *) B_I_PITEM(bh, ih), I_UNFM_NUM(ih) - 1,
+			unbh->b_blocknr);
+		/*mark_block_unformatted (unbh->b_blocknr); */
+		mark_buffer_dirty(bh);
+	}
+	memset(unbh->b_data + end_of_data, 0, zero_number);
+	memcpy(unbh->b_data + offset, item, coming_len);
 
 //    save_unfm_overwriting (unbh->b_blocknr, comingih);
 
-    free_space -= (zero_number + coming_len);
-    set_ih_free_space(ih, get_ih_free_space(ih) - (zero_number + coming_len));
-    memset (unbh->b_data + offset + coming_len, 0, free_space);
+	free_space -= (zero_number + coming_len);
+	set_ih_free_space(ih,
+			  get_ih_free_space(ih) - (zero_number + coming_len));
+	memset(unbh->b_data + offset + coming_len, 0, free_space);
 //  mark_buffer_uptodate (unbh, 0);
-    mark_buffer_uptodate (unbh, 1);
-    mark_buffer_dirty (unbh);
-    brelse (unbh);
-    pathrelse (path);
-    return coming_len;
+	mark_buffer_uptodate(unbh, 1);
+	mark_buffer_dirty(unbh);
+	brelse(unbh);
+	pathrelse(path);
+	return coming_len;
 }
 
 /* this appends file with one unformatted node pointer (since balancing
    algorithm limitation). This pointer can be 0, or new allocated block or
    pointer from indirect item that is being inserted into tree */
-int reiserfsck_append_file (struct item_head * comingih, char * item, int pos, struct reiserfs_path *path,
-			    int was_in_tree)
+int reiserfsck_append_file(struct item_head *comingih, char *item, int pos,
+			   struct reiserfs_path *path, int was_in_tree)
 {
-    __u32 * ni;
-    struct buffer_head * unbh;
-    int retval;
-    struct item_head * ih = PATH_PITEM_HEAD (path);
-    __u32 bytes_number;
-    int i, count = 0;
-
-    if (!is_indirect_ih (ih))
-	reiserfs_panic ("reiserfsck_append_file: Operation is not allowed for non-indirect item %k", &ih->ih_key);
-
-    if (is_direct_ih (comingih)) {
-	unsigned int coming_len = get_bytes_number (comingih, fs->fs_blocksize);
-
-	if (get_offset (&comingih->ih_key) < get_offset (&ih->ih_key) + fs->fs_blocksize * I_UNFM_NUM (ih)) {
-	    /* direct item fits to free space of indirect item */
-	    return append_to_unformatted_node (comingih, ih, item, path, coming_len);
-	}
+	__u32 *ni;
+	struct buffer_head *unbh;
+	int retval;
+	struct item_head *ih = PATH_PITEM_HEAD(path);
+	__u32 bytes_number;
+	int i, count = 0;
 
-	unbh = reiserfsck_get_new_buffer (PATH_PLAST_BUFFER (path)->b_blocknr);
-	memset (unbh->b_data, 0, unbh->b_size);
-	memcpy (unbh->b_data + get_offset (&comingih->ih_key) % unbh->b_size - 1, item, coming_len);
+	if (!is_indirect_ih(ih))
+		reiserfs_panic
+		    ("reiserfsck_append_file: Operation is not allowed for non-indirect item %k",
+		     &ih->ih_key);
+
+	if (is_direct_ih(comingih)) {
+		unsigned int coming_len =
+		    get_bytes_number(comingih, fs->fs_blocksize);
+
+		if (get_offset(&comingih->ih_key) <
+		    get_offset(&ih->ih_key) +
+		    fs->fs_blocksize * I_UNFM_NUM(ih)) {
+			/* direct item fits to free space of indirect item */
+			return append_to_unformatted_node(comingih, ih, item,
+							  path, coming_len);
+		}
 
+		unbh =
+		    reiserfsck_get_new_buffer(PATH_PLAST_BUFFER(path)->
+					      b_blocknr);
+		memset(unbh->b_data, 0, unbh->b_size);
+		memcpy(unbh->b_data +
+		       get_offset(&comingih->ih_key) % unbh->b_size - 1, item,
+		       coming_len);
 
-	mark_buffer_dirty (unbh);
-	mark_buffer_uptodate (unbh, 1);
+		mark_buffer_dirty(unbh);
+		mark_buffer_uptodate(unbh, 1);
 
-	ni = getmem (UNFM_P_SIZE);
-	d32_put (ni, 0, unbh->b_blocknr);
-	count = 1;
-	
-	brelse (unbh);
-	retval = coming_len;
-    } else {
-	/* coming item is indirect item */
-
-	bytes_number = get_bytes_number (ih, fs->fs_blocksize);
-	if (get_offset (&comingih->ih_key) + pos * fs->fs_blocksize != get_offset (&ih->ih_key) + bytes_number)
-	    reiserfs_panic ("reiserfsck_append_file: file %K: Cannot append indirect pointers of the offset "
-		"(%LLu) at the position %LLu\n", &comingih->ih_key, get_offset (&comingih->ih_key) + pos * fs->fs_blocksize, 
-		get_offset (&ih->ih_key) + bytes_number);
-
-	/* take unformatted pointer from an indirect item */
-	count = I_UNFM_NUM(comingih) - pos;
-	ni = getmem (count * UNFM_P_SIZE);
-	memcpy (ni, (item + pos * UNFM_P_SIZE), count * UNFM_P_SIZE);
-	
-	if (!was_in_tree) {
-	    for (i = 0; i < count; i++ ) {
-		if (still_bad_unfm_ptr_2 (d32_get (ni, i)))
-		    die ("reiserfsck_append_file: Trying to insert a pointer to illegal block (%u)", d32_get (ni, i));
-		mark_block_used (d32_get (ni, i), 0);
-	    }
-	}
+		ni = getmem(UNFM_P_SIZE);
+		d32_put(ni, 0, unbh->b_blocknr);
+		count = 1;
 
-	retval = fs->fs_blocksize * count;
-    }
+		brelse(unbh);
+		retval = coming_len;
+	} else {
+		/* coming item is indirect item */
+
+		bytes_number = get_bytes_number(ih, fs->fs_blocksize);
+		if (get_offset(&comingih->ih_key) + pos * fs->fs_blocksize !=
+		    get_offset(&ih->ih_key) + bytes_number)
+			reiserfs_panic
+			    ("reiserfsck_append_file: file %K: Cannot append indirect pointers of the offset "
+			     "(%LLu) at the position %LLu\n", &comingih->ih_key,
+			     get_offset(&comingih->ih_key) +
+			     pos * fs->fs_blocksize,
+			     get_offset(&ih->ih_key) + bytes_number);
+
+		/* take unformatted pointer from an indirect item */
+		count = I_UNFM_NUM(comingih) - pos;
+		ni = getmem(count * UNFM_P_SIZE);
+		memcpy(ni, (item + pos * UNFM_P_SIZE), count * UNFM_P_SIZE);
+
+		if (!was_in_tree) {
+			for (i = 0; i < count; i++) {
+				if (still_bad_unfm_ptr_2(d32_get(ni, i)))
+					die("reiserfsck_append_file: Trying to insert a pointer to illegal block (%u)", d32_get(ni, i));
+				mark_block_used(d32_get(ni, i), 0);
+			}
+		}
+
+		retval = fs->fs_blocksize * count;
+	}
 
-    reiserfsck_paste_into_item (path, (const char *)ni, count * UNFM_P_SIZE);
-    freemem (ni);
-    return retval;
+	reiserfsck_paste_into_item(path, (const char *)ni, count * UNFM_P_SIZE);
+	freemem(ni);
+	return retval;
 }
 
-long long int must_there_be_a_hole (struct item_head * comingih, struct reiserfs_path *path)
+long long int must_there_be_a_hole(struct item_head *comingih,
+				   struct reiserfs_path *path)
 {
-    struct item_head * ih = PATH_PITEM_HEAD (path);
+	struct item_head *ih = PATH_PITEM_HEAD(path);
 
-    if (is_direct_ih (ih)) {
-	direct2indirect2 (0, path);
-	ih = PATH_PITEM_HEAD (path);
-    }
+	if (is_direct_ih(ih)) {
+		direct2indirect2(0, path);
+		ih = PATH_PITEM_HEAD(path);
+	}
 
-    path->pos_in_item = I_UNFM_NUM (ih);
+	path->pos_in_item = I_UNFM_NUM(ih);
 
-    return (get_offset (&comingih->ih_key) - get_offset (&ih->ih_key)) / fs->fs_blocksize - I_UNFM_NUM (ih);
+	return (get_offset(&comingih->ih_key) -
+		get_offset(&ih->ih_key)) / fs->fs_blocksize - I_UNFM_NUM(ih);
 /*
     if (get_offset (&ih->ih_key) + (I_UNFM_NUM (ih) + 1) * fs->fs_blocksize <= get_offset (&comingih->ih_key))
 	return 1;
@@ -857,366 +1020,395 @@ long long int must_there_be_a_hole (struct item_head * comingih, struct reiserfs
     return 0;*/
 }
 
-
-int reiserfs_append_zero_unfm_ptr (struct reiserfs_path *path, long long int p_count)
+int reiserfs_append_zero_unfm_ptr(struct reiserfs_path *path,
+				  long long int p_count)
 {
-    __u32 * ni;
-    long long int count;
+	__u32 *ni;
+	long long int count;
 
-    if (is_direct_ih (PATH_PITEM_HEAD (path)))
-	/* convert direct item to indirect */
-	direct2indirect2 (0, path);
-	
-    count = MAX_INDIRECT_ITEM_LEN (fs->fs_blocksize) / UNFM_P_SIZE;
-    	
-    if (p_count <= count)
-       count = p_count;
+	if (is_direct_ih(PATH_PITEM_HEAD(path)))
+		/* convert direct item to indirect */
+		direct2indirect2(0, path);
 
-    ni = getmem (count * UNFM_P_SIZE);
-    memset (ni, 0, count * UNFM_P_SIZE);
+	count = MAX_INDIRECT_ITEM_LEN(fs->fs_blocksize) / UNFM_P_SIZE;
 
-    reiserfsck_paste_into_item (path, (const char *)ni, count * UNFM_P_SIZE);
-    freemem(ni);
-    return 0;
-}
+	if (p_count <= count)
+		count = p_count;
 
+	ni = getmem(count * UNFM_P_SIZE);
+	memset(ni, 0, count * UNFM_P_SIZE);
+
+	reiserfsck_paste_into_item(path, (const char *)ni, count * UNFM_P_SIZE);
+	freemem(ni);
+	return 0;
+}
 
 /* write direct item to unformatted node */
 /* coming item is direct */
-static int overwrite_by_direct_item (struct item_head * comingih, char * item, struct reiserfs_path *path)
+static int overwrite_by_direct_item(struct item_head *comingih, char *item,
+				    struct reiserfs_path *path)
 {
-    __u32 unfm_ptr;
-    struct buffer_head * unbh, * bh;
-    struct item_head * ih;
-    int offset;
-    __u64 coming_len = get_bytes_number (comingih, fs->fs_blocksize);
-
-
-    bh = PATH_PLAST_BUFFER (path);
-    ih = PATH_PITEM_HEAD (path);
-
-    unfm_ptr = d32_get ((__u32 *)B_I_PITEM(bh, ih), path->pos_in_item);
-    unbh = 0;
-
-    if (unfm_ptr != 0 && unfm_ptr < get_sb_block_count (fs->fs_ondisk_sb)) {
-	/**/
-	unbh = bread (fs->fs_dev, unfm_ptr, bh->b_size);
-	if (!is_block_used (unfm_ptr))
-	    die ("overwrite_by_direct_item: block %lu, item %d, pointer %d: The pointed block"
-		"(%u) being overwritten is marked as unused.", bh->b_blocknr, PATH_LAST_POSITION(path), 
-		path->pos_in_item, unfm_ptr);
-	if (unbh == 0)
-	    unfm_ptr = 0;
-    }
-    if (unfm_ptr == 0 || unfm_ptr >= get_sb_block_count (fs->fs_ondisk_sb)) {
-	if ((unbh = reiserfsck_get_new_buffer (bh->b_blocknr)) != NULL) {
-	    memset (unbh->b_data, 0, unbh->b_size);
-	    d32_put ((__u32 *)B_I_PITEM(bh, ih), path->pos_in_item,  unbh->b_blocknr);
-	    mark_buffer_dirty (bh);
-	} else {
-	    die ("overwrite_by_direct_item: Could not allocate a new block for new data");
+	__u32 unfm_ptr;
+	struct buffer_head *unbh, *bh;
+	struct item_head *ih;
+	int offset;
+	__u64 coming_len = get_bytes_number(comingih, fs->fs_blocksize);
+
+	bh = PATH_PLAST_BUFFER(path);
+	ih = PATH_PITEM_HEAD(path);
+
+	unfm_ptr = d32_get((__u32 *) B_I_PITEM(bh, ih), path->pos_in_item);
+	unbh = 0;
+
+	if (unfm_ptr != 0 && unfm_ptr < get_sb_block_count(fs->fs_ondisk_sb)) {
+		 /**/ unbh = bread(fs->fs_dev, unfm_ptr, bh->b_size);
+		if (!is_block_used(unfm_ptr))
+			die("overwrite_by_direct_item: block %lu, item %d, pointer %d: The pointed block" "(%u) being overwritten is marked as unused.", bh->b_blocknr, PATH_LAST_POSITION(path), path->pos_in_item, unfm_ptr);
+		if (unbh == 0)
+			unfm_ptr = 0;
+	}
+	if (unfm_ptr == 0 || unfm_ptr >= get_sb_block_count(fs->fs_ondisk_sb)) {
+		if ((unbh = reiserfsck_get_new_buffer(bh->b_blocknr)) != NULL) {
+			memset(unbh->b_data, 0, unbh->b_size);
+			d32_put((__u32 *) B_I_PITEM(bh, ih), path->pos_in_item,
+				unbh->b_blocknr);
+			mark_buffer_dirty(bh);
+		} else {
+			die("overwrite_by_direct_item: Could not allocate a new block for new data");
+		}
 	}
-    }
 
-    offset = (get_offset (&comingih->ih_key) % bh->b_size) - 1;
-    if (offset + coming_len > bh->b_size)
-    	die ("overwrite_by_direct_item: The length of the file after insertion (offset=%lu, length=%u)"
-	    "will exceed the maximal possible length.", ( long unsigned ) get_offset (&comingih->ih_key), 
-	     ( unsigned ) coming_len);
+	offset = (get_offset(&comingih->ih_key) % bh->b_size) - 1;
+	if (offset + coming_len > bh->b_size)
+		die("overwrite_by_direct_item: The length of the file after insertion (offset=%lu, length=%u)" "will exceed the maximal possible length.", (long unsigned)get_offset(&comingih->ih_key), (unsigned)coming_len);
 
-    memcpy (unbh->b_data + offset, item, coming_len);
+	memcpy(unbh->b_data + offset, item, coming_len);
 
 //    save_unfm_overwriting (unbh->b_blocknr, comingih);
 
-    if ((path->pos_in_item == (I_UNFM_NUM (ih) - 1)) && 
-	(bh->b_size - 0/*ih_free_space (ih)*/) < (offset + coming_len)) {
-	set_ih_free_space (ih, bh->b_size - (offset + coming_len)) ;
-	mark_buffer_dirty (bh);
-    }
-    mark_buffer_dirty (unbh);
+	if ((path->pos_in_item == (I_UNFM_NUM(ih) - 1)) &&
+	    (bh->b_size - 0 /*ih_free_space (ih) */ ) < (offset + coming_len)) {
+		set_ih_free_space(ih, bh->b_size - (offset + coming_len));
+		mark_buffer_dirty(bh);
+	}
+	mark_buffer_dirty(unbh);
 //  mark_buffer_uptodate (unbh, 0);
-    mark_buffer_uptodate (unbh, 1);
-    brelse (unbh);
-    return coming_len;
+	mark_buffer_uptodate(unbh, 1);
+	brelse(unbh);
+	return coming_len;
 }
 
-
 #if 0
 
-void overwrite_unfm_by_unfm (unsigned long unfm_in_tree, unsigned long coming_unfm, int bytes_in_unfm)
+void overwrite_unfm_by_unfm(unsigned long unfm_in_tree,
+			    unsigned long coming_unfm, int bytes_in_unfm)
 {
-    struct overwritten_unfm_segment * unfm_os_list;/* list of overwritten segments of the unformatted node */
-    struct overwritten_unfm_segment unoverwritten_segment;
-    struct buffer_head * bh_in_tree, * coming_bh;
-
+	struct overwritten_unfm_segment *unfm_os_list;	/* list of overwritten segments of the unformatted node */
+	struct overwritten_unfm_segment unoverwritten_segment;
+	struct buffer_head *bh_in_tree, *coming_bh;
+
+	if (!test_bit
+	    (coming_unfm % (fs->fs_blocksize * 8),
+	     SB_AP_BITMAP(fs)[coming_unfm / (fs->fs_blocksize * 8)]->b_data))
+		/* block (pointed by indirect item) is free, we do not have to keep its contents */
+		return;
+
+	/* coming block is marked as used in disk bitmap. Put its contents to
+	   block in tree preserving everything, what has been overwritten there by
+	   direct items */
+	unfm_os_list =
+	    find_overwritten_unfm(unfm_in_tree, bytes_in_unfm,
+				  &unoverwritten_segment);
+	if (unfm_os_list) {
+		/*    add_event (UNFM_OVERWRITING_UNFM); */
+		bh_in_tree = bread(fs->fs_dev, unfm_in_tree, fs->fs_blocksize);
+		coming_bh = bread(fs->fs_dev, coming_unfm, fs->fs_blocksize);
+		if (bh_in_tree == 0 || coming_bh == 0)
+			return;
+
+		while (get_unoverwritten_segment
+		       (unfm_os_list, &unoverwritten_segment)) {
+			if (unoverwritten_segment.ous_begin < 0
+			    || unoverwritten_segment.ous_end > bytes_in_unfm - 1
+			    || unoverwritten_segment.ous_begin >
+			    unoverwritten_segment.ous_end)
+				die("overwrite_unfm_by_unfm: invalid segment found (%d %d)", unoverwritten_segment.ous_begin, unoverwritten_segment.ous_end);
+
+			memcpy(bh_in_tree->b_data +
+			       unoverwritten_segment.ous_begin,
+			       coming_bh->b_data +
+			       unoverwritten_segment.ous_begin,
+			       unoverwritten_segment.ous_end -
+			       unoverwritten_segment.ous_begin + 1);
+			mark_buffer_dirty(bh_in_tree);
+		}
 
-    if (!test_bit (coming_unfm % (fs->fs_blocksize * 8), SB_AP_BITMAP (fs)[coming_unfm / (fs->fs_blocksize * 8)]->b_data))
-	/* block (pointed by indirect item) is free, we do not have to keep its contents */
-	return;
-    
-    /* coming block is marked as used in disk bitmap. Put its contents to
-       block in tree preserving everything, what has been overwritten there by
-       direct items */
-    unfm_os_list = find_overwritten_unfm (unfm_in_tree, bytes_in_unfm, &unoverwritten_segment);
-    if (unfm_os_list) {
-	/*    add_event (UNFM_OVERWRITING_UNFM);*/
-	bh_in_tree = bread (fs->fs_dev, unfm_in_tree, fs->fs_blocksize);
-	coming_bh = bread (fs->fs_dev, coming_unfm, fs->fs_blocksize);
-	if (bh_in_tree == 0 || coming_bh == 0)
-	    return;
-	
-	while (get_unoverwritten_segment (unfm_os_list, &unoverwritten_segment)) {
-	    if (unoverwritten_segment.ous_begin < 0 || unoverwritten_segment.ous_end > bytes_in_unfm - 1 ||
-		unoverwritten_segment.ous_begin > unoverwritten_segment.ous_end)
-		die ("overwrite_unfm_by_unfm: invalid segment found (%d %d)", unoverwritten_segment.ous_begin, unoverwritten_segment.ous_end);
-	    
-	    memcpy (bh_in_tree->b_data + unoverwritten_segment.ous_begin, coming_bh->b_data + unoverwritten_segment.ous_begin,
-		    unoverwritten_segment.ous_end - unoverwritten_segment.ous_begin + 1);
-	    mark_buffer_dirty (bh_in_tree);
+		brelse(bh_in_tree);
+		brelse(coming_bh);
 	}
-	
-	brelse (bh_in_tree);
-	brelse (coming_bh);
-    }
 }
 #endif
 
-
 /* put unformatted node pointers from incoming item over the in-tree ones */
-static int overwrite_by_indirect_item (struct item_head * comingih, __u32 * coming_item,
-				       struct reiserfs_path *path, int * pos_in_coming_item)
+static int overwrite_by_indirect_item(struct item_head *comingih,
+				      __u32 * coming_item,
+				      struct reiserfs_path *path,
+				      int *pos_in_coming_item)
 {
-    struct buffer_head * bh = PATH_PLAST_BUFFER (path);
-    struct item_head * ih = PATH_PITEM_HEAD (path);
-    int written;
-    __u32 * item_in_tree;
-    int src_unfm_ptrs, dest_unfm_ptrs, to_copy, i, dirty = 0;
-
-    item_in_tree = (__u32 *)B_I_PITEM (bh, ih) + path->pos_in_item;
-    coming_item += *pos_in_coming_item;
-
-    dest_unfm_ptrs = I_UNFM_NUM (ih) - path->pos_in_item;
-    src_unfm_ptrs = I_UNFM_NUM (comingih) - *pos_in_coming_item;
-  
-    if (dest_unfm_ptrs >= src_unfm_ptrs) {
-	/* whole coming item (comingih) fits into item in tree (ih) starting with path->pos_in_item */
-
-	//free_sp = ih_get_free_space(0, comingih, (char *)coming_item);
-
-	written = get_bytes_number (comingih, fs->fs_blocksize) -
-	    /* free_sp - */ *pos_in_coming_item * fs->fs_blocksize;
-	*pos_in_coming_item = I_UNFM_NUM (comingih);
-	to_copy = src_unfm_ptrs;
-	if (dest_unfm_ptrs == src_unfm_ptrs)
-	    set_ih_free_space(ih, 0 /* free_sp */ );
-    } else {
-	/* only part of coming item overlaps item in the tree */
-	*pos_in_coming_item += dest_unfm_ptrs;
-	written = dest_unfm_ptrs * fs->fs_blocksize;
-	to_copy = dest_unfm_ptrs;
-	set_ih_free_space(ih, 0);
-    }
-  
-    for (i = 0; i < to_copy; i ++) {
-	if (d32_get (coming_item, i) != 0 && d32_get (item_in_tree, i) == 0) {
-	    /* overwrite holes only by correct a pointer in the coming item
-               which must be correct */
-	    d32_put (item_in_tree, i, d32_get (coming_item, i));
-	    mark_block_used (d32_get (coming_item, i), 0);
-	    dirty ++;
+	struct buffer_head *bh = PATH_PLAST_BUFFER(path);
+	struct item_head *ih = PATH_PITEM_HEAD(path);
+	int written;
+	__u32 *item_in_tree;
+	int src_unfm_ptrs, dest_unfm_ptrs, to_copy, i, dirty = 0;
+
+	item_in_tree = (__u32 *) B_I_PITEM(bh, ih) + path->pos_in_item;
+	coming_item += *pos_in_coming_item;
+
+	dest_unfm_ptrs = I_UNFM_NUM(ih) - path->pos_in_item;
+	src_unfm_ptrs = I_UNFM_NUM(comingih) - *pos_in_coming_item;
+
+	if (dest_unfm_ptrs >= src_unfm_ptrs) {
+		/* whole coming item (comingih) fits into item in tree (ih) starting with path->pos_in_item */
+
+		//free_sp = ih_get_free_space(0, comingih, (char *)coming_item);
+
+		written = get_bytes_number(comingih, fs->fs_blocksize) -
+		    /* free_sp - */ *pos_in_coming_item * fs->fs_blocksize;
+		*pos_in_coming_item = I_UNFM_NUM(comingih);
+		to_copy = src_unfm_ptrs;
+		if (dest_unfm_ptrs == src_unfm_ptrs)
+			set_ih_free_space(ih, 0 /* free_sp */ );
+	} else {
+		/* only part of coming item overlaps item in the tree */
+		*pos_in_coming_item += dest_unfm_ptrs;
+		written = dest_unfm_ptrs * fs->fs_blocksize;
+		to_copy = dest_unfm_ptrs;
+		set_ih_free_space(ih, 0);
 	}
-    }
-    if (dirty)
-	mark_buffer_dirty (bh);
-    return written;
-}
 
+	for (i = 0; i < to_copy; i++) {
+		if (d32_get(coming_item, i) != 0
+		    && d32_get(item_in_tree, i) == 0) {
+			/* overwrite holes only by correct a pointer in the coming item
+			   which must be correct */
+			d32_put(item_in_tree, i, d32_get(coming_item, i));
+			mark_block_used(d32_get(coming_item, i), 0);
+			dirty++;
+		}
+	}
+	if (dirty)
+		mark_buffer_dirty(bh);
+	return written;
+}
 
-static int reiserfsck_overwrite_file (struct item_head * comingih, char * item,
-				      struct reiserfs_path *path, int * pos_in_coming_item,
-				      int was_in_tree)
+static int reiserfsck_overwrite_file(struct item_head *comingih, char *item,
+				     struct reiserfs_path *path,
+				     int *pos_in_coming_item, int was_in_tree)
 {
-    __u32 unfm_ptr;
-    int written = 0;
-    struct item_head * ih = PATH_PITEM_HEAD (path);
-
-
-    if (not_of_one_file (ih, &(comingih->ih_key)))
-	    reiserfs_panic ("reiserfsck_overwrite_file: The file to be overwritten %K must be of"
-		" the same as the new data %K", &ih->ih_key, &comingih->ih_key);
-
-    if (is_direct_ih (ih)) {
-	unfm_ptr = 0;
-	if (is_indirect_ih (comingih)) {
-	    if (get_offset (&ih->ih_key) % fs->fs_blocksize != 1)
-		reiserfs_panic ("reiserfsck_overwrite_file: The second part of the tail %k can not"
-		    " be overwritten by indirect item %k", &ih->ih_key, &comingih->ih_key);
-	    /* use pointer from coming indirect item */
-	    unfm_ptr = d32_get ((__u32 *)item, *pos_in_coming_item);
-	    if (!was_in_tree) {
-		if (still_bad_unfm_ptr_2 (unfm_ptr))
-		    die ("reiserfsck_overwrite_file: The pointer to the unformatted block (%u)"
-			" points to the bad area.", unfm_ptr);
-	    }
+	__u32 unfm_ptr;
+	int written = 0;
+	struct item_head *ih = PATH_PITEM_HEAD(path);
+
+	if (not_of_one_file(ih, &(comingih->ih_key)))
+		reiserfs_panic
+		    ("reiserfsck_overwrite_file: The file to be overwritten %K must be of"
+		     " the same as the new data %K", &ih->ih_key,
+		     &comingih->ih_key);
+
+	if (is_direct_ih(ih)) {
+		unfm_ptr = 0;
+		if (is_indirect_ih(comingih)) {
+			if (get_offset(&ih->ih_key) % fs->fs_blocksize != 1)
+				reiserfs_panic
+				    ("reiserfsck_overwrite_file: The second part of the tail %k can not"
+				     " be overwritten by indirect item %k",
+				     &ih->ih_key, &comingih->ih_key);
+			/* use pointer from coming indirect item */
+			unfm_ptr = d32_get((__u32 *) item, *pos_in_coming_item);
+			if (!was_in_tree) {
+				if (still_bad_unfm_ptr_2(unfm_ptr))
+					die("reiserfsck_overwrite_file: The pointer to the unformatted block (%u)" " points to the bad area.", unfm_ptr);
+			}
+		}
+		/* */
+		direct2indirect2(unfm_ptr, path);
+	}
+	if (is_direct_ih(comingih)) {
+		written = overwrite_by_direct_item(comingih, item, path);
+	} else {
+		if (was_in_tree)
+			reiserfs_panic
+			    ("reiserfsck_overwrite_file: Item %k we are going to overwrite with"
+			     " %k cannot not be in the tree yet", &ih->ih_key,
+			     &comingih->ih_key);
+		written =
+		    overwrite_by_indirect_item(comingih, (__u32 *) item, path,
+					       pos_in_coming_item);
 	}
-	/* */
-	direct2indirect2 (unfm_ptr, path);
-    }
-    if (is_direct_ih (comingih))
-    {
-	written = overwrite_by_direct_item (comingih, item, path);
-    } else {
-	if (was_in_tree)
-	    reiserfs_panic ("reiserfsck_overwrite_file: Item %k we are going to overwrite with"
-		" %k cannot not be in the tree yet", &ih->ih_key, &comingih->ih_key);
-	written = overwrite_by_indirect_item (comingih, (__u32 *)item, path, pos_in_coming_item);
-    }
 
-    return written;
+	return written;
 }
 
-
 /*
  */
-int reiserfsck_file_write (struct item_head * ih, char * item, int was_in_tree) {
-    struct reiserfs_path path;
-    int count, pos_in_coming_item;
-    long long int retval, written;
-    struct reiserfs_key key;
-    int file_format = KEY_FORMAT_UNDEFINED;
-    int relocated = 0;
-
-    if (!was_in_tree) {
-	__u16 mode;
+int reiserfsck_file_write(struct item_head *ih, char *item, int was_in_tree)
+{
+	struct reiserfs_path path;
+	int count, pos_in_coming_item;
+	long long int retval, written;
+	struct reiserfs_key key;
+	int file_format = KEY_FORMAT_UNDEFINED;
+	int relocated = 0;
+
+	if (!was_in_tree) {
+		__u16 mode;
 
-        /* We already inserted all SD items. If we cannot find SD of this item - skip it */
-	memset (&key, 0, sizeof (key));
+		/* We already inserted all SD items. If we cannot find SD of this item - skip it */
+		memset(&key, 0, sizeof(key));
 
 check_again:
-        copy_short_key (&key, &(ih->ih_key));
-	
-        if (reiserfs_search_by_key_4 (fs, &key, &path) != ITEM_FOUND) {
-            fsck_log ("vpf-10260: The file we are inserting the new item (%H) into has no"
-		" StatData, insertion was skipped\n", ih);
-            pathrelse (&path);
-            return 0;
-        }
-
-        /*SD found*/
-        file_format = get_ih_key_format (get_ih(&path));
-        get_sd_mode (get_ih(&path), get_item(&path), &mode);
-
-        if (file_format != get_ih_key_format (ih)) {
-	    /* Not for symlinks and not for items which should be relocted. */
-	    if (((S_ISDIR(mode) && is_direntry_ih(ih)) || 
-		(!S_ISDIR(mode) && !is_direntry_ih(ih))) && 
-		!S_ISLNK(mode))
-	    {
-		set_type_and_offset (file_format, &ih->ih_key, get_offset (&ih->ih_key), get_type (&ih->ih_key));
-		set_ih_key_format(ih, file_format);		
-	    }
-        }
-
-	if (!relocated && should_relocate (ih)) {
-	    rewrite_file (ih, 1, 1/*change new_ih*/);
-	    pathrelse(&path);
-	    relocated = 1;
-	    
-	    /* object has been relocated but we should not mark it as used in semantic map,
-	       as it does not exist at pass2 and we do not get here for relocation as 
-	       was_in_tree == 1 */
-	    
-	    goto check_again;
-	}
-	
-	if (make_file_writeable (get_bh(&path), get_item_pos (&path)) == -1) {
-	    /* write was not completed. Skip that item. Maybe it should be saved to lost_found */
-	    fsck_log ("reiserfsck_file_write: WARNING: The file we are inserting the new item %k into was"
-		" not recovered and is still in inconsistent state, insertion was skipped\n", &ih->ih_key);
-	    pathrelse(&path);
-	    return 0;
-	}
+		copy_short_key(&key, &(ih->ih_key));
+
+		if (reiserfs_search_by_key_4(fs, &key, &path) != ITEM_FOUND) {
+			fsck_log
+			    ("vpf-10260: The file we are inserting the new item (%H) into has no"
+			     " StatData, insertion was skipped\n", ih);
+			pathrelse(&path);
+			return 0;
+		}
 
-        pathrelse (&path);
-    }
+		/*SD found */
+		file_format = get_ih_key_format(get_ih(&path));
+		get_sd_mode(get_ih(&path), get_item(&path), &mode);
+
+		if (file_format != get_ih_key_format(ih)) {
+			/* Not for symlinks and not for items which should be relocted. */
+			if (((S_ISDIR(mode) && is_direntry_ih(ih)) ||
+			     (!S_ISDIR(mode) && !is_direntry_ih(ih))) &&
+			    !S_ISLNK(mode)) {
+				set_type_and_offset(file_format, &ih->ih_key,
+						    get_offset(&ih->ih_key),
+						    get_type(&ih->ih_key));
+				set_ih_key_format(ih, file_format);
+			}
+		}
 
-    count = get_bytes_number (ih, fs->fs_blocksize);
-    pos_in_coming_item = 0;
+		if (!relocated && should_relocate(ih)) {
+			rewrite_file(ih, 1, 1 /*change new_ih */ );
+			pathrelse(&path);
+			relocated = 1;
 
-    copy_key (&key, &(ih->ih_key));
+			/* object has been relocated but we should not mark it as used in semantic map,
+			   as it does not exist at pass2 and we do not get here for relocation as 
+			   was_in_tree == 1 */
 
-    while (count) {
+			goto check_again;
+		}
 
-	retval = usearch_by_position (fs, &key, key_format (&key), &path);
+		if (make_file_writeable(get_bh(&path), get_item_pos(&path)) ==
+		    -1) {
+			/* write was not completed. Skip that item. Maybe it should be saved to lost_found */
+			fsck_log
+			    ("reiserfsck_file_write: WARNING: The file we are inserting the new item %k into was"
+			     " not recovered and is still in inconsistent state, insertion was skipped\n",
+			     &ih->ih_key);
+			pathrelse(&path);
+			return 0;
+		}
 
-	/*  if there are items of bigger offset than we are looking for and
-	    there is no item between wamted offset and SD, insert first item */
-	if (retval == POSITION_NOT_FOUND &&
-	    (	PATH_LAST_POSITION (&path) >= B_NR_ITEMS (get_bh(&path)) ||
-		get_offset (&get_ih(&path)->ih_key) > get_offset (&key)))
-            retval = FILE_NOT_FOUND;	
-	
-	if (retval == DIRECTORY_FOUND)
-	    reiserfs_panic ("The directory was found at the place of the file we are going to insert"
-		" the item %k into", key);
-
-	if (retval == POSITION_FOUND) {
-	    written = reiserfsck_overwrite_file (ih, item, &path, &pos_in_coming_item, was_in_tree);
-            count -= written;
-	    set_offset (key_format (&key), &key, get_offset (&key) + written);
+		pathrelse(&path);
 	}
-	if (retval == FILE_NOT_FOUND) {
-	    written = create_first_item_of_file (ih, item, &path, was_in_tree);
-	    count -= written;
 
-	    set_offset (key_format (&key), &key, get_offset (&key) + written );
-	}
-	if (retval == POSITION_NOT_FOUND) {
-	
-	    if (is_direct_ih (ih)) {
-	        mark_ih_was_tail (get_ih(&path));
-	        mark_buffer_dirty (get_bh(&path));
-	    }
-	
-	    if ((written = must_there_be_a_hole (ih, &path)) > 0)
-	    {
-		reiserfs_append_zero_unfm_ptr (&path, written);
-	    }else {
-		written = reiserfsck_append_file (ih, item, pos_in_coming_item, &path, was_in_tree);
-		count -= written;
-		set_offset (key_format (&key), &key, get_offset (&key) + written);
-		pos_in_coming_item += written / fs->fs_blocksize;
-	    }
-	}
-	if (count < 0)
-	    reiserfs_panic ("reiserfsck_file_write: We wrote into the file %K more bytes than needed - count (%d) < 0.",
-			    &key, count);
-	pathrelse (&path);
-    }
+	count = get_bytes_number(ih, fs->fs_blocksize);
+	pos_in_coming_item = 0;
+
+	copy_key(&key, &(ih->ih_key));
+
+	while (count) {
+
+		retval = usearch_by_position(fs, &key, key_format(&key), &path);
 
+		/*  if there are items of bigger offset than we are looking for and
+		   there is no item between wamted offset and SD, insert first item */
+		if (retval == POSITION_NOT_FOUND &&
+		    (PATH_LAST_POSITION(&path) >= B_NR_ITEMS(get_bh(&path)) ||
+		     get_offset(&get_ih(&path)->ih_key) > get_offset(&key)))
+			retval = FILE_NOT_FOUND;
 
-    /* This is a test for writing into the file. If not sure that file data are consistent after
-       reiserfsck_file_write - uncomment this clause: */
+		if (retval == DIRECTORY_FOUND)
+			reiserfs_panic
+			    ("The directory was found at the place of the file we are going to insert"
+			     " the item %k into", key);
+
+		if (retval == POSITION_FOUND) {
+			written =
+			    reiserfsck_overwrite_file(ih, item, &path,
+						      &pos_in_coming_item,
+						      was_in_tree);
+			count -= written;
+			set_offset(key_format(&key), &key,
+				   get_offset(&key) + written);
+		}
+		if (retval == FILE_NOT_FOUND) {
+			written =
+			    create_first_item_of_file(ih, item, &path,
+						      was_in_tree);
+			count -= written;
+
+			set_offset(key_format(&key), &key,
+				   get_offset(&key) + written);
+		}
+		if (retval == POSITION_NOT_FOUND) {
+
+			if (is_direct_ih(ih)) {
+				mark_ih_was_tail(get_ih(&path));
+				mark_buffer_dirty(get_bh(&path));
+			}
+
+			if ((written = must_there_be_a_hole(ih, &path)) > 0) {
+				reiserfs_append_zero_unfm_ptr(&path, written);
+			} else {
+				written =
+				    reiserfsck_append_file(ih, item,
+							   pos_in_coming_item,
+							   &path, was_in_tree);
+				count -= written;
+				set_offset(key_format(&key), &key,
+					   get_offset(&key) + written);
+				pos_in_coming_item +=
+				    written / fs->fs_blocksize;
+			}
+		}
+		if (count < 0)
+			reiserfs_panic
+			    ("reiserfsck_file_write: We wrote into the file %K more bytes than needed - count (%d) < 0.",
+			     &key, count);
+		pathrelse(&path);
+	}
+
+	/* This is a test for writing into the file. If not sure that file data are consistent after
+	   reiserfsck_file_write - uncomment this clause: */
 
 /*    if (!was_in_tree && are_file_items_correct (&ih->ih_key,
     	(file_format == KEY_FORMAT_UNDEFINED) ?	get_ih_key_format (ih) : file_format,
     	&size, &blocks, 0, symlink, 0) == 0)
         reiserfs_panic ("reiserfsck_file_write: item was not inserted properly\n");*/
 
-    return get_bytes_number (ih, fs->fs_blocksize);
+	return get_bytes_number(ih, fs->fs_blocksize);
 }
 
-
-void one_more_corruption(reiserfs_filsys_t *fs, int kind) {
-    if (kind == FATAL)
-	fsck_check_stat (fs)->fatal_corruptions++;
-    else if (kind == FIXABLE)
-	fsck_check_stat (fs)->fixable_corruptions++;
+void one_more_corruption(reiserfs_filsys_t *fs, int kind)
+{
+	if (kind == FATAL)
+		fsck_check_stat(fs)->fatal_corruptions++;
+	else if (kind == FIXABLE)
+		fsck_check_stat(fs)->fixable_corruptions++;
 }
 
-void one_less_corruption(reiserfs_filsys_t *fs, int kind) {
-    if (kind == FATAL)
-	fsck_check_stat (fs)->fatal_corruptions--;
-    else if (kind == FIXABLE)
-	fsck_check_stat (fs)->fixable_corruptions--;
+void one_less_corruption(reiserfs_filsys_t *fs, int kind)
+{
+	if (kind == FATAL)
+		fsck_check_stat(fs)->fatal_corruptions--;
+	else if (kind == FIXABLE)
+		fsck_check_stat(fs)->fixable_corruptions--;
 }
diff --git a/fsck/uobjectid.c b/fsck/uobjectid.c
index fcd79f3..33b5b7c 100644
--- a/fsck/uobjectid.c
+++ b/fsck/uobjectid.c
@@ -5,7 +5,6 @@
 
 #include "fsck.h"
 
-
 /* when --check fsck builds a map of objectids of files it finds in the tree
    when --rebuild-tree - fsck builds map of objectids it inserts into tree */
 
@@ -28,111 +27,116 @@ typedef struct sb_id_map {
 } sb_id_map_t;
 */
 
-id_map_t *id_map_init() {
-    id_map_t *map;
-    __u32 i;
- 
-    map = getmem(sizeof(id_map_t));
-    map->index = mem_alloc(INDEX_COUNT * sizeof(void *));
+id_map_t *id_map_init()
+{
+	id_map_t *map;
+	__u32 i;
 
-    for (i = 0; i < INDEX_COUNT; i++) {
-	if (map->index[i] != (void *)0)
-	    map->index[i] = (void *)0;
-    }
+	map = getmem(sizeof(id_map_t));
+	map->index = mem_alloc(INDEX_COUNT * sizeof(void *));
 
-    id_map_mark(map, 0);
-    id_map_mark(map, 1);
+	for (i = 0; i < INDEX_COUNT; i++) {
+		if (map->index[i] != (void *)0)
+			map->index[i] = (void *)0;
+	}
 
-    /* id == 0 should not be there, just for convinient usage */
-    map->count--;
-    
-    return map;
+	id_map_mark(map, 0);
+	id_map_mark(map, 1);
+
+	/* id == 0 should not be there, just for convinient usage */
+	map->count--;
+
+	return map;
 }
 
-void id_map_free(id_map_t *map) {
-    __u32 i;
- 
-    for (i = 0; i < INDEX_COUNT; i++) {
-	if (map->index[i] != (void *)0 && map->index[i] != (void *)1)
-	    freemem(map->index[i]);
-    }
-    
-    freemem(map->index);
-    freemem(map);
+void id_map_free(id_map_t *map)
+{
+	__u32 i;
+
+	for (i = 0; i < INDEX_COUNT; i++) {
+		if (map->index[i] != (void *)0 && map->index[i] != (void *)1)
+			freemem(map->index[i]);
+	}
+
+	freemem(map->index);
+	freemem(map);
 }
 
-int id_map_test(id_map_t *map, __u32 id) {
-    void **interval = id_map_interval(map, id);
+int id_map_test(id_map_t *map, __u32 id)
+{
+	void **interval = id_map_interval(map, id);
 
-    if (*interval == (void *)0)
-	return 0;
-    
-    if (*interval == (void *)1)
-	return 1;
-    
-    return misc_test_bit(id % BM_INTERVAL, *interval);
+	if (*interval == (void *)0)
+		return 0;
+
+	if (*interval == (void *)1)
+		return 1;
+
+	return misc_test_bit(id % BM_INTERVAL, *interval);
 }
 
-int id_map_mark(id_map_t *map, __u32 id) {
-    void **interval = id_map_interval(map, id);
+int id_map_mark(id_map_t *map, __u32 id)
+{
+	void **interval = id_map_interval(map, id);
+
+	if (*interval == (void *)0)
+		*interval = getmem(ALLOC_SIZE);
 
-    if (*interval == (void *)0)
-	*interval = getmem(ALLOC_SIZE);
+	if (*interval == (void *)1)
+		return 1;
 
-    if (*interval == (void *)1)
-	return 1;
+	if (misc_test_bit(id % BM_INTERVAL, *interval))
+		return 1;
 
-    if (misc_test_bit(id % BM_INTERVAL, *interval))
-	return 1;
-	
-    misc_set_bit(id % BM_INTERVAL, *interval);
-    
-    (*(__u16 *)id_map_local_count(*interval))++;
-    map->count++;
+	misc_set_bit(id % BM_INTERVAL, *interval);
 
-    if ((*(__u16 *)id_map_local_count(*interval)) == BM_INTERVAL) {
-	/* Dealloc fully used bitmap */
-	freemem(*interval);
-	*interval = (void *)1;
-    }
+	(*(__u16 *) id_map_local_count(*interval))++;
+	map->count++;
 
-    if (map->last_used < (id / BM_INTERVAL))
-	map->last_used = id / BM_INTERVAL;
-    
-    return 0;
+	if ((*(__u16 *) id_map_local_count(*interval)) == BM_INTERVAL) {
+		/* Dealloc fully used bitmap */
+		freemem(*interval);
+		*interval = (void *)1;
+	}
+
+	if (map->last_used < (id / BM_INTERVAL))
+		map->last_used = id / BM_INTERVAL;
+
+	return 0;
 }
 
 /* call this for proper_id_map only!! */
-__u32 id_map_alloc(id_map_t *map) {
-    __u32 i, zero_count;
-    __u32 id = 0, first = ~(__u32)0;
-
-    for (i = 0, zero_count = 0; zero_count < 10 && i < INDEX_COUNT - 1; i++) {
-	if (map->index[i] == (void *)0) {
-	    if (zero_count == 0)
-		first = i;
-	    
-	    zero_count++;
-	} else if (map->index[i] != (void *)1)
-	    break;
-    }
+__u32 id_map_alloc(id_map_t *map)
+{
+	__u32 i, zero_count;
+	__u32 id = 0, first = ~(__u32) 0;
 
-    if (map->index[i] != (void *)1 && map->index[i] != (void *)0) {
-	id = misc_find_first_zero_bit(map->index[i], BM_INTERVAL);
-	if (id >= BM_INTERVAL)
-	    die ("Id is out of interval size, interval looks corrupted.");
-	
-	id += i * BM_INTERVAL;
-    } else if (first != ~(__u32)0) {
-	id = first * BM_INTERVAL;
-	if (id == 0) 
-	    id = 2;
-    } else 
-	die ("%s: No more free objectid is available.", __FUNCTION__);
+	for (i = 0, zero_count = 0; zero_count < 10 && i < INDEX_COUNT - 1; i++) {
+		if (map->index[i] == (void *)0) {
+			if (zero_count == 0)
+				first = i;
+
+			zero_count++;
+		} else if (map->index[i] != (void *)1)
+			break;
+	}
+
+	if (map->index[i] != (void *)1 && map->index[i] != (void *)0) {
+		id = misc_find_first_zero_bit(map->index[i], BM_INTERVAL);
+		if (id >= BM_INTERVAL)
+			die("Id is out of interval size, interval looks corrupted.");
 
-    id_map_mark(map, id);
+		id += i * BM_INTERVAL;
+	} else if (first != ~(__u32) 0) {
+		id = first * BM_INTERVAL;
+		if (id == 0)
+			id = 2;
+	} else
+		die("%s: No more free objectid is available.", __FUNCTION__);
 
-    return id;
+	id_map_mark(map, id);
+
+	return id;
 }
 
 /* this could be used if some more sofisticated flushing will be needed. */
@@ -143,133 +147,143 @@ static void sb_id_map_pack(sb_id_map_t *map) {
     map->m_used_slot_count = 2;
 }*/
 
-static __u32 id_map_next_bound(id_map_t *map, __u32 start) {
-    __u32 index = start / BM_INTERVAL;
-    __u32 offset = start % BM_INTERVAL;
-    int look_for;
-    
-    if (map->index[index] == (void *)0)
-	look_for = 1;
-    else if (map->index[index] == (void *)1)
-	look_for = 0;
-    else 
-	look_for = !misc_test_bit(offset, map->index[index]);
+static __u32 id_map_next_bound(id_map_t *map, __u32 start)
+{
+	__u32 index = start / BM_INTERVAL;
+	__u32 offset = start % BM_INTERVAL;
+	int look_for;
+
+	if (map->index[index] == (void *)0)
+		look_for = 1;
+	else if (map->index[index] == (void *)1)
+		look_for = 0;
+	else
+		look_for = !misc_test_bit(offset, map->index[index]);
 
-    offset++;
+	offset++;
 
 start_again:
-    
-    if (look_for) {	
-	while (index < INDEX_COUNT && map->index[index] == (void *)0)
-	    index++;
-	
-	if (index == INDEX_COUNT)
-	    return 0;
-	
-	if (map->index[index] == (void *)1)
-	    return index * BM_INTERVAL;
-	
-	offset = misc_find_next_set_bit(map->index[index], BM_INTERVAL, offset);
 
-	if (offset >= BM_INTERVAL) {
-	    offset = 0;
-	    index++;
-	    goto start_again;
-	}
-	
-	return index * BM_INTERVAL + offset;
-    } else {
-	while (index < INDEX_COUNT && map->index[index] == (void *)1)
-	    index++;
-	
-	if (index == INDEX_COUNT)
-	    return 0;
-	
-	if (map->index[index] == (void *)0)
-	    return index * BM_INTERVAL;
+	if (look_for) {
+		while (index < INDEX_COUNT && map->index[index] == (void *)0)
+			index++;
 
-	offset = misc_find_next_zero_bit(map->index[index], BM_INTERVAL, offset);
-	
-	if (offset >= BM_INTERVAL) {
-	    offset = 0;
-	    index++;
-	    goto start_again;
+		if (index == INDEX_COUNT)
+			return 0;
+
+		if (map->index[index] == (void *)1)
+			return index * BM_INTERVAL;
+
+		offset =
+		    misc_find_next_set_bit(map->index[index], BM_INTERVAL,
+					   offset);
+
+		if (offset >= BM_INTERVAL) {
+			offset = 0;
+			index++;
+			goto start_again;
+		}
+
+		return index * BM_INTERVAL + offset;
+	} else {
+		while (index < INDEX_COUNT && map->index[index] == (void *)1)
+			index++;
+
+		if (index == INDEX_COUNT)
+			return 0;
+
+		if (map->index[index] == (void *)0)
+			return index * BM_INTERVAL;
+
+		offset =
+		    misc_find_next_zero_bit(map->index[index], BM_INTERVAL,
+					    offset);
+
+		if (offset >= BM_INTERVAL) {
+			offset = 0;
+			index++;
+			goto start_again;
+		}
+
+		return index * BM_INTERVAL + offset;
 	}
-	
-	return index * BM_INTERVAL + offset;
-    }
 }
 
-void id_map_flush(struct id_map * map, reiserfs_filsys_t * fs) {
-    int size, max, i;
-    __u32 id, prev_id;
-    __u32 * sb_objectid_map;
+void id_map_flush(struct id_map *map, reiserfs_filsys_t *fs)
+{
+	int size, max, i;
+	__u32 id, prev_id;
+	__u32 *sb_objectid_map;
+
+	size = reiserfs_super_block_size(fs->fs_ondisk_sb);
+	sb_objectid_map = (__u32 *) ((char *)(fs->fs_ondisk_sb) + size);
+
+	max = ((fs->fs_blocksize - size) >> 3 << 1);
+	set_sb_oid_maxsize(fs->fs_ondisk_sb, max);
+
+	id = 1;
+	sb_objectid_map[0] = cpu_to_le32(1);
+
+	for (i = 1; i < max - 1; i++) {
+		id = id_map_next_bound(map, id);
+		sb_objectid_map[i] = cpu_to_le32(id);
+		if (id == 0) {
+			if (i % 2)
+				die("%s: Used interval is not closed on flushing.", __FUNCTION__);
+			break;
+		}
+	}
 
-    size = reiserfs_super_block_size (fs->fs_ondisk_sb);
-    sb_objectid_map = (__u32 *)((char *)(fs->fs_ondisk_sb) + size);
+	if (map->index[map->last_used] == (void *)0)
+		die("Object id map looks corrupted - last used interval cannot be zeroed.");
 
-    max = ((fs->fs_blocksize - size) >> 3 << 1);
-    set_sb_oid_maxsize (fs->fs_ondisk_sb, max);
-    
-    id = 1;
-    sb_objectid_map[0] = cpu_to_le32(1);
-
-    for (i = 1; i < max - 1; i++) {
-	id = id_map_next_bound(map, id);
-	sb_objectid_map[i] = cpu_to_le32(id);
-	if (id == 0) {
-	    if (i % 2)
-		die ("%s: Used interval is not closed on flushing.", __FUNCTION__);
-	    break;
-	}
-    }
+	i++;
 
-    if (map->index[map->last_used] == (void *)0)
-	die ("Object id map looks corrupted - last used interval cannot be zeroed.");
-    
-    i++;
-    
-    if (i == max) {
-	if (id == 0)
-	    die ("Objectid interval does not contain any set bit what is expected.");
-	
-	if (map->index[map->last_used] == (void *)1) {
-	    prev_id = BM_INTERVAL - 1;
-	} else {	    
-	    prev_id = ~(__u32)0;
-	    
-	    if (id < map->last_used * BM_INTERVAL)
-		id = 0;
-	    else 
-		id %= BM_INTERVAL;
-	    
-	    if (misc_test_bit(id, map->index[map->last_used]))
-		prev_id = id;
-	    
-	    while ((id = misc_find_next_set_bit(map->index[map->last_used], 
-		BM_INTERVAL, (id + 1))) != BM_INTERVAL) 
-	    {
-		prev_id = id;
-	    }
-
-	    if (prev_id == ~(__u32)0)
-		die ("Objectid interval does not contain any set bit what is expected.");
-
-	    prev_id++;
+	if (i == max) {
+		if (id == 0)
+			die("Objectid interval does not contain any set bit what is expected.");
+
+		if (map->index[map->last_used] == (void *)1) {
+			prev_id = BM_INTERVAL - 1;
+		} else {
+			prev_id = ~(__u32) 0;
+
+			if (id < map->last_used * BM_INTERVAL)
+				id = 0;
+			else
+				id %= BM_INTERVAL;
+
+			if (misc_test_bit(id, map->index[map->last_used]))
+				prev_id = id;
+
+			while ((id =
+				misc_find_next_set_bit(map->
+						       index[map->last_used],
+						       BM_INTERVAL,
+						       (id + 1))) !=
+			       BM_INTERVAL) {
+				prev_id = id;
+			}
+
+			if (prev_id == ~(__u32) 0)
+				die("Objectid interval does not contain any set bit what is expected.");
+
+			prev_id++;
+		}
+
+		sb_objectid_map[max - 1] =
+		    cpu_to_le32(prev_id + map->last_used * BM_INTERVAL);
+	} else {
+		i--;
+		memset(sb_objectid_map + i, 0, (max - i) * sizeof(__u32));
 	}
-	
-	sb_objectid_map[max - 1] = cpu_to_le32(prev_id + map->last_used * BM_INTERVAL);
-    } else { 
-	i--;
-	memset(sb_objectid_map + i, 0, (max - i) * sizeof (__u32));
-    }
 
-    set_sb_oid_cursize (fs->fs_ondisk_sb, i);
+	set_sb_oid_cursize(fs->fs_ondisk_sb, i);
 }
 
 /* FIXME: these 3 methods must be implemented also.
 
-void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t * fs)
+void fetch_objectid_map (struct id_map * map, reiserfs_filsys_t *fs)
 {
     int sb_size;
     __u32 * sb_objectid_map;
diff --git a/fsck/ustree.c b/fsck/ustree.c
index 8046999..c5df62a 100644
--- a/fsck/ustree.c
+++ b/fsck/ustree.c
@@ -6,106 +6,114 @@
 #include "fsck.h"
 #include "progbar.h"
 
-struct tree_balance * cur_tb = 0;
+struct tree_balance *cur_tb = 0;
 
-void reiserfsck_paste_into_item (struct reiserfs_path *path, const char * body, int size)
+void reiserfsck_paste_into_item(struct reiserfs_path *path, const char *body,
+				int size)
 {
-    struct tree_balance tb;
-  
-    init_tb_struct (&tb, fs, path, size);
-    if (fix_nodes (/*tb.transaction_handle,*/ M_PASTE, &tb, 0/*ih*/) != CARRY_ON)
-	//fix_nodes(options, tree_balance, ih_to_option, body_to_option)
-	
-	die ("reiserfsck_paste_into_item: fix_nodes failed");
-    
-    do_balance (/*tb.transaction_handle,*/ &tb, 0, body, M_PASTE, 0/*zero num*/);
-}
+	struct tree_balance tb;
 
+	init_tb_struct(&tb, fs, path, size);
+	if (fix_nodes( /*tb.transaction_handle, */ M_PASTE, &tb, 0 /*ih */ ) !=
+	    CARRY_ON)
+		//fix_nodes(options, tree_balance, ih_to_option, body_to_option)
 
-void reiserfsck_insert_item (struct reiserfs_path *path, struct item_head * ih, const char * body)
-{
-    struct tree_balance tb;
-    
-    init_tb_struct (&tb, fs, path, IH_SIZE + get_ih_item_len(ih));
-    if (fix_nodes (/*tb.transaction_handle,*/ M_INSERT, &tb, ih/*, body*/) != CARRY_ON)
-	die ("reiserfsck_insert_item: fix_nodes failed");
-    do_balance (/*tb.transaction_handle,*/ &tb, ih, body, M_INSERT, 0/*zero num*/);
+		die("reiserfsck_paste_into_item: fix_nodes failed");
+
+	do_balance( /*tb.transaction_handle, */ &tb, 0, body, M_PASTE,
+		   0 /*zero num */ );
 }
 
+void reiserfsck_insert_item(struct reiserfs_path *path, struct item_head *ih,
+			    const char *body)
+{
+	struct tree_balance tb;
+
+	init_tb_struct(&tb, fs, path, IH_SIZE + get_ih_item_len(ih));
+	if (fix_nodes
+	    ( /*tb.transaction_handle, */ M_INSERT, &tb,
+	     ih /*, body */ ) != CARRY_ON)
+		die("reiserfsck_insert_item: fix_nodes failed");
+	do_balance( /*tb.transaction_handle, */ &tb, ih, body, M_INSERT,
+		   0 /*zero num */ );
+}
 
-static void free_unformatted_nodes (struct item_head * ih, struct buffer_head * bh)
+static void free_unformatted_nodes(struct item_head *ih, struct buffer_head *bh)
 {
-    __u32 * punfm = (__u32 *)B_I_PITEM (bh, ih);
-    unsigned int i;
-
-    for (i = 0; i < I_UNFM_NUM (ih); i ++) {
-        __u32 unfm = d32_get (punfm, i);
-	if (unfm != 0) {
-	    struct buffer_head * to_be_forgotten;
-
-	    to_be_forgotten = find_buffer (fs->fs_dev, unfm, fs->fs_blocksize);
-	    if (to_be_forgotten) {
-		//atomic_inc(&to_be_forgotten->b_count);
-		to_be_forgotten->b_count ++;
-		bforget (to_be_forgotten);
-	    }
-
-	    reiserfs_free_block (fs, unfm);
+	__u32 *punfm = (__u32 *) B_I_PITEM(bh, ih);
+	unsigned int i;
+
+	for (i = 0; i < I_UNFM_NUM(ih); i++) {
+		__u32 unfm = d32_get(punfm, i);
+		if (unfm != 0) {
+			struct buffer_head *to_be_forgotten;
+
+			to_be_forgotten =
+			    find_buffer(fs->fs_dev, unfm, fs->fs_blocksize);
+			if (to_be_forgotten) {
+				//atomic_inc(&to_be_forgotten->b_count);
+				to_be_forgotten->b_count++;
+				bforget(to_be_forgotten);
+			}
+
+			reiserfs_free_block(fs, unfm);
+		}
 	}
-    }
 }
 
-void reiserfsck_delete_item (struct reiserfs_path *path, int temporary)
+void reiserfsck_delete_item(struct reiserfs_path *path, int temporary)
 {
-    struct tree_balance tb;
-    struct item_head * ih = PATH_PITEM_HEAD (path);
-    
-    if (is_indirect_ih (ih) && !temporary)
-	free_unformatted_nodes (ih, PATH_PLAST_BUFFER (path));
-
-    init_tb_struct (&tb, fs, path, -(IH_SIZE + get_ih_item_len(ih)));
-
-    if (fix_nodes (/*tb.transaction_handle,*/ M_DELETE, &tb, 0/*ih*/) != CARRY_ON)
-	die ("reiserfsck_delete_item: fix_nodes failed");
-    
-    do_balance (/*tb.transaction_handle,*/ &tb, 0, 0, M_DELETE, 0/*zero num*/);
-}
+	struct tree_balance tb;
+	struct item_head *ih = PATH_PITEM_HEAD(path);
+
+	if (is_indirect_ih(ih) && !temporary)
+		free_unformatted_nodes(ih, PATH_PLAST_BUFFER(path));
 
+	init_tb_struct(&tb, fs, path, -(IH_SIZE + get_ih_item_len(ih)));
 
-void reiserfsck_cut_from_item (struct reiserfs_path *path, int cut_size)
+	if (fix_nodes( /*tb.transaction_handle, */ M_DELETE, &tb, 0 /*ih */ ) !=
+	    CARRY_ON)
+		die("reiserfsck_delete_item: fix_nodes failed");
+
+	do_balance( /*tb.transaction_handle, */ &tb, 0, 0, M_DELETE,
+		   0 /*zero num */ );
+}
+
+void reiserfsck_cut_from_item(struct reiserfs_path *path, int cut_size)
 {
-    struct tree_balance tb;
-    struct item_head * ih;
-
-    if (cut_size >= 0)
-	die ("reiserfsck_cut_from_item: cut size == %d", cut_size);
-
-    if (is_indirect_ih (ih = PATH_PITEM_HEAD (path))) {
-	struct buffer_head *bh = PATH_PLAST_BUFFER (path);
-	__u32 unfm_ptr = d32_get ((__u32 *)B_I_PITEM(bh, ih), I_UNFM_NUM (ih) - 1);
-	if (unfm_ptr != 0) {
-	    struct buffer_head * to_be_forgotten;
-
-	    to_be_forgotten = find_buffer (fs->fs_dev, unfm_ptr, fs->fs_blocksize);
-	    if (to_be_forgotten) {
-		//atomic_inc(&to_be_forgotten->b_count);
-		to_be_forgotten->b_count ++;
-		bforget (to_be_forgotten);
-	    }
-	    reiserfs_free_block (fs, unfm_ptr);
+	struct tree_balance tb;
+	struct item_head *ih;
+
+	if (cut_size >= 0)
+		die("reiserfsck_cut_from_item: cut size == %d", cut_size);
+
+	if (is_indirect_ih(ih = PATH_PITEM_HEAD(path))) {
+		struct buffer_head *bh = PATH_PLAST_BUFFER(path);
+		__u32 unfm_ptr =
+		    d32_get((__u32 *) B_I_PITEM(bh, ih), I_UNFM_NUM(ih) - 1);
+		if (unfm_ptr != 0) {
+			struct buffer_head *to_be_forgotten;
+
+			to_be_forgotten =
+			    find_buffer(fs->fs_dev, unfm_ptr, fs->fs_blocksize);
+			if (to_be_forgotten) {
+				//atomic_inc(&to_be_forgotten->b_count);
+				to_be_forgotten->b_count++;
+				bforget(to_be_forgotten);
+			}
+			reiserfs_free_block(fs, unfm_ptr);
+		}
 	}
-    }
 
+	init_tb_struct(&tb, fs, path, cut_size);
 
-    init_tb_struct (&tb, fs, path, cut_size);
+	if (fix_nodes( /*tb.transaction_handle, */ M_CUT, &tb, 0) != CARRY_ON)
+		die("reiserfsck_cut_from_item: fix_nodes failed");
 
-    if (fix_nodes (/*tb.transaction_handle,*/ M_CUT, &tb, 0) != CARRY_ON)
-	die ("reiserfsck_cut_from_item: fix_nodes failed");
-
-    do_balance (/*tb.transaction_handle,*/ &tb, 0, 0, M_CUT, 0/*zero num*/);
+	do_balance( /*tb.transaction_handle, */ &tb, 0, 0, M_CUT,
+		   0 /*zero num */ );
 }
 
-
 /* uget_rkey is utils clone of stree.c/get_rkey */
 /*
 struct reiserfs_key *uget_rkey (struct reiserfs_path *path)
@@ -143,147 +151,148 @@ struct reiserfs_key *uget_rkey (struct reiserfs_path *path)
 }
 */
 
-
-static unsigned long first_child (struct buffer_head * bh)
+static unsigned long first_child(struct buffer_head *bh)
 {
-    return get_dc_child_blocknr (B_N_CHILD (bh, 0));
+	return get_dc_child_blocknr(B_N_CHILD(bh, 0));
 }
 
 #if 0
-static unsigned long last_child (struct buffer_head * bh)
+static unsigned long last_child(struct buffer_head *bh)
 {
-    return child_block_number (bh, node_item_number (bh));
+	return child_block_number(bh, node_item_number(bh));
 }
 #endif
 
-
-static unsigned long get_child (int pos, struct buffer_head * parent)
+static unsigned long get_child(int pos, struct buffer_head *parent)
 {
-    if (pos == -1)
-        return -1;
+	if (pos == -1)
+		return -1;
 
-    if (pos > B_NR_ITEMS (parent))
-        die ("get_child: no child found, should not happen: %d of %d", pos, B_NR_ITEMS (parent));
-    return get_dc_child_blocknr (B_N_CHILD (parent, pos));
+	if (pos > B_NR_ITEMS(parent))
+		die("get_child: no child found, should not happen: %d of %d",
+		    pos, B_NR_ITEMS(parent));
+	return get_dc_child_blocknr(B_N_CHILD(parent, pos));
 
 }
 
-
-static void print (int cur, int total)
+static void print(int cur, int total)
 {
-    if (fsck_quiet (fs))
-	return;
-    printf ("/%3d (of %3d)", cur, total);fflush (stdout);
+	if (fsck_quiet(fs))
+		return;
+	printf("/%3d (of %3d)", cur, total);
+	fflush(stdout);
 }
 
-
 /* erase /XXX(of XXX) */
-static void erase (void)
+static void erase(void)
 {
-    if (fsck_quiet (fs))
-	return;
-    printf ("\b\b\b\b\b\b\b\b\b\b\b\b\b");
-    printf ("             ");
-    printf ("\b\b\b\b\b\b\b\b\b\b\b\b\b");
-    fflush (stdout);
+	if (fsck_quiet(fs))
+		return;
+	printf("\b\b\b\b\b\b\b\b\b\b\b\b\b");
+	printf("             ");
+	printf("\b\b\b\b\b\b\b\b\b\b\b\b\b");
+	fflush(stdout);
 }
 
-void pass_through_tree (reiserfs_filsys_t * fs, do_after_read_t action1,
-			do_on_full_path_t action2, int depth)
+void pass_through_tree(reiserfs_filsys_t *fs, do_after_read_t action1,
+		       do_on_full_path_t action2, int depth)
 {
-    struct buffer_head * path[MAX_HEIGHT] = {0,};
-    int total[MAX_HEIGHT] = {0,};
-    int cur[MAX_HEIGHT] = {0,};
-    int h = 0;
-    unsigned long block = get_sb_root_block (fs->fs_ondisk_sb);
-    int problem;
-    struct spinner spinner;
-
-    spinner_init(&spinner, fsck_progress_file(fs));
-
+	struct buffer_head *path[MAX_HEIGHT] = { 0, };
+	int total[MAX_HEIGHT] = { 0, };
+	int cur[MAX_HEIGHT] = { 0, };
+	int h = 0;
+	unsigned long block = get_sb_root_block(fs->fs_ondisk_sb);
+	int problem;
+	struct spinner spinner;
+
+	spinner_init(&spinner, fsck_progress_file(fs));
+
+	if (block >= get_sb_block_count(fs->fs_ondisk_sb)
+	    || not_data_block(fs, block)) {
+		die("\nBad root block %lu. (--rebuild-tree did not complete)\n",
+		    block);
+	}
 
-    if (block >= get_sb_block_count (fs->fs_ondisk_sb) || not_data_block (fs, block)) {
-	die ("\nBad root block %lu. (--rebuild-tree did not complete)\n", block);
-    }
+	while (1) {
+		problem = 0;
+
+		if (path[h])
+			die("pass_through_tree: empty slot expected");
+		if (h)
+			print(cur[h - 1], total[h - 1]);
+
+		if (fs->fs_badblocks_bm
+		    && reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, block)) {
+			fsck_log
+			    ("%s: block %lu specified in badblock list found in tree, whole subtree skipped\n",
+			     __FUNCTION__, block);
+			fsck_data(fs)->check.bad_nodes++;
+			one_more_corruption(fs, FATAL);
+
+			if (h == 0) {
+				brelse(path[h]);
+				path[h] = 0;
+				break;
+			}
+			problem = 1;
+		} else {
+
+			spinner_touch(&spinner);
+			path[h] = bread(fs->fs_dev, block, fs->fs_blocksize);
+			if (path[h] == 0)
+				/* FIXME: handle case when read failed */
+				die("pass_through_tree: unable to read %lu block on device 0x%x\n", block, fs->fs_dev);
+
+			if (action1)
+				if ((problem = action1(fs, path, h))) {
+					fsck_log
+					    (" the problem in the internal node occured (%lu), whole subtree is skipped\n",
+					     path[h]->b_blocknr);
+					fsck_data(fs)->check.bad_nodes++;
+
+					if (h == 0) {
+						brelse(path[h]);
+						path[h] = 0;
+						break;
+					}
+				}
+		}
 
-    while ( 1 ) {
-	problem = 0;
-
-        if (path[h])
-            die ("pass_through_tree: empty slot expected");
-        if (h)
-            print (cur[h - 1], total[h - 1]);
-
-	if (fs->fs_badblocks_bm && reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, block)) {
-	    fsck_log ("%s: block %lu specified in badblock list found in tree, whole subtree skipped\n",
-		__FUNCTION__, block);
-	    fsck_data (fs)->check.bad_nodes++;
-	    one_more_corruption (fs, FATAL);
-
-	    if (h == 0) {
-		brelse (path[h]);
-		path[h] = 0;
-		break;
-	    }
-	    problem = 1;		
-	} else {
-
-	    spinner_touch(&spinner);
-	    path[h] = bread (fs->fs_dev, block, fs->fs_blocksize);
-	    if (path[h] == 0)
-		/* FIXME: handle case when read failed */
-		die ("pass_through_tree: unable to read %lu block on device 0x%x\n",
-			block, fs->fs_dev);
-
-	    if (action1)
-		if ((problem = action1 (fs, path, h))) {
-		    fsck_log (" the problem in the internal node occured (%lu), whole subtree is skipped\n", 
-			path[h]->b_blocknr);
-		    fsck_data (fs)->check.bad_nodes++;
- 
-		    if (h == 0) {
-			brelse (path[h]);
+		/* Time to stop. */
+		if (h == depth)
+			problem++;
+
+		if (problem || is_leaf_node(path[h])) {
+			if (!problem && action2)
+				action2(fs, path, h);
+
+			brelse(path[h]);
+			if (h)
+				erase();
+
+			while (h && (cur[h - 1] == total[h - 1] || problem)) {
+				problem = 0;
+				path[h] = 0;
+				h--;
+				brelse(path[h]);
+				if (h)
+					erase();
+			}
+
+			if (h == 0) {
+				path[h] = 0;
+				break;
+			}
+
+			block = get_child(cur[h - 1], path[h - 1]);
+			cur[h - 1]++;
 			path[h] = 0;
-			break;
-		    }
+			continue;
 		}
+		total[h] = B_NR_ITEMS(path[h]) + 1;
+		cur[h] = 1;
+		block = first_child(path[h]);
+		h++;
 	}
-
-	/* Time to stop. */
-	if (h == depth)
-	    problem ++;
-
-        if (problem || is_leaf_node (path[h])) {
-            if (!problem && action2)
-                action2 (fs, path, h);
-
-	    brelse (path[h]);
-            if (h)
-		erase ();
-
-            while (h && (cur[h-1] == total[h-1] || problem)) {
-                problem = 0;
-                path[h] = 0;
-                h --;
-                brelse (path[h]);
-                if (h)
-                    erase ();
-	    }
-
-    	    if (h == 0) {
-    	    	path[h] = 0;
-		break;
-    	    }
-
-            block = get_child (cur[h - 1], path[h-1]);
-            cur[h - 1] ++;
-            path[h] = 0;
-            continue;
-	}
-        total[h] = B_NR_ITEMS (path[h]) + 1;
-        cur[h] = 1;
-        block = first_child (path[h]);
-        h ++;
-    }
-    spinner_clear(&spinner);
+	spinner_clear(&spinner);
 }
diff --git a/include/io.h b/include/io.h
index d4dc0f0..ebfdcaa 100644
--- a/include/io.h
+++ b/include/io.h
@@ -18,20 +18,20 @@
 #include "misc.h"
 
 struct buffer_head {
-    unsigned long b_blocknr;
-    int b_dev;
-    unsigned long b_size;
-    char * b_data;
-    unsigned long b_state;
-    unsigned int b_count;
-    unsigned int b_list ;
-    void (*b_start_io) (unsigned long);
-    void (*b_end_io)(struct buffer_head *bh, int uptodate);
-    
-    struct buffer_head * b_next;
-    struct buffer_head * b_prev;
-    struct buffer_head * b_hash_next;
-    struct buffer_head * b_hash_prev;
+	unsigned long b_blocknr;
+	int b_dev;
+	unsigned long b_size;
+	char *b_data;
+	unsigned long b_state;
+	unsigned int b_count;
+	unsigned int b_list;
+	void (*b_start_io) (unsigned long);
+	void (*b_end_io) (struct buffer_head * bh, int uptodate);
+
+	struct buffer_head *b_next;
+	struct buffer_head *b_prev;
+	struct buffer_head *b_hash_next;
+	struct buffer_head *b_hash_prev;
 };
 
 #define BH_Uptodate	0
@@ -39,7 +39,6 @@ struct buffer_head {
 #define BH_Lock		2
 #define BH_Do_not_flush 3
 
-
 #define buffer_uptodate(bh) misc_test_bit(BH_Uptodate, &(bh)->b_state)
 #define buffer_dirty(bh) misc_test_bit(BH_Dirty, &(bh)->b_state)
 #define buffer_locked(bh) misc_test_bit(BH_Lock, &(bh)->b_state)
@@ -59,27 +58,28 @@ __FILE__, __FUNCTION__, __LINE__,
 	__builtin_return_address (2));
 */
 
+void __wait_on_buffer(struct buffer_head *bh);
+struct buffer_head *getblk(int dev, unsigned long block, int size);
+struct buffer_head *reiserfs_getblk(int dev, unsigned long block, int size,
+				    int *repeat);
 
+struct buffer_head *find_buffer(int dev, unsigned long block,
+				unsigned long size);
+struct buffer_head *get_hash_table(dev_t dev, unsigned long block, int size);
+struct buffer_head *bread(int dev, unsigned long block, size_t size);
+struct buffer_head *reiserfs_bread(int dev, unsigned long block, int size,
+				   int *repeat);
+int bwrite(struct buffer_head *bh);
+void brelse(struct buffer_head *bh);
+void bforget(struct buffer_head *bh);
+void init_rollback_file(char *rollback_file, unsigned int *blocksize,
+			FILE * log);
+int open_rollback_file(char *rollback_file, FILE * log);
+void close_rollback_file();
+void do_fsck_rollback(int fd_device, int fd_journal_device, FILE * log);
 
-void __wait_on_buffer (struct buffer_head * bh);
-struct buffer_head * getblk (int dev, unsigned long block, int size);
-struct buffer_head * reiserfs_getblk (int dev, unsigned long block, int size, int *repeat);
-
-struct buffer_head * find_buffer (int dev, unsigned long block, unsigned long size);
-struct buffer_head * get_hash_table(dev_t dev, unsigned long block, int size);
-struct buffer_head * bread (int dev, unsigned long block, size_t size);
-struct buffer_head * reiserfs_bread (int dev, unsigned long block, int size, int *repeat);
-int bwrite (struct buffer_head * bh);
-void brelse (struct buffer_head * bh);
-void bforget (struct buffer_head * bh);
-void init_rollback_file (char * rollback_file, unsigned int *blocksize,
-			 FILE * log);
-int open_rollback_file (char * rollback_file, FILE * log);
-void close_rollback_file ();
-void do_fsck_rollback (int fd_device, int fd_journal_device, FILE * log); 
-
-void flush_buffers (int);
-void free_buffers (void);
-void invalidate_buffers (int);
+void flush_buffers(int);
+void free_buffers(void);
+void invalidate_buffers(int);
 
 #endif
diff --git a/include/misc.h b/include/misc.h
index 5400e82..e5c8651 100644
--- a/include/misc.h
+++ b/include/misc.h
@@ -35,60 +35,72 @@
 #define INVAL_PTR	(void *)-1
 
 void check_memory_msg(void);
-void die (char * fmt, ...) __attribute__ ((format (printf, 1, 2)));
-void * getmem (int size);
+void die(char *fmt, ...) __attribute__ ((format(printf, 1, 2)));
+void *getmem(int size);
 void *mem_alloc(int size);
-void freemem (void * p);
-void checkmem (char * p, int size);
-void * expandmem (void * p, int size, int by);
-unsigned int get_mem_size (char * p);
-void check_and_free_mem (void);
-char * kdevname (int dev);
+void freemem(void *p);
+void checkmem(char *p, int size);
+void *expandmem(void *p, int size, int by);
+unsigned int get_mem_size(char *p);
+void check_and_free_mem(void);
+char *kdevname(int dev);
 
 typedef enum mount_flags {
-	MF_NOT_MOUNTED  = 0x0,
-	MF_RO		= 0x1,
-	MF_RW		= 0x2
+	MF_NOT_MOUNTED = 0x0,
+	MF_RO = 0x1,
+	MF_RW = 0x2
 } mount_flags_t;
 
 typedef struct mount_hint {
-    char *point;	/* Mount point. */
-    __u32 psize;	/* Mount point buffer size. */
-    __u32 flags;	/* Mount flags. */
+	char *point;		/* Mount point. */
+	__u32 psize;		/* Mount point buffer size. */
+	__u32 flags;		/* Mount flags. */
 } mount_hint_t;
 
 struct mntent *misc_mntent(char *device);
 int misc_device_mounted(char *device);
-	
+
 typedef struct dma_info {
-    int fd;
-    struct stat st;
-    int support_type;
-    int dma;
-    __u64 speed;
+	int fd;
+	struct stat st;
+	int support_type;
+	int dma;
+	__u64 speed;
 } dma_info_t;
 
 int prepare_dma_check(dma_info_t *dma_info);
 int get_dma_info(dma_info_t *dma_info);
 void clean_after_dma_check(int fd, dma_info_t *dma_info);
 
-int valid_offset( int fd, loff_t offset);
-unsigned long count_blocks (char * filename, int blocksize);
-
-void print_how_far (FILE * fp, unsigned long *passed, unsigned long total, unsigned int inc, int quiet);
-void print_how_fast (unsigned long total, 
-		     unsigned long passed, int cursor_pos, int reset_time);
-__u32 get_random (void);
-
-int user_confirmed (FILE * fp, char * q, char * yes);
-
-extern inline int misc_set_bit (unsigned long long nr, void * addr);
-extern inline int misc_clear_bit (unsigned long long nr, void * addr);
-extern inline int misc_test_bit(unsigned long long nr, const void * addr);
-extern inline unsigned long long misc_find_first_zero_bit (const void *vaddr, unsigned long long size);
-extern inline unsigned long long misc_find_next_zero_bit (const void *vaddr, unsigned long long size, unsigned long long offset);
-extern inline unsigned long long misc_find_next_set_bit(const void *vaddr, unsigned long long size, unsigned long long offset);
-extern inline unsigned long long misc_find_first_set_bit (const void *vaddr, unsigned long long size);
+int valid_offset(int fd, loff_t offset);
+unsigned long count_blocks(char *filename, int blocksize);
+
+void print_how_far(FILE * fp, unsigned long *passed, unsigned long total,
+		   unsigned int inc, int quiet);
+void print_how_fast(unsigned long total, unsigned long passed, int cursor_pos,
+		    int reset_time);
+__u32 get_random(void);
+
+int user_confirmed(FILE * fp, char *q, char *yes);
+
+extern inline int misc_set_bit(unsigned long long nr, void *addr);
+extern inline int misc_clear_bit(unsigned long long nr, void *addr);
+extern inline int misc_test_bit(unsigned long long nr, const void *addr);
+extern inline unsigned long long misc_find_first_zero_bit(const void *vaddr,
+							  unsigned long long
+							  size);
+extern inline unsigned long long misc_find_next_zero_bit(const void *vaddr,
+							 unsigned long long
+							 size,
+							 unsigned long long
+							 offset);
+extern inline unsigned long long misc_find_next_set_bit(const void *vaddr,
+							unsigned long long size,
+							unsigned long long
+							offset);
+extern inline unsigned long long misc_find_first_set_bit(const void *vaddr,
+							 unsigned long long
+							 size);
 
 #define STAT_FIELD_H(Field, Type)	\
 inline Type misc_device_##Field(char *device);
@@ -98,25 +110,24 @@ STAT_FIELD_H(rdev, dev_t);
 STAT_FIELD_H(size, off_t);
 STAT_FIELD_H(blocks, blkcnt_t);
 
-__u16 mask16 (int from, int count);
-__u32 mask32 (int from, int count);
-__u64 mask64 (int from, int count);
+__u16 mask16(int from, int count);
+__u32 mask32(int from, int count);
+__u64 mask64(int from, int count);
 
-int reiserfs_bin_search (void * key, void * base, __u32 num, int width,
-			 __u32 *ppos, __compar_fn_t comp_func);
+int reiserfs_bin_search(void *key, void *base, __u32 num, int width,
+			__u32 * ppos, __compar_fn_t comp_func);
 
 struct block_handler {
-    __u32 blocknr;
-    dev_t device;
+	__u32 blocknr;
+	dev_t device;
 };
 
-int  blocklist__is_block_saved (struct block_handler ** base, __u32 * count, __u32 blocknr, 
-    dev_t device, __u32 * position);
-void blocklist__insert_in_position (void * block_h, void ** base, __u32 * count, 
-    int elem_size, __u32 * position);
-int blockdev_list_compare (const void * block1, const void * block2);
-			
-			 
+int blocklist__is_block_saved(struct block_handler **base, __u32 * count,
+			      __u32 blocknr, dev_t device, __u32 * position);
+void blocklist__insert_in_position(void *block_h, void **base, __u32 * count,
+				   int elem_size, __u32 * position);
+int blockdev_list_compare(const void *block1, const void *block2);
+
 #define set_bit_field_XX(XX,vp,val,from,count) \
 {\
     __u##XX * p, tmp;\
@@ -137,7 +148,6 @@ int blockdev_list_compare (const void * block1, const void * block2);
     *p = cpu_to_le##XX (tmp);\
 }
 
-
 #define get_bit_field_XX(XX,vp,from,count) \
 \
     __u##XX * p, tmp;\
@@ -152,19 +162,16 @@ int blockdev_list_compare (const void * block1, const void * block2);
     tmp >>= from;\
     return tmp;
 
-
 #ifndef major
 #define major(rdev)      ((rdev)>>8)
 #define minor(rdev)      ((rdev) & 0xff)
 #endif /* major */
 
-
-
 #ifndef SCSI_DISK_MAJOR
 #define SCSI_DISK_MAJOR(maj) ((maj) == SCSI_DISK0_MAJOR || \
 			     ((maj) >= SCSI_DISK1_MAJOR && (maj) <= SCSI_DISK7_MAJOR))
 #endif /* SCSI_DISK_MAJOR */
-    
+
 #ifndef SCSI_BLK_MAJOR
 #define SCSI_BLK_MAJOR(maj)  (SCSI_DISK_MAJOR(maj) || (maj) == SCSI_CDROM_MAJOR)
 #endif /* SCSI_BLK_MAJOR */
@@ -183,5 +190,4 @@ int blockdev_list_compare (const void * block1, const void * block2);
 #endif /* IDE9_MAJOR */
 #endif /* IDE_DISK_MAJOR */
 
-
 #endif /* REISERFS_MISC_H */
diff --git a/include/progbar.h b/include/progbar.h
index e05bfc6..9f32649 100644
--- a/include/progbar.h
+++ b/include/progbar.h
@@ -20,12 +20,12 @@ struct spinner {
 	FILE *file;
 };
 
-void progbar_init(struct progbar *ctx, const char *units, FILE *fp);
-void progbar_clear(struct progbar * ctx);
-int progbar_update(struct progbar * ctx, const char *label, int curr, int max,
-                           unsigned int dpynum);
+void progbar_init(struct progbar *ctx, const char *units, FILE * fp);
+void progbar_clear(struct progbar *ctx);
+int progbar_update(struct progbar *ctx, const char *label, int curr, int max,
+		   unsigned int dpynum);
 
-void spinner_init(struct spinner *spinner, FILE *fp);
+void spinner_init(struct spinner *spinner, FILE * fp);
 void spinner_touch(struct spinner *spinner);
 void spinner_clear(struct spinner *spinner);
 
diff --git a/include/reiserfs_fs.h b/include/reiserfs_fs.h
index a0be250..a338c61 100644
--- a/include/reiserfs_fs.h
+++ b/include/reiserfs_fs.h
@@ -30,7 +30,7 @@
 */
 
 #ifndef REISERFSPROGS_FS_H
-#define REISERFSPRIGS_FS_H 
+#define REISERFSPRIGS_FS_H
 
 typedef unsigned int blocknr_t;
 
@@ -70,52 +70,46 @@ typedef unsigned int blocknr_t;
 #define get_le64(p,field)	get_leXX (64, p, field)
 #define set_le64(p,field,val)	set_leXX (64, p, field, val)
 
-
-
 /***************************************************************************/
 /*                             SUPER BLOCK                                 */
 /***************************************************************************/
 
-#define UNSET_HASH 0 // read_super will guess about, what hash names
-                     // in directories were sorted with
+#define UNSET_HASH 0		// read_super will guess about, what hash names
+		     // in directories were sorted with
 #define TEA_HASH  1
 #define YURA_HASH 2
 #define R5_HASH   3
 #define DEFAULT_HASH R5_HASH
 
-
 /* super block of prejournalled version */
-struct reiserfs_super_block_v0
-{
-    __u32 s_block_count;
-    __u32 s_free_blocks;
-    __u32 s_root_block;
-    __u16 s_blocksize;
-    __u16 s_oid_maxsize;
-    __u16 s_oid_cursize;
-    __u16 s_state;
-    char s_magic[16];
-    __u16 s_tree_height;
-    __u16 s_bmap_nr;
-    __u16 s_reserved;
+struct reiserfs_super_block_v0 {
+	__u32 s_block_count;
+	__u32 s_free_blocks;
+	__u32 s_root_block;
+	__u16 s_blocksize;
+	__u16 s_oid_maxsize;
+	__u16 s_oid_cursize;
+	__u16 s_state;
+	char s_magic[16];
+	__u16 s_tree_height;
+	__u16 s_bmap_nr;
+	__u16 s_reserved;
 };
 
-
 struct journal_params {
-    __u32 jp_journal_1st_block;	/* where does journal start from on its
-                                   device */
-    __u32 jp_journal_dev;	/* journal device st_rdev */
-    __u32 jp_journal_size;	/* size of the journal on FS creation. used to
+	__u32 jp_journal_1st_block;	/* where does journal start from on its
+					   device */
+	__u32 jp_journal_dev;	/* journal device st_rdev */
+	__u32 jp_journal_size;	/* size of the journal on FS creation. used to
 				   make sure they don't overflow it */
-    __u32 jp_journal_trans_max;	/* max number of blocks in a transaction.  */
-    __u32 jp_journal_magic; 	/* random value made on fs creation (this was
+	__u32 jp_journal_trans_max;	/* max number of blocks in a transaction.  */
+	__u32 jp_journal_magic;	/* random value made on fs creation (this was
 				   sb_journal_block_count) */
-    __u32 jp_journal_max_batch;	/* max number of blocks to batch into a trans */
-    __u32 jp_journal_max_commit_age;      /* in seconds, how old can an async commit be */
-    __u32 jp_journal_max_trans_age;       /* in seconds, how old can a transaction be */
+	__u32 jp_journal_max_batch;	/* max number of blocks to batch into a trans */
+	__u32 jp_journal_max_commit_age;	/* in seconds, how old can an async commit be */
+	__u32 jp_journal_max_trans_age;	/* in seconds, how old can a transaction be */
 };
 
-
 #define get_jp_journal_1st_block(jp)	 get_le32 (jp, jp_journal_1st_block)
 #define set_jp_journal_1st_block(jp,val) set_le32 (jp, jp_journal_1st_block, val)
 
@@ -142,44 +136,42 @@ struct journal_params {
 #define get_jp_journal_max_trans_age(jp)	get_le32 (jp, jp_journal_max_commit_age)
 #define set_jp_journal_max_trans_age(jp,val)	set_le32 (jp, jp_journal_max_commit_age, val)
 
-
 /* this is the super from 3.5.X */
-struct reiserfs_super_block_v1
-{
-    __u32 sb_block_count; 	/* 0 number of block on data device */
-    __u32 sb_free_blocks; 	/* 4 free blocks count */
-    __u32 sb_root_block;        /* 8 root of the tree */
+struct reiserfs_super_block_v1 {
+	__u32 sb_block_count;	/* 0 number of block on data device */
+	__u32 sb_free_blocks;	/* 4 free blocks count */
+	__u32 sb_root_block;	/* 8 root of the tree */
 
-    struct journal_params sb_journal; /* 12 */
+	struct journal_params sb_journal;	/* 12 */
 
-    __u16 sb_blocksize;         /* 44 */
-    __u16 sb_oid_maxsize;	/* 46 max size of object id array, see
+	__u16 sb_blocksize;	/* 44 */
+	__u16 sb_oid_maxsize;	/* 46 max size of object id array, see
 				   get_objectid() commentary */
-    __u16 sb_oid_cursize; 	/* 48 current size of object id array */
-    __u16 sb_umount_state;	/* 50 this is set to 1 when filesystem was
+	__u16 sb_oid_cursize;	/* 48 current size of object id array */
+	__u16 sb_umount_state;	/* 50 this is set to 1 when filesystem was
 				   umounted, to 2 - when not */
-    
-    char s_magic[10]; 		/* 52 reiserfs magic string indicates that
+
+	char s_magic[10];	/* 52 reiserfs magic string indicates that
 				   file system is reiserfs: "ReIsErFs" or
 				   "ReIsEr2Fs" or "ReIsEr3Fs" */
-    __u16 sb_fs_state; 		/* 62 it is set to used by fsck to mark which phase of
+	__u16 sb_fs_state;	/* 62 it is set to used by fsck to mark which phase of
 				   rebuilding is done (used for fsck debugging) */
-    __u32 sb_hash_function_code;/* 64 code of fuction which was/is/will be
-				   used to sort names in a directory. See
-				   codes in above */
-    __u16 sb_tree_height;	/* 68 height of filesytem tree. Tree
+	__u32 sb_hash_function_code;	/* 64 code of fuction which was/is/will be
+					   used to sort names in a directory. See
+					   codes in above */
+	__u16 sb_tree_height;	/* 68 height of filesytem tree. Tree
 				   consisting of only one root block has 2
 				   here */
-    __u16 sb_bmap_nr;     	/* 70 amount of bitmap blocks needed to
+	__u16 sb_bmap_nr;	/* 70 amount of bitmap blocks needed to
 				   address each block of file system */
-    __u16 sb_version; 		/* 72 this field is only reliable on
+	__u16 sb_version;	/* 72 this field is only reliable on
 				   filesystem with non-standard journal */
-    __u16 sb_reserved_for_journal;  /* 74 size in blocks of journal area on
-				       main device, we need to keep after
-				       non-standard journal relocation */
+	__u16 sb_reserved_for_journal;	/* 74 size in blocks of journal area on
+					   main device, we need to keep after
+					   non-standard journal relocation */
 };
 
-#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1)) /* 76 bytes */
+#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))	/* 76 bytes */
 
 #define sb_jp(sb) (&((sb)->s_v1.sb_journal))
 
@@ -188,38 +180,38 @@ struct reiserfs_super_block_v1
 #define REISERFS_FORMAT_3_5 0
 #define REISERFS_FORMAT_3_6 2
 #define REISERFS_FORMAT_UNKNOWN -1
-                                   
 
 /* values for sb_mount_state field */
-#define FS_CLEANLY_UMOUNTED    1 /* this was REISERFS_VALID_FS */
-#define FS_NOT_CLEANLY_UMOUNTED    2 /* this was REISERFS_ERROR. It
-                                              means that filesystem was not
-                                              cleanly unmounted */
+#define FS_CLEANLY_UMOUNTED    1	/* this was REISERFS_VALID_FS */
+#define FS_NOT_CLEANLY_UMOUNTED    2	/* this was REISERFS_ERROR. It
+					   means that filesystem was not
+					   cleanly unmounted */
 
 /* Structure of super block on disk */
-struct reiserfs_super_block
-{
-/*  0 */    struct reiserfs_super_block_v1 s_v1;
-/* 76 */     __u32 sb_inode_generation; 
-/* 80 */     __u32 s_flags;                /* Right now used only by inode-attributes, if enabled */
-/* 84 */    unsigned char s_uuid[16];      /* filesystem unique identifier */
-/*100 */    char s_label[16];              /* filesystem volume label */
-/*116 */    __u16 s_mnt_count;
-/*118 */    __u16 s_max_mnt_count;
-/*120 */    __u32 s_lastcheck;
-/*124 */    __u32 s_check_interval;
-/*128 */    char s_unused[76] ;            /* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
-                                            * so any additions must be updated there as well. */ 
+struct reiserfs_super_block {
+/*  0 */ struct reiserfs_super_block_v1 s_v1;
+/* 76 */ __u32 sb_inode_generation;
+				/* 80 */ __u32 s_flags;
+				/* Right now used only by inode-attributes, if enabled */
+						/* 84 */ unsigned char s_uuid[16];
+						/* filesystem unique identifier */
+					/*100 */ char s_label[16];
+					/* filesystem volume label */
+/*116 */ __u16 s_mnt_count;
+/*118 */ __u16 s_max_mnt_count;
+/*120 */ __u32 s_lastcheck;
+/*124 */ __u32 s_check_interval;
+					/*128 */ char s_unused[76];
+					/* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
+					 * so any additions must be updated there as well. */
 /*204*/
 } __attribute__ ((__packed__));;
 
 typedef enum {
-  reiserfs_attrs_cleared       = 0x00000001,
+	reiserfs_attrs_cleared = 0x00000001,
 } reiserfs_super_block_flags;
 
-
-
-#define SB_SIZE (sizeof(struct reiserfs_super_block)) /* 204 bytes */
+#define SB_SIZE (sizeof(struct reiserfs_super_block))	/* 204 bytes */
 
 /* set/get fields of super block with these defines */
 #define get_sb_block_count(sb)		get_le32 (sb, s_v1.sb_block_count)
@@ -299,31 +291,31 @@ typedef enum {
 #define journal_is_relocated(sb)        get_jp_journal_dev(sb_jp (sb))
 */
 
-#define DEFAULT_MAX_MNT_COUNT	30			/* 30 mounts */
+#define DEFAULT_MAX_MNT_COUNT	30	/* 30 mounts */
 #define DEFAULT_CHECK_INTERVAL	(180 * 60 * 60 * 24)	/* 180 days */
 
 /* these are possible values for sb_fs_state */
-#define FS_CONSISTENT   0x0	    /* this is set by mkreiserfs and by reiserfsck */
-#define FS_ERROR	0x1	    /* this is set by the kernel when fsck is wanted. */
-#define FS_FATAL	0x2	    /* this is set by fsck when fatal corruption is found */
-#define IO_ERROR	0x4	    /* this is set by kernel when io error occures */
-#define PASS_0_DONE     0xfa02	    /* set by fsck when pass-by-pass (-d),
-				       FS_FATAL flag included */
-#define PASS_1_DONE     0xfb02	    /* set by fsck when pass-by-pass (-d),
-                                       FS_FATAL flag included */
-#define TREE_IS_BUILT   0xfc02	    /* set by fsck when pass-by-pass (-d),
-                                       FS_FATAL flag included */
-#define SEMANTIC_DONE   0xfd02	    /* set by fsck when pass-by-pass (-d),
-                                       FS_FATAL flag included */
-#define LOST_FOUND_DONE 0xfe02	    /* set by fsck when pass-by-pass (-d),
-                                       FS_FATAL flag included */
+#define FS_CONSISTENT   0x0	/* this is set by mkreiserfs and by reiserfsck */
+#define FS_ERROR	0x1	/* this is set by the kernel when fsck is wanted. */
+#define FS_FATAL	0x2	/* this is set by fsck when fatal corruption is found */
+#define IO_ERROR	0x4	/* this is set by kernel when io error occures */
+#define PASS_0_DONE     0xfa02	/* set by fsck when pass-by-pass (-d),
+				   FS_FATAL flag included */
+#define PASS_1_DONE     0xfb02	/* set by fsck when pass-by-pass (-d),
+				   FS_FATAL flag included */
+#define TREE_IS_BUILT   0xfc02	/* set by fsck when pass-by-pass (-d),
+				   FS_FATAL flag included */
+#define SEMANTIC_DONE   0xfd02	/* set by fsck when pass-by-pass (-d),
+				   FS_FATAL flag included */
+#define LOST_FOUND_DONE 0xfe02	/* set by fsck when pass-by-pass (-d),
+				   FS_FATAL flag included */
 
 /* struct stat_data* access macros */
 /* v1 */
 #define sd_v1_mode(sd)                 (le16_to_cpu((sd)->sd_mode))
 #define set_sd_v1_mode(sd,n)           ((sd)->sd_mode = cpu_to_le16((n)))
 #define sd_v1_nlink(sd)                (le16_to_cpu((sd)->sd_nlink))
-#define set_sd_v1_nlink(sd,n)          ((sd)->sd_nlink = cpu_to_le16((n))) 
+#define set_sd_v1_nlink(sd,n)          ((sd)->sd_nlink = cpu_to_le16((n)))
 #define sd_v1_uid(sd)                  (le16_to_cpu((sd)->sd_uid))
 #define set_sd_v1_uid(sd,n)            ((sd)->sd_uid = cpu_to_le16((n)))
 #define sd_v1_gid(sd)                  (le16_to_cpu((sd)->sd_gid))
@@ -349,7 +341,7 @@ typedef enum {
 #define sd_v2_sd_attrs(sd)             (le16_to_cpu((sd)->sd_attrs))
 #define set_sd_v2_sd_attrs(sd,n)       ((sd)->sd_attrs = cpu_to_le16((n)))
 #define sd_v2_nlink(sd)                (le32_to_cpu((sd)->sd_nlink))
-#define set_sd_v2_nlink(sd,n)          ((sd)->sd_nlink = cpu_to_le32((n))) 
+#define set_sd_v2_nlink(sd,n)          ((sd)->sd_nlink = cpu_to_le32((n)))
 #define sd_v2_size(sd)                 (le64_to_cpu((sd)->sd_size))
 #define set_sd_v2_size(sd,n)           ((sd)->sd_size = cpu_to_le64((n)))
 #define sd_v2_uid(sd)                  (le32_to_cpu((sd)->sd_uid))
@@ -367,7 +359,6 @@ typedef enum {
 #define sd_v2_rdev(sd)                 (le32_to_cpu((sd)->u.sd_rdev))
 #define set_sd_v2_rdev(sd,n)           ((sd)->u.sd_rdev = cpu_to_le32((n)))
 
-
 /* ReiserFS leaves the first 64k unused, so that partition labels have enough
    space.  If someone wants to write a fancy bootloader that needs more than
    64k, let us know, and this will be increased in size.  This number must be
@@ -393,8 +384,8 @@ typedef enum {
    64-th and at the 8-th 1k block of the device */
 #define REISERFS_3_5_SUPER_MAGIC_STRING "ReIsErFs"
 #define REISERFS_3_6_SUPER_MAGIC_STRING "ReIsEr2Fs"
-#define REISERFS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs" /* JR stands for Journal
-						      Relocation */
+#define REISERFS_JR_SUPER_MAGIC_STRING "ReIsEr3Fs"	/* JR stands for Journal
+							   Relocation */
 
 #define get_reiserfs_ondisk_offset(block_of_super_block, block_size) \
     (block_of_super_block * block_size)
@@ -402,7 +393,7 @@ typedef enum {
 #define is_new_sb_location(block_of_super_block, block_size) \
     ((get_reiserfs_ondisk_offset(block_of_super_block, block_size) == REISERFS_DISK_OFFSET_IN_BYTES) \
 	? 1 : 0)
-	
+
 /*only 4k blocks for old location*/
 #define is_old_sb_location(block_of_super_block, block_size) \
     ((get_reiserfs_ondisk_offset(block_of_super_block, 4096) == REISERFS_OLD_DISK_OFFSET_IN_BYTES) \
@@ -412,8 +403,8 @@ typedef enum {
 /*                             JOURNAL                                     */
 /***************************************************************************/
 
-#define JOURNAL_DESC_MAGIC "ReIsErLB" /* ick.  magic string to find desc
-                                         blocks in the journal */
+#define JOURNAL_DESC_MAGIC "ReIsErLB"	/* ick.  magic string to find desc
+					   blocks in the journal */
 
 /* journal.c see journal.c for all the comments here */
 
@@ -421,16 +412,14 @@ typedef enum {
 
 /* first block written in a commit.  BUG, not 64bit safe */
 struct reiserfs_journal_desc {
-    __u32 j2_trans_id ;	/* id of commit */
-    __u32 j2_len ;	/* length of commit. len +1 is the commit block */
-    __u32 j2_mount_id ;	/* mount id of this trans*/
-    __u32 j2_realblock[1] ; /* real locations for each block */    
+	__u32 j2_trans_id;	/* id of commit */
+	__u32 j2_len;		/* length of commit. len +1 is the commit block */
+	__u32 j2_mount_id;	/* mount id of this trans */
+	__u32 j2_realblock[1];	/* real locations for each block */
 };
 
 #define get_jd_magic(bh) (bh->b_data + bh->b_size - 12)
 
-
-
 #define journal_trans_half(blocksize) \
 ((blocksize - sizeof (struct reiserfs_journal_desc) + sizeof (__u32) - 12) / sizeof (__u32))
 
@@ -444,14 +433,13 @@ struct reiserfs_journal_desc {
 
 #define get_desc_mount_id(bh)	  get_le32 (jdesc_header (bh), j2_mount_id)
 #define set_desc_mount_id(bh,val)	  set_le32 (jdesc_header (bh), j2_mount_id, val)
-    
 
 /* last block written in a commit BUG, not 64bit safe */
 struct reiserfs_journal_commit {
-    __u32 j3_trans_id ;	 /* must match j_trans_id from the desc block */
-    __u32 j3_len ;	 /* ditto */
-    __u32 j3_realblock[1] ; /* real locations for each block */
-} ;
+	__u32 j3_trans_id;	/* must match j_trans_id from the desc block */
+	__u32 j3_len;		/* ditto */
+	__u32 j3_realblock[1];	/* real locations for each block */
+};
 
 #define jcommit_header(bh) ((struct reiserfs_journal_commit *)bh->b_data)
 
@@ -461,22 +449,20 @@ struct reiserfs_journal_commit {
 #define get_commit_trans_len(bh)	get_le32 (jcommit_header(bh), j3_len)
 #define set_comm_trans_len(bh,val)	set_le32 (jcommit_header(bh), j3_len, val)
 
-
 /* this header block gets written whenever a transaction is considered fully
 ** flushed, and is more recent than the last fully flushed transaction.  fully
 ** flushed means all the log blocks and all the real blocks are on disk, and
 ** this transaction does not need to be replayed.  */
-struct reiserfs_journal_header {    
-    __u32 jh_last_flush_trans_id ;    /* id of last fully flushed transaction */
-    __u32 jh_first_unflushed_offset ; /* offset in the log of where to start replay after a crash */
-    __u32 jh_mount_id ;
+struct reiserfs_journal_header {
+	__u32 jh_last_flush_trans_id;	/* id of last fully flushed transaction */
+	__u32 jh_first_unflushed_offset;	/* offset in the log of where to start replay after a crash */
+	__u32 jh_mount_id;
 
-    struct journal_params jh_journal;
+	struct journal_params jh_journal;
 
-    __u32 jh_last_check_mount_id;	/* the mount id of the fs during the last reiserfsck --check. */
+	__u32 jh_last_check_mount_id;	/* the mount id of the fs during the last reiserfsck --check. */
 };
 
-
 /* set/get fields of journal header with these defines */
 #define get_jh_mount_id(jh)	get_le32 (jh, jh_mount_id)
 #define set_jh_mount_id(jh,val)	set_le32 (jh, jh_mount_id, val)
@@ -487,18 +473,16 @@ struct reiserfs_journal_header {
 #define get_jh_replay_start_offset(jh)		get_le32 (jh, jh_first_unflushed_offset)
 #define set_jh_replay_start_offset(jh,val)	set_le32 (jh, jh_first_unflushed_offset, val)
 
-
-
 /* journal default settings */
 
 #define JOURNAL_MIN_SIZE 	512
-#define JOURNAL_TRANS_MAX 	1024   	/* biggest possible single transaction, don't
-                                    	change for now (8/3/99) */
-#define JOURNAL_TRANS_MIN 	256    	/* need to check whether it works */
-#define JOURNAL_DEFAULT_RATIO 	8  	/* default journal size / max trans length */
+#define JOURNAL_TRANS_MAX 	1024	/* biggest possible single transaction, don't
+					   change for now (8/3/99) */
+#define JOURNAL_TRANS_MIN 	256	/* need to check whether it works */
+#define JOURNAL_DEFAULT_RATIO 	8	/* default journal size / max trans length */
 #define JOURNAL_MIN_RATIO 	2
-#define JOURNAL_MAX_BATCH   	900 	/* max blocks to batch into one transaction,
-                                   	don't make this any bigger than 900 */
+#define JOURNAL_MAX_BATCH   	900	/* max blocks to batch into one transaction,
+					   don't make this any bigger than 900 */
 #define JOURNAL_MAX_COMMIT_AGE 	30
 #define JOURNAL_MAX_TRANS_AGE 	30
 
@@ -517,40 +501,37 @@ struct reiserfs_journal_header {
 #define bh_desc(bh) ((struct reiserfs_journal_desc *)((bh)->b_data))
 #define bh_commit(bh) ((struct reiserfs_journal_commit *)((bh)->b_data))
 
-
 /***************************************************************************/
 /*                       KEY & ITEM HEAD                                   */
 /***************************************************************************/
 
 struct offset_v1 {
-    __u32 k_offset;
-    __u32 k_uniqueness;
+	__u32 k_offset;
+	__u32 k_uniqueness;
 } __attribute__ ((__packed__));
 
 struct offset_v2 {
 #if __BYTE_ORDER == __LITTLE_ENDIAN
-    __u64 k_offset:60;
-    __u64 k_type: 4; // TYPE_STAT_DATA | TYPE_INDIRECT | TYPE_DIRECT | TYPE_DIRENTRY
+	__u64 k_offset:60;
+	__u64 k_type:4;		// TYPE_STAT_DATA | TYPE_INDIRECT | TYPE_DIRECT | TYPE_DIRENTRY
 #elif __BYTE_ORDER == __BIG_ENDIAN
-    __u64 k_type: 4; // TYPE_STAT_DATA | TYPE_INDIRECT | TYPE_DIRECT | TYPE_DIRENTRY
-    __u64 k_offset:60;
+	__u64 k_type:4;		// TYPE_STAT_DATA | TYPE_INDIRECT | TYPE_DIRECT | TYPE_DIRENTRY
+	__u64 k_offset:60;
 #else
 # error "nuxi/pdp-endian archs are not supported"
 #endif
 } __attribute__ ((__packed__));
 
-
 /* Key of the object determines object's location in the tree, composed of 4 components */
 struct reiserfs_key {
-    __u32 k2_dir_id;    /* packing locality: by default parent directory object id */
-    __u32 k2_objectid;  /* object identifier */
-    union {
-	struct offset_v1 k2_offset_v1;
-	struct offset_v2 k2_offset_v2;
-    } __attribute__ ((__packed__)) u;
+	__u32 k2_dir_id;	/* packing locality: by default parent directory object id */
+	__u32 k2_objectid;	/* object identifier */
+	union {
+		struct offset_v1 k2_offset_v1;
+		struct offset_v2 k2_offset_v2;
+	} __attribute__ ((__packed__)) u;
 } __attribute__ ((__packed__));
 
-
 /* set/get fields of keys on disk with these defines */
 #define get_key_dirid(k)		get_le32 (k, k2_dir_id)
 #define set_key_dirid(k,val)		set_le32 (k, k2_dir_id, val)
@@ -564,7 +545,6 @@ struct reiserfs_key {
 #define get_key_uniqueness(k)		get_le32 (k, u.k2_offset_v1.k_uniqueness)
 #define set_key_uniqueness(k,val)	set_le32 (k, u.k2_offset_v1.k_uniqueness, val)
 
-
 /*
 #define get_key_offset_v2(k)		get_le64 (k, u.k2_offset_v2.k_offset)
 #define set_key_offset_v2(k,val)	set_le64 (k, u.k2_offset_v2.k_offset, val)
@@ -584,7 +564,6 @@ struct reiserfs_key {
 #define KEY_SIZE (sizeof(struct reiserfs_key))
 #define SHORT_KEY_SIZE 8
 
-
 // values for k_uniqueness field of the struct reiserfs_key
 #define V1_SD_UNIQUENESS 0
 #define V1_DIRENTRY_UNIQUENESS 500
@@ -597,7 +576,7 @@ struct reiserfs_key {
 #define TYPE_STAT_DATA 0
 #define TYPE_INDIRECT 1
 #define TYPE_DIRECT 2
-#define TYPE_DIRENTRY 3 
+#define TYPE_DIRENTRY 3
 
 #define TYPE_UNKNOWN 15
 
@@ -616,44 +595,41 @@ struct reiserfs_key {
 
 #define REISERFS_SHORT_KEY_LEN    2
 
-
 /* Everything in the filesystem is stored as a set of items.  The item head
    contains the key of the item, its free space (for indirect items) and
    specifies the location of the item itself within the block.  */
 
-struct item_head
-{
-    struct reiserfs_key ih_key; 	/* Everything in the tree is found by searching for it
-                           based on its key.*/
-
-    union {
-	__u16 ih2_free_space; /* The free space in the last unformatted node
-				of an indirect item if this is an indirect
-				item.  This equals 0xFFFF iff this is a direct
-				item or stat data item. Note that the key, not
-				this field, is used to determine the item
-				type, and thus which field this union
-				contains. */
-	__u16 ih2_entry_count; /* Iff this is a directory item, this field
-				  equals the number of directory entries in
-				  the directory item. */
-    } __attribute__ ((__packed__)) u;
-    __u16 ih2_item_len;           /* total size of the item body */
-    __u16 ih2_item_location;      /* an offset to the item body within the
-                                    block */
-
-    __u16 ih_format;	/* key format is stored in bits 0-11 of this item
-			   flags are stored in bits 12-15 */
+struct item_head {
+	struct reiserfs_key ih_key;	/* Everything in the tree is found by searching for it
+					   based on its key. */
+
+	union {
+		__u16 ih2_free_space;	/* The free space in the last unformatted node
+					   of an indirect item if this is an indirect
+					   item.  This equals 0xFFFF iff this is a direct
+					   item or stat data item. Note that the key, not
+					   this field, is used to determine the item
+					   type, and thus which field this union
+					   contains. */
+		__u16 ih2_entry_count;	/* Iff this is a directory item, this field
+					   equals the number of directory entries in
+					   the directory item. */
+	} __attribute__ ((__packed__)) u;
+	__u16 ih2_item_len;	/* total size of the item body */
+	__u16 ih2_item_location;	/* an offset to the item body within the
+					   block */
+
+	__u16 ih_format;	/* key format is stored in bits 0-11 of this item
+				   flags are stored in bits 12-15 */
 #if 0
-    struct {
-	__u16 key_format : 12; /* KEY_FORMAT_1 or KEY_FORMAT_2. This is not
-				  necessary, but we have space, let use it */
-	__u16 flags : 4;   /* fsck set here its flag (reachable/unreachable) */
-    } __attribute__ ((__packed__)) ih2_format;
+	struct {
+		__u16 key_format:12;	/* KEY_FORMAT_1 or KEY_FORMAT_2. This is not
+					   necessary, but we have space, let use it */
+		__u16 flags:4;	/* fsck set here its flag (reachable/unreachable) */
+	} __attribute__ ((__packed__)) ih2_format;
 #endif
 } __attribute__ ((__packed__));
 
-
 /* size of item header     */
 #define IH_SIZE (sizeof(struct item_head))
 
@@ -670,11 +646,10 @@ struct item_head
 #define get_ih_location(ih)		get_le16 (ih, ih2_item_location)
 #define set_ih_location(ih,val)		set_le16 (ih, ih2_item_location, val)
 
-__u16 get_ih_flags (const struct item_head * ih);
-__u16 get_ih_key_format (const struct item_head * ih);
-void set_ih_flags (struct item_head * ih, __u16 val);
-void set_ih_key_format (struct item_head * ih, __u16 val);
-
+__u16 get_ih_flags(const struct item_head *ih);
+__u16 get_ih_key_format(const struct item_head *ih);
+void set_ih_flags(struct item_head *ih, __u16 val);
+void set_ih_key_format(struct item_head *ih, __u16 val);
 
 /*
 #define get_ih_key_format(ih)		get_le16 (ih, ih2_format.key_format)
@@ -693,7 +668,6 @@ void set_ih_key_format (struct item_head * ih, __u16 val);
 #define IH_Checked     2
 #define IH_Writable    3
 
-
 /* Bad item flag is set temporary by recover_leaf */
 /*
 extern_inline __u16 mark_ih_bad( struct item_head *ih )
@@ -740,12 +714,10 @@ extern_inline __u16 unmark_item_bad( struct item_head *ih )
 #define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)
 #define MIN_ITEM_LEN 1
 
-
 /* object identifier for root dir */
 #define REISERFS_ROOT_OBJECTID 2
 #define REISERFS_ROOT_PARENT_OBJECTID 1
 
-
 /* 
  * Picture represents a leaf of internal tree
  *  ______________________________________________________
@@ -757,12 +729,12 @@ extern_inline __u16 unmark_item_bad( struct item_head *ih )
 
 /* Header of a disk block.  More precisely, header of a formatted leaf
    or internal node, and not the header of an unformatted node. */
-struct block_head {       
-    __u16 blk2_level;        /* Level of a block in the tree. */
-    __u16 blk2_nr_item;      /* Number of keys/items in a block. */
-    __u16 blk2_free_space;   /* Block free space in bytes. */
-    __u16 blk_reserved;
-    __u32 reserved [4];
+struct block_head {
+	__u16 blk2_level;	/* Level of a block in the tree. */
+	__u16 blk2_nr_item;	/* Number of keys/items in a block. */
+	__u16 blk2_free_space;	/* Block free space in bytes. */
+	__u16 blk_reserved;
+	__u32 reserved[4];
 };
 
 #define BLKH_SIZE (sizeof(struct block_head))
@@ -777,41 +749,28 @@ struct block_head {
 #define get_blkh_free_space(blkh)	get_le16 (blkh, blk2_free_space)
 #define set_blkh_free_space(blkh,val)	set_le16 (blkh, blk2_free_space, val)
 
-
-
-
-
 /*
  * values for blk_type field
  */
 
-#define FREE_LEVEL        0 /* Node of this level is out of the tree. */
-#define DISK_LEAF_NODE_LEVEL  1 /* Leaf node level.                       */
-
+#define FREE_LEVEL        0	/* Node of this level is out of the tree. */
+#define DISK_LEAF_NODE_LEVEL  1	/* Leaf node level.                       */
 
 #define is_leaf_block_head(buf) (get_blkh_level ((struct block_head *)(buf)) == DISK_LEAF_NODE_LEVEL)
 #define is_internal_block_head(buf) \
 ((get_blkh_level (((struct block_head *)(buf))) > DISK_LEAF_NODE_LEVEL) &&\
  (get_blkh_level (((struct block_head *)(buf))) <= MAX_HEIGHT))
 
-
 /* Given the buffer head of a formatted node, resolve to the block head of that node. */
 #define B_BLK_HEAD(p_s_bh)  ((struct block_head *)((p_s_bh)->b_data))
 
-
 #define B_NR_ITEMS(bh)		get_blkh_nr_items (B_BLK_HEAD(bh))
 #define B_LEVEL(bh)		get_blkh_level (B_BLK_HEAD(bh))
 #define B_FREE_SPACE(bh)	get_blkh_free_space (B_BLK_HEAD(bh))
 
-
 #define is_leaf_node(bh) is_leaf_block_head ((bh)->b_data)
 #define is_internal_node(bh) is_internal_block_head ((bh)->b_data)
 
-
-
-
-
-
 /***************************************************************************/
 /*                             STAT DATA                                   */
 /***************************************************************************/
@@ -829,65 +788,62 @@ struct block_head {
    overloaded.  */
 
 struct stat_data_v1 {
-    __u16 sd_mode;	/* file type, permissions */
-    __u16 sd_nlink;	/* number of hard links */
-    __u16 sd_uid;		/* owner */
-    __u16 sd_gid;		/* group */
-    __u32 sd_size;	/* file size */
-    __u32 sd_atime;	/* time of last access */
-    __u32 sd_mtime;	/* time file was last modified  */
-    __u32 sd_ctime;	/* time inode (stat data) was last changed (except
-                           changes to sd_atime and sd_mtime) */
-    union {
-	__u32 sd_rdev;
-	__u32 sd_blocks;	/* number of blocks file uses */
-    } __attribute__ ((__packed__)) u;
-    __u32 sd_first_direct_byte; /* first byte of file which is stored
-				   in a direct item: except that if it
-				   equals 1 it is a symlink and if it
-				   equals MAX_KEY_OFFSET there is no
-				   direct item.  The existence of this
-				   field really grates on me. Let's
-				   replace it with a macro based on
-				   sd_size and our tail suppression
-				   policy.  Someday.  -Hans */
+	__u16 sd_mode;		/* file type, permissions */
+	__u16 sd_nlink;		/* number of hard links */
+	__u16 sd_uid;		/* owner */
+	__u16 sd_gid;		/* group */
+	__u32 sd_size;		/* file size */
+	__u32 sd_atime;		/* time of last access */
+	__u32 sd_mtime;		/* time file was last modified  */
+	__u32 sd_ctime;		/* time inode (stat data) was last changed (except
+				   changes to sd_atime and sd_mtime) */
+	union {
+		__u32 sd_rdev;
+		__u32 sd_blocks;	/* number of blocks file uses */
+	} __attribute__ ((__packed__)) u;
+	__u32 sd_first_direct_byte;	/* first byte of file which is stored
+					   in a direct item: except that if it
+					   equals 1 it is a symlink and if it
+					   equals MAX_KEY_OFFSET there is no
+					   direct item.  The existence of this
+					   field really grates on me. Let's
+					   replace it with a macro based on
+					   sd_size and our tail suppression
+					   policy.  Someday.  -Hans */
 } __attribute__ ((__packed__));
 #define SD_V1_SIZE (sizeof(struct stat_data_v1))
 
-
 /* this is used to check sd_size of stat data v1 */
 #define MAX_FILE_SIZE_V1 0x7fffffff
 
-
 // sd_first_direct_byte is set to this when there are no direct items in a
 // file
 #define NO_BYTES_IN_DIRECT_ITEM 0xffffffff
 
-
 /* Stat Data on disk (reiserfs version of UFS disk inode minus the
    address blocks) */
 struct stat_data {
-    __u16 sd_mode;	/* file type, permissions */
-    __u16 sd_attrs;
-    __u32 sd_nlink;	/* 32 bit nlink! */
-    __u64 sd_size;	/* 64 bit size!*/
-    __u32 sd_uid;	/* 32 bit uid! */
-    __u32 sd_gid;	/* 32 bit gid! */
-    __u32 sd_atime;	/* time of last access */
-    __u32 sd_mtime;	/* time file was last modified  */
-    __u32 sd_ctime;	/* time inode (stat data) was last changed (except
-                           changes to sd_atime and sd_mtime) */
-    __u32 sd_blocks;
-    union {
-	__u32 sd_rdev;
-	__u32 sd_generation;
-      //__u32 sd_first_direct_byte; 
-      /* first byte of file which is stored in a direct item: except that if
-	 it equals 1 it is a symlink and if it equals ~(__u32)0 there is no
-	 direct item.  The existence of this field really grates on me. Let's
-	 replace it with a macro based on sd_size and our tail suppression
-	 policy? */
-  } __attribute__ ((__packed__)) u;
+	__u16 sd_mode;		/* file type, permissions */
+	__u16 sd_attrs;
+	__u32 sd_nlink;		/* 32 bit nlink! */
+	__u64 sd_size;		/* 64 bit size! */
+	__u32 sd_uid;		/* 32 bit uid! */
+	__u32 sd_gid;		/* 32 bit gid! */
+	__u32 sd_atime;		/* time of last access */
+	__u32 sd_mtime;		/* time file was last modified  */
+	__u32 sd_ctime;		/* time inode (stat data) was last changed (except
+				   changes to sd_atime and sd_mtime) */
+	__u32 sd_blocks;
+	union {
+		__u32 sd_rdev;
+		__u32 sd_generation;
+		//__u32 sd_first_direct_byte; 
+		/* first byte of file which is stored in a direct item: except that if
+		   it equals 1 it is a symlink and if it equals ~(__u32)0 there is no
+		   direct item.  The existence of this field really grates on me. Let's
+		   replace it with a macro based on sd_size and our tail suppression
+		   policy? */
+	} __attribute__ ((__packed__)) u;
 } __attribute__ ((__packed__));
 //
 // this is 44 bytes long
@@ -902,7 +858,6 @@ struct stat_data {
    be reached with a key of format 2 is 60 bits */
 #define MAX_FILE_SIZE_V2 0xfffffffffffffffLL
 
-
 /***************************************************************************/
 /*                      DIRECTORY STRUCTURE                                */
 /***************************************************************************/
@@ -923,22 +878,20 @@ struct stat_data {
 #define DOT_OFFSET 1
 #define DOT_DOT_OFFSET 2
 
-
 /* Each directory entry has its header. This header has deh_dir_id and
    deh_objectid fields, those are key of object, entry points to */
 
 /* NOT IMPLEMENTED:   
    Directory will someday contain stat data of object */
-struct reiserfs_de_head
-{
-    __u32 deh2_offset;  /* third component of the directory entry key */
-    __u32 deh2_dir_id;  /* objectid of the parent directory of the object,
-			   that is referenced by directory entry */
-    __u32 deh2_objectid;/* objectid of the object, that is referenced by
-			   directory entry */
-    __u16 deh2_location;/* offset of name in the whole item */
-    __u16 deh2_state;   /* whether 1) entry contains stat data (for future),
-			   and 2) whether entry is hidden (unlinked) */
+struct reiserfs_de_head {
+	__u32 deh2_offset;	/* third component of the directory entry key */
+	__u32 deh2_dir_id;	/* objectid of the parent directory of the object,
+				   that is referenced by directory entry */
+	__u32 deh2_objectid;	/* objectid of the object, that is referenced by
+				   directory entry */
+	__u16 deh2_location;	/* offset of name in the whole item */
+	__u16 deh2_state;	/* whether 1) entry contains stat data (for future),
+				   and 2) whether entry is hidden (unlinked) */
 } __attribute__ ((__packed__));
 
 #define DEH_SIZE sizeof(struct reiserfs_de_head)
@@ -959,15 +912,12 @@ struct reiserfs_de_head
 #define get_deh_state(deh)	get_le16 (deh, deh2_state)
 #define set_deh_state(deh,val)	set_le16 (deh, deh2_state, val)
 
-
-
 #define deh_offset(deh) (le32_to_cpu ((deh)->deh_offset))
 #define deh_dir_id(deh) (le32_to_cpu ((deh)->deh_dir_id))
 #define deh_objectid(deh) (le32_to_cpu ((deh)->deh_objectid))
 #define deh_location(deh) (le16_to_cpu ((deh)->deh_location))
 #define deh_state(deh) (le16_to_cpu ((deh)->deh_state))
 
-
 /* empty directory contains two entries "." and ".." and their headers */
 #define EMPTY_DIR_SIZE \
 (DEH_SIZE * 2 + ROUND_UP (strlen (".")) + ROUND_UP (strlen ("..")))
@@ -975,13 +925,12 @@ struct reiserfs_de_head
 /* old format directories have this size when empty */
 #define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)
 
-#define DEH_Statdata 0			/* not used now */
+#define DEH_Statdata 0		/* not used now */
 #define DEH_Visible2 2
 
-#define DEH_Bad_offset 4 /* fsck marks entries to be deleted with this flag */
+#define DEH_Bad_offset 4	/* fsck marks entries to be deleted with this flag */
 #define DEH_Bad_location 5
 
-
 #define test_deh_state_le_bit(deh,bit) (get_deh_state (deh) & (1 << bit))
 
 #define set_deh_state_le_bit(deh,bit) \
@@ -1000,7 +949,6 @@ struct reiserfs_de_head
 	set_deh_state(deh, state);\
 }
 
-
 #define mark_de_without_sd(deh)	clear_deh_state_le_bit (deh, DEH_Statdata)
 #define mark_de_visible(deh)	set_deh_state_le_bit (deh, DEH_Visible2)
 #define mark_de_hidden(deh)	clear_deh_state_le_bit (deh, DEH_Visible)
@@ -1019,7 +967,6 @@ struct reiserfs_de_head
 
 #define de_bad(deh) (de_bad_location(deh) || de_bad_offset(deh))
 
-
 /* for directories st_blocks is number of 512 byte units which fit into dir
    size round up to blocksize */
 #define dir_size2st_blocks(size) ((size + 511) / 512)
@@ -1030,13 +977,11 @@ struct reiserfs_de_head
 #define REISERFS_MAX_NAME_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE - DEH_SIZE)
 	/* -SD_SIZE when entry will contain stat data */
 
-
 /* hash value occupies 24 bits starting from 7 up to 30 */
 #define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80)
 /* generation number occupies 7 bits starting from 0 up to 6 */
 #define GET_GENERATION_NUMBER(offset) ((offset) & 0x0000007f)
 
-
 /*
  * Picture represents an internal node of the reiserfs tree
  *  ______________________________________________________
@@ -1052,9 +997,9 @@ struct reiserfs_de_head
 /* Disk child pointer: The pointer from an internal node of the tree
    to a node that is on disk. */
 struct disk_child {
-    __u32 dc2_block_number;              /* Disk child's block number. */
-    __u16 dc2_size;		            /* Disk child's used space.   */
-    __u16 dc2_reserved;
+	__u32 dc2_block_number;	/* Disk child's block number. */
+	__u16 dc2_size;		/* Disk child's used space.   */
+	__u16 dc2_reserved;
 } __attribute__ ((__packed__));
 
 #define DC_SIZE (sizeof(struct disk_child))
@@ -1078,8 +1023,7 @@ struct disk_child {
             ((p_s_bh)->b_data + BLKH_SIZE + B_NR_ITEMS(p_s_bh) \
             * KEY_SIZE + DC_SIZE * (n_pos)))
 
-
- /* maximal value of field child_size in structure disk_child */ 
+ /* maximal value of field child_size in structure disk_child */
  /* child size is the combined size of all items and their headers */
 #define MAX_CHILD_SIZE(blocksize) ((blocksize) - BLKH_SIZE)
 #define MAX_FREE_SPACE(blocksize) MAX_CHILD_SIZE(blocksize)
@@ -1091,7 +1035,6 @@ struct disk_child {
 #define MAX_NR_KEY(bh) ( (MAX_CHILD_SIZE(bh->b_size)-DC_SIZE)/(KEY_SIZE+DC_SIZE) )
 #define MIN_NR_KEY(bh)    (MAX_NR_KEY(bh)/2)
 
-
 /***************************************************************************/
 /*                      PATH STRUCTURES AND DEFINES                        */
 /***************************************************************************/
@@ -1108,14 +1051,13 @@ struct disk_child {
    equal to given key, or which is the maximal key less than the given
    key. */
 
-struct reiserfs_path_element  {
-    struct buffer_head * pe_buffer; /* Pointer to the buffer at the path in
-				       the tree. */
-    unsigned int pe_position;  /* Position in the tree node which is placed
-				  in the buffer above. */
+struct reiserfs_path_element {
+	struct buffer_head *pe_buffer;	/* Pointer to the buffer at the path in
+					   the tree. */
+	unsigned int pe_position;	/* Position in the tree node which is placed
+					   in the buffer above. */
 };
 
-
 #define MAX_HEIGHT 6
 #define FIRST_PATH_ELEMENT_OFFSET   2
 #define EXTENDED_MAX_HEIGHT         (MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET)
@@ -1123,8 +1065,6 @@ struct reiserfs_path_element  {
 #define ILLEGAL_PATH_ELEMENT_OFFSET 1
 #define MAX_FEB_SIZE (MAX_HEIGHT + 1)
 
-
-
 /* We need to keep track of who the ancestors of nodes are.  When we
    perform a search we record which nodes were visited while
    descending the tree looking for the node we searched for. This list
@@ -1135,9 +1075,9 @@ struct reiserfs_path_element  {
    in it, especially about decrement_counters_in_path(), to understand
    this structure. */
 struct reiserfs_path {
-  unsigned int          path_length;                      	/* Length of the array above.   */
-  struct  reiserfs_path_element  path_elements[EXTENDED_MAX_HEIGHT];	/* Array of the path elements.  */
-  unsigned int		pos_in_item;
+	unsigned int path_length;	/* Length of the array above.   */
+	struct reiserfs_path_element path_elements[EXTENDED_MAX_HEIGHT];	/* Array of the path elements.  */
+	unsigned int pos_in_item;
 };
 
 #define INITIALIZE_REISERFS_PATH(var) \
@@ -1152,19 +1092,17 @@ struct reiserfs_path var = {ILLEGAL_PATH_ELEMENT_OFFSET, }
 /* Get position in the element at the path by path and path position. */
 #define PATH_OFFSET_POSITION(p_s_path,n_offset) (PATH_OFFSET_PELEMENT(p_s_path,n_offset)->pe_position)
 
-
 #define PATH_PLAST_BUFFER(p_s_path) (PATH_OFFSET_PBUFFER((p_s_path), (p_s_path)->path_length))
 #define PATH_LAST_POSITION(p_s_path) (PATH_OFFSET_POSITION((p_s_path), (p_s_path)->path_length))
 
-
 #define PATH_PITEM_HEAD(p_s_path)    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(p_s_path),PATH_LAST_POSITION(p_s_path))
 
 /* in do_balance leaf has h == 0 in contrast with path structure,
    where root has level == 0. That is why we need these defines */
 #define PATH_H_PBUFFER(p_s_path, h) PATH_OFFSET_PBUFFER (p_s_path, p_s_path->path_length - (h))	/* tb->S[h] */
-#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)			/* tb->F[h] or tb->S[0]->b_parent */
-#define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))	
-#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)		/* tb->S[h]->b_item_order */
+#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER (path, (h) + 1)	/* tb->F[h] or tb->S[0]->b_parent */
+#define PATH_H_POSITION(path, h) PATH_OFFSET_POSITION (path, path->path_length - (h))
+#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)	/* tb->S[h]->b_item_order */
 
 #define PATH_H_PATH_OFFSET(p_s_path, n_h) ((p_s_path)->path_length - (n_h))
 
@@ -1175,7 +1113,6 @@ struct reiserfs_path var = {ILLEGAL_PATH_ELEMENT_OFFSET, }
 #define item_moved(ih,path) comp_items(ih, path)
 #define path_changed(ih,path) comp_items (ih, path)
 
-
 /***************************************************************************/
 /*                       MISC                                              */
 /***************************************************************************/
@@ -1188,7 +1125,6 @@ struct reiserfs_path var = {ILLEGAL_PATH_ELEMENT_OFFSET, }
 // FIXME: do not change 4 by anything else: there is code which relies on that
 #define ROUND_UP(x) _ROUND_UP(x,8LL)
 
-
 // search_by_key (and clones) and fix_nodes error code
 #define CARRY_ON		    0
 
@@ -1202,21 +1138,18 @@ struct reiserfs_path var = {ILLEGAL_PATH_ELEMENT_OFFSET, }
 #define FILE_NOT_FOUND		    12
 
 // used by fsck
-#define DIRECTORY_NOT_FOUND	    13 
+#define DIRECTORY_NOT_FOUND	    13
 #define REGULAR_FILE_FOUND	    14
 #define DIRECTORY_FOUND		    15
 
-
 struct unfm_nodeinfo {
-    __u32	 unfm_nodenum;
-    __u16 unfm_freespace;
+	__u32 unfm_nodenum;
+	__u16 unfm_freespace;
 };
 
-
 /* Size of pointer to the unformatted node. */
 #define UNFM_P_SIZE (sizeof(__u32))
 
-
 #define MAX_KEY1_OFFSET	 0xffffffff
 #define MAX_KEY2_OFFSET  0xfffffffffffffffLL
 
@@ -1236,7 +1169,6 @@ struct unfm_nodeinfo {
      ( (n_tail_size) >=   (MAX_ITEM_LEN(n_block_size) * 3)/4) ) ) \
 )
 
-
 /***************************************************************************/
 /*                  FIXATE NODES                                           */
 /***************************************************************************/
@@ -1262,32 +1194,29 @@ struct unfm_nodeinfo {
    all entries in directory item. We use this array of items when calculating
    what we can shift to neighbors and how many nodes we have to have if we do
    not any shiftings, if we shift to left/right neighbor or to both. */
-struct virtual_item
-{
-    unsigned short vi_type;	/* item type, mergeability */
-    unsigned short vi_item_len; /* length of item that it will have after balancing */
-    __u64 vi_item_offset; /* offset of item that it have before balancing */
+struct virtual_item {
+	unsigned short vi_type;	/* item type, mergeability */
+	unsigned short vi_item_len;	/* length of item that it will have after balancing */
+	__u64 vi_item_offset;	/* offset of item that it have before balancing */
 
-    short vi_entry_count;	/* number of entries in directory item
+	short vi_entry_count;	/* number of entries in directory item
 				   (including the new one if any, or excluding
 				   entry if it must be cut) */
-    unsigned short * vi_entry_sizes; /* array of entry lengths for directory item */
+	unsigned short *vi_entry_sizes;	/* array of entry lengths for directory item */
 };
 
-struct virtual_node
-{
-    char * vn_free_ptr;	 /* this is a pointer to the free space in the buffer */
-    unsigned short vn_nr_item;	/* number of items in virtual node */
-    short vn_size; /* size of node , that node would have if it has unlimited
-		      size and no balancing is performed */
-    short vn_mode;		/* mode of balancing (paste, insert, delete, cut) */
-    short vn_affected_item_num; 
-    short vn_pos_in_item;
-    struct item_head * vn_ins_ih;	/* item header of inserted item, 0 for other modes */
-    struct virtual_item * vn_vi;	/* array of items (including a new one, excluding item to be deleted) */
+struct virtual_node {
+	char *vn_free_ptr;	/* this is a pointer to the free space in the buffer */
+	unsigned short vn_nr_item;	/* number of items in virtual node */
+	short vn_size;		/* size of node , that node would have if it has unlimited
+				   size and no balancing is performed */
+	short vn_mode;		/* mode of balancing (paste, insert, delete, cut) */
+	short vn_affected_item_num;
+	short vn_pos_in_item;
+	struct item_head *vn_ins_ih;	/* item header of inserted item, 0 for other modes */
+	struct virtual_item *vn_vi;	/* array of items (including a new one, excluding item to be deleted) */
 };
 
-
 /***************************************************************************/
 /*                  TREE BALANCE                                           */
 /***************************************************************************/
@@ -1308,69 +1237,66 @@ struct virtual_node
 #define MAX_AMOUNT_NEEDED 2
 
 /* someday somebody will prefix every field in this struct with tb_ */
-struct tree_balance
-{
-    struct reiserfs_transaction_handle *transaction_handle ;
-    reiserfs_filsys_t * tb_fs;
-    struct reiserfs_path *tb_path;
-    struct buffer_head * L[MAX_HEIGHT];        /* array of left neighbors of nodes in the path */
-    struct buffer_head * R[MAX_HEIGHT];        /* array of right neighbors of nodes in the path*/
-    struct buffer_head * FL[MAX_HEIGHT];       /* array of fathers of the left  neighbors      */
-    struct buffer_head * FR[MAX_HEIGHT];       /* array of fathers of the right neighbors      */
-    struct buffer_head * CFL[MAX_HEIGHT];      /* array of common parents of center node and its left neighbor  */
-    struct buffer_head * CFR[MAX_HEIGHT];      /* array of common parents of center node and its right neighbor */
-    
-    /* array of blocknr's that are free and are the nearest to the left node that are usable
-       for writing dirty formatted leaves, using the write_next_to algorithm. */
-    /*unsigned long free_and_near[MAX_DIRTIABLE];*/
-    
-    struct buffer_head * FEB[MAX_FEB_SIZE]; /* array of empty buffers. Number of buffers in array equals
-					       cur_blknum. */
-    struct buffer_head * used[MAX_FEB_SIZE];
-    short int lnum[MAX_HEIGHT];	/* array of number of items which must be shifted to the left in
-				   order to balance the current node; for leaves includes item
-				   that will be partially shifted; for internal nodes, it is
-				   the number of child pointers rather than items. It includes
-				   the new item being created.  For preserve_shifted() purposes
-				   the code sometimes subtracts one from this number to get the
-				   number of currently existing items being shifted, and even
-				   more often for leaves it subtracts one to get the number of
-				   wholly shifted items for other purposes. */
-    short int rnum[MAX_HEIGHT];	/* substitute right for left in comment above */
-    short int lkey[MAX_HEIGHT];               /* array indexed by height h mapping the key delimiting L[h] and
-					       S[h] to its item number within the node CFL[h] */
-    short int rkey[MAX_HEIGHT];               /* substitute r for l in comment above */
-    short int insert_size[MAX_HEIGHT];        /* the number of bytes by we are trying to add or remove from
-						 S[h]. A negative value means removing.  */
-    short int blknum[MAX_HEIGHT];             /* number of nodes that will replace node S[h] after
-						 balancing on the level h of the tree.  If 0 then S is
-						 being deleted, if 1 then S is remaining and no new nodes
-						 are being created, if 2 or 3 then 1 or 2 new nodes is
-						 being created */
-    
-    /* fields that are used only for balancing leaves of the tree */
-    short int cur_blknum;	/* number of empty blocks having been already allocated			*/
-    short int s0num;             /* number of items that fall into left most  node when S[0] splits	*/
-    short int s1num;             /* number of items that fall into first  new node when S[0] splits	*/
-    short int s2num;             /* number of items that fall into second new node when S[0] splits	*/
-    short int lbytes;            /* number of bytes which can flow to the left neighbor from the	left	*/
-    /* most liquid item that cannot be shifted from S[0] entirely		*/
-    /* if -1 then nothing will be partially shifted */
-    short int rbytes;            /* number of bytes which will flow to the right neighbor from the right	*/
-    /* most liquid item that cannot be shifted from S[0] entirely		*/
-    /* if -1 then nothing will be partially shifted                           */
-    short int s1bytes;		/* number of bytes which flow to the first  new node when S[0] splits	*/
-            			/* note: if S[0] splits into 3 nodes, then items do not need to be cut	*/
-    short int s2bytes;
-    struct buffer_head * buf_to_free[MAX_FREE_BLOCK]; /* buffers which are to be freed after do_balance finishes by unfix_nodes */
-    char * vn_buf;		/* kmalloced memory. Used to create
+struct tree_balance {
+	struct reiserfs_transaction_handle *transaction_handle;
+	reiserfs_filsys_t *tb_fs;
+	struct reiserfs_path *tb_path;
+	struct buffer_head *L[MAX_HEIGHT];	/* array of left neighbors of nodes in the path */
+	struct buffer_head *R[MAX_HEIGHT];	/* array of right neighbors of nodes in the path */
+	struct buffer_head *FL[MAX_HEIGHT];	/* array of fathers of the left  neighbors      */
+	struct buffer_head *FR[MAX_HEIGHT];	/* array of fathers of the right neighbors      */
+	struct buffer_head *CFL[MAX_HEIGHT];	/* array of common parents of center node and its left neighbor  */
+	struct buffer_head *CFR[MAX_HEIGHT];	/* array of common parents of center node and its right neighbor */
+
+	/* array of blocknr's that are free and are the nearest to the left node that are usable
+	   for writing dirty formatted leaves, using the write_next_to algorithm. */
+	/*unsigned long free_and_near[MAX_DIRTIABLE]; */
+
+	struct buffer_head *FEB[MAX_FEB_SIZE];	/* array of empty buffers. Number of buffers in array equals
+						   cur_blknum. */
+	struct buffer_head *used[MAX_FEB_SIZE];
+	short int lnum[MAX_HEIGHT];	/* array of number of items which must be shifted to the left in
+					   order to balance the current node; for leaves includes item
+					   that will be partially shifted; for internal nodes, it is
+					   the number of child pointers rather than items. It includes
+					   the new item being created.  For preserve_shifted() purposes
+					   the code sometimes subtracts one from this number to get the
+					   number of currently existing items being shifted, and even
+					   more often for leaves it subtracts one to get the number of
+					   wholly shifted items for other purposes. */
+	short int rnum[MAX_HEIGHT];	/* substitute right for left in comment above */
+	short int lkey[MAX_HEIGHT];	/* array indexed by height h mapping the key delimiting L[h] and
+					   S[h] to its item number within the node CFL[h] */
+	short int rkey[MAX_HEIGHT];	/* substitute r for l in comment above */
+	short int insert_size[MAX_HEIGHT];	/* the number of bytes by we are trying to add or remove from
+						   S[h]. A negative value means removing.  */
+	short int blknum[MAX_HEIGHT];	/* number of nodes that will replace node S[h] after
+					   balancing on the level h of the tree.  If 0 then S is
+					   being deleted, if 1 then S is remaining and no new nodes
+					   are being created, if 2 or 3 then 1 or 2 new nodes is
+					   being created */
+
+	/* fields that are used only for balancing leaves of the tree */
+	short int cur_blknum;	/* number of empty blocks having been already allocated                 */
+	short int s0num;	/* number of items that fall into left most  node when S[0] splits     */
+	short int s1num;	/* number of items that fall into first  new node when S[0] splits     */
+	short int s2num;	/* number of items that fall into second new node when S[0] splits     */
+	short int lbytes;	/* number of bytes which can flow to the left neighbor from the        left    */
+	/* most liquid item that cannot be shifted from S[0] entirely               */
+	/* if -1 then nothing will be partially shifted */
+	short int rbytes;	/* number of bytes which will flow to the right neighbor from the right        */
+	/* most liquid item that cannot be shifted from S[0] entirely               */
+	/* if -1 then nothing will be partially shifted                           */
+	short int s1bytes;	/* number of bytes which flow to the first  new node when S[0] splits   */
+	/* note: if S[0] splits into 3 nodes, then items do not need to be cut  */
+	short int s2bytes;
+	struct buffer_head *buf_to_free[MAX_FREE_BLOCK];	/* buffers which are to be freed after do_balance finishes by unfix_nodes */
+	char *vn_buf;		/* kmalloced memory. Used to create
 				   virtual node and keep map of
 				   dirtied bitmap blocks */
-    int vn_buf_size;		/* size of the vn_buf */
-    struct virtual_node * tb_vn;	/* VN starts after bitmap of bitmap blocks */
-} ;
-
-
+	int vn_buf_size;	/* size of the vn_buf */
+	struct virtual_node *tb_vn;	/* VN starts after bitmap of bitmap blocks */
+};
 
 /* These are modes of balancing */
 
@@ -1521,8 +1447,8 @@ void decrement_counters_in_path (struct reiserfs_path *p_s_search_path);
 void pathrelse (struct reiserfs_path *p_s_search_path);
 
 
-int is_left_mergeable (reiserfs_filsys_t * s, struct reiserfs_path *path);
-int is_right_mergeable (reiserfs_filsys_t * s, struct reiserfs_path *path);
+int is_left_mergeable (reiserfs_filsys_t *s, struct reiserfs_path *path);
+int is_right_mergeable (reiserfs_filsys_t *s, struct reiserfs_path *path);
 int are_items_mergeable (struct item_head * left, struct item_head * right, int bsize);
 
 
@@ -1546,8 +1472,8 @@ void init_path (struct reiserfs_path *);
 void print_tb (int mode, int item_pos, int pos_in_item, struct tree_balance * tb, char * mes);
 
 
-void print_bmap (FILE * fp, reiserfs_filsys_t * fs, int silent);
-void print_objectid_map (FILE * fp, reiserfs_filsys_t * fs);
+void print_bmap (FILE * fp, reiserfs_filsys_t *fs, int silent);
+void print_objectid_map (FILE * fp, reiserfs_filsys_t *fs);
 
 
 
@@ -1604,9 +1530,9 @@ __u32 r5_hash (const char *msg, int len);
 
 
 /* node_format.c */
-extern unsigned int get_journal_old_start_must (reiserfs_filsys_t * fs);
-extern unsigned int get_journal_new_start_must (reiserfs_filsys_t * fs);
-extern unsigned int get_journal_start_must (reiserfs_filsys_t * fs);
+extern unsigned int get_journal_old_start_must (reiserfs_filsys_t *fs);
+extern unsigned int get_journal_new_start_must (reiserfs_filsys_t *fs);
+extern unsigned int get_journal_start_must (reiserfs_filsys_t *fs);
 /*extern hashf_t hashes [];*/
 
 #endif
diff --git a/include/reiserfs_lib.h b/include/reiserfs_lib.h
index d6abb58..b5a7325 100644
--- a/include/reiserfs_lib.h
+++ b/include/reiserfs_lib.h
@@ -14,145 +14,150 @@ typedef struct reiserfs_filsys reiserfs_filsys_t;
 #include "reiserfs_fs.h"
 
 struct _bitmap {
-    unsigned long bm_byte_size;
-    unsigned long bm_bit_size;
-    char * bm_map;
-    unsigned long bm_set_bits;
-    int bm_dirty;  /* used for fetched bitmap */
+	unsigned long bm_byte_size;
+	unsigned long bm_bit_size;
+	char *bm_map;
+	unsigned long bm_set_bits;
+	int bm_dirty;		/* used for fetched bitmap */
 };
 
 typedef struct _bitmap reiserfs_bitmap_t;
 
-typedef __u32 (*hashf_t) (const char *, int);
+typedef __u32(*hashf_t) (const char *, int);
 
 struct reiserfs_filsys {
-    unsigned int fs_blocksize;
-    int fs_format;	      /* on-disk format version */
-    hashf_t fs_hash_function; /* pointer to function which is used to sort
-				 names in directory. It is set by
-				 reiserfs_open if it is set in the super
-				 block, otherwise it is set by first
-				 is_properly_hashed */
-    
-    char * fs_file_name;       /* file name of underlying device */
-    int fs_dev; /* descriptor of opened block device file */
-    struct buffer_head * fs_super_bh;  /* buffer containing super block */
-    struct reiserfs_super_block * fs_ondisk_sb; /* pointer to its b_data */
-
-
-    reiserfs_bitmap_t * fs_bitmap2; /* ondisk bitmap after
-				       reiserfs_open_ondisk_bitmap */
-
-
-    /* opened journal fields */
-    char * fs_j_file_name;  /* file name of relocated journal device */
-    int fs_journal_dev;		/* descriptor of opened journal device */
-    struct buffer_head * fs_jh_bh;	/* buffer containing journal header */
-
-    /* badblocks */
-    reiserfs_bitmap_t * fs_badblocks_bm;
-
-    int fs_dirt;
-    int fs_flags;
-    void * fs_vp;
-    int (*block_allocator) (reiserfs_filsys_t * fs, 
-			    unsigned long * free_blocknrs,
-			    unsigned long start, int amount_needed);
-    int (*block_deallocator) (reiserfs_filsys_t * fs, unsigned long block);
+	unsigned int fs_blocksize;
+	int fs_format;		/* on-disk format version */
+	hashf_t fs_hash_function;	/* pointer to function which is used to sort
+					   names in directory. It is set by
+					   reiserfs_open if it is set in the super
+					   block, otherwise it is set by first
+					   is_properly_hashed */
+
+	char *fs_file_name;	/* file name of underlying device */
+	int fs_dev;		/* descriptor of opened block device file */
+	struct buffer_head *fs_super_bh;	/* buffer containing super block */
+	struct reiserfs_super_block *fs_ondisk_sb;	/* pointer to its b_data */
+
+	reiserfs_bitmap_t *fs_bitmap2;	/* ondisk bitmap after
+					   reiserfs_open_ondisk_bitmap */
+
+	/* opened journal fields */
+	char *fs_j_file_name;	/* file name of relocated journal device */
+	int fs_journal_dev;	/* descriptor of opened journal device */
+	struct buffer_head *fs_jh_bh;	/* buffer containing journal header */
+
+	/* badblocks */
+	reiserfs_bitmap_t *fs_badblocks_bm;
+
+	int fs_dirt;
+	int fs_flags;
+	void *fs_vp;
+	int (*block_allocator) (reiserfs_filsys_t *fs,
+				unsigned long *free_blocknrs,
+				unsigned long start, int amount_needed);
+	int (*block_deallocator) (reiserfs_filsys_t *fs, unsigned long block);
 };
 
-
 struct _transaction {
-    unsigned long mount_id;
-    unsigned long trans_id;
-    unsigned long desc_blocknr;
-    unsigned long trans_len;
-    unsigned long commit_blocknr;
-    unsigned long next_trans_offset;
+	unsigned long mount_id;
+	unsigned long trans_id;
+	unsigned long desc_blocknr;
+	unsigned long trans_len;
+	unsigned long commit_blocknr;
+	unsigned long next_trans_offset;
 };
 
 typedef struct _transaction reiserfs_trans_t;
 
-
 /* reiserfslib.c */
 
-void init_tb_struct (struct tree_balance * tb, reiserfs_filsys_t *, struct reiserfs_path *path, int size);
+void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t *,
+		    struct reiserfs_path *path, int size);
 
-reiserfs_filsys_t * reiserfs_open (char * filename, int flags, int * error, void * vp, int skip_check);
-reiserfs_filsys_t * reiserfs_create (char * filename, int version, unsigned long block_count,
-				     int block_size, int default_journal, int new_format);
-void reiserfs_flush (reiserfs_filsys_t *);
-void reiserfs_free (reiserfs_filsys_t *);
-void reiserfs_close (reiserfs_filsys_t *);
-void reiserfs_reopen (reiserfs_filsys_t *, int flags);
-int is_opened_rw (reiserfs_filsys_t * fs);
+reiserfs_filsys_t *reiserfs_open(char *filename, int flags, int *error,
+				 void *vp, int skip_check);
+reiserfs_filsys_t *reiserfs_create(char *filename, int version,
+				   unsigned long block_count, int block_size,
+				   int default_journal, int new_format);
+void reiserfs_flush(reiserfs_filsys_t *);
+void reiserfs_free(reiserfs_filsys_t *);
+void reiserfs_close(reiserfs_filsys_t *);
+void reiserfs_reopen(reiserfs_filsys_t *, int flags);
+int is_opened_rw(reiserfs_filsys_t *fs);
 
 /*
 void reiserfs_read_bitmap_blocks (reiserfs_filsys_t *);
 void reiserfs_free_bitmap_blocks (reiserfs_filsys_t *);
 */
-int no_reiserfs_found (reiserfs_filsys_t *);
+int no_reiserfs_found(reiserfs_filsys_t *);
 int block_size_ok(int blocksize, int force);
-int is_block_count_correct (unsigned long block_of_super_block, unsigned int block_size,
-	unsigned long block_count, unsigned long journal_size);
+int is_block_count_correct(unsigned long block_of_super_block,
+			   unsigned int block_size, unsigned long block_count,
+			   unsigned long journal_size);
 //unsigned long min_block_amount (int block_size, unsigned long journal_size);
-unsigned long get_size_of_journal_or_reserved_area (struct reiserfs_super_block * sb);
-
-int reiserfs_new_blocknrs (reiserfs_filsys_t *, 
-			   unsigned long * free_blocknrs, unsigned long start,
-			   int amount_needed);
-int reiserfs_free_block (reiserfs_filsys_t *, unsigned long block);
-int spread_bitmaps (reiserfs_filsys_t *);
-int filesystem_dirty (reiserfs_filsys_t *);
-void mark_filesystem_dirty (reiserfs_filsys_t *);
-
-void reiserfs_paste_into_item (reiserfs_filsys_t *, struct reiserfs_path *path,
-			       const void * body, int size);
-void reiserfs_insert_item (reiserfs_filsys_t *, struct reiserfs_path *path,
-			   struct item_head * ih, const void * body);
-
-int reiserfs_locate_entry (reiserfs_filsys_t *, struct reiserfs_key *dir, char * name,
-			   struct reiserfs_path *path);
-int reiserfs_find_entry (reiserfs_filsys_t *, struct reiserfs_key *dir, char * name,
-			 unsigned int * min_gen_counter, struct reiserfs_key *key);
-int reiserfs_add_entry (reiserfs_filsys_t *, struct reiserfs_key *dir, char * name, int name_len,
-			struct reiserfs_key *key, __u16 fsck_need);
-
-struct reiserfs_key *uget_lkey (struct reiserfs_path *path);
-struct reiserfs_key *uget_rkey (struct reiserfs_path *path);
-int reiserfs_search_by_key_3 (reiserfs_filsys_t *, struct reiserfs_key *key,
-			    struct reiserfs_path *path);
-int reiserfs_search_by_key_4 (reiserfs_filsys_t *, struct reiserfs_key *key, 
-			    struct reiserfs_path *path);
-int reiserfs_search_by_entry_key (reiserfs_filsys_t *, struct reiserfs_key *key, 
-				  struct reiserfs_path *path);
-int usearch_by_position (reiserfs_filsys_t *, struct reiserfs_key *key, int version, struct reiserfs_path *path);
-struct reiserfs_key *reiserfs_next_key (struct reiserfs_path *path);
-void copy_key (void * to, void * from);
-void copy_short_key (void * to, void * from);
-void copy_item_head(void * p_v_to, void * p_v_from);
-int comp_keys (const void * k1, const void * k2);
-int comp_keys_3 (const void * k1, const void * k2);
-int  comp_short_keys (const void * p_s_key1, const void * p_s_key2);
-int comp_items (struct item_head  * p_s_ih, struct reiserfs_path *p_s_path);
-
-__u32 hash_value (hashf_t func, char * name, int namelen);
-
-int create_dir_sd (reiserfs_filsys_t * fs,
-		    struct reiserfs_path *path, struct reiserfs_key *key,
-		    void (*modify_item)(struct item_head *, void *));
-void make_sure_root_dir_exists (reiserfs_filsys_t * fs,
-				void (*modyfy_item)(struct item_head *, void *),
-				int ih_flags);
-
-typedef void (*badblock_func_t) (reiserfs_filsys_t *fs, 
-				 struct reiserfs_path *badblock_path, 
+unsigned long get_size_of_journal_or_reserved_area(struct reiserfs_super_block
+						   *sb);
+
+int reiserfs_new_blocknrs(reiserfs_filsys_t *,
+			  unsigned long *free_blocknrs, unsigned long start,
+			  int amount_needed);
+int reiserfs_free_block(reiserfs_filsys_t *, unsigned long block);
+int spread_bitmaps(reiserfs_filsys_t *);
+int filesystem_dirty(reiserfs_filsys_t *);
+void mark_filesystem_dirty(reiserfs_filsys_t *);
+
+void reiserfs_paste_into_item(reiserfs_filsys_t *, struct reiserfs_path *path,
+			      const void *body, int size);
+void reiserfs_insert_item(reiserfs_filsys_t *, struct reiserfs_path *path,
+			  struct item_head *ih, const void *body);
+
+int reiserfs_locate_entry(reiserfs_filsys_t *, struct reiserfs_key *dir,
+			  char *name, struct reiserfs_path *path);
+int reiserfs_find_entry(reiserfs_filsys_t *, struct reiserfs_key *dir,
+			char *name, unsigned int *min_gen_counter,
+			struct reiserfs_key *key);
+int reiserfs_add_entry(reiserfs_filsys_t *, struct reiserfs_key *dir,
+		       char *name, int name_len, struct reiserfs_key *key,
+		       __u16 fsck_need);
+
+struct reiserfs_key *uget_lkey(struct reiserfs_path *path);
+struct reiserfs_key *uget_rkey(struct reiserfs_path *path);
+int reiserfs_search_by_key_3(reiserfs_filsys_t *, struct reiserfs_key *key,
+			     struct reiserfs_path *path);
+int reiserfs_search_by_key_4(reiserfs_filsys_t *, struct reiserfs_key *key,
+			     struct reiserfs_path *path);
+int reiserfs_search_by_entry_key(reiserfs_filsys_t *, struct reiserfs_key *key,
+				 struct reiserfs_path *path);
+int usearch_by_position(reiserfs_filsys_t *, struct reiserfs_key *key,
+			int version, struct reiserfs_path *path);
+struct reiserfs_key *reiserfs_next_key(struct reiserfs_path *path);
+void copy_key(void *to, void *from);
+void copy_short_key(void *to, void *from);
+void copy_item_head(void *p_v_to, void *p_v_from);
+int comp_keys(const void *k1, const void *k2);
+int comp_keys_3(const void *k1, const void *k2);
+int comp_short_keys(const void *p_s_key1, const void *p_s_key2);
+int comp_items(struct item_head *p_s_ih, struct reiserfs_path *p_s_path);
+
+__u32 hash_value(hashf_t func, char *name, int namelen);
+
+int create_dir_sd(reiserfs_filsys_t *fs,
+		  struct reiserfs_path *path, struct reiserfs_key *key,
+		  void (*modify_item) (struct item_head *, void *));
+void make_sure_root_dir_exists(reiserfs_filsys_t *fs,
+			       void (*modyfy_item) (struct item_head *, void *),
+			       int ih_flags);
+
+typedef void (*badblock_func_t) (reiserfs_filsys_t *fs,
+				 struct reiserfs_path *badblock_path,
 				 void *data);
 
-void mark_badblock(reiserfs_filsys_t *fs, struct reiserfs_path *badblock_path, void *data);
-int create_badblock_bitmap (reiserfs_filsys_t * fs, char * badblocks_file);
-void add_badblock_list (reiserfs_filsys_t * fs, int no_badblock_in_tree_yet);
-void badblock_list(reiserfs_filsys_t * fs, badblock_func_t action, void *data);
+void mark_badblock(reiserfs_filsys_t *fs, struct reiserfs_path *badblock_path,
+		   void *data);
+int create_badblock_bitmap(reiserfs_filsys_t *fs, char *badblocks_file);
+void add_badblock_list(reiserfs_filsys_t *fs, int no_badblock_in_tree_yet);
+void badblock_list(reiserfs_filsys_t *fs, badblock_func_t action, void *data);
 #define reiserfs_fs_bmap_nr(fs) reiserfs_bmap_nr(get_sb_block_count(fs->fs_ondisk_sb), fs->fs_blocksize)
 #define reiserfs_bmap_nr(count, blk_size) ((count - 1) / (blk_size * 8) + 1)
 #define reiserfs_bmap_over(nr) (nr > ((1LL << 16) - 1))
@@ -163,52 +168,51 @@ extern struct reiserfs_key lost_found_dir_key;
 extern __u16 root_dir_format;
 extern __u16 lost_found_dir_format;
 
-
 /* bitmap.c */
-int reiserfs_open_ondisk_bitmap (reiserfs_filsys_t *);
-int reiserfs_create_ondisk_bitmap (reiserfs_filsys_t *);
-void reiserfs_free_ondisk_bitmap (reiserfs_filsys_t *);
-void reiserfs_close_ondisk_bitmap (reiserfs_filsys_t *);
-int reiserfs_flush_to_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t * fs);
+int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t *);
+int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t *);
+void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t *);
+void reiserfs_close_ondisk_bitmap(reiserfs_filsys_t *);
+int reiserfs_flush_to_ondisk_bitmap(reiserfs_bitmap_t *bm,
+				    reiserfs_filsys_t *fs);
 unsigned int reiserfs_calc_bmap_nr(reiserfs_filsys_t *fs, unsigned int blocks);
 
-reiserfs_bitmap_t * reiserfs_create_bitmap (unsigned int bit_count);
-int reiserfs_expand_bitmap (reiserfs_bitmap_t * bm, unsigned int bit_count);
-void reiserfs_shrink_bitmap (reiserfs_bitmap_t * bm, unsigned int bit_count);
-void reiserfs_delete_bitmap (reiserfs_bitmap_t * bm);
-void reiserfs_bitmap_copy (reiserfs_bitmap_t * to, reiserfs_bitmap_t * from);
-int reiserfs_bitmap_compare (reiserfs_bitmap_t * bm1, reiserfs_bitmap_t * bm2);
-void reiserfs_bitmap_disjunction (reiserfs_bitmap_t * disk, reiserfs_bitmap_t * cont);
-void reiserfs_bitmap_delta (reiserfs_bitmap_t * base, reiserfs_bitmap_t * exclude);
-void reiserfs_bitmap_set_bit (reiserfs_bitmap_t * bm, unsigned int bit_number);
-void reiserfs_bitmap_clear_bit (reiserfs_bitmap_t * bm, unsigned int bit_number);
-
-int reiserfs_bitmap_test_bit (reiserfs_bitmap_t * bm, unsigned int bit_number);
-int reiserfs_bitmap_find_zero_bit (reiserfs_bitmap_t * bm, unsigned long * start);
-/*int reiserfs_fetch_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t *);*/
-/*int reiserfs_flush_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t *);*/
-void reiserfs_bitmap_zero (reiserfs_bitmap_t * bm);
-void reiserfs_bitmap_fill (reiserfs_bitmap_t * bm);
-unsigned int reiserfs_bitmap_ones (reiserfs_bitmap_t * bm);
-unsigned int reiserfs_bitmap_zeros (reiserfs_bitmap_t * bm);
-
-FILE * open_file(char * filename, char * option);
+reiserfs_bitmap_t *reiserfs_create_bitmap(unsigned int bit_count);
+int reiserfs_expand_bitmap(reiserfs_bitmap_t *bm, unsigned int bit_count);
+void reiserfs_shrink_bitmap(reiserfs_bitmap_t *bm, unsigned int bit_count);
+void reiserfs_delete_bitmap(reiserfs_bitmap_t *bm);
+void reiserfs_bitmap_copy(reiserfs_bitmap_t *to, reiserfs_bitmap_t *from);
+int reiserfs_bitmap_compare(reiserfs_bitmap_t *bm1, reiserfs_bitmap_t *bm2);
+void reiserfs_bitmap_disjunction(reiserfs_bitmap_t *disk,
+				 reiserfs_bitmap_t *cont);
+void reiserfs_bitmap_delta(reiserfs_bitmap_t *base,
+			   reiserfs_bitmap_t *exclude);
+void reiserfs_bitmap_set_bit(reiserfs_bitmap_t *bm, unsigned int bit_number);
+void reiserfs_bitmap_clear_bit(reiserfs_bitmap_t *bm, unsigned int bit_number);
+
+int reiserfs_bitmap_test_bit(reiserfs_bitmap_t *bm, unsigned int bit_number);
+int reiserfs_bitmap_find_zero_bit(reiserfs_bitmap_t *bm, unsigned long *start);
+/*int reiserfs_fetch_ondisk_bitmap (reiserfs_bitmap_t *bm, reiserfs_filsys_t *);*/
+/*int reiserfs_flush_bitmap (reiserfs_bitmap_t *bm, reiserfs_filsys_t *);*/
+void reiserfs_bitmap_zero(reiserfs_bitmap_t *bm);
+void reiserfs_bitmap_fill(reiserfs_bitmap_t *bm);
+unsigned int reiserfs_bitmap_ones(reiserfs_bitmap_t *bm);
+unsigned int reiserfs_bitmap_zeros(reiserfs_bitmap_t *bm);
+
+FILE *open_file(char *filename, char *option);
 void close_file(FILE * fp);
-void reiserfs_bitmap_save (FILE * fp, reiserfs_bitmap_t * bm);
+void reiserfs_bitmap_save(FILE * fp, reiserfs_bitmap_t *bm);
 
 /* this probably should be in fsck */
 void reiserfs_begin_stage_info_save(FILE * file, unsigned long stage);
 void reiserfs_end_stage_info_save(FILE * file);
-int is_stage_magic_correct (FILE * fp);
+int is_stage_magic_correct(FILE * fp);
 //void reiserfs_stage_info_save(struct fsck_data *, FILE * file);
 
-reiserfs_bitmap_t * reiserfs_bitmap_load (FILE * fp);
-void reiserfs_bitmap_invert (reiserfs_bitmap_t * bm);
-
-
-int reiserfs_remove_entry (reiserfs_filsys_t *, struct reiserfs_key *key);
-
+reiserfs_bitmap_t *reiserfs_bitmap_load(FILE * fp);
+void reiserfs_bitmap_invert(reiserfs_bitmap_t *bm);
 
+int reiserfs_remove_entry(reiserfs_filsys_t *, struct reiserfs_key *key);
 
 /* node_formats.c */
 
@@ -219,85 +223,85 @@ int reiserfs_remove_entry (reiserfs_filsys_t *, struct reiserfs_key *key);
 #define HAS_IH_ARRAY 5
 #define THE_UNKNOWN 6
 
-int is_blocksize_correct (unsigned int blocksize);
-int is_reiserfs_3_5_magic_string (struct reiserfs_super_block * rs);
-int is_reiserfs_3_6_magic_string (struct reiserfs_super_block * rs);
-int is_reiserfs_jr_magic_string (struct reiserfs_super_block * rs);
-int does_look_like_super_block (struct reiserfs_super_block * rs);
-int is_any_reiserfs_magic_string (struct reiserfs_super_block * rs);
-int get_reiserfs_format (struct reiserfs_super_block * sb);
-int reiserfs_super_block_size (struct reiserfs_super_block * rs);
+int is_blocksize_correct(unsigned int blocksize);
+int is_reiserfs_3_5_magic_string(struct reiserfs_super_block *rs);
+int is_reiserfs_3_6_magic_string(struct reiserfs_super_block *rs);
+int is_reiserfs_jr_magic_string(struct reiserfs_super_block *rs);
+int does_look_like_super_block(struct reiserfs_super_block *rs);
+int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs);
+int get_reiserfs_format(struct reiserfs_super_block *sb);
+int reiserfs_super_block_size(struct reiserfs_super_block *rs);
 /*int magic_2_version (struct reiserfs_super_block * rs);*/
-int is_prejournaled_reiserfs (struct reiserfs_super_block * rs);
-int who_is_this (char * buf, int blocksize);
-
-int leaf_count_ih(char * buf, int blocksize);
-int leaf_free_space_estimate(char * buf, int blocksize);
-int is_a_leaf(char * buf, int blocksize);
-int leaf_item_number_estimate(struct buffer_head * bh);
-
-char * which_block (int code);
-int get_journal_size (reiserfs_filsys_t *);
-int not_data_block (reiserfs_filsys_t *, unsigned long block);
-int not_journalable (reiserfs_filsys_t *, unsigned long block);
-int block_of_bitmap (reiserfs_filsys_t *, unsigned long block);
-int block_of_journal (reiserfs_filsys_t *, unsigned long block);
-int is_tree_node (struct buffer_head * bh, int level);
-int is_properly_hashed (reiserfs_filsys_t *,
-			char * name, int namelen, __u32 offset);
-int dir_entry_bad_location (struct reiserfs_de_head * deh, 
-			    struct item_head * ih, int first);
-void make_dir_stat_data (int blocksize, int key_format, 
-			 __u32 dirid, __u32 objectid, 
-			 struct item_head * ih, void * sd);
-void make_empty_dir_item_v1 (char * body, __u32 dirid, __u32 objid,
-			     __u32 par_dirid, __u32 par_objid);
-void make_empty_dir_item (char * body, __u32 dirid, __u32 objid,
-			  __u32 par_dirid, __u32 par_objid);
-int reiserfs_is_fs_consistent (reiserfs_filsys_t * fs);
-
+int is_prejournaled_reiserfs(struct reiserfs_super_block *rs);
+int who_is_this(char *buf, int blocksize);
+
+int leaf_count_ih(char *buf, int blocksize);
+int leaf_free_space_estimate(char *buf, int blocksize);
+int is_a_leaf(char *buf, int blocksize);
+int leaf_item_number_estimate(struct buffer_head *bh);
+
+char *which_block(int code);
+int get_journal_size(reiserfs_filsys_t *);
+int not_data_block(reiserfs_filsys_t *, unsigned long block);
+int not_journalable(reiserfs_filsys_t *, unsigned long block);
+int block_of_bitmap(reiserfs_filsys_t *, unsigned long block);
+int block_of_journal(reiserfs_filsys_t *, unsigned long block);
+int is_tree_node(struct buffer_head *bh, int level);
+int is_properly_hashed(reiserfs_filsys_t *,
+		       char *name, int namelen, __u32 offset);
+int dir_entry_bad_location(struct reiserfs_de_head *deh,
+			   struct item_head *ih, int first);
+void make_dir_stat_data(int blocksize, int key_format,
+			__u32 dirid, __u32 objectid,
+			struct item_head *ih, void *sd);
+void make_empty_dir_item_v1(char *body, __u32 dirid, __u32 objid,
+			    __u32 par_dirid, __u32 par_objid);
+void make_empty_dir_item(char *body, __u32 dirid, __u32 objid,
+			 __u32 par_dirid, __u32 par_objid);
+int reiserfs_is_fs_consistent(reiserfs_filsys_t *fs);
 
 typedef void (*item_action_t) (struct buffer_head * bh, struct item_head * ih);
 typedef void (*item_head_action_t) (struct item_head * ih);
 
-void for_every_item (struct buffer_head * bh, item_head_action_t action,
-		     item_action_t * actions);
-int key_format (const struct reiserfs_key *key);
-unsigned long long get_offset (const struct reiserfs_key *key);
-int uniqueness2type (__u32 uniqueness);
-__u32 type2uniqueness (int type);
-int get_type (const struct reiserfs_key *key);
-char * key_of_what (const struct reiserfs_key *key);
-int type_unknown (struct reiserfs_key *key);
-void set_type (int format, struct reiserfs_key *key, int type);
-void set_offset (int format, struct reiserfs_key *key, loff_t offset);
-void set_type_and_offset (int format, struct reiserfs_key *key, loff_t offset, int type);
-
+void for_every_item(struct buffer_head *bh, item_head_action_t action,
+		    item_action_t *actions);
+int key_format(const struct reiserfs_key *key);
+unsigned long long get_offset(const struct reiserfs_key *key);
+int uniqueness2type(__u32 uniqueness);
+__u32 type2uniqueness(int type);
+int get_type(const struct reiserfs_key *key);
+char *key_of_what(const struct reiserfs_key *key);
+int type_unknown(struct reiserfs_key *key);
+void set_type(int format, struct reiserfs_key *key, int type);
+void set_offset(int format, struct reiserfs_key *key, loff_t offset);
+void set_type_and_offset(int format, struct reiserfs_key *key, loff_t offset,
+			 int type);
 
 typedef int (*check_unfm_func_t) (reiserfs_filsys_t *, __u32);
-int is_it_bad_item (reiserfs_filsys_t *, struct item_head *, char *,
-		    check_unfm_func_t, int bad_dir);
+int is_it_bad_item(reiserfs_filsys_t *, struct item_head *, char *,
+		   check_unfm_func_t, int bad_dir);
 
 #define hash_func_is_unknown(fs) ((fs)->fs_hash_function == 0)
 #define reiserfs_hash(fs) ((fs)->fs_hash_function)
 
-int known_hashes (void);
-char *code2name (unsigned int code);
-int func2code (hashf_t func);
-hashf_t code2func (unsigned int code);
-hashf_t name2func (char * hash);
-int find_hash_in_use (char * name, int namelen, __u32 deh_offset, unsigned int code_to_try_first);
-
-int entry_length (struct item_head * ih, struct reiserfs_de_head * deh,
-		  int pos_in_item);
-char * name_in_entry (struct reiserfs_de_head * deh, int pos_in_item);
-int name_in_entry_length (struct item_head * ih,
-		 struct reiserfs_de_head * deh, int pos_in_item);
-int name_length (char * name, int key_format);
+int known_hashes(void);
+char *code2name(unsigned int code);
+int func2code(hashf_t func);
+hashf_t code2func(unsigned int code);
+hashf_t name2func(char *hash);
+int find_hash_in_use(char *name, int namelen, __u32 deh_offset,
+		     unsigned int code_to_try_first);
+
+int entry_length(struct item_head *ih, struct reiserfs_de_head *deh,
+		 int pos_in_item);
+char *name_in_entry(struct reiserfs_de_head *deh, int pos_in_item);
+int name_in_entry_length(struct item_head *ih,
+			 struct reiserfs_de_head *deh, int pos_in_item);
+int name_length(char *name, int key_format);
 
 /*  access to stat data fields */
-void get_set_sd_field (int field, struct item_head * ih, void * sd,
-		       void * value, int set);
+void get_set_sd_field(int field, struct item_head *ih, void *sd,
+		      void *value, int set);
 #define GET_SD_MODE 0
 #define GET_SD_SIZE 1
 #define GET_SD_NLINK 2
@@ -325,61 +329,58 @@ void get_set_sd_field (int field, struct item_head * ih, void * sd,
 #define get_sd_first_direct_byte(ih,sd,pfdb) get_set_sd_field (GET_SD_FIRST_DIRECT_BYTE, ih, sd, pfdb, 0/*get*/)
 #define set_sd_first_direct_byte(ih,sd,pfdb) get_set_sd_field (GET_SD_FIRST_DIRECT_BYTE, ih, sd, pfdb, 1/*set*/)
 
-int is_objectid_used (reiserfs_filsys_t * fs, __u32 objectid);
-void mark_objectid_used (reiserfs_filsys_t * fs, __u32 objectid);
-
-
+int is_objectid_used(reiserfs_filsys_t *fs, __u32 objectid);
+void mark_objectid_used(reiserfs_filsys_t *fs, __u32 objectid);
 
 /* journal.c */
-int get_boundary_transactions (reiserfs_filsys_t *, reiserfs_trans_t *,
-			       reiserfs_trans_t *);
-int next_transaction (reiserfs_filsys_t *, reiserfs_trans_t *, reiserfs_trans_t);
+int get_boundary_transactions(reiserfs_filsys_t *, reiserfs_trans_t *,
+			      reiserfs_trans_t *);
+int next_transaction(reiserfs_filsys_t *, reiserfs_trans_t *, reiserfs_trans_t);
 
-int replay_one_transaction (reiserfs_filsys_t *, reiserfs_trans_t *);
+int replay_one_transaction(reiserfs_filsys_t *, reiserfs_trans_t *);
 
 typedef void (*action_on_trans_t) (reiserfs_filsys_t *, reiserfs_trans_t *);
-void for_each_transaction (reiserfs_filsys_t *, action_on_trans_t);
+void for_each_transaction(reiserfs_filsys_t *, action_on_trans_t);
 
 typedef void (*action_on_block_t) (reiserfs_filsys_t *, reiserfs_trans_t *,
 				   unsigned int index,
 				   unsigned long in_journal,
 				   unsigned long in_place);
-void for_each_block (reiserfs_filsys_t * fs, reiserfs_trans_t * trans,
-		     action_on_block_t action);
+void for_each_block(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
+		    action_on_block_t action);
 
-int reiserfs_open_journal (reiserfs_filsys_t *, char *, int flags);
+int reiserfs_open_journal(reiserfs_filsys_t *, char *, int flags);
 int reiserfs_journal_params_check(reiserfs_filsys_t *fs);
-int reiserfs_create_journal (reiserfs_filsys_t * fs, char * j_filename,
-			     unsigned long offset, unsigned long len, 
-			     int transaction_max_size, int force);
-int reiserfs_journal_opened (reiserfs_filsys_t *);
-void reiserfs_flush_journal (reiserfs_filsys_t * fs);
-void reiserfs_free_journal (reiserfs_filsys_t * fs);
-void reiserfs_close_journal (reiserfs_filsys_t *);
-void reiserfs_reopen_journal (reiserfs_filsys_t * fs, int flag);
-__u32 advise_journal_max_trans_age (void);
-__u32 advise_journal_max_commit_age (void);
-__u32 advise_journal_max_batch (unsigned long journal_trans_max);
-__u32 advise_journal_max_trans_len (__u32 desired, __u32 journal_size, int blocksize, int verbose);
-
-
+int reiserfs_create_journal(reiserfs_filsys_t *fs, char *j_filename,
+			    unsigned long offset, unsigned long len,
+			    int transaction_max_size, int force);
+int reiserfs_journal_opened(reiserfs_filsys_t *);
+void reiserfs_flush_journal(reiserfs_filsys_t *fs);
+void reiserfs_free_journal(reiserfs_filsys_t *fs);
+void reiserfs_close_journal(reiserfs_filsys_t *);
+void reiserfs_reopen_journal(reiserfs_filsys_t *fs, int flag);
+__u32 advise_journal_max_trans_age(void);
+__u32 advise_journal_max_commit_age(void);
+__u32 advise_journal_max_batch(unsigned long journal_trans_max);
+__u32 advise_journal_max_trans_len(__u32 desired, __u32 journal_size,
+				   int blocksize, int verbose);
 
 /* prints.c */
-void print_indirect_item (FILE * fp, struct buffer_head * bh, int item_num);
-void print_block (FILE * fp, reiserfs_filsys_t *, struct buffer_head * bh, ...);//int print_mode, int first, int last);
-int print_super_block (FILE * fp, reiserfs_filsys_t *, char * file_name, struct buffer_head * bh, int short_print);
-void print_journal (reiserfs_filsys_t *);
-void print_journal_header (reiserfs_filsys_t * fs);
-void reiserfs_warning (FILE * fp, const char * fmt, ...);
-char ftypelet (mode_t mode);
-void reiserfs_print_item (FILE * fp, struct buffer_head * bh,
-			  struct item_head * ih);
-void print_filesystem_state (FILE * fp, reiserfs_filsys_t * fs);
-void print_one_transaction (reiserfs_filsys_t * fs, reiserfs_trans_t * trans);
-void print_journal_params (FILE * fp, struct journal_params * jp);
-char * get_reiserfs_version (__u16 version);
-int can_we_format_it (char * device_name, int force);
-
+void print_indirect_item(FILE * fp, struct buffer_head *bh, int item_num);
+void print_block(FILE * fp, reiserfs_filsys_t *, struct buffer_head *bh, ...);	//int print_mode, int first, int last);
+int print_super_block(FILE * fp, reiserfs_filsys_t *, char *file_name,
+		      struct buffer_head *bh, int short_print);
+void print_journal(reiserfs_filsys_t *);
+void print_journal_header(reiserfs_filsys_t *fs);
+void reiserfs_warning(FILE * fp, const char *fmt, ...);
+char ftypelet(mode_t mode);
+void reiserfs_print_item(FILE * fp, struct buffer_head *bh,
+			 struct item_head *ih);
+void print_filesystem_state(FILE * fp, reiserfs_filsys_t *fs);
+void print_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans);
+void print_journal_params(FILE * fp, struct journal_params *jp);
+char *get_reiserfs_version(__u16 version);
+int can_we_format_it(char *device_name, int force);
 
 #define reiserfs_panic(fmt, list...) \
 {\
diff --git a/include/swab.h b/include/swab.h
index 06ebceb..cf738b4 100644
--- a/include/swab.h
+++ b/include/swab.h
@@ -41,7 +41,6 @@
                 (__u64)(((__u64)(__x) & (__u64)0xff00000000000000ULL) >> 56) )); \
 })
 
-
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 
 # define cpu_to_le16(val)                 (val)
diff --git a/lib/io.c b/lib/io.c
index 62aec45..f047d47 100644
--- a/lib/io.c
+++ b/lib/io.c
@@ -9,58 +9,56 @@
 #include <errno.h>
 #include <asm/types.h>
 
-void check_memory_msg (void) {
-    fprintf(stderr, 
-	"\nThe problem has occurred looks like a hardware problem (perhaps\n"
-        "memory). Send us the bug report only if the second run dies at\n"
-	"the same place with the same block number.\n");
-}
-
-void check_hd_msg (void) {
-    fprintf(stderr, 
-	"\nThe problem has occurred looks like a hardware problem. If you have\n"
-	"bad blocks, we advise you to get a new hard drive, because once you\n"
-	"get one bad block  that the disk  drive internals  cannot hide from\n"
-        "your sight,the chances of getting more are generally said to become\n"
-        "much higher  (precise statistics are unknown to us), and  this disk\n"
-        "drive is probably not expensive enough  for you to you to risk your\n"
-        "time and  data on it.  If you don't want to follow that follow that\n"
-        "advice then  if you have just a few bad blocks,  try writing to the\n"
-	"bad blocks  and see if the drive remaps  the bad blocks (that means\n"
-	"it takes a block  it has  in reserve  and allocates  it for use for\n"
-	"of that block number).  If it cannot remap the block,  use badblock\n"
-	"option (-B) with  reiserfs utils to handle this block correctly.\n");
-}
-
-static int is_bad_block (unsigned long block)
+void check_memory_msg(void)
+{
+	fprintf(stderr,
+		"\nThe problem has occurred looks like a hardware problem (perhaps\n"
+		"memory). Send us the bug report only if the second run dies at\n"
+		"the same place with the same block number.\n");
+}
+
+void check_hd_msg(void)
+{
+	fprintf(stderr,
+		"\nThe problem has occurred looks like a hardware problem. If you have\n"
+		"bad blocks, we advise you to get a new hard drive, because once you\n"
+		"get one bad block  that the disk  drive internals  cannot hide from\n"
+		"your sight,the chances of getting more are generally said to become\n"
+		"much higher  (precise statistics are unknown to us), and  this disk\n"
+		"drive is probably not expensive enough  for you to you to risk your\n"
+		"time and  data on it.  If you don't want to follow that follow that\n"
+		"advice then  if you have just a few bad blocks,  try writing to the\n"
+		"bad blocks  and see if the drive remaps  the bad blocks (that means\n"
+		"it takes a block  it has  in reserve  and allocates  it for use for\n"
+		"of that block number).  If it cannot remap the block,  use badblock\n"
+		"option (-B) with  reiserfs utils to handle this block correctly.\n");
+}
+
+static int is_bad_block(unsigned long block)
 {
 #ifdef IO_FAILURE_EMULATION
-    
-    /* this array similates bad blocks on the device */
-    unsigned long bad_blocks [] =
-	{
-	    8208, 8209, 8210
+
+	/* this array similates bad blocks on the device */
+	unsigned long bad_blocks[] = {
+		8208, 8209, 8210
 /*, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17, 18, 19*/
 	};
-    int i;
-    
-    for (i = 0; i < sizeof (bad_blocks) / sizeof (bad_blocks[0]); i ++)
-	if (bad_blocks [i] == block)
-	    return 1;
+	int i;
+
+	for (i = 0; i < sizeof(bad_blocks) / sizeof(bad_blocks[0]); i++)
+		if (bad_blocks[i] == block)
+			return 1;
 
 #endif
 
-    return 0;
+	return 0;
 }
 
-
-
 /* All buffers are in double linked cycled list.  If getblk found buffer with
    wanted block number in hash queue it moves buffer to the end of list. */
 
 static int g_nr_buffers;
 
-
 static unsigned long buffers_memory;
 
 /* create buffers until we spend this fraction of system memory, this
@@ -77,140 +75,136 @@ static unsigned long buffers_memory;
 #define BUFFER_SOFT_LIMIT (500 * 1024)
 static unsigned long buffer_soft_limit = BUFFER_SOFT_LIMIT;
 
-
 #define NR_HASH_QUEUES 4096
-static struct buffer_head * g_a_hash_queues [NR_HASH_QUEUES];
-static struct buffer_head * Buffer_list_head;
-static struct buffer_head * g_free_buffers = NULL ;
-static struct buffer_head * g_buffer_heads;
-static int buffer_hits = 0 ;
-static int buffer_misses = 0 ;
-static int buffer_reads = 0 ;
-static int buffer_writes = 0 ;
-
-
-
-static void _show_buffers(struct buffer_head **list, int dev, unsigned long size) {
-    int all = 0;
-    int dirty = 0;
-    int in_use = 0; /* count != 0 */
-    int free = 0;
-    struct buffer_head * next;
-
-    next = *list;
-    if (!next)
-        return ;
-
-    for (;;) {
-	if (next->b_dev == dev && next->b_size == size) {
-	    all ++;
-	    if (next->b_count != 0) {
-		in_use ++;
-	    }
-	    if (buffer_dirty (next)) {
-		dirty ++;
-	    }
-	    if (buffer_clean (next) && next->b_count == 0) {
-		free ++;
-	    }
-	}
-	next = next->b_next;
-	if (next == *list)
-	    break;
-    }
+static struct buffer_head *g_a_hash_queues[NR_HASH_QUEUES];
+static struct buffer_head *Buffer_list_head;
+static struct buffer_head *g_free_buffers = NULL;
+static struct buffer_head *g_buffer_heads;
+static int buffer_hits = 0;
+static int buffer_misses = 0;
+static int buffer_reads = 0;
+static int buffer_writes = 0;
+
+static void _show_buffers(struct buffer_head **list, int dev,
+			  unsigned long size)
+{
+	int all = 0;
+	int dirty = 0;
+	int in_use = 0;		/* count != 0 */
+	int free = 0;
+	struct buffer_head *next;
 
-    printf("show_buffers (dev %d, size %lu): free %d, count != 0 %d, dirty %d, "
-	"all %d\n", dev, size, free, in_use, dirty, all);
-}
+	next = *list;
+	if (!next)
+		return;
+
+	for (;;) {
+		if (next->b_dev == dev && next->b_size == size) {
+			all++;
+			if (next->b_count != 0) {
+				in_use++;
+			}
+			if (buffer_dirty(next)) {
+				dirty++;
+			}
+			if (buffer_clean(next) && next->b_count == 0) {
+				free++;
+			}
+		}
+		next = next->b_next;
+		if (next == *list)
+			break;
+	}
 
+	printf
+	    ("show_buffers (dev %d, size %lu): free %d, count != 0 %d, dirty %d, "
+	     "all %d\n", dev, size, free, in_use, dirty, all);
+}
 
-static void show_buffers (int dev, int size)
+static void show_buffers(int dev, int size)
 {
-    _show_buffers(&Buffer_list_head, dev, size) ;
-    _show_buffers(&g_free_buffers, dev, size) ;
+	_show_buffers(&Buffer_list_head, dev, size);
+	_show_buffers(&g_free_buffers, dev, size);
 }
 
-
-static void insert_into_hash_queue (struct buffer_head * bh)
+static void insert_into_hash_queue(struct buffer_head *bh)
 {
-    int index = bh->b_blocknr % NR_HASH_QUEUES;
+	int index = bh->b_blocknr % NR_HASH_QUEUES;
 
-    if (bh->b_hash_prev || bh->b_hash_next)
-	die ("insert_into_hash_queue: hash queue corrupted");
+	if (bh->b_hash_prev || bh->b_hash_next)
+		die("insert_into_hash_queue: hash queue corrupted");
 
-    if (g_a_hash_queues[index]) {
-	g_a_hash_queues[index]->b_hash_prev = bh;
-	bh->b_hash_next = g_a_hash_queues[index];
-    }
-    g_a_hash_queues[index] = bh;
+	if (g_a_hash_queues[index]) {
+		g_a_hash_queues[index]->b_hash_prev = bh;
+		bh->b_hash_next = g_a_hash_queues[index];
+	}
+	g_a_hash_queues[index] = bh;
 }
 
-
-static void remove_from_hash_queue (struct buffer_head * bh)
+static void remove_from_hash_queue(struct buffer_head *bh)
 {
-    if (bh->b_hash_next == 0 && bh->b_hash_prev == 0 && bh != g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES])
-	/* (b_dev == -1) ? */
-	return;
-
-    if (bh == g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES]) {
-	if (bh->b_hash_prev != 0)
-	    die ("remove_from_hash_queue: hash queue corrupted");
-	g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES] = bh->b_hash_next;
-    }
-    if (bh->b_hash_next)
-	bh->b_hash_next->b_hash_prev = bh->b_hash_prev;
+	if (bh->b_hash_next == 0 && bh->b_hash_prev == 0
+	    && bh != g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES])
+		/* (b_dev == -1) ? */
+		return;
+
+	if (bh == g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES]) {
+		if (bh->b_hash_prev != 0)
+			die("remove_from_hash_queue: hash queue corrupted");
+		g_a_hash_queues[bh->b_blocknr % NR_HASH_QUEUES] =
+		    bh->b_hash_next;
+	}
+	if (bh->b_hash_next)
+		bh->b_hash_next->b_hash_prev = bh->b_hash_prev;
 
-    if (bh->b_hash_prev)
-	bh->b_hash_prev->b_hash_next = bh->b_hash_next;
+	if (bh->b_hash_prev)
+		bh->b_hash_prev->b_hash_next = bh->b_hash_next;
 
-    bh->b_hash_prev = bh->b_hash_next = 0;
+	bh->b_hash_prev = bh->b_hash_next = 0;
 }
 
-
-static void put_buffer_list_end (struct buffer_head **list,
-                                 struct buffer_head * bh)
+static void put_buffer_list_end(struct buffer_head **list,
+				struct buffer_head *bh)
 {
-    struct buffer_head * last = 0;
+	struct buffer_head *last = 0;
 
-    if (bh->b_prev || bh->b_next)
-	die ("put_buffer_list_end: buffer list corrupted");
+	if (bh->b_prev || bh->b_next)
+		die("put_buffer_list_end: buffer list corrupted");
 
-    if (*list == 0) {
-	bh->b_next = bh;
-	bh->b_prev = bh;
-	*list = bh;
-    } else {
-	last = (*list)->b_prev;
+	if (*list == 0) {
+		bh->b_next = bh;
+		bh->b_prev = bh;
+		*list = bh;
+	} else {
+		last = (*list)->b_prev;
 
-	bh->b_next = last->b_next;
-	bh->b_prev = last;
-	last->b_next->b_prev = bh;
-	last->b_next = bh;
-    }
+		bh->b_next = last->b_next;
+		bh->b_prev = last;
+		last->b_next->b_prev = bh;
+		last->b_next = bh;
+	}
 }
 
-
-static void remove_from_buffer_list (struct buffer_head **list,
-                                     struct buffer_head * bh)
+static void remove_from_buffer_list(struct buffer_head **list,
+				    struct buffer_head *bh)
 {
-    if (bh == bh->b_next) {
-	*list = 0;
-    } else {
-	bh->b_prev->b_next = bh->b_next;
-	bh->b_next->b_prev = bh->b_prev;
-	if (bh == *list)
-	    *list = bh->b_next;
-    }
+	if (bh == bh->b_next) {
+		*list = 0;
+	} else {
+		bh->b_prev->b_next = bh->b_next;
+		bh->b_next->b_prev = bh->b_prev;
+		if (bh == *list)
+			*list = bh->b_next;
+	}
 
-    bh->b_next = bh->b_prev = 0;
+	bh->b_next = bh->b_prev = 0;
 }
 
-
-static void put_buffer_list_head (struct buffer_head **list,
-                                  struct buffer_head * bh)
+static void put_buffer_list_head(struct buffer_head **list,
+				 struct buffer_head *bh)
 {
-    put_buffer_list_end (list, bh);
-    *list = bh;
+	put_buffer_list_end(list, bh);
+	*list = bh;
 }
 
 /*
@@ -252,394 +246,413 @@ static size_t estimate_memory_amount (void)
 #define GROW_BUFFERS__NEW_BUFERS_PER_CALL 10
 
 /* creates number of new buffers and insert them into head of buffer list */
-static int grow_buffers (int size)
-{
-    int i;
-    struct buffer_head * bh, * tmp;
-
-
-    /* get memory for array of buffer heads */
-    bh = (struct buffer_head *)getmem (GROW_BUFFERS__NEW_BUFERS_PER_CALL * 
-				       sizeof (struct buffer_head) + sizeof (struct buffer_head *));
-    if (g_buffer_heads == 0)
-	g_buffer_heads = bh;
-    else {
-	/* link new array to the end of array list */
-	tmp = g_buffer_heads;
-	while (*(struct buffer_head **)(tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL) != 0)
-	    tmp = *(struct buffer_head **)(tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
-	*(struct buffer_head **)(tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL) = bh;
-    }
+static int grow_buffers(int size)
+{
+	int i;
+	struct buffer_head *bh, *tmp;
+
+	/* get memory for array of buffer heads */
+	bh = (struct buffer_head *)getmem(GROW_BUFFERS__NEW_BUFERS_PER_CALL *
+					  sizeof(struct buffer_head) +
+					  sizeof(struct buffer_head *));
+	if (g_buffer_heads == 0)
+		g_buffer_heads = bh;
+	else {
+		/* link new array to the end of array list */
+		tmp = g_buffer_heads;
+		while (*(struct buffer_head **)
+		       (tmp + GROW_BUFFERS__NEW_BUFERS_PER_CALL) != 0)
+			tmp =
+			    *(struct buffer_head **)(tmp +
+						     GROW_BUFFERS__NEW_BUFERS_PER_CALL);
+		*(struct buffer_head **)(tmp +
+					 GROW_BUFFERS__NEW_BUFERS_PER_CALL) =
+		    bh;
+	}
 
-    for (i = 0; i < GROW_BUFFERS__NEW_BUFERS_PER_CALL; i ++) {
+	for (i = 0; i < GROW_BUFFERS__NEW_BUFERS_PER_CALL; i++) {
 
-	tmp = bh + i;
-	memset (tmp, 0, sizeof (struct buffer_head));
-	tmp->b_data = getmem (size);
-	if (tmp->b_data == 0)
-	    die ("grow_buffers: no memory for new buffer data");
-	tmp->b_dev = -1;
-	tmp->b_size = size;
-	put_buffer_list_head (&g_free_buffers, tmp);
-    }
-    buffers_memory += GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
-    g_nr_buffers += GROW_BUFFERS__NEW_BUFERS_PER_CALL;
-    return GROW_BUFFERS__NEW_BUFERS_PER_CALL;
+		tmp = bh + i;
+		memset(tmp, 0, sizeof(struct buffer_head));
+		tmp->b_data = getmem(size);
+		if (tmp->b_data == 0)
+			die("grow_buffers: no memory for new buffer data");
+		tmp->b_dev = -1;
+		tmp->b_size = size;
+		put_buffer_list_head(&g_free_buffers, tmp);
+	}
+	buffers_memory += GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
+	g_nr_buffers += GROW_BUFFERS__NEW_BUFERS_PER_CALL;
+	return GROW_BUFFERS__NEW_BUFERS_PER_CALL;
 }
 
-
-struct buffer_head *find_buffer(int dev, unsigned long block, unsigned long size)
-{		
-    struct buffer_head * next;
-
-    next = g_a_hash_queues[block % NR_HASH_QUEUES];
-    for (;;) {
-	struct buffer_head *tmp = next;
-	if (!next)
-	    break;
-	next = tmp->b_hash_next;
-	if (tmp->b_blocknr != block || tmp->b_size != size || tmp->b_dev != dev)
-	    continue;
-	next = tmp;
-	break;
-    }
-    return next;
+struct buffer_head *find_buffer(int dev, unsigned long block,
+				unsigned long size)
+{
+	struct buffer_head *next;
+
+	next = g_a_hash_queues[block % NR_HASH_QUEUES];
+	for (;;) {
+		struct buffer_head *tmp = next;
+		if (!next)
+			break;
+		next = tmp->b_hash_next;
+		if (tmp->b_blocknr != block || tmp->b_size != size
+		    || tmp->b_dev != dev)
+			continue;
+		next = tmp;
+		break;
+	}
+	return next;
 }
 
-
-static struct buffer_head * get_free_buffer (struct buffer_head **list,
-                                             unsigned long size)
+static struct buffer_head *get_free_buffer(struct buffer_head **list,
+					   unsigned long size)
 {
-    struct buffer_head * next;
+	struct buffer_head *next;
 
-    next = *list;
-    if (!next)
-	return 0;
-
-    for (;;) {
+	next = *list;
 	if (!next)
-	    die ("get_free_buffer: buffer list is corrupted");
-	if (next->b_count == 0 && buffer_clean (next) && next->b_size == size) {
-	    remove_from_hash_queue (next);
-	    remove_from_buffer_list (list, next);
-	    return next;
-	}
-	next = next->b_next;
-	if (next == *list)
-	    break;
-    }
-    return 0;
+		return 0;
+
+	for (;;) {
+		if (!next)
+			die("get_free_buffer: buffer list is corrupted");
+		if (next->b_count == 0 && buffer_clean(next)
+		    && next->b_size == size) {
+			remove_from_hash_queue(next);
+			remove_from_buffer_list(list, next);
+			return next;
+		}
+		next = next->b_next;
+		if (next == *list)
+			break;
+	}
+	return 0;
 }
 
-
 /* to_write == 0 when all blocks have to be flushed. Otherwise - write only
    buffers with b_count == 0 */
-static int sync_buffers (struct buffer_head **list, int dev, int to_write) {
-    struct buffer_head * next;
-    int written = 0;
-
+static int sync_buffers(struct buffer_head **list, int dev, int to_write)
+{
+	struct buffer_head *next;
+	int written = 0;
 
 restart:
-    next = *list;
-    if (!next)
-	return 0;
-    for (;;) {
+	next = *list;
 	if (!next)
-	    die ("sync_buffers: buffer list is corrupted");
- 
-	if (next->b_dev == dev && buffer_dirty (next) && buffer_uptodate (next)) {
-	    if ((to_write == 0 || next->b_count == 0) && !buffer_do_not_flush (next)) {
-		bwrite (next);
-	    }
+		return 0;
+	for (;;) {
+		if (!next)
+			die("sync_buffers: buffer list is corrupted");
+
+		if (next->b_dev == dev && buffer_dirty(next)
+		    && buffer_uptodate(next)) {
+			if ((to_write == 0 || next->b_count == 0)
+			    && !buffer_do_not_flush(next)) {
+				bwrite(next);
+			}
+		}
+
+		/* if this buffer is reusable, put it onto the end of the free list */
+		if (next->b_count == 0 && buffer_clean(next)) {
+			remove_from_hash_queue(next);
+			remove_from_buffer_list(list, next);
+			put_buffer_list_end(&g_free_buffers, next);
+			written++;
+			if (written == to_write)
+				return written;
+			goto restart;
+		}
+		if (to_write && written >= to_write)
+			return written;
+
+		next = next->b_next;
+		if (next == *list)
+			break;
 	}
-    
-	/* if this buffer is reusable, put it onto the end of the free list */
-	if (next->b_count == 0 && buffer_clean(next)) {
-	    remove_from_hash_queue (next);
-	    remove_from_buffer_list (list, next);
-	    put_buffer_list_end (&g_free_buffers, next);
-	    written++ ;
-	    if (written == to_write)
-		return written;
-	    goto restart;
-	}
-	if (to_write && written >= to_write)
-	    return written;
-
-	next = next->b_next;
-	if (next == *list)
-	    break;
-    }
 
-    return written;
+	return written;
 }
 
-
-void flush_buffers (int dev)
+void flush_buffers(int dev)
 {
-    if (dev == -1)
-	die ("flush_buffers: device is not specified");
+	if (dev == -1)
+		die("flush_buffers: device is not specified");
 
-    sync_buffers (&Buffer_list_head, dev, 0/*all*/);
-    buffer_soft_limit = BUFFER_SOFT_LIMIT;
+	sync_buffers(&Buffer_list_head, dev, 0 /*all */ );
+	buffer_soft_limit = BUFFER_SOFT_LIMIT;
 }
 
-
-struct buffer_head * getblk (int dev, unsigned long block, int size)
+struct buffer_head *getblk(int dev, unsigned long block, int size)
 {
-    struct buffer_head * bh;
+	struct buffer_head *bh;
 
-    bh = find_buffer (dev, block, size);
-    if (bh) {
-	/* move the buffer to the end of list */
+	bh = find_buffer(dev, block, size);
+	if (bh) {
+		/* move the buffer to the end of list */
 
-	/*checkmem (bh->b_data, bh->b_size);*/
+		/*checkmem (bh->b_data, bh->b_size); */
 
-	remove_from_buffer_list (&Buffer_list_head, bh);
-	put_buffer_list_end (&Buffer_list_head, bh);
-	bh->b_count ++;
-	buffer_hits++ ;
-	return bh;
-    }
-    buffer_misses++ ;
-
-    bh = get_free_buffer (&g_free_buffers, size);
-    if (bh == NULL) {
-	if (buffers_memory >= buffer_soft_limit) {
-	    if (sync_buffers (&Buffer_list_head, dev, 32) == 0) {
-		grow_buffers(size);
-		buffer_soft_limit = buffers_memory + 
-			GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
-	    }
-	} else {
-	    if (grow_buffers(size) == 0)
-		sync_buffers (&Buffer_list_head, dev, 32);
+		remove_from_buffer_list(&Buffer_list_head, bh);
+		put_buffer_list_end(&Buffer_list_head, bh);
+		bh->b_count++;
+		buffer_hits++;
+		return bh;
 	}
+	buffer_misses++;
 
-	bh = get_free_buffer (&g_free_buffers, size);
+	bh = get_free_buffer(&g_free_buffers, size);
 	if (bh == NULL) {
-	    show_buffers (dev, size);
-	    die ("getblk: no free buffers after grow_buffers "
-		 "and refill (%d)", g_nr_buffers);
+		if (buffers_memory >= buffer_soft_limit) {
+			if (sync_buffers(&Buffer_list_head, dev, 32) == 0) {
+				grow_buffers(size);
+				buffer_soft_limit = buffers_memory +
+				    GROW_BUFFERS__NEW_BUFERS_PER_CALL * size;
+			}
+		} else {
+			if (grow_buffers(size) == 0)
+				sync_buffers(&Buffer_list_head, dev, 32);
+		}
+
+		bh = get_free_buffer(&g_free_buffers, size);
+		if (bh == NULL) {
+			show_buffers(dev, size);
+			die("getblk: no free buffers after grow_buffers "
+			    "and refill (%d)", g_nr_buffers);
+		}
 	}
-    }
 
-    bh->b_count = 1;
-    bh->b_dev = dev;
-    bh->b_size = size;
-    bh->b_blocknr = block;
-    bh->b_end_io = NULL ;
-    memset (bh->b_data, 0, size);
-    misc_clear_bit(BH_Dirty, &bh->b_state);
-    misc_clear_bit(BH_Uptodate, &bh->b_state);
+	bh->b_count = 1;
+	bh->b_dev = dev;
+	bh->b_size = size;
+	bh->b_blocknr = block;
+	bh->b_end_io = NULL;
+	memset(bh->b_data, 0, size);
+	misc_clear_bit(BH_Dirty, &bh->b_state);
+	misc_clear_bit(BH_Uptodate, &bh->b_state);
 
-    put_buffer_list_end (&Buffer_list_head, bh);
-    insert_into_hash_queue (bh);
-    /*checkmem (bh->b_data, bh->b_size);*/
+	put_buffer_list_end(&Buffer_list_head, bh);
+	insert_into_hash_queue(bh);
+	/*checkmem (bh->b_data, bh->b_size); */
 
-    return bh;
+	return bh;
 }
 
-
-void brelse (struct buffer_head * bh)
+void brelse(struct buffer_head *bh)
 {
-    if (bh == 0)
-	return;
-    
-    if (bh->b_count == 0)
-	die ("brelse: can not free a free buffer %lu", bh->b_blocknr);
-    
-    /*checkmem (bh->b_data, get_mem_size (bh->b_data));*/
-    
-    bh->b_count --;
-}
+	if (bh == 0)
+		return;
+
+	if (bh->b_count == 0)
+		die("brelse: can not free a free buffer %lu", bh->b_blocknr);
 
+	/*checkmem (bh->b_data, get_mem_size (bh->b_data)); */
 
-void bforget (struct buffer_head * bh)
+	bh->b_count--;
+}
+
+void bforget(struct buffer_head *bh)
 {
-    if (bh) {
-	bh->b_state = 0;
-	brelse (bh);
-	remove_from_hash_queue (bh);
-	remove_from_buffer_list(&Buffer_list_head, bh);
-	put_buffer_list_head(&Buffer_list_head, bh);
-    }
+	if (bh) {
+		bh->b_state = 0;
+		brelse(bh);
+		remove_from_hash_queue(bh);
+		remove_from_buffer_list(&Buffer_list_head, bh);
+		put_buffer_list_head(&Buffer_list_head, bh);
+	}
 }
 
 /* Returns 0 on success; 1 - end of file; 0 - OK. */
-static int f_read(struct buffer_head * bh)
+static int f_read(struct buffer_head *bh)
 {
-    unsigned long long offset;
-    ssize_t bytes;
+	unsigned long long offset;
+	ssize_t bytes;
 
-    buffer_reads++ ;
+	buffer_reads++;
 
-    offset = (unsigned long long)bh->b_size * bh->b_blocknr;
-    if (lseek (bh->b_dev, offset, SEEK_SET) < 0)
-	return -1;
+	offset = (unsigned long long)bh->b_size * bh->b_blocknr;
+	if (lseek(bh->b_dev, offset, SEEK_SET) < 0)
+		return -1;
 
-    bytes = read (bh->b_dev, bh->b_data, bh->b_size);
-    
-    return bytes < 0 ? -1 : (bytes != (ssize_t)bh->b_size ? 1 : 0);
-}
+	bytes = read(bh->b_dev, bh->b_data, bh->b_size);
 
+	return bytes < 0 ? -1 : (bytes != (ssize_t) bh->b_size ? 1 : 0);
+}
 
-struct buffer_head * bread (int dev, unsigned long block, size_t size)
+struct buffer_head *bread(int dev, unsigned long block, size_t size)
 {
-    struct buffer_head * bh;
-    int ret;
-
-    if (is_bad_block (block))
-	return 0;
+	struct buffer_head *bh;
+	int ret;
+
+	if (is_bad_block(block))
+		return 0;
+
+	bh = getblk(dev, block, size);
+
+	/*checkmem (bh->b_data, get_mem_size(bh->b_data)); */
+
+	if (buffer_uptodate(bh))
+		return bh;
+
+	ret = f_read(bh);
+
+	if (ret > 0) {
+		die("%s: End of file, cannot read the block (%lu).\n",
+		    __FUNCTION__, block);
+	} else if (ret < 0) {
+		/* BAD BLOCK LIST SUPPORT
+		 * die ("%s: Cannot read a block # %lu. Specify list of badblocks\n",*/
+
+		if (errno == EIO) {
+			check_hd_msg();
+			die("%s: Cannot read the block (%lu): (%s).\n",
+			    __FUNCTION__, block, strerror(errno));
+		} else {
+			fprintf(stderr,
+				"%s: Cannot read the block (%lu): (%s).\n",
+				__FUNCTION__, block, strerror(errno));
+			return NULL;
+		}
+	}
 
-    bh = getblk (dev, block, size);
-    
-    /*checkmem (bh->b_data, get_mem_size(bh->b_data));*/
-    
-    if (buffer_uptodate (bh))
+	mark_buffer_uptodate(bh, 0);
 	return bh;
-
-    ret = f_read(bh);
-    
-    if (ret > 0) {
-	die ("%s: End of file, cannot read the block (%lu).\n", 
-	     __FUNCTION__, block);
-    } else if (ret < 0) {
-	/* BAD BLOCK LIST SUPPORT
-	 * die ("%s: Cannot read a block # %lu. Specify list of badblocks\n",*/
-
-	if (errno == EIO) {
-	    check_hd_msg();
-	    die ("%s: Cannot read the block (%lu): (%s).\n", 
-		 __FUNCTION__, block, strerror(errno));
-	} else	{
-	    fprintf (stderr, "%s: Cannot read the block (%lu): (%s).\n", 
-		     __FUNCTION__, block, strerror(errno));
-	    return NULL;
-	}
-    }
-       
-    mark_buffer_uptodate (bh, 0);
-    return bh;
 }
 
 #define ROLLBACK_FILE_START_MAGIC       "_RollBackFileForReiserfsFSCK"
 
-static struct block_handler * rollback_blocks_array;
+static struct block_handler *rollback_blocks_array;
 static __u32 rollback_blocks_number = 0;
-static FILE * s_rollback_file = 0;
-static FILE * log_file;
+static FILE *s_rollback_file = 0;
+static FILE *log_file;
 static int do_rollback = 0;
 
-static char * rollback_data;
+static char *rollback_data;
 static int rollback_blocksize;
 
-void init_rollback_file (char * rollback_file, unsigned int *blocksize,
-			 FILE * log)
+void init_rollback_file(char *rollback_file, unsigned int *blocksize,
+			FILE * log)
 {
-    char * string;
-    struct stat buf;
-    
-    if (rollback_file == NULL)
-        return;
-        
-    stat(rollback_file, &buf);
-    
-    s_rollback_file = fopen (rollback_file, "w+");    
-    if (s_rollback_file == NULL) {
-	fprintf (stderr, "Cannot create file %s, work without a rollback file\n", rollback_file);
-        return;
-    }
+	char *string;
+	struct stat buf;
 
-    rollback_blocksize = *blocksize;
+	if (rollback_file == NULL)
+		return;
+
+	stat(rollback_file, &buf);
+
+	s_rollback_file = fopen(rollback_file, "w+");
+	if (s_rollback_file == NULL) {
+		fprintf(stderr,
+			"Cannot create file %s, work without a rollback file\n",
+			rollback_file);
+		return;
+	}
+
+	rollback_blocksize = *blocksize;
+
+	string = ROLLBACK_FILE_START_MAGIC;
+	fwrite(string, 28, 1, s_rollback_file);
+	fwrite(&rollback_blocksize, sizeof(rollback_blocksize), 1,
+	       s_rollback_file);
+	fwrite(&rollback_blocks_number, sizeof(rollback_blocks_number), 1,
+	       s_rollback_file);
+	fflush(s_rollback_file);
+
+	rollback_data = getmem(rollback_blocksize);
 
-    string = ROLLBACK_FILE_START_MAGIC;
-    fwrite (string, 28, 1, s_rollback_file);
-    fwrite (&rollback_blocksize, sizeof (rollback_blocksize), 1, s_rollback_file);
-    fwrite (&rollback_blocks_number, sizeof (rollback_blocks_number), 1, s_rollback_file);
-    fflush(s_rollback_file);
-        
-    rollback_data = getmem(rollback_blocksize);
-    
 //    printf("\ncheckmem1");
 //    fflush (stdout);
 //    checkmem (rollback_data, get_mem_size((char *)rollback_data));
 //    printf(" OK");
-    
-    log_file = log;
-    if (log_file)
-        fprintf (log_file, "rollback: file (%s) initialize\n", rollback_file);
 
-    do_rollback = 0;
+	log_file = log;
+	if (log_file)
+		fprintf(log_file, "rollback: file (%s) initialize\n",
+			rollback_file);
+
+	do_rollback = 0;
 }
 
 #if 0
-static void erase_rollback_file (char * rollback_file) {
-    close_rollback_file ();
-    unlink (rollback_file);    
+static void erase_rollback_file(char *rollback_file)
+{
+	close_rollback_file();
+	unlink(rollback_file);
 }
 #endif
 
-int open_rollback_file (char * rollback_file, FILE * log) {
-    char string [28];
-    struct stat buf;
-    
-    if (rollback_file == NULL)
-        return -1;
-    
-    if (stat(rollback_file, &buf)) {
-	fprintf (stderr, "Cannot stat rollback file (%s)\n", rollback_file);
-	return -1;
-    }
-        
-    s_rollback_file = fopen (rollback_file, "r+");
-    if (s_rollback_file == NULL) {
-	fprintf (stderr, "Cannot open file (%s)\n", rollback_file);
-	return -1;
-    }
-    
-    fread (string, 28, 1, s_rollback_file);
-    if (!strcmp (string, ROLLBACK_FILE_START_MAGIC)) {
-        fprintf (stderr, "Specified file (%s) does not look like a rollback file\n", rollback_file);
-        fclose (s_rollback_file);
-        s_rollback_file = 0;
-        return -1;
-    }
-    
-    fread (&rollback_blocksize, sizeof (rollback_blocksize), 1, s_rollback_file);
-    
-    if (rollback_blocksize <= 0) {
-        fprintf(stderr, "rollback: wrong rollback blocksize, exit\n");
-        return -1;
-    }
-    
-    log_file = log;
-    if (log_file)
-        fprintf (log_file, "rollback: file (%s) opened\n", rollback_file);
-    
-    do_rollback = 1;
-    return 0;
+int open_rollback_file(char *rollback_file, FILE * log)
+{
+	char string[28];
+	struct stat buf;
+
+	if (rollback_file == NULL)
+		return -1;
+
+	if (stat(rollback_file, &buf)) {
+		fprintf(stderr, "Cannot stat rollback file (%s)\n",
+			rollback_file);
+		return -1;
+	}
+
+	s_rollback_file = fopen(rollback_file, "r+");
+	if (s_rollback_file == NULL) {
+		fprintf(stderr, "Cannot open file (%s)\n", rollback_file);
+		return -1;
+	}
+
+	fread(string, 28, 1, s_rollback_file);
+	if (!strcmp(string, ROLLBACK_FILE_START_MAGIC)) {
+		fprintf(stderr,
+			"Specified file (%s) does not look like a rollback file\n",
+			rollback_file);
+		fclose(s_rollback_file);
+		s_rollback_file = 0;
+		return -1;
+	}
+
+	fread(&rollback_blocksize, sizeof(rollback_blocksize), 1,
+	      s_rollback_file);
+
+	if (rollback_blocksize <= 0) {
+		fprintf(stderr, "rollback: wrong rollback blocksize, exit\n");
+		return -1;
+	}
+
+	log_file = log;
+	if (log_file)
+		fprintf(log_file, "rollback: file (%s) opened\n",
+			rollback_file);
+
+	do_rollback = 1;
+	return 0;
 }
 
-void close_rollback_file () {
-    if (s_rollback_file == 0)
-        return;   
+void close_rollback_file()
+{
+	if (s_rollback_file == 0)
+		return;
+
+	if (!do_rollback) {
+		if (fseek(s_rollback_file, 28 + sizeof(int), SEEK_SET) ==
+		    (loff_t) - 1)
+			return;
+		fwrite(&rollback_blocks_number, sizeof(rollback_blocksize), 1,
+		       s_rollback_file);
+		if (log_file != 0)
+			fprintf(log_file, "rollback: %u blocks backed up\n",
+				rollback_blocks_number);
+	}
 
-    if (!do_rollback) {
-        if (fseek (s_rollback_file, 28 + sizeof(int), SEEK_SET) == (loff_t)-1)
-            return;
-        fwrite (&rollback_blocks_number, sizeof (rollback_blocksize), 1, s_rollback_file);
-        if (log_file != 0) 
-            fprintf (log_file, "rollback: %u blocks backed up\n", rollback_blocks_number);
-    }
-        
-    fclose (s_rollback_file);
+	fclose(s_rollback_file);
 
-    freemem (rollback_data);
-    freemem (rollback_blocks_array);
+	freemem(rollback_data);
+	freemem(rollback_blocks_array);
 
 //    fprintf (stdout, "rollback: (%u) blocks saved, \n", rollback_blocks_number);
-    
+
 /*    for (i = 0; i < rollback_blocks_number; i++) 
         fprintf(stdout, "device (%Lu), block number (%u)\n", 
                 rollback_blocks_array [i].device, 
@@ -648,105 +661,122 @@ void close_rollback_file () {
     */
 }
 
-void do_fsck_rollback (int fd_device, int fd_journal_device, FILE * progress) {
-    long long int offset;
-    
-    struct stat buf;
-    int descriptor;
-    ssize_t retval;
-    int count_failed = 0;
-    int count_rollbacked = 0;
-    
-    int b_dev;
-    int n_dev = 0;
-    int n_journal_dev = 0;
-    unsigned long done = 0;
-
-    if (fd_device == 0) {
-        fprintf(stderr, "rollback: unspecified device, exit\n");
-        return;
-    }
-        
-    if (fd_journal_device) {
-        if (!fstat (fd_journal_device, &buf)) {
-            n_journal_dev = buf.st_rdev;
-        } else {
-            fprintf(stderr, "rollback: specified journal device cannot be stated\n");
-        }
-    }
-    
-    if (!fstat (fd_device, &buf)) {
-        n_dev = buf.st_rdev;
-    } else {
-        fprintf(stderr, "rollback: specified device cannot be stated, exit\n");
-        return;
-    }
-    
-    rollback_data = getmem (rollback_blocksize);
+void do_fsck_rollback(int fd_device, int fd_journal_device, FILE * progress)
+{
+	long long int offset;
+
+	struct stat buf;
+	int descriptor;
+	ssize_t retval;
+	int count_failed = 0;
+	int count_rollbacked = 0;
+
+	int b_dev;
+	int n_dev = 0;
+	int n_journal_dev = 0;
+	unsigned long done = 0;
+
+	if (fd_device == 0) {
+		fprintf(stderr, "rollback: unspecified device, exit\n");
+		return;
+	}
+
+	if (fd_journal_device) {
+		if (!fstat(fd_journal_device, &buf)) {
+			n_journal_dev = buf.st_rdev;
+		} else {
+			fprintf(stderr,
+				"rollback: specified journal device cannot be stated\n");
+		}
+	}
+
+	if (!fstat(fd_device, &buf)) {
+		n_dev = buf.st_rdev;
+	} else {
+		fprintf(stderr,
+			"rollback: specified device cannot be stated, exit\n");
+		return;
+	}
+
+	rollback_data = getmem(rollback_blocksize);
 //    printf("\ncheckmem2");
 //    fflush (stdout);
 //    checkmem (rollback_data, get_mem_size((char *)rollback_data));
 //   printf(" OK");
-    
-    fread (&rollback_blocks_number, sizeof (rollback_blocks_number), 1, s_rollback_file);
-
-    while (1) {
-        print_how_far (progress, &done, rollback_blocks_number, 1, 0/*not quiet*/);
-	
-        descriptor = 0;
-        if ((retval = fread (&b_dev, sizeof (b_dev), 1, s_rollback_file)) <= 0) {
-            if (retval) 
-                fprintf (stderr, "rollback: fread: %s\n", strerror (errno));
-            break;            
-        }
-        if ((retval = fread (&offset, sizeof (offset), 1, s_rollback_file)) <= 0) {
-            if (retval) 
-                fprintf (stderr, "rollback: fread: %s\n", strerror (errno));
-            break;
-        }
-
-        if ((retval = fread (rollback_data, rollback_blocksize, 1, s_rollback_file)) <= 0) {
-            if (retval) 
-                fprintf (stderr, "rollback: fread: %s\n", strerror (errno));
-            break;
-        }
-                
-        if (n_dev == b_dev)
-            descriptor = fd_device;
-        if ((n_journal_dev) && (n_journal_dev == b_dev))
-            descriptor = fd_journal_device;
-        
-        if (descriptor == 0) {
-            fprintf(stderr, "rollback: block from unknown device, skip block\n");
-            count_failed ++;
-            continue;
-        }
-        
-        if (lseek (descriptor, offset, SEEK_SET) == (loff_t)-1) {
-            fprintf(stderr, "device cannot be lseeked, skip block\n");
-            count_failed ++;
-            continue;
-        }
-        
-        if (write (descriptor, rollback_data, rollback_blocksize) == -1) {
-            fprintf (stderr, "rollback: write %d bytes returned error "
-		"(block=%lld, dev=%d): %s\n", rollback_blocksize, 
-		offset/rollback_blocksize, b_dev, strerror (errno));
-            count_failed ++;
-        } else {
-            count_rollbacked ++;
-              /*if you want to know what gets rollbacked, uncomment it*/
+
+	fread(&rollback_blocks_number, sizeof(rollback_blocks_number), 1,
+	      s_rollback_file);
+
+	while (1) {
+		print_how_far(progress, &done, rollback_blocks_number, 1,
+			      0 /*not quiet */ );
+
+		descriptor = 0;
+		if ((retval =
+		     fread(&b_dev, sizeof(b_dev), 1, s_rollback_file)) <= 0) {
+			if (retval)
+				fprintf(stderr, "rollback: fread: %s\n",
+					strerror(errno));
+			break;
+		}
+		if ((retval =
+		     fread(&offset, sizeof(offset), 1, s_rollback_file)) <= 0) {
+			if (retval)
+				fprintf(stderr, "rollback: fread: %s\n",
+					strerror(errno));
+			break;
+		}
+
+		if ((retval =
+		     fread(rollback_data, rollback_blocksize, 1,
+			   s_rollback_file)) <= 0) {
+			if (retval)
+				fprintf(stderr, "rollback: fread: %s\n",
+					strerror(errno));
+			break;
+		}
+
+		if (n_dev == b_dev)
+			descriptor = fd_device;
+		if ((n_journal_dev) && (n_journal_dev == b_dev))
+			descriptor = fd_journal_device;
+
+		if (descriptor == 0) {
+			fprintf(stderr,
+				"rollback: block from unknown device, skip block\n");
+			count_failed++;
+			continue;
+		}
+
+		if (lseek(descriptor, offset, SEEK_SET) == (loff_t) - 1) {
+			fprintf(stderr,
+				"device cannot be lseeked, skip block\n");
+			count_failed++;
+			continue;
+		}
+
+		if (write(descriptor, rollback_data, rollback_blocksize) == -1) {
+			fprintf(stderr,
+				"rollback: write %d bytes returned error "
+				"(block=%lld, dev=%d): %s\n",
+				rollback_blocksize, offset / rollback_blocksize,
+				b_dev, strerror(errno));
+			count_failed++;
+		} else {
+			count_rollbacked++;
+			/*if you want to know what gets rollbacked, uncomment it */
 /*            if (log_file != 0 && log_file != stdout) 
                 fprintf (log_file, "rollback: block %Lu of device %Lu was restored\n", 
                         (loff_t)offset/rollback_blocksize, b_dev);
 */
 //            fprintf (stdout, "rollback: block (%Ld) written\n", (loff_t)offset/rollback_blocksize);
-        }
-    }
-    
-    printf ("\n");
-    if (log_file != 0) 
-        fprintf (log_file, "rollback: (%u) blocks restored\n", count_rollbacked);
+		}
+	}
+
+	printf("\n");
+	if (log_file != 0)
+		fprintf(log_file, "rollback: (%u) blocks restored\n",
+			count_rollbacked);
 }
 
 /*
@@ -771,190 +801,215 @@ static void rollback__mark_block_saved (struct block_handler * rb_e) {
 }
 */
 /* for now - just make sure that bad blocks did not get here */
-int bwrite (struct buffer_head * bh)
+int bwrite(struct buffer_head *bh)
 {
-    unsigned long long offset;
-    long long bytes, size;
-
-    if (is_bad_block (bh->b_blocknr)) {
-	fprintf (stderr, "bwrite: bad block is going to be written: %lu\n",
-		 bh->b_blocknr);
-	exit(8);
-    }
+	unsigned long long offset;
+	long long bytes, size;
+
+	if (is_bad_block(bh->b_blocknr)) {
+		fprintf(stderr,
+			"bwrite: bad block is going to be written: %lu\n",
+			bh->b_blocknr);
+		exit(8);
+	}
 
-    if (!buffer_dirty (bh) || !buffer_uptodate (bh))
-	return 0;
+	if (!buffer_dirty(bh) || !buffer_uptodate(bh))
+		return 0;
 
-    buffer_writes++ ;
-    if (bh->b_start_io)
-	/* this is used by undo feature of reiserfsck */
-	bh->b_start_io (bh->b_blocknr);
+	buffer_writes++;
+	if (bh->b_start_io)
+		/* this is used by undo feature of reiserfsck */
+		bh->b_start_io(bh->b_blocknr);
 
-    size = bh->b_size;
-    offset = (loff_t)size * (loff_t)bh->b_blocknr;
+	size = bh->b_size;
+	offset = (loff_t) size *(loff_t) bh->b_blocknr;
 
-    if (lseek (bh->b_dev, offset, SEEK_SET) == (loff_t)-1){
-	fprintf (stderr, "bwrite: lseek to position %llu (block=%lu, dev=%d): %s\n",
-	    offset, bh->b_blocknr, bh->b_dev, strerror(errno));
-	exit(8); /* File system errors left uncorrected */
-    }
+	if (lseek(bh->b_dev, offset, SEEK_SET) == (loff_t) - 1) {
+		fprintf(stderr,
+			"bwrite: lseek to position %llu (block=%lu, dev=%d): %s\n",
+			offset, bh->b_blocknr, bh->b_dev, strerror(errno));
+		exit(8);	/* File system errors left uncorrected */
+	}
 
-    if (s_rollback_file != NULL && bh->b_size == (unsigned long)rollback_blocksize) {
-        struct stat buf;
-        __u32 position;
-	struct block_handler block_h;
-        
-        /*log previous content into the log*/
-        if (!fstat (bh->b_dev, &buf)) {
-	    block_h.blocknr = bh->b_blocknr;
-	    block_h.device = buf.st_rdev;
-	    if (reiserfs_bin_search(&block_h, rollback_blocks_array, 
-				    rollback_blocks_number, sizeof (block_h), 
-				    &position, blockdev_list_compare)
-		!= POSITION_FOUND)
-	    {
-                /*read initial data from the disk*/
-                if (read(bh->b_dev, rollback_data, bh->b_size) == (long long)bh->b_size) {
-                    fwrite(&buf.st_rdev, sizeof (buf.st_rdev), 1, s_rollback_file);
-                    fwrite(&offset, sizeof (offset), 1, s_rollback_file);
-                    fwrite(rollback_data, rollback_blocksize, 1, s_rollback_file);
-                    fflush(s_rollback_file);
-                    blocklist__insert_in_position(&block_h, (void *)(&rollback_blocks_array),
-			&rollback_blocks_number, sizeof(block_h), &position);
-		    
-                    /*if you want to know what gets saved, uncomment it*/
+	if (s_rollback_file != NULL
+	    && bh->b_size == (unsigned long)rollback_blocksize) {
+		struct stat buf;
+		__u32 position;
+		struct block_handler block_h;
+
+		/*log previous content into the log */
+		if (!fstat(bh->b_dev, &buf)) {
+			block_h.blocknr = bh->b_blocknr;
+			block_h.device = buf.st_rdev;
+			if (reiserfs_bin_search(&block_h, rollback_blocks_array,
+						rollback_blocks_number,
+						sizeof(block_h), &position,
+						blockdev_list_compare)
+			    != POSITION_FOUND) {
+				/*read initial data from the disk */
+				if (read(bh->b_dev, rollback_data, bh->b_size)
+				    == (long long)bh->b_size) {
+					fwrite(&buf.st_rdev,
+					       sizeof(buf.st_rdev), 1,
+					       s_rollback_file);
+					fwrite(&offset, sizeof(offset), 1,
+					       s_rollback_file);
+					fwrite(rollback_data,
+					       rollback_blocksize, 1,
+					       s_rollback_file);
+					fflush(s_rollback_file);
+					blocklist__insert_in_position(&block_h,
+								      (void
+								       *)
+								      (&rollback_blocks_array),
+								      &rollback_blocks_number,
+								      sizeof
+								      (block_h),
+								      &position);
+
+					/*if you want to know what gets saved, uncomment it */
 /*                    if (log_file != 0 && log_file != stdout) {
                         fprintf (log_file, "rollback: block %lu of device %Lu was "
 			    "backed up\n", bh->b_blocknr, buf.st_rdev);
                     }
 */
-                    
-                } else {
-                    fprintf (stderr, "bwrite: read (block=%lu, dev=%d): %s\n", 
-			bh->b_blocknr, bh->b_dev, strerror (errno));
-                    exit(8);
-                }
-		
-                if (lseek (bh->b_dev, offset, SEEK_SET) == (loff_t)-1) {
-                    fprintf (stderr, "bwrite: lseek to position %llu (block=%lu, "
-			"dev=%d): %s\n", offset, bh->b_blocknr, bh->b_dev, 
-			strerror(errno));
-                    exit(8);
-                }
-            }
-        } else {
-            fprintf (stderr, "bwrite: fstat of (%d) returned -1: %s\n", 
-		bh->b_dev, strerror(errno));
-        }
-    } else if (s_rollback_file != NULL) {
-	fprintf (stderr, "rollback: block (%lu) has the size different from "
-	    "the fs uses, block skipped\n", bh->b_blocknr);
-    }
-    
-    bytes = write(bh->b_dev, bh->b_data, size);
-    if (bytes != size) {
-	fprintf (stderr, "bwrite: write %lld bytes returned %lld (block=%ld, "
-	    "dev=%d): %s\n", size, bytes, bh->b_blocknr, bh->b_dev, 
-	    strerror(errno));
-	exit(8);
-    }
-
-    mark_buffer_clean (bh);
 
-    if (bh->b_end_io) {
-	bh->b_end_io(bh, 1) ;
-    }
-
-    return 0;
-}
+				} else {
+					fprintf(stderr,
+						"bwrite: read (block=%lu, dev=%d): %s\n",
+						bh->b_blocknr, bh->b_dev,
+						strerror(errno));
+					exit(8);
+				}
+
+				if (lseek(bh->b_dev, offset, SEEK_SET) ==
+				    (loff_t) - 1) {
+					fprintf(stderr,
+						"bwrite: lseek to position %llu (block=%lu, "
+						"dev=%d): %s\n", offset,
+						bh->b_blocknr, bh->b_dev,
+						strerror(errno));
+					exit(8);
+				}
+			}
+		} else {
+			fprintf(stderr,
+				"bwrite: fstat of (%d) returned -1: %s\n",
+				bh->b_dev, strerror(errno));
+		}
+	} else if (s_rollback_file != NULL) {
+		fprintf(stderr,
+			"rollback: block (%lu) has the size different from "
+			"the fs uses, block skipped\n", bh->b_blocknr);
+	}
 
+	bytes = write(bh->b_dev, bh->b_data, size);
+	if (bytes != size) {
+		fprintf(stderr,
+			"bwrite: write %lld bytes returned %lld (block=%ld, "
+			"dev=%d): %s\n", size, bytes, bh->b_blocknr, bh->b_dev,
+			strerror(errno));
+		exit(8);
+	}
 
-static int _check_and_free_buffer_list(struct buffer_head *list) {
-    struct buffer_head *next = list ;
-    int count = 0 ;
-    if (!list)
-	return 0 ;
+	mark_buffer_clean(bh);
 
-    for(;;) {
-	if (next->b_count != 0)
-	    fprintf (stderr, "check_and_free_buffer_mem: not free buffer "
-		"(%d, %ld, %ld, %d)\n", next->b_dev, next->b_blocknr, 
-		next->b_size, next->b_count);
+	if (bh->b_end_io) {
+		bh->b_end_io(bh, 1);
+	}
 
-	if (buffer_dirty (next) && buffer_uptodate (next))
-	    fprintf (stderr, "check_and_free_buffer_mem: dirty buffer "
-		"(%d %lu) found\n", next->b_dev, next->b_blocknr);
+	return 0;
+}
 
-	freemem (next->b_data);
-	count++;
-	next = next->b_next;
-	if (next == list)
-            break;
-    }
-    return count;
+static int _check_and_free_buffer_list(struct buffer_head *list)
+{
+	struct buffer_head *next = list;
+	int count = 0;
+	if (!list)
+		return 0;
+
+	for (;;) {
+		if (next->b_count != 0)
+			fprintf(stderr,
+				"check_and_free_buffer_mem: not free buffer "
+				"(%d, %ld, %ld, %d)\n", next->b_dev,
+				next->b_blocknr, next->b_size, next->b_count);
+
+		if (buffer_dirty(next) && buffer_uptodate(next))
+			fprintf(stderr,
+				"check_and_free_buffer_mem: dirty buffer "
+				"(%d %lu) found\n", next->b_dev,
+				next->b_blocknr);
+
+		freemem(next->b_data);
+		count++;
+		next = next->b_next;
+		if (next == list)
+			break;
+	}
+	return count;
 }
 
-static void check_and_free_buffer_mem (void)
+static void check_and_free_buffer_mem(void)
 {
-    int count = 0;
-    struct buffer_head * next ;
+	int count = 0;
+	struct buffer_head *next;
 
 //    printf("check and free buffer mem, hits %d misses %d reads %d writes %d\n", 
-//	    buffer_hits, buffer_misses, buffer_reads, buffer_writes) ;
-    /*sync_buffers (0, 0);*/
+//          buffer_hits, buffer_misses, buffer_reads, buffer_writes) ;
+	/*sync_buffers (0, 0); */
 
-    count = _check_and_free_buffer_list(Buffer_list_head);
-    count += _check_and_free_buffer_list(g_free_buffers);
+	count = _check_and_free_buffer_list(Buffer_list_head);
+	count += _check_and_free_buffer_list(g_free_buffers);
 
-    if (count != g_nr_buffers)
-       die ("check_and_free_buffer_mem: found %d buffers, must be %d", 
-	    count, g_nr_buffers);
+	if (count != g_nr_buffers)
+		die("check_and_free_buffer_mem: found %d buffers, must be %d",
+		    count, g_nr_buffers);
 
-    /* free buffer heads */
-    while ((next = g_buffer_heads)) {
-	g_buffer_heads = *(struct buffer_head **)
-		(next + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
+	/* free buffer heads */
+	while ((next = g_buffer_heads)) {
+		g_buffer_heads = *(struct buffer_head **)
+		    (next + GROW_BUFFERS__NEW_BUFERS_PER_CALL);
 
-	freemem (next);
-    }
-  
-    return;
-}
+		freemem(next);
+	}
 
+	return;
+}
 
 /* */
-void free_buffers (void)
+void free_buffers(void)
 {
-    check_and_free_buffer_mem ();
+	check_and_free_buffer_mem();
 }
 
-
 static void _invalidate_buffer_list(struct buffer_head *list, int dev)
 {
-    struct buffer_head * next;
-
-    if (!list)
-	return;
-
-    next = list;
-
-    for (;;) {
-	if (next->b_dev == dev) {
-	    if (buffer_dirty (next) || next->b_count)
-		fprintf (stderr, "invalidate_buffers: dirty buffer or used buffer (%d %lu) found\n",
-			 next->b_count, next->b_blocknr);
-	    next->b_state = 0;
-	    remove_from_hash_queue (next);
+	struct buffer_head *next;
+
+	if (!list)
+		return;
+
+	next = list;
+
+	for (;;) {
+		if (next->b_dev == dev) {
+			if (buffer_dirty(next) || next->b_count)
+				fprintf(stderr,
+					"invalidate_buffers: dirty buffer or used buffer (%d %lu) found\n",
+					next->b_count, next->b_blocknr);
+			next->b_state = 0;
+			remove_from_hash_queue(next);
+		}
+		next = next->b_next;
+		if (next == list)
+			break;
 	}
-	next = next->b_next;
-	if (next == list)
-	    break;
-    }
 }
 
 /* forget all buffers of the given device */
-void invalidate_buffers (int dev)
+void invalidate_buffers(int dev)
 {
-    _invalidate_buffer_list(Buffer_list_head, dev) ;
-    _invalidate_buffer_list(g_free_buffers, dev) ;
+	_invalidate_buffer_list(Buffer_list_head, dev);
+	_invalidate_buffer_list(g_free_buffers, dev);
 }
diff --git a/lib/misc.c b/lib/misc.c
index e3aef28..7a77283 100644
--- a/lib/misc.c
+++ b/lib/misc.c
@@ -23,7 +23,6 @@
 #include <sys/ioctl.h>
 #include <signal.h>
 
-
 /* Debian modifications by Ed Boraas <ed@debian.org> */
 #include <sys/mount.h>
 /* End Debian mods */
@@ -44,136 +43,132 @@ STAT_FIELD(rdev, dev_t);
 STAT_FIELD(size, off_t);
 STAT_FIELD(blocks, blkcnt_t);
 
-void die (char * fmt, ...)
+void die(char *fmt, ...)
 {
-    static char buf[1024];
-    va_list args;
+	static char buf[1024];
+	va_list args;
 
-    va_start (args, fmt);
-    vsprintf (buf, fmt, args);
-    va_end (args);
+	va_start(args, fmt);
+	vsprintf(buf, fmt, args);
+	va_end(args);
 
-    fprintf (stderr, "\n%s\n", buf);
-    abort ();
+	fprintf(stderr, "\n%s\n", buf);
+	abort();
 }
 
-
 #define MEM_BEGIN "_mem_begin_"
 #define MEM_END "mem_end"
 #define MEM_FREED "__free_"
 #define CONTROL_SIZE (strlen (MEM_BEGIN) + 1 + sizeof (int) + strlen (MEM_END) + 1)
 
+unsigned int get_mem_size(char *p)
+{
+	char *begin;
 
-unsigned int get_mem_size(char *p) {
-    char *begin;
-    
-    begin = p - strlen (MEM_BEGIN) - 1 - sizeof(int);
-    return *(int *)(begin + strlen (MEM_BEGIN) + 1);
+	begin = p - strlen(MEM_BEGIN) - 1 - sizeof(int);
+	return *(int *)(begin + strlen(MEM_BEGIN) + 1);
 }
 
-
-void checkmem (char * p, int size)
+void checkmem(char *p, int size)
 {
-    char * begin;
-    char * end;
-  
-    begin = p - strlen (MEM_BEGIN) - 1 - sizeof (int);
-    if (strcmp (begin, MEM_BEGIN))
-	die ("checkmem: memory corrupted - invalid head sign");
+	char *begin;
+	char *end;
 
-    if (*(int *)(begin + strlen (MEM_BEGIN) + 1) != size)
-	die ("checkmem: memory corrupted - invalid size");
+	begin = p - strlen(MEM_BEGIN) - 1 - sizeof(int);
+	if (strcmp(begin, MEM_BEGIN))
+		die("checkmem: memory corrupted - invalid head sign");
 
-    end = begin + size + CONTROL_SIZE - strlen (MEM_END) - 1;
-    if (strcmp (end, MEM_END))
-	die ("checkmem: memory corrupted - invalid end sign");
-}
+	if (*(int *)(begin + strlen(MEM_BEGIN) + 1) != size)
+		die("checkmem: memory corrupted - invalid size");
 
+	end = begin + size + CONTROL_SIZE - strlen(MEM_END) - 1;
+	if (strcmp(end, MEM_END))
+		die("checkmem: memory corrupted - invalid end sign");
+}
 
-void *getmem (int size)
+void *getmem(int size)
 {
-    char * mem;
+	char *mem;
 
-    if ((mem = mem_alloc(size)) == NULL)
-	die ("getmem: no more memory (%d)", size);
-    
-    memset (mem, 0, size);
-//    checkmem (mem, size);
+	if ((mem = mem_alloc(size)) == NULL)
+		die("getmem: no more memory (%d)", size);
 
-    return mem;
-}
-
-void *mem_alloc(int size) {
-    char * p;
-    char * mem;
-
-    p = (char *)malloc (CONTROL_SIZE + size);
-    if (!p)
-	die ("getmem: no more memory (%d)", size);
-
-    /* Write the MEM_BEGIN magic in the beginning of allocated memory. */
-    strcpy (p, MEM_BEGIN);
-    p += strlen (MEM_BEGIN) + 1;
-    /* Write the size after the magic. */
-    *(int *)p = size;
-    p += sizeof (int);
-    mem = p;
-    p += size;
-    strcpy (p, MEM_END);
-
-    return mem;
-}
-
-void * expandmem (void * vp, int size, int by)
-{
-    int allocated;
-    char * mem, * p = vp;
-    int expand_by = by;
-
-    if (p) {
-	checkmem (p, size);
-	allocated = CONTROL_SIZE + size;
-	p -= (strlen (MEM_BEGIN) + 1 + sizeof (int));
-    } else {
-	allocated = 0;
-	/* add control bytes to the new allocated area */
-	expand_by += CONTROL_SIZE;
-    }
-    p = realloc (p, allocated + expand_by);
-    if (!p)
-	die ("expandmem: no more memory (%d)", size);
-    if (!vp) {
-	strcpy (p, MEM_BEGIN);
-    }
-    mem = p + strlen (MEM_BEGIN) + 1 + sizeof (int);
-
-    *(int *)(p + strlen (MEM_BEGIN) + 1) = size + by;
-    /* fill new allocated area by 0s */
-    if(by > 0)
-        memset (mem + size, 0, by);
-    strcpy (mem + size + by, MEM_END);
-//    checkmem (mem, size + by);
+	memset(mem, 0, size);
+//    checkmem (mem, size);
 
-    return mem;
+	return mem;
 }
 
+void *mem_alloc(int size)
+{
+	char *p;
+	char *mem;
+
+	p = (char *)malloc(CONTROL_SIZE + size);
+	if (!p)
+		die("getmem: no more memory (%d)", size);
 
-void freemem (void * vp)
+	/* Write the MEM_BEGIN magic in the beginning of allocated memory. */
+	strcpy(p, MEM_BEGIN);
+	p += strlen(MEM_BEGIN) + 1;
+	/* Write the size after the magic. */
+	*(int *)p = size;
+	p += sizeof(int);
+	mem = p;
+	p += size;
+	strcpy(p, MEM_END);
+
+	return mem;
+}
+
+void *expandmem(void *vp, int size, int by)
 {
-    char * p = vp;
-    int size;
-  
-    if (!p)
-	return;
-    size = get_mem_size (vp);
-    checkmem (p, size);
+	int allocated;
+	char *mem, *p = vp;
+	int expand_by = by;
+
+	if (p) {
+		checkmem(p, size);
+		allocated = CONTROL_SIZE + size;
+		p -= (strlen(MEM_BEGIN) + 1 + sizeof(int));
+	} else {
+		allocated = 0;
+		/* add control bytes to the new allocated area */
+		expand_by += CONTROL_SIZE;
+	}
+	p = realloc(p, allocated + expand_by);
+	if (!p)
+		die("expandmem: no more memory (%d)", size);
+	if (!vp) {
+		strcpy(p, MEM_BEGIN);
+	}
+	mem = p + strlen(MEM_BEGIN) + 1 + sizeof(int);
 
-    p -= (strlen (MEM_BEGIN) + 1 + sizeof (int));
-    strcpy (p, MEM_FREED);
-    strcpy (p + size + CONTROL_SIZE - strlen (MEM_END) - 1, MEM_FREED);
-    free (p);
+	*(int *)(p + strlen(MEM_BEGIN) + 1) = size + by;
+	/* fill new allocated area by 0s */
+	if (by > 0)
+		memset(mem + size, 0, by);
+	strcpy(mem + size + by, MEM_END);
+//    checkmem (mem, size + by);
+
+	return mem;
 }
 
+void freemem(void *vp)
+{
+	char *p = vp;
+	int size;
+
+	if (!p)
+		return;
+	size = get_mem_size(vp);
+	checkmem(p, size);
+
+	p -= (strlen(MEM_BEGIN) + 1 + sizeof(int));
+	strcpy(p, MEM_FREED);
+	strcpy(p + size + CONTROL_SIZE - strlen(MEM_END) - 1, MEM_FREED);
+	free(p);
+}
 
 typedef int (*func_t) (char *);
 
@@ -182,9 +177,7 @@ typedef int (*func_t) (char *);
    
    Warning: if the root fs is mounted RO, the content of /etc/mtab may be 
    not correct. */
-static struct mntent *misc_mntent_lookup(char *mntfile, 
-					 char *file, 
-					 int path) 
+static struct mntent *misc_mntent_lookup(char *mntfile, char *file, int path)
 {
 	struct mntent *mnt;
 	int name_match = 0;
@@ -194,7 +187,7 @@ static struct mntent *misc_mntent_lookup(char *mntfile,
 	ino_t ino = 0;
 	char *name;
 	FILE *fp;
-	
+
 	assert(mntfile != NULL);
 	assert(file != NULL);
 
@@ -214,21 +207,20 @@ static struct mntent *misc_mntent_lookup(char *mntfile,
 	while ((mnt = getmntent(fp)) != NULL) {
 		/* Check if names match. */
 		name = path ? mnt->mnt_dir : mnt->mnt_fsname;
-		
+
 		if (strcmp(file, name) == 0)
 			name_match = 1;
 
 		if (stat(name, &st))
 			continue;
-		
+
 		/* If names do not match, check if stats match. */
 		if (!name_match) {
 			if (rdev && S_ISBLK(st.st_mode)) {
 				if (rdev != st.st_rdev)
 					continue;
 			} else if (dev && !S_ISBLK(st.st_mode)) {
-				if (dev != st.st_dev ||
-				    ino != st.st_ino)
+				if (dev != st.st_dev || ino != st.st_ino)
 					continue;
 			} else {
 				continue;
@@ -236,47 +228,47 @@ static struct mntent *misc_mntent_lookup(char *mntfile,
 		}
 
 		/* If not path and not block device do not check anything more. */
-		if (!path && !rdev) 
+		if (!path && !rdev)
 			break;
 
 		if (path) {
 			/* Either names or stats match. Make sure the st_dev of 
 			   the path is same as @mnt_fsname device rdev. */
-			if (stat(mnt->mnt_fsname, &st) == 0 && 
+			if (stat(mnt->mnt_fsname, &st) == 0 &&
 			    dev == st.st_rdev)
 				break;
 		} else {
 			/* Either names or stats match. Make sure the st_dev of 
 			   the mount entry is same as the given device rdev. */
-			if (stat(mnt->mnt_dir, &st) == 0 && 
-			    rdev == st.st_dev)
+			if (stat(mnt->mnt_dir, &st) == 0 && rdev == st.st_dev)
 				break;
 		}
 	}
 
-	endmntent (fp);
-        return mnt;
+	endmntent(fp);
+	return mnt;
 }
 
-static int misc_root_mounted(char *device) {
+static int misc_root_mounted(char *device)
+{
 	struct stat rootst, devst;
-	
+
 	assert(device != NULL);
 
-	if (stat("/", &rootst) != 0) 
+	if (stat("/", &rootst) != 0)
 		return -1;
 
 	if (stat(device, &devst) != 0)
 		return -1;
 
-	if (!S_ISBLK(devst.st_mode) || 
-	    devst.st_rdev != rootst.st_dev)
+	if (!S_ISBLK(devst.st_mode) || devst.st_rdev != rootst.st_dev)
 		return 0;
 
 	return 1;
 }
 
-static int misc_file_ro(char *file) {
+static int misc_file_ro(char *file)
+{
 	if (utime(file, 0) == -1) {
 		if (errno == EROFS)
 			return 1;
@@ -285,35 +277,36 @@ static int misc_file_ro(char *file) {
 	return 0;
 }
 
-struct mntent *misc_mntent(char *device) {
+struct mntent *misc_mntent(char *device)
+{
 	int proc = 0, path = 0, root = 0;
-	
+
 	struct mntent *mnt;
 	struct statfs stfs;
 
 	assert(device != NULL);
-	
+
 	/* Check if the root. */
 	if (misc_root_mounted(device) == 1)
 		root = 1;
-	
+
 #ifdef __linux__
 	/* Check if /proc is procfs. */
 	if (statfs("/proc", &stfs) == 0 && stfs.f_type == 0x9fa0) {
 		proc = 1;
-		
+
 		if (root) {
 			/* Lookup the "/" entry in /proc/mounts. Special 
 			   case as root entry can present as:
-				rootfs / rootfs rw 0 0
+			   rootfs / rootfs rw 0 0
 			   Look up the mount point in this case. */
 			mnt = misc_mntent_lookup("/proc/mounts", "/", 1);
 		} else {
 			/* Lookup the @device /proc/mounts */
 			mnt = misc_mntent_lookup("/proc/mounts", device, 0);
 		}
-		
-		if (mnt == INVAL_PTR) 
+
+		if (mnt == INVAL_PTR)
 			proc = 0;
 		else if (mnt)
 			return mnt;
@@ -323,7 +316,7 @@ struct mntent *misc_mntent(char *device) {
 #if defined(MOUNTED) || defined(_PATH_MOUNTED)
 
 #ifndef MOUNTED
-    #define MOUNTED _PATH_MOUNTED
+#define MOUNTED _PATH_MOUNTED
 #endif
 	/* Check in MOUNTED (/etc/mtab) if RW. */
 	if (!misc_file_ro(MOUNTED)) {
@@ -335,27 +328,28 @@ struct mntent *misc_mntent(char *device) {
 			mnt = misc_mntent_lookup(MOUNTED, device, 0);
 		}
 
-		if (mnt == INVAL_PTR) 
+		if (mnt == INVAL_PTR)
 			path = 0;
 		else if (mnt)
 			return mnt;
 	}
 #endif /* defined(MOUNTED) || defined(_PATH_MOUNTED) */
-	
+
 	/* If has not been checked in neither /proc/mounts nor /etc/mtab (or 
 	   errors have occured), return INVAL_PTR, NULL otherwise. */
 	return (!proc && !path) ? INVAL_PTR : NULL;
 }
 
-int misc_device_mounted(char *device) {
+int misc_device_mounted(char *device)
+{
 	struct mntent *mnt;
-	
+
 	/* Check for the "/" first to avoid any possible problem with 
 	   reflecting the root fs info in mtab files. */
 	if (misc_root_mounted(device) == 1) {
 		return misc_file_ro("/") ? MF_RO : MF_RW;
 	}
-	
+
 	/* Lookup the mount entry. */
 	if ((mnt = misc_mntent(device)) == NULL) {
 		return MF_NOT_MOUNTED;
@@ -366,99 +360,99 @@ int misc_device_mounted(char *device) {
 	return hasmntopt(mnt, MNTOPT_RO) ? MF_RO : MF_RW;
 }
 
-char buf1 [100];
-char buf2 [100];
+char buf1[100];
+char buf2[100];
 
-void print_how_fast (unsigned long passed, unsigned long total,
-		     int cursor_pos, int reset_time)
+void print_how_fast(unsigned long passed, unsigned long total,
+		    int cursor_pos, int reset_time)
 {
-    static time_t t0 = 0, t1 = 0, t2 = 0;
-    int speed;
-    int indent;
-
-    if (reset_time)
-	time (&t0);
-
-    time (&t1);
-    if (t1 != t0) {
-	speed = passed / (t1 - t0);
-	if (total - passed) {
-	    if (t1 - t2 < 1)
-	        return;
-	    t2 = t1;
-	}	
-    } else
-	speed = 0;
+	static time_t t0 = 0, t1 = 0, t2 = 0;
+	int speed;
+	int indent;
+
+	if (reset_time)
+		time(&t0);
+
+	time(&t1);
+	if (t1 != t0) {
+		speed = passed / (t1 - t0);
+		if (total - passed) {
+			if (t1 - t2 < 1)
+				return;
+			t2 = t1;
+		}
+	} else
+		speed = 0;
+
+	/* what has to be written */
+	if (total)
+		sprintf(buf1, "left %lu, %d /sec", total - passed, speed);
+	else {
+		/*(*passed) ++; */
+		sprintf(buf1, "done %lu, %d /sec", passed, speed);
+	}
 
-    /* what has to be written */
-    if (total)
-      sprintf (buf1, "left %lu, %d /sec", total - passed, speed);
-    else {
-	/*(*passed) ++;*/
-	sprintf (buf1, "done %lu, %d /sec", passed, speed);
-    }
-    
-    /* make indent */
-    indent = 79 - cursor_pos - strlen (buf1);
-    memset (buf2, ' ', indent);
-    buf2[indent] = 0;
-    fprintf (stderr, "%s%s", buf2, buf1);
+	/* make indent */
+	indent = 79 - cursor_pos - strlen(buf1);
+	memset(buf2, ' ', indent);
+	buf2[indent] = 0;
+	fprintf(stderr, "%s%s", buf2, buf1);
 
-    memset (buf2, '\b', indent + strlen (buf1));
-    buf2 [indent + strlen (buf1)] = 0;
-    fprintf (stderr, "%s", buf2);
-    fflush (stderr);
+	memset(buf2, '\b', indent + strlen(buf1));
+	buf2[indent + strlen(buf1)] = 0;
+	fprintf(stderr, "%s", buf2);
+	fflush(stderr);
 }
 
-
-static char * strs[] =
-{"0%",".",".",".",".","20%",".",".",".",".","40%",".",".",".",".","60%",".",".",".",".","80%",".",".",".",".","100%"};
+static char *strs[] =
+    { "0%", ".", ".", ".", ".", "20%", ".", ".", ".", ".", "40%", ".", ".", ".",
+".", "60%", ".", ".", ".", ".", "80%", ".", ".", ".", ".", "100%" };
 
 static char progress_to_be[1024];
 static char current_progress[1024];
 
-static void str_to_be (char * buf, int prosents)
+static void str_to_be(char *buf, int prosents)
 {
-    int i;
-    prosents -= prosents % 4;
-    buf[0] = 0;
-    for (i = 0; i <= prosents / 4; i ++)
-	strcat (buf, strs[i]);
+	int i;
+	prosents -= prosents % 4;
+	buf[0] = 0;
+	for (i = 0; i <= prosents / 4; i++)
+		strcat(buf, strs[i]);
 }
 
-
-void print_how_far (FILE * fp,
-		    unsigned long * passed, unsigned long total,
-		    unsigned int inc, int quiet)
+void print_how_far(FILE * fp,
+		   unsigned long *passed, unsigned long total,
+		   unsigned int inc, int quiet)
 {
-    int percent;
+	int percent;
 
-    if (*passed == 0)
-	current_progress[0] = 0;
+	if (*passed == 0)
+		current_progress[0] = 0;
 
-    (*passed) += inc;
-    if (*passed > total) {
+	(*passed) += inc;
+	if (*passed > total) {
 /*	fprintf (fp, "\nprint_how_far: total %lu has been reached already. cur=%lu\n",
 	total, *passed);*/
-	return;
-    }
+		return;
+	}
 
-    percent = ((*passed) * 100) / total;
+	percent = ((*passed) * 100) / total;
 
-    str_to_be (progress_to_be, percent);
+	str_to_be(progress_to_be, percent);
 
-    if (strlen (current_progress) != strlen (progress_to_be)) {
-	fprintf (fp, "%s", progress_to_be + strlen (current_progress));
-    }
+	if (strlen(current_progress) != strlen(progress_to_be)) {
+		fprintf(fp, "%s", progress_to_be + strlen(current_progress));
+	}
 
-    strcat (current_progress, progress_to_be + strlen (current_progress));
+	strcat(current_progress, progress_to_be + strlen(current_progress));
 
-    if (!quiet) {
-	print_how_fast(*passed /* - inc*/, total, strlen (progress_to_be),
-	    (*passed == inc) ? 1 : 0);
-    }
+	if (!quiet) {
+		print_how_fast(*passed /* - inc */ , total,
+			       strlen(progress_to_be),
+			       (*passed == inc) ? 1 : 0);
+	}
 
-    fflush (fp);
+	fflush(fp);
 }
 
 #if defined(__linux__) && defined(_IOR) && !defined(BLKGETSIZE64)
@@ -475,230 +469,223 @@ void print_how_far (FILE * fp,
    to smaller one. */
 #define MAX_BS (64 * 1024)
 
-int valid_offset( int fd, loff_t offset) {
-    char ch;
-    loff_t res;
-
-    /*res = reiserfs_llseek (fd, offset, 0);*/
-    res = lseek (fd, offset, SEEK_SET);
-    if (res < 0)
-	return 0;
+int valid_offset(int fd, loff_t offset)
+{
+	char ch;
+	loff_t res;
 
-    /* if (read (fd, &ch, 1) < 0) does not wirk on files */
-    if (read (fd, &ch, 1) < 1)
-	return 0;
+	/*res = reiserfs_llseek (fd, offset, 0); */
+	res = lseek(fd, offset, SEEK_SET);
+	if (res < 0)
+		return 0;
 
+	/* if (read (fd, &ch, 1) < 0) does not wirk on files */
+	if (read(fd, &ch, 1) < 1)
+		return 0;
 
-    return 1;
+	return 1;
 }
 
 /* calculates number of blocks in a file. Returns 0 for "sparse"
    regular files and files other than regular files and block devices */
-unsigned long count_blocks (char * filename, int blocksize)
+unsigned long count_blocks(char *filename, int blocksize)
 {
-    loff_t high, low;
-    unsigned long sz;
-    __u64 size;
-    int fd;
-
-    if (!S_ISBLK(misc_device_mode(filename)) && 
-	!S_ISREG(misc_device_mode(filename)))
-	return 0;
+	loff_t high, low;
+	unsigned long sz;
+	__u64 size;
+	int fd;
 
-    fd = open (filename, O_RDONLY);
-    if (fd == -1) {
-	fprintf(stderr, "Failed to open '%s': %s.\n", filename, strerror(errno));
-	return 0;
-    }
+	if (!S_ISBLK(misc_device_mode(filename)) &&
+	    !S_ISREG(misc_device_mode(filename)))
+		return 0;
 
+	fd = open(filename, O_RDONLY);
+	if (fd == -1) {
+		fprintf(stderr, "Failed to open '%s': %s.\n", filename,
+			strerror(errno));
+		return 0;
+	}
 #ifdef BLKGETSIZE64
-    {
-	if (ioctl (fd, BLKGETSIZE64, &size) >= 0) {
-	    size = (size / MAX_BS) * MAX_BS / blocksize;
-	    sz = size;
-	    if ((__u64)sz != size)
-		    die ("count_blocks: block device too large");
-
-	    close(fd);
-	    return sz;
+	{
+		if (ioctl(fd, BLKGETSIZE64, &size) >= 0) {
+			size = (size / MAX_BS) * MAX_BS / blocksize;
+			sz = size;
+			if ((__u64) sz != size)
+				die("count_blocks: block device too large");
+
+			close(fd);
+			return sz;
+		}
 	}
-    }
 #endif
 
-
 #ifdef BLKGETSIZE
-    {
-	if (ioctl (fd, BLKGETSIZE, &sz) >= 0) {
-	    size = sz;
+	{
+		if (ioctl(fd, BLKGETSIZE, &sz) >= 0) {
+			size = sz;
 
-	    close(fd);
-	    return (size * 512 / MAX_BS) * MAX_BS / blocksize;
+			close(fd);
+			return (size * 512 / MAX_BS) * MAX_BS / blocksize;
+		}
 	}
-    }
 #endif
 
-    low = 0;
-    for( high = 1; valid_offset (fd, high); high *= 2 )
-	low = high;
-    while (low < high - 1) {
-	const loff_t mid = ( low + high ) / 2;
+	low = 0;
+	for (high = 1; valid_offset(fd, high); high *= 2)
+		low = high;
+	while (low < high - 1) {
+		const loff_t mid = (low + high) / 2;
 
-	if (valid_offset (fd, mid))
-	    low = mid;
-	else
-	    high = mid;
-    }
-    
-    valid_offset (fd, 0);
+		if (valid_offset(fd, mid))
+			low = mid;
+		else
+			high = mid;
+	}
+
+	valid_offset(fd, 0);
 
-    close (fd);
-    return (low + 1) * MAX_BS / MAX_BS / blocksize;
+	close(fd);
+	return (low + 1) * MAX_BS / MAX_BS / blocksize;
 }
 
 /* there are masks for certain bits  */
-__u16 mask16 (int from, int count)
+__u16 mask16(int from, int count)
 {
-    __u16 mask;
+	__u16 mask;
 
-
-    mask = (0xffff >> from);
-    mask <<= from;
-    mask <<= (16 - from - count);
-    mask >>= (16 - from - count);
-    return mask;
+	mask = (0xffff >> from);
+	mask <<= from;
+	mask <<= (16 - from - count);
+	mask >>= (16 - from - count);
+	return mask;
 }
 
-
-__u32 mask32 (int from, int count)
+__u32 mask32(int from, int count)
 {
-    __u32 mask;
+	__u32 mask;
 
-
-    mask = (0xffffffff >> from);
-    mask <<= from;
-    mask <<= (32 - from - count);
-    mask >>= (32 - from - count);
-    return mask;
+	mask = (0xffffffff >> from);
+	mask <<= from;
+	mask <<= (32 - from - count);
+	mask >>= (32 - from - count);
+	return mask;
 }
 
-
-__u64 mask64 (int from, int count)
+__u64 mask64(int from, int count)
 {
-    __u64 mask;
-
+	__u64 mask;
 
-    mask = (0xffffffffffffffffLL >> from);
-    mask <<= from;
-    mask <<= (64 - from - count);
-    mask >>= (64 - from - count);
-    return mask;
+	mask = (0xffffffffffffffffLL >> from);
+	mask <<= from;
+	mask <<= (64 - from - count);
+	mask >>= (64 - from - count);
+	return mask;
 }
 
-
-__u32 get_random (void)
+__u32 get_random(void)
 {
-    srandom (time (0));
-    return random ();
+	srandom(time(0));
+	return random();
 }
 
 /* this implements binary search in the array 'base' among 'num' elements each
    of those is 'width' bytes long. 'comp_func' is used to compare keys */
-int reiserfs_bin_search (void * key, void * base, __u32 num, int width,
-			 __u32 * ppos, comparison_fn_t comp_func)
+int reiserfs_bin_search(void *key, void *base, __u32 num, int width,
+			__u32 * ppos, comparison_fn_t comp_func)
 {
-    __u32 rbound, lbound, j;
-    int ret;
+	__u32 rbound, lbound, j;
+	int ret;
 
-    if (num == 0 || base == NULL) {
-	/* objectid map may be 0 elements long */
-	*ppos = 0;
-	return POSITION_NOT_FOUND;
-    }
-
-    lbound = 0;
-    rbound = num - 1;
-
-    for (j = (rbound + lbound) / 2; lbound <= rbound; j = (rbound + lbound) / 2) {
-	ret =  comp_func ((void *)((char *)base + j * width), key ) ;
-	if (ret < 0) { /* second is greater */
-	    lbound = j + 1;
-	    continue;
-
-	} else if (ret > 0) { /* first is greater */
-	    if (j == 0)
-	    	break;
-	    rbound = j - 1;
-	    continue;
-	} else { /* equal */
-	    *ppos = j;
-	    return POSITION_FOUND;
+	if (num == 0 || base == NULL) {
+		/* objectid map may be 0 elements long */
+		*ppos = 0;
+		return POSITION_NOT_FOUND;
 	}
-    }
 
-    *ppos = lbound;
-    return POSITION_NOT_FOUND;
-}
+	lbound = 0;
+	rbound = num - 1;
+
+	for (j = (rbound + lbound) / 2; lbound <= rbound;
+	     j = (rbound + lbound) / 2) {
+		ret = comp_func((void *)((char *)base + j * width), key);
+		if (ret < 0) {	/* second is greater */
+			lbound = j + 1;
+			continue;
+
+		} else if (ret > 0) {	/* first is greater */
+			if (j == 0)
+				break;
+			rbound = j - 1;
+			continue;
+		} else {	/* equal */
+			*ppos = j;
+			return POSITION_FOUND;
+		}
+	}
 
+	*ppos = lbound;
+	return POSITION_NOT_FOUND;
+}
 
 #define BLOCKLIST__ELEMENT_NUMBER 10
 
 /*element is block number and device*/
-int blockdev_list_compare (const void * block1, const void * block2) {
-    if (*(__u32 *)block1 < *(__u32 *)block2)
-        return -1;
-    if (*(__u32 *)block1 > *(__u32 *)block2)
-        return 1;
-        
-    if (*((__u32 *)block1 + 1) < *((__u32 *)block2 + 1))
-        return -1;        
-    if (*((__u32 *)block1 + 1) > *((__u32 *)block2 + 1))
-        return 1;
-        
-    return 0;
-}
-
-void blocklist__insert_in_position (void *elem, void **base, __u32 *count, 
-    int elem_size, __u32 *position) 
-{
-    if (elem_size == 0)
-    	return;
-    	
-    if (*base == NULL)
-        *base = getmem (BLOCKLIST__ELEMENT_NUMBER * elem_size);
-    
-    if (*count == get_mem_size((void *)*base) / elem_size)
-        *base = expandmem (*base, get_mem_size((void *)*base), 
-                        BLOCKLIST__ELEMENT_NUMBER * elem_size);
-    
-    if (*position < *count) {
-        memmove (*base + (*position + 1), 
-                 *base + (*position),
-                 (*count - *position) * elem_size);
-    }
-
-    memcpy (*base + (char) *position * elem_size, elem, elem_size);
-    *count+=1;
+int blockdev_list_compare(const void *block1, const void *block2)
+{
+	if (*(__u32 *) block1 < *(__u32 *) block2)
+		return -1;
+	if (*(__u32 *) block1 > *(__u32 *) block2)
+		return 1;
+
+	if (*((__u32 *) block1 + 1) < *((__u32 *) block2 + 1))
+		return -1;
+	if (*((__u32 *) block1 + 1) > *((__u32 *) block2 + 1))
+		return 1;
+
+	return 0;
+}
+
+void blocklist__insert_in_position(void *elem, void **base, __u32 * count,
+				   int elem_size, __u32 * position)
+{
+	if (elem_size == 0)
+		return;
+
+	if (*base == NULL)
+		*base = getmem(BLOCKLIST__ELEMENT_NUMBER * elem_size);
+
+	if (*count == get_mem_size((void *)*base) / elem_size)
+		*base = expandmem(*base, get_mem_size((void *)*base),
+				  BLOCKLIST__ELEMENT_NUMBER * elem_size);
+
+	if (*position < *count) {
+		memmove(*base + (*position + 1),
+			*base + (*position), (*count - *position) * elem_size);
+	}
+
+	memcpy(*base + (char)*position * elem_size, elem, elem_size);
+	*count += 1;
 }
 
 /* 0 - dma is not supported, scsi or regular file */
 /* 1 - xt drive                                   */
 /* 2 - ide drive */
-static void get_dma_support(dma_info_t *dma_info){
-    if (S_ISREG(dma_info->st.st_mode))
-	dma_info->st.st_rdev = dma_info->st.st_dev;
-
-    if (IDE_DISK_MAJOR(major(dma_info->st.st_rdev))) {
-        dma_info->support_type = 2;
-	return;
-    }
-    
+static void get_dma_support(dma_info_t *dma_info)
+{
+	if (S_ISREG(dma_info->st.st_mode))
+		dma_info->st.st_rdev = dma_info->st.st_dev;
+
+	if (IDE_DISK_MAJOR(major(dma_info->st.st_rdev))) {
+		dma_info->support_type = 2;
+		return;
+	}
 #ifdef XT_DISK_MAJOR
-    if (major(dma_info->st.st_rdev) == XT_DISK_MAJOR) {
-	dma_info->support_type = 1;
-	return;
-    }
-#endif    
-    dma_info->support_type = 0;
+	if (major(dma_info->st.st_rdev) == XT_DISK_MAJOR) {
+		dma_info->support_type = 1;
+		return;
+	}
+#endif
+	dma_info->support_type = 0;
 }
 
 /* 
@@ -708,257 +695,268 @@ static void get_dma_support(dma_info_t *dma_info){
  * -1 - preparation failed
  */
 
-int prepare_dma_check(dma_info_t *dma_info) {
-    DIR *dir;
-    struct dirent *dirent;
-    struct stat st;
-    dev_t rdev;
-    int rem;
-    char buf[256];
+int prepare_dma_check(dma_info_t *dma_info)
+{
+	DIR *dir;
+	struct dirent *dirent;
+	struct stat st;
+	dev_t rdev;
+	int rem;
+	char buf[256];
 
 #ifndef HDIO_GET_DMA
-        return -1;
+	return -1;
 #endif
-	
-    if (fstat(dma_info->fd, &dma_info->st))
-	die("stat on device failed\n");
-   
-    get_dma_support(dma_info);
-   
-    /* dma should be supported */
-    if (dma_info->support_type == 0)
-	return 1;
-    
-    if (dma_info->support_type == 2) {
-	rdev = dma_info->st.st_rdev;
 
-	if ((rem = (minor(rdev) % 64)) != 0) {
-	    rdev -= rem;
-	    if(!(dir = opendir("/dev/"))) {
-		dma_info->support_type = 1;
-		return 0;
-	    }
-	    
-	    while ((dirent = readdir(dir)) != NULL) {
-		if (strncmp(dirent->d_name, ".", 1) == 0 || strncmp(dirent->d_name, "..", 2) == 0)
-		    continue;
-		memset(buf, 0, 256);
-		strncat(buf, "/dev/", 5);
-		strncat(buf, dirent->d_name, strlen(dirent->d_name));
-		
-		if (stat(buf, &st))
-		    break;
-		
-		if (S_ISBLK(st.st_mode) && st.st_rdev == rdev) 
-		{
-		    dma_info->st = st;
-		    dma_info->fd = open(buf, O_RDONLY
+	if (fstat(dma_info->fd, &dma_info->st))
+		die("stat on device failed\n");
+
+	get_dma_support(dma_info);
+
+	/* dma should be supported */
+	if (dma_info->support_type == 0)
+		return 1;
+
+	if (dma_info->support_type == 2) {
+		rdev = dma_info->st.st_rdev;
+
+		if ((rem = (minor(rdev) % 64)) != 0) {
+			rdev -= rem;
+			if (!(dir = opendir("/dev/"))) {
+				dma_info->support_type = 1;
+				return 0;
+			}
+
+			while ((dirent = readdir(dir)) != NULL) {
+				if (strncmp(dirent->d_name, ".", 1) == 0
+				    || strncmp(dirent->d_name, "..", 2) == 0)
+					continue;
+				memset(buf, 0, 256);
+				strncat(buf, "/dev/", 5);
+				strncat(buf, dirent->d_name,
+					strlen(dirent->d_name));
+
+				if (stat(buf, &st))
+					break;
+
+				if (S_ISBLK(st.st_mode) && st.st_rdev == rdev) {
+					dma_info->st = st;
+					dma_info->fd = open(buf, O_RDONLY
 #if defined(O_LARGEFILE)
-					| O_LARGEFILE
+							    | O_LARGEFILE
 #endif
-					);
-		    closedir(dir);
-		    return 0;
+					    );
+					closedir(dir);
+					return 0;
+				}
+			}
+			closedir(dir);
+			dma_info->support_type = 1;
+			return 1;
 		}
-	    }
-	    closedir(dir);
-	    dma_info->support_type = 1;
-	    return 1;
 	}
-    }
-    
-    return 0;
+
+	return 0;
 }
 
-static int is_dma_on (int fd) {
-#ifdef HDIO_GET_DMA    
-    static long parm;
-    if (ioctl(fd, HDIO_GET_DMA, &parm))
-	return -1;
-    else 
-	return parm;
+static int is_dma_on(int fd)
+{
+#ifdef HDIO_GET_DMA
+	static long parm;
+	if (ioctl(fd, HDIO_GET_DMA, &parm))
+		return -1;
+	else
+		return parm;
 #endif
-    return 0;
+	return 0;
 }
 
+static __u64 dma_speed(int fd, int support_type)
+{
+	static struct hd_driveid id;
+	__u64 speed = 0;
 
-static __u64 dma_speed(int fd, int support_type) {
-    static struct hd_driveid id;
-    __u64 speed = 0;
-            
-    if (support_type != 2) 
-	return 0;
+	if (support_type != 2)
+		return 0;
 
 #ifdef HDIO_OBSOLETE_IDENTITY
-    if (!ioctl(fd, HDIO_GET_IDENTITY, &id) || 
-	!ioctl(fd, HDIO_OBSOLETE_IDENTITY)) {
+	if (!ioctl(fd, HDIO_GET_IDENTITY, &id) ||
+	    !ioctl(fd, HDIO_OBSOLETE_IDENTITY)) {
 #else
-    if (!ioctl(fd, HDIO_GET_IDENTITY, &id)) {
+	if (!ioctl(fd, HDIO_GET_IDENTITY, &id)) {
 #endif
-	speed |= (__u64)id.dma_1word &  ~(__u64)0xff;
-	speed |= ((__u64)id.dma_mword & ~(__u64)0xff) << 16;
-	speed |= ((__u64)id.dma_ultra & ~(__u64)0xff) << 32;
-    } else if (errno == -ENOMSG)
-	return -1;
-    else 
-	return -1;
-    
-    return speed;
+		speed |= (__u64) id.dma_1word & ~(__u64) 0xff;
+		speed |= ((__u64) id.dma_mword & ~(__u64) 0xff) << 16;
+		speed |= ((__u64) id.dma_ultra & ~(__u64) 0xff) << 32;
+	} else if (errno == -ENOMSG)
+		return -1;
+	else
+		return -1;
+
+	return speed;
 }
 
-int get_dma_info(dma_info_t *dma_info) {
-    if ((dma_info->dma = is_dma_on(dma_info->fd)) == -1)
-	return -1;
-    if ((dma_info->speed = dma_speed(dma_info->fd, dma_info->support_type)) == (__u64)-1) 
-	return -1;
-    return 0;
+int get_dma_info(dma_info_t *dma_info)
+{
+	if ((dma_info->dma = is_dma_on(dma_info->fd)) == -1)
+		return -1;
+	if ((dma_info->speed =
+	     dma_speed(dma_info->fd, dma_info->support_type)) == (__u64) - 1)
+		return -1;
+	return 0;
 }
 
-void clean_after_dma_check(int fd, dma_info_t *dma_info) {
-    signal(SIGALRM, SIG_IGN);
-    if (dma_info->fd && fd != dma_info->fd)
-	close(dma_info->fd);
+void clean_after_dma_check(int fd, dma_info_t *dma_info)
+{
+	signal(SIGALRM, SIG_IGN);
+	if (dma_info->fd && fd != dma_info->fd)
+		close(dma_info->fd);
 }
 
 /* Only le bitops operations are used. */
 
-inline int misc_set_bit (unsigned long long nr, void * addr) {
-    __u8 * p, mask;
-    int retval;
+inline int misc_set_bit(unsigned long long nr, void *addr)
+{
+	__u8 *p, mask;
+	int retval;
 
-    p = (__u8 *)addr;
-    p += nr >> 3;
-    mask = 1 << (nr & 0x7);
-    /*cli();*/
-    retval = (mask & *p) != 0;
-    *p |= mask;
-    /*sti();*/
-    return retval;
+	p = (__u8 *) addr;
+	p += nr >> 3;
+	mask = 1 << (nr & 0x7);
+	/*cli(); */
+	retval = (mask & *p) != 0;
+	*p |= mask;
+	/*sti(); */
+	return retval;
 }
 
+inline int misc_clear_bit(unsigned long long nr, void *addr)
+{
+	__u8 *p, mask;
+	int retval;
 
-inline int misc_clear_bit (unsigned long long nr, void * addr) {
-    __u8 * p, mask;
-    int retval;
-
-    p = (__u8 *)addr;
-    p += nr >> 3;
-    mask = 1 << (nr & 0x7);
-    /*cli();*/
-    retval = (mask & *p) != 0;
-    *p &= ~mask;
-    /*sti();*/
-    return retval;
+	p = (__u8 *) addr;
+	p += nr >> 3;
+	mask = 1 << (nr & 0x7);
+	/*cli(); */
+	retval = (mask & *p) != 0;
+	*p &= ~mask;
+	/*sti(); */
+	return retval;
 }
 
-inline int misc_test_bit(unsigned long long nr, const void * addr) {
-    __u8 * p, mask;
+inline int misc_test_bit(unsigned long long nr, const void *addr)
+{
+	__u8 *p, mask;
 
-    p = (__u8 *)addr;
-    p += nr >> 3;
-    mask = 1 << (nr & 0x7);
-    return ((mask & *p) != 0);
+	p = (__u8 *) addr;
+	p += nr >> 3;
+	mask = 1 << (nr & 0x7);
+	return ((mask & *p) != 0);
 }
 
-inline unsigned long long misc_find_first_zero_bit (const void *vaddr, 
-    unsigned long long size) 
+inline unsigned long long misc_find_first_zero_bit(const void *vaddr,
+						   unsigned long long size)
 {
-    const __u8 *p = vaddr, *addr = vaddr;
-    unsigned long long res;
+	const __u8 *p = vaddr, *addr = vaddr;
+	unsigned long long res;
 
-    if (!size)
-        return 0;
+	if (!size)
+		return 0;
 
-    size = (size >> 3) + ((size & 0x7) > 0);
-    while (*p++ == 255) {
-        if (--size == 0)
-            return (unsigned long long)(p - addr) << 3;
-    }
+	size = (size >> 3) + ((size & 0x7) > 0);
+	while (*p++ == 255) {
+		if (--size == 0)
+			return (unsigned long long)(p - addr) << 3;
+	}
 
-    --p;
-    for (res = 0; res < 8; res++)
-        if (!misc_test_bit (res, p))
-            break;
-    return res + (p - addr) * 8;
+	--p;
+	for (res = 0; res < 8; res++)
+		if (!misc_test_bit(res, p))
+			break;
+	return res + (p - addr) * 8;
 }
 
-
-inline unsigned long long misc_find_next_zero_bit (const void *vaddr, 
-    unsigned long long size, unsigned long long offset) 
+inline unsigned long long misc_find_next_zero_bit(const void *vaddr,
+						  unsigned long long size,
+						  unsigned long long offset)
 {
-    const __u8 *addr = vaddr;
-    const __u8 *p = addr + (offset >> 3);
-    int bit = offset & 7;
-    unsigned long long res;
-
-    if (offset >= size)
-        return size;
-
-    if (bit) {
-        /* Look for zero in first char */
-        for (res = bit; res < 8; res++)
-            if (!misc_test_bit (res, p))
-                return res + (p - addr) * 8;
-        p++;
-    }
-    /* No zero yet, search remaining full bytes for a zero */
-    res = misc_find_first_zero_bit (p, size - 8 * (p - addr));
-    return res + (p - addr) * 8;
+	const __u8 *addr = vaddr;
+	const __u8 *p = addr + (offset >> 3);
+	int bit = offset & 7;
+	unsigned long long res;
+
+	if (offset >= size)
+		return size;
+
+	if (bit) {
+		/* Look for zero in first char */
+		for (res = bit; res < 8; res++)
+			if (!misc_test_bit(res, p))
+				return res + (p - addr) * 8;
+		p++;
+	}
+	/* No zero yet, search remaining full bytes for a zero */
+	res = misc_find_first_zero_bit(p, size - 8 * (p - addr));
+	return res + (p - addr) * 8;
 }
 
-inline unsigned long long misc_find_first_set_bit (const void *vaddr, 
-    unsigned long long size) 
+inline unsigned long long misc_find_first_set_bit(const void *vaddr,
+						  unsigned long long size)
 {
-    const __u8 *p = vaddr, *addr = vaddr;
-    unsigned long long res;
+	const __u8 *p = vaddr, *addr = vaddr;
+	unsigned long long res;
 
-    if (!size)
-        return 0;
+	if (!size)
+		return 0;
 
-    size = (size >> 3) + ((size & 0x7) > 0);
-    while (*p++ == 0) {
-        if (--size == 0)
-            return (unsigned long long)(p - addr) << 3;
-    }
+	size = (size >> 3) + ((size & 0x7) > 0);
+	while (*p++ == 0) {
+		if (--size == 0)
+			return (unsigned long long)(p - addr) << 3;
+	}
 
-    --p;
-    for (res = 0; res < 8; res++)
-        if (misc_test_bit (res, p))
-            break;
+	--p;
+	for (res = 0; res < 8; res++)
+		if (misc_test_bit(res, p))
+			break;
 
-    return res + (p - addr) * 8;
+	return res + (p - addr) * 8;
 }
 
-inline unsigned long long misc_find_next_set_bit(const void *vaddr, 
-    unsigned long long size, unsigned long long offset)
+inline unsigned long long misc_find_next_set_bit(const void *vaddr,
+						 unsigned long long size,
+						 unsigned long long offset)
 {
-    const __u8 *addr = vaddr;
-    const __u8 *p = addr + (offset >> 3);
-    int bit = offset & 7;
-    unsigned long long res;
-
-    if (offset >= size)
-        return size;
-
-    if (bit) {
-        /* Look for zero in first char */
-        for (res = bit; res < 8; res++)
-            if (misc_test_bit (res, p))
-                return res + (p - addr) * 8;
-        p++;
-    }
-    /* No set bit yet, search remaining full bytes for a 1 */
-    res = misc_find_first_set_bit (p, size - 8 * (p - addr));
-    return res + (p - addr) * 8;
+	const __u8 *addr = vaddr;
+	const __u8 *p = addr + (offset >> 3);
+	int bit = offset & 7;
+	unsigned long long res;
+
+	if (offset >= size)
+		return size;
+
+	if (bit) {
+		/* Look for zero in first char */
+		for (res = bit; res < 8; res++)
+			if (misc_test_bit(res, p))
+				return res + (p - addr) * 8;
+		p++;
+	}
+	/* No set bit yet, search remaining full bytes for a 1 */
+	res = misc_find_first_set_bit(p, size - 8 * (p - addr));
+	return res + (p - addr) * 8;
 }
 
-int user_confirmed (FILE * fp, char * q, char * yes) {
-    char * answer = 0;
-    size_t n = 0;
+int user_confirmed(FILE * fp, char *q, char *yes)
+{
+	char *answer = 0;
+	size_t n = 0;
 
-    fprintf (fp, "%s", q);
-    if (getline (&answer, &n, stdin) != (ssize_t)strlen (yes) || strcmp (yes, answer))
-	return 0;
+	fprintf(fp, "%s", q);
+	if (getline(&answer, &n, stdin) != (ssize_t) strlen(yes)
+	    || strcmp(yes, answer))
+		return 0;
 
-    return 1;
+	return 1;
 }
diff --git a/lib/parse_time.c b/lib/parse_time.c
index 28f33bf..13acca6 100644
--- a/lib/parse_time.c
+++ b/lib/parse_time.c
@@ -17,7 +17,7 @@ time_t parse_time(char *str)
 	if (strcmp(str, "now") == 0) {
 		return (time(0));
 	}
-	memset(&ts, 0, sizeof (ts));
+	memset(&ts, 0, sizeof(ts));
 #ifdef HAVE_STRPTIME
 	strptime(str, "%Y%m%d%H%M%S", &ts);
 #else
@@ -32,6 +32,6 @@ time_t parse_time(char *str)
 #endif
 	if (ts.tm_mday == 0)
 		reiserfs_warning(stderr, "Couldn't parse date/time "
-		                 "specifier: %s", str);
+				 "specifier: %s", str);
 	return (mktime(&ts));
 }
diff --git a/lib/progbar.c b/lib/progbar.c
index 9ecc803..8052635 100644
--- a/lib/progbar.c
+++ b/lib/progbar.c
@@ -8,19 +8,18 @@
 static char bar[128], spaces[128];
 static const char spinner[] = "\\|/-";
 
-void progbar_init(struct progbar *ctx, const char *units, FILE *fp)
+void progbar_init(struct progbar *ctx, const char *units, FILE * fp)
 {
-	memset(ctx, 0, sizeof (*ctx));
+	memset(ctx, 0, sizeof(*ctx));
 	if (!bar[0])
-		memset(bar, '=', sizeof(bar)-1);
+		memset(bar, '=', sizeof(bar) - 1);
 	if (!spaces[0])
-		memset(spaces, ' ', sizeof(spaces)-1);
+		memset(spaces, ' ', sizeof(spaces) - 1);
 	strncpy(ctx->units, units, sizeof(ctx->units));
 	ctx->file = fp;
 }
 
-
-void progbar_clear(struct progbar * ctx)
+void progbar_clear(struct progbar *ctx)
 {
 	if (!(ctx->flags & E2F_FLAG_PROG_BAR))
 		return;
@@ -30,17 +29,17 @@ void progbar_clear(struct progbar * ctx)
 	ctx->flags &= ~E2F_FLAG_PROG_BAR;
 }
 
-int progbar_update(struct progbar * ctx, const char *label, int curr, int max,
-                           unsigned int dpynum)
+int progbar_update(struct progbar *ctx, const char *label, int curr, int max,
+		   unsigned int dpynum)
 {
-	int	i;
-	unsigned int	tick;
-	struct timeval	tv;
+	int i;
+	unsigned int tick;
+	struct timeval tv;
 	int dpywidth;
 	int fixed_percent;
 	assert (curr >= 0);
 	assert (max > 0);
-	float percent = ((float) curr) / ((float) max) * 100;
+	float percent = ((float)curr) / ((float)max) * 100;
 
 	if (ctx->flags & E2F_FLAG_PROG_SUPPRESS)
 		return 0;
@@ -50,7 +49,7 @@ int progbar_update(struct progbar * ctx, const char *label, int curr, int max,
 	 * percentage hasn't changed, then we skip out right
 	 * away.
 	 */
-	fixed_percent = (int) ((10 * percent) + 0.5);
+	fixed_percent = (int)((10 * percent) + 0.5);
 	if (ctx->progress_last_percent == fixed_percent)
 		return 0;
 	ctx->progress_last_percent = fixed_percent;
@@ -71,7 +70,7 @@ int progbar_update(struct progbar * ctx, const char *label, int curr, int max,
 	 * Advance the spinner, and note that the progress bar
 	 * will be on the screen
 	 */
-	ctx->progress_pos = (ctx->progress_pos+1) & 3;
+	ctx->progress_pos = (ctx->progress_pos + 1) & 3;
 	ctx->flags |= E2F_FLAG_PROG_BAR;
 
 	dpywidth = 66 - strlen(label);
@@ -81,8 +80,8 @@ int progbar_update(struct progbar * ctx, const char *label, int curr, int max,
 
 	i = ((percent * dpywidth) + 50) / 100;
 	fprintf(ctx->file, "\r%s: |%s%s", label,
-	       bar + (sizeof(bar) - (i+1)),
-	       spaces + (sizeof(spaces) - (dpywidth - i + 1)));
+		bar + (sizeof(bar) - (i + 1)),
+		spaces + (sizeof(spaces) - (dpywidth - i + 1)));
 	if (fixed_percent == 1000)
 		fputc('|', ctx->file);
 	else
@@ -100,21 +99,18 @@ int progbar_update(struct progbar * ctx, const char *label, int curr, int max,
 	return 0;
 }
 
-void
-spinner_init(struct spinner *ctx, FILE *fp)
+void spinner_init(struct spinner *ctx, FILE * fp)
 {
-	memset(ctx, 0, sizeof (*ctx));
+	memset(ctx, 0, sizeof(*ctx));
 	ctx->file = fp;
 }
 
-void
-spinner_touch(struct spinner *ctx)
+void spinner_touch(struct spinner *ctx)
 {
 	fprintf(ctx->file, "%c", spinner[ctx->count++ % 4]);
 }
 
-void
-spinner_clear(struct spinner *ctx)
+void spinner_clear(struct spinner *ctx)
 {
 	fputs("", ctx->file);
 }
diff --git a/mkreiserfs/mkreiserfs.c b/mkreiserfs/mkreiserfs.c
index f0fe473..ed3b37d 100644
--- a/mkreiserfs/mkreiserfs.c
+++ b/mkreiserfs/mkreiserfs.c
@@ -34,447 +34,446 @@
 #  include <uuid/uuid.h>
 #endif
 
-
 char *program_name;
 
-static void message( const char * fmt, ... ) 
-	__attribute__ ((format (printf, 1, 2)));
-
-static void message( const char * fmt, ... ) {
-    char *buf;
-    va_list args;
-	
-    buf = NULL;
-    va_start( args, fmt );
-    vasprintf( &buf, fmt, args );
-    va_end( args );
-
-    if( buf ) {
-	    fprintf( stderr, "%s: %s\n", program_name, buf );
-	    free( buf );
-    }
+static void message(const char *fmt, ...)
+    __attribute__ ((format(printf, 1, 2)));
+
+static void message(const char *fmt, ...)
+{
+	char *buf;
+	va_list args;
+
+	buf = NULL;
+	va_start(args, fmt);
+	vasprintf(&buf, fmt, args);
+	va_end(args);
+
+	if (buf) {
+		fprintf(stderr, "%s: %s\n", program_name, buf);
+		free(buf);
+	}
 }
 
 static void print_usage_and_exit(void)
 {
-    fprintf(stderr, "Usage: %s [options] "
-	" device [block-count]\n"
-	"\n"
-	"Options:\n\n"
-	"  -b | --block-size N              size of file-system block, in bytes\n"
-	"  -j | --journal-device FILE       path to separate device to hold journal\n"
-	"  -s | --journal-size N            size of the journal in blocks\n"
-	"  -o | --journal-offset N          offset of the journal from the start of\n"
-	"                                   the separate device, in blocks\n"
-	"  -t | --transaction-max-size N    maximal size of transaction, in blocks\n"
-	"  -B | --badblocks file            store all bad blocks given in file on the fs\n"
-	"  -h | --hash rupasov|tea|r5       hash function to use by default\n"
-	"  -u | --uuid UUID                 store UUID in the superblock\n"
-	"  -l | --label LABEL               store LABEL in the superblock\n"
-	"  --format 3.5|3.6                 old 3.5 format or newer 3.6\n"
-	"  -f | --force                     specified once, make mkreiserfs the whole\n"
-	"                                   disk, not block device or mounted partition;\n"
-	"                                   specified twice, do not ask for confirmation\n"
-	"  -q | --quiet                     quiet work without messages, progress and\n"
-	"                                   questions. Useful if run in a script. For use\n" 
-	"                                   by end users only.\n"
-	"  -d | --debug                     print debugging information during mkreiser\n"
-	"  -V                               print version and exit\n",
-	program_name);
-    exit (1);
+	fprintf(stderr, "Usage: %s [options] "
+		" device [block-count]\n"
+		"\n"
+		"Options:\n\n"
+		"  -b | --block-size N              size of file-system block, in bytes\n"
+		"  -j | --journal-device FILE       path to separate device to hold journal\n"
+		"  -s | --journal-size N            size of the journal in blocks\n"
+		"  -o | --journal-offset N          offset of the journal from the start of\n"
+		"                                   the separate device, in blocks\n"
+		"  -t | --transaction-max-size N    maximal size of transaction, in blocks\n"
+		"  -B | --badblocks file            store all bad blocks given in file on the fs\n"
+		"  -h | --hash rupasov|tea|r5       hash function to use by default\n"
+		"  -u | --uuid UUID                 store UUID in the superblock\n"
+		"  -l | --label LABEL               store LABEL in the superblock\n"
+		"  --format 3.5|3.6                 old 3.5 format or newer 3.6\n"
+		"  -f | --force                     specified once, make mkreiserfs the whole\n"
+		"                                   disk, not block device or mounted partition;\n"
+		"                                   specified twice, do not ask for confirmation\n"
+		"  -q | --quiet                     quiet work without messages, progress and\n"
+		"                                   questions. Useful if run in a script. For use\n"
+		"                                   by end users only.\n"
+		"  -d | --debug                     print debugging information during mkreiser\n"
+		"  -V                               print version and exit\n",
+		program_name);
+	exit(1);
 }
 
-
 int Create_default_journal = 1;
 int Block_size = 4096;
 
 /* size of journal + 1 block for journal header */
 unsigned long Journal_size = 0;
-int Max_trans_size = 0; //JOURNAL_TRANS_MAX;
+int Max_trans_size = 0;		//JOURNAL_TRANS_MAX;
 int Hash = DEFAULT_HASH;
 int Offset = 0;
-char * Format;
+char *Format;
 unsigned char UUID[16];
-char * LABEL = NULL;
-char * badblocks_file;
+char *LABEL = NULL;
+char *badblocks_file;
 
 enum mkfs_mode {
-    DEBUG_MODE = 1 << 0,
-    QUIET_MODE = 1 << 1,
-    DO_NOTHING = 1 << 2
+	DEBUG_MODE = 1 << 0,
+	QUIET_MODE = 1 << 1,
+	DO_NOTHING = 1 << 2
 };
 
 int mode;
 
 /* form super block (old one) */
-static void make_super_block (reiserfs_filsys_t * fs)
+static void make_super_block(reiserfs_filsys_t *fs)
 {
-    set_sb_umount_state (fs->fs_ondisk_sb, FS_CLEANLY_UMOUNTED);
-    set_sb_tree_height (fs->fs_ondisk_sb, 2);
-    set_sb_hash_code (fs->fs_ondisk_sb, Hash);
-    if (fs->fs_format == REISERFS_FORMAT_3_6) {
+	set_sb_umount_state(fs->fs_ondisk_sb, FS_CLEANLY_UMOUNTED);
+	set_sb_tree_height(fs->fs_ondisk_sb, 2);
+	set_sb_hash_code(fs->fs_ondisk_sb, Hash);
+	if (fs->fs_format == REISERFS_FORMAT_3_6) {
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-        if (uuid_is_null(UUID))
-	    uuid_generate(UUID);
+		if (uuid_is_null(UUID))
+			uuid_generate(UUID);
 
-	memcpy (fs->fs_ondisk_sb->s_uuid, UUID, 16);
+		memcpy(fs->fs_ondisk_sb->s_uuid, UUID, 16);
 #endif
-	if (LABEL != NULL) {
-	    if (strlen (LABEL) > 16)
-	        reiserfs_warning (stderr, "\nSpecified LABEL is longer then 16 "
-		"characters, will be truncated\n\n");
-	    strncpy (fs->fs_ondisk_sb->s_label, LABEL, 16);
-	}
-	set_sb_v2_flag (fs->fs_ondisk_sb, reiserfs_attrs_cleared);
-    }
-
-    if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb) ||
-	strcmp (fs->fs_file_name, fs->fs_j_file_name))
-	/* either standard journal (and we leave all new fields to be 0) or
-	   journal is created on separate device so there is no space on data
-	   device which can be used as a journal */
-	set_sb_reserved_for_journal (fs->fs_ondisk_sb, 0);
-    else
-	set_sb_reserved_for_journal (fs->fs_ondisk_sb,
-		get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)) + 1);
-
-    if (fs->fs_badblocks_bm)
-	set_sb_free_blocks(fs->fs_ondisk_sb, get_sb_free_blocks(fs->fs_ondisk_sb) - 
-			   fs->fs_badblocks_bm->bm_set_bits);
-}
+		if (LABEL != NULL) {
+			if (strlen(LABEL) > 16)
+				reiserfs_warning(stderr,
+						 "\nSpecified LABEL is longer then 16 "
+						 "characters, will be truncated\n\n");
+			strncpy(fs->fs_ondisk_sb->s_label, LABEL, 16);
+		}
+		set_sb_v2_flag(fs->fs_ondisk_sb, reiserfs_attrs_cleared);
+	}
 
+	if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb) ||
+	    strcmp(fs->fs_file_name, fs->fs_j_file_name))
+		/* either standard journal (and we leave all new fields to be 0) or
+		   journal is created on separate device so there is no space on data
+		   device which can be used as a journal */
+		set_sb_reserved_for_journal(fs->fs_ondisk_sb, 0);
+	else
+		set_sb_reserved_for_journal(fs->fs_ondisk_sb,
+					    get_jp_journal_size(sb_jp
+								(fs->
+								 fs_ondisk_sb))
+					    + 1);
+
+	if (fs->fs_badblocks_bm)
+		set_sb_free_blocks(fs->fs_ondisk_sb,
+				   get_sb_free_blocks(fs->fs_ondisk_sb) -
+				   fs->fs_badblocks_bm->bm_set_bits);
+}
 
 /* wipe out first 64 k of a device and both possible reiserfs super block */
-static void invalidate_other_formats (int dev)
+static void invalidate_other_formats(int dev)
 {
-    struct buffer_head * bh;
-    
-    bh = bread (dev, 0, 64 * 1024);
-    if (!bh) {
-	    reiserfs_exit(1, "Unable to read first blocks of the device");
-    }
+	struct buffer_head *bh;
+
+	bh = bread(dev, 0, 64 * 1024);
+	if (!bh) {
+		reiserfs_exit(1, "Unable to read first blocks of the device");
+	}
 #if defined(__sparc__) || defined(__sparc_v9__)
-    memset (bh->b_data + 1024, 0, bh->b_size - 1024);
+	memset(bh->b_data + 1024, 0, bh->b_size - 1024);
 #else
-    memset (bh->b_data, 0, bh->b_size);
+	memset(bh->b_data, 0, bh->b_size);
 #endif
-    mark_buffer_uptodate (bh, 1);
-    mark_buffer_dirty (bh);
-    bwrite (bh);
-    brelse (bh);
+	mark_buffer_uptodate(bh, 1);
+	mark_buffer_dirty(bh);
+	bwrite(bh);
+	brelse(bh);
 }
 
-
-void zero_journal (reiserfs_filsys_t * fs)
+void zero_journal(reiserfs_filsys_t *fs)
 {
-    unsigned long start, len, done;
-    struct buffer_head * bh;
-    unsigned int i;
+	unsigned long start, len, done;
+	struct buffer_head *bh;
+	unsigned int i;
 
-    fprintf (stdout, "Initializing journal - ");
+	fprintf(stdout, "Initializing journal - ");
 
-    start = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));
-    len = get_jp_journal_size (sb_jp (fs->fs_ondisk_sb));
+	start = get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb));
+	len = get_jp_journal_size(sb_jp(fs->fs_ondisk_sb));
 
-    done = 0;
-    for (i = 0; i < len; i ++) {
-        print_how_far (stdout, &done, len, 1, 1/*be quiet*/);
-        bh = getblk (fs->fs_journal_dev, start + i, fs->fs_blocksize);
-	if (!bh) {
-		reiserfs_exit(1, "zero_journal: getblk failed");
+	done = 0;
+	for (i = 0; i < len; i++) {
+		print_how_far(stdout, &done, len, 1, 1 /*be quiet */ );
+		bh = getblk(fs->fs_journal_dev, start + i, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_exit(1, "zero_journal: getblk failed");
+		}
+		memset(bh->b_data, 0, bh->b_size);
+		mark_buffer_dirty(bh);
+		mark_buffer_uptodate(bh, 1);
+		bwrite(bh);
+		brelse(bh);
 	}
-        memset (bh->b_data, 0, bh->b_size);
-        mark_buffer_dirty (bh);
-        mark_buffer_uptodate (bh, 1);
-        bwrite (bh);
-        brelse (bh);
-    }
 
-    fprintf (stdout, "\n");
-    fflush (stdout);
+	fprintf(stdout, "\n");
+	fflush(stdout);
 }
 
-
 /* this only sets few first bits in bitmap block. Fills not initialized fields
    of super block (root block and bitmap block numbers) */
-static void make_bitmap (reiserfs_filsys_t * fs) {
-    struct reiserfs_super_block * sb = fs->fs_ondisk_sb;
-    unsigned int i;
-    unsigned long block;
-    int marked;
-    
-    marked = 0;
-
-    /* mark skipped area and super block */
-    for (i = 0; i <= fs->fs_super_bh->b_blocknr; i ++) {
-	reiserfs_bitmap_set_bit (fs->fs_bitmap2, i);
-	marked ++;
-    }
-    
-    if (fs->fs_badblocks_bm) {
-	for (i = 0; i < get_sb_block_count (sb); i ++) {
-	    if (reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i)) {
-		reiserfs_bitmap_set_bit (fs->fs_bitmap2, i);
-		marked ++;
-	    }
-	}
-    }
-
-    /* mark bitmaps as used */
-    block = fs->fs_super_bh->b_blocknr + 1;
-
-    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
-	reiserfs_bitmap_set_bit (fs->fs_bitmap2, block);
-	marked ++;
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * 
-		    (fs->fs_blocksize * 8);
-	else
-	    block ++;
-    }
-
-    if (!get_size_of_journal_or_reserved_area (fs->fs_ondisk_sb))
-	/* root block follows directly super block and first bitmap */
-	block = fs->fs_super_bh->b_blocknr + 1 + 1;
-    else {
-	/* makr journal blocks as used */
-	for (i = 0; i <= get_jp_journal_size (sb_jp (sb)); i ++) {
-	    reiserfs_bitmap_set_bit (fs->fs_bitmap2,
-				     i + get_jp_journal_1st_block (sb_jp (sb)));
-	    marked ++;
-	}
-	block = get_jp_journal_1st_block (sb_jp (sb)) + i;
-    }
-
-    /*get correct block - not journal nor bitmap*/
-    while (block_of_journal (fs, block) || block_of_bitmap (fs, block)) {
-	block++;
-    }
-
-    while ((block < get_sb_block_count (sb)) && 
-	   reiserfs_bitmap_test_bit (fs->fs_bitmap2, block)) 
-    {
-    	block++;
-    }
-
-    if (block >= get_sb_block_count (sb))
-    	reiserfs_exit(1, "mkreiserfs: too many bad blocks");
-
-    reiserfs_bitmap_set_bit (fs->fs_bitmap2, block);
-    marked ++;
-
-    set_sb_root_block (sb, block);
-    set_sb_free_blocks (sb, get_sb_block_count (sb) - marked);
-}
+static void make_bitmap(reiserfs_filsys_t *fs)
+{
+	struct reiserfs_super_block *sb = fs->fs_ondisk_sb;
+	unsigned int i;
+	unsigned long block;
+	int marked;
 
+	marked = 0;
 
-static void set_root_dir_nlink (struct item_head * ih, void * sd)
-{
-    __u32 nlink;
+	/* mark skipped area and super block */
+	for (i = 0; i <= fs->fs_super_bh->b_blocknr; i++) {
+		reiserfs_bitmap_set_bit(fs->fs_bitmap2, i);
+		marked++;
+	}
+
+	if (fs->fs_badblocks_bm) {
+		for (i = 0; i < get_sb_block_count(sb); i++) {
+			if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i)) {
+				reiserfs_bitmap_set_bit(fs->fs_bitmap2, i);
+				marked++;
+			}
+		}
+	}
+
+	/* mark bitmaps as used */
+	block = fs->fs_super_bh->b_blocknr + 1;
+
+	for (i = 0; i < reiserfs_fs_bmap_nr(fs); i++) {
+		reiserfs_bitmap_set_bit(fs->fs_bitmap2, block);
+		marked++;
+		if (spread_bitmaps(fs))
+			block = (block / (fs->fs_blocksize * 8) + 1) *
+			    (fs->fs_blocksize * 8);
+		else
+			block++;
+	}
+
+	if (!get_size_of_journal_or_reserved_area(fs->fs_ondisk_sb))
+		/* root block follows directly super block and first bitmap */
+		block = fs->fs_super_bh->b_blocknr + 1 + 1;
+	else {
+		/* makr journal blocks as used */
+		for (i = 0; i <= get_jp_journal_size(sb_jp(sb)); i++) {
+			reiserfs_bitmap_set_bit(fs->fs_bitmap2,
+						i +
+						get_jp_journal_1st_block(sb_jp
+									 (sb)));
+			marked++;
+		}
+		block = get_jp_journal_1st_block(sb_jp(sb)) + i;
+	}
 
-    nlink = 3;
-    set_sd_nlink (ih, sd, &nlink);
+	/*get correct block - not journal nor bitmap */
+	while (block_of_journal(fs, block) || block_of_bitmap(fs, block)) {
+		block++;
+	}
+
+	while ((block < get_sb_block_count(sb)) &&
+	       reiserfs_bitmap_test_bit(fs->fs_bitmap2, block)) {
+		block++;
+	}
+
+	if (block >= get_sb_block_count(sb))
+		reiserfs_exit(1, "mkreiserfs: too many bad blocks");
+
+	reiserfs_bitmap_set_bit(fs->fs_bitmap2, block);
+	marked++;
+
+	set_sb_root_block(sb, block);
+	set_sb_free_blocks(sb, get_sb_block_count(sb) - marked);
 }
 
+static void set_root_dir_nlink(struct item_head *ih, void *sd)
+{
+	__u32 nlink;
+
+	nlink = 3;
+	set_sd_nlink(ih, sd, &nlink);
+}
 
 /* form the root block of the tree (the block head, the item head, the
    root directory) */
-static void make_root_block (reiserfs_filsys_t * fs)
+static void make_root_block(reiserfs_filsys_t *fs)
 {
-    struct reiserfs_super_block * sb;
-    struct buffer_head * bh;
+	struct reiserfs_super_block *sb;
+	struct buffer_head *bh;
 
+	sb = fs->fs_ondisk_sb;
+	/* get memory for root block */
+	bh = getblk(fs->fs_dev, get_sb_root_block(sb), get_sb_block_size(sb));
 
-    sb = fs->fs_ondisk_sb;
-    /* get memory for root block */
-    bh = getblk (fs->fs_dev, get_sb_root_block (sb), get_sb_block_size (sb));
-    
-    if (!bh) {
-	    reiserfs_exit(1, "getblk failed");
-    }
+	if (!bh) {
+		reiserfs_exit(1, "getblk failed");
+	}
 
-    mark_buffer_uptodate (bh, 1);
+	mark_buffer_uptodate(bh, 1);
 
-    make_empty_leaf (bh);
-    make_sure_root_dir_exists (fs, set_root_dir_nlink, 0);
-    brelse (bh);
+	make_empty_leaf(bh);
+	make_sure_root_dir_exists(fs, set_root_dir_nlink, 0);
+	brelse(bh);
 
-    mark_objectid_used (fs, REISERFS_ROOT_PARENT_OBJECTID);
-    mark_objectid_used (fs, REISERFS_ROOT_OBJECTID);
+	mark_objectid_used(fs, REISERFS_ROOT_PARENT_OBJECTID);
+	mark_objectid_used(fs, REISERFS_ROOT_OBJECTID);
 }
 
-
-
-static void report (reiserfs_filsys_t * fs, char * j_filename)
+static void report(reiserfs_filsys_t *fs, char *j_filename)
 {
 //    print_block (stdout, fs, fs->fs_super_bh);
-    struct reiserfs_super_block * sb = 
-	(struct reiserfs_super_block *)(fs->fs_super_bh->b_data);
-
-    struct stat st;
-    dev_t rdev;
-
-    if (!is_any_reiserfs_magic_string (sb))
-	    return;
-
-    if (fstat (fs->fs_super_bh->b_dev, &st) == -1) {
-	    /*reiserfs_warning (stderr, "fstat failed: %s\n", strerror(errno));*/
-	    rdev = 0;
-    } else	
-	    rdev = st.st_rdev;
-
-    if (mode & DEBUG_MODE) {
-	    reiserfs_warning (stdout, "Block %lu (0x%x) contains super block. ",
-			      fs->fs_super_bh->b_blocknr, rdev);
-    }
-    switch (get_reiserfs_format (sb)) {
-    case REISERFS_FORMAT_3_5:
-	    reiserfs_warning (stdout, " Format 3.5 with ");
-	    break;
-    case REISERFS_FORMAT_3_6:
-	    reiserfs_warning (stdout, "Format 3.6 with ");
-	    break;
-    }
-    if (is_reiserfs_jr_magic_string (sb))
-	    reiserfs_warning (stdout, "non-");
-    reiserfs_warning (stdout, "standard journal\n");
-    reiserfs_warning (stdout, "Count of blocks on the device: %u\n", 
-		      get_sb_block_count (sb));
-    reiserfs_warning (stdout, "Number of blocks consumed by mkreiserfs "
-		      "formatting process: %u\n", get_sb_block_count (sb) 
-		      - get_sb_free_blocks (sb));
-    if (mode & DEBUG_MODE)
-	    reiserfs_warning (stdout, "Free blocks: %u\n", 
-			      get_sb_free_blocks (sb));
-    reiserfs_warning (stdout, "Blocksize: %d\n", get_sb_block_size (sb));
-    reiserfs_warning (stdout, "Hash function used to sort names: %s\n",
-		      code2name (get_sb_hash_code (sb)));
-    if (mode & DEBUG_MODE) {
-        reiserfs_warning (stdout, "Number of bitmaps: %u", get_sb_bmap_nr (sb));
-	if (get_sb_bmap_nr(sb) != reiserfs_fs_bmap_nr(fs))
-		reiserfs_warning(stdout, " (really uses %u)",
-		                 reiserfs_fs_bmap_nr(fs));
-        reiserfs_warning (stdout, "\nRoot block: %u\n", get_sb_root_block (sb));
-        reiserfs_warning (stdout, "Tree height: %d\n", get_sb_tree_height (sb));
-        reiserfs_warning (stdout, "Objectid map size %d, max %d\n", 
-			  get_sb_oid_cursize (sb), get_sb_oid_maxsize (sb));
-        reiserfs_warning (stdout, "Journal parameters:\n");
-        print_journal_params (stdout, sb_jp (sb));
-    } else {
-        if (j_filename && strcmp (j_filename, fs->fs_file_name)) 
-		reiserfs_warning (stdout, "Journal Device [0x%x]\n", 
-				  get_jp_journal_dev (sb_jp (sb)));
-	
-        reiserfs_warning (stdout, "Journal Size %u blocks (first block %u)\n",
-			  get_jp_journal_size (sb_jp (sb)) + 1,
-			  get_jp_journal_1st_block (sb_jp (sb)));
-        reiserfs_warning (stdout, "Journal Max transaction length %u\n", 
-			  get_jp_journal_max_trans_len (sb_jp (sb)));
-    }
-
-    if (j_filename && strcmp (j_filename, fs->fs_file_name)) {
-	    reiserfs_warning (stdout, "Space on this device reserved by journal: "
-			      "%u\n", get_sb_reserved_for_journal (sb));
-    }
-    
-    if (mode & DEBUG_MODE) {
-	reiserfs_warning (stdout, "Filesystem state 0x%x\n", 
-			  get_sb_fs_state (sb));
-	reiserfs_warning (stdout, "sb_version %u\n", 
-			  get_sb_version (sb));
-    }
-
-    if (get_reiserfs_format (sb) == REISERFS_FORMAT_3_6) {
-        reiserfs_warning (stdout, "inode generation number: %u\n", 
-			  get_sb_v2_inode_generation (sb));
-        reiserfs_warning (stdout, "UUID: %U\n", sb->s_uuid);
-        if (strcmp (sb->s_label, ""))
-		reiserfs_warning (stdout, "LABEL: %s\n", sb->s_label);
-    }
-
-    return;
-}
+	struct reiserfs_super_block *sb =
+	    (struct reiserfs_super_block *)(fs->fs_super_bh->b_data);
 
+	struct stat st;
+	dev_t rdev;
 
+	if (!is_any_reiserfs_magic_string(sb))
+		return;
 
+	if (fstat(fs->fs_super_bh->b_dev, &st) == -1) {
+		/*reiserfs_warning (stderr, "fstat failed: %s\n", strerror(errno)); */
+		rdev = 0;
+	} else
+		rdev = st.st_rdev;
 
-static void set_hash_function (char * str)
-{
-    if (!strcmp (str, "tea"))
-	    Hash = TEA_HASH;
-    else if (!strcmp (str, "rupasov"))
-	    Hash = YURA_HASH;
-    else if (!strcmp (str, "r5"))
-	    Hash = R5_HASH;
-    else
-	    message("wrong hash type specified. Using default");
-}
+	if (mode & DEBUG_MODE) {
+		reiserfs_warning(stdout,
+				 "Block %lu (0x%x) contains super block. ",
+				 fs->fs_super_bh->b_blocknr, rdev);
+	}
+	switch (get_reiserfs_format(sb)) {
+	case REISERFS_FORMAT_3_5:
+		reiserfs_warning(stdout, " Format 3.5 with ");
+		break;
+	case REISERFS_FORMAT_3_6:
+		reiserfs_warning(stdout, "Format 3.6 with ");
+		break;
+	}
+	if (is_reiserfs_jr_magic_string(sb))
+		reiserfs_warning(stdout, "non-");
+	reiserfs_warning(stdout, "standard journal\n");
+	reiserfs_warning(stdout, "Count of blocks on the device: %u\n",
+			 get_sb_block_count(sb));
+	reiserfs_warning(stdout, "Number of blocks consumed by mkreiserfs "
+			 "formatting process: %u\n", get_sb_block_count(sb)
+			 - get_sb_free_blocks(sb));
+	if (mode & DEBUG_MODE)
+		reiserfs_warning(stdout, "Free blocks: %u\n",
+				 get_sb_free_blocks(sb));
+	reiserfs_warning(stdout, "Blocksize: %d\n", get_sb_block_size(sb));
+	reiserfs_warning(stdout, "Hash function used to sort names: %s\n",
+			 code2name(get_sb_hash_code(sb)));
+	if (mode & DEBUG_MODE) {
+		reiserfs_warning(stdout, "Number of bitmaps: %u",
+				 get_sb_bmap_nr(sb));
+		if (get_sb_bmap_nr(sb) != reiserfs_fs_bmap_nr(fs))
+			reiserfs_warning(stdout, " (really uses %u)",
+					 reiserfs_fs_bmap_nr(fs));
+		reiserfs_warning(stdout, "\nRoot block: %u\n",
+				 get_sb_root_block(sb));
+		reiserfs_warning(stdout, "Tree height: %d\n",
+				 get_sb_tree_height(sb));
+		reiserfs_warning(stdout, "Objectid map size %d, max %d\n",
+				 get_sb_oid_cursize(sb),
+				 get_sb_oid_maxsize(sb));
+		reiserfs_warning(stdout, "Journal parameters:\n");
+		print_journal_params(stdout, sb_jp(sb));
+	} else {
+		if (j_filename && strcmp(j_filename, fs->fs_file_name))
+			reiserfs_warning(stdout, "Journal Device [0x%x]\n",
+					 get_jp_journal_dev(sb_jp(sb)));
+
+		reiserfs_warning(stdout,
+				 "Journal Size %u blocks (first block %u)\n",
+				 get_jp_journal_size(sb_jp(sb)) + 1,
+				 get_jp_journal_1st_block(sb_jp(sb)));
+		reiserfs_warning(stdout, "Journal Max transaction length %u\n",
+				 get_jp_journal_max_trans_len(sb_jp(sb)));
+	}
+
+	if (j_filename && strcmp(j_filename, fs->fs_file_name)) {
+		reiserfs_warning(stdout,
+				 "Space on this device reserved by journal: "
+				 "%u\n", get_sb_reserved_for_journal(sb));
+	}
+
+	if (mode & DEBUG_MODE) {
+		reiserfs_warning(stdout, "Filesystem state 0x%x\n",
+				 get_sb_fs_state(sb));
+		reiserfs_warning(stdout, "sb_version %u\n", get_sb_version(sb));
+	}
+
+	if (get_reiserfs_format(sb) == REISERFS_FORMAT_3_6) {
+		reiserfs_warning(stdout, "inode generation number: %u\n",
+				 get_sb_v2_inode_generation(sb));
+		reiserfs_warning(stdout, "UUID: %U\n", sb->s_uuid);
+		if (strcmp(sb->s_label, ""))
+			reiserfs_warning(stdout, "LABEL: %s\n", sb->s_label);
+	}
 
+	return;
+}
 
-static void set_reiserfs_version (char * str)
+static void set_hash_function(char *str)
 {
-    if (!strcmp (str, "3.5"))
-	    Format = "3.5";
-    else  {
-	    Format = "3.6";
-	    if (strcmp (str, "3.6"))
-		    message("wrong reiserfs version specified. "
-			    "Using default 3.6 format");
-    }
+	if (!strcmp(str, "tea"))
+		Hash = TEA_HASH;
+	else if (!strcmp(str, "rupasov"))
+		Hash = YURA_HASH;
+	else if (!strcmp(str, "r5"))
+		Hash = R5_HASH;
+	else
+		message("wrong hash type specified. Using default");
 }
 
-static int str2int (char * str)
+static void set_reiserfs_version(char *str)
 {
-    int val;
-    char * tmp;
-
-    val = (int) strtol (str, &tmp, 0);
-    
-    if (*tmp) {
-	reiserfs_exit (1, "%s: strtol is unable to make an integer of %s\n",
-		       program_name, str);
-    }
-    
-    return val;
+	if (!strcmp(str, "3.5"))
+		Format = "3.5";
+	else {
+		Format = "3.6";
+		if (strcmp(str, "3.6"))
+			message("wrong reiserfs version specified. "
+				"Using default 3.6 format");
+	}
 }
 
-static __u64 str2u64 (char *str)
+static int str2int(char *str)
 {
-    __u64 val;
-    char *tmp;
+	int val;
+	char *tmp;
 
-    val = (__u64)strtoll(str, &tmp, 0);
+	val = (int)strtol(str, &tmp, 0);
 
-    if (*tmp) {
-	reiserfs_exit (1, "%s: strtoll is unable to make an integer of %s\n",
-		       program_name, str);
-    }
+	if (*tmp) {
+		reiserfs_exit(1,
+			      "%s: strtol is unable to make an integer of %s\n",
+			      program_name, str);
+	}
 
-    return val;
+	return val;
 }
 
-
-static void set_block_size (char * str, int *b_size)
+static __u64 str2u64(char *str)
 {
-    *b_size = str2int (str);
-      
-    if (!is_blocksize_correct (*b_size))
-        reiserfs_exit (1, "%s: wrong blocksize %s specified, "
-		       "only power of 2 from 512-8192 interval "
-		       "are supported", program_name, str);
-}
+	__u64 val;
+	char *tmp;
+
+	val = (__u64) strtoll(str, &tmp, 0);
 
+	if (*tmp) {
+		reiserfs_exit(1,
+			      "%s: strtoll is unable to make an integer of %s\n",
+			      program_name, str);
+	}
+
+	return val;
+}
 
-static void set_transaction_max_size (char * str)
+static void set_block_size(char *str, int *b_size)
 {
-	Max_trans_size = str2int( str );
+	*b_size = str2int(str);
+
+	if (!is_blocksize_correct(*b_size))
+		reiserfs_exit(1, "%s: wrong blocksize %s specified, "
+			      "only power of 2 from 512-8192 interval "
+			      "are supported", program_name, str);
 }
 
+static void set_transaction_max_size(char *str)
+{
+	Max_trans_size = str2int(str);
+}
 
 /* reiserfs_create_journal will check this */
-static void set_journal_device_size (char * str)
+static void set_journal_device_size(char *str)
 {
-    Journal_size = str2int (str);
+	Journal_size = str2int(str);
 /*
     if (Journal_size < JOURNAL_MIN_SIZE)
 		die ("%s: wrong journal size specified: %lu. Should be at least %u",
@@ -483,96 +482,91 @@ static void set_journal_device_size (char * str)
 */
 }
 
-
 /* reiserfs_create_journal will check this */
-static void set_offset_in_journal_device (char * str)
+static void set_offset_in_journal_device(char *str)
 {
-	Offset = str2int( str );
+	Offset = str2int(str);
 }
 
-
-static int is_journal_default (char * name, char * jname, int blocksize)
+static int is_journal_default(char *name, char *jname, int blocksize)
 {
-    if (jname && strcmp (name, jname))
-	return 0;
-    
-    if (Journal_size && Journal_size != 
-	journal_default_size(REISERFS_DISK_OFFSET_IN_BYTES / blocksize, 
-			     blocksize) + 1)
-	/* journal size is set and it is not default size */
-	return 0;
-    
-    if (Max_trans_size && Max_trans_size != JOURNAL_TRANS_MAX)
-	return 0;
+	if (jname && strcmp(name, jname))
+		return 0;
+
+	if (Journal_size && Journal_size !=
+	    journal_default_size(REISERFS_DISK_OFFSET_IN_BYTES / blocksize,
+				 blocksize) + 1)
+		/* journal size is set and it is not default size */
+		return 0;
+
+	if (Max_trans_size && Max_trans_size != JOURNAL_TRANS_MAX)
+		return 0;
 
-    return 1;
+	return 1;
 }
 
-	
-		
 /* if running kernel is 2.2 - mkreiserfs creates 3.5 format, if 2.4 - 3.6,
    otherwise - mkreiserfs fails */
-static int select_format (void)
+static int select_format(void)
 {
 	struct utsname sysinfo;
 
 	if (Format) {
-		if (!strcmp (Format, "3.5"))
+		if (!strcmp(Format, "3.5"))
 			return REISERFS_FORMAT_3_5;
 
-		if (strcmp (Format, "3.6")) {
-			message ("Unknown fromat %s specified\n", Format);
-			exit (1);
+		if (strcmp(Format, "3.6")) {
+			message("Unknown fromat %s specified\n", Format);
+			exit(1);
 		}
 		return REISERFS_FORMAT_3_6;
 	}
-	
-	reiserfs_warning (stdout, "Guessing about desired format.. ");
-	
-	if (uname (&sysinfo) == -1) {
-		message ("could not get system info: %s", strerror(errno));
-		exit (1);
+
+	reiserfs_warning(stdout, "Guessing about desired format.. ");
+
+	if (uname(&sysinfo) == -1) {
+		message("could not get system info: %s", strerror(errno));
+		exit(1);
 	}
-	
+
 	reiserfs_warning(stdout, "Kernel %s is running.\n", sysinfo.release);
-	
-	if (strncmp (sysinfo.release, "2.4", 3) >= 0)
+
+	if (strncmp(sysinfo.release, "2.4", 3) >= 0)
 		return REISERFS_FORMAT_3_6;
 
-	if (strncmp (sysinfo.release, "2.2", 3)) {
-		message( "You should run either 2.2 or 2.4 or higher to be able "
-		    "to create reiserfs filesystem or specify desired format with --format");
-		exit (1);
+	if (strncmp(sysinfo.release, "2.2", 3)) {
+		message("You should run either 2.2 or 2.4 or higher to be able "
+			"to create reiserfs filesystem or specify desired format with --format");
+		exit(1);
 	}
 
-    reiserfs_warning(stdout, "Creating filesystem of format 3.5\n");
-    return REISERFS_FORMAT_3_5;
+	reiserfs_warning(stdout, "Creating filesystem of format 3.5\n");
+	return REISERFS_FORMAT_3_5;
 }
 
-
-int main (int argc, char **argv)
+int main(int argc, char **argv)
 {
-    reiserfs_filsys_t * fs;
-    int force = 0;
-    char * device_name = NULL;
-    char * jdevice_name = NULL;
-    __u64 fs_size = 0;
-    int c;
-    static int flag;
-
-    program_name = strrchr( argv[ 0 ], '/' );
-    
-    if (program_name)
-	program_name++;
-    else
-	program_name = argv[ 0 ];
-    
-    if (argc < 2)
-	print_usage_and_exit ();
-    
-    memset(UUID, 0, 16);
-    
-    while (1) {
+	reiserfs_filsys_t *fs;
+	int force = 0;
+	char *device_name = NULL;
+	char *jdevice_name = NULL;
+	__u64 fs_size = 0;
+	int c;
+	static int flag;
+
+	program_name = strrchr(argv[0], '/');
+
+	if (program_name)
+		program_name++;
+	else
+		program_name = argv[0];
+
+	if (argc < 2)
+		print_usage_and_exit();
+
+	memset(UUID, 0, 16);
+
+	while (1) {
 		static struct option options[] = {
 			{"block-size", required_argument, 0, 'b'},
 			{"journal-device", required_argument, 0, 'j'},
@@ -587,12 +581,12 @@ int main (int argc, char **argv)
 			{0, 0, 0, 0}
 		};
 		int option_index;
-      
-		c = getopt_long (argc, argv, "b:j:s:t:o:h:u:l:VfdB:q",
-						 options, &option_index);
+
+		c = getopt_long(argc, argv, "b:j:s:t:o:h:u:l:VfdB:q",
+				options, &option_index);
 		if (c == -1)
 			break;
-	
+
 		switch (c) {
 		case 0:
 			if (flag) {
@@ -600,40 +594,40 @@ int main (int argc, char **argv)
 				flag = 0;
 			}
 			break;
-		case 'b': /* --block-size */
-			set_block_size (optarg, &Block_size);
+		case 'b':	/* --block-size */
+			set_block_size(optarg, &Block_size);
 			break;
 
-		case 'j': /* --journal-device */
+		case 'j':	/* --journal-device */
 			Create_default_journal = 0;
 			jdevice_name = optarg;
 			break;
 
-		case 's': /* --journal-size */
+		case 's':	/* --journal-size */
 			Create_default_journal = 0;
-			set_journal_device_size (optarg);	    
+			set_journal_device_size(optarg);
 			break;
 
-		case 't': /* --transaction-max-size */
+		case 't':	/* --transaction-max-size */
 			Create_default_journal = 0;
-			set_transaction_max_size (optarg);
+			set_transaction_max_size(optarg);
 			break;
 
-		case 'o': /* --offset */
+		case 'o':	/* --offset */
 			Create_default_journal = 0;
-			set_offset_in_journal_device (optarg);
+			set_offset_in_journal_device(optarg);
 			break;
 
-		case 'B': /* --badblock-list */
-			asprintf (&badblocks_file, "%s", optarg);			
+		case 'B':	/* --badblock-list */
+			asprintf(&badblocks_file, "%s", optarg);
 			break;
-		
-		case 'h': /* --hash */
-			set_hash_function (optarg);
+
+		case 'h':	/* --hash */
+			set_hash_function(optarg);
 			break;
 
-		case 'v': /* --format */
-			set_reiserfs_version (optarg);
+		case 'v':	/* --format */
+			set_reiserfs_version(optarg);
 			break;
 
 		case 'V':
@@ -641,27 +635,27 @@ int main (int argc, char **argv)
 			break;
 
 		case 'f':
-			force ++;
+			force++;
 			break;
 
 		case 'd':
 			mode |= DEBUG_MODE;
 			break;
-		
+
 		case 'u':
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
 			if (uuid_parse(optarg, UUID) < 0) {
-			    reiserfs_warning(stderr, "Invalid UUID '%s' is "
-					     "specified\n", optarg);
-			    return 1;
+				reiserfs_warning(stderr, "Invalid UUID '%s' is "
+						 "specified\n", optarg);
+				return 1;
 			}
 #else
-			message ("Cannot set up the UUID, uuidlib was not "
-				 "found by configure.\n");
+			message("Cannot set up the UUID, uuidlib was not "
+				"found by configure.\n");
 			return 1;
 #endif
 			break;
-		
+
 		case 'l':
 			LABEL = optarg;
 			break;
@@ -671,132 +665,134 @@ int main (int argc, char **argv)
 		default:
 			print_usage_and_exit();
 		}
-    }
-
-    print_banner (program_name);
-
-    if (mode & QUIET_MODE)
-	fclose(stdout);
-    
-    if (mode == DO_NOTHING)
-	    exit(0);
-
-    /* device to be formatted */
-    device_name = argv [optind];
-    
-    if (optind == argc - 2) {
-        /* number of blocks for filesystem is specified */
-        fs_size = str2u64 (argv[optind + 1]);
-    } else if (optind == argc - 1) {
-        /* number of blocks is not specified */
-        if (!(fs_size = count_blocks (device_name, Block_size)))
-		exit(1);
-    } else {
-        print_usage_and_exit ();
-    }
-
-    if (fs_size >= UINT_MAX) {
-	fprintf(stderr, ">>> ReiserFS supports file systems of up to %u "
-	        "blocks.\n>>> The maximum size with a block size of %u bytes "
-		"is about %Lu MiB.\n>>> This file system would occupy %Lu "
-		"blocks. ", UINT_MAX, Block_size,
-		((__u64)UINT_MAX * Block_size) / (1024 * 1024), fs_size);
-
-	if (optind == argc - 1) {
-	    if (!force &&
-		!user_confirmed (stderr, "Truncate? (y/N): ", "y\n")) {
-		fprintf(stderr, "\nExiting.\n\n");
-		exit(1);
-	    }
-	    fprintf(stderr, "Truncating.\n\n");
-	    fs_size = UINT_MAX;
+	}
+
+	print_banner(program_name);
+
+	if (mode & QUIET_MODE)
+		fclose(stdout);
+
+	if (mode == DO_NOTHING)
+		exit(0);
+
+	/* device to be formatted */
+	device_name = argv[optind];
+
+	if (optind == argc - 2) {
+		/* number of blocks for filesystem is specified */
+		fs_size = str2u64(argv[optind + 1]);
+	} else if (optind == argc - 1) {
+		/* number of blocks is not specified */
+		if (!(fs_size = count_blocks(device_name, Block_size)))
+			exit(1);
 	} else {
-	    fprintf(stderr, "Exiting.\n\n");
-	    exit(1);
-	}
-    }
-
-    if (is_journal_default (device_name, jdevice_name, Block_size))
-        Create_default_journal = 1;
-    
-    if (!(mode & QUIET_MODE) && !can_we_format_it (device_name, force))
-        return 1;
-
-    if (!(mode & QUIET_MODE) && !block_size_ok (Block_size, force))
-        return 1;
-	
-    if (jdevice_name)
-        if (!(mode & QUIET_MODE) && !can_we_format_it (jdevice_name, force))
-            return 1;
-
-    fs = reiserfs_create (device_name, select_format(), fs_size, Block_size, 
-	Create_default_journal, 1);
-    
-    if (!fs) {
-        return 1;
-    }
-		
-    if (!reiserfs_create_journal (fs, jdevice_name, Offset, Journal_size, 
-	Max_trans_size, force))
-    {
-        return 1;
-    }
-
-    if (!reiserfs_create_ondisk_bitmap (fs)) {
-        return 1;
-    }
-
-    /* these fill buffers (super block, first bitmap, root block) with
-       reiserfs structures */
-#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-    if (!uuid_is_null(UUID) && fs->fs_format != REISERFS_FORMAT_3_6) {
-	reiserfs_warning(stderr, "UUID can be specified only with 3.6 format\n");
-	return 1;
-    }
-#endif
+		print_usage_and_exit();
+	}
 
-    if (badblocks_file) {
-	if (create_badblock_bitmap (fs, badblocks_file))
-	    exit(1);
-    }
+	if (fs_size >= UINT_MAX) {
+		fprintf(stderr,
+			">>> ReiserFS supports file systems of up to %u "
+			"blocks.\n>>> The maximum size with a block size of %u bytes "
+			"is about %Lu MiB.\n>>> This file system would occupy %Lu "
+			"blocks. ", UINT_MAX, Block_size,
+			((__u64) UINT_MAX * Block_size) / (1024 * 1024),
+			fs_size);
+
+		if (optind == argc - 1) {
+			if (!force &&
+			    !user_confirmed(stderr, "Truncate? (y/N): ",
+					    "y\n")) {
+				fprintf(stderr, "\nExiting.\n\n");
+				exit(1);
+			}
+			fprintf(stderr, "Truncating.\n\n");
+			fs_size = UINT_MAX;
+		} else {
+			fprintf(stderr, "Exiting.\n\n");
+			exit(1);
+		}
+	}
 
+	if (is_journal_default(device_name, jdevice_name, Block_size))
+		Create_default_journal = 1;
 
-    make_super_block (fs);
-    make_bitmap (fs);
-    make_root_block (fs);
-    add_badblock_list (fs, 1);
+	if (!(mode & QUIET_MODE) && !can_we_format_it(device_name, force))
+		return 1;
 
-    report (fs, jdevice_name);
+	if (!(mode & QUIET_MODE) && !block_size_ok(Block_size, force))
+		return 1;
 
-    if (!force && !(mode & QUIET_MODE)) {
-        fprintf (stderr, "ATTENTION: YOU SHOULD REBOOT AFTER FDISK!\n"
-                "\tALL DATA WILL BE LOST ON '%s'", device_name);
-        if (jdevice_name && strcmp (jdevice_name, device_name))
-            fprintf (stderr, " AND ON JOURNAL DEVICE '%s'", jdevice_name);
+	if (jdevice_name)
+		if (!(mode & QUIET_MODE)
+		    && !can_we_format_it(jdevice_name, force))
+			return 1;
 
-        if (!user_confirmed (stderr, "!\nContinue (y/n):", "y\n"))
-            return 1;
-    }
+	fs = reiserfs_create(device_name, select_format(), fs_size, Block_size,
+			     Create_default_journal, 1);
 
+	if (!fs) {
+		return 1;
+	}
 
-    invalidate_other_formats (fs->fs_dev);
-    zero_journal (fs);
+	if (!reiserfs_create_journal(fs, jdevice_name, Offset, Journal_size,
+				     Max_trans_size, force)) {
+		return 1;
+	}
 
-    reiserfs_close (fs);
+	if (!reiserfs_create_ondisk_bitmap(fs)) {
+		return 1;
+	}
 
-    printf ("Syncing.."); fflush (stdout);
-    sync ();
-    printf ("ok\n");
- 
-    if (mode & DEBUG_MODE)
-	return 0;
+	/* these fill buffers (super block, first bitmap, root block) with
+	   reiserfs structures */
+#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
+	if (!uuid_is_null(UUID) && fs->fs_format != REISERFS_FORMAT_3_6) {
+		reiserfs_warning(stderr,
+				 "UUID can be specified only with 3.6 format\n");
+		return 1;
+	}
+#endif
+
+	if (badblocks_file) {
+		if (create_badblock_bitmap(fs, badblocks_file))
+			exit(1);
+	}
 
-    printf("ReiserFS is successfully created on %s.\n", device_name);
+	make_super_block(fs);
+	make_bitmap(fs);
+	make_root_block(fs);
+	add_badblock_list(fs, 1);
 
-    return 0;
-}
+	report(fs, jdevice_name);
+
+	if (!force && !(mode & QUIET_MODE)) {
+		fprintf(stderr, "ATTENTION: YOU SHOULD REBOOT AFTER FDISK!\n"
+			"\tALL DATA WILL BE LOST ON '%s'", device_name);
+		if (jdevice_name && strcmp(jdevice_name, device_name))
+			fprintf(stderr, " AND ON JOURNAL DEVICE '%s'",
+				jdevice_name);
+
+		if (!user_confirmed(stderr, "!\nContinue (y/n):", "y\n"))
+			return 1;
+	}
+
+	invalidate_other_formats(fs->fs_dev);
+	zero_journal(fs);
+
+	reiserfs_close(fs);
 
+	printf("Syncing..");
+	fflush(stdout);
+	sync();
+	printf("ok\n");
 
+	if (mode & DEBUG_MODE)
+		return 0;
+
+	printf("ReiserFS is successfully created on %s.\n", device_name);
+
+	return 0;
+}
 
 /* 
  * Use BSD fomatting.
diff --git a/reiserfscore/bitmap.c b/reiserfscore/bitmap.c
index 34f15c6..79a913c 100644
--- a/reiserfscore/bitmap.c
+++ b/reiserfscore/bitmap.c
@@ -10,112 +10,113 @@
 #include "includes.h"
 #include <assert.h>
 
-
 /* create clean bitmap */
-reiserfs_bitmap_t * reiserfs_create_bitmap (unsigned int bit_count)
+reiserfs_bitmap_t *reiserfs_create_bitmap(unsigned int bit_count)
 {
-    reiserfs_bitmap_t * bm;
-
-    bm = getmem (sizeof (*bm));
-    if (!bm)
-	return 0;
-    bm->bm_bit_size = bit_count;
-    bm->bm_byte_size = ((unsigned long long)bit_count + 7) / 8;
-    bm->bm_set_bits = 0;
-    bm->bm_map = getmem (bm->bm_byte_size);
-    if (!bm->bm_map) {
-	freemem (bm);
-	return 0;
-    }
+	reiserfs_bitmap_t *bm;
+
+	bm = getmem(sizeof(*bm));
+	if (!bm)
+		return 0;
+	bm->bm_bit_size = bit_count;
+	bm->bm_byte_size = ((unsigned long long)bit_count + 7) / 8;
+	bm->bm_set_bits = 0;
+	bm->bm_map = getmem(bm->bm_byte_size);
+	if (!bm->bm_map) {
+		freemem(bm);
+		return 0;
+	}
 
-    return bm;
+	return bm;
 }
 
 /* Expand existing bitmap.  Return non-zero if can't. FIXME: it is
    assumed that bit_count is new number of blocks to be addressed */
-int reiserfs_expand_bitmap (reiserfs_bitmap_t * bm, unsigned int bit_count)
+int reiserfs_expand_bitmap(reiserfs_bitmap_t *bm, unsigned int bit_count)
 {
-    unsigned int byte_count = ((bit_count + 7) / 8);
-    char * new_map;
+	unsigned int byte_count = ((bit_count + 7) / 8);
+	char *new_map;
 
-    new_map = expandmem (bm->bm_map, bm->bm_byte_size,
-			 byte_count - bm->bm_byte_size);
+	new_map = expandmem(bm->bm_map, bm->bm_byte_size,
+			    byte_count - bm->bm_byte_size);
 
-    if (!new_map) {
-	return 1;
-    }
-    
-    bm->bm_map = new_map;
-    bm->bm_byte_size = byte_count;
-    bm->bm_bit_size = bit_count;
+	if (!new_map) {
+		return 1;
+	}
+
+	bm->bm_map = new_map;
+	bm->bm_byte_size = byte_count;
+	bm->bm_bit_size = bit_count;
 
-    bm->bm_dirty = 1;
+	bm->bm_dirty = 1;
 
-    return 0;
+	return 0;
 }
 
-void reiserfs_shrink_bitmap (reiserfs_bitmap_t * bm, unsigned int bit_count)
+void reiserfs_shrink_bitmap(reiserfs_bitmap_t *bm, unsigned int bit_count)
 {
-    unsigned long i;
-    
-    assert (bm->bm_bit_size >= bit_count);
-
-    bm->bm_byte_size = (bit_count + 7) / 8;
-    bm->bm_bit_size = bit_count;
-    bm->bm_set_bits = 0;
-    
-    bm->bm_dirty = 1;
-    
-    for (i = 0; i < bm->bm_bit_size; i++) {
-	if (reiserfs_bitmap_test_bit(bm, i))
-	    bm->bm_set_bits++;
-    }
+	unsigned long i;
+
+	assert(bm->bm_bit_size >= bit_count);
+
+	bm->bm_byte_size = (bit_count + 7) / 8;
+	bm->bm_bit_size = bit_count;
+	bm->bm_set_bits = 0;
+
+	bm->bm_dirty = 1;
+
+	for (i = 0; i < bm->bm_bit_size; i++) {
+		if (reiserfs_bitmap_test_bit(bm, i))
+			bm->bm_set_bits++;
+	}
 }
 
 /* bitmap destructor */
-void reiserfs_delete_bitmap (reiserfs_bitmap_t * bm)
+void reiserfs_delete_bitmap(reiserfs_bitmap_t *bm)
 {
-    freemem(bm->bm_map);
-    bm->bm_map = NULL;		/* to not reuse bitmap handle */
-    bm->bm_bit_size = 0;
-    bm->bm_byte_size = 0;
-    freemem(bm);
+	freemem(bm->bm_map);
+	bm->bm_map = NULL;	/* to not reuse bitmap handle */
+	bm->bm_bit_size = 0;
+	bm->bm_byte_size = 0;
+	freemem(bm);
 }
 
-
-void reiserfs_bitmap_copy (reiserfs_bitmap_t * to, reiserfs_bitmap_t * from)
+void reiserfs_bitmap_copy(reiserfs_bitmap_t *to, reiserfs_bitmap_t *from)
 {
-    assert (to->bm_byte_size == from->bm_byte_size);
-    memcpy (to->bm_map, from->bm_map, from->bm_byte_size);
-    to->bm_bit_size = from->bm_bit_size;
-    to->bm_set_bits = from->bm_set_bits;
-    to->bm_dirty = 1;
+	assert(to->bm_byte_size == from->bm_byte_size);
+	memcpy(to->bm_map, from->bm_map, from->bm_byte_size);
+	to->bm_bit_size = from->bm_bit_size;
+	to->bm_set_bits = from->bm_set_bits;
+	to->bm_dirty = 1;
 }
 
-int reiserfs_bitmap_compare (reiserfs_bitmap_t * bm1, reiserfs_bitmap_t * bm2)
+int reiserfs_bitmap_compare(reiserfs_bitmap_t *bm1, reiserfs_bitmap_t *bm2)
 {
-    unsigned long i, diff;
-    unsigned long int bytes, bits;
-
-    assert (bm1->bm_byte_size == bm2->bm_byte_size &&
-	    bm1->bm_bit_size == bm2->bm_bit_size);
-
-    diff = 0;
-
-    /* compare full bytes */
-    bytes = bm1->bm_bit_size / 8;
-    bits = bytes * 8;
-    if (memcmp (bm1->bm_map, bm2->bm_map, bytes)) {
-	for (i = 0; i < bits; i ++)
-	    if (reiserfs_bitmap_test_bit(bm1, i) != reiserfs_bitmap_test_bit(bm2, i))
-		diff ++;
-    }
-    
-    /* compare last byte of bitmap which can be used partially */
-    bits = bm1->bm_bit_size % 8;
-    for (i = bm1->bm_bit_size / 8 * 8; i < bm1->bm_bit_size / 8 * 8 + bits; i ++)
-	if (reiserfs_bitmap_test_bit(bm1, i) != reiserfs_bitmap_test_bit(bm2, i))
-            diff ++;
+	unsigned long i, diff;
+	unsigned long int bytes, bits;
+
+	assert(bm1->bm_byte_size == bm2->bm_byte_size &&
+	       bm1->bm_bit_size == bm2->bm_bit_size);
+
+	diff = 0;
+
+	/* compare full bytes */
+	bytes = bm1->bm_bit_size / 8;
+	bits = bytes * 8;
+	if (memcmp(bm1->bm_map, bm2->bm_map, bytes)) {
+		for (i = 0; i < bits; i++)
+			if (reiserfs_bitmap_test_bit(bm1, i) !=
+			    reiserfs_bitmap_test_bit(bm2, i))
+				diff++;
+	}
+
+	/* compare last byte of bitmap which can be used partially */
+	bits = bm1->bm_bit_size % 8;
+	for (i = bm1->bm_bit_size / 8 * 8; i < bm1->bm_bit_size / 8 * 8 + bits;
+	     i++)
+		if (reiserfs_bitmap_test_bit(bm1, i) !=
+		    reiserfs_bitmap_test_bit(bm2, i))
+			diff++;
 
 /*	int mask;
 
@@ -124,7 +125,7 @@ int reiserfs_bitmap_compare (reiserfs_bitmap_t * bm1, reiserfs_bitmap_t * bm2)
 	    diff ++;
 	}
     }*/
-    return diff;
+	return diff;
 }
 
 /* 
@@ -133,21 +134,22 @@ int reiserfs_bitmap_compare (reiserfs_bitmap_t * bm1, reiserfs_bitmap_t * bm2)
     Y - `from` bitmap. 
     Save result in the `to` bitmap.
 */
-void reiserfs_bitmap_disjunction (reiserfs_bitmap_t * to, 
-    reiserfs_bitmap_t * from) 
+void reiserfs_bitmap_disjunction(reiserfs_bitmap_t *to,
+				 reiserfs_bitmap_t *from)
 {
-    unsigned int i;
+	unsigned int i;
 
-    assert (to->bm_byte_size == from->bm_byte_size &&
-	    to->bm_bit_size == from->bm_bit_size);
+	assert(to->bm_byte_size == from->bm_byte_size &&
+	       to->bm_bit_size == from->bm_bit_size);
 
-    for (i = 0; i < to->bm_bit_size; i++) {
-	if (misc_test_bit(i, from->bm_map) && !misc_test_bit(i, to->bm_map)) {
-	    misc_set_bit(i, to->bm_map);
-	    to->bm_set_bits ++;
-	    to->bm_dirty = 1;	
+	for (i = 0; i < to->bm_bit_size; i++) {
+		if (misc_test_bit(i, from->bm_map)
+		    && !misc_test_bit(i, to->bm_map)) {
+			misc_set_bit(i, to->bm_map);
+			to->bm_set_bits++;
+			to->bm_dirty = 1;
+		}
 	}
-    }
 }
 
 /* 
@@ -156,173 +158,179 @@ void reiserfs_bitmap_disjunction (reiserfs_bitmap_t * to,
     Y - `exclude` bitmap. 
     Save result in the `base` bitmap.
 */
-void reiserfs_bitmap_delta (reiserfs_bitmap_t * base, reiserfs_bitmap_t * exclude) {
-   unsigned int i;
+void reiserfs_bitmap_delta(reiserfs_bitmap_t *base,
+			   reiserfs_bitmap_t *exclude)
+{
+	unsigned int i;
 
-    assert (base->bm_byte_size == exclude->bm_byte_size &&
-	    base->bm_bit_size == exclude->bm_bit_size);
+	assert(base->bm_byte_size == exclude->bm_byte_size &&
+	       base->bm_bit_size == exclude->bm_bit_size);
 
-    for (i = 0; i < base->bm_bit_size; i++) {
-	if (misc_test_bit(i, exclude->bm_map) && misc_test_bit(i, base->bm_map)) {
-	    misc_clear_bit(i, base->bm_map);
-	    base->bm_set_bits --;
-	    base->bm_dirty = 1;
+	for (i = 0; i < base->bm_bit_size; i++) {
+		if (misc_test_bit(i, exclude->bm_map)
+		    && misc_test_bit(i, base->bm_map)) {
+			misc_clear_bit(i, base->bm_map);
+			base->bm_set_bits--;
+			base->bm_dirty = 1;
+		}
 	}
-    }
 }
 
-void reiserfs_bitmap_set_bit (reiserfs_bitmap_t * bm, unsigned int bit_number)
+void reiserfs_bitmap_set_bit(reiserfs_bitmap_t *bm, unsigned int bit_number)
 {
-    assert(bit_number < bm->bm_bit_size);
-    if (misc_test_bit (bit_number, bm->bm_map))
-	return;
-    misc_set_bit(bit_number, bm->bm_map);
-    bm->bm_set_bits ++;
-    bm->bm_dirty = 1;
+	assert(bit_number < bm->bm_bit_size);
+	if (misc_test_bit(bit_number, bm->bm_map))
+		return;
+	misc_set_bit(bit_number, bm->bm_map);
+	bm->bm_set_bits++;
+	bm->bm_dirty = 1;
 }
 
-
-void reiserfs_bitmap_clear_bit (reiserfs_bitmap_t * bm, unsigned int bit_number)
+void reiserfs_bitmap_clear_bit(reiserfs_bitmap_t *bm, unsigned int bit_number)
 {
-    assert(bit_number < bm->bm_bit_size);
-    if (!misc_test_bit (bit_number, bm->bm_map))
-	return;
-    misc_clear_bit (bit_number, bm->bm_map);
-    bm->bm_set_bits --;
-    bm->bm_dirty = 1;
+	assert(bit_number < bm->bm_bit_size);
+	if (!misc_test_bit(bit_number, bm->bm_map))
+		return;
+	misc_clear_bit(bit_number, bm->bm_map);
+	bm->bm_set_bits--;
+	bm->bm_dirty = 1;
 }
 
-
-int reiserfs_bitmap_test_bit (reiserfs_bitmap_t * bm, unsigned int bit_number)
+int reiserfs_bitmap_test_bit(reiserfs_bitmap_t *bm, unsigned int bit_number)
 {
-    if (bit_number >= bm->bm_bit_size)
-	printf ("bit %u, bitsize %lu\n", bit_number, bm->bm_bit_size);
-    assert(bit_number < bm->bm_bit_size);
-    return misc_test_bit(bit_number, bm->bm_map);
+	if (bit_number >= bm->bm_bit_size)
+		printf("bit %u, bitsize %lu\n", bit_number, bm->bm_bit_size);
+	assert(bit_number < bm->bm_bit_size);
+	return misc_test_bit(bit_number, bm->bm_map);
 }
 
-
-unsigned int reiserfs_bitmap_zeros (reiserfs_bitmap_t * bm) {
-    return bm->bm_bit_size - bm->bm_set_bits;
+unsigned int reiserfs_bitmap_zeros(reiserfs_bitmap_t *bm)
+{
+	return bm->bm_bit_size - bm->bm_set_bits;
 }
 
-
-unsigned int reiserfs_bitmap_ones (reiserfs_bitmap_t * bm) {
-    return bm->bm_set_bits;
+unsigned int reiserfs_bitmap_ones(reiserfs_bitmap_t *bm)
+{
+	return bm->bm_set_bits;
 }
 
-
-int reiserfs_bitmap_find_zero_bit (reiserfs_bitmap_t * bm, unsigned long * first)
+int reiserfs_bitmap_find_zero_bit(reiserfs_bitmap_t *bm, unsigned long *first)
 {
-    unsigned long bit_nr = *first;
-    assert(*first < bm->bm_bit_size);
+	unsigned long bit_nr = *first;
+	assert(*first < bm->bm_bit_size);
 
-    bit_nr = misc_find_next_zero_bit(bm->bm_map, bm->bm_bit_size, *first);
+	bit_nr = misc_find_next_zero_bit(bm->bm_map, bm->bm_bit_size, *first);
 
-    if (bit_nr >= bm->bm_bit_size) { /* search failed */	
-	return 1;
-    }
+	if (bit_nr >= bm->bm_bit_size) {	/* search failed */
+		return 1;
+	}
 
-    *first = bit_nr;
-    return 0;
+	*first = bit_nr;
+	return 0;
 }
 
-
 /* read every bitmap block and copy their content into bitmap 'bm' */
-static int reiserfs_fetch_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t * fs)
+static int reiserfs_fetch_ondisk_bitmap(reiserfs_bitmap_t *bm,
+					reiserfs_filsys_t *fs)
 {
-    unsigned int last_byte_unused_bits;
-    unsigned long block, to_copy;
-    struct buffer_head * bh;
-    unsigned int i;
-    int copied;
-    int ret = 0;
-    char * p;
+	unsigned int last_byte_unused_bits;
+	unsigned long block, to_copy;
+	struct buffer_head *bh;
+	unsigned int i;
+	int copied;
+	int ret = 0;
+	char *p;
+
+	to_copy = (get_sb_block_count(fs->fs_ondisk_sb) + 7) / 8;
+
+	/*reiserfs_warning (stderr, "Fetching on-disk bitmap.."); */
+	assert(bm->bm_byte_size == to_copy);
+
+	copied = fs->fs_blocksize;
+	p = bm->bm_map;
+	block = fs->fs_super_bh->b_blocknr + 1;
+
+	while (to_copy) {
+		bh = bread(fs->fs_dev, block, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(stderr,
+					 "reiserfs_fetch_ondisk_bitmap: "
+					 "bread failed reading bitmap (%lu)\n",
+					 block);
+
+			bh = getblk(fs->fs_dev, block, fs->fs_blocksize);
+			if (!bh) {
+				reiserfs_exit(1,
+					      "reiserfs_fetch_ondisk_bitmap: "
+					      "getblk failed");
+			}
+
+			memset(bh->b_data, 0xff, bh->b_size);
+			mark_buffer_uptodate(bh, 1);
+		}
 
-    to_copy = (get_sb_block_count (fs->fs_ondisk_sb) + 7) / 8;
+		if (to_copy < fs->fs_blocksize) {
+			for (i = to_copy; i < fs->fs_blocksize; i++) {
+				if (bh->b_data[i] != (char)0xff) {
+					ret = 1;
+					break;
+				}
+			}
 
-    /*reiserfs_warning (stderr, "Fetching on-disk bitmap..");*/
-    assert (bm->bm_byte_size == to_copy);
+			copied = to_copy;
+		}
+		memcpy(p, bh->b_data, copied);
+		brelse(bh);
+		p += copied;
+		to_copy -= copied;
+
+		/* next bitmap block */
+		if (spread_bitmaps(fs))
+			block =
+			    (block / (fs->fs_blocksize * 8) +
+			     1) * (fs->fs_blocksize * 8);
+		else
+			block++;
+	}
 
-    copied = fs->fs_blocksize;
-    p = bm->bm_map;
-    block = fs->fs_super_bh->b_blocknr + 1;
+	/* on disk bitmap has bits out of SB_BLOCK_COUNT set to 1, where as
+	   reiserfs_bitmap_t has those bits set to 0 */
+	last_byte_unused_bits = bm->bm_byte_size * 8 - bm->bm_bit_size;
 
-    while (to_copy) {
-	bh = bread (fs->fs_dev, block, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (stderr, "reiserfs_fetch_ondisk_bitmap: "
-			      "bread failed reading bitmap (%lu)\n", block);
-	    
-	    bh = getblk (fs->fs_dev, block, fs->fs_blocksize); 
-	    if (!bh) {
-		reiserfs_exit (1, "reiserfs_fetch_ondisk_bitmap: "
-			       "getblk failed");
-	    }
-
-	    memset (bh->b_data, 0xff, bh->b_size);
-	    mark_buffer_uptodate (bh, 1);
+	for (i = 0; i < last_byte_unused_bits; i++) {
+		if (misc_test_bit(bm->bm_bit_size + i, bm->bm_map) == 0)
+			ret = 1;
+		else
+			misc_clear_bit(bm->bm_bit_size + i, bm->bm_map);
 	}
 
-	if (to_copy < fs->fs_blocksize) {
-	    for (i = to_copy; i < fs->fs_blocksize; i++) {
-		if (bh->b_data[i] != (char)0xff) {
-		    ret = 1;
-		    break;
-		}
-	    }
-	    
-	    copied = to_copy;
-	}
-	memcpy (p, bh->b_data, copied); 
-	brelse (bh);
-	p += copied;
-	to_copy -= copied;
-
-	/* next bitmap block */
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8);
-	else
-	    block ++;
-    }
-
-    /* on disk bitmap has bits out of SB_BLOCK_COUNT set to 1, where as
-       reiserfs_bitmap_t has those bits set to 0 */
-    last_byte_unused_bits = bm->bm_byte_size * 8 - bm->bm_bit_size;
-
-    for (i = 0; i < last_byte_unused_bits; i ++) {
-	if (misc_test_bit (bm->bm_bit_size + i, bm->bm_map) == 0)
-	    ret = 1;
-	else	    
-	    misc_clear_bit (bm->bm_bit_size + i, bm->bm_map);
-    }
-
-    bm->bm_set_bits = 0;
-    /* FIXME: optimize that */
-    for (i = 0; i < bm->bm_bit_size; i ++)
-	if (reiserfs_bitmap_test_bit (bm, i))
-	    bm->bm_set_bits ++;
-    
-    bm->bm_dirty = 0;
-
-    return ret;
-}
+	bm->bm_set_bits = 0;
+	/* FIXME: optimize that */
+	for (i = 0; i < bm->bm_bit_size; i++)
+		if (reiserfs_bitmap_test_bit(bm, i))
+			bm->bm_set_bits++;
 
+	bm->bm_dirty = 0;
+
+	return ret;
+}
 
 /* copy bitmap 'bm' to buffers which hold on-disk bitmap if bitmap was ever
    changed and return 1. Otherwise - return 0 */
-int reiserfs_flush_to_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t * fs)
+int reiserfs_flush_to_ondisk_bitmap(reiserfs_bitmap_t *bm,
+				    reiserfs_filsys_t *fs)
 {
-    unsigned int last_byte_unused_bits, i;
-    unsigned long to_copy, copied, block;
-    struct buffer_head * bh;
-    char * p;
-
-    /* make sure that the device is big enough */
-    bh = bread (fs->fs_dev, bm->bm_bit_size - 1, fs->fs_blocksize);
-    if (!bh) {
-	reiserfs_warning (stderr, "reiserfs_flush_to_ondisk_bitmap: bread failed for block %lu\n",
-			  bm->bm_bit_size - 1);
+	unsigned int last_byte_unused_bits, i;
+	unsigned long to_copy, copied, block;
+	struct buffer_head *bh;
+	char *p;
+
+	/* make sure that the device is big enough */
+	bh = bread(fs->fs_dev, bm->bm_bit_size - 1, fs->fs_blocksize);
+	if (!bh) {
+		reiserfs_warning(stderr,
+				 "reiserfs_flush_to_ondisk_bitmap: bread failed for block %lu\n",
+				 bm->bm_bit_size - 1);
 /*
 	bh = getblk (fs->fs_dev, bm->bm_bit_size - 1, fs->fs_blocksize);
 	if (!bh)
@@ -330,71 +338,72 @@ int reiserfs_flush_to_ondisk_bitmap (reiserfs_bitmap_t * bm, reiserfs_filsys_t *
 	mark_buffer_uptodate (bh, 1);
 	mark_buffer_dirty (bh);
 	bwrite (bh);*/
-    }
-    brelse (bh);
+	}
+	brelse(bh);
 
-    if (!bm->bm_dirty)
-	return 0;
+	if (!bm->bm_dirty)
+		return 0;
 
-    to_copy = bm->bm_byte_size;
+	to_copy = bm->bm_byte_size;
 
-    copied = fs->fs_blocksize;
-    p = bm->bm_map;
-    block = fs->fs_super_bh->b_blocknr + 1;
+	copied = fs->fs_blocksize;
+	p = bm->bm_map;
+	block = fs->fs_super_bh->b_blocknr + 1;
 
-    while (to_copy) {
-	/* we bread to make sure that filesystem contains enough blocks */
-	bh = getblk (fs->fs_dev, block, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_exit (1, "Getblk failed for (%lu)\n", block);
-	}
-	
-	memset (bh->b_data, 0xff, bh->b_size);
-	mark_buffer_uptodate (bh, 1);
-
-	if (to_copy < fs->fs_blocksize)
-	    copied = to_copy;
-	memcpy (bh->b_data, p, copied);
-	if (copied == to_copy) {
-	    /* set unused bits of last byte of a bitmap to 1 */
-	    last_byte_unused_bits = bm->bm_byte_size * 8 - bm->bm_bit_size;
+	while (to_copy) {
+		/* we bread to make sure that filesystem contains enough blocks */
+		bh = getblk(fs->fs_dev, block, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_exit(1, "Getblk failed for (%lu)\n", block);
+		}
 
-	    for (i = 0; i < last_byte_unused_bits; i ++)
-		misc_set_bit ((bm->bm_bit_size % (fs->fs_blocksize * 8)) + i, bh->b_data);
+		memset(bh->b_data, 0xff, bh->b_size);
+		mark_buffer_uptodate(bh, 1);
+
+		if (to_copy < fs->fs_blocksize)
+			copied = to_copy;
+		memcpy(bh->b_data, p, copied);
+		if (copied == to_copy) {
+			/* set unused bits of last byte of a bitmap to 1 */
+			last_byte_unused_bits =
+			    bm->bm_byte_size * 8 - bm->bm_bit_size;
+
+			for (i = 0; i < last_byte_unused_bits; i++)
+				misc_set_bit((bm->bm_bit_size %
+					      (fs->fs_blocksize * 8)) + i,
+					     bh->b_data);
+		}
+		mark_buffer_dirty(bh);
+		brelse(bh);
+		p += copied;
+		to_copy -= copied;
+
+		/* next bitmap block */
+		if (spread_bitmaps(fs))
+			block =
+			    (block / (fs->fs_blocksize * 8) +
+			     1) * (fs->fs_blocksize * 8);
+		else
+			block++;
 	}
-	mark_buffer_dirty (bh);
-	brelse (bh);
-	p += copied;
-	to_copy -= copied;
-
-	/* next bitmap block */
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8);
-	else
-	    block ++;
-    }
-
 
-    return 1;
+	return 1;
 }
 
-
-void reiserfs_bitmap_zero (reiserfs_bitmap_t * bm)
+void reiserfs_bitmap_zero(reiserfs_bitmap_t *bm)
 {
-    memset (bm->bm_map, 0, bm->bm_byte_size);
-    bm->bm_set_bits = 0;
-    bm->bm_dirty = 1;
+	memset(bm->bm_map, 0, bm->bm_byte_size);
+	bm->bm_set_bits = 0;
+	bm->bm_dirty = 1;
 }
 
-
-void reiserfs_bitmap_fill (reiserfs_bitmap_t * bm)
+void reiserfs_bitmap_fill(reiserfs_bitmap_t *bm)
 {
-    memset (bm->bm_map, 0xff, bm->bm_byte_size);
-    bm->bm_set_bits = bm->bm_bit_size;
-    bm->bm_dirty = 1;
+	memset(bm->bm_map, 0xff, bm->bm_byte_size);
+	bm->bm_set_bits = bm->bm_bit_size;
+	bm->bm_dirty = 1;
 }
 
-
 /* format of bitmap saved in a file:
    magic number (32 bits)
    bm_bit_size (32 bits)
@@ -405,99 +414,97 @@ void reiserfs_bitmap_fill (reiserfs_bitmap_t * bm)
 #define BITMAP_START_MAGIC 374031
 #define BITMAP_END_MAGIC 7786472
 
-
-FILE * open_file (char * filename, char * option)
+FILE *open_file(char *filename, char *option)
 {
-    FILE * fp = fopen (filename, option);
-    if (!fp) {
-	reiserfs_warning (stderr, "open_file: could not open file %s\n", filename);
-	return 0;
-    }
-    reiserfs_warning (stderr, "Temp file opened by fsck: \"%s\" .. \n", filename);
-    return fp;
+	FILE *fp = fopen(filename, option);
+	if (!fp) {
+		reiserfs_warning(stderr, "open_file: could not open file %s\n",
+				 filename);
+		return 0;
+	}
+	reiserfs_warning(stderr, "Temp file opened by fsck: \"%s\" .. \n",
+			 filename);
+	return fp;
 }
 
-
-void close_file (FILE * fp)
+void close_file(FILE * fp)
 {
-    fclose (fp);
-    /*reiserfs_warning (stderr, "done\n"); fflush (stderr);*/
+	fclose(fp);
+	/*reiserfs_warning (stderr, "done\n"); fflush (stderr); */
 }
 
-
-void reiserfs_bitmap_save (FILE * fp, reiserfs_bitmap_t * bm)
+void reiserfs_bitmap_save(FILE * fp, reiserfs_bitmap_t *bm)
 {
 //    FILE * fp;
-    __u32 v;
-    int zeros;
-    int count;
-    unsigned int i;
-    int extents;
-    long position;
-
-  /*  fp = fopen (filename, "w+");
-    if (!fp) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_save: could not save bitmap in %s: %s",
-			  filename, strerror(errno));
-	return;
-    }*/
-
+	__u32 v;
+	int zeros;
+	int count;
+	unsigned int i;
+	int extents;
+	long position;
+
+	/*  fp = fopen (filename, "w+");
+	   if (!fp) {
+	   reiserfs_warning (stderr, "reiserfs_bitmap_save: could not save bitmap in %s: %s",
+	   filename, strerror(errno));
+	   return;
+	   } */
 
 //    reiserfs_warning (stderr, "Saving bitmap in \"%s\" .. ", filename); fflush (stderr);
 
-	
-
-    v = BITMAP_START_MAGIC;
-    fwrite (&v, 4, 1, fp);
-
-    v = bm->bm_bit_size;
-    fwrite (&v, 4, 1, fp);
-
-    /*printf ("SAVE: bit_size - %d\n", v);*/
-
-    position = ftell(fp);
-
-    if (fseek (fp, 4, SEEK_CUR)) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_save: fseek failed: %s\n", strerror(errno));
-//	fclose (fp);
-	return;
-    }
-
-    zeros = 0;
-    count = 0;
-    extents = 0;
-    for (i = 0; i < v; i ++) {
-	if (reiserfs_bitmap_test_bit (bm, i)) {
-	    if (zeros) {
-		/* previous bit was not set, write amount of not set
-                   bits, switch to count set bits */
-		fwrite (&count, 4, 1, fp);
-		/*printf ("SAVE: Free %d\n", count);*/
-		extents ++;
-		count = 1;
-		zeros = 0;
-	    } else {
-		/* one more zero bit appeared */
-		count ++;
-	    }
-	} else {
-	    /* zero bit found */
-	    if (zeros) {
-		count ++;
-	    } else {
-		/* previous bit was set, write amount of set bits,
-                   switch to count not set bits */
-		fwrite (&count, 4, 1, fp);
-		/*printf ("SAVE: Used %d\n", count);*/
-		extents ++;
-		count = 1;
-		zeros = 1;
-	    }
+	v = BITMAP_START_MAGIC;
+	fwrite(&v, 4, 1, fp);
+
+	v = bm->bm_bit_size;
+	fwrite(&v, 4, 1, fp);
+
+	/*printf ("SAVE: bit_size - %d\n", v); */
+
+	position = ftell(fp);
+
+	if (fseek(fp, 4, SEEK_CUR)) {
+		reiserfs_warning(stderr,
+				 "reiserfs_bitmap_save: fseek failed: %s\n",
+				 strerror(errno));
+//      fclose (fp);
+		return;
+	}
+
+	zeros = 0;
+	count = 0;
+	extents = 0;
+	for (i = 0; i < v; i++) {
+		if (reiserfs_bitmap_test_bit(bm, i)) {
+			if (zeros) {
+				/* previous bit was not set, write amount of not set
+				   bits, switch to count set bits */
+				fwrite(&count, 4, 1, fp);
+				/*printf ("SAVE: Free %d\n", count); */
+				extents++;
+				count = 1;
+				zeros = 0;
+			} else {
+				/* one more zero bit appeared */
+				count++;
+			}
+		} else {
+			/* zero bit found */
+			if (zeros) {
+				count++;
+			} else {
+				/* previous bit was set, write amount of set bits,
+				   switch to count not set bits */
+				fwrite(&count, 4, 1, fp);
+				/*printf ("SAVE: Used %d\n", count); */
+				extents++;
+				count = 1;
+				zeros = 1;
+			}
+		}
 	}
-    }
 
-    fwrite (&count, 4, 1, fp);
-    extents ++;
+	fwrite(&count, 4, 1, fp);
+	extents++;
 /*
     if (zeros)
 	printf ("SAVE: Free %d\n", count);
@@ -505,23 +512,26 @@ void reiserfs_bitmap_save (FILE * fp, reiserfs_bitmap_t * bm)
 	printf ("SAVE: Used %d\n", count);
 */
 
-    v = BITMAP_END_MAGIC;
-    fwrite (&v, 4, 1, fp);
+	v = BITMAP_END_MAGIC;
+	fwrite(&v, 4, 1, fp);
 
-    if (fseek (fp, position, SEEK_SET)) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_save: fseek failed: %s", strerror(errno));
-	return;
-    }
+	if (fseek(fp, position, SEEK_SET)) {
+		reiserfs_warning(stderr,
+				 "reiserfs_bitmap_save: fseek failed: %s",
+				 strerror(errno));
+		return;
+	}
 
-    fwrite (&extents, 4, 1, fp);
+	fwrite(&extents, 4, 1, fp);
 
-    if (fseek (fp, 0, SEEK_END)) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_save: fseek failed: %s", strerror(errno));
-	return;
-    }
+	if (fseek(fp, 0, SEEK_END)) {
+		reiserfs_warning(stderr,
+				 "reiserfs_bitmap_save: fseek failed: %s",
+				 strerror(errno));
+		return;
+	}
 }
 
-
 /* format of fsck dump file:
         after pass0
    magic number                 (32 bits)
@@ -534,206 +544,210 @@ void reiserfs_bitmap_save (FILE * fp, reiserfs_bitmap_t * bm)
 #define FSCK_DUMP_START_MAGIC 374033
 #define FSCK_DUMP_END_MAGIC 7786470
 
-
 void reiserfs_begin_stage_info_save(FILE * file, unsigned long stage)
 {
-    __u32 v = FSCK_DUMP_START_MAGIC;
-    fwrite (&v, 4, 1, file);
-    fwrite (&stage, 4, 1, file);
+	__u32 v = FSCK_DUMP_START_MAGIC;
+	fwrite(&v, 4, 1, file);
+	fwrite(&stage, 4, 1, file);
 }
 
-
 void reiserfs_end_stage_info_save(FILE * file)
 {
-    __u32 v = FSCK_DUMP_END_MAGIC;
-    fwrite (&v, 4, 1, file);
+	__u32 v = FSCK_DUMP_END_MAGIC;
+	fwrite(&v, 4, 1, file);
 }
 
-
 /*return last passed stage*/
-int is_stage_magic_correct (FILE * fp)
+int is_stage_magic_correct(FILE * fp)
 {
-    __u32 v;
-
-    if (fseek (fp, -4, SEEK_END)) {
-	reiserfs_warning (stderr, "is_stage_magic_correct: fseek failed: %s\n", 
-	    strerror(errno));
-	return -1;
-    }
-
-    fread (&v, 4, 1, fp);
-    if (v != FSCK_DUMP_END_MAGIC) {
-	reiserfs_warning (stderr, "is_stage_magic_correct: no magic found\n");	
-	return -1;
-    }
-
-    if (fseek (fp, 0, SEEK_SET)) {
-	reiserfs_warning (stderr, "is_stage_magic_correct: fseek failed: %s\n", 
-	    strerror(errno));
-	return -1;
-    }
-
-    fread (&v, 4, 1, fp);
-    if (v != FSCK_DUMP_START_MAGIC) {
-	reiserfs_warning (stderr, "is_stage_magic_correct: no magic found\n");	
-	return -1;
-    }
-
-    fread (&v, 4, 1, fp);
-    if (v != PASS_0_DONE && v != PASS_1_DONE && v != TREE_IS_BUILT && v != SEMANTIC_DONE && v != LOST_FOUND_DONE) {
-	reiserfs_warning (stderr, "is_stage_magic_correct: wrong pass found");	
-	return -1;
-    }
-
-    return (__u16)v;
-}
+	__u32 v;
+
+	if (fseek(fp, -4, SEEK_END)) {
+		reiserfs_warning(stderr,
+				 "is_stage_magic_correct: fseek failed: %s\n",
+				 strerror(errno));
+		return -1;
+	}
+
+	fread(&v, 4, 1, fp);
+	if (v != FSCK_DUMP_END_MAGIC) {
+		reiserfs_warning(stderr,
+				 "is_stage_magic_correct: no magic found\n");
+		return -1;
+	}
+
+	if (fseek(fp, 0, SEEK_SET)) {
+		reiserfs_warning(stderr,
+				 "is_stage_magic_correct: fseek failed: %s\n",
+				 strerror(errno));
+		return -1;
+	}
+
+	fread(&v, 4, 1, fp);
+	if (v != FSCK_DUMP_START_MAGIC) {
+		reiserfs_warning(stderr,
+				 "is_stage_magic_correct: no magic found\n");
+		return -1;
+	}
+
+	fread(&v, 4, 1, fp);
+	if (v != PASS_0_DONE && v != PASS_1_DONE && v != TREE_IS_BUILT
+	    && v != SEMANTIC_DONE && v != LOST_FOUND_DONE) {
+		reiserfs_warning(stderr,
+				 "is_stage_magic_correct: wrong pass found");
+		return -1;
+	}
 
+	return (__u16) v;
+}
 
-reiserfs_bitmap_t * reiserfs_bitmap_load (FILE * fp)
+reiserfs_bitmap_t *reiserfs_bitmap_load(FILE * fp)
 {
 //    FILE * fp;
-    __u32 v;
-    int count;
-    int i, j;
-    int extents;
-    int bit;
-    reiserfs_bitmap_t * bm;
-    
+	__u32 v;
+	int count;
+	int i, j;
+	int extents;
+	int bit;
+	reiserfs_bitmap_t *bm;
+
 /*    fp = fopen (filename, "r");
     if (!fp) {
 	reiserfs_warning (stderr, "reiserfs_bitmap_load: fopen failed: %s\n", strerror(errno));
 	return 0;
     }*/
 
-    fread (&v, 4, 1, fp);
-    if (v != BITMAP_START_MAGIC) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_load: "
-			  "no bitmap start magic found");	
-//	fclose (fp);
-	return 0;
-    }
-	
-    /* read bit size of bitmap */
-    fread (&v, 4, 1, fp);
-
-    bm = reiserfs_create_bitmap (v);
-    if (!bm) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_load: creation failed");	
-//	fclose (fp);
-	return 0;
-    }
-    
-    /*printf ("LOAD: bit_size - %d\n", v);*/
+	fread(&v, 4, 1, fp);
+	if (v != BITMAP_START_MAGIC) {
+		reiserfs_warning(stderr, "reiserfs_bitmap_load: "
+				 "no bitmap start magic found");
+//      fclose (fp);
+		return 0;
+	}
+
+	/* read bit size of bitmap */
+	fread(&v, 4, 1, fp);
+
+	bm = reiserfs_create_bitmap(v);
+	if (!bm) {
+		reiserfs_warning(stderr,
+				 "reiserfs_bitmap_load: creation failed");
+//      fclose (fp);
+		return 0;
+	}
 
-    fread (&extents, 4, 1, fp);
+	/*printf ("LOAD: bit_size - %d\n", v); */
 
-    /*printf ("LOAD: extents - %d\n", extents);*/
+	fread(&extents, 4, 1, fp);
 
-    bit = 0;
-    for (i = 0; i < extents; i ++) {
-	fread (&count, 4, 1, fp);
+	/*printf ("LOAD: extents - %d\n", extents); */
+
+	bit = 0;
+	for (i = 0; i < extents; i++) {
+		fread(&count, 4, 1, fp);
 /*
 	if (i % 2)
 	    printf ("LOAD: Free %d\n", count);
 	else
 	    printf ("LOAD: Used %d\n", count);
 */
-	for (j = 0; j < count; j ++, bit ++)
-	    if (i % 2 == 0) {
-		reiserfs_bitmap_set_bit (bm, bit);
-	    }
-    }
+		for (j = 0; j < count; j++, bit++)
+			if (i % 2 == 0) {
+				reiserfs_bitmap_set_bit(bm, bit);
+			}
+	}
 
-    fread (&v, 4, 1, fp);
+	fread(&v, 4, 1, fp);
 
-    /*printf ("LOAD: Endmagic %d\n", v);*/
+	/*printf ("LOAD: Endmagic %d\n", v); */
 
 //    fclose (fp);
-    if (v != BITMAP_END_MAGIC) {
-	reiserfs_warning (stderr, "reiserfs_bitmap_load: "
-			  "no bitmap end magic found");
-	return 0;
-    }
+	if (v != BITMAP_END_MAGIC) {
+		reiserfs_warning(stderr, "reiserfs_bitmap_load: "
+				 "no bitmap end magic found");
+		return 0;
+	}
 
-    /*    reiserfs_warning (stderr, "%d bits set - done\n", reiserfs_bitmap_ones (bm));*/
-    fflush (stderr);
-    return bm;
+	/*    reiserfs_warning (stderr, "%d bits set - done\n", reiserfs_bitmap_ones (bm)); */
+	fflush(stderr);
+	return bm;
 }
 
-
-void reiserfs_bitmap_invert (reiserfs_bitmap_t * bm)
+void reiserfs_bitmap_invert(reiserfs_bitmap_t *bm)
 {
-    unsigned int i;
-
-    /*reiserfs_warning (stderr, "Bitmap inverting..");fflush (stderr);*/
-    for (i = 0; i < bm->bm_bit_size; i ++) {
-	if (reiserfs_bitmap_test_bit (bm, i))
-	    reiserfs_bitmap_clear_bit (bm, i);
-	else
-	    reiserfs_bitmap_set_bit (bm, i);
-    }
+	unsigned int i;
+
+	/*reiserfs_warning (stderr, "Bitmap inverting..");fflush (stderr); */
+	for (i = 0; i < bm->bm_bit_size; i++) {
+		if (reiserfs_bitmap_test_bit(bm, i))
+			reiserfs_bitmap_clear_bit(bm, i);
+		else
+			reiserfs_bitmap_set_bit(bm, i);
+	}
 
-    /*reiserfs_warning (stderr, "done\n");*/
+	/*reiserfs_warning (stderr, "done\n"); */
 }
 
-
-void reiserfs_free_ondisk_bitmap (reiserfs_filsys_t * fs)
+void reiserfs_free_ondisk_bitmap(reiserfs_filsys_t *fs)
 {
-    if (fs->fs_bitmap2) {
-	reiserfs_delete_bitmap (fs->fs_bitmap2);
-	fs->fs_bitmap2 = 0;
-    }
+	if (fs->fs_bitmap2) {
+		reiserfs_delete_bitmap(fs->fs_bitmap2);
+		fs->fs_bitmap2 = 0;
+	}
 }
 
 /* read bitmap blocks */
-int reiserfs_open_ondisk_bitmap (reiserfs_filsys_t * fs)
+int reiserfs_open_ondisk_bitmap(reiserfs_filsys_t *fs)
 {
-    unsigned int blocks = get_sb_block_count(fs->fs_ondisk_sb) ;
-    unsigned int bmap_nr = reiserfs_bmap_nr(blocks, fs->fs_blocksize);
-
-    if (fs->fs_bitmap2)
-	reiserfs_panic ("bitmap is initiaized already");
-
-    fs->fs_bitmap2 = reiserfs_create_bitmap (blocks);
-    if (!fs->fs_bitmap2)
-	return -1;
-
-    if (reiserfs_bmap_over(bmap_nr)) {
-	     if (get_sb_bmap_nr(fs->fs_ondisk_sb) != 0) {
-		reiserfs_warning (stderr, "%s: large file system has "
-		                  "incorrect bitmap count %u. Should be 0 "
-				  "to indicate overflow.\nPlease re-run with "
-				  "--rebuild-sb to fix it.\n", __FUNCTION__,
-				  get_sb_bmap_nr(fs->fs_ondisk_sb));
+	unsigned int blocks = get_sb_block_count(fs->fs_ondisk_sb);
+	unsigned int bmap_nr = reiserfs_bmap_nr(blocks, fs->fs_blocksize);
+
+	if (fs->fs_bitmap2)
+		reiserfs_panic("bitmap is initiaized already");
+
+	fs->fs_bitmap2 = reiserfs_create_bitmap(blocks);
+	if (!fs->fs_bitmap2)
 		return -1;
-	     }
-    } else if (bmap_nr != get_sb_bmap_nr (fs->fs_ondisk_sb)) {
-	reiserfs_warning (stderr, "%s: wrong either bitmaps number,\n",
-	                  __FUNCTION__);
-	reiserfs_warning (stderr, "count of blocks or blocksize, run with "
-	                  "--rebuild-sb to fix it\n");
-	return -1;
-    }
-
-    return reiserfs_fetch_ondisk_bitmap (fs->fs_bitmap2, fs);
+
+	if (reiserfs_bmap_over(bmap_nr)) {
+		if (get_sb_bmap_nr(fs->fs_ondisk_sb) != 0) {
+			reiserfs_warning(stderr, "%s: large file system has "
+					 "incorrect bitmap count %u. Should be 0 "
+					 "to indicate overflow.\nPlease re-run with "
+					 "--rebuild-sb to fix it.\n",
+					 __FUNCTION__,
+					 get_sb_bmap_nr(fs->fs_ondisk_sb));
+			return -1;
+		}
+	} else if (bmap_nr != get_sb_bmap_nr(fs->fs_ondisk_sb)) {
+		reiserfs_warning(stderr, "%s: wrong either bitmaps number,\n",
+				 __FUNCTION__);
+		reiserfs_warning(stderr,
+				 "count of blocks or blocksize, run with "
+				 "--rebuild-sb to fix it\n");
+		return -1;
+	}
+
+	return reiserfs_fetch_ondisk_bitmap(fs->fs_bitmap2, fs);
 }
 
-int reiserfs_create_ondisk_bitmap (reiserfs_filsys_t * fs)
+int reiserfs_create_ondisk_bitmap(reiserfs_filsys_t *fs)
 {
-    if (fs->fs_bitmap2)
-	reiserfs_panic ("bitmap is initiaized already");
+	if (fs->fs_bitmap2)
+		reiserfs_panic("bitmap is initiaized already");
 
-    fs->fs_bitmap2 = reiserfs_create_bitmap (get_sb_block_count (fs->fs_ondisk_sb));
-    if (!fs->fs_bitmap2)
-	return 0;
+	fs->fs_bitmap2 =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	if (!fs->fs_bitmap2)
+		return 0;
 
-    return 1;
+	return 1;
 }
 
-void reiserfs_close_ondisk_bitmap (reiserfs_filsys_t * fs)
+void reiserfs_close_ondisk_bitmap(reiserfs_filsys_t *fs)
 {
-    if (!fs->fs_bitmap2)
-	return;
-    reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs);
-    reiserfs_free_ondisk_bitmap (fs);
+	if (!fs->fs_bitmap2)
+		return;
+	reiserfs_flush_to_ondisk_bitmap(fs->fs_bitmap2, fs);
+	reiserfs_free_ondisk_bitmap(fs);
 }
diff --git a/reiserfscore/do_balan.c b/reiserfscore/do_balan.c
index 7a9ae24..1cddc8d 100644
--- a/reiserfscore/do_balan.c
+++ b/reiserfscore/do_balan.c
@@ -9,7 +9,6 @@
 /* balance the tree according to the analysis made before,		*/
 /* and using buffers obtained after all above.				*/
 
-
 /**
  ** balance_leaf_when_delete
  ** balance_leaf
@@ -42,8 +41,6 @@ be performed by do_balance.
 
 -Hans */
 
-
-
 /* Balance leaf node in case of delete or cut: insert_size[0] < 0
  *
  * lnum, rnum can have values >= -1
@@ -51,1004 +48,1517 @@ be performed by do_balance.
  *	 0 means that nothing should be done with the neighbor
  *	>0 means to shift entirely or partly the specified number of items to the neighbor
  */
-static int balance_leaf_when_delete (/*struct reiserfs_transaction_handle *th,*/
-				     struct tree_balance * tb, 
-				     int flag)
+static int balance_leaf_when_delete(	/*struct reiserfs_transaction_handle *th, */
+					   struct tree_balance *tb, int flag)
 {
-    struct buffer_head * tbS0 = PATH_PLAST_BUFFER (tb->tb_path);
-    int item_pos = PATH_LAST_POSITION (tb->tb_path);
-    int pos_in_item = tb->tb_path->pos_in_item;
-    struct buffer_info bi;
-    int n;
-    struct item_head * ih;
-
-    ih = B_N_PITEM_HEAD (tbS0, item_pos);
-
-    /* Delete or truncate the item */
-
-    switch (flag) {
-    case M_DELETE:   /* delete item in S[0] */
-
-	bi.bi_bh = tbS0;
-	bi.bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-	bi.bi_position = PATH_H_POSITION (tb->tb_path, 1);
-	leaf_delete_items (tb->tb_fs, &bi, 0, item_pos, 1, -1);
-
-	if ( ! item_pos ) {
-	    // we have removed first item in the node - update left delimiting key
-	    if ( B_NR_ITEMS(tbS0) ) {
-		replace_key(tb->tb_fs, tb->CFL[0],tb->lkey[0],tbS0,0);
-	    }
-	    else {
-		if ( ! PATH_H_POSITION (tb->tb_path, 1) )
-		    replace_key(tb->tb_fs, tb->CFL[0],tb->lkey[0],PATH_H_PPARENT(tb->tb_path, 0),0);
-	    }
-	} 
-    
-	break;
-
-    case M_CUT: {  /* cut item in S[0] */
-	bi.bi_bh = tbS0;
-	bi.bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-	bi.bi_position = PATH_H_POSITION (tb->tb_path, 1);
-	if (I_IS_DIRECTORY_ITEM (ih)) {
-	    /* UFS unlink semantics are such that you can only delete
-               one directory entry at a time. */
-	    /* when we cut a directory tb->insert_size[0] means number
-               of entries to be cut (always 1) */
-	    tb->insert_size[0] = -1;
-	    leaf_cut_from_buffer (tb->tb_fs, &bi, item_pos, pos_in_item, -tb->insert_size[0]);
-
-	    if ( ! item_pos && ! pos_in_item ) {
-		replace_key(tb->tb_fs, tb->CFL[0],tb->lkey[0],tbS0,0);
-	    }
-	} else {
-	    leaf_cut_from_buffer (tb->tb_fs, &bi, item_pos, pos_in_item, -tb->insert_size[0]);
-	}
-	break;
-    }
-
-    default:
-	print_tb(flag, item_pos, pos_in_item, tb,"when_del");
-	reiserfs_panic ("PAP-12040: balance_leaf_when_delete: unexpectable mode: %s(%d)",
-			(flag == M_PASTE) ? "PASTE" : ((flag == M_INSERT) ? "INSERT" : "UNKNOWN"), flag);
-    }
-
-    /* the rule is that no shifting occurs unless by shifting a node can be freed */
-    n = B_NR_ITEMS(tbS0);
-    if ( tb->lnum[0] )     /* L[0] takes part in balancing */
-    {
-	if ( tb->lnum[0] == -1 )    /* L[0] must be joined with S[0] */
-	{
-	    if ( tb->rnum[0] == -1 )    /* R[0] must be also joined with S[0] */
-	    {			
-		if ( tb->FR[0] == PATH_H_PPARENT(tb->tb_path, 0) )
-		{
-		    /* all contents of all the 3 buffers will be in L[0] */
-		    if ( PATH_H_POSITION (tb->tb_path, 1) == 0 && 1 < B_NR_ITEMS(tb->FR[0]) )
-			replace_key(tb->tb_fs, tb->CFL[0],tb->lkey[0],tb->FR[0],1);
-
-
-		    leaf_move_items (LEAF_FROM_S_TO_L, tb, n, -1, 0);
-		    leaf_move_items (LEAF_FROM_R_TO_L, tb, B_NR_ITEMS(tb->R[0]), -1, 0);
-
-		    reiserfs_invalidate_buffer (tb, tbS0, 1/*do_free_block*/);
-		    reiserfs_invalidate_buffer (tb, tb->R[0], 1/*do_free_block*/);
-
-		    return 0;
-		}
-		/* all contents of all the 3 buffers will be in R[0] */
-		leaf_move_items(LEAF_FROM_S_TO_R, tb, n, -1, 0);
-		leaf_move_items(LEAF_FROM_L_TO_R, tb, B_NR_ITEMS(tb->L[0]), -1, 0);
+	struct buffer_head *tbS0 = PATH_PLAST_BUFFER(tb->tb_path);
+	int item_pos = PATH_LAST_POSITION(tb->tb_path);
+	int pos_in_item = tb->tb_path->pos_in_item;
+	struct buffer_info bi;
+	int n;
+	struct item_head *ih;
 
-		/* right_delimiting_key is correct in R[0] */
-		replace_key(tb->tb_fs, tb->CFR[0],tb->rkey[0],tb->R[0],0);
+	ih = B_N_PITEM_HEAD(tbS0, item_pos);
 
-		reiserfs_invalidate_buffer (tb, tbS0, 1/*do_free_block*/);
-		reiserfs_invalidate_buffer (tb, tb->L[0], 1/*do_free_block*/);
+	/* Delete or truncate the item */
 
-		return -1;
-	    }
+	switch (flag) {
+	case M_DELETE:		/* delete item in S[0] */
+
+		bi.bi_bh = tbS0;
+		bi.bi_parent = PATH_H_PPARENT(tb->tb_path, 0);
+		bi.bi_position = PATH_H_POSITION(tb->tb_path, 1);
+		leaf_delete_items(tb->tb_fs, &bi, 0, item_pos, 1, -1);
+
+		if (!item_pos) {
+			// we have removed first item in the node - update left delimiting key
+			if (B_NR_ITEMS(tbS0)) {
+				replace_key(tb->tb_fs, tb->CFL[0], tb->lkey[0],
+					    tbS0, 0);
+			} else {
+				if (!PATH_H_POSITION(tb->tb_path, 1))
+					replace_key(tb->tb_fs, tb->CFL[0],
+						    tb->lkey[0],
+						    PATH_H_PPARENT(tb->tb_path,
+								   0), 0);
+			}
+		}
 
-	    /* all contents of L[0] and S[0] will be in L[0] */
-	    leaf_shift_left(tb, n, -1);
+		break;
 
-	    reiserfs_invalidate_buffer (tb, tbS0, 1/*do_free_block*/);
+	case M_CUT:{		/* cut item in S[0] */
+			bi.bi_bh = tbS0;
+			bi.bi_parent = PATH_H_PPARENT(tb->tb_path, 0);
+			bi.bi_position = PATH_H_POSITION(tb->tb_path, 1);
+			if (I_IS_DIRECTORY_ITEM(ih)) {
+				/* UFS unlink semantics are such that you can only delete
+				   one directory entry at a time. */
+				/* when we cut a directory tb->insert_size[0] means number
+				   of entries to be cut (always 1) */
+				tb->insert_size[0] = -1;
+				leaf_cut_from_buffer(tb->tb_fs, &bi, item_pos,
+						     pos_in_item,
+						     -tb->insert_size[0]);
+
+				if (!item_pos && !pos_in_item) {
+					replace_key(tb->tb_fs, tb->CFL[0],
+						    tb->lkey[0], tbS0, 0);
+				}
+			} else {
+				leaf_cut_from_buffer(tb->tb_fs, &bi, item_pos,
+						     pos_in_item,
+						     -tb->insert_size[0]);
+			}
+			break;
+		}
 
-	    return 0;
+	default:
+		print_tb(flag, item_pos, pos_in_item, tb, "when_del");
+		reiserfs_panic
+		    ("PAP-12040: balance_leaf_when_delete: unexpectable mode: %s(%d)",
+		     (flag ==
+		      M_PASTE) ? "PASTE" : ((flag ==
+					     M_INSERT) ? "INSERT" : "UNKNOWN"),
+		     flag);
 	}
-	/* a part of contents of S[0] will be in L[0] and the rest part of S[0] will be in R[0] */
 
-	leaf_shift_left (tb, tb->lnum[0], tb->lbytes);
-	leaf_shift_right(tb, tb->rnum[0], tb->rbytes);
+	/* the rule is that no shifting occurs unless by shifting a node can be freed */
+	n = B_NR_ITEMS(tbS0);
+	if (tb->lnum[0]) {	/* L[0] takes part in balancing */
+		if (tb->lnum[0] == -1) {	/* L[0] must be joined with S[0] */
+			if (tb->rnum[0] == -1) {	/* R[0] must be also joined with S[0] */
+				if (tb->FR[0] == PATH_H_PPARENT(tb->tb_path, 0)) {
+					/* all contents of all the 3 buffers will be in L[0] */
+					if (PATH_H_POSITION(tb->tb_path, 1) == 0
+					    && 1 < B_NR_ITEMS(tb->FR[0]))
+						replace_key(tb->tb_fs,
+							    tb->CFL[0],
+							    tb->lkey[0],
+							    tb->FR[0], 1);
+
+					leaf_move_items(LEAF_FROM_S_TO_L, tb, n,
+							-1, 0);
+					leaf_move_items(LEAF_FROM_R_TO_L, tb,
+							B_NR_ITEMS(tb->R[0]),
+							-1, 0);
+
+					reiserfs_invalidate_buffer(tb, tbS0,
+								   1
+								   /*do_free_block */
+								   );
+					reiserfs_invalidate_buffer(tb, tb->R[0],
+								   1
+								   /*do_free_block */
+								   );
+
+					return 0;
+				}
+				/* all contents of all the 3 buffers will be in R[0] */
+				leaf_move_items(LEAF_FROM_S_TO_R, tb, n, -1, 0);
+				leaf_move_items(LEAF_FROM_L_TO_R, tb,
+						B_NR_ITEMS(tb->L[0]), -1, 0);
+
+				/* right_delimiting_key is correct in R[0] */
+				replace_key(tb->tb_fs, tb->CFR[0], tb->rkey[0],
+					    tb->R[0], 0);
+
+				reiserfs_invalidate_buffer(tb, tbS0,
+							   1 /*do_free_block */
+							   );
+				reiserfs_invalidate_buffer(tb, tb->L[0],
+							   1 /*do_free_block */
+							   );
+
+				return -1;
+			}
 
-	reiserfs_invalidate_buffer (tb, tbS0, 1/*do_free_block*/);
+			/* all contents of L[0] and S[0] will be in L[0] */
+			leaf_shift_left(tb, n, -1);
 
-	return 0;
-    }
+			reiserfs_invalidate_buffer(tb, tbS0,
+						   1 /*do_free_block */ );
+
+			return 0;
+		}
+		/* a part of contents of S[0] will be in L[0] and the rest part of S[0] will be in R[0] */
+
+		leaf_shift_left(tb, tb->lnum[0], tb->lbytes);
+		leaf_shift_right(tb, tb->rnum[0], tb->rbytes);
 
-    if ( tb->rnum[0] == -1 ) {
-	/* all contents of R[0] and S[0] will be in R[0] */
-	leaf_shift_right(tb, n, -1);
-	reiserfs_invalidate_buffer (tb, tbS0, 1/*do_free_block*/);
+		reiserfs_invalidate_buffer(tb, tbS0, 1 /*do_free_block */ );
+
+		return 0;
+	}
+
+	if (tb->rnum[0] == -1) {
+		/* all contents of R[0] and S[0] will be in R[0] */
+		leaf_shift_right(tb, n, -1);
+		reiserfs_invalidate_buffer(tb, tbS0, 1 /*do_free_block */ );
+		return 0;
+	}
 	return 0;
-    }
-    return 0;
 }
 
-static int balance_leaf(/*struct reiserfs_transaction_handle *th, */
-			struct tree_balance * tb, /* see reiserfs_fs.h */
-			struct item_head * ih, /* item header of inserted item */
-			const char * body,		/* body  of inserted item or bytes to paste */
-			int flag,			/* i - insert, d - delete, c - cut, p - paste
-							   (see comment to do_balance) */
-			int zeros_number,		/* it is always 0 */
-				
-			struct item_head * insert_key,  /* in our processing of one level we sometimes determine what
-							   must be inserted into the next higher level.  This insertion
-							   consists of a key or two keys and their corresponding
-							   pointers */
-			struct buffer_head ** insert_ptr /* inserted node-ptrs for the next level */
+static int balance_leaf(	/*struct reiserfs_transaction_handle *th, */
+			       struct tree_balance *tb,	/* see reiserfs_fs.h */
+			       struct item_head *ih,	/* item header of inserted item */
+			       const char *body,	/* body  of inserted item or bytes to paste */
+			       int flag,	/* i - insert, d - delete, c - cut, p - paste
+						   (see comment to do_balance) */
+			       int zeros_number,	/* it is always 0 */
+			       struct item_head *insert_key,	/* in our processing of one level we sometimes determine what
+								   must be inserted into the next higher level.  This insertion
+								   consists of a key or two keys and their corresponding
+								   pointers */
+			       struct buffer_head **insert_ptr	/* inserted node-ptrs for the next level */
     )
 {
-    int pos_in_item = tb->tb_path->pos_in_item; /* position in item, in bytes for direct and
-						   indirect items, in entries for directories (for
-						   which it is an index into the array of directory
-						   entry headers.) */
-    struct buffer_head * tbS0 = PATH_PLAST_BUFFER (tb->tb_path);
+	int pos_in_item = tb->tb_path->pos_in_item;	/* position in item, in bytes for direct and
+							   indirect items, in entries for directories (for
+							   which it is an index into the array of directory
+							   entry headers.) */
+	struct buffer_head *tbS0 = PATH_PLAST_BUFFER(tb->tb_path);
 /*  struct buffer_head * tbF0 = PATH_H_PPARENT (tb->tb_path, 0);
     int S0_b_item_order = PATH_H_B_ITEM_ORDER (tb->tb_path, 0);*/
-    int item_pos = PATH_LAST_POSITION (tb->tb_path);	/*  index into the array of item headers in S[0] 
-							    of the affected item */
-    struct buffer_info bi;
-    struct buffer_head *S_new[2];  /* new nodes allocated to hold what could not fit into S */
-    int snum[2];			   /* number of items that will be placed into S_new (includes partially shifted items) */
-    int sbytes[2];                   /* if an item is partially shifted into S_new then 
-					if it is a directory item 
-					it is the number of entries from the item that are shifted into S_new
-					else
-					it is the number of bytes from the item that are shifted into S_new
-				     */
-    int n, i;
-    int ret_val;
-
-    /* Make balance in case insert_size[0] < 0 */
-    if ( tb->insert_size[0] < 0 )
-	return balance_leaf_when_delete (/*th,*/ tb, flag);
-  
-    /* for indirect item pos_in_item is measured in unformatted node
-       pointers. Recalculate to bytes */
-    if (flag != M_INSERT && I_IS_INDIRECT_ITEM (B_N_PITEM_HEAD (tbS0, item_pos)))
-	pos_in_item *= UNFM_P_SIZE;
-
-    if ( tb->lnum[0] > 0 ) {
-	/* Shift lnum[0] items from S[0] to the left neighbor L[0] */
-	if ( item_pos < tb->lnum[0] ) {
-	    /* new item or it part falls to L[0], shift it too */
-	    n = B_NR_ITEMS(tb->L[0]);
-
-	    switch (flag) {
-	    case M_INSERT:   /* insert item into L[0] */
-
-		if ( item_pos == tb->lnum[0] - 1 && tb->lbytes != -1 ) {
-		    /* part of new item falls into L[0] */
-		    int new_item_len;
-
-		    ret_val = leaf_shift_left (/*th,*/ tb, tb->lnum[0]-1, -1);
-		    /* Calculate item length to insert to S[0] */
-		    new_item_len = get_ih_item_len (ih) - tb->lbytes;
-		    /* Calculate and check item length to insert to L[0] */
-		    set_ih_item_len (ih, get_ih_item_len (ih) - new_item_len);
-		    /* Insert new item into L[0] */
-		    bi.bi_bh = tb->L[0];
-		    bi.bi_parent = tb->FL[0];
-		    bi.bi_position = get_left_neighbor_position (tb, 0);
-		    leaf_insert_into_buf (tb->tb_fs, &bi, n + item_pos - ret_val, ih, body,
-					  zeros_number > get_ih_item_len (ih) ? get_ih_item_len (ih) : zeros_number);
-
-		    /* Calculate key component, item length and body to insert into S[0] */
-		    //ih->ih_key.k_offset += tb->lbytes;
-		    set_offset (key_format (&ih->ih_key), &ih->ih_key, get_offset (&ih->ih_key) +
-		    	tb->lbytes * (is_indirect_ih(ih) ? tb->tb_fs->fs_blocksize / UNFM_P_SIZE : 1) );
-		    set_ih_item_len (ih, new_item_len);
-		    if ( tb->lbytes >  zeros_number ) {
-			body += (tb->lbytes - zeros_number);
-			zeros_number = 0;
-		    }
-		    else
-			zeros_number -= tb->lbytes;
-		} else {
-		    /* new item in whole falls into L[0] */
-		    /* Shift lnum[0]-1 items to L[0] */
-		    ret_val = leaf_shift_left(tb, tb->lnum[0]-1, tb->lbytes);
-
-		    /* Insert new item into L[0] */
-		    bi.bi_bh = tb->L[0];
-		    bi.bi_parent = tb->FL[0];
-		    bi.bi_position = get_left_neighbor_position (tb, 0);
-		    leaf_insert_into_buf (tb->tb_fs, &bi, n + item_pos - ret_val, ih, body, zeros_number);
-
-		    tb->insert_size[0] = 0;
-		    zeros_number = 0;
-		}
-		break;
-
-	    case M_PASTE:   /* append item in L[0] */
-
-		if ( item_pos == tb->lnum[0] - 1 && tb->lbytes != -1 ) {
-		    /* we must shift the part of the appended item */
-		    if ( I_IS_DIRECTORY_ITEM (B_N_PITEM_HEAD (tbS0, item_pos))) {
-			/* directory item */
-			if ( tb->lbytes > pos_in_item ) {
-			    /* new directory entry falls into L[0] */
-			    struct item_head * pasted;
-			    int l_pos_in_item = pos_in_item;
-							  
-			    /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 entries from given directory item */
-			    ret_val = leaf_shift_left(tb, tb->lnum[0], tb->lbytes - 1);
-			    if ( ret_val && ! item_pos ) {
-				pasted =  B_N_PITEM_HEAD(tb->L[0],B_NR_ITEMS(tb->L[0])-1);
-				l_pos_in_item += get_ih_entry_count(pasted) - (tb->lbytes-1);
-			    }
-
-			    /* Append given directory entry to directory item */
-			    bi.bi_bh = tb->L[0];
-			    bi.bi_parent = tb->FL[0];
-			    bi.bi_position = get_left_neighbor_position (tb, 0);
-			    leaf_paste_in_buffer (tb->tb_fs, &bi, n + item_pos - ret_val, l_pos_in_item,
-						  tb->insert_size[0], body, zeros_number);
-
-			    /* previous string prepared space for pasting new entry, following string pastes this entry */
-
-			    /* when we have merge directory item, pos_in_item has been changed too */
-
-			    /* paste new directory entry. 1 is entry number */
-			    leaf_paste_entries (bi.bi_bh, n + item_pos - ret_val, l_pos_in_item, 1,
-						(struct reiserfs_de_head *)body, 
-						body + DEH_SIZE, tb->insert_size[0]
-				);
-			    tb->insert_size[0] = 0;
-			} else {
-			    /* new directory item doesn't fall into L[0] */
-			    /* Shift lnum[0]-1 items in whole. Shift lbytes directory entries from directory item number lnum[0] */
-			    leaf_shift_left (tb, tb->lnum[0], tb->lbytes);
-			}
-			/* Calculate new position to append in item body */
-			pos_in_item -= tb->lbytes;
-		    }
-		    else {
-			/* regular object */
-			if ( tb->lbytes >= pos_in_item ) {
-			    /* appended item will be in L[0] in whole */
-			    int l_n, temp_n;
-                            struct reiserfs_key *key;
-
-			    /* this bytes number must be appended to the last item of L[h] */
-			    l_n = tb->lbytes - pos_in_item;
-
-			    /* Calculate new insert_size[0] */
-			    tb->insert_size[0] -= l_n;
-
-			    ret_val =  leaf_shift_left(tb, tb->lnum[0],
-						       get_ih_item_len (B_N_PITEM_HEAD(tbS0,item_pos)));
-			    /* Append to body of item in L[0] */
-			    bi.bi_bh = tb->L[0];
-			    bi.bi_parent = tb->FL[0];
-			    bi.bi_position = get_left_neighbor_position (tb, 0);
-			    leaf_paste_in_buffer(tb->tb_fs, 
-						 &bi,n + item_pos - ret_val,
-						 get_ih_item_len (B_N_PITEM_HEAD(tb->L[0],n+item_pos-ret_val)),
-						 l_n,body, zeros_number > l_n ? l_n : zeros_number);
-
-
-			    /* 0-th item in S0 can be only of DIRECT type when l_n != 0*/
-			    //B_N_PKEY (tbS0, 0)->k_offset += l_n;z
-			    key = B_N_PKEY (tbS0, 0);
-                            temp_n = is_indirect_ih(B_N_PITEM_HEAD (tb->L[0], n + item_pos - ret_val)) ?
-                                 (int)((l_n / UNFM_P_SIZE) * tb->tb_fs->fs_blocksize) : l_n;
-
-			    set_offset (key_format (key), key, get_offset (key) + temp_n);
-
-			    //B_N_PDELIM_KEY(tb->CFL[0],tb->lkey[0])->k_offset += l_n;
-			    key = B_N_PDELIM_KEY(tb->CFL[0],tb->lkey[0]);
-			    set_offset (key_format (key), key, get_offset (key) + temp_n);
-
-			    /* Calculate new body, position in item and insert_size[0] */
-			    if ( l_n > zeros_number ) {
-				body += (l_n - zeros_number);
-				zeros_number = 0;
-			    }
-			    else
-				zeros_number -= l_n;
-			    pos_in_item = 0;	
-			}
-			else {
-			    /* only part of the appended item will be in L[0] */
-
-			    /* Calculate position in item for append in S[0] */
-			    pos_in_item -= tb->lbytes;
-
-			    /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 byte from item number lnum[0] */
-			    leaf_shift_left(tb,tb->lnum[0],tb->lbytes);
+	int item_pos = PATH_LAST_POSITION(tb->tb_path);	/*  index into the array of item headers in S[0] 
+							   of the affected item */
+	struct buffer_info bi;
+	struct buffer_head *S_new[2];	/* new nodes allocated to hold what could not fit into S */
+	int snum[2];		/* number of items that will be placed into S_new (includes partially shifted items) */
+	int sbytes[2];		/* if an item is partially shifted into S_new then 
+				   if it is a directory item 
+				   it is the number of entries from the item that are shifted into S_new
+				   else
+				   it is the number of bytes from the item that are shifted into S_new
+				 */
+	int n, i;
+	int ret_val;
+
+	/* Make balance in case insert_size[0] < 0 */
+	if (tb->insert_size[0] < 0)
+		return balance_leaf_when_delete( /*th, */ tb, flag);
+
+	/* for indirect item pos_in_item is measured in unformatted node
+	   pointers. Recalculate to bytes */
+	if (flag != M_INSERT
+	    && I_IS_INDIRECT_ITEM(B_N_PITEM_HEAD(tbS0, item_pos)))
+		pos_in_item *= UNFM_P_SIZE;
+
+	if (tb->lnum[0] > 0) {
+		/* Shift lnum[0] items from S[0] to the left neighbor L[0] */
+		if (item_pos < tb->lnum[0]) {
+			/* new item or it part falls to L[0], shift it too */
+			n = B_NR_ITEMS(tb->L[0]);
+
+			switch (flag) {
+			case M_INSERT:	/* insert item into L[0] */
+
+				if (item_pos == tb->lnum[0] - 1
+				    && tb->lbytes != -1) {
+					/* part of new item falls into L[0] */
+					int new_item_len;
+
+					ret_val =
+					    leaf_shift_left( /*th, */ tb,
+							    tb->lnum[0] - 1,
+							    -1);
+					/* Calculate item length to insert to S[0] */
+					new_item_len =
+					    get_ih_item_len(ih) - tb->lbytes;
+					/* Calculate and check item length to insert to L[0] */
+					set_ih_item_len(ih,
+							get_ih_item_len(ih) -
+							new_item_len);
+					/* Insert new item into L[0] */
+					bi.bi_bh = tb->L[0];
+					bi.bi_parent = tb->FL[0];
+					bi.bi_position =
+					    get_left_neighbor_position(tb, 0);
+					leaf_insert_into_buf(tb->tb_fs, &bi,
+							     n + item_pos -
+							     ret_val, ih, body,
+							     zeros_number >
+							     get_ih_item_len(ih)
+							     ?
+							     get_ih_item_len(ih)
+							     : zeros_number);
+
+					/* Calculate key component, item length and body to insert into S[0] */
+					//ih->ih_key.k_offset += tb->lbytes;
+					set_offset(key_format(&ih->ih_key),
+						   &ih->ih_key,
+						   get_offset(&ih->ih_key) +
+						   tb->lbytes *
+						   (is_indirect_ih(ih) ? tb->
+						    tb_fs->fs_blocksize /
+						    UNFM_P_SIZE : 1));
+					set_ih_item_len(ih, new_item_len);
+					if (tb->lbytes > zeros_number) {
+						body +=
+						    (tb->lbytes - zeros_number);
+						zeros_number = 0;
+					} else
+						zeros_number -= tb->lbytes;
+				} else {
+					/* new item in whole falls into L[0] */
+					/* Shift lnum[0]-1 items to L[0] */
+					ret_val =
+					    leaf_shift_left(tb, tb->lnum[0] - 1,
+							    tb->lbytes);
+
+					/* Insert new item into L[0] */
+					bi.bi_bh = tb->L[0];
+					bi.bi_parent = tb->FL[0];
+					bi.bi_position =
+					    get_left_neighbor_position(tb, 0);
+					leaf_insert_into_buf(tb->tb_fs, &bi,
+							     n + item_pos -
+							     ret_val, ih, body,
+							     zeros_number);
+
+					tb->insert_size[0] = 0;
+					zeros_number = 0;
+				}
+				break;
+
+			case M_PASTE:	/* append item in L[0] */
+
+				if (item_pos == tb->lnum[0] - 1
+				    && tb->lbytes != -1) {
+					/* we must shift the part of the appended item */
+					if (I_IS_DIRECTORY_ITEM
+					    (B_N_PITEM_HEAD(tbS0, item_pos))) {
+						/* directory item */
+						if (tb->lbytes > pos_in_item) {
+							/* new directory entry falls into L[0] */
+							struct item_head
+							    *pasted;
+							int l_pos_in_item =
+							    pos_in_item;
+
+							/* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 entries from given directory item */
+							ret_val =
+							    leaf_shift_left(tb,
+									    tb->
+									    lnum
+									    [0],
+									    tb->
+									    lbytes
+									    -
+									    1);
+							if (ret_val
+							    && !item_pos) {
+								pasted =
+								    B_N_PITEM_HEAD
+								    (tb->L[0],
+								     B_NR_ITEMS
+								     (tb->
+								      L[0]) -
+								     1);
+								l_pos_in_item +=
+								    get_ih_entry_count
+								    (pasted) -
+								    (tb->
+								     lbytes -
+								     1);
+							}
+
+							/* Append given directory entry to directory item */
+							bi.bi_bh = tb->L[0];
+							bi.bi_parent =
+							    tb->FL[0];
+							bi.bi_position =
+							    get_left_neighbor_position
+							    (tb, 0);
+							leaf_paste_in_buffer
+							    (tb->tb_fs, &bi,
+							     n + item_pos -
+							     ret_val,
+							     l_pos_in_item,
+							     tb->insert_size[0],
+							     body,
+							     zeros_number);
+
+							/* previous string prepared space for pasting new entry, following string pastes this entry */
+
+							/* when we have merge directory item, pos_in_item has been changed too */
+
+							/* paste new directory entry. 1 is entry number */
+							leaf_paste_entries(bi.
+									   bi_bh,
+									   n +
+									   item_pos
+									   -
+									   ret_val,
+									   l_pos_in_item,
+									   1,
+									   (struct
+									    reiserfs_de_head
+									    *)
+									   body,
+									   body
+									   +
+									   DEH_SIZE,
+									   tb->
+									   insert_size
+									   [0]
+							    );
+							tb->insert_size[0] = 0;
+						} else {
+							/* new directory item doesn't fall into L[0] */
+							/* Shift lnum[0]-1 items in whole. Shift lbytes directory entries from directory item number lnum[0] */
+							leaf_shift_left(tb,
+									tb->
+									lnum[0],
+									tb->
+									lbytes);
+						}
+						/* Calculate new position to append in item body */
+						pos_in_item -= tb->lbytes;
+					} else {
+						/* regular object */
+						if (tb->lbytes >= pos_in_item) {
+							/* appended item will be in L[0] in whole */
+							int l_n, temp_n;
+							struct reiserfs_key
+							    *key;
+
+							/* this bytes number must be appended to the last item of L[h] */
+							l_n =
+							    tb->lbytes -
+							    pos_in_item;
+
+							/* Calculate new insert_size[0] */
+							tb->insert_size[0] -=
+							    l_n;
+
+							ret_val =
+							    leaf_shift_left(tb,
+									    tb->
+									    lnum
+									    [0],
+									    get_ih_item_len
+									    (B_N_PITEM_HEAD
+									     (tbS0,
+									      item_pos)));
+							/* Append to body of item in L[0] */
+							bi.bi_bh = tb->L[0];
+							bi.bi_parent =
+							    tb->FL[0];
+							bi.bi_position =
+							    get_left_neighbor_position
+							    (tb, 0);
+							leaf_paste_in_buffer
+							    (tb->tb_fs, &bi,
+							     n + item_pos -
+							     ret_val,
+							     get_ih_item_len
+							     (B_N_PITEM_HEAD
+							      (tb->L[0],
+							       n + item_pos -
+							       ret_val)), l_n,
+							     body,
+							     zeros_number >
+							     l_n ? l_n :
+							     zeros_number);
+
+							/* 0-th item in S0 can be only of DIRECT type when l_n != 0 */
+							//B_N_PKEY (tbS0, 0)->k_offset += l_n;z
+							key = B_N_PKEY(tbS0, 0);
+							temp_n =
+							    is_indirect_ih
+							    (B_N_PITEM_HEAD
+							     (tb->L[0],
+							      n + item_pos -
+							      ret_val))
+							    ? (int)((l_n /
+								     UNFM_P_SIZE)
+								    *
+								    tb->tb_fs->
+								    fs_blocksize)
+							    : l_n;
+
+							set_offset(key_format
+								   (key), key,
+								   get_offset
+								   (key) +
+								   temp_n);
+
+							//B_N_PDELIM_KEY(tb->CFL[0],tb->lkey[0])->k_offset += l_n;
+							key =
+							    B_N_PDELIM_KEY(tb->
+									   CFL
+									   [0],
+									   tb->
+									   lkey
+									   [0]);
+							set_offset(key_format
+								   (key), key,
+								   get_offset
+								   (key) +
+								   temp_n);
+
+							/* Calculate new body, position in item and insert_size[0] */
+							if (l_n > zeros_number) {
+								body +=
+								    (l_n -
+								     zeros_number);
+								zeros_number =
+								    0;
+							} else
+								zeros_number -=
+								    l_n;
+							pos_in_item = 0;
+						} else {
+							/* only part of the appended item will be in L[0] */
+
+							/* Calculate position in item for append in S[0] */
+							pos_in_item -=
+							    tb->lbytes;
+
+							/* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 byte from item number lnum[0] */
+							leaf_shift_left(tb,
+									tb->
+									lnum[0],
+									tb->
+									lbytes);
+						}
+					}
+				} else {
+					/* appended item will be in L[0] in whole */
+					struct item_head *pasted;
+
+					if (!item_pos && is_left_mergeable(tb->tb_fs, tb->tb_path) == 1) {	/* if we paste into first item of S[0] and it is left mergable */
+						/* then increment pos_in_item by the size of the last item in L[0] */
+						pasted =
+						    B_N_PITEM_HEAD(tb->L[0],
+								   n - 1);
+						if (I_IS_DIRECTORY_ITEM(pasted))
+							pos_in_item +=
+							    get_ih_entry_count
+							    (pasted);
+						else
+							pos_in_item +=
+							    get_ih_item_len
+							    (pasted);
+					}
+
+					/* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 byte from item number lnum[0] */
+					ret_val =
+					    leaf_shift_left(tb, tb->lnum[0],
+							    tb->lbytes);
+					/* Append to body of item in L[0] */
+					bi.bi_bh = tb->L[0];
+					bi.bi_parent = tb->FL[0];
+					bi.bi_position =
+					    get_left_neighbor_position(tb, 0);
+					leaf_paste_in_buffer(tb->tb_fs, &bi,
+							     n + item_pos -
+							     ret_val,
+							     pos_in_item,
+							     tb->insert_size[0],
+							     body,
+							     zeros_number);
+
+					/* if appended item is directory, paste entry */
+					pasted =
+					    B_N_PITEM_HEAD(tb->L[0],
+							   n + item_pos -
+							   ret_val);
+					if (I_IS_DIRECTORY_ITEM(pasted))
+						leaf_paste_entries(bi.bi_bh,
+								   n +
+								   item_pos -
+								   ret_val,
+								   pos_in_item,
+								   1,
+								   (struct
+								    reiserfs_de_head
+								    *)body,
+								   body +
+								   DEH_SIZE,
+								   tb->
+								   insert_size
+								   [0]);
+
+					/* if appended item is indirect item, put unformatted node into un list */
+					if (I_IS_INDIRECT_ITEM(pasted))
+						set_ih_free_space(pasted, 0);
+
+					tb->insert_size[0] = 0;
+					zeros_number = 0;
+				}
+				break;
+			default:	/* cases d and t */
+				reiserfs_panic
+				    ("PAP-12130: balance_leaf: lnum > 0: unexpectable mode: %s(%d)",
+				     (flag ==
+				      M_DELETE) ? "DELETE" : ((flag ==
+							       M_CUT) ? "CUT" :
+							      "UNKNOWN"), flag);
 			}
-		    }
 		} else {
-		    /* appended item will be in L[0] in whole */
-		    struct item_head * pasted;
-		
-		    if ( ! item_pos  && is_left_mergeable (tb->tb_fs, tb->tb_path) == 1 )
-			{ /* if we paste into first item of S[0] and it is left mergable */
-			    /* then increment pos_in_item by the size of the last item in L[0] */
-			    pasted = B_N_PITEM_HEAD(tb->L[0],n-1);
-			    if ( I_IS_DIRECTORY_ITEM(pasted) )
-				pos_in_item += get_ih_entry_count (pasted);
-			    else
-				pos_in_item += get_ih_item_len (pasted);
-			}
-
-		    /* Shift lnum[0] - 1 items in whole. Shift lbytes - 1 byte from item number lnum[0] */
-		    ret_val = leaf_shift_left(tb, tb->lnum[0], tb->lbytes);
-		    /* Append to body of item in L[0] */
-		    bi.bi_bh = tb->L[0];
-		    bi.bi_parent = tb->FL[0];
-		    bi.bi_position = get_left_neighbor_position (tb, 0);
-		    leaf_paste_in_buffer (tb->tb_fs, &bi, n + item_pos - ret_val, pos_in_item, tb->insert_size[0],
-					  body, zeros_number);
-
-		    /* if appended item is directory, paste entry */
-		    pasted = B_N_PITEM_HEAD (tb->L[0], n + item_pos - ret_val);
-		    if (I_IS_DIRECTORY_ITEM (pasted))
-			leaf_paste_entries (bi.bi_bh, n + item_pos - ret_val, pos_in_item, 1, 
-					    (struct reiserfs_de_head *)body, body + DEH_SIZE, tb->insert_size[0]);
-
-		    /* if appended item is indirect item, put unformatted node into un list */
-		    if (I_IS_INDIRECT_ITEM (pasted))
-			set_ih_free_space (pasted, 0);
-
-		    tb->insert_size[0] = 0;
-		    zeros_number = 0;
+			/* new item doesn't fall into L[0] */
+			leaf_shift_left(tb, tb->lnum[0], tb->lbytes);
 		}
-		break;
-	    default:    /* cases d and t */
-		reiserfs_panic ("PAP-12130: balance_leaf: lnum > 0: unexpectable mode: %s(%d)",
-				(flag == M_DELETE) ? "DELETE" : ((flag == M_CUT) ? "CUT" : "UNKNOWN"), flag);
-	    }
-	} else { 
-	    /* new item doesn't fall into L[0] */
-	    leaf_shift_left (tb, tb->lnum[0], tb->lbytes);
 	}
-    }	/* tb->lnum[0] > 0 */
-
-    /* Calculate new item position */
-    item_pos -= ( tb->lnum[0] - (( tb->lbytes != -1 ) ? 1 : 0));
-
-    if ( tb->rnum[0] > 0 ) {
-	/* shift rnum[0] items from S[0] to the right neighbor R[0] */
-	n = B_NR_ITEMS(tbS0);
-	switch ( flag ) {
-
-	case M_INSERT:   /* insert item */
-	    if ( n - tb->rnum[0] < item_pos ) {
-		/* new item or its part falls to R[0] */
-		if ( item_pos == n - tb->rnum[0] + 1 && tb->rbytes != -1 ) {
-		    /* part of new item falls into R[0] */
-		    loff_t old_key_comp, old_len, r_zeros_number;
-		    const char * r_body;
-		    loff_t multiplyer;
-
-		    leaf_shift_right(tb, tb->rnum[0] - 1, -1);
-
-		    /* Remember key component and item length */
-		    old_key_comp = get_offset (&ih->ih_key);
-		    old_len = get_ih_item_len (ih);
-
-		    multiplyer = is_indirect_ih(ih) ? tb->tb_fs->fs_blocksize / UNFM_P_SIZE : 1;
-		    /* Calculate key component and item length to insert into R[0] */
-		    //ih->ih_key.k_offset += (old_len - tb->rbytes);
-		    set_offset (key_format (&ih->ih_key), &ih->ih_key, old_key_comp +
-		    	(old_len - tb->rbytes) * multiplyer );
-
-		    set_ih_item_len (ih, tb->rbytes);
-		    /* Insert part of the item into R[0] */
-		    bi.bi_bh = tb->R[0];
-		    bi.bi_parent = tb->FR[0];
-		    bi.bi_position = get_right_neighbor_position (tb, 0);
-		    if (old_len - tb->rbytes > zeros_number ) {
-			r_zeros_number = 0;
-			r_body = body + old_len - tb->rbytes - zeros_number;
-		    }
-		    else { /* zeros_number is always 0 */
-			r_body = body;
-			r_zeros_number = zeros_number - old_len - tb->rbytes;
-			zeros_number -= r_zeros_number;
-		    }
-
-		    leaf_insert_into_buf (tb->tb_fs, &bi, 0, ih, r_body, r_zeros_number);
-
-		    /* Replace right delimiting key by first key in R[0] */
-		    replace_key(tb->tb_fs, tb->CFR[0],tb->rkey[0],tb->R[0],0);
-
-		    /* Calculate key component and item length to insert into S[0] */
-		    //ih->ih_key.k_offset = old_key_comp;
-		    set_offset (key_format (&ih->ih_key), &ih->ih_key, old_key_comp);
-
-		    set_ih_item_len (ih, old_len - tb->rbytes);
-
-		    tb->insert_size[0] -= tb->rbytes;
 
-		} else {
-		    /* whole new item falls into R[0] */
-
-		    /* Shift rnum[0]-1 items to R[0] */
-		    ret_val = leaf_shift_right(tb, tb->rnum[0] - 1, tb->rbytes);
-
-		    /* Insert new item into R[0] */
-		    bi.bi_bh = tb->R[0];
-		    bi.bi_parent = tb->FR[0];
-		    bi.bi_position = get_right_neighbor_position (tb, 0);
-		    leaf_insert_into_buf (tb->tb_fs, &bi, item_pos - n + tb->rnum[0] - 1, ih, body, zeros_number);
-
-		    /* If we insert new item in the begin of R[0] change the right delimiting key */
-		    if ( item_pos - n + tb->rnum[0] - 1 == 0 ) {
-			replace_key (tb->tb_fs, tb->CFR[0],tb->rkey[0],tb->R[0],0);
-		    }
-		    zeros_number = tb->insert_size[0] = 0;
-		}
-	    } else {
-		/* new item or part of it doesn't fall into R[0] */
-		leaf_shift_right (tb, tb->rnum[0], tb->rbytes);
-	    }
-	    break;
-
-	case M_PASTE:   /* append item */
-
-	    if ( n - tb->rnum[0] <= item_pos ) { /* pasted item or part of it falls to R[0] */
-		if ( item_pos == n - tb->rnum[0] && tb->rbytes != -1 ) {
-		    /* we must shift the part of the appended item */
-		    if ( I_IS_DIRECTORY_ITEM (B_N_PITEM_HEAD(tbS0, item_pos))) {
-			/* we append to directory item */
-			int entry_count;
-
-			entry_count = get_ih_entry_count (B_N_PITEM_HEAD(tbS0, item_pos));
-			if ( entry_count - tb->rbytes < pos_in_item ) {
-			    /* new directory entry falls into R[0] */
-			    int paste_entry_position;
-
-			    /* Shift rnum[0]-1 items in whole. Shift rbytes-1 directory entries from directory item number rnum[0] */
-			    leaf_shift_right (tb, tb->rnum[0], tb->rbytes - 1);
-
-			    /* Paste given directory entry to directory item */
-			    paste_entry_position = pos_in_item - entry_count + tb->rbytes - 1;
-
-			    bi.bi_bh = tb->R[0];
-			    bi.bi_parent = tb->FR[0];
-			    bi.bi_position = get_right_neighbor_position (tb, 0);
-			    leaf_paste_in_buffer (tb->tb_fs, &bi, 0, paste_entry_position,
-						  tb->insert_size[0],body,zeros_number);
-			    /* paste entry */
-			    leaf_paste_entries (
-				bi.bi_bh, 0, paste_entry_position, 1, (struct reiserfs_de_head *)body, 
-				body + DEH_SIZE, tb->insert_size[0]
-				);								
-						
-			    if ( paste_entry_position == 0 ) {
-				/* change delimiting keys */
-				replace_key(tb->tb_fs, tb->CFR[0],tb->rkey[0],tb->R[0],0);
-			    }
-
-			    tb->insert_size[0] = 0;
-			    pos_in_item++;
+	/* tb->lnum[0] > 0 */
+	/* Calculate new item position */
+	item_pos -= (tb->lnum[0] - ((tb->lbytes != -1) ? 1 : 0));
+
+	if (tb->rnum[0] > 0) {
+		/* shift rnum[0] items from S[0] to the right neighbor R[0] */
+		n = B_NR_ITEMS(tbS0);
+		switch (flag) {
+
+		case M_INSERT:	/* insert item */
+			if (n - tb->rnum[0] < item_pos) {
+				/* new item or its part falls to R[0] */
+				if (item_pos == n - tb->rnum[0] + 1
+				    && tb->rbytes != -1) {
+					/* part of new item falls into R[0] */
+					loff_t old_key_comp, old_len,
+					    r_zeros_number;
+					const char *r_body;
+					loff_t multiplyer;
+
+					leaf_shift_right(tb, tb->rnum[0] - 1,
+							 -1);
+
+					/* Remember key component and item length */
+					old_key_comp = get_offset(&ih->ih_key);
+					old_len = get_ih_item_len(ih);
+
+					multiplyer =
+					    is_indirect_ih(ih) ? tb->tb_fs->
+					    fs_blocksize / UNFM_P_SIZE : 1;
+					/* Calculate key component and item length to insert into R[0] */
+					//ih->ih_key.k_offset += (old_len - tb->rbytes);
+					set_offset(key_format(&ih->ih_key),
+						   &ih->ih_key,
+						   old_key_comp + (old_len -
+								   tb->rbytes) *
+						   multiplyer);
+
+					set_ih_item_len(ih, tb->rbytes);
+					/* Insert part of the item into R[0] */
+					bi.bi_bh = tb->R[0];
+					bi.bi_parent = tb->FR[0];
+					bi.bi_position =
+					    get_right_neighbor_position(tb, 0);
+					if (old_len - tb->rbytes > zeros_number) {
+						r_zeros_number = 0;
+						r_body =
+						    body + old_len -
+						    tb->rbytes - zeros_number;
+					} else {	/* zeros_number is always 0 */
+						r_body = body;
+						r_zeros_number =
+						    zeros_number - old_len -
+						    tb->rbytes;
+						zeros_number -= r_zeros_number;
+					}
+
+					leaf_insert_into_buf(tb->tb_fs, &bi, 0,
+							     ih, r_body,
+							     r_zeros_number);
+
+					/* Replace right delimiting key by first key in R[0] */
+					replace_key(tb->tb_fs, tb->CFR[0],
+						    tb->rkey[0], tb->R[0], 0);
+
+					/* Calculate key component and item length to insert into S[0] */
+					//ih->ih_key.k_offset = old_key_comp;
+					set_offset(key_format(&ih->ih_key),
+						   &ih->ih_key, old_key_comp);
+
+					set_ih_item_len(ih,
+							old_len - tb->rbytes);
+
+					tb->insert_size[0] -= tb->rbytes;
+
+				} else {
+					/* whole new item falls into R[0] */
+
+					/* Shift rnum[0]-1 items to R[0] */
+					ret_val =
+					    leaf_shift_right(tb,
+							     tb->rnum[0] - 1,
+							     tb->rbytes);
+
+					/* Insert new item into R[0] */
+					bi.bi_bh = tb->R[0];
+					bi.bi_parent = tb->FR[0];
+					bi.bi_position =
+					    get_right_neighbor_position(tb, 0);
+					leaf_insert_into_buf(tb->tb_fs, &bi,
+							     item_pos - n +
+							     tb->rnum[0] - 1,
+							     ih, body,
+							     zeros_number);
+
+					/* If we insert new item in the begin of R[0] change the right delimiting key */
+					if (item_pos - n + tb->rnum[0] - 1 == 0) {
+						replace_key(tb->tb_fs,
+							    tb->CFR[0],
+							    tb->rkey[0],
+							    tb->R[0], 0);
+					}
+					zeros_number = tb->insert_size[0] = 0;
+				}
 			} else {
-			    /* new directory entry doesn't fall into R[0] */
-			    leaf_shift_right (tb, tb->rnum[0],tb->rbytes);
+				/* new item or part of it doesn't fall into R[0] */
+				leaf_shift_right(tb, tb->rnum[0], tb->rbytes);
 			}
-		    }
-		    else {
-			/* regular object */
-
-			int n_shift, n_rem, r_zeros_number;
-			const char * r_body;
-			struct reiserfs_key *key;
-
-			/* Calculate number of bytes which must be shifted from appended item */
-			if ( (n_shift = tb->rbytes - tb->insert_size[0]) < 0 )
-			    n_shift = 0;
-
-			leaf_shift_right (tb, tb->rnum[0], n_shift);
-
-			/* Calculate number of bytes which must remain in body after appending to R[0] */
-			if ( (n_rem = tb->insert_size[0] - tb->rbytes) < 0 )
-			    n_rem = 0;
-
-			{
-			    unsigned long temp_rem = n_rem;
-			
-			    if (is_indirect_key(B_N_PKEY(tb->R[0],0)))
-				temp_rem = (n_rem / UNFM_P_SIZE) * tb->tb_fs->fs_blocksize;
-
-			    //B_N_PKEY(tb->R[0],0)->k_offset += n_rem;
-			    key = B_N_PKEY(tb->R[0],0);
-			    set_offset (key_format (key), key, get_offset (key) + temp_rem);
-
-			    //B_N_PDELIM_KEY(tb->CFR[0],tb->rkey[0])->k_offset += n_rem;
-			    key = B_N_PDELIM_KEY(tb->CFR[0],tb->rkey[0]);
-			    set_offset (key_format (key), key, get_offset (key) + temp_rem);
-                        }
-
-			mark_buffer_dirty (tb->CFR[0]);
-
-			/* Append part of body into R[0] */
-			bi.bi_bh = tb->R[0];
-			bi.bi_parent = tb->FR[0];
-			bi.bi_position = get_right_neighbor_position (tb, 0);
-			if ( n_rem > zeros_number ) {
-			    r_zeros_number = 0;
-			    r_body = body + n_rem - zeros_number;
-			}
-			else {
-			    r_body = body;
-			    r_zeros_number = zeros_number - n_rem;
-			    zeros_number -= r_zeros_number;
-			}
-
-			leaf_paste_in_buffer(tb->tb_fs, &bi, 0, n_shift, tb->insert_size[0] - n_rem, r_body, r_zeros_number);
-
-			if (I_IS_INDIRECT_ITEM(B_N_PITEM_HEAD(tb->R[0],0))) {
-			    set_ih_free_space (B_N_PITEM_HEAD(tb->R[0],0), 0);
+			break;
+
+		case M_PASTE:	/* append item */
+
+			if (n - tb->rnum[0] <= item_pos) {	/* pasted item or part of it falls to R[0] */
+				if (item_pos == n - tb->rnum[0]
+				    && tb->rbytes != -1) {
+					/* we must shift the part of the appended item */
+					if (I_IS_DIRECTORY_ITEM
+					    (B_N_PITEM_HEAD(tbS0, item_pos))) {
+						/* we append to directory item */
+						int entry_count;
+
+						entry_count =
+						    get_ih_entry_count
+						    (B_N_PITEM_HEAD
+						     (tbS0, item_pos));
+						if (entry_count - tb->rbytes <
+						    pos_in_item) {
+							/* new directory entry falls into R[0] */
+							int paste_entry_position;
+
+							/* Shift rnum[0]-1 items in whole. Shift rbytes-1 directory entries from directory item number rnum[0] */
+							leaf_shift_right(tb,
+									 tb->
+									 rnum
+									 [0],
+									 tb->
+									 rbytes
+									 - 1);
+
+							/* Paste given directory entry to directory item */
+							paste_entry_position =
+							    pos_in_item -
+							    entry_count +
+							    tb->rbytes - 1;
+
+							bi.bi_bh = tb->R[0];
+							bi.bi_parent =
+							    tb->FR[0];
+							bi.bi_position =
+							    get_right_neighbor_position
+							    (tb, 0);
+							leaf_paste_in_buffer
+							    (tb->tb_fs, &bi, 0,
+							     paste_entry_position,
+							     tb->insert_size[0],
+							     body,
+							     zeros_number);
+							/* paste entry */
+							leaf_paste_entries(bi.
+									   bi_bh,
+									   0,
+									   paste_entry_position,
+									   1,
+									   (struct
+									    reiserfs_de_head
+									    *)
+									   body,
+									   body
+									   +
+									   DEH_SIZE,
+									   tb->
+									   insert_size
+									   [0]
+							    );
+
+							if (paste_entry_position
+							    == 0) {
+								/* change delimiting keys */
+								replace_key(tb->
+									    tb_fs,
+									    tb->
+									    CFR
+									    [0],
+									    tb->
+									    rkey
+									    [0],
+									    tb->
+									    R
+									    [0],
+									    0);
+							}
+
+							tb->insert_size[0] = 0;
+							pos_in_item++;
+						} else {
+							/* new directory entry doesn't fall into R[0] */
+							leaf_shift_right(tb,
+									 tb->
+									 rnum
+									 [0],
+									 tb->
+									 rbytes);
+						}
+					} else {
+						/* regular object */
+
+						int n_shift, n_rem,
+						    r_zeros_number;
+						const char *r_body;
+						struct reiserfs_key *key;
+
+						/* Calculate number of bytes which must be shifted from appended item */
+						if ((n_shift =
+						     tb->rbytes -
+						     tb->insert_size[0]) < 0)
+							n_shift = 0;
+
+						leaf_shift_right(tb,
+								 tb->rnum[0],
+								 n_shift);
+
+						/* Calculate number of bytes which must remain in body after appending to R[0] */
+						if ((n_rem =
+						     tb->insert_size[0] -
+						     tb->rbytes) < 0)
+							n_rem = 0;
+
+						{
+							unsigned long temp_rem =
+							    n_rem;
+
+							if (is_indirect_key
+							    (B_N_PKEY
+							     (tb->R[0], 0)))
+								temp_rem =
+								    (n_rem /
+								     UNFM_P_SIZE)
+								    *
+								    tb->tb_fs->
+								    fs_blocksize;
+
+							//B_N_PKEY(tb->R[0],0)->k_offset += n_rem;
+							key =
+							    B_N_PKEY(tb->R[0],
+								     0);
+							set_offset(key_format
+								   (key), key,
+								   get_offset
+								   (key) +
+								   temp_rem);
+
+							//B_N_PDELIM_KEY(tb->CFR[0],tb->rkey[0])->k_offset += n_rem;
+							key =
+							    B_N_PDELIM_KEY(tb->
+									   CFR
+									   [0],
+									   tb->
+									   rkey
+									   [0]);
+							set_offset(key_format
+								   (key), key,
+								   get_offset
+								   (key) +
+								   temp_rem);
+						}
+
+						mark_buffer_dirty(tb->CFR[0]);
+
+						/* Append part of body into R[0] */
+						bi.bi_bh = tb->R[0];
+						bi.bi_parent = tb->FR[0];
+						bi.bi_position =
+						    get_right_neighbor_position
+						    (tb, 0);
+						if (n_rem > zeros_number) {
+							r_zeros_number = 0;
+							r_body =
+							    body + n_rem -
+							    zeros_number;
+						} else {
+							r_body = body;
+							r_zeros_number =
+							    zeros_number -
+							    n_rem;
+							zeros_number -=
+							    r_zeros_number;
+						}
+
+						leaf_paste_in_buffer(tb->tb_fs,
+								     &bi, 0,
+								     n_shift,
+								     tb->
+								     insert_size
+								     [0] -
+								     n_rem,
+								     r_body,
+								     r_zeros_number);
+
+						if (I_IS_INDIRECT_ITEM
+						    (B_N_PITEM_HEAD
+						     (tb->R[0], 0))) {
+							set_ih_free_space
+							    (B_N_PITEM_HEAD
+							     (tb->R[0], 0), 0);
+						}
+
+						tb->insert_size[0] = n_rem;
+						if (!n_rem)
+							pos_in_item++;
+					}
+				} else {
+					/* pasted item falls into R[0] entirely */
+
+					struct item_head *pasted;
+
+					ret_val =
+					    leaf_shift_right(tb, tb->rnum[0],
+							     tb->rbytes);
+
+					/* append item in R[0] */
+					if (pos_in_item >= 0) {
+						bi.bi_bh = tb->R[0];
+						bi.bi_parent = tb->FR[0];
+						bi.bi_position =
+						    get_right_neighbor_position
+						    (tb, 0);
+						leaf_paste_in_buffer(tb->tb_fs,
+								     &bi,
+								     item_pos -
+								     n +
+								     tb->
+								     rnum[0],
+								     pos_in_item,
+								     tb->
+								     insert_size
+								     [0], body,
+								     zeros_number);
+					}
+
+					/* paste new entry, if item is directory item */
+					pasted =
+					    B_N_PITEM_HEAD(tb->R[0],
+							   item_pos - n +
+							   tb->rnum[0]);
+					if (I_IS_DIRECTORY_ITEM(pasted)
+					    && pos_in_item >= 0) {
+						leaf_paste_entries(bi.bi_bh,
+								   item_pos -
+								   n +
+								   tb->rnum[0],
+								   pos_in_item,
+								   1,
+								   (struct
+								    reiserfs_de_head
+								    *)body,
+								   body +
+								   DEH_SIZE,
+								   tb->
+								   insert_size
+								   [0]);
+						if (!pos_in_item) {
+							/* update delimiting keys */
+							replace_key(tb->tb_fs,
+								    tb->CFR[0],
+								    tb->rkey[0],
+								    tb->R[0],
+								    0);
+						}
+					}
+
+					if (I_IS_INDIRECT_ITEM(pasted))
+						set_ih_free_space(pasted, 0);
+					zeros_number = tb->insert_size[0] = 0;
+				}
+			} else {
+				/* new item doesn't fall into R[0] */
+				leaf_shift_right(tb, tb->rnum[0], tb->rbytes);
 			}
-
-			tb->insert_size[0] = n_rem;
-			if ( ! n_rem )
-			    pos_in_item ++;
-		    }
+			break;
+
+		default:	/* cases d and t */
+			reiserfs_panic
+			    ("PAP-12175: balance_leaf: rnum > 0: unexpectable mode: %s(%d)",
+			     (flag ==
+			      M_DELETE) ? "DELETE" : ((flag ==
+						       M_CUT) ? "CUT" :
+						      "UNKNOWN"), flag);
 		}
-		else { 
-		    /* pasted item falls into R[0] entirely */
-
-		    struct item_head * pasted;
-
-		    ret_val = leaf_shift_right (tb, tb->rnum[0], tb->rbytes);
-
-		    /* append item in R[0] */
-		    if ( pos_in_item >= 0 ) {
-			bi.bi_bh = tb->R[0];
-			bi.bi_parent = tb->FR[0];
-			bi.bi_position = get_right_neighbor_position (tb, 0);
-			leaf_paste_in_buffer(tb->tb_fs, &bi,item_pos - n + tb->rnum[0], pos_in_item,
-					     tb->insert_size[0],body, zeros_number);
-		    }
-
-		    /* paste new entry, if item is directory item */
-		    pasted = B_N_PITEM_HEAD(tb->R[0], item_pos - n + tb->rnum[0]);
-		    if (I_IS_DIRECTORY_ITEM (pasted) && pos_in_item >= 0 ) {
-			leaf_paste_entries (bi.bi_bh, item_pos - n + tb->rnum[0], pos_in_item, 1, 
-					    (struct reiserfs_de_head *)body, body + DEH_SIZE, tb->insert_size[0]);
-			if ( ! pos_in_item ) {
-			    /* update delimiting keys */
-			    replace_key (tb->tb_fs, tb->CFR[0],tb->rkey[0],tb->R[0],0);
-			}
-		    }
 
-		    if (I_IS_INDIRECT_ITEM (pasted))
-			set_ih_free_space (pasted, 0);
-		    zeros_number = tb->insert_size[0] = 0;
-		}
-	    }
-	    else {
-		/* new item doesn't fall into R[0] */
-		leaf_shift_right (tb, tb->rnum[0], tb->rbytes);
-	    }
-	    break;
-
-	default:    /* cases d and t */
-	    reiserfs_panic ("PAP-12175: balance_leaf: rnum > 0: unexpectable mode: %s(%d)",
-			    (flag == M_DELETE) ? "DELETE" : ((flag == M_CUT) ? "CUT" : "UNKNOWN"), flag);
 	}
-    
-    }	/* tb->rnum[0] > 0 */
-
-    /* if while adding to a node we discover that it is possible to split
-       it in two, and merge the left part into the left neighbor and the
-       right part into the right neighbor, eliminating the node */
-    if ( tb->blknum[0] == 0 ) { /* node S[0] is empty now */
-        /* if insertion was done before 0-th position in R[0], right
-           delimiting key of the tb->L[0]'s and left delimiting key are
-           not set correctly */
-        if (tb->CFL[0]) {
-            if (!tb->CFR[0])
-                reiserfs_panic (tb->tb_fs, "vs-12195: balance_leaf: CFR not initialized");
-            copy_key (B_N_PDELIM_KEY (tb->CFL[0], tb->lkey[0]), B_N_PDELIM_KEY (tb->CFR[0], tb->rkey[0]));
-            mark_buffer_dirty (tb->CFL[0]);
-        }
-        
-	reiserfs_invalidate_buffer(tb,tbS0, 1);									
-	return 0;
-    }
 
+	/* tb->rnum[0] > 0 */
+	/* if while adding to a node we discover that it is possible to split
+	   it in two, and merge the left part into the left neighbor and the
+	   right part into the right neighbor, eliminating the node */
+	if (tb->blknum[0] == 0) {	/* node S[0] is empty now */
+		/* if insertion was done before 0-th position in R[0], right
+		   delimiting key of the tb->L[0]'s and left delimiting key are
+		   not set correctly */
+		if (tb->CFL[0]) {
+			if (!tb->CFR[0])
+				reiserfs_panic(tb->tb_fs,
+					       "vs-12195: balance_leaf: CFR not initialized");
+			copy_key(B_N_PDELIM_KEY(tb->CFL[0], tb->lkey[0]),
+				 B_N_PDELIM_KEY(tb->CFR[0], tb->rkey[0]));
+			mark_buffer_dirty(tb->CFL[0]);
+		}
 
-    /* Fill new nodes that appear in place of S[0] */
+		reiserfs_invalidate_buffer(tb, tbS0, 1);
+		return 0;
+	}
 
-    /* I am told that this copying is because we need an array to enable
-       the looping code. -Hans */
-    snum[0] = tb->s1num,
-	snum[1] = tb->s2num;
-    sbytes[0] = tb->s1bytes;
-    sbytes[1] = tb->s2bytes;
-    for( i = tb->blknum[0] - 2; i >= 0; i-- ) {
-	/* here we shift from S to S_new nodes */
-	S_new[i] = get_FEB(tb);
+	/* Fill new nodes that appear in place of S[0] */
+
+	/* I am told that this copying is because we need an array to enable
+	   the looping code. -Hans */
+	snum[0] = tb->s1num, snum[1] = tb->s2num;
+	sbytes[0] = tb->s1bytes;
+	sbytes[1] = tb->s2bytes;
+	for (i = tb->blknum[0] - 2; i >= 0; i--) {
+		/* here we shift from S to S_new nodes */
+		S_new[i] = get_FEB(tb);
+
+		/* set block_head's level to leaf level */
+		set_blkh_level(B_BLK_HEAD(S_new[i]), DISK_LEAF_NODE_LEVEL);
+
+		n = B_NR_ITEMS(tbS0);
+
+		switch (flag) {
+		case M_INSERT:	/* insert item */
+
+			if (n - snum[i] < item_pos) {
+				/* new item or it's part falls to first new node S_new[i] */
+				if (item_pos == n - snum[i] + 1
+				    && sbytes[i] != -1) {
+					/* part of new item falls into S_new[i] */
+					int old_key_comp, old_len,
+					    r_zeros_number;
+					const char *r_body;
+					loff_t multiplyer;
+
+					/* Move snum[i]-1 items from S[0] to S_new[i] */
+					leaf_move_items(LEAF_FROM_S_TO_SNEW, tb,
+							snum[i] - 1, -1,
+							S_new[i]);
+
+					/* Remember key component and item length */
+					old_key_comp = get_offset(&ih->ih_key);
+					old_len = get_ih_item_len(ih);
+					multiplyer =
+					    is_indirect_ih(ih) ? tb->tb_fs->
+					    fs_blocksize / UNFM_P_SIZE : 1;
+
+					/* Calculate key component and item length to insert into S_new[i] */
+					//ih->ih_key.k_offset += (old_len - sbytes[i]);
+					set_offset(key_format(&ih->ih_key),
+						   &ih->ih_key,
+						   old_key_comp + (old_len -
+								   sbytes[i]) *
+						   multiplyer);
+
+					set_ih_item_len(ih, sbytes[i]);
+
+					/* Insert part of the item into S_new[i] before 0-th item */
+					bi.bi_bh = S_new[i];
+					bi.bi_parent = 0;
+					bi.bi_position = 0;
+
+					if (old_len - sbytes[i] > zeros_number) {
+						r_zeros_number = 0;
+						r_body =
+						    body + (old_len -
+							    sbytes[i]) -
+						    zeros_number;
+					} else {
+						r_body = body;
+						r_zeros_number =
+						    zeros_number - (old_len -
+								    sbytes[i]);
+						zeros_number -= r_zeros_number;
+					}
+
+					leaf_insert_into_buf(tb->tb_fs, &bi, 0,
+							     ih, r_body,
+							     r_zeros_number);
+
+					/* Calculate key component and item length to insert into S[i] */
+					//ih->ih_key.k_offset = old_key_comp;
+					set_offset(key_format(&ih->ih_key),
+						   &ih->ih_key, old_key_comp);
+					set_ih_item_len(ih,
+							old_len - sbytes[i]);
+					tb->insert_size[0] -= sbytes[i];
+				} else {	/* whole new item falls into S_new[i] */
+
+					/* Shift snum[0] - 1 items to S_new[i] (sbytes[i] of split item) */
+					leaf_move_items(LEAF_FROM_S_TO_SNEW, tb,
+							snum[i] - 1, sbytes[i],
+							S_new[i]);
+
+					/* Insert new item into S_new[i] */
+					bi.bi_bh = S_new[i];
+					bi.bi_parent = 0;
+					bi.bi_position = 0;
+					leaf_insert_into_buf(tb->tb_fs, &bi,
+							     item_pos - n +
+							     snum[i] - 1, ih,
+							     body,
+							     zeros_number);
+					zeros_number = tb->insert_size[0] = 0;
+				}
+			}
 
-	/* set block_head's level to leaf level */
-	set_blkh_level (B_BLK_HEAD (S_new[i]), DISK_LEAF_NODE_LEVEL);
+			else {	/* new item or it part don't falls into S_new[i] */
 
-	n = B_NR_ITEMS(tbS0);
-	
-	switch (flag) {
-	case M_INSERT:   /* insert item */
-
-	    if ( n - snum[i] < item_pos ) {
-		/* new item or it's part falls to first new node S_new[i]*/
-		if ( item_pos == n - snum[i] + 1 && sbytes[i] != -1 ) {
-		    /* part of new item falls into S_new[i] */
-		    int old_key_comp, old_len, r_zeros_number;
-		    const char * r_body;
-		    loff_t multiplyer;
-
-		    /* Move snum[i]-1 items from S[0] to S_new[i] */
-		    leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i] - 1, -1, S_new[i]);
-
-		    /* Remember key component and item length */
-		    old_key_comp = get_offset (&ih->ih_key);
-		    old_len = get_ih_item_len (ih);
-		    multiplyer = is_indirect_ih(ih) ? tb->tb_fs->fs_blocksize / UNFM_P_SIZE : 1;
-
-		    /* Calculate key component and item length to insert into S_new[i] */
-		    //ih->ih_key.k_offset += (old_len - sbytes[i]);
-		    set_offset (key_format (&ih->ih_key), &ih->ih_key, old_key_comp +
-		    	(old_len - sbytes[i]) * multiplyer);
-
-		    set_ih_item_len (ih, sbytes[i]);
-
-		    /* Insert part of the item into S_new[i] before 0-th item */
-		    bi.bi_bh = S_new[i];
-		    bi.bi_parent = 0;
-		    bi.bi_position = 0;
-
-		    if ( old_len - sbytes[i] > zeros_number ) {
-			r_zeros_number = 0;
-			r_body = body + (old_len - sbytes[i]) - zeros_number;
-		    }
-		    else {
-			r_body = body;
-			r_zeros_number = zeros_number - (old_len - sbytes[i]);
-			zeros_number -= r_zeros_number;
-		    }
-
-		    leaf_insert_into_buf (tb->tb_fs, &bi, 0, ih, r_body, r_zeros_number);
-
-		    /* Calculate key component and item length to insert into S[i] */
-		    //ih->ih_key.k_offset = old_key_comp;
-		    set_offset (key_format (&ih->ih_key), &ih->ih_key, old_key_comp);
-		    set_ih_item_len (ih, old_len - sbytes[i]);
-		    tb->insert_size[0] -= sbytes[i];
-		}
-		else /* whole new item falls into S_new[i] */
-		{
-		    /* Shift snum[0] - 1 items to S_new[i] (sbytes[i] of split item) */
-		    leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i] - 1, sbytes[i], S_new[i]);
-
-		    /* Insert new item into S_new[i] */
-		    bi.bi_bh = S_new[i];
-		    bi.bi_parent = 0;
-		    bi.bi_position = 0;
-		    leaf_insert_into_buf (tb->tb_fs, &bi, item_pos - n + snum[i] - 1, ih, body, zeros_number);
-		    zeros_number = tb->insert_size[0] = 0;
-		}
-	    }
-
-	    else /* new item or it part don't falls into S_new[i] */
-	    {
-		leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i], sbytes[i], S_new[i]);
-	    }
-	    break;
-
-	case M_PASTE:   /* append item */
-
-	    if ( n - snum[i] <= item_pos )  /* pasted item or part if it falls to S_new[i] */
-	    {
-		if ( item_pos == n - snum[i] && sbytes[i] != -1 )
-		{ /* we must shift part of the appended item */
-		    struct item_head * aux_ih;
-
-		    if ( I_IS_DIRECTORY_ITEM (aux_ih = B_N_PITEM_HEAD(tbS0,item_pos))) {
-			/* we append to directory item */
-
-			int entry_count;
-		
-			entry_count = get_ih_entry_count(aux_ih);
-
-			if ( entry_count - sbytes[i] < pos_in_item  && pos_in_item <= entry_count ) {
-			    /* new directory entry falls into S_new[i] */
-		  
-			    /* Shift snum[i]-1 items in whole. Shift sbytes[i] directory entries from directory item number snum[i] */
-			    leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i], sbytes[i]-1, S_new[i]);
-
-			    /* Paste given directory entry to directory item */
-			    bi.bi_bh = S_new[i];
-			    bi.bi_parent = 0;
-			    bi.bi_position = 0;
-			    leaf_paste_in_buffer (tb->tb_fs, &bi, 0, pos_in_item - entry_count + sbytes[i] - 1,
-						  tb->insert_size[0], body,zeros_number);
-			    /* paste new directory entry */
-			    leaf_paste_entries (
-				bi.bi_bh, 0, pos_in_item - entry_count + sbytes[i] - 1,
-				1, (struct reiserfs_de_head *)body, body + DEH_SIZE,
-				tb->insert_size[0]
-				);
-			    tb->insert_size[0] = 0;
-			    pos_in_item++;
-			} else { /* new directory entry doesn't fall into S_new[i] */
-			    leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i], sbytes[i], S_new[i]);
-			}
-		    }
-		    else /* regular object */
-		    {
-			int n_shift, n_rem, r_zeros_number;
-			const char * r_body;
-			struct item_head * tmp;
-
-			/* Calculate number of bytes which must be shifted from appended item */
-			n_shift = sbytes[i] - tb->insert_size[0];
-			if ( n_shift < 0 )
-			    n_shift = 0;
-			leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i], n_shift, S_new[i]);
-
-			/* Calculate number of bytes which must remain in body after append to S_new[i] */
-			n_rem = tb->insert_size[0] - sbytes[i];
-			if ( n_rem < 0 )
-			    n_rem = 0;
-			/* Append part of body into S_new[0] */
-			bi.bi_bh = S_new[i];
-			bi.bi_parent = 0;
-			bi.bi_position = 0;
-
-			if ( n_rem > zeros_number ) {
-			    r_zeros_number = 0;
-			    r_body = body + n_rem - zeros_number;
-			}
-			else {
-			    r_body = body;
-			    r_zeros_number = zeros_number - n_rem;
-			    zeros_number -= r_zeros_number;
+				leaf_move_items(LEAF_FROM_S_TO_SNEW, tb,
+						snum[i], sbytes[i], S_new[i]);
 			}
-
-			leaf_paste_in_buffer(tb->tb_fs, &bi, 0, n_shift, tb->insert_size[0]-n_rem, r_body,r_zeros_number);
-			tmp = B_N_PITEM_HEAD (S_new[i], 0);
-			if (I_IS_INDIRECT_ITEM(tmp)) {
+			break;
+
+		case M_PASTE:	/* append item */
+
+			if (n - snum[i] <= item_pos) {	/* pasted item or part if it falls to S_new[i] */
+				if (item_pos == n - snum[i] && sbytes[i] != -1) {	/* we must shift part of the appended item */
+					struct item_head *aux_ih;
+
+					if (I_IS_DIRECTORY_ITEM
+					    (aux_ih =
+					     B_N_PITEM_HEAD(tbS0, item_pos))) {
+						/* we append to directory item */
+
+						int entry_count;
+
+						entry_count =
+						    get_ih_entry_count(aux_ih);
+
+						if (entry_count - sbytes[i] <
+						    pos_in_item
+						    && pos_in_item <=
+						    entry_count) {
+							/* new directory entry falls into S_new[i] */
+
+							/* Shift snum[i]-1 items in whole. Shift sbytes[i] directory entries from directory item number snum[i] */
+							leaf_move_items
+							    (LEAF_FROM_S_TO_SNEW,
+							     tb, snum[i],
+							     sbytes[i] - 1,
+							     S_new[i]);
+
+							/* Paste given directory entry to directory item */
+							bi.bi_bh = S_new[i];
+							bi.bi_parent = 0;
+							bi.bi_position = 0;
+							leaf_paste_in_buffer
+							    (tb->tb_fs, &bi, 0,
+							     pos_in_item -
+							     entry_count +
+							     sbytes[i] - 1,
+							     tb->insert_size[0],
+							     body,
+							     zeros_number);
+							/* paste new directory entry */
+							leaf_paste_entries(bi.
+									   bi_bh,
+									   0,
+									   pos_in_item
+									   -
+									   entry_count
+									   +
+									   sbytes
+									   [i] -
+									   1, 1,
+									   (struct
+									    reiserfs_de_head
+									    *)
+									   body,
+									   body
+									   +
+									   DEH_SIZE,
+									   tb->
+									   insert_size
+									   [0]
+							    );
+							tb->insert_size[0] = 0;
+							pos_in_item++;
+						} else {	/* new directory entry doesn't fall into S_new[i] */
+							leaf_move_items
+							    (LEAF_FROM_S_TO_SNEW,
+							     tb, snum[i],
+							     sbytes[i],
+							     S_new[i]);
+						}
+					} else {	/* regular object */
+
+						int n_shift, n_rem,
+						    r_zeros_number;
+						const char *r_body;
+						struct item_head *tmp;
+
+						/* Calculate number of bytes which must be shifted from appended item */
+						n_shift =
+						    sbytes[i] -
+						    tb->insert_size[0];
+						if (n_shift < 0)
+							n_shift = 0;
+						leaf_move_items
+						    (LEAF_FROM_S_TO_SNEW, tb,
+						     snum[i], n_shift,
+						     S_new[i]);
+
+						/* Calculate number of bytes which must remain in body after append to S_new[i] */
+						n_rem =
+						    tb->insert_size[0] -
+						    sbytes[i];
+						if (n_rem < 0)
+							n_rem = 0;
+						/* Append part of body into S_new[0] */
+						bi.bi_bh = S_new[i];
+						bi.bi_parent = 0;
+						bi.bi_position = 0;
+
+						if (n_rem > zeros_number) {
+							r_zeros_number = 0;
+							r_body =
+							    body + n_rem -
+							    zeros_number;
+						} else {
+							r_body = body;
+							r_zeros_number =
+							    zeros_number -
+							    n_rem;
+							zeros_number -=
+							    r_zeros_number;
+						}
+
+						leaf_paste_in_buffer(tb->tb_fs,
+								     &bi, 0,
+								     n_shift,
+								     tb->
+								     insert_size
+								     [0] -
+								     n_rem,
+								     r_body,
+								     r_zeros_number);
+						tmp =
+						    B_N_PITEM_HEAD(S_new[i], 0);
+						if (I_IS_INDIRECT_ITEM(tmp)) {
 /*			
 			    if (n_rem)
 				reiserfs_panic ("PAP-12230: balance_leaf: "
 						"invalid action with indirect item");
 			    set_ih_free_space (tmp, 0);
 */
-			    set_ih_free_space (tmp, 0);
-			    set_offset( key_format (&tmp->ih_key), &tmp->ih_key, get_offset(&tmp->ih_key) +
-				(n_rem / UNFM_P_SIZE) * tb->tb_fs->fs_blocksize);
-			} else
-				set_offset (key_format (&tmp->ih_key), &tmp->ih_key, get_offset (&tmp->ih_key) + n_rem);
-
-			//B_N_PKEY(S_new[i],0)->k_offset += n_rem;
-//			
-
-			tb->insert_size[0] = n_rem;
-			if ( ! n_rem )
-			    pos_in_item++;
-		    }
-		}
-		else
-		    /* item falls wholly into S_new[i] */
-		{
-		    struct item_head * pasted;
-		
-		    leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i], sbytes[i], S_new[i]);
-		    /* paste into item */
-		    bi.bi_bh = S_new[i];
-		    bi.bi_parent = 0;
-		    bi.bi_position = 0;
-		    leaf_paste_in_buffer(tb->tb_fs, &bi, item_pos - n + snum[i], pos_in_item, tb->insert_size[0], body, zeros_number);
-
-		    pasted = B_N_PITEM_HEAD(S_new[i], item_pos - n + snum[i]);
-		    if (I_IS_DIRECTORY_ITEM (pasted)) {
-			leaf_paste_entries (bi.bi_bh, item_pos - n + snum[i], pos_in_item, 1, 
-					    (struct reiserfs_de_head *)body, body + DEH_SIZE, tb->insert_size[0]);
-		    }
-
-		    /* if we paste to indirect item update ih_free_space */
-		    if (I_IS_INDIRECT_ITEM (pasted))
-			set_ih_free_space (pasted, 0);
-		    zeros_number = tb->insert_size[0] = 0;
+							set_ih_free_space(tmp,
+									  0);
+							set_offset(key_format
+								   (&tmp->
+								    ih_key),
+								   &tmp->ih_key,
+								   get_offset
+								   (&tmp->
+								    ih_key) +
+								   (n_rem /
+								    UNFM_P_SIZE)
+								   *
+								   tb->tb_fs->
+								   fs_blocksize);
+						} else
+							set_offset(key_format
+								   (&tmp->
+								    ih_key),
+								   &tmp->ih_key,
+								   get_offset
+								   (&tmp->
+								    ih_key) +
+								   n_rem);
+
+						//B_N_PKEY(S_new[i],0)->k_offset += n_rem;
+//                      
+
+						tb->insert_size[0] = n_rem;
+						if (!n_rem)
+							pos_in_item++;
+					}
+				} else
+					/* item falls wholly into S_new[i] */
+				{
+					struct item_head *pasted;
+
+					leaf_move_items(LEAF_FROM_S_TO_SNEW, tb,
+							snum[i], sbytes[i],
+							S_new[i]);
+					/* paste into item */
+					bi.bi_bh = S_new[i];
+					bi.bi_parent = 0;
+					bi.bi_position = 0;
+					leaf_paste_in_buffer(tb->tb_fs, &bi,
+							     item_pos - n +
+							     snum[i],
+							     pos_in_item,
+							     tb->insert_size[0],
+							     body,
+							     zeros_number);
+
+					pasted =
+					    B_N_PITEM_HEAD(S_new[i],
+							   item_pos - n +
+							   snum[i]);
+					if (I_IS_DIRECTORY_ITEM(pasted)) {
+						leaf_paste_entries(bi.bi_bh,
+								   item_pos -
+								   n + snum[i],
+								   pos_in_item,
+								   1,
+								   (struct
+								    reiserfs_de_head
+								    *)body,
+								   body +
+								   DEH_SIZE,
+								   tb->
+								   insert_size
+								   [0]);
+					}
+
+					/* if we paste to indirect item update ih_free_space */
+					if (I_IS_INDIRECT_ITEM(pasted))
+						set_ih_free_space(pasted, 0);
+					zeros_number = tb->insert_size[0] = 0;
+				}
+			} else {
+				/* pasted item doesn't fall into S_new[i] */
+				leaf_move_items(LEAF_FROM_S_TO_SNEW, tb,
+						snum[i], sbytes[i], S_new[i]);
+			}
+			break;
+
+		default:	/* cases d and t */
+			reiserfs_panic
+			    ("PAP-12245: balance_leaf: blknum > 2: unexpectable mode: %s(%d)",
+			     (flag ==
+			      M_DELETE) ? "DELETE" : ((flag ==
+						       M_CUT) ? "CUT" :
+						      "UNKNOWN"), flag);
 		}
-	    } else {
-		/* pasted item doesn't fall into S_new[i] */
-		leaf_move_items (LEAF_FROM_S_TO_SNEW, tb, snum[i], sbytes[i], S_new[i]);
-	    }
-	    break;
-
-	default:    /* cases d and t */
-	    reiserfs_panic ("PAP-12245: balance_leaf: blknum > 2: unexpectable mode: %s(%d)",
-			    (flag == M_DELETE) ? "DELETE" : ((flag == M_CUT) ? "CUT" : "UNKNOWN"), flag);
-	}
-
-	memcpy (insert_key + i,B_N_PKEY(S_new[i],0),KEY_SIZE);
-	insert_ptr[i] = S_new[i];
-    }
 
-    /* if the affected item was not wholly shifted then we perform all
-       necessary operations on that part or whole of the affected item which
-       remains in S */
-    if ( 0 <= item_pos && item_pos < tb->s0num ) {
-	/* if we must insert or append into buffer S[0] */
+		memcpy(insert_key + i, B_N_PKEY(S_new[i], 0), KEY_SIZE);
+		insert_ptr[i] = S_new[i];
+	}
 
-	switch (flag) {
-	case M_INSERT:   /* insert item into S[0] */
-	    bi.bi_bh = tbS0;
-	    bi.bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-	    bi.bi_position = PATH_H_POSITION (tb->tb_path, 1);
-	    leaf_insert_into_buf (tb->tb_fs, &bi, item_pos, ih, body, zeros_number);
-
-	    /* If we insert the first key change the delimiting key */
-	    if( item_pos == 0 ) {
-		if (tb->CFL[0]) /* can be 0 in reiserfsck */
-		    replace_key (tb->tb_fs, tb->CFL[0], tb->lkey[0],tbS0,0);
-	    }
-	    break;
-
-	case M_PASTE: {  /* append item in S[0] */
-	    struct item_head * pasted;
-
-	    pasted = B_N_PITEM_HEAD (tbS0, item_pos);
-	    /* when directory, may be new entry already pasted */
-	    if (I_IS_DIRECTORY_ITEM (pasted)) {
-		if ( pos_in_item >= 0 && pos_in_item <= get_ih_entry_count (pasted) ) {
-		    /* prepare space */
-		    bi.bi_bh = tbS0;
-		    bi.bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-		    bi.bi_position = PATH_H_POSITION (tb->tb_path, 1);
-		    leaf_paste_in_buffer(tb->tb_fs, &bi, item_pos, pos_in_item, tb->insert_size[0], body, zeros_number);
-
-		    /* paste entry */
-		    leaf_paste_entries (bi.bi_bh, item_pos, pos_in_item, 1, (struct reiserfs_de_head *)body,
-					body + DEH_SIZE, tb->insert_size[0]);
-		    if ( ! item_pos && ! pos_in_item ) {
-			if (tb->CFL[0])  // can be 0 in reiserfsck
-			    replace_key(tb->tb_fs, tb->CFL[0], tb->lkey[0],tbS0,0);
-		    }
-		    tb->insert_size[0] = 0;
-		}
-	    } else { /* regular object */
-		if ( pos_in_item == get_ih_item_len (pasted) ) {
-		    bi.bi_bh = tbS0;
-		    bi.bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-		    bi.bi_position = PATH_H_POSITION (tb->tb_path, 1);
-		    leaf_paste_in_buffer (tb->tb_fs, &bi, item_pos, pos_in_item, tb->insert_size[0], body, zeros_number);
-
-		    if (I_IS_INDIRECT_ITEM (pasted)) {
-			set_ih_free_space (pasted, 0);
-		    }
-		    tb->insert_size[0] = 0;
+	/* if the affected item was not wholly shifted then we perform all
+	   necessary operations on that part or whole of the affected item which
+	   remains in S */
+	if (0 <= item_pos && item_pos < tb->s0num) {
+		/* if we must insert or append into buffer S[0] */
+
+		switch (flag) {
+		case M_INSERT:	/* insert item into S[0] */
+			bi.bi_bh = tbS0;
+			bi.bi_parent = PATH_H_PPARENT(tb->tb_path, 0);
+			bi.bi_position = PATH_H_POSITION(tb->tb_path, 1);
+			leaf_insert_into_buf(tb->tb_fs, &bi, item_pos, ih, body,
+					     zeros_number);
+
+			/* If we insert the first key change the delimiting key */
+			if (item_pos == 0) {
+				if (tb->CFL[0])	/* can be 0 in reiserfsck */
+					replace_key(tb->tb_fs, tb->CFL[0],
+						    tb->lkey[0], tbS0, 0);
+			}
+			break;
+
+		case M_PASTE:{	/* append item in S[0] */
+				struct item_head *pasted;
+
+				pasted = B_N_PITEM_HEAD(tbS0, item_pos);
+				/* when directory, may be new entry already pasted */
+				if (I_IS_DIRECTORY_ITEM(pasted)) {
+					if (pos_in_item >= 0
+					    && pos_in_item <=
+					    get_ih_entry_count(pasted)) {
+						/* prepare space */
+						bi.bi_bh = tbS0;
+						bi.bi_parent =
+						    PATH_H_PPARENT(tb->tb_path,
+								   0);
+						bi.bi_position =
+						    PATH_H_POSITION(tb->tb_path,
+								    1);
+						leaf_paste_in_buffer(tb->tb_fs,
+								     &bi,
+								     item_pos,
+								     pos_in_item,
+								     tb->
+								     insert_size
+								     [0], body,
+								     zeros_number);
+
+						/* paste entry */
+						leaf_paste_entries(bi.bi_bh,
+								   item_pos,
+								   pos_in_item,
+								   1,
+								   (struct
+								    reiserfs_de_head
+								    *)body,
+								   body +
+								   DEH_SIZE,
+								   tb->
+								   insert_size
+								   [0]);
+						if (!item_pos && !pos_in_item) {
+							if (tb->CFL[0])	// can be 0 in reiserfsck
+								replace_key(tb->
+									    tb_fs,
+									    tb->
+									    CFL
+									    [0],
+									    tb->
+									    lkey
+									    [0],
+									    tbS0,
+									    0);
+						}
+						tb->insert_size[0] = 0;
+					}
+				} else {	/* regular object */
+					if (pos_in_item ==
+					    get_ih_item_len(pasted)) {
+						bi.bi_bh = tbS0;
+						bi.bi_parent =
+						    PATH_H_PPARENT(tb->tb_path,
+								   0);
+						bi.bi_position =
+						    PATH_H_POSITION(tb->tb_path,
+								    1);
+						leaf_paste_in_buffer(tb->tb_fs,
+								     &bi,
+								     item_pos,
+								     pos_in_item,
+								     tb->
+								     insert_size
+								     [0], body,
+								     zeros_number);
+
+						if (I_IS_INDIRECT_ITEM(pasted)) {
+							set_ih_free_space
+							    (pasted, 0);
+						}
+						tb->insert_size[0] = 0;
+					}
+				}
+			}	/* case M_PASTE: */
 		}
-	    }
-	} /* case M_PASTE: */
 	}
-    }
-
-    return 0;
-} /* Leaf level of the tree is balanced (end of balance_leaf) */
 
+	return 0;
+}				/* Leaf level of the tree is balanced (end of balance_leaf) */
 
-void make_empty_leaf (struct buffer_head * bh)
+void make_empty_leaf(struct buffer_head *bh)
 {
-    set_blkh_nr_items (B_BLK_HEAD (bh), 0);
-    set_blkh_free_space (B_BLK_HEAD (bh), MAX_FREE_SPACE (bh->b_size));
-    set_blkh_level (B_BLK_HEAD (bh), DISK_LEAF_NODE_LEVEL);
+	set_blkh_nr_items(B_BLK_HEAD(bh), 0);
+	set_blkh_free_space(B_BLK_HEAD(bh), MAX_FREE_SPACE(bh->b_size));
+	set_blkh_level(B_BLK_HEAD(bh), DISK_LEAF_NODE_LEVEL);
 }
 
-
 /* Make empty node */
-void make_empty_node (struct buffer_info * bi)
+void make_empty_node(struct buffer_info *bi)
 {
-    make_empty_leaf (bi->bi_bh);
+	make_empty_leaf(bi->bi_bh);
 
-    if (bi->bi_parent)
-	set_dc_child_size (B_N_CHILD (bi->bi_parent, bi->bi_position), 0);
+	if (bi->bi_parent)
+		set_dc_child_size(B_N_CHILD(bi->bi_parent, bi->bi_position), 0);
 }
 
-
 /* Get first empty buffer */
-struct buffer_head * get_FEB (struct tree_balance * tb)
+struct buffer_head *get_FEB(struct tree_balance *tb)
 {
-    int i;
-    struct buffer_head * first_b;
-    struct buffer_info bi;
+	int i;
+	struct buffer_head *first_b;
+	struct buffer_info bi;
 
-    for (i = 0; i < MAX_FEB_SIZE; i ++)
-	if (tb->FEB[i] != 0)
-	    break;
+	for (i = 0; i < MAX_FEB_SIZE; i++)
+		if (tb->FEB[i] != 0)
+			break;
 
-    if (i == MAX_FEB_SIZE)
-	reiserfs_panic("vs-12300: get_FEB: FEB list is empty");
+	if (i == MAX_FEB_SIZE)
+		reiserfs_panic("vs-12300: get_FEB: FEB list is empty");
 
-    bi.bi_bh = first_b = tb->FEB[i];
-    bi.bi_parent = 0;
-    bi.bi_position = 0;
-    make_empty_node (&bi);
-    misc_set_bit(BH_Uptodate, &first_b->b_state);
+	bi.bi_bh = first_b = tb->FEB[i];
+	bi.bi_parent = 0;
+	bi.bi_position = 0;
+	make_empty_node(&bi);
+	misc_set_bit(BH_Uptodate, &first_b->b_state);
 
-    tb->FEB[i] = 0;
-    tb->used[i] = first_b;
+	tb->FEB[i] = 0;
+	tb->used[i] = first_b;
 
-    return(first_b);
+	return (first_b);
 }
 
-
 /* Replace n_dest'th key in buffer dest by n_src'th key of buffer src.*/
-void replace_key (reiserfs_filsys_t * fs,
-		  struct buffer_head * dest, int n_dest,
-		  struct buffer_head * src, int n_src)
+void replace_key(reiserfs_filsys_t *fs,
+		 struct buffer_head *dest, int n_dest,
+		 struct buffer_head *src, int n_src)
 {
-    if (dest) {
-	if (is_leaf_node (src))
-	    /* source buffer contains leaf node */
-	    memcpy (B_N_PDELIM_KEY(dest,n_dest), B_N_PITEM_HEAD(src,n_src), KEY_SIZE);
-	else
-	    memcpy (B_N_PDELIM_KEY(dest,n_dest), B_N_PDELIM_KEY(src,n_src), KEY_SIZE);
-	
-	mark_buffer_dirty(dest);
-    }
-}
+	if (dest) {
+		if (is_leaf_node(src))
+			/* source buffer contains leaf node */
+			memcpy(B_N_PDELIM_KEY(dest, n_dest),
+			       B_N_PITEM_HEAD(src, n_src), KEY_SIZE);
+		else
+			memcpy(B_N_PDELIM_KEY(dest, n_dest),
+			       B_N_PDELIM_KEY(src, n_src), KEY_SIZE);
 
+		mark_buffer_dirty(dest);
+	}
+}
 
-void reiserfs_invalidate_buffer (struct tree_balance * tb, struct buffer_head * bh, int do_free_block)
+void reiserfs_invalidate_buffer(struct tree_balance *tb, struct buffer_head *bh,
+				int do_free_block)
 {
-    set_blkh_level (B_BLK_HEAD (bh), FREE_LEVEL);
-    misc_clear_bit(BH_Dirty, &bh->b_state);
+	set_blkh_level(B_BLK_HEAD(bh), FREE_LEVEL);
+	misc_clear_bit(BH_Dirty, &bh->b_state);
 
-    if (do_free_block) {
-	struct buffer_head * to_be_forgotten;
+	if (do_free_block) {
+		struct buffer_head *to_be_forgotten;
 
-	to_be_forgotten = find_buffer (bh->b_dev, bh->b_blocknr, bh->b_size);
-	if (to_be_forgotten) {
-	    to_be_forgotten->b_count ++;
-	    bforget (to_be_forgotten);
-	}
+		to_be_forgotten =
+		    find_buffer(bh->b_dev, bh->b_blocknr, bh->b_size);
+		if (to_be_forgotten) {
+			to_be_forgotten->b_count++;
+			bforget(to_be_forgotten);
+		}
 
-	reiserfs_free_block (tb->tb_fs, bh->b_blocknr);
-    }
+		reiserfs_free_block(tb->tb_fs, bh->b_blocknr);
+	}
 }
 
-
-int get_left_neighbor_position (
-				struct tree_balance * tb, 
-				int h
-				)
+int get_left_neighbor_position(struct tree_balance *tb, int h)
 {
-  int Sh_position = PATH_H_POSITION (tb->tb_path, h + 1);
+	int Sh_position = PATH_H_POSITION(tb->tb_path, h + 1);
 
-  if (Sh_position == 0)
-    return B_NR_ITEMS (tb->FL[h]);
-  else
-    return Sh_position - 1;
+	if (Sh_position == 0)
+		return B_NR_ITEMS(tb->FL[h]);
+	else
+		return Sh_position - 1;
 }
 
-
-int get_right_neighbor_position (struct tree_balance * tb, int h)
+int get_right_neighbor_position(struct tree_balance *tb, int h)
 {
-  int Sh_position = PATH_H_POSITION (tb->tb_path, h + 1);
+	int Sh_position = PATH_H_POSITION(tb->tb_path, h + 1);
 
-  if (Sh_position == B_NR_ITEMS (PATH_H_PPARENT (tb->tb_path, h)))
-    return 0;
-  else
-    return Sh_position + 1;
+	if (Sh_position == B_NR_ITEMS(PATH_H_PPARENT(tb->tb_path, h)))
+		return 0;
+	else
+		return Sh_position + 1;
 }
 
 /* Now we have all of the buffers that must be used in balancing of the tree.
@@ -1079,75 +1589,72 @@ int get_right_neighbor_position (struct tree_balance * tb, int h)
 
 */
 
-void do_balance (struct tree_balance * tb,		/* tree_balance structure 		*/
-		 struct item_head * ih,	/* item header of inserted item */
-		 const char * body, /* body  of inserted item or bytes to paste */
-		 int flag,  /* i - insert, d - delete
-			       c - cut, p - paste
-						      
-			       Cut means delete part of an item (includes
-			       removing an entry from a directory).
-						      
-			       Delete means delete whole item.
-						      
-			       Insert means add a new item into the tree.
-						      						      
-			       Paste means to append to the end of an existing
-			       file or to insert a directory entry.  */
-		 int zeros_num)
-{
-    //int pos_in_item = tb->tb_path->pos_in_item;
-    int child_pos, /* position of a child node in its parent */
-	h;	   /* level of the tree being processed */
-    struct item_head insert_key[2]; /* in our processing of one level we
-				       sometimes determine what must be
-				       inserted into the next higher level.
-				       This insertion consists of a key or two
-				       keys and their corresponding pointers */
-    struct buffer_head *insert_ptr[2]; /* inserted node-ptrs for the next
-					  level */
-
-    /* if we have no real work to do  */
-    if ( ! tb->insert_size[0] ) {
-	unfix_nodes(/*th,*/ tb);
-	return;
-    }
-
-    if (flag == M_INTERNAL) {
-	insert_ptr[0] = (struct buffer_head *)body;
-	/* we must prepare insert_key */
-
-	if (PATH_H_B_ITEM_ORDER (tb->tb_path, 0)/*LAST_POSITION (tb->tb_path)*//*item_pos*/ == -1) {
-		/* get delimiting key from buffer in tree */
-		copy_key (&insert_key[0].ih_key, B_N_PKEY (PATH_PLAST_BUFFER (tb->tb_path), 0));
-		/*insert_ptr[0]->b_item_order = 0;*/
-	} else {
-	    /* get delimiting key from new buffer */
-	    copy_key (&insert_key[0].ih_key, B_N_PKEY((struct buffer_head *)body,0));
-	    /*insert_ptr[0]->b_item_order = item_pos;*/
-	}
-      
-	/* and insert_ptr instead of balance_leaf */
-	child_pos = PATH_H_B_ITEM_ORDER (tb->tb_path, 0)/*item_pos*/;
-    } else
-	/* balance leaf returns 0 except if combining L R and S into one node.
-	   see balance_internal() for explanation of this line of code.*/
-	child_pos = PATH_H_B_ITEM_ORDER (tb->tb_path, 0) +
-	    balance_leaf (/*th,*/ tb/*, pos_in_item*/, ih, body, flag, zeros_num, insert_key, insert_ptr);
-
-    /* Balance internal level of the tree. */
-    for ( h = 1; h < MAX_HEIGHT && tb->insert_size[h]; h++ )
-	child_pos = balance_internal (/*th,*/ tb, h, child_pos, insert_key, insert_ptr);
-
-    /* Release all (except for S[0]) non NULL buffers fixed by fix_nodes() */
-    unfix_nodes(/*th,*/ tb);
-}
-
-
+void do_balance(struct tree_balance *tb,	/* tree_balance structure               */
+		struct item_head *ih,	/* item header of inserted item */
+		const char *body,	/* body  of inserted item or bytes to paste */
+		int flag,	/* i - insert, d - delete
+				   c - cut, p - paste
 
+				   Cut means delete part of an item (includes
+				   removing an entry from a directory).
 
+				   Delete means delete whole item.
 
+				   Insert means add a new item into the tree.
 
+				   Paste means to append to the end of an existing
+				   file or to insert a directory entry.  */
+		int zeros_num)
+{
+	//int pos_in_item = tb->tb_path->pos_in_item;
+	int child_pos,		/* position of a child node in its parent */
+	 h;			/* level of the tree being processed */
+	struct item_head insert_key[2];	/* in our processing of one level we
+					   sometimes determine what must be
+					   inserted into the next higher level.
+					   This insertion consists of a key or two
+					   keys and their corresponding pointers */
+	struct buffer_head *insert_ptr[2];	/* inserted node-ptrs for the next
+						   level */
+
+	/* if we have no real work to do  */
+	if (!tb->insert_size[0]) {
+		unfix_nodes( /*th, */ tb);
+		return;
+	}
 
+	if (flag == M_INTERNAL) {
+		insert_ptr[0] = (struct buffer_head *)body;
+		/* we must prepare insert_key */
 
+		if (PATH_H_B_ITEM_ORDER(tb->tb_path, 0)	/*LAST_POSITION (tb->tb_path) */
+		    /*item_pos */  == -1) {
+			/* get delimiting key from buffer in tree */
+			copy_key(&insert_key[0].ih_key,
+				 B_N_PKEY(PATH_PLAST_BUFFER(tb->tb_path), 0));
+			/*insert_ptr[0]->b_item_order = 0; */
+		} else {
+			/* get delimiting key from new buffer */
+			copy_key(&insert_key[0].ih_key,
+				 B_N_PKEY((struct buffer_head *)body, 0));
+			/*insert_ptr[0]->b_item_order = item_pos; */
+		}
 
+		/* and insert_ptr instead of balance_leaf */
+		child_pos = PATH_H_B_ITEM_ORDER(tb->tb_path, 0) /*item_pos */ ;
+	} else
+		/* balance leaf returns 0 except if combining L R and S into one node.
+		   see balance_internal() for explanation of this line of code. */
+		child_pos = PATH_H_B_ITEM_ORDER(tb->tb_path, 0) +
+		    balance_leaf( /*th, */ tb /*, pos_in_item */ , ih, body,
+				 flag, zeros_num, insert_key, insert_ptr);
+
+	/* Balance internal level of the tree. */
+	for (h = 1; h < MAX_HEIGHT && tb->insert_size[h]; h++)
+		child_pos =
+		    balance_internal( /*th, */ tb, h, child_pos, insert_key,
+				     insert_ptr);
+
+	/* Release all (except for S[0]) non NULL buffers fixed by fix_nodes() */
+	unfix_nodes( /*th, */ tb);
+}
diff --git a/reiserfscore/fix_node.c b/reiserfscore/fix_node.c
index 9fa3661..558a336 100644
--- a/reiserfscore/fix_node.c
+++ b/reiserfscore/fix_node.c
@@ -36,10 +36,8 @@
  ** 
  **/
 
-
 #include "includes.h"
 
-
 /* To make any changes in the tree we find a node, that contains item to be
    changed/deleted or position in the node we insert a new item to. We call
    this node S. To do balancing we need to decide what we will shift to
@@ -53,462 +51,488 @@
    to have if we do not any shiftings, if we shift to left/right neighbor or
    to both. */
 
-
 /* taking item number in virtual node, returns number of item, that it has in
    source buffer */
-static inline int old_item_num (int new_num, int affected_item_num, int mode)
+static inline int old_item_num(int new_num, int affected_item_num, int mode)
 {
-    if (mode == M_PASTE || mode == M_CUT || new_num < affected_item_num)
-	return new_num;
-    
-    if (mode == M_INSERT)
-	return new_num - 1;
-
-    /* delete mode */
-    return new_num + 1;
-}
+	if (mode == M_PASTE || mode == M_CUT || new_num < affected_item_num)
+		return new_num;
+
+	if (mode == M_INSERT)
+		return new_num - 1;
 
+	/* delete mode */
+	return new_num + 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 new_num, int affected_item_num, int new_entry_num, int pos_in_item, int mode)
+static inline int old_entry_num(int new_num, int affected_item_num,
+				int new_entry_num, int pos_in_item, int mode)
 {
-    if ( mode == M_INSERT || mode == M_DELETE)
-	return new_entry_num;
-    
-    if (new_num != affected_item_num) {
-	/* cut or paste is applied to another item */
-	return new_entry_num;
-    }
-    
-    if (new_entry_num < pos_in_item)
-	return new_entry_num;
-    
-    if (mode == M_CUT)
-	return new_entry_num + 1;
-    
-    return new_entry_num - 1;
-}
+	if (mode == M_INSERT || mode == M_DELETE)
+		return new_entry_num;
+
+	if (new_num != affected_item_num) {
+		/* cut or paste is applied to another item */
+		return new_entry_num;
+	}
 
+	if (new_entry_num < pos_in_item)
+		return new_entry_num;
 
+	if (mode == M_CUT)
+		return new_entry_num + 1;
+
+	return new_entry_num - 1;
+}
 
 /*
  * Create an array of sizes of directory entries for virtual item
  */
-static void set_entry_sizes (struct tree_balance * tb,
-			     int old_num, int new_num,
-			     struct buffer_head * bh,
-			     struct item_head * ih)
+static void set_entry_sizes(struct tree_balance *tb,
+			    int old_num, int new_num,
+			    struct buffer_head *bh, struct item_head *ih)
 {
-    struct virtual_node * vn = tb->tb_vn;
-    int i;
-    struct reiserfs_de_head * deh;
-    struct virtual_item * vi;
-  
-    deh = B_I_DEH (bh, ih);
-
-    /* seek to given virtual item in array of virtual items */
-    vi = vn->vn_vi + new_num;
-
-    /* virtual directory item have this amount of entry after */
-    vi->vi_entry_count = get_ih_entry_count (ih) + 
-	((old_num == vn->vn_affected_item_num) ? ((vn->vn_mode == M_CUT) ? -1 :
-						  (vn->vn_mode == M_PASTE ? 1 : 0)) : 0);
-    vi->vi_entry_sizes = (__u16 *)vn->vn_free_ptr;
-    vn->vn_free_ptr += vi->vi_entry_count * sizeof (__u16);
-
-    /* set sizes of old entries */
-    for (i = 0; i < vi->vi_entry_count; i ++) {
-	int j;
-    
-	j = old_entry_num (old_num, vn->vn_affected_item_num, i, vn->vn_pos_in_item, vn->vn_mode);
-	vi->vi_entry_sizes[i] = entry_length (ih, &(deh[j]), j) + DEH_SIZE;
-    }
-  
-    /* set size of pasted entry */
-    if (old_num == vn->vn_affected_item_num && vn->vn_mode == M_PASTE)
-	vi->vi_entry_sizes[vn->vn_pos_in_item] = tb->insert_size[0];
-}
+	struct virtual_node *vn = tb->tb_vn;
+	int i;
+	struct reiserfs_de_head *deh;
+	struct virtual_item *vi;
+
+	deh = B_I_DEH(bh, ih);
+
+	/* seek to given virtual item in array of virtual items */
+	vi = vn->vn_vi + new_num;
+
+	/* virtual directory item have this amount of entry after */
+	vi->vi_entry_count = get_ih_entry_count(ih) +
+	    ((old_num ==
+	      vn->vn_affected_item_num) ? ((vn->vn_mode ==
+					    M_CUT) ? -1 : (vn->vn_mode ==
+							   M_PASTE ? 1 : 0)) :
+	     0);
+	vi->vi_entry_sizes = (__u16 *) vn->vn_free_ptr;
+	vn->vn_free_ptr += vi->vi_entry_count * sizeof(__u16);
+
+	/* set sizes of old entries */
+	for (i = 0; i < vi->vi_entry_count; i++) {
+		int j;
+
+		j = old_entry_num(old_num, vn->vn_affected_item_num, i,
+				  vn->vn_pos_in_item, vn->vn_mode);
+		vi->vi_entry_sizes[i] =
+		    entry_length(ih, &(deh[j]), j) + DEH_SIZE;
+	}
 
+	/* set size of pasted entry */
+	if (old_num == vn->vn_affected_item_num && vn->vn_mode == M_PASTE)
+		vi->vi_entry_sizes[vn->vn_pos_in_item] = tb->insert_size[0];
+}
 
-static void create_virtual_node (struct tree_balance * tb, int h)
+static void create_virtual_node(struct tree_balance *tb, int h)
 {
-    struct item_head * ih;
-    struct virtual_node * vn = tb->tb_vn;
-    int new_num;
-    struct buffer_head * Sh;	/* this comes from tb->S[h] */
-
-    Sh = PATH_H_PBUFFER (tb->tb_path, h);
-
-    /* size of changed node */
-    vn->vn_size = MAX_CHILD_SIZE (Sh->b_size) - get_blkh_free_space (B_BLK_HEAD (Sh)) + tb->insert_size[h];
-
-    /* for internal nodes array if virtual items is not created */
-    if (h) {
-	vn->vn_nr_item = (vn->vn_size - DC_SIZE) / (DC_SIZE + KEY_SIZE);
-	return;
-    }
-
-    /* number of items in virtual node  */
-    vn->vn_nr_item = B_NR_ITEMS (Sh) + ((vn->vn_mode == M_INSERT)? 1 : 0) - ((vn->vn_mode == M_DELETE)? 1 : 0);
-
-    /* first virtual item */
-    vn->vn_vi = (struct virtual_item *)(tb->tb_vn + 1);
-    memset (vn->vn_vi, 0, vn->vn_nr_item * sizeof (struct virtual_item));
-    vn->vn_free_ptr += vn->vn_nr_item * sizeof (struct virtual_item);
-
-
-    /* first item in the node */
-    ih = B_N_PITEM_HEAD (Sh, 0);
-
-    /* define the mergeability for 0-th item (if it is not being deleted) */
-    if (is_left_mergeable (tb->tb_fs, tb->tb_path) == 1 && (vn->vn_mode != M_DELETE || vn->vn_affected_item_num))
-	vn->vn_vi[0].vi_type |= VI_TYPE_LEFT_MERGEABLE;
-
-    /* go through all items those remain in the virtual node (except for the new (inserted) one) */
-    for (new_num = 0; new_num < vn->vn_nr_item; new_num ++) {
-	int j;
-    
-	if (vn->vn_affected_item_num == new_num && vn->vn_mode == M_INSERT)
-	    continue;
-    
-	/* get item number in source node */
-	j = old_item_num (new_num, vn->vn_affected_item_num, vn->vn_mode);
-    
-	vn->vn_vi[new_num].vi_item_len += get_ih_item_len (&ih[j]) + IH_SIZE;
-    
-	if (I_IS_STAT_DATA_ITEM (ih + j)) {
-	    vn->vn_vi[new_num].vi_type |= VI_TYPE_STAT_DATA;
-	    continue;
+	struct item_head *ih;
+	struct virtual_node *vn = tb->tb_vn;
+	int new_num;
+	struct buffer_head *Sh;	/* this comes from tb->S[h] */
+
+	Sh = PATH_H_PBUFFER(tb->tb_path, h);
+
+	/* size of changed node */
+	vn->vn_size =
+	    MAX_CHILD_SIZE(Sh->b_size) - get_blkh_free_space(B_BLK_HEAD(Sh)) +
+	    tb->insert_size[h];
+
+	/* for internal nodes array if virtual items is not created */
+	if (h) {
+		vn->vn_nr_item = (vn->vn_size - DC_SIZE) / (DC_SIZE + KEY_SIZE);
+		return;
+	}
+
+	/* number of items in virtual node  */
+	vn->vn_nr_item =
+	    B_NR_ITEMS(Sh) + ((vn->vn_mode == M_INSERT) ? 1 : 0) -
+	    ((vn->vn_mode == M_DELETE) ? 1 : 0);
+
+	/* first virtual item */
+	vn->vn_vi = (struct virtual_item *)(tb->tb_vn + 1);
+	memset(vn->vn_vi, 0, vn->vn_nr_item * sizeof(struct virtual_item));
+	vn->vn_free_ptr += vn->vn_nr_item * sizeof(struct virtual_item);
+
+	/* first item in the node */
+	ih = B_N_PITEM_HEAD(Sh, 0);
+
+	/* define the mergeability for 0-th item (if it is not being deleted) */
+	if (is_left_mergeable(tb->tb_fs, tb->tb_path) == 1
+	    && (vn->vn_mode != M_DELETE || vn->vn_affected_item_num))
+		vn->vn_vi[0].vi_type |= VI_TYPE_LEFT_MERGEABLE;
+
+	/* go through all items those remain in the virtual node (except for the new (inserted) one) */
+	for (new_num = 0; new_num < vn->vn_nr_item; new_num++) {
+		int j;
+
+		if (vn->vn_affected_item_num == new_num
+		    && vn->vn_mode == M_INSERT)
+			continue;
+
+		/* get item number in source node */
+		j = old_item_num(new_num, vn->vn_affected_item_num,
+				 vn->vn_mode);
+
+		vn->vn_vi[new_num].vi_item_len +=
+		    get_ih_item_len(&ih[j]) + IH_SIZE;
+
+		if (I_IS_STAT_DATA_ITEM(ih + j)) {
+			vn->vn_vi[new_num].vi_type |= VI_TYPE_STAT_DATA;
+			continue;
+		}
+
+		/* set type of item */
+		if (I_IS_DIRECT_ITEM(ih + j))
+			vn->vn_vi[new_num].vi_type |= VI_TYPE_DIRECT;
+
+		if (I_IS_INDIRECT_ITEM(ih + j))
+			vn->vn_vi[new_num].vi_type |= VI_TYPE_INDIRECT;
+
+		if (I_IS_DIRECTORY_ITEM(ih + j)) {
+			set_entry_sizes(tb, j, new_num, Sh, ih + j);
+			vn->vn_vi[new_num].vi_type |= VI_TYPE_DIRECTORY;
+			if (get_key_offset_v1(&ih[j].ih_key) == DOT_OFFSET)
+				vn->vn_vi[new_num].vi_type |=
+				    VI_TYPE_FIRST_DIRECTORY_ITEM;
+		}
+
+		vn->vn_vi[new_num].vi_item_offset =
+		    get_offset(&(ih + j)->ih_key);
+
+		if (new_num != vn->vn_affected_item_num)
+			/* this is not being changed */
+			continue;
+
+		if (vn->vn_mode == M_PASTE || vn->vn_mode == M_CUT)
+			vn->vn_vi[new_num].vi_item_len += tb->insert_size[0];
 	}
 
-	/* set type of item */
-	if (I_IS_DIRECT_ITEM (ih + j))
-	    vn->vn_vi[new_num].vi_type |= VI_TYPE_DIRECT;
-    
-	if (I_IS_INDIRECT_ITEM (ih + j))
-	    vn->vn_vi[new_num].vi_type |= VI_TYPE_INDIRECT;
-
-	if (I_IS_DIRECTORY_ITEM (ih + j)) {
-	    set_entry_sizes (tb, j, new_num, Sh, ih + j);
-	    vn->vn_vi[new_num].vi_type |= VI_TYPE_DIRECTORY;
-	    if (get_key_offset_v1 (&ih[j].ih_key) == DOT_OFFSET)
-		vn->vn_vi[new_num].vi_type |= VI_TYPE_FIRST_DIRECTORY_ITEM;
+	/* virtual inserted item is not defined yet */
+	if (vn->vn_mode == M_INSERT) {
+		vn->vn_vi[vn->vn_affected_item_num].vi_item_len =
+		    tb->insert_size[0];
+		vn->vn_vi[vn->vn_affected_item_num].vi_item_offset =
+		    get_offset(&vn->vn_ins_ih->ih_key);
+
+		switch (get_type(&vn->vn_ins_ih->ih_key)) {
+		case TYPE_STAT_DATA:
+			vn->vn_vi[vn->vn_affected_item_num].vi_type |=
+			    VI_TYPE_STAT_DATA;
+			break;
+		case TYPE_DIRECT:
+			vn->vn_vi[vn->vn_affected_item_num].vi_type |=
+			    VI_TYPE_DIRECT;
+			break;
+		case TYPE_INDIRECT:
+			vn->vn_vi[vn->vn_affected_item_num].vi_type |=
+			    VI_TYPE_INDIRECT;
+			break;
+		default:
+			/* inseted item is directory (it must be item with "." and "..") */
+			vn->vn_vi[vn->vn_affected_item_num].vi_type |=
+			    (VI_TYPE_DIRECTORY | VI_TYPE_FIRST_DIRECTORY_ITEM |
+			     VI_TYPE_INSERTED_DIRECTORY_ITEM);
+
+			/* this directory item can not be split, so do not set sizes of entries */
+			break;
+		}
 	}
-    
-	vn->vn_vi[new_num].vi_item_offset = get_offset (&(ih + j)->ih_key);
-	
-	if (new_num != vn->vn_affected_item_num)
-	    /* this is not being changed */
-	    continue;
-    
-	if (vn->vn_mode == M_PASTE || vn->vn_mode == M_CUT)
-	    vn->vn_vi[new_num].vi_item_len += tb->insert_size[0];
-    }
-  
-  
-    /* virtual inserted item is not defined yet */
-    if (vn->vn_mode == M_INSERT) {
-	vn->vn_vi[vn->vn_affected_item_num].vi_item_len = tb->insert_size[0];
-	vn->vn_vi[vn->vn_affected_item_num].vi_item_offset = get_offset (&vn->vn_ins_ih->ih_key);
 
-	switch (get_type (&vn->vn_ins_ih->ih_key)) {
-	case TYPE_STAT_DATA:
-	    vn->vn_vi[vn->vn_affected_item_num].vi_type |= VI_TYPE_STAT_DATA;
-	    break;
-	case TYPE_DIRECT:
-	    vn->vn_vi[vn->vn_affected_item_num].vi_type |= VI_TYPE_DIRECT;
-	    break;
-	case TYPE_INDIRECT:
-	    vn->vn_vi[vn->vn_affected_item_num].vi_type |= VI_TYPE_INDIRECT;
-	    break;
-	default:
-	    /* inseted item is directory (it must be item with "." and "..") */
-	    vn->vn_vi[vn->vn_affected_item_num].vi_type |= 
-		(VI_TYPE_DIRECTORY | VI_TYPE_FIRST_DIRECTORY_ITEM | VI_TYPE_INSERTED_DIRECTORY_ITEM);
-      
-	    /* this directory item can not be split, so do not set sizes of entries */
-	    break;
+	/* set right merge flag we take right delimiting key and check whether it is a mergeable item */
+	if (tb->CFR[0]) {
+		ih = (struct item_head *)B_N_PDELIM_KEY(tb->CFR[0],
+							tb->rkey[0]);
+		if (is_right_mergeable(tb->tb_fs, tb->tb_path) == 1
+		    && (vn->vn_mode != M_DELETE
+			|| vn->vn_affected_item_num != B_NR_ITEMS(Sh) - 1))
+			vn->vn_vi[vn->vn_nr_item - 1].vi_type |=
+			    VI_TYPE_RIGHT_MERGEABLE;
 	}
-    }
-  
-    /* set right merge flag we take right delimiting key and check whether it is a mergeable item */
-    if (tb->CFR[0]) {
-	ih = (struct item_head *)B_N_PDELIM_KEY (tb->CFR[0], tb->rkey[0]);
-	if (is_right_mergeable (tb->tb_fs, tb->tb_path) == 1 &&
-		(vn->vn_mode != M_DELETE || vn->vn_affected_item_num != B_NR_ITEMS (Sh) - 1))
-	    vn->vn_vi[vn->vn_nr_item-1].vi_type |= VI_TYPE_RIGHT_MERGEABLE;
-    }
 }
 
-
 /* using virtual node check, how many items can be shifted to left
    neighbor */
-static  int check_left (struct tree_balance * tb, int h, int cur_free)
+static int check_left(struct tree_balance *tb, int h, int cur_free)
 {
-    int i;
-    struct virtual_node * vn = tb->tb_vn;
-    int d_size, ih_size, bytes = -1;
-
-    /* internal level */
-    if (h > 0) {	
-	if (!cur_free ) {
-	    tb->lnum[h] = 0; 
-	    return 0;
+	int i;
+	struct virtual_node *vn = tb->tb_vn;
+	int d_size, ih_size, bytes = -1;
+
+	/* internal level */
+	if (h > 0) {
+		if (!cur_free) {
+			tb->lnum[h] = 0;
+			return 0;
+		}
+		tb->lnum[h] = cur_free / (DC_SIZE + KEY_SIZE);
+		return -1;
 	}
-	tb->lnum[h] = cur_free / (DC_SIZE + KEY_SIZE);
-	return -1;
-    }
 
-    /* leaf level */
+	/* leaf level */
 
-    if (!cur_free || !vn->vn_nr_item) {
-	/* no free space */
-	tb->lnum[h] = 0;
-	tb->lbytes = -1;
-	return 0;
-    }
-
-    if ((unsigned int)cur_free >= (vn->vn_size - ((vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE) ? IH_SIZE : 0))) {
-	/* all contents of S[0] fits into L[0] */
-	tb->lnum[0] = vn->vn_nr_item;
-	tb->lbytes = -1;
-	return -1;
-    }
-  
-    d_size = 0, ih_size = IH_SIZE;
-
-    /* first item may be merge with last item in left neighbor */
-    if (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE)
-	d_size = -((int)IH_SIZE), ih_size = 0;
-
-    tb->lnum[0] = 0;
-    for (i = 0; i < vn->vn_nr_item; i ++, ih_size = IH_SIZE, d_size = 0) {
-	d_size += vn->vn_vi[i].vi_item_len;
-	if (cur_free >= d_size) {	
-	    /* the item can be shifted entirely */
-	    cur_free -= d_size;
-	    tb->lnum[0] ++;
-	    continue;
-	}
-      
-	/* the item cannot be shifted entirely, try to split it */
-	/* check whether L[0] can hold ih and at least one byte of the item body */
-	if (cur_free <= ih_size) {
-	    /* cannot shift even a part of the current item */
-	    tb->lbytes = -1;
-	    return -1;
-	}
-	cur_free -= ih_size;
-    
-	if (vn->vn_vi[i].vi_type & VI_TYPE_STAT_DATA ||
-	    vn->vn_vi[i].vi_type & VI_TYPE_INSERTED_DIRECTORY_ITEM)	{
-	    /* virtual item is a stat_data or empty directory body ("." and ".."), that is not split able */
-	    tb->lbytes = -1;
-	    return -1;
-	}
-    
-	if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECT) {
-	    /* body of a direct item can be split by 8 bytes */
-	    int align = 8 - (vn->vn_vi[i].vi_item_offset - 1) % 8;
-//	    reiserfs_warning(stderr,"\nbalancing: cur_free (%d) ", cur_free);
-	    tb->lbytes = bytes = (cur_free >= align) ? (align + ((cur_free - align) / 8 * 8)) : 0;
-//	    reiserfs_warning(stderr,"offset (0x%Lx), move_left (%d), get offset (0x%Lx)",
-//	    	vn->vn_vi[i].vi_item_offset, bytes, vn->vn_vi[i].vi_item_offset + bytes);
+	if (!cur_free || !vn->vn_nr_item) {
+		/* no free space */
+		tb->lnum[h] = 0;
+		tb->lbytes = -1;
+		return 0;
 	}
 
-	if (vn->vn_vi[i].vi_type & VI_TYPE_INDIRECT)
-	    /* body of a indirect item can be split at unformatted pointer bound */
-	    tb->lbytes = bytes = cur_free - cur_free % UNFM_P_SIZE;
-    
-	/* item is of directory type */     
-	if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECTORY) {
-	    /* directory entries are the solid granules of the directory
-	       item, they cannot be split in the middle */
-      
-	    /* calculate number of dir entries that can be shifted, and
-	       their total size */
-	    int j;
-	    struct virtual_item * vi;
-      
-	    tb->lbytes = 0;
-	    bytes = 0;
-	    vi = &vn->vn_vi[i];
-      
-	    for (j = 0; j < vi->vi_entry_count; j ++) {
-		if (vi->vi_entry_sizes[j] > cur_free)
-		    /* j-th entry doesn't fit into L[0] */
-		    break;
-		  
-		bytes += vi->vi_entry_sizes[j];
-		cur_free -= vi->vi_entry_sizes[j];
-		tb->lbytes ++;
-	    }
-	    /* "." can not be cut from first directory item */
-	    if ((vn->vn_vi[i].vi_type & VI_TYPE_FIRST_DIRECTORY_ITEM) && tb->lbytes < 2)
-		tb->lbytes = 0;
+	if ((unsigned int)cur_free >=
+	    (vn->vn_size -
+	     ((vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE) ? IH_SIZE : 0))) {
+		/* all contents of S[0] fits into L[0] */
+		tb->lnum[0] = vn->vn_nr_item;
+		tb->lbytes = -1;
+		return -1;
 	}
-    
 
-	if (tb->lbytes <= 0) {
-	    /* nothing can flow from the item */
-	    tb->lbytes = -1;
-	    return -1;
+	d_size = 0, ih_size = IH_SIZE;
+
+	/* first item may be merge with last item in left neighbor */
+	if (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE)
+		d_size = -((int)IH_SIZE), ih_size = 0;
+
+	tb->lnum[0] = 0;
+	for (i = 0; i < vn->vn_nr_item; i++, ih_size = IH_SIZE, d_size = 0) {
+		d_size += vn->vn_vi[i].vi_item_len;
+		if (cur_free >= d_size) {
+			/* the item can be shifted entirely */
+			cur_free -= d_size;
+			tb->lnum[0]++;
+			continue;
+		}
+
+		/* the item cannot be shifted entirely, try to split it */
+		/* check whether L[0] can hold ih and at least one byte of the item body */
+		if (cur_free <= ih_size) {
+			/* cannot shift even a part of the current item */
+			tb->lbytes = -1;
+			return -1;
+		}
+		cur_free -= ih_size;
+
+		if (vn->vn_vi[i].vi_type & VI_TYPE_STAT_DATA ||
+		    vn->vn_vi[i].vi_type & VI_TYPE_INSERTED_DIRECTORY_ITEM) {
+			/* virtual item is a stat_data or empty directory body ("." and ".."), that is not split able */
+			tb->lbytes = -1;
+			return -1;
+		}
+
+		if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECT) {
+			/* body of a direct item can be split by 8 bytes */
+			int align = 8 - (vn->vn_vi[i].vi_item_offset - 1) % 8;
+//          reiserfs_warning(stderr,"\nbalancing: cur_free (%d) ", cur_free);
+			tb->lbytes = bytes =
+			    (cur_free >=
+			     align) ? (align +
+				       ((cur_free - align) / 8 * 8)) : 0;
+//          reiserfs_warning(stderr,"offset (0x%Lx), move_left (%d), get offset (0x%Lx)",
+//              vn->vn_vi[i].vi_item_offset, bytes, vn->vn_vi[i].vi_item_offset + bytes);
+		}
+
+		if (vn->vn_vi[i].vi_type & VI_TYPE_INDIRECT)
+			/* body of a indirect item can be split at unformatted pointer bound */
+			tb->lbytes = bytes = cur_free - cur_free % UNFM_P_SIZE;
+
+		/* item is of directory type */
+		if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECTORY) {
+			/* directory entries are the solid granules of the directory
+			   item, they cannot be split in the middle */
+
+			/* calculate number of dir entries that can be shifted, and
+			   their total size */
+			int j;
+			struct virtual_item *vi;
+
+			tb->lbytes = 0;
+			bytes = 0;
+			vi = &vn->vn_vi[i];
+
+			for (j = 0; j < vi->vi_entry_count; j++) {
+				if (vi->vi_entry_sizes[j] > cur_free)
+					/* j-th entry doesn't fit into L[0] */
+					break;
+
+				bytes += vi->vi_entry_sizes[j];
+				cur_free -= vi->vi_entry_sizes[j];
+				tb->lbytes++;
+			}
+			/* "." can not be cut from first directory item */
+			if ((vn->vn_vi[i].
+			     vi_type & VI_TYPE_FIRST_DIRECTORY_ITEM)
+			    && tb->lbytes < 2)
+				tb->lbytes = 0;
+		}
+
+		if (tb->lbytes <= 0) {
+			/* nothing can flow from the item */
+			tb->lbytes = -1;
+			return -1;
+		}
+
+		/* something can flow from the item */
+		tb->lnum[0]++;
+		return bytes;	/* part of split item in bytes */
 	}
-    
-	/* something can flow from the item */
-	tb->lnum[0] ++;
-	return bytes;	/* part of split item in bytes */
-    }
-  
 
-    reiserfs_panic (0, "vs-8065: check_left: all items fit in the left neighbor");
-    return 0;
+	reiserfs_panic(0,
+		       "vs-8065: check_left: all items fit in the left neighbor");
+	return 0;
 }
 
-	
-
 /* using virtual node check, how many items can be shifted to right
    neighbor */
-static int check_right (struct tree_balance * tb, int h, int cur_free)
+static int check_right(struct tree_balance *tb, int h, int cur_free)
 {
-    int i;
-    struct virtual_node * vn = tb->tb_vn;
-    int d_size, ih_size, bytes = -1;
-
-    /* internal level */
-    if (h > 0) {
-	if (!cur_free) {
-	    tb->rnum[h] = 0; 
-	    return 0;
-	}
-	tb->rnum[h] = cur_free / (DC_SIZE + KEY_SIZE);
-	return -1;
-    }
-    
-    /* leaf level */
-    
-    if (!cur_free || !vn->vn_nr_item) {
-	/* no free space  */
-	tb->rnum[h] = 0;
-	tb->rbytes = -1;
-	return 0;
-    }
-  
-    if ((unsigned int)cur_free >= (vn->vn_size - ((vn->vn_vi[vn->vn_nr_item-1].vi_type & VI_TYPE_RIGHT_MERGEABLE) ? IH_SIZE : 0)))
-    {
-	/* all contents of S[0] fits into R[0] */
-	tb->rnum[h] = vn->vn_nr_item;
-	tb->rbytes = -1;
-	return -1;
-    }
-    
-    d_size = 0, ih_size = IH_SIZE;
-    
-    /* last item may be merge with first item in right neighbor */
-    if (vn->vn_vi[vn->vn_nr_item - 1].vi_type & VI_TYPE_RIGHT_MERGEABLE)
-	d_size = -(int)IH_SIZE, ih_size = 0;
-    
-    tb->rnum[0] = 0;
-    for (i = vn->vn_nr_item - 1; i >= 0; i --, d_size = 0, ih_size = IH_SIZE) {
-	d_size += vn->vn_vi[i].vi_item_len;
-	if (cur_free >= d_size)	{	
-	    /* the item can be shifted entirely */
-	    cur_free -= d_size;
-	    tb->rnum[0] ++;
-	    continue;
+	int i;
+	struct virtual_node *vn = tb->tb_vn;
+	int d_size, ih_size, bytes = -1;
+
+	/* internal level */
+	if (h > 0) {
+		if (!cur_free) {
+			tb->rnum[h] = 0;
+			return 0;
+		}
+		tb->rnum[h] = cur_free / (DC_SIZE + KEY_SIZE);
+		return -1;
 	}
 
-	/* the item cannot be shifted entirely, try to split it */
-	if (vn->vn_vi[i].vi_type & VI_TYPE_STAT_DATA || vn->vn_vi[i].vi_type & VI_TYPE_INSERTED_DIRECTORY_ITEM) {
-	    /* virtual item is a stat_data or empty directory body ("." and
-               "..), that is not split able */
-	    tb->rbytes = -1;
-	    return -1;
-	}
-	
-	/* check whether R[0] can hold ih and at least one byte of the item
-           body */
-	if ( cur_free <= ih_size ) {
-	    /* cannot shift even a part of the current item */
-	    tb->rbytes = -1;
-	    return -1;
-	}
-	
-	/* R[0] can hold the header of the item and at least one byte of its
-           body */
-	cur_free -= ih_size;	/* cur_free is still > 0 */
-	
-	/* item is of direct type */
-	if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECT) {
-	    /* body of a direct item can be split by 8 bytes */
-	    int align = vn->vn_vi[i].vi_item_len % 8;
-//	    reiserfs_warning(stderr,"\nbalancing: cur_free (%d) ", cur_free);
-	    tb->rbytes = bytes = (cur_free >= align) ? (align + ((cur_free - align) / 8 * 8)) : 0;
-//	    reiserfs_warning(stderr, "offset (0x%Lx) len (%d), move right (%d), get offset (0x%Lx)",
-//	    	vn->vn_vi[i].vi_item_offset, vn->vn_vi[i].vi_item_len, bytes,
-//	    	vn->vn_vi[i].vi_item_offset + vn->vn_vi[i].vi_item_len - bytes);
+	/* leaf level */
+
+	if (!cur_free || !vn->vn_nr_item) {
+		/* no free space  */
+		tb->rnum[h] = 0;
+		tb->rbytes = -1;
+		return 0;
 	}
-	
-	/* item is of indirect type */
-	if (vn->vn_vi[i].vi_type & VI_TYPE_INDIRECT)
-	    /* an unformatted node pointer (having size long) is a solid
-               granule of the item */
-	    tb->rbytes = bytes = cur_free - cur_free % UNFM_P_SIZE;
-	
-	/* item is of directory type */
-	if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECTORY) {
-	    int j;
-	    struct virtual_item * vi;
-	    
-	    tb->rbytes = 0;
-	    bytes = 0;
-	    vi = &vn->vn_vi[i];
-	  
-	    for (j = vi->vi_entry_count - 1; j >= 0; j --) {
-		if (vi->vi_entry_sizes[j] > cur_free)
-		    /* j-th entry doesn't fit into L[0] */
-		    break;
-	      
-		bytes += vi->vi_entry_sizes[j];
-		cur_free -= vi->vi_entry_sizes[j];
-		tb->rbytes ++;
-	    }
-	    
-	    /* ".." can not be cut from first directory item */
-	    if ((vn->vn_vi[i].vi_type & VI_TYPE_FIRST_DIRECTORY_ITEM) && tb->rbytes > vi->vi_entry_count - 2)
-		tb->rbytes = vi->vi_entry_count - 2;
+
+	if ((unsigned int)cur_free >=
+	    (vn->vn_size -
+	     ((vn->vn_vi[vn->vn_nr_item - 1].
+	       vi_type & VI_TYPE_RIGHT_MERGEABLE) ? IH_SIZE : 0))) {
+		/* all contents of S[0] fits into R[0] */
+		tb->rnum[h] = vn->vn_nr_item;
+		tb->rbytes = -1;
+		return -1;
 	}
-	
-	if ( tb->rbytes <= 0 ) {
-	    /* nothing can flow from the item */
-	    tb->rbytes = -1;
-	    return -1;
+
+	d_size = 0, ih_size = IH_SIZE;
+
+	/* last item may be merge with first item in right neighbor */
+	if (vn->vn_vi[vn->vn_nr_item - 1].vi_type & VI_TYPE_RIGHT_MERGEABLE)
+		d_size = -(int)IH_SIZE, ih_size = 0;
+
+	tb->rnum[0] = 0;
+	for (i = vn->vn_nr_item - 1; i >= 0; i--, d_size = 0, ih_size = IH_SIZE) {
+		d_size += vn->vn_vi[i].vi_item_len;
+		if (cur_free >= d_size) {
+			/* the item can be shifted entirely */
+			cur_free -= d_size;
+			tb->rnum[0]++;
+			continue;
+		}
+
+		/* the item cannot be shifted entirely, try to split it */
+		if (vn->vn_vi[i].vi_type & VI_TYPE_STAT_DATA
+		    || vn->vn_vi[i].vi_type & VI_TYPE_INSERTED_DIRECTORY_ITEM) {
+			/* virtual item is a stat_data or empty directory body ("." and
+			   "..), that is not split able */
+			tb->rbytes = -1;
+			return -1;
+		}
+
+		/* check whether R[0] can hold ih and at least one byte of the item
+		   body */
+		if (cur_free <= ih_size) {
+			/* cannot shift even a part of the current item */
+			tb->rbytes = -1;
+			return -1;
+		}
+
+		/* R[0] can hold the header of the item and at least one byte of its
+		   body */
+		cur_free -= ih_size;	/* cur_free is still > 0 */
+
+		/* item is of direct type */
+		if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECT) {
+			/* body of a direct item can be split by 8 bytes */
+			int align = vn->vn_vi[i].vi_item_len % 8;
+//          reiserfs_warning(stderr,"\nbalancing: cur_free (%d) ", cur_free);
+			tb->rbytes = bytes =
+			    (cur_free >=
+			     align) ? (align +
+				       ((cur_free - align) / 8 * 8)) : 0;
+//          reiserfs_warning(stderr, "offset (0x%Lx) len (%d), move right (%d), get offset (0x%Lx)",
+//              vn->vn_vi[i].vi_item_offset, vn->vn_vi[i].vi_item_len, bytes,
+//              vn->vn_vi[i].vi_item_offset + vn->vn_vi[i].vi_item_len - bytes);
+		}
+
+		/* item is of indirect type */
+		if (vn->vn_vi[i].vi_type & VI_TYPE_INDIRECT)
+			/* an unformatted node pointer (having size long) is a solid
+			   granule of the item */
+			tb->rbytes = bytes = cur_free - cur_free % UNFM_P_SIZE;
+
+		/* item is of directory type */
+		if (vn->vn_vi[i].vi_type & VI_TYPE_DIRECTORY) {
+			int j;
+			struct virtual_item *vi;
+
+			tb->rbytes = 0;
+			bytes = 0;
+			vi = &vn->vn_vi[i];
+
+			for (j = vi->vi_entry_count - 1; j >= 0; j--) {
+				if (vi->vi_entry_sizes[j] > cur_free)
+					/* j-th entry doesn't fit into L[0] */
+					break;
+
+				bytes += vi->vi_entry_sizes[j];
+				cur_free -= vi->vi_entry_sizes[j];
+				tb->rbytes++;
+			}
+
+			/* ".." can not be cut from first directory item */
+			if ((vn->vn_vi[i].
+			     vi_type & VI_TYPE_FIRST_DIRECTORY_ITEM)
+			    && tb->rbytes > vi->vi_entry_count - 2)
+				tb->rbytes = vi->vi_entry_count - 2;
+		}
+
+		if (tb->rbytes <= 0) {
+			/* nothing can flow from the item */
+			tb->rbytes = -1;
+			return -1;
+		}
+
+		/* something can flow from the item */
+		tb->rnum[0]++;
+		return bytes;	/* part of split item in bytes */
 	}
-	
-	
-	/* something can flow from the item */
-	tb->rnum[0] ++;
-	return bytes;	/* part of split item in bytes */
-    }
-    
-    reiserfs_panic ("vs-8095: check_right: all items fit in the left neighbor");
-    return 0;
-}
 
+	reiserfs_panic
+	    ("vs-8095: check_right: all items fit in the left neighbor");
+	return 0;
+}
 
 /* sum of entry sizes between from-th and to-th entries including both edges */
-static int directory_part_size (struct virtual_item * vi, int from, int to)
+static int directory_part_size(struct virtual_item *vi, int from, int to)
 {
-    int i, retval;
-    
-    retval = 0;
-    for (i = from; i <= to; i ++)
-	retval += vi->vi_entry_sizes[i];
-    
-    return retval;
-}
+	int i, retval;
 
+	retval = 0;
+	for (i = from; i <= to; i++)
+		retval += vi->vi_entry_sizes[i];
+
+	return retval;
+}
 
 /*
  * from - number of items, which are shifted to left neighbor entirely
@@ -518,255 +542,278 @@ static int directory_part_size (struct virtual_item * vi, int from, int to)
  * to_bytes - number of bytes of boundary item (or directory entries) which
  * are shifted to right neighbor */
 
-static int get_num_ver (int mode, struct tree_balance * tb, int h,
-			int from, int from_bytes,
-			int to,   int to_bytes,
-			short * snum012, int flow
-			)
+static int get_num_ver(int mode, struct tree_balance *tb, int h,
+		       int from, int from_bytes,
+		       int to, int to_bytes, short *snum012, int flow)
 {
-    int i;
-    int bytes;
-    struct virtual_node * vn = tb->tb_vn;
-    struct virtual_item * vi;
-    
-    int total_node_size, max_node_size, current_item_size;
-    int needed_nodes;
-    int start_item, 	/* position of item we start filling node from */
-	end_item,	/* position of item we finish filling node by */
-	start_bytes,/* number of first bytes (entries for directory) of start_item-th item 
-		       we do not include into node that is being filled */
-	end_bytes;	/* number of last bytes (entries for directory) of end_item-th item 
-			   we do node include into node that is being filled */
-    int splitted_item_positions[2];	/* these are positions in virtual item of items, 
+	int i;
+	int bytes;
+	struct virtual_node *vn = tb->tb_vn;
+	struct virtual_item *vi;
+
+	int total_node_size, max_node_size, current_item_size;
+	int needed_nodes;
+	int start_item,		/* position of item we start filling node from */
+	 end_item,		/* position of item we finish filling node by */
+	 start_bytes,		/* number of first bytes (entries for directory) of start_item-th item 
+				   we do not include into node that is being filled */
+	 end_bytes;		/* number of last bytes (entries for directory) of end_item-th item 
+				   we do node include into node that is being filled */
+	int splitted_item_positions[2];	/* these are positions in virtual item of items, 
 					   that are splitted between S[0] and S1new and S1new and S2new */
 
-    max_node_size = MAX_CHILD_SIZE (tb->tb_fs->fs_blocksize);
-    
-    /* snum012 [0-2] - number of items, that lay to S[0], first new node and
-       second new node */
-    snum012[3] = -1;	/* s1bytes */
-    snum012[4] = -1;	/* s2bytes */
-    
-
-    /* internal level */
-    if (h > 0) {
-	i = ((to - from) * (KEY_SIZE + DC_SIZE) + DC_SIZE);
-	if (i == max_node_size)
-	    return 1;
-	return (i / max_node_size + 1);
-    }
-    
-
-    /* leaf level */
-    needed_nodes = 1;
-    total_node_size = 0;
-    
-    start_item = from;
-    start_bytes = from_bytes;
-    end_item = vn->vn_nr_item - to - 1;
-    end_bytes = to_bytes;
-    
-    /* go through all items begining from the start_item-th item and ending by
-       the end_item-th item. If start_bytes != -1 we skip first start_bytes
-       item units (entries in case of directory). If end_bytes != -1 we skip
-       end_bytes units of the end_item-th item. */
-    for (i = start_item; i <= end_item; i ++) {
-	/* get size of current item */
-	current_item_size = (vi = &vn->vn_vi[i])->vi_item_len;
-	
-	/* do not take in calculation head part (from_bytes) of from-th item */
-	if (i == start_item && start_bytes != -1) {
-	    if (vi->vi_type & VI_TYPE_DIRECTORY)
-		current_item_size -= directory_part_size (vi, 0, start_bytes - 1);
-	    else
-		current_item_size -= start_bytes;
-	}
-	
-	/* do not take in calculation tail part of (to-1)-th item */
-	if (i == end_item && end_bytes != -1) {
-	    if (vi->vi_type & VI_TYPE_DIRECTORY)
-		/* first entry, that is not included */
-		current_item_size -= directory_part_size (vi, vi->vi_entry_count - end_bytes, vi->vi_entry_count - 1);
-	    else
-		current_item_size -= end_bytes;
-	}
-	
-	/* if item fits into current node entirely */
-	if (total_node_size + current_item_size <= max_node_size) {
-	    snum012[needed_nodes - 1] ++;
-	    total_node_size += current_item_size;
-	    continue;
-	}
-	
-	if (current_item_size > max_node_size)
-	    /* virtual item length is longer, than max size of item in a
-               node. It is impossible for direct item */
-	    /* we will try to split it */
-	    flow = 1;
-	
-	
-	if (!flow) {
-	    /* as we do not split items, take new node and continue */
-	    needed_nodes ++; i --; total_node_size = 0;
-	    continue;
-	}
-	
-	if (total_node_size + (int)IH_SIZE >= max_node_size) {
-	    /* even minimal item does not fit into current node, take new node
-               and continue */
-	    needed_nodes ++, i--, total_node_size = 0;
-	    continue;
-	}
-	if (vi->vi_type & VI_TYPE_STAT_DATA) {
-	    /* stat data can not be split */
-	    needed_nodes ++, i--, total_node_size = 0;
-	    continue;
-	}
-	
-	/*bytes is free space in filled node*/
-	bytes = max_node_size - total_node_size - IH_SIZE;
-	
-	if (vi->vi_type & VI_TYPE_DIRECT) {
-	    /* body of a direct item can be split by 8 bytes. */
-	    int align = 8 - (vn->vn_vi[i].vi_item_offset - 1) % 8;
-//	    reiserfs_warning(stderr,"\nbalancing: cur_free (%d) ", bytes);
-//	    reiserfs_warning(stderr,"offset (0x%Lx), move (%d), get offset (0x%Lx)",
-//	    	vn->vn_vi[i].vi_item_offset, (bytes - align) / 8 * 8,
-//	    	vn->vn_vi[i].vi_item_offset + ((bytes - align) / 8 * 8));
-	    bytes = (bytes >= align) ? (align + ((bytes - align) / 8 * 8)) : 0;
+	max_node_size = MAX_CHILD_SIZE(tb->tb_fs->fs_blocksize);
+
+	/* snum012 [0-2] - number of items, that lay to S[0], first new node and
+	   second new node */
+	snum012[3] = -1;	/* s1bytes */
+	snum012[4] = -1;	/* s2bytes */
+
+	/* internal level */
+	if (h > 0) {
+		i = ((to - from) * (KEY_SIZE + DC_SIZE) + DC_SIZE);
+		if (i == max_node_size)
+			return 1;
+		return (i / max_node_size + 1);
 	}
 
+	/* leaf level */
+	needed_nodes = 1;
+	total_node_size = 0;
+
+	start_item = from;
+	start_bytes = from_bytes;
+	end_item = vn->vn_nr_item - to - 1;
+	end_bytes = to_bytes;
+
+	/* go through all items begining from the start_item-th item and ending by
+	   the end_item-th item. If start_bytes != -1 we skip first start_bytes
+	   item units (entries in case of directory). If end_bytes != -1 we skip
+	   end_bytes units of the end_item-th item. */
+	for (i = start_item; i <= end_item; i++) {
+		/* get size of current item */
+		current_item_size = (vi = &vn->vn_vi[i])->vi_item_len;
+
+		/* do not take in calculation head part (from_bytes) of from-th item */
+		if (i == start_item && start_bytes != -1) {
+			if (vi->vi_type & VI_TYPE_DIRECTORY)
+				current_item_size -=
+				    directory_part_size(vi, 0, start_bytes - 1);
+			else
+				current_item_size -= start_bytes;
+		}
+
+		/* do not take in calculation tail part of (to-1)-th item */
+		if (i == end_item && end_bytes != -1) {
+			if (vi->vi_type & VI_TYPE_DIRECTORY)
+				/* first entry, that is not included */
+				current_item_size -=
+				    directory_part_size(vi,
+							vi->vi_entry_count -
+							end_bytes,
+							vi->vi_entry_count - 1);
+			else
+				current_item_size -= end_bytes;
+		}
+
+		/* if item fits into current node entirely */
+		if (total_node_size + current_item_size <= max_node_size) {
+			snum012[needed_nodes - 1]++;
+			total_node_size += current_item_size;
+			continue;
+		}
+
+		if (current_item_size > max_node_size)
+			/* virtual item length is longer, than max size of item in a
+			   node. It is impossible for direct item */
+			/* we will try to split it */
+			flow = 1;
+
+		if (!flow) {
+			/* as we do not split items, take new node and continue */
+			needed_nodes++;
+			i--;
+			total_node_size = 0;
+			continue;
+		}
+
+		if (total_node_size + (int)IH_SIZE >= max_node_size) {
+			/* even minimal item does not fit into current node, take new node
+			   and continue */
+			needed_nodes++, i--, total_node_size = 0;
+			continue;
+		}
+		if (vi->vi_type & VI_TYPE_STAT_DATA) {
+			/* stat data can not be split */
+			needed_nodes++, i--, total_node_size = 0;
+			continue;
+		}
+
+		/*bytes is free space in filled node */
+		bytes = max_node_size - total_node_size - IH_SIZE;
+
+		if (vi->vi_type & VI_TYPE_DIRECT) {
+			/* body of a direct item can be split by 8 bytes. */
+			int align = 8 - (vn->vn_vi[i].vi_item_offset - 1) % 8;
+//          reiserfs_warning(stderr,"\nbalancing: cur_free (%d) ", bytes);
+//          reiserfs_warning(stderr,"offset (0x%Lx), move (%d), get offset (0x%Lx)",
+//              vn->vn_vi[i].vi_item_offset, (bytes - align) / 8 * 8,
+//              vn->vn_vi[i].vi_item_offset + ((bytes - align) / 8 * 8));
+			bytes =
+			    (bytes >=
+			     align) ? (align + ((bytes - align) / 8 * 8)) : 0;
+		}
+
+		/* item is of indirect type */
+		if (vi->vi_type & VI_TYPE_INDIRECT)
+			/* an unformatted node pointer (having size long) is a solid
+			   granule of the item. bytes of unformatted node pointers fits
+			   into free space of filled node */
+			bytes -= (bytes) % UNFM_P_SIZE;
+
+		/* S1bytes or S2bytes. It depends from needed_nodes */
+		snum012[needed_nodes - 1 + 3] = bytes;
+
+		/* item is of directory type */
+		if (vi->vi_type & VI_TYPE_DIRECTORY) {
+			/* calculate, how many entries can be put into current node */
+			int j;
+			int end_entry;
+
+			snum012[needed_nodes - 1 + 3] = 0;
+
+			total_node_size += IH_SIZE;
+			if (start_bytes == -1 || i != start_item)
+				start_bytes = 0;
+
+			end_entry =
+			    vi->vi_entry_count -
+			    ((i == end_item
+			      && end_bytes != -1) ? end_bytes : 0);
+			for (j = start_bytes; j < end_entry; j++) {
+				/* j-th entry doesn't fit into current node */
+				if (total_node_size + vi->vi_entry_sizes[j] >
+				    max_node_size)
+					break;
+				snum012[needed_nodes - 1 + 3]++;
+				bytes += vi->vi_entry_sizes[j];
+				total_node_size += vi->vi_entry_sizes[j];
+			}
+			/* "." can not be cut from first directory item */
+			if (start_bytes == 0
+			    && (vn->vn_vi[i].
+				vi_type & VI_TYPE_FIRST_DIRECTORY_ITEM)
+			    && snum012[needed_nodes - 1 + 3] < 2)
+				snum012[needed_nodes - 1 + 3] = 0;
+		}
+
+		if (snum012[needed_nodes - 1 + 3] <= 0) {
+			/* nothing fits into current node, take new node and continue */
+			needed_nodes++, i--, total_node_size = 0;
+			continue;
+		}
+
+		/* something fits into the current node */
+		if (vi->vi_type & VI_TYPE_DIRECTORY)
+			start_bytes += snum012[needed_nodes - 1 + 3];
+		else
+			start_bytes = bytes;
+
+		snum012[needed_nodes - 1]++;
+		splitted_item_positions[needed_nodes - 1] = i;
 
-	/* item is of indirect type */
-	if (vi->vi_type & VI_TYPE_INDIRECT)
-	    /* an unformatted node pointer (having size long) is a solid
-	       granule of the item. bytes of unformatted node pointers fits
-	       into free space of filled node */
-	    bytes -= (bytes) % UNFM_P_SIZE;
-	
-	/* S1bytes or S2bytes. It depends from needed_nodes */
-	snum012[needed_nodes - 1 + 3] = bytes;
-	
-	/* item is of directory type */
-	if (vi->vi_type & VI_TYPE_DIRECTORY) {
-	    /* calculate, how many entries can be put into current node */
-	    int j;
-	    int end_entry;
-	    
-	    snum012[needed_nodes - 1 + 3] = 0;
-
-	    total_node_size += IH_SIZE;
-	    if (start_bytes == -1 || i != start_item)
-		start_bytes = 0;
-	    
-	    end_entry = vi->vi_entry_count - ((i == end_item && end_bytes != -1) ? end_bytes : 0);
-	    for (j = start_bytes; j < end_entry; j ++) {
-		/* j-th entry doesn't fit into current node */
-		if (total_node_size + vi->vi_entry_sizes[j] > max_node_size)
-		    break;
-		snum012[needed_nodes - 1 + 3] ++;
-		bytes += vi->vi_entry_sizes[j];
-		total_node_size += vi->vi_entry_sizes[j];
-	    }
-	    /* "." can not be cut from first directory item */
-	    if (start_bytes == 0 && (vn->vn_vi[i].vi_type & VI_TYPE_FIRST_DIRECTORY_ITEM) && 
-		snum012[needed_nodes - 1 + 3] < 2)
-		snum012[needed_nodes - 1 + 3] = 0;
+		needed_nodes++;
+		/* continue from the same item with start_bytes != -1 */
+		start_item = i;
+		i--;
+		total_node_size = 0;
 	}
-	
-	if (snum012[needed_nodes-1+3] <= 0 ) {
-	    /* nothing fits into current node, take new node and continue */
-	    needed_nodes ++, i--, total_node_size = 0;
-	    continue;
+
+	/* snum012[3] and snum012[4] contain how many bytes (entries) of split
+	   item can be in S[0] and S1new. s1bytes and s2bytes are how many bytes
+	   (entries) can be in S1new and S2new. Recalculate it */
+
+	if (snum012[4] > 0) {	/* s2bytes */
+		/* get number of item that is split between S1new and S2new */
+		int split_item_num;
+		int bytes_to_r, bytes_to_l;
+
+		split_item_num = splitted_item_positions[1];
+		bytes_to_l =
+		    ((from == split_item_num
+		      && from_bytes != -1) ? from_bytes : 0);
+		bytes_to_r =
+		    ((end_item == split_item_num
+		      && end_bytes != -1) ? end_bytes : 0);
+		if (vn->vn_vi[split_item_num].vi_type & VI_TYPE_DIRECTORY) {
+			int entries_to_S2new;
+
+			/* calculate number of entries fit into S2new */
+			entries_to_S2new =
+			    vn->vn_vi[split_item_num].vi_entry_count -
+			    snum012[4] - bytes_to_r - bytes_to_l;
+			if (snum012[3] != -1 && snum012[1] == 1) {
+				/* directory split into 3 nodes */
+				int entries_to_S1new;
+
+				entries_to_S2new -= snum012[3];
+				entries_to_S1new = snum012[4];
+				snum012[3] = entries_to_S1new;
+				snum012[4] = entries_to_S2new;
+				return needed_nodes;
+			}
+			snum012[4] = entries_to_S2new;
+		} else {
+			/* item is not of directory type */
+			int bytes_to_S2new;
+
+			bytes_to_S2new =
+			    vn->vn_vi[split_item_num].vi_item_len - IH_SIZE -
+			    snum012[4] - bytes_to_r - bytes_to_l;
+			snum012[4] = bytes_to_S2new;
+		}
 	}
-	
-	/* something fits into the current node */
-	if (vi->vi_type & VI_TYPE_DIRECTORY)
-	    start_bytes += snum012[needed_nodes - 1 + 3];
-	else
-	    start_bytes = bytes;
-	
-	snum012[needed_nodes - 1] ++;
-	splitted_item_positions[needed_nodes - 1] = i;
-
-	needed_nodes ++;
-	/* continue from the same item with start_bytes != -1 */
-	start_item = i;
-	i --;
-	total_node_size = 0;
-    }
-
-    
-    /* snum012[3] and snum012[4] contain how many bytes (entries) of split
-       item can be in S[0] and S1new. s1bytes and s2bytes are how many bytes
-       (entries) can be in S1new and S2new. Recalculate it */
-    
-    if (snum012[4] > 0) {	/* s2bytes */
-	/* get number of item that is split between S1new and S2new */
-	int split_item_num;
-	int bytes_to_r, bytes_to_l;
-    
-	split_item_num = splitted_item_positions[1];
-	bytes_to_l = ((from == split_item_num && from_bytes != -1) ? from_bytes : 0);
-	bytes_to_r = ((end_item == split_item_num && end_bytes != -1) ? end_bytes : 0);
-	if (vn->vn_vi[split_item_num].vi_type & VI_TYPE_DIRECTORY) {
-	    int entries_to_S2new;
-	    
-	    /* calculate number of entries fit into S2new */
-	    entries_to_S2new =  vn->vn_vi[split_item_num].vi_entry_count - snum012[4] - bytes_to_r - bytes_to_l;
-	    if (snum012[3] != -1 && snum012[1] == 1) {
-		/* directory split into 3 nodes */
-		int entries_to_S1new;
-		
-		entries_to_S2new -= snum012[3];
-		entries_to_S1new = snum012[4];
-		snum012[3] = entries_to_S1new;
-		snum012[4] = entries_to_S2new;
-		return needed_nodes;
-	    }
-	    snum012[4] = entries_to_S2new;
-	} else {
-	    /* item is not of directory type */
-	    int bytes_to_S2new;
-	    
-	    bytes_to_S2new = vn->vn_vi[split_item_num].vi_item_len - IH_SIZE - snum012[4] - bytes_to_r - bytes_to_l;
-	    snum012[4] = bytes_to_S2new;
+
+	/* now we know S2bytes, calculate S1bytes */
+	if (snum012[3] > 0) {	/* s1bytes */
+		/* get number of item that is split between S0 and S1new */
+		int split_item_num;
+		int bytes_to_r, bytes_to_l;
+
+		split_item_num = splitted_item_positions[0];
+		bytes_to_l =
+		    ((from == split_item_num
+		      && from_bytes != -1) ? from_bytes : 0);
+		bytes_to_r =
+		    ((end_item == split_item_num
+		      && end_bytes != -1) ? end_bytes : 0);
+		if (vn->vn_vi[split_item_num].vi_type & VI_TYPE_DIRECTORY) {
+			/* entries, who go to S1new node */
+			snum012[3] =
+			    vn->vn_vi[split_item_num].vi_entry_count -
+			    snum012[3] - bytes_to_r - bytes_to_l;
+		} else
+			/* bytes, who go to S1new node (not including HI_SIZE) */
+			snum012[3] =
+			    vn->vn_vi[split_item_num].vi_item_len - IH_SIZE -
+			    snum012[3] - bytes_to_r - bytes_to_l;
 	}
-    }
-    
-    /* now we know S2bytes, calculate S1bytes */
-    if (snum012[3] > 0) {	/* s1bytes */
-	/* get number of item that is split between S0 and S1new */
-	int split_item_num;
-	int bytes_to_r, bytes_to_l;
-	
-	split_item_num = splitted_item_positions[0];
-	bytes_to_l = ((from == split_item_num && from_bytes != -1) ? from_bytes : 0);
-	bytes_to_r = ((end_item == split_item_num && end_bytes != -1) ? end_bytes : 0);
-	if (vn->vn_vi[split_item_num].vi_type & VI_TYPE_DIRECTORY) {
-	    /* entries, who go to S1new node */
-	    snum012[3] =  vn->vn_vi[split_item_num].vi_entry_count - snum012[3] - bytes_to_r - bytes_to_l;
-	} else
-	    /* bytes, who go to S1new node (not including HI_SIZE) */
-	    snum012[3] = vn->vn_vi[split_item_num].vi_item_len - IH_SIZE - snum012[3] - bytes_to_r - bytes_to_l;
-    }
-    
-    return needed_nodes;
+
+	return needed_nodes;
 }
 
 /* size of item_num-th item in bytes when regular and in entries when item is
    directory */
-static int item_length (struct tree_balance * tb, int item_num)
+static int item_length(struct tree_balance *tb, int item_num)
 {
-    struct virtual_node * vn = tb->tb_vn;
+	struct virtual_node *vn = tb->tb_vn;
 
-    if (vn->vn_vi[item_num].vi_type & VI_TYPE_DIRECTORY)
-	return vn->vn_vi[item_num].vi_entry_count;
+	if (vn->vn_vi[item_num].vi_type & VI_TYPE_DIRECTORY)
+		return vn->vn_vi[item_num].vi_entry_count;
 
-    return vn->vn_vi[item_num].vi_item_len - IH_SIZE;
+	return vn->vn_vi[item_num].vi_item_len - IH_SIZE;
 }
 
-
 /* Set parameters for balancing.
  * Performs write of results of analysis of balancing into structure tb,
  * where it will later be used by the functions that actually do the balancing. 
@@ -784,257 +831,275 @@ static int item_length (struct tree_balance * tb, int item_num)
  *	s1bytes	number of bytes which flow to the first  new node when S[0] splits (this number is contained in s012 array)
  */
 
-static void set_parameters (struct tree_balance * tb, int h, int lnum,
-			    int rnum, int blk_num, short * s012, int lb, int rb)
+static void set_parameters(struct tree_balance *tb, int h, int lnum,
+			   int rnum, int blk_num, short *s012, int lb, int rb)
 {
 
-    tb->lnum[h] = lnum;
-    tb->rnum[h] = rnum;
-    tb->blknum[h] = blk_num;
+	tb->lnum[h] = lnum;
+	tb->rnum[h] = rnum;
+	tb->blknum[h] = blk_num;
 
-    if (h == 0)
-    {  /* only for leaf level */
-	if (s012 != NULL)
-	{
-	    tb->s0num = * s012 ++,
-		tb->s1num = * s012 ++,
-		tb->s2num = * s012 ++;
-	    tb->s1bytes = * s012 ++;
-	    tb->s2bytes = * s012;
+	if (h == 0) {		/* only for leaf level */
+		if (s012 != NULL) {
+			tb->s0num = *s012++,
+			    tb->s1num = *s012++, tb->s2num = *s012++;
+			tb->s1bytes = *s012++;
+			tb->s2bytes = *s012;
+		}
+		tb->lbytes = lb;
+		tb->rbytes = rb;
 	}
-	tb->lbytes = lb;
-	tb->rbytes = rb;
-    }
 }
 
-static void decrement_key (struct reiserfs_key *p_s_key) 
+static void decrement_key(struct reiserfs_key *p_s_key)
 {
-    int type;
-
-    type = get_type (p_s_key);
-    switch (type) {
-    case TYPE_STAT_DATA:
-	set_key_objectid (p_s_key, get_key_objectid (p_s_key) - 1);
-	set_type_and_offset (key_format (p_s_key), p_s_key,
-			     (loff_t)MAX_FILE_SIZE_V2, TYPE_INDIRECT);
-	return;
-
-    case TYPE_INDIRECT:
-    case TYPE_DIRECT:
-    case TYPE_DIRENTRY:
-	set_offset (key_format (p_s_key), p_s_key, get_offset (p_s_key) - 1);
-	if (get_offset (p_s_key) == 0)
-	    set_type (key_format (p_s_key), p_s_key, TYPE_STAT_DATA);
-	return;
-    }
-    reiserfs_warning (stderr, "vs-8125: decrement_key: item of wrong type found %k",
-		      p_s_key);
-}
+	int type;
+
+	type = get_type(p_s_key);
+	switch (type) {
+	case TYPE_STAT_DATA:
+		set_key_objectid(p_s_key, get_key_objectid(p_s_key) - 1);
+		set_type_and_offset(key_format(p_s_key), p_s_key,
+				    (loff_t) MAX_FILE_SIZE_V2, TYPE_INDIRECT);
+		return;
 
+	case TYPE_INDIRECT:
+	case TYPE_DIRECT:
+	case TYPE_DIRENTRY:
+		set_offset(key_format(p_s_key), p_s_key,
+			   get_offset(p_s_key) - 1);
+		if (get_offset(p_s_key) == 0)
+			set_type(key_format(p_s_key), p_s_key, TYPE_STAT_DATA);
+		return;
+	}
+	reiserfs_warning(stderr,
+			 "vs-8125: decrement_key: item of wrong type found %k",
+			 p_s_key);
+}
 
-int are_items_mergeable (struct item_head * left, struct item_head * right, int bsize)
+int are_items_mergeable(struct item_head *left, struct item_head *right,
+			int bsize)
 {
-    if (comp_keys (&left->ih_key, &right->ih_key) != -1) {
-	reiserfs_panic ("vs-16070: are_items_mergeable: left %k, right %k", &(left->ih_key), &(right->ih_key));
-    }
+	if (comp_keys(&left->ih_key, &right->ih_key) != -1) {
+		reiserfs_panic
+		    ("vs-16070: are_items_mergeable: left %k, right %k",
+		     &(left->ih_key), &(right->ih_key));
+	}
 
-    if (not_of_one_file (&left->ih_key, &right->ih_key))
-	return 0;
+	if (not_of_one_file(&left->ih_key, &right->ih_key))
+		return 0;
 
-    if (I_IS_DIRECTORY_ITEM (left)) {
-	return 1;
-    }
+	if (I_IS_DIRECTORY_ITEM(left)) {
+		return 1;
+	}
 
-    if ((I_IS_DIRECT_ITEM (left) && I_IS_DIRECT_ITEM (right)) || 
-	(I_IS_INDIRECT_ITEM (left) && I_IS_INDIRECT_ITEM (right)))
-	return (get_offset (&left->ih_key) + get_bytes_number (left, bsize) == get_offset (&right->ih_key)) ? 1 : 0;
+	if ((I_IS_DIRECT_ITEM(left) && I_IS_DIRECT_ITEM(right)) ||
+	    (I_IS_INDIRECT_ITEM(left) && I_IS_INDIRECT_ITEM(right)))
+		return (get_offset(&left->ih_key) +
+			get_bytes_number(left,
+					 bsize) ==
+			get_offset(&right->ih_key)) ? 1 : 0;
 
-    return 0;
+	return 0;
 }
 
 /* get left neighbor of the leaf node */
-static struct buffer_head * get_left_neighbor (reiserfs_filsys_t * s, struct reiserfs_path *path)
+static struct buffer_head *get_left_neighbor(reiserfs_filsys_t *s,
+					     struct reiserfs_path *path)
 {
-    struct reiserfs_key key;
-    struct reiserfs_path path_to_left_neighbor;
-    struct buffer_head * bh;
-
-    copy_key (&key, B_N_PKEY (PATH_PLAST_BUFFER (path), 0));
-    decrement_key (&key);
-
-    init_path (&path_to_left_neighbor);
-    search_by_key (s, &key, &path_to_left_neighbor, DISK_LEAF_NODE_LEVEL);
-    if (PATH_LAST_POSITION (&path_to_left_neighbor) == 0) {
-	pathrelse (&path_to_left_neighbor);
-	return 0;
-    }
-    bh = PATH_PLAST_BUFFER (&path_to_left_neighbor);
-    bh->b_count ++;
-    pathrelse (&path_to_left_neighbor);
-    return bh;
+	struct reiserfs_key key;
+	struct reiserfs_path path_to_left_neighbor;
+	struct buffer_head *bh;
+
+	copy_key(&key, B_N_PKEY(PATH_PLAST_BUFFER(path), 0));
+	decrement_key(&key);
+
+	init_path(&path_to_left_neighbor);
+	search_by_key(s, &key, &path_to_left_neighbor, DISK_LEAF_NODE_LEVEL);
+	if (PATH_LAST_POSITION(&path_to_left_neighbor) == 0) {
+		pathrelse(&path_to_left_neighbor);
+		return 0;
+	}
+	bh = PATH_PLAST_BUFFER(&path_to_left_neighbor);
+	bh->b_count++;
+	pathrelse(&path_to_left_neighbor);
+	return bh;
 }
 
-
-extern struct reiserfs_key  MIN_KEY;
-static struct buffer_head * get_right_neighbor (reiserfs_filsys_t * s, struct reiserfs_path *path)
+extern struct reiserfs_key MIN_KEY;
+static struct buffer_head *get_right_neighbor(reiserfs_filsys_t *s,
+					      struct reiserfs_path *path)
 {
-    struct reiserfs_key key;
-    struct reiserfs_key *rkey;
-    struct reiserfs_path path_to_right_neighbor;
-    struct buffer_head * bh;
-    
-    rkey = get_rkey (path, s);
-    if (comp_keys (rkey, &MIN_KEY) == 0)
-	reiserfs_panic ("vs-16080: get_right_neighbor: get_rkey returned min key (path has changed)");
-    copy_key (&key, rkey);
-    
-  
-    init_path (&path_to_right_neighbor);
-    search_by_key (s, &key, &path_to_right_neighbor, DISK_LEAF_NODE_LEVEL);
-    if (PATH_PLAST_BUFFER (&path_to_right_neighbor) == PATH_PLAST_BUFFER (path)) {
-	pathrelse (&path_to_right_neighbor);
-	return 0;
-    }
-    bh = PATH_PLAST_BUFFER (&path_to_right_neighbor);
-    bh->b_count ++;
-    pathrelse (&path_to_right_neighbor);
-    return bh;
+	struct reiserfs_key key;
+	struct reiserfs_key *rkey;
+	struct reiserfs_path path_to_right_neighbor;
+	struct buffer_head *bh;
+
+	rkey = get_rkey(path, s);
+	if (comp_keys(rkey, &MIN_KEY) == 0)
+		reiserfs_panic
+		    ("vs-16080: get_right_neighbor: get_rkey returned min key (path has changed)");
+	copy_key(&key, rkey);
+
+	init_path(&path_to_right_neighbor);
+	search_by_key(s, &key, &path_to_right_neighbor, DISK_LEAF_NODE_LEVEL);
+	if (PATH_PLAST_BUFFER(&path_to_right_neighbor) ==
+	    PATH_PLAST_BUFFER(path)) {
+		pathrelse(&path_to_right_neighbor);
+		return 0;
+	}
+	bh = PATH_PLAST_BUFFER(&path_to_right_neighbor);
+	bh->b_count++;
+	pathrelse(&path_to_right_neighbor);
+	return bh;
 }
 
-
-int is_left_mergeable (reiserfs_filsys_t * s, struct reiserfs_path *path)
+int is_left_mergeable(reiserfs_filsys_t *s, struct reiserfs_path *path)
 {
-    struct item_head * right;
-    struct buffer_head * bh;
-    int retval;
-    
-    right = B_N_PITEM_HEAD (PATH_PLAST_BUFFER (path), 0);
-    
-    bh = get_left_neighbor (s, path);
-    if (bh == 0) {
-	return 0;
-    }
-    retval = are_items_mergeable (B_N_PITEM_HEAD (bh, B_NR_ITEMS (bh) - 1), right, bh->b_size);
-    brelse (bh);
-    return retval;
-}
+	struct item_head *right;
+	struct buffer_head *bh;
+	int retval;
 
+	right = B_N_PITEM_HEAD(PATH_PLAST_BUFFER(path), 0);
 
-int is_right_mergeable (reiserfs_filsys_t * s, struct reiserfs_path *path)
-{
-    struct item_head * left;
-    struct buffer_head * bh;
-    int retval;
-    
-    left = B_N_PITEM_HEAD (PATH_PLAST_BUFFER (path), B_NR_ITEMS (PATH_PLAST_BUFFER (path)) - 1);
-    
-    bh = get_right_neighbor (s, path);
-    if (bh == 0) {
-	return 0;
-    }
-    retval = are_items_mergeable (left, B_N_PITEM_HEAD (bh, 0), bh->b_size);
-    brelse (bh);
-    return retval;
+	bh = get_left_neighbor(s, path);
+	if (bh == 0) {
+		return 0;
+	}
+	retval =
+	    are_items_mergeable(B_N_PITEM_HEAD(bh, B_NR_ITEMS(bh) - 1), right,
+				bh->b_size);
+	brelse(bh);
+	return retval;
 }
 
+int is_right_mergeable(reiserfs_filsys_t *s, struct reiserfs_path *path)
+{
+	struct item_head *left;
+	struct buffer_head *bh;
+	int retval;
 
+	left =
+	    B_N_PITEM_HEAD(PATH_PLAST_BUFFER(path),
+			   B_NR_ITEMS(PATH_PLAST_BUFFER(path)) - 1);
+
+	bh = get_right_neighbor(s, path);
+	if (bh == 0) {
+		return 0;
+	}
+	retval = are_items_mergeable(left, B_N_PITEM_HEAD(bh, 0), bh->b_size);
+	brelse(bh);
+	return retval;
+}
 
 /* check, does node disappear if we shift tb->lnum[0] items to left neighbor
    and tb->rnum[0] to the right one. */
-static int is_leaf_removable (struct tree_balance * tb)
+static int is_leaf_removable(struct tree_balance *tb)
 {
-    struct virtual_node * vn = tb->tb_vn;
-    int to_left, to_right;
-    int size;
-    int remain_items;
-    
-    /* number of items, that will be shifted to left (right) neighbor entirely */
-    to_left = tb->lnum[0] - ((tb->lbytes != -1) ? 1 : 0);
-    to_right = tb->rnum[0] - ((tb->rbytes != -1) ? 1 : 0);
-    remain_items = vn->vn_nr_item;
-    
-    /* how many items remain in S[0] after shiftings to neighbors */
-    remain_items -= (to_left + to_right);
-    
-    if (remain_items < 1) {
-	/* all content of node can be shifted to neighbors */
-	set_parameters (tb, 0, to_left, vn->vn_nr_item - to_left, 0, NULL, -1, -1);    
-	return 1;
-    }
-    
-    if (remain_items > 1 || tb->lbytes == -1 || tb->rbytes == -1)
-	/* S[0] is not removable */
+	struct virtual_node *vn = tb->tb_vn;
+	int to_left, to_right;
+	int size;
+	int remain_items;
+
+	/* number of items, that will be shifted to left (right) neighbor entirely */
+	to_left = tb->lnum[0] - ((tb->lbytes != -1) ? 1 : 0);
+	to_right = tb->rnum[0] - ((tb->rbytes != -1) ? 1 : 0);
+	remain_items = vn->vn_nr_item;
+
+	/* how many items remain in S[0] after shiftings to neighbors */
+	remain_items -= (to_left + to_right);
+
+	if (remain_items < 1) {
+		/* all content of node can be shifted to neighbors */
+		set_parameters(tb, 0, to_left, vn->vn_nr_item - to_left, 0,
+			       NULL, -1, -1);
+		return 1;
+	}
+
+	if (remain_items > 1 || tb->lbytes == -1 || tb->rbytes == -1)
+		/* S[0] is not removable */
+		return 0;
+
+	/* check, whether we can divide 1 remaining item between neighbors */
+
+	/* get size of remaining item (in directory entry count if directory) */
+	size = item_length(tb, to_left);
+
+	if (tb->lbytes + tb->rbytes >= size) {
+		set_parameters(tb, 0, to_left + 1, to_right + 1, 0, NULL,
+			       tb->lbytes, -1);
+		return 1;
+	}
+
 	return 0;
-    
-    /* check, whether we can divide 1 remaining item between neighbors */
-    
-    /* get size of remaining item (in directory entry count if directory) */
-    size = item_length (tb, to_left);
-    
-    if (tb->lbytes + tb->rbytes >= size) {
-	set_parameters (tb, 0, to_left + 1, to_right + 1, 0, NULL, tb->lbytes, -1);
-	return 1;
-    }
-    
-    return 0;
 }
 
-
 /* check whether L, S, R can be joined in one node */
-static int are_leaves_removable (struct tree_balance * tb, int lfree, int rfree)
+static int are_leaves_removable(struct tree_balance *tb, int lfree, int rfree)
 {
-    struct virtual_node * vn = tb->tb_vn;
-    int ih_size;
-    struct buffer_head *S0;
+	struct virtual_node *vn = tb->tb_vn;
+	int ih_size;
+	struct buffer_head *S0;
 
-    S0 = PATH_H_PBUFFER (tb->tb_path, 0);
+	S0 = PATH_H_PBUFFER(tb->tb_path, 0);
 
-    ih_size = 0;
-    if (vn->vn_nr_item) {
-	if (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE)
-	    ih_size += IH_SIZE;
-    
-	if (vn->vn_vi[vn->vn_nr_item-1].vi_type & VI_TYPE_RIGHT_MERGEABLE)
-	    ih_size += IH_SIZE;
-    } else {
-	/* there was only one item and it will be deleted */
-	struct item_head * ih;
-    
-	ih = B_N_PITEM_HEAD (S0, 0);
-	if (tb->CFR[0] && !not_of_one_file (&(ih->ih_key), B_N_PDELIM_KEY (tb->CFR[0], tb->rkey[0])))
-	    if (I_IS_DIRECTORY_ITEM(ih)) {
-		/* we can delete any directory item in fsck (if it is unreachable) */
-		if (get_offset (&ih->ih_key) != DOT_OFFSET) {
-		    /* must get left neighbor here to make sure, that
-                       left neighbor is of the same directory */
-		    struct buffer_head * left;
-		    
-		    left = get_left_neighbor (tb->tb_fs, tb->tb_path);
-		    if (left) {
-			struct item_head * last;
-
-			if (B_NR_ITEMS (left) == 0)
-			    reiserfs_panic ("vs-8135: are_leaves_removable: "
-					    "empty node in the tree");
-			last = B_N_PITEM_HEAD (left, B_NR_ITEMS (left) - 1);
-			if (!comp_short_keys (&last->ih_key, &ih->ih_key))
-			    ih_size = IH_SIZE;
-			brelse (left);
-		    }
-		}
-	    }
-    
-    }
-
-    if ((int)MAX_CHILD_SIZE(S0->b_size) + vn->vn_size <= rfree + lfree + ih_size) {
-	set_parameters (tb, 0, -1, -1, -1, NULL, -1, -1);
-	return 1;  
-    }
-    return 0;
-  
-}
+	ih_size = 0;
+	if (vn->vn_nr_item) {
+		if (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE)
+			ih_size += IH_SIZE;
+
+		if (vn->vn_vi[vn->vn_nr_item - 1].
+		    vi_type & VI_TYPE_RIGHT_MERGEABLE)
+			ih_size += IH_SIZE;
+	} else {
+		/* there was only one item and it will be deleted */
+		struct item_head *ih;
+
+		ih = B_N_PITEM_HEAD(S0, 0);
+		if (tb->CFR[0]
+		    && !not_of_one_file(&(ih->ih_key),
+					B_N_PDELIM_KEY(tb->CFR[0],
+						       tb->rkey[0])))
+			if (I_IS_DIRECTORY_ITEM(ih)) {
+				/* we can delete any directory item in fsck (if it is unreachable) */
+				if (get_offset(&ih->ih_key) != DOT_OFFSET) {
+					/* must get left neighbor here to make sure, that
+					   left neighbor is of the same directory */
+					struct buffer_head *left;
+
+					left =
+					    get_left_neighbor(tb->tb_fs,
+							      tb->tb_path);
+					if (left) {
+						struct item_head *last;
+
+						if (B_NR_ITEMS(left) == 0)
+							reiserfs_panic
+							    ("vs-8135: are_leaves_removable: "
+							     "empty node in the tree");
+						last =
+						    B_N_PITEM_HEAD(left,
+								   B_NR_ITEMS
+								   (left) - 1);
+						if (!comp_short_keys
+						    (&last->ih_key,
+						     &ih->ih_key))
+							ih_size = IH_SIZE;
+						brelse(left);
+					}
+				}
+			}
 
+	}
 
+	if ((int)MAX_CHILD_SIZE(S0->b_size) + vn->vn_size <=
+	    rfree + lfree + ih_size) {
+		set_parameters(tb, 0, -1, -1, -1, NULL, -1, -1);
+		return 1;
+	}
+	return 0;
+
+}
 
 /* when we do not split item, lnum and rnum are numbers of entire items */
 #define SET_PAR_SHIFT_LEFT \
@@ -1057,7 +1122,6 @@ else \
 		     -1, -1);\
 }
 
-
 #define SET_PAR_SHIFT_RIGHT \
 if (h)\
 {\
@@ -1077,166 +1141,164 @@ else \
 		  -1, -1);\
 }
 
-
-
 /* Get new buffers for storing new nodes that are created while balancing.
  * Returns:	SCHEDULE_OCCURED - schedule occured while the function worked;
  *	        CARRY_ON - schedule didn't occur while the function worked;
  *	        NO_DISK_SPACE - no disk space.
  */
-static int  get_empty_nodes (struct tree_balance * p_s_tb,
-			     int n_h)
+static int get_empty_nodes(struct tree_balance *p_s_tb, int n_h)
 {
-    struct buffer_head  * p_s_new_bh,
-	*	p_s_Sh = PATH_H_PBUFFER (p_s_tb->tb_path, n_h);
-    unsigned long	      *	p_n_blocknr,
-	a_n_blocknrs[MAX_AMOUNT_NEEDED] = {0, };
-    int       		n_counter,
-	n_number_of_freeblk,
-	n_amount_needed,/* number of needed empty blocks */
-	n_repeat;
-    reiserfs_filsys_t *	fs = p_s_tb->tb_fs;
-
-
-    if (n_h == 0 && p_s_tb->insert_size[n_h] == 0x7fff)
-	return CARRY_ON;
-    
-    /* number_of_freeblk is the number of empty blocks which have been
-       acquired for use by the balancing algorithm minus the number of
-       empty blocks used in the previous levels of the analysis,
-       number_of_freeblk = tb->cur_blknum can be non-zero if a
-       schedule occurs after empty blocks are acquired, and the
-       balancing analysis is then restarted, amount_needed is the
-       number needed by this level (n_h) of the balancing analysis.
-			    
-       Note that for systems with many processes writing, it would be
-       more layout optimal to calculate the total number needed by all
-       levels and then to run reiserfs_new_blocks to get all of them
-       at once.  */
-
-    /* Initiate number_of_freeblk to the amount acquired prior to the restart of
-       the analysis or 0 if not restarted, then subtract the amount needed
-       by all of the levels of the tree below n_h. */
-    /* blknum includes S[n_h], so we subtract 1 in this calculation */
-    for ( n_counter = 0, n_number_of_freeblk = p_s_tb->cur_blknum; n_counter < n_h; n_counter++ )
-	n_number_of_freeblk -= ( p_s_tb->blknum[n_counter] ) ? (p_s_tb->blknum[n_counter] - 1) : 0;
-
-    /* Allocate missing empty blocks. */
-    /* if p_s_Sh == 0  then we are getting a new root */
-    n_amount_needed = ( p_s_Sh ) ? (p_s_tb->blknum[n_h] - 1) : 1;
-    /*  Amount_needed = the amount that we need more than the amount that we have. */
-    if ( n_amount_needed > n_number_of_freeblk )
-	n_amount_needed -= n_number_of_freeblk;
-    else /* If we have enough already then there is nothing to do. */
-	return CARRY_ON;
+	struct buffer_head *p_s_new_bh,
+	    *p_s_Sh = PATH_H_PBUFFER(p_s_tb->tb_path, n_h);
+	unsigned long *p_n_blocknr, a_n_blocknrs[MAX_AMOUNT_NEEDED] = { 0, };
+	int n_counter, n_number_of_freeblk, n_amount_needed,	/* number of needed empty blocks */
+	 n_repeat;
+	reiserfs_filsys_t *fs = p_s_tb->tb_fs;
+
+	if (n_h == 0 && p_s_tb->insert_size[n_h] == 0x7fff)
+		return CARRY_ON;
 
-    if ( (n_repeat = reiserfs_new_blocknrs (p_s_tb->tb_fs, a_n_blocknrs,
-					    PATH_PLAST_BUFFER(p_s_tb->tb_path)->b_blocknr, n_amount_needed)) != CARRY_ON ) {
-	return n_repeat; /* Out of disk space. */ 
-    }
-
-    /* for each blocknumber we just got, get a buffer and stick it on FEB */
-    for ( p_n_blocknr = a_n_blocknrs, n_counter = 0; n_counter < n_amount_needed;
-	  p_n_blocknr++, n_counter++ ) { 
-	p_s_new_bh = getblk (fs->fs_dev, *p_n_blocknr, fs->fs_blocksize);
-	if (p_s_new_bh->b_count > 1) {
-	    die ("get_empty_nodes: not free empty buffer");
+	/* number_of_freeblk is the number of empty blocks which have been
+	   acquired for use by the balancing algorithm minus the number of
+	   empty blocks used in the previous levels of the analysis,
+	   number_of_freeblk = tb->cur_blknum can be non-zero if a
+	   schedule occurs after empty blocks are acquired, and the
+	   balancing analysis is then restarted, amount_needed is the
+	   number needed by this level (n_h) of the balancing analysis.
+
+	   Note that for systems with many processes writing, it would be
+	   more layout optimal to calculate the total number needed by all
+	   levels and then to run reiserfs_new_blocks to get all of them
+	   at once.  */
+
+	/* Initiate number_of_freeblk to the amount acquired prior to the restart of
+	   the analysis or 0 if not restarted, then subtract the amount needed
+	   by all of the levels of the tree below n_h. */
+	/* blknum includes S[n_h], so we subtract 1 in this calculation */
+	for (n_counter = 0, n_number_of_freeblk = p_s_tb->cur_blknum;
+	     n_counter < n_h; n_counter++)
+		n_number_of_freeblk -=
+		    (p_s_tb->blknum[n_counter]) ? (p_s_tb->blknum[n_counter] -
+						   1) : 0;
+
+	/* Allocate missing empty blocks. */
+	/* if p_s_Sh == 0  then we are getting a new root */
+	n_amount_needed = (p_s_Sh) ? (p_s_tb->blknum[n_h] - 1) : 1;
+	/*  Amount_needed = the amount that we need more than the amount that we have. */
+	if (n_amount_needed > n_number_of_freeblk)
+		n_amount_needed -= n_number_of_freeblk;
+	else			/* If we have enough already then there is nothing to do. */
+		return CARRY_ON;
+
+	if ((n_repeat = reiserfs_new_blocknrs(p_s_tb->tb_fs, a_n_blocknrs,
+					      PATH_PLAST_BUFFER(p_s_tb->
+								tb_path)->
+					      b_blocknr,
+					      n_amount_needed)) != CARRY_ON) {
+		return n_repeat;	/* Out of disk space. */
 	}
-	
-	/* Put empty buffers into the array. */
-	p_s_tb->FEB[p_s_tb->cur_blknum++] = p_s_new_bh;
-    }
-    
-    return CARRY_ON;
-}
 
+	/* for each blocknumber we just got, get a buffer and stick it on FEB */
+	for (p_n_blocknr = a_n_blocknrs, n_counter = 0;
+	     n_counter < n_amount_needed; p_n_blocknr++, n_counter++) {
+		p_s_new_bh = getblk(fs->fs_dev, *p_n_blocknr, fs->fs_blocksize);
+		if (p_s_new_bh->b_count > 1) {
+			die("get_empty_nodes: not free empty buffer");
+		}
+
+		/* Put empty buffers into the array. */
+		p_s_tb->FEB[p_s_tb->cur_blknum++] = p_s_new_bh;
+	}
+
+	return CARRY_ON;
+}
 
 /* Get free space of the left neighbor,
  * which is stored in the parent node of the left neighbor.
  */
-static int get_lfree (struct tree_balance * tb, int h)
+static int get_lfree(struct tree_balance *tb, int h)
 {
-    struct buffer_head * l, * f;
-    int order;
+	struct buffer_head *l, *f;
+	int order;
 
-    if ((f = PATH_H_PPARENT (tb->tb_path, h)) == 0 || (l = tb->FL[h]) == 0)
-	return 0;
+	if ((f = PATH_H_PPARENT(tb->tb_path, h)) == 0 || (l = tb->FL[h]) == 0)
+		return 0;
 
-    if (f == l)
-	order = PATH_H_B_ITEM_ORDER (tb->tb_path, h) - 1;
-    else {
-	order = get_blkh_nr_items (B_BLK_HEAD(l));
-	f = l;
-    }
-
-    if (get_dc_child_size (B_N_CHILD(f,order)) == 0) {
-	reiserfs_warning (stderr, "get_lfree: block %u block_head %z has bad child pointer %y, order %d\n",
-			  l->b_blocknr, l, B_N_CHILD(f,order), order);
-    }
-    return (MAX_CHILD_SIZE(f->b_size) - get_dc_child_size (B_N_CHILD(f,order)));
-}
+	if (f == l)
+		order = PATH_H_B_ITEM_ORDER(tb->tb_path, h) - 1;
+	else {
+		order = get_blkh_nr_items(B_BLK_HEAD(l));
+		f = l;
+	}
 
+	if (get_dc_child_size(B_N_CHILD(f, order)) == 0) {
+		reiserfs_warning(stderr,
+				 "get_lfree: block %u block_head %z has bad child pointer %y, order %d\n",
+				 l->b_blocknr, l, B_N_CHILD(f, order), order);
+	}
+	return (MAX_CHILD_SIZE(f->b_size) -
+		get_dc_child_size(B_N_CHILD(f, order)));
+}
 
 /* Get free space of the right neighbor, which is stored in the parent node of
  * the right neighbor.  */
-static int get_rfree (struct tree_balance * tb, int h)
+static int get_rfree(struct tree_balance *tb, int h)
 {
-    struct buffer_head * r, * f;
-    int order;
+	struct buffer_head *r, *f;
+	int order;
 
-    if ((f = PATH_H_PPARENT (tb->tb_path, h)) == 0 || (r = tb->FR[h]) == 0)
-	return 0;
+	if ((f = PATH_H_PPARENT(tb->tb_path, h)) == 0 || (r = tb->FR[h]) == 0)
+		return 0;
 
-    if (f == r)
-	order = PATH_H_B_ITEM_ORDER (tb->tb_path, h) + 1;
-    else {
-	order = 0;
-	f = r;
-    }
+	if (f == r)
+		order = PATH_H_B_ITEM_ORDER(tb->tb_path, h) + 1;
+	else {
+		order = 0;
+		f = r;
+	}
 
-    return (MAX_CHILD_SIZE(f->b_size) - get_dc_child_size (B_N_CHILD(f,order)));
+	return (MAX_CHILD_SIZE(f->b_size) -
+		get_dc_child_size(B_N_CHILD(f, order)));
 
 }
 
-
 /* Check whether left neighbor is in memory. */
-static int  is_left_neighbor_in_cache (struct tree_balance * p_s_tb,
-				       int n_h)
+static int is_left_neighbor_in_cache(struct tree_balance *p_s_tb, int n_h)
 {
-    struct buffer_head  * p_s_father;
-    reiserfs_filsys_t * fs = p_s_tb->tb_fs;
-    unsigned long         n_left_neighbor_blocknr;
-    int                   n_left_neighbor_position;
+	struct buffer_head *p_s_father;
+	reiserfs_filsys_t *fs = p_s_tb->tb_fs;
+	unsigned long n_left_neighbor_blocknr;
+	int n_left_neighbor_position;
+
+	if (!p_s_tb->FL[n_h])	/* Father of the left neighbor does not exist. */
+		return 0;
+
+	/* Calculate father of the node to be balanced. */
+	p_s_father = PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1);
+	/* Get position of the pointer to the left neighbor into the left father. */
+	n_left_neighbor_position = (p_s_father == p_s_tb->FL[n_h]) ?
+	    p_s_tb->lkey[n_h] : get_blkh_nr_items(B_BLK_HEAD(p_s_tb->FL[n_h]));
+	/* Get left neighbor block number. */
+	n_left_neighbor_blocknr =
+	    get_dc_child_blocknr(B_N_CHILD
+				 (p_s_tb->FL[n_h], n_left_neighbor_position));
+	/* Look for the left neighbor in the cache. */
+	if ((p_s_father =
+	     find_buffer(fs->fs_dev, n_left_neighbor_blocknr,
+			 fs->fs_blocksize)))
+		return 1;
 
-    if ( ! p_s_tb->FL[n_h] ) /* Father of the left neighbor does not exist. */
 	return 0;
-
-    /* Calculate father of the node to be balanced. */
-    p_s_father = PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1);
-    /* Get position of the pointer to the left neighbor into the left father. */
-    n_left_neighbor_position = ( p_s_father == p_s_tb->FL[n_h] ) ?
-	p_s_tb->lkey[n_h] : get_blkh_nr_items (B_BLK_HEAD(p_s_tb->FL[n_h]));
-    /* Get left neighbor block number. */
-    n_left_neighbor_blocknr = get_dc_child_blocknr (B_N_CHILD (p_s_tb->FL[n_h], n_left_neighbor_position));
-    /* Look for the left neighbor in the cache. */
-    if ( (p_s_father = find_buffer(fs->fs_dev, n_left_neighbor_blocknr, fs->fs_blocksize)) )
-	return 1;
-
-    return 0;
 }
 
-
 #define LEFT_PARENTS  'l'
 #define RIGHT_PARENTS 'r'
 
-
-
-void init_path (struct reiserfs_path *path)
+void init_path(struct reiserfs_path *path)
 {
-    path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
+	path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
 }
 
-
 /* Calculate far left/right parent of the left/right neighbor of the current node, that
  * is calculate the left/right (FL[h]/FR[h]) neighbor of the parent F[h].
  * Calculate left/right common parent of the current node and L[h]/R[h].
@@ -1245,92 +1307,107 @@ void init_path (struct reiserfs_path *path)
  		SCHEDULE_OCCURRED - schedule occured while the function worked;
  *	        CARRY_ON         - schedule didn't occur while the function worked;
  */
-static int get_far_parent (struct tree_balance *   p_s_tb,
-			   int n_h,
-			   struct buffer_head  **  pp_s_father,
-			   struct buffer_head  **  pp_s_com_father,
-			   char c_lr_par)
+static int get_far_parent(struct tree_balance *p_s_tb,
+			  int n_h,
+			  struct buffer_head **pp_s_father,
+			  struct buffer_head **pp_s_com_father, char c_lr_par)
 {
-    struct buffer_head  * p_s_parent;
-    struct reiserfs_path         	s_path_to_neighbor_father,
-	* p_s_path = p_s_tb->tb_path;
-    struct reiserfs_key		s_lr_father_key;
-    int                   n_counter,
-	n_position = -1,
-	n_first_last_position = 0,
-	n_path_offset = PATH_H_PATH_OFFSET(p_s_path, n_h);
-    
-    /* Starting from F[n_h] go upwards in the tree, and look for the common
-       ancestor of F[n_h], and its neighbor l/r, that should be obtained. */
-    
-    n_counter = n_path_offset;
-    
-    for ( ; n_counter > FIRST_PATH_ELEMENT_OFFSET; n_counter--  )  {
-	/* Check whether parent of the current buffer in the path is really parent in the tree. */
-	if ( ! B_IS_IN_TREE(p_s_parent = PATH_OFFSET_PBUFFER(p_s_path, n_counter - 1)) )
-	    reiserfs_panic ("get_far_parent: buffer of path is notin the tree");
-
-	/* Check whether position in the parent is correct. */
-	if ( (n_position = PATH_OFFSET_POSITION(p_s_path, n_counter - 1)) > B_NR_ITEMS(p_s_parent) )
-	    reiserfs_panic ("get_far_parent: incorrect position in the parent");
-
-	/* Check whether parent at the path really points to the child. */
-	if ( get_dc_child_blocknr (B_N_CHILD (p_s_parent, n_position)) !=
-	     PATH_OFFSET_PBUFFER(p_s_path, n_counter)->b_blocknr )
-	    reiserfs_panic ("get_far_parent: incorrect disk child in the parent");
-
-	/* Return delimiting key if position in the parent is not equal to first/last one. */
-	if ( c_lr_par == RIGHT_PARENTS )
-	    n_first_last_position = get_blkh_nr_items (B_BLK_HEAD(p_s_parent));
-	if ( n_position != n_first_last_position ) {
-	    (*pp_s_com_father = p_s_parent)->b_count++;
-	    break;
+	struct buffer_head *p_s_parent;
+	struct reiserfs_path s_path_to_neighbor_father,
+	    *p_s_path = p_s_tb->tb_path;
+	struct reiserfs_key s_lr_father_key;
+	int n_counter,
+	    n_position = -1,
+	    n_first_last_position = 0,
+	    n_path_offset = PATH_H_PATH_OFFSET(p_s_path, n_h);
+
+	/* Starting from F[n_h] go upwards in the tree, and look for the common
+	   ancestor of F[n_h], and its neighbor l/r, that should be obtained. */
+
+	n_counter = n_path_offset;
+
+	for (; n_counter > FIRST_PATH_ELEMENT_OFFSET; n_counter--) {
+		/* Check whether parent of the current buffer in the path is really parent in the tree. */
+		if (!B_IS_IN_TREE
+		    (p_s_parent = PATH_OFFSET_PBUFFER(p_s_path, n_counter - 1)))
+			reiserfs_panic
+			    ("get_far_parent: buffer of path is notin the tree");
+
+		/* Check whether position in the parent is correct. */
+		if ((n_position =
+		     PATH_OFFSET_POSITION(p_s_path,
+					  n_counter - 1)) >
+		    B_NR_ITEMS(p_s_parent))
+			reiserfs_panic
+			    ("get_far_parent: incorrect position in the parent");
+
+		/* Check whether parent at the path really points to the child. */
+		if (get_dc_child_blocknr(B_N_CHILD(p_s_parent, n_position)) !=
+		    PATH_OFFSET_PBUFFER(p_s_path, n_counter)->b_blocknr)
+			reiserfs_panic
+			    ("get_far_parent: incorrect disk child in the parent");
+
+		/* Return delimiting key if position in the parent is not equal to first/last one. */
+		if (c_lr_par == RIGHT_PARENTS)
+			n_first_last_position =
+			    get_blkh_nr_items(B_BLK_HEAD(p_s_parent));
+		if (n_position != n_first_last_position) {
+			(*pp_s_com_father = p_s_parent)->b_count++;
+			break;
+		}
+	}
+
+	/* we are in the root of the tree. */
+	if (n_counter == FIRST_PATH_ELEMENT_OFFSET) {
+		struct reiserfs_super_block *sb;
+
+		sb = p_s_tb->tb_fs->fs_ondisk_sb;
+
+		/* Check whether first buffer in the path is the root of the tree. */
+		if (PATH_OFFSET_PBUFFER
+		    (p_s_tb->tb_path,
+		     FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
+		    get_sb_root_block(sb)) {
+			*pp_s_father = *pp_s_com_father = NULL;
+			return CARRY_ON;
+		}
+		reiserfs_panic("get_far_parent: root not found in the path");
 	}
-    }
-    
-    /* we are in the root of the tree. */
-    if ( n_counter == FIRST_PATH_ELEMENT_OFFSET ) {
-	struct reiserfs_super_block * sb;
-
-	sb = p_s_tb->tb_fs->fs_ondisk_sb;
-
-	/* Check whether first buffer in the path is the root of the tree. */
-	if ( PATH_OFFSET_PBUFFER(p_s_tb->tb_path, FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
-	     get_sb_root_block (sb) ) {
-	    *pp_s_father = *pp_s_com_father = NULL;
-	    return CARRY_ON;
+
+	if (n_position == -1)
+		reiserfs_panic("get_far_parent: position is not defined");
+
+	/* So, we got common parent of the current node and its left/right
+	   neighbor.  Now we are geting the parent of the left/right neighbor. */
+
+	/* Form key to get parent of the left/right neighbor. */
+	copy_key(&s_lr_father_key,
+		 B_N_PDELIM_KEY(*pp_s_com_father,
+				(c_lr_par ==
+				 LEFT_PARENTS) ? (p_s_tb->lkey[n_h - 1] =
+						  n_position -
+						  1) : (p_s_tb->rkey[n_h - 1] =
+							n_position)));
+
+	if (c_lr_par == LEFT_PARENTS) {
+		//reiserfs_warning ("decrememnting key %k\n", &s_lr_father_key);
+		decrement_key(&s_lr_father_key);
+		//reiserfs_warning ("done: %k\n", &s_lr_father_key);
 	}
-	reiserfs_panic ("get_far_parent: root not found in the path");
-    }
-    
-    if (n_position == -1)
-	reiserfs_panic ("get_far_parent: position is not defined");
-
-    /* So, we got common parent of the current node and its left/right
-       neighbor.  Now we are geting the parent of the left/right neighbor. */
-
-    /* Form key to get parent of the left/right neighbor. */
-    copy_key(&s_lr_father_key, B_N_PDELIM_KEY(*pp_s_com_father, ( c_lr_par == LEFT_PARENTS ) ?
-					      (p_s_tb->lkey[n_h - 1] = n_position - 1) : (p_s_tb->rkey[n_h - 1] = n_position)));
-
-    if ( c_lr_par == LEFT_PARENTS ) {
-	//reiserfs_warning ("decrememnting key %k\n", &s_lr_father_key);
-	decrement_key(&s_lr_father_key);
-	//reiserfs_warning ("done: %k\n", &s_lr_father_key);
-    }
-
-    init_path (&s_path_to_neighbor_father);
-    
-    if (search_by_key(p_s_tb->tb_fs, &s_lr_father_key, &s_path_to_neighbor_father, n_h + 1) == IO_ERROR)
-	return IO_ERROR;
-    
-    *pp_s_father = PATH_PLAST_BUFFER(&s_path_to_neighbor_father);
-    s_path_to_neighbor_father.path_length--;
-    pathrelse (&s_path_to_neighbor_father);
-    //decrement_counters_in_path(&s_path_to_neighbor_father);
-    return CARRY_ON;
-}
 
+	init_path(&s_path_to_neighbor_father);
+
+	if (search_by_key
+	    (p_s_tb->tb_fs, &s_lr_father_key, &s_path_to_neighbor_father,
+	     n_h + 1) == IO_ERROR)
+		return IO_ERROR;
+
+	*pp_s_father = PATH_PLAST_BUFFER(&s_path_to_neighbor_father);
+	s_path_to_neighbor_father.path_length--;
+	pathrelse(&s_path_to_neighbor_father);
+	//decrement_counters_in_path(&s_path_to_neighbor_father);
+	return CARRY_ON;
+}
 
 /* Get parents of neighbors of node in the path(S[n_path_offset]) and common parents of
  * S[n_path_offset] and L[n_path_offset]/R[n_path_offset]: F[n_path_offset], FL[n_path_offset],
@@ -1339,110 +1416,124 @@ static int get_far_parent (struct tree_balance *   p_s_tb,
  * Returns:	SCHEDULE_OCCURRED - schedule occured while the function worked;
  *	        CARRY_ON - schedule didn't occur while the function worked;
  */
-static int  get_parents (struct tree_balance * p_s_tb, int n_h)
+static int get_parents(struct tree_balance *p_s_tb, int n_h)
 {
-    struct reiserfs_path         * p_s_path = p_s_tb->tb_path;
-    int                   n_position,
-	n_ret_value,
-	n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
-    struct buffer_head  * p_s_curf,
-	* p_s_curcf;
-
-    /* Current node is the root of the tree or will be root of the tree */
-    if ( n_path_offset <= FIRST_PATH_ELEMENT_OFFSET ) {
-	/* The root can not have parents.
-	   Release nodes which previously were obtained as parents of the current node neighbors. */
+	struct reiserfs_path *p_s_path = p_s_tb->tb_path;
+	int n_position,
+	    n_ret_value,
+	    n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
+	struct buffer_head *p_s_curf, *p_s_curcf;
+
+	/* Current node is the root of the tree or will be root of the tree */
+	if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
+		/* The root can not have parents.
+		   Release nodes which previously were obtained as parents of the current node neighbors. */
+		brelse(p_s_tb->FL[n_h]);
+		brelse(p_s_tb->CFL[n_h]);
+		brelse(p_s_tb->FR[n_h]);
+		brelse(p_s_tb->CFR[n_h]);
+		//decrement_bcount(p_s_tb->FL[n_h]);
+		//decrement_bcount(p_s_tb->CFL[n_h]);
+		//decrement_bcount(p_s_tb->FR[n_h]);
+		//decrement_bcount(p_s_tb->CFR[n_h]);
+		p_s_tb->FL[n_h] = p_s_tb->CFL[n_h] = p_s_tb->FR[n_h] =
+		    p_s_tb->CFR[n_h] = NULL;
+		return CARRY_ON;
+	}
+
+	/* Get parent FL[n_path_offset] of L[n_path_offset]. */
+	if ((n_position = PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1))) {
+		/* Current node is not the first child of its parent. */
+		(p_s_curf = p_s_curcf =
+		 PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))->b_count +=
+2;
+		p_s_tb->lkey[n_h] = n_position - 1;
+	} else {
+		/* Calculate current parent of L[n_path_offset], which is the left neighbor of the current node.
+		   Calculate current common parent of L[n_path_offset] and the current node. Note that
+		   CFL[n_path_offset] not equal FL[n_path_offset] and CFL[n_path_offset] not equal F[n_path_offset].
+		   Calculate lkey[n_path_offset]. */
+		if ((n_ret_value = get_far_parent(p_s_tb, n_h + 1, &p_s_curf,
+						  &p_s_curcf,
+						  LEFT_PARENTS)) != CARRY_ON)
+			return n_ret_value;	/*schedule() occured or path is not correct */
+	}
+
 	brelse(p_s_tb->FL[n_h]);
+	p_s_tb->FL[n_h] = p_s_curf;	/* New initialization of FL[n_h]. */
+
 	brelse(p_s_tb->CFL[n_h]);
-	brelse(p_s_tb->FR[n_h]);
-	brelse(p_s_tb->CFR[n_h]);
-	//decrement_bcount(p_s_tb->FL[n_h]);
-	//decrement_bcount(p_s_tb->CFL[n_h]);
-	//decrement_bcount(p_s_tb->FR[n_h]);
-	//decrement_bcount(p_s_tb->CFR[n_h]);
-	p_s_tb->FL[n_h] = p_s_tb->CFL[n_h] = p_s_tb->FR[n_h] = p_s_tb->CFR[n_h] = NULL;
-	return CARRY_ON;
-    }
-  
-    /* Get parent FL[n_path_offset] of L[n_path_offset]. */
-    if ( (n_position = PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1)) )  {
-	/* Current node is not the first child of its parent. */
-	(p_s_curf = p_s_curcf = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))->b_count += 2;
-	p_s_tb->lkey[n_h] = n_position - 1;
-    }
-    else  {
-	/* Calculate current parent of L[n_path_offset], which is the left neighbor of the current node.
-	   Calculate current common parent of L[n_path_offset] and the current node. Note that
-	   CFL[n_path_offset] not equal FL[n_path_offset] and CFL[n_path_offset] not equal F[n_path_offset].
-	   Calculate lkey[n_path_offset]. */
-	if ( (n_ret_value = get_far_parent(p_s_tb, n_h + 1, &p_s_curf,
-					   &p_s_curcf, LEFT_PARENTS)) != CARRY_ON )
-	    return n_ret_value; /*schedule() occured or path is not correct*/
-    }
-
-    brelse(p_s_tb->FL[n_h]);	
-    p_s_tb->FL[n_h] = p_s_curf; /* New initialization of FL[n_h]. */
- 
-    brelse(p_s_tb->CFL[n_h]);
-    p_s_tb->CFL[n_h] = p_s_curcf; /* New initialization of CFL[n_h]. */
+	p_s_tb->CFL[n_h] = p_s_curcf;	/* New initialization of CFL[n_h]. */
 
 /* Get parent FR[n_h] of R[n_h]. */
 
 /* Current node is the last child of F[n_h]. FR[n_h] != F[n_h]. */
-    if ( n_position == get_blkh_nr_items (B_BLK_HEAD(PATH_H_PBUFFER(p_s_path, n_h + 1))) ) {
+	if (n_position ==
+	    get_blkh_nr_items(B_BLK_HEAD(PATH_H_PBUFFER(p_s_path, n_h + 1)))) {
 /* Calculate current parent of R[n_h], which is the right neighbor of F[n_h].
    Calculate current common parent of R[n_h] and current node. Note that CFR[n_h]
    not equal FR[n_path_offset] and CFR[n_h] not equal F[n_h]. */
-	if ( (n_ret_value = get_far_parent(p_s_tb, n_h + 1, &p_s_curf,  &p_s_curcf, RIGHT_PARENTS)) != CARRY_ON )
-	    return n_ret_value; /*schedule() occured while get_far_parent() worked.*/
-    }
-    else {
+		if ((n_ret_value =
+		     get_far_parent(p_s_tb, n_h + 1, &p_s_curf, &p_s_curcf,
+				    RIGHT_PARENTS)) != CARRY_ON)
+			return n_ret_value;	/*schedule() occured while get_far_parent() worked. */
+	} else {
 /* Current node is not the last child of its parent F[n_h]. */
-	(p_s_curf = p_s_curcf = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))->b_count += 2;
-	p_s_tb->rkey[n_h] = n_position;
-    }	
+		(p_s_curf = p_s_curcf =
+		 PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1))->b_count +=
+2;
+		p_s_tb->rkey[n_h] = n_position;
+	}
 
-    brelse/*decrement_bcount*/(p_s_tb->FR[n_h]);
-    p_s_tb->FR[n_h] = p_s_curf; /* New initialization of FR[n_path_offset]. */
+	brelse /*decrement_bcount */ (p_s_tb->FR[n_h]);
+	p_s_tb->FR[n_h] = p_s_curf;	/* New initialization of FR[n_path_offset]. */
 
-    brelse/*decrement_bcount*/(p_s_tb->CFR[n_h]);
-    p_s_tb->CFR[n_h] = p_s_curcf; /* New initialization of CFR[n_path_offset]. */
+	brelse /*decrement_bcount */ (p_s_tb->CFR[n_h]);
+	p_s_tb->CFR[n_h] = p_s_curcf;	/* New initialization of CFR[n_path_offset]. */
 
-    return CARRY_ON; /* schedule not occured while get_parents() worked. */
+	return CARRY_ON;	/* schedule not occured while get_parents() worked. */
 }
 
-
 /* it is possible to remove node as result of shiftings to
    neighbors even when we insert or paste item. */
-static inline int can_node_be_removed (int mode, int lfree, int sfree, int rfree, struct tree_balance * tb, int h)
+static inline int can_node_be_removed(int mode, int lfree, int sfree, int rfree,
+				      struct tree_balance *tb, int h)
 {
-    struct buffer_head * Sh = PATH_H_PBUFFER (tb->tb_path, h);
-    int levbytes = tb->insert_size[h];
-    struct item_head * r_ih = NULL;
-  
-    if ( tb->CFR[h] )
-	r_ih = (struct item_head *)B_N_PDELIM_KEY(tb->CFR[h],tb->rkey[h]);
-  
-    if (lfree + rfree + sfree < (int)(MAX_CHILD_SIZE(Sh->b_size) + levbytes
-	/* shifting may merge items which might save space */
-	- (( ! h && is_left_mergeable (tb->tb_fs, tb->tb_path) == 1 ) ? IH_SIZE : 0)
-	- (( ! h && r_ih && is_right_mergeable (tb->tb_fs, tb->tb_path) == 1 ) ? IH_SIZE : 0)
-	+ (( h ) ? KEY_SIZE : 0)))
-    {
-	/* node can not be removed */
-	if (sfree >= levbytes ) /* new item fits into node S[h] without any shifting */
-	{
-	    if ( ! h )
-		tb->s0num = B_NR_ITEMS(Sh) + ((mode == M_INSERT ) ? 1 : 0);
-	    set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-	    return NO_BALANCING_NEEDED;
+	struct buffer_head *Sh = PATH_H_PBUFFER(tb->tb_path, h);
+	int levbytes = tb->insert_size[h];
+	struct item_head *r_ih = NULL;
+
+	if (tb->CFR[h])
+		r_ih =
+		    (struct item_head *)B_N_PDELIM_KEY(tb->CFR[h], tb->rkey[h]);
+
+	if (lfree + rfree + sfree < (int)(MAX_CHILD_SIZE(Sh->b_size) + levbytes
+					  /* shifting may merge items which might save space */
+					  -
+					  ((!h
+					    && is_left_mergeable(tb->tb_fs,
+								 tb->tb_path) ==
+					    1) ? IH_SIZE : 0)
+					  -
+					  ((!h && r_ih
+					    && is_right_mergeable(tb->tb_fs,
+								  tb->
+								  tb_path) ==
+					    1) ? IH_SIZE : 0)
+					  + ((h) ? KEY_SIZE : 0))) {
+		/* node can not be removed */
+		if (sfree >= levbytes) {	/* new item fits into node S[h] without any shifting */
+			if (!h)
+				tb->s0num =
+				    B_NR_ITEMS(Sh) +
+				    ((mode == M_INSERT) ? 1 : 0);
+			set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+			return NO_BALANCING_NEEDED;
+		}
 	}
-    }
-    return !NO_BALANCING_NEEDED;
+	return !NO_BALANCING_NEEDED;
 }
 
-
-
 /* Check whether current node S[h] is balanced when increasing its size by
  * Inserting or Pasting.
  * Calculate parameters for balancing for current level h.
@@ -1457,146 +1548,150 @@ static inline int can_node_be_removed (int mode, int lfree, int sfree, int rfree
  *	       -2 - no disk space.
  */
 /* ip means Inserting or Pasting */
-static int ip_check_balance (/*struct reiserfs_transaction_handle *th,*/ struct tree_balance * tb, int h)
+static int ip_check_balance( /*struct reiserfs_transaction_handle *th, */ struct
+			    tree_balance *tb, int h)
 {
-    struct virtual_node * vn = tb->tb_vn;
-    int levbytes,  /* Number of bytes that must be inserted into (value is
-		      negative if bytes are deleted) buffer which contains
-		      node being balanced.  The mnemonic is that the attempted
-		      change in node space used level is levbytes bytes. */
-	n_ret_value;
-    
-    int lfree, sfree, rfree /* free space in L, S and R */;
-
-    /* nver is short for number of vertices, and lnver is the number if we
-       shift to the left, rnver is the number if we shift to the right, and
-       lrnver is the number if we shift in both directions.  The goal is to
-       minimize first the number of vertices, and second, the number of
-       vertices whose contents are changed by shifting, and third the number
-       of uncached vertices whose contents are changed by shifting and must be
-       read from disk.  */
-    int nver, lnver, rnver, lrnver;
-
-    /* used at leaf level only, S0 = S[0] is the node being balanced, sInum [
-       I = 0,1,2 ] is the number of items that will remain in node SI after
-       balancing.  S1 and S2 are new nodes that might be created. */
-  
-    /* we perform 8 calls to get_num_ver().  For each call we calculate five
-     parameters.  where 4th parameter is s1bytes and 5th - s2bytes */
-    short snum012[40] = {0,};	/* s0num, s1num, s2num for 8 cases 
-				   0,1 - do not shift and do not shift but bottle
-				   2 - shift only whole item to left
-				   3 - shift to left and bottle as much as possible
-				   4,5 - shift to right	(whole items and as much as possible
-				   6,7 - shift to both directions (whole items and as much as possible)
-				   */
-
-    /* Sh is the node whose balance is currently being checked */
-    struct buffer_head * Sh;
-  
-    /* special mode for insert pointer to the most low internal node */
-    if (h == 0 && vn->vn_mode == M_INTERNAL) {
-	/* blk_num == 2 is to get pointer inserted to the next level */
-	set_parameters (tb, h, 0, 0, 2, NULL, -1, -1);
-	return 0;
-    }
-
-    Sh = PATH_H_PBUFFER (tb->tb_path, h);
-    levbytes = tb->insert_size[h];
-    
-    /* Calculate balance parameters for creating new root. */
-    if ( ! Sh )  {
-	if ( ! h )
-	    reiserfs_panic ("vs-8210: ip_check_balance: S[0] can not be 0");
-	switch ( n_ret_value = get_empty_nodes (tb, h) )  {
-	case CARRY_ON:
-	    set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-	    return NO_BALANCING_NEEDED; /* no balancing for higher levels needed */
-	    
-	case NO_DISK_SPACE:
-	    return n_ret_value;
-
-	default:   
-	    reiserfs_panic("vs-8215: ip_check_balance: incorrect return value of get_empty_nodes");
+	struct virtual_node *vn = tb->tb_vn;
+	int levbytes,		/* Number of bytes that must be inserted into (value is
+				   negative if bytes are deleted) buffer which contains
+				   node being balanced.  The mnemonic is that the attempted
+				   change in node space used level is levbytes bytes. */
+	 n_ret_value;
+
+	int lfree, sfree, rfree /* free space in L, S and R */ ;
+
+	/* nver is short for number of vertices, and lnver is the number if we
+	   shift to the left, rnver is the number if we shift to the right, and
+	   lrnver is the number if we shift in both directions.  The goal is to
+	   minimize first the number of vertices, and second, the number of
+	   vertices whose contents are changed by shifting, and third the number
+	   of uncached vertices whose contents are changed by shifting and must be
+	   read from disk.  */
+	int nver, lnver, rnver, lrnver;
+
+	/* used at leaf level only, S0 = S[0] is the node being balanced, sInum [
+	   I = 0,1,2 ] is the number of items that will remain in node SI after
+	   balancing.  S1 and S2 are new nodes that might be created. */
+
+	/* we perform 8 calls to get_num_ver().  For each call we calculate five
+	   parameters.  where 4th parameter is s1bytes and 5th - s2bytes */
+	short snum012[40] = { 0, };	/* s0num, s1num, s2num for 8 cases 
+					   0,1 - do not shift and do not shift but bottle
+					   2 - shift only whole item to left
+					   3 - shift to left and bottle as much as possible
+					   4,5 - shift to right (whole items and as much as possible
+					   6,7 - shift to both directions (whole items and as much as possible)
+					 */
+
+	/* Sh is the node whose balance is currently being checked */
+	struct buffer_head *Sh;
+
+	/* special mode for insert pointer to the most low internal node */
+	if (h == 0 && vn->vn_mode == M_INTERNAL) {
+		/* blk_num == 2 is to get pointer inserted to the next level */
+		set_parameters(tb, h, 0, 0, 2, NULL, -1, -1);
+		return 0;
 	}
-    }
-    
-    if ( (n_ret_value = get_parents (tb, h)) != CARRY_ON ) /* get parents of S[h] neighbors. */
-	return n_ret_value;
-    
-    sfree = get_blkh_free_space (B_BLK_HEAD(Sh));
-    
-    /* get free space of neighbors */
-    rfree = get_rfree (tb, h);
-    lfree = get_lfree (tb, h);
-    
-    if (can_node_be_removed (vn->vn_mode, lfree, sfree, rfree, tb, h) == NO_BALANCING_NEEDED)
-	/* and new item fits into node S[h] without any shifting */
-	return NO_BALANCING_NEEDED;
-    
-    create_virtual_node (tb, h);
-    
-     /* determine maximal number of items we can shift to the left neighbor
-	(in tb structure) and the maximal number of bytes that can flow to the
-	left neighbor from the left most liquid item that cannot be shifted
-	from S[0] entirely (returned value) */
-    check_left (tb, h, lfree);
-    
-    /* determine maximal number of items we can shift to the right neighbor
-       (in tb structure) and the maximal number of bytes that can flow to the
-       right neighbor from the right most liquid item that cannot be shifted
-       from S[0] entirely (returned value) */
-    check_right (tb, h, rfree);
-    
-
-    /* all contents of internal node S[h] can be moved into its neighbors,
-       S[h] will be removed after balancing */
-    if (h && (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1)) {
-	int to_r; 
-	
-       /* Since we are working on internal nodes, and our internal nodes have
-	  fixed size entries, then we can balance by the number of items
-	  rather than the space they consume.  In this routine we set the left
-	  node equal to the right node, allowing a difference of less than or
-	  equal to 1 child pointer. */
-	to_r = ((MAX_NR_KEY(Sh)<<1)+2-tb->lnum[h]-tb->rnum[h]+vn->vn_nr_item+1)/2 - 
-	    (MAX_NR_KEY(Sh) + 1 - tb->rnum[h]);
-	set_parameters (tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL, -1, -1);
-	return CARRY_ON;
-    }
-    
-    /* all contents of S[0] can be moved into its neighbors S[0] will be
-       removed after balancing. */
-    if (!h && is_leaf_removable (tb))
-       return CARRY_ON;
-    
-    
-    /* why do we perform this check here rather than earlier??
-       Answer: we can win 1 node in some cases above. Moreover we
-       checked it above, when we checked, that S[0] is not removable
-       in principle */
-    if (sfree >= levbytes) { /* new item fits into node S[h] without any shifting */
-	if ( ! h )
-	 tb->s0num = vn->vn_nr_item;
-	set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-	return NO_BALANCING_NEEDED;
-    }
-    
-    
-    {
-	int lpar, rpar, nset, lset, rset, lrset;
-	/* 
-	 * regular overflowing of the node
-	 */
-
-	/* get_num_ver works in 2 modes (FLOW & NO_FLOW) lpar, rpar - number
-	   of items we can shift to left/right neighbor (including splitting
-	   item) nset, lset, rset, lrset - shows, whether flowing items give
-	   better packing */
+
+	Sh = PATH_H_PBUFFER(tb->tb_path, h);
+	levbytes = tb->insert_size[h];
+
+	/* Calculate balance parameters for creating new root. */
+	if (!Sh) {
+		if (!h)
+			reiserfs_panic
+			    ("vs-8210: ip_check_balance: S[0] can not be 0");
+		switch (n_ret_value = get_empty_nodes(tb, h)) {
+		case CARRY_ON:
+			set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+			return NO_BALANCING_NEEDED;	/* no balancing for higher levels needed */
+
+		case NO_DISK_SPACE:
+			return n_ret_value;
+
+		default:
+			reiserfs_panic
+			    ("vs-8215: ip_check_balance: incorrect return value of get_empty_nodes");
+		}
+	}
+
+	if ((n_ret_value = get_parents(tb, h)) != CARRY_ON)	/* get parents of S[h] neighbors. */
+		return n_ret_value;
+
+	sfree = get_blkh_free_space(B_BLK_HEAD(Sh));
+
+	/* get free space of neighbors */
+	rfree = get_rfree(tb, h);
+	lfree = get_lfree(tb, h);
+
+	if (can_node_be_removed(vn->vn_mode, lfree, sfree, rfree, tb, h) ==
+	    NO_BALANCING_NEEDED)
+		/* and new item fits into node S[h] without any shifting */
+		return NO_BALANCING_NEEDED;
+
+	create_virtual_node(tb, h);
+
+	/* determine maximal number of items we can shift to the left neighbor
+	   (in tb structure) and the maximal number of bytes that can flow to the
+	   left neighbor from the left most liquid item that cannot be shifted
+	   from S[0] entirely (returned value) */
+	check_left(tb, h, lfree);
+
+	/* determine maximal number of items we can shift to the right neighbor
+	   (in tb structure) and the maximal number of bytes that can flow to the
+	   right neighbor from the right most liquid item that cannot be shifted
+	   from S[0] entirely (returned value) */
+	check_right(tb, h, rfree);
+
+	/* all contents of internal node S[h] can be moved into its neighbors,
+	   S[h] will be removed after balancing */
+	if (h && (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1)) {
+		int to_r;
+
+		/* Since we are working on internal nodes, and our internal nodes have
+		   fixed size entries, then we can balance by the number of items
+		   rather than the space they consume.  In this routine we set the left
+		   node equal to the right node, allowing a difference of less than or
+		   equal to 1 child pointer. */
+		to_r =
+		    ((MAX_NR_KEY(Sh) << 1) + 2 - tb->lnum[h] - tb->rnum[h] +
+		     vn->vn_nr_item + 1) / 2 - (MAX_NR_KEY(Sh) + 1 -
+						tb->rnum[h]);
+		set_parameters(tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL,
+			       -1, -1);
+		return CARRY_ON;
+	}
+
+	/* all contents of S[0] can be moved into its neighbors S[0] will be
+	   removed after balancing. */
+	if (!h && is_leaf_removable(tb))
+		return CARRY_ON;
+
+	/* why do we perform this check here rather than earlier??
+	   Answer: we can win 1 node in some cases above. Moreover we
+	   checked it above, when we checked, that S[0] is not removable
+	   in principle */
+	if (sfree >= levbytes) {	/* new item fits into node S[h] without any shifting */
+		if (!h)
+			tb->s0num = vn->vn_nr_item;
+		set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+		return NO_BALANCING_NEEDED;
+	}
+
+	{
+		int lpar, rpar, nset, lset, rset, lrset;
+		/* 
+		 * regular overflowing of the node
+		 */
+
+		/* get_num_ver works in 2 modes (FLOW & NO_FLOW) lpar, rpar - number
+		   of items we can shift to left/right neighbor (including splitting
+		   item) nset, lset, rset, lrset - shows, whether flowing items give
+		   better packing */
 #define FLOW 1
-#define NO_FLOW 0	/* do not any splitting */
-	
-     /* we choose one the following */
+#define NO_FLOW 0		/* do not any splitting */
+
+		/* we choose one the following */
 #define NOTHING_SHIFT_NO_FLOW	0
 #define NOTHING_SHIFT_FLOW	5
 #define LEFT_SHIFT_NO_FLOW	10
@@ -1606,147 +1701,167 @@ static int ip_check_balance (/*struct reiserfs_transaction_handle *th,*/ struct
 #define LR_SHIFT_NO_FLOW	30
 #define LR_SHIFT_FLOW		35
 
+		lpar = tb->lnum[h];
+		rpar = tb->rnum[h];
+
+		/* calculate number of blocks S[h] must be split into when nothing is
+		   shifted to the neighbors, as well as number of items in each part
+		   of the split node (s012 numbers), and number of bytes (s1bytes) of
+		   the shared drop which flow to S1 if any */
+		nset = NOTHING_SHIFT_NO_FLOW;
+		nver = get_num_ver(vn->vn_mode, tb, h,
+				   0, -1, h ? vn->vn_nr_item : 0, -1,
+				   snum012, NO_FLOW);
+
+		if (!h) {
+			int nver1;
+
+			/* note, that in this case we try to bottle between S[0] and S1
+			   (S1 - the first new node) */
+			nver1 = get_num_ver(vn->vn_mode, tb, h,
+					    0, -1, 0, -1,
+					    snum012 + NOTHING_SHIFT_FLOW, FLOW);
+			if (nver > nver1)
+				nset = NOTHING_SHIFT_FLOW, nver = nver1;
+		}
 
-	lpar = tb->lnum[h];
-	rpar = tb->rnum[h];
-	
-
-	/* calculate number of blocks S[h] must be split into when nothing is
-	   shifted to the neighbors, as well as number of items in each part
-	   of the split node (s012 numbers), and number of bytes (s1bytes) of
-	   the shared drop which flow to S1 if any */
-	nset = NOTHING_SHIFT_NO_FLOW;
-	nver = get_num_ver (vn->vn_mode, tb, h,
-			    0, -1, h?vn->vn_nr_item:0, -1, 
-			    snum012, NO_FLOW);
-	
-	if (!h)	{
-	    int nver1;
-	    
-	    /* note, that in this case we try to bottle between S[0] and S1
-               (S1 - the first new node) */
-	    nver1 = get_num_ver (vn->vn_mode, tb, h, 
-				 0, -1, 0, -1, 
-				 snum012 + NOTHING_SHIFT_FLOW, FLOW);
-	    if (nver > nver1)
-		nset = NOTHING_SHIFT_FLOW, nver = nver1;
-	}
-	
-	
-	/* calculate number of blocks S[h] must be split into when l_shift_num
-	   first items and l_shift_bytes of the right most liquid item to be
-	   shifted are shifted to the left neighbor, as well as number of
-	   items in each part of the split node (s012 numbers), and number
-	   of bytes (s1bytes) of the shared drop which flow to S1 if any */
-	lset = LEFT_SHIFT_NO_FLOW;
-	lnver = get_num_ver (vn->vn_mode, tb, h, 
-			     lpar - (( h || tb->lbytes == -1 ) ? 0 : 1), -1, h ? vn->vn_nr_item:0, -1,
-			     snum012 + LEFT_SHIFT_NO_FLOW, NO_FLOW);
-	if (!h)	{
-	    int lnver1;
-	    
-	    lnver1 = get_num_ver (vn->vn_mode, tb, h, 
-				  lpar - ((tb->lbytes != -1) ? 1 : 0), tb->lbytes, 0, -1,
-				  snum012 + LEFT_SHIFT_FLOW, FLOW);
-	    if (lnver > lnver1)
-		lset = LEFT_SHIFT_FLOW, lnver = lnver1;
-	}
-	
-	
-	/* calculate number of blocks S[h] must be split into when r_shift_num
-	   first items and r_shift_bytes of the left most liquid item to be
-	   shifted are shifted to the right neighbor, as well as number of
-	   items in each part of the splitted node (s012 numbers), and number
-	   of bytes (s1bytes) of the shared drop which flow to S1 if any */
-	rset = RIGHT_SHIFT_NO_FLOW;
-	rnver = get_num_ver (vn->vn_mode, tb, h, 
-			     0, -1, h ? (vn->vn_nr_item-rpar) : (rpar - (( tb->rbytes != -1 ) ? 1 : 0)), -1, 
-			     snum012 + RIGHT_SHIFT_NO_FLOW, NO_FLOW);
-	if (!h)	{
-	    int rnver1;
-	    
-	    rnver1 = get_num_ver (vn->vn_mode, tb, h, 
-				  0, -1, (rpar - ((tb->rbytes != -1) ? 1 : 0)), tb->rbytes, 
-				  snum012 + RIGHT_SHIFT_FLOW, FLOW);
-	    
-	    if (rnver > rnver1)
-		rset = RIGHT_SHIFT_FLOW, rnver = rnver1;
-	}
-	
-	
-	/* calculate number of blocks S[h] must be split into when items are
-	   shifted in both directions, as well as number of items in each part
-	   of the splitted node (s012 numbers), and number of bytes (s1bytes)
-	   of the shared drop which flow to S1 if any */
-	lrset = LR_SHIFT_NO_FLOW;
-	lrnver = get_num_ver (vn->vn_mode, tb, h, 
-			      lpar - ((h || tb->lbytes == -1) ? 0 : 1), -1, h ? (vn->vn_nr_item-rpar):(rpar - ((tb->rbytes != -1) ? 1 : 0)), -1,
-			      snum012 + LR_SHIFT_NO_FLOW, NO_FLOW);
-	if (!h)	{
-	    int lrnver1;
-	    
-	    lrnver1 = get_num_ver (vn->vn_mode, tb, h, 
-				   lpar - ((tb->lbytes != -1) ? 1 : 0), tb->lbytes, (rpar - ((tb->rbytes != -1) ? 1 : 0)), tb->rbytes,
-				   snum012 + LR_SHIFT_FLOW, FLOW);
-	    if (lrnver > lrnver1)
-		lrset = LR_SHIFT_FLOW, lrnver = lrnver1;
-	}
-	
-	
-	
-	/* Our general shifting strategy is:
-	   1) to minimized number of new nodes;
-	   2) to minimized number of neighbors involved in shifting;
-	   3) to minimized number of disk reads; */
-	
-	/* we can win TWO or ONE nodes by shifting in both directions */
-	if (lrnver < lnver && lrnver < rnver) {
-	    if (lrset == LR_SHIFT_FLOW)
-		set_parameters (tb, h, tb->lnum[h], tb->rnum[h], lrnver, snum012 + lrset,
-				tb->lbytes, tb->rbytes);
-	    else
-		set_parameters (tb, h, tb->lnum[h] - ((tb->lbytes == -1) ? 0 : 1), 
-				tb->rnum[h] - ((tb->rbytes == -1) ? 0 : 1), lrnver, snum012 + lrset, -1, -1);
-	    
-	    return CARRY_ON;
-	}
-	
-	/* if shifting doesn't lead to better packing then don't shift */
-	if (nver == lrnver) {
-	    set_parameters (tb, h, 0, 0, nver, snum012 + nset, -1, -1);
-	    return CARRY_ON;
-	}
+		/* calculate number of blocks S[h] must be split into when l_shift_num
+		   first items and l_shift_bytes of the right most liquid item to be
+		   shifted are shifted to the left neighbor, as well as number of
+		   items in each part of the split node (s012 numbers), and number
+		   of bytes (s1bytes) of the shared drop which flow to S1 if any */
+		lset = LEFT_SHIFT_NO_FLOW;
+		lnver = get_num_ver(vn->vn_mode, tb, h,
+				    lpar - ((h || tb->lbytes == -1) ? 0 : 1),
+				    -1, h ? vn->vn_nr_item : 0, -1,
+				    snum012 + LEFT_SHIFT_NO_FLOW, NO_FLOW);
+		if (!h) {
+			int lnver1;
+
+			lnver1 = get_num_ver(vn->vn_mode, tb, h,
+					     lpar -
+					     ((tb->lbytes != -1) ? 1 : 0),
+					     tb->lbytes, 0, -1,
+					     snum012 + LEFT_SHIFT_FLOW, FLOW);
+			if (lnver > lnver1)
+				lset = LEFT_SHIFT_FLOW, lnver = lnver1;
+		}
 
-	/* now we know that for better packing shifting in only one direction
-	   either to the left or to the right is required */
+		/* calculate number of blocks S[h] must be split into when r_shift_num
+		   first items and r_shift_bytes of the left most liquid item to be
+		   shifted are shifted to the right neighbor, as well as number of
+		   items in each part of the splitted node (s012 numbers), and number
+		   of bytes (s1bytes) of the shared drop which flow to S1 if any */
+		rset = RIGHT_SHIFT_NO_FLOW;
+		rnver = get_num_ver(vn->vn_mode, tb, h,
+				    0, -1,
+				    h ? (vn->vn_nr_item - rpar) : (rpar -
+								   ((tb->
+								     rbytes !=
+								     -1) ? 1 :
+								    0)), -1,
+				    snum012 + RIGHT_SHIFT_NO_FLOW, NO_FLOW);
+		if (!h) {
+			int rnver1;
+
+			rnver1 = get_num_ver(vn->vn_mode, tb, h,
+					     0, -1,
+					     (rpar -
+					      ((tb->rbytes != -1) ? 1 : 0)),
+					     tb->rbytes,
+					     snum012 + RIGHT_SHIFT_FLOW, FLOW);
+
+			if (rnver > rnver1)
+				rset = RIGHT_SHIFT_FLOW, rnver = rnver1;
+		}
 
-	/*  if shifting to the left is better than shifting to the right */
-	if (lnver < rnver) {
-	    SET_PAR_SHIFT_LEFT;
-	    return CARRY_ON;
-	}
+		/* calculate number of blocks S[h] must be split into when items are
+		   shifted in both directions, as well as number of items in each part
+		   of the splitted node (s012 numbers), and number of bytes (s1bytes)
+		   of the shared drop which flow to S1 if any */
+		lrset = LR_SHIFT_NO_FLOW;
+		lrnver = get_num_ver(vn->vn_mode, tb, h,
+				     lpar - ((h || tb->lbytes == -1) ? 0 : 1),
+				     -1,
+				     h ? (vn->vn_nr_item - rpar) : (rpar -
+								    ((tb->
+								      rbytes !=
+								      -1) ? 1 :
+								     0)), -1,
+				     snum012 + LR_SHIFT_NO_FLOW, NO_FLOW);
+		if (!h) {
+			int lrnver1;
+
+			lrnver1 = get_num_ver(vn->vn_mode, tb, h,
+					      lpar -
+					      ((tb->lbytes != -1) ? 1 : 0),
+					      tb->lbytes,
+					      (rpar -
+					       ((tb->rbytes != -1) ? 1 : 0)),
+					      tb->rbytes,
+					      snum012 + LR_SHIFT_FLOW, FLOW);
+			if (lrnver > lrnver1)
+				lrset = LR_SHIFT_FLOW, lrnver = lrnver1;
+		}
 
-	/* if shifting to the right is better than shifting to the left */
-	if (lnver > rnver) {
-	    SET_PAR_SHIFT_RIGHT;
-	    return CARRY_ON;
-	}
+		/* Our general shifting strategy is:
+		   1) to minimized number of new nodes;
+		   2) to minimized number of neighbors involved in shifting;
+		   3) to minimized number of disk reads; */
+
+		/* we can win TWO or ONE nodes by shifting in both directions */
+		if (lrnver < lnver && lrnver < rnver) {
+			if (lrset == LR_SHIFT_FLOW)
+				set_parameters(tb, h, tb->lnum[h], tb->rnum[h],
+					       lrnver, snum012 + lrset,
+					       tb->lbytes, tb->rbytes);
+			else
+				set_parameters(tb, h,
+					       tb->lnum[h] -
+					       ((tb->lbytes == -1) ? 0 : 1),
+					       tb->rnum[h] -
+					       ((tb->rbytes == -1) ? 0 : 1),
+					       lrnver, snum012 + lrset, -1, -1);
+
+			return CARRY_ON;
+		}
+
+		/* if shifting doesn't lead to better packing then don't shift */
+		if (nver == lrnver) {
+			set_parameters(tb, h, 0, 0, nver, snum012 + nset, -1,
+				       -1);
+			return CARRY_ON;
+		}
+
+		/* now we know that for better packing shifting in only one direction
+		   either to the left or to the right is required */
+
+		/*  if shifting to the left is better than shifting to the right */
+		if (lnver < rnver) {
+			SET_PAR_SHIFT_LEFT;
+			return CARRY_ON;
+		}
 
-	/* now shifting in either direction gives the same number of nodes and
-	   we can make use of the cached neighbors */
-	if (is_left_neighbor_in_cache (tb,h)) {
-	    SET_PAR_SHIFT_LEFT;
-	    return CARRY_ON;
+		/* if shifting to the right is better than shifting to the left */
+		if (lnver > rnver) {
+			SET_PAR_SHIFT_RIGHT;
+			return CARRY_ON;
+		}
+
+		/* now shifting in either direction gives the same number of nodes and
+		   we can make use of the cached neighbors */
+		if (is_left_neighbor_in_cache(tb, h)) {
+			SET_PAR_SHIFT_LEFT;
+			return CARRY_ON;
+		}
+
+		/* shift to the right independently on whether the right neighbor in
+		   cache or not */
+		SET_PAR_SHIFT_RIGHT;
+		return CARRY_ON;
 	}
-	
-	/* shift to the right independently on whether the right neighbor in
-           cache or not */
-	SET_PAR_SHIFT_RIGHT;
-	return CARRY_ON;
-    }
 }
 
-
 /* Check whether current node S[h] is balanced when Decreasing its size by
  * Deleting or Cutting for INTERNAL node of internal tree.
  * Calculate parameters for balancing for current level h.
@@ -1763,144 +1878,178 @@ static int ip_check_balance (/*struct reiserfs_transaction_handle *th,*/ struct
  * Note: Items of internal nodes have fixed size, so the balance condition for
  * the internal part of internal tree is as for the B-trees.
  */
-static int dc_check_balance_internal (struct tree_balance * tb, int h)
+static int dc_check_balance_internal(struct tree_balance *tb, int h)
 {
-    struct virtual_node * vn = tb->tb_vn;
-
-  /* Sh is the node whose balance is currently being checked,
-     and Fh is its father.  */
-    struct buffer_head * Sh, * Fh;
-    int n_ret_value;
-    int lfree, rfree /* free space in L and R */;
-
-    Sh = PATH_H_PBUFFER (tb->tb_path, h); 
-    Fh = PATH_H_PPARENT (tb->tb_path, h); 
-
-    /* using tb->insert_size[h], which is negative in this case,
-       create_virtual_node calculates: new_nr_item = number of items node
-       would have if operation is performed without balancing (new_nr_item); */
-    create_virtual_node (tb, h);
-
-    if ( ! Fh ) {
-	/* S[h] is the root. */
-	if ( vn->vn_nr_item > 0 ) {
-	    set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-	    return NO_BALANCING_NEEDED; /* no balancing for higher levels needed */
-	}
-	/* new_nr_item == 0.
-	 * Current root will be deleted resulting in
-	 * decrementing the tree height. */
-	set_parameters (tb, h, 0, 0, 0, NULL, -1, -1);
-	return CARRY_ON;
-    }
-    
-    if ( (n_ret_value = get_parents(tb,h)) != CARRY_ON )
-	return n_ret_value;
-    
-    /* get free space of neighbors */
-    rfree = get_rfree (tb, h);
-    lfree = get_lfree (tb, h);
-    
-    /* determine maximal number of items we can fit into neighbors */
-
-    check_left (tb, h, lfree);
-    check_right (tb, h, rfree);
-    
-    if ( vn->vn_nr_item >= MIN_NR_KEY(Sh) ) {
-	/* Balance condition for the internal node is valid. In this case we
-	 * balance only if it leads to better packing. */
-	if ( vn->vn_nr_item == MIN_NR_KEY(Sh) ) {
-	    /* Here we join S[h] with one of its neighbors, which is
-	     * impossible with greater values of new_nr_item. */
-	    if ( tb->lnum[h] >= vn->vn_nr_item + 1 ) {
-		/* All contents of S[h] can be moved to L[h]. */
-		int n;
-		int order_L;
-		
-		order_L = ((n=PATH_H_B_ITEM_ORDER(tb->tb_path, h))==0) ? B_NR_ITEMS(tb->FL[h]) : n - 1;
-		n = get_dc_child_size (B_N_CHILD(tb->FL[h],order_L)) / (DC_SIZE + KEY_SIZE);
-		set_parameters (tb, h, -n-1, 0, 0, NULL, -1, -1);
+	struct virtual_node *vn = tb->tb_vn;
+
+	/* Sh is the node whose balance is currently being checked,
+	   and Fh is its father.  */
+	struct buffer_head *Sh, *Fh;
+	int n_ret_value;
+	int lfree, rfree /* free space in L and R */ ;
+
+	Sh = PATH_H_PBUFFER(tb->tb_path, h);
+	Fh = PATH_H_PPARENT(tb->tb_path, h);
+
+	/* using tb->insert_size[h], which is negative in this case,
+	   create_virtual_node calculates: new_nr_item = number of items node
+	   would have if operation is performed without balancing (new_nr_item); */
+	create_virtual_node(tb, h);
+
+	if (!Fh) {
+		/* S[h] is the root. */
+		if (vn->vn_nr_item > 0) {
+			set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+			return NO_BALANCING_NEEDED;	/* no balancing for higher levels needed */
+		}
+		/* new_nr_item == 0.
+		 * Current root will be deleted resulting in
+		 * decrementing the tree height. */
+		set_parameters(tb, h, 0, 0, 0, NULL, -1, -1);
 		return CARRY_ON;
-	    }
-	    
-	    if ( tb->rnum[h] >= vn->vn_nr_item + 1 ) {
-		/* All contents of S[h] can be moved to R[h]. */
+	}
+
+	if ((n_ret_value = get_parents(tb, h)) != CARRY_ON)
+		return n_ret_value;
+
+	/* get free space of neighbors */
+	rfree = get_rfree(tb, h);
+	lfree = get_lfree(tb, h);
+
+	/* determine maximal number of items we can fit into neighbors */
+
+	check_left(tb, h, lfree);
+	check_right(tb, h, rfree);
+
+	if (vn->vn_nr_item >= MIN_NR_KEY(Sh)) {
+		/* Balance condition for the internal node is valid. In this case we
+		 * balance only if it leads to better packing. */
+		if (vn->vn_nr_item == MIN_NR_KEY(Sh)) {
+			/* Here we join S[h] with one of its neighbors, which is
+			 * impossible with greater values of new_nr_item. */
+			if (tb->lnum[h] >= vn->vn_nr_item + 1) {
+				/* All contents of S[h] can be moved to L[h]. */
+				int n;
+				int order_L;
+
+				order_L =
+				    ((n =
+				      PATH_H_B_ITEM_ORDER(tb->tb_path,
+							  h)) ==
+				     0) ? B_NR_ITEMS(tb->FL[h]) : n - 1;
+				n = get_dc_child_size(B_N_CHILD
+						      (tb->FL[h],
+						       order_L)) / (DC_SIZE +
+								    KEY_SIZE);
+				set_parameters(tb, h, -n - 1, 0, 0, NULL, -1,
+					       -1);
+				return CARRY_ON;
+			}
+
+			if (tb->rnum[h] >= vn->vn_nr_item + 1) {
+				/* All contents of S[h] can be moved to R[h]. */
+				int n;
+				int order_R;
+
+				order_R =
+				    ((n =
+				      PATH_H_B_ITEM_ORDER(tb->tb_path,
+							  h)) ==
+				     B_NR_ITEMS(Fh)) ? 0 : n + 1;
+				n = get_dc_child_size(B_N_CHILD
+						      (tb->FR[h],
+						       order_R)) / (DC_SIZE +
+								    KEY_SIZE);
+				set_parameters(tb, h, 0, -n - 1, 0, NULL, -1,
+					       -1);
+				return CARRY_ON;
+			}
+		}
+
+		if (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1) {
+			/* All contents of S[h] can be moved to the neighbors (L[h] &
+			   R[h]). */
+			int to_r;
+
+			to_r =
+			    ((MAX_NR_KEY(Sh) << 1) + 2 - tb->lnum[h] -
+			     tb->rnum[h] + vn->vn_nr_item + 1) / 2 -
+			    (MAX_NR_KEY(Sh) + 1 - tb->rnum[h]);
+			set_parameters(tb, h, vn->vn_nr_item + 1 - to_r, to_r,
+				       0, NULL, -1, -1);
+			return CARRY_ON;
+		}
+
+		/* Balancing does not lead to better packing. */
+		set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+		return NO_BALANCING_NEEDED;
+	}
+
+	/* Current node contain insufficient number of items. Balancing is
+	   required.  Check whether we can merge S[h] with left neighbor. */
+	if (tb->lnum[h] >= vn->vn_nr_item + 1)
+		if (is_left_neighbor_in_cache(tb, h)
+		    || tb->rnum[h] < vn->vn_nr_item + 1 || !tb->FR[h]) {
+			int n;
+			int order_L;
+
+			order_L =
+			    ((n =
+			      PATH_H_B_ITEM_ORDER(tb->tb_path,
+						  h)) ==
+			     0) ? B_NR_ITEMS(tb->FL[h]) : n - 1;
+			n = get_dc_child_size(B_N_CHILD(tb->FL[h], order_L)) /
+			    (DC_SIZE + KEY_SIZE);
+			set_parameters(tb, h, -n - 1, 0, 0, NULL, -1, -1);
+			return CARRY_ON;
+		}
+
+	/* Check whether we can merge S[h] with right neighbor. */
+	if (tb->rnum[h] >= vn->vn_nr_item + 1) {
 		int n;
 		int order_R;
-		
-		order_R = ((n=PATH_H_B_ITEM_ORDER(tb->tb_path, h))==B_NR_ITEMS(Fh)) ? 0 : n + 1;
-		n = get_dc_child_size (B_N_CHILD(tb->FR[h],order_R)) / (DC_SIZE + KEY_SIZE);
-		set_parameters (tb, h, 0, -n-1, 0, NULL, -1, -1);
-		return CARRY_ON;   
-	    }
+
+		order_R =
+		    ((n =
+		      PATH_H_B_ITEM_ORDER(tb->tb_path,
+					  h)) == B_NR_ITEMS(Fh)) ? 0 : (n + 1);
+		n = get_dc_child_size(B_N_CHILD(tb->FR[h], order_R)) /
+		    (DC_SIZE + KEY_SIZE);
+		set_parameters(tb, h, 0, -n - 1, 0, NULL, -1, -1);
+		return CARRY_ON;
 	}
-	
+
+	/* All contents of S[h] can be moved to the neighbors (L[h] & R[h]). */
 	if (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1) {
-	    /* All contents of S[h] can be moved to the neighbors (L[h] &
-               R[h]). */
-	    int to_r;
-	    
-	    to_r = ((MAX_NR_KEY(Sh)<<1)+2-tb->lnum[h]-tb->rnum[h]+vn->vn_nr_item+1)/2 - 
-		(MAX_NR_KEY(Sh) + 1 - tb->rnum[h]);
-	    set_parameters (tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL, -1, -1);
-	    return CARRY_ON;
+		int to_r;
+
+		to_r =
+		    ((MAX_NR_KEY(Sh) << 1) + 2 - tb->lnum[h] - tb->rnum[h] +
+		     vn->vn_nr_item + 1) / 2 - (MAX_NR_KEY(Sh) + 1 -
+						tb->rnum[h]);
+		set_parameters(tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL,
+			       -1, -1);
+		return CARRY_ON;
 	}
-	
-	/* Balancing does not lead to better packing. */
-	set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-	return NO_BALANCING_NEEDED;
-    }
-    
-    /* Current node contain insufficient number of items. Balancing is
-       required.  Check whether we can merge S[h] with left neighbor. */
-    if (tb->lnum[h] >= vn->vn_nr_item + 1)
-	if (is_left_neighbor_in_cache (tb,h) || tb->rnum[h] < vn->vn_nr_item + 1 || !tb->FR[h]) {
-	    int n;
-	    int order_L;
-	    
-	    order_L = ((n=PATH_H_B_ITEM_ORDER(tb->tb_path, h))==0) ? B_NR_ITEMS(tb->FL[h]) : n - 1;
-	    n = get_dc_child_size (B_N_CHILD(tb->FL[h],order_L)) / (DC_SIZE + KEY_SIZE);
-	    set_parameters (tb, h, -n-1, 0, 0, NULL, -1, -1);
-	    return CARRY_ON;
+
+	/* For internal nodes try to borrow item from a neighbor */
+	/* Borrow one or two items from caching neighbor */
+	if (is_left_neighbor_in_cache(tb, h) || !tb->FR[h]) {
+		int from_l;
+
+		from_l =
+		    (MAX_NR_KEY(Sh) + 1 - tb->lnum[h] + vn->vn_nr_item +
+		     1) / 2 - (vn->vn_nr_item + 1);
+		set_parameters(tb, h, -from_l, 0, 1, NULL, -1, -1);
+		return CARRY_ON;
 	}
-    
-    /* Check whether we can merge S[h] with right neighbor. */
-    if (tb->rnum[h] >= vn->vn_nr_item + 1) {
-	int n;
-	int order_R;
-	
-	order_R = ((n=PATH_H_B_ITEM_ORDER(tb->tb_path, h))==B_NR_ITEMS(Fh)) ? 0 : (n + 1);
-	n = get_dc_child_size (B_N_CHILD(tb->FR[h],order_R)) / (DC_SIZE + KEY_SIZE);
-	set_parameters (tb, h, 0, -n-1, 0, NULL, -1, -1);
-	return CARRY_ON;   
-    }
-    
-    /* All contents of S[h] can be moved to the neighbors (L[h] & R[h]). */
-    if (tb->rnum[h] + tb->lnum[h] >= vn->vn_nr_item + 1) {
-	int to_r;
-	
-	to_r = ((MAX_NR_KEY(Sh)<<1)+2-tb->lnum[h]-tb->rnum[h]+vn->vn_nr_item+1)/2 - 
-	    (MAX_NR_KEY(Sh) + 1 - tb->rnum[h]);
-	set_parameters (tb, h, vn->vn_nr_item + 1 - to_r, to_r, 0, NULL, -1, -1);
-	return CARRY_ON;
-    }
-    
-    /* For internal nodes try to borrow item from a neighbor */
-    /* Borrow one or two items from caching neighbor */
-    if (is_left_neighbor_in_cache (tb,h) || !tb->FR[h]) {
-	int from_l;
-		
-	from_l = (MAX_NR_KEY(Sh) + 1 - tb->lnum[h] + vn->vn_nr_item + 1) / 2 -  (vn->vn_nr_item + 1);
-	set_parameters (tb, h, -from_l, 0, 1, NULL, -1, -1);
+
+	set_parameters(tb, h, 0,
+		       -((MAX_NR_KEY(Sh) + 1 - tb->rnum[h] + vn->vn_nr_item +
+			  1) / 2 - (vn->vn_nr_item + 1)), 1, NULL, -1, -1);
 	return CARRY_ON;
-    }
-    
-    set_parameters (tb, h, 0, -((MAX_NR_KEY(Sh)+1-tb->rnum[h]+vn->vn_nr_item+1)/2-(vn->vn_nr_item+1)), 1, 
-		    NULL, -1, -1);
-    return CARRY_ON;
 }
 
-
 /* Check whether current node S[h] is balanced when Decreasing its size by
  * Deleting or Truncating for LEAF node of internal tree.
  * Calculate parameters for balancing for current level h.
@@ -1914,72 +2063,69 @@ static int dc_check_balance_internal (struct tree_balance * tb, int h)
  *	       -1 - no balancing for higher levels needed;
  *	       -2 - no disk space.
  */
-static int dc_check_balance_leaf (struct tree_balance * tb, int h)
+static int dc_check_balance_leaf(struct tree_balance *tb, int h)
 {
-    struct virtual_node * vn = tb->tb_vn;
-
-    /* the maximal item size */
-    int n_ret_value;
-    /* F0 is the parent of the node whose balance is currently being checked */
-    struct buffer_head * F0;
-    int lfree, rfree /* free space in L and R */;
-    
-    F0 = PATH_H_PPARENT (tb->tb_path, 0);
-
-    if ( ! F0 ) {
-	/* S[0] is the root now. */
-	set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-	return NO_BALANCING_NEEDED;
-    }
-    
-    if ( (n_ret_value = get_parents(tb,h)) != CARRY_ON )
-	return n_ret_value;
-    
-    /* get free space of neighbors */
-    rfree = get_rfree (tb, h);
-    lfree = get_lfree (tb, h);		
-
-    create_virtual_node (tb, h);
-    
-    /* if 3 leaves can be merge to one, set parameters and return */
-    if (are_leaves_removable (tb, lfree, rfree))
-	return CARRY_ON;
+	struct virtual_node *vn = tb->tb_vn;
+
+	/* the maximal item size */
+	int n_ret_value;
+	/* F0 is the parent of the node whose balance is currently being checked */
+	struct buffer_head *F0;
+	int lfree, rfree /* free space in L and R */ ;
 
-    /* determine maximal number of items we can shift to the left/right
-       neighbor and the maximal number of bytes that can flow to the
-       left/right neighbor from the left/right most liquid item that cannot be
-       shifted from S[0] entirely */
-    check_left (tb, h, lfree);
-    check_right (tb, h, rfree);   
-
-    /* check whether we can merge S with left neighbor. */
-    if (tb->lnum[0] >= vn->vn_nr_item && tb->lbytes == -1)
-	if (is_left_neighbor_in_cache (tb,h) ||
-	    ((tb->rnum[0] - ((tb->rbytes == -1) ? 0 : 1)) < vn->vn_nr_item) || /* S can not be merged with R */
-	    !tb->FR[h]) {
-	    /* set parameter to merge S[0] with its left neighbor */
-	    set_parameters (tb, h, -1, 0, 0, NULL, -1, -1);
-	    return CARRY_ON;
+	F0 = PATH_H_PPARENT(tb->tb_path, 0);
+
+	if (!F0) {
+		/* S[0] is the root now. */
+		set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+		return NO_BALANCING_NEEDED;
 	}
 
-    /* check whether we can merge S[0] with right neighbor. */
-    if (tb->rnum[0] >= vn->vn_nr_item && tb->rbytes == -1) {
-	set_parameters (tb, h, 0, -1, 0, NULL, -1, -1);
-	return CARRY_ON;
-    }
-    
-    /* All contents of S[0] can be moved to the neighbors (L[0] & R[0]). Set
-       parameters and return */
-    if (is_leaf_removable (tb))
-	return CARRY_ON;
-    
-    /* Balancing is not required. */
-    tb->s0num = vn->vn_nr_item;
-    set_parameters (tb, h, 0, 0, 1, NULL, -1, -1);
-    return NO_BALANCING_NEEDED;
-}
+	if ((n_ret_value = get_parents(tb, h)) != CARRY_ON)
+		return n_ret_value;
+
+	/* get free space of neighbors */
+	rfree = get_rfree(tb, h);
+	lfree = get_lfree(tb, h);
 
+	create_virtual_node(tb, h);
 
+	/* if 3 leaves can be merge to one, set parameters and return */
+	if (are_leaves_removable(tb, lfree, rfree))
+		return CARRY_ON;
+
+	/* determine maximal number of items we can shift to the left/right
+	   neighbor and the maximal number of bytes that can flow to the
+	   left/right neighbor from the left/right most liquid item that cannot be
+	   shifted from S[0] entirely */
+	check_left(tb, h, lfree);
+	check_right(tb, h, rfree);
+
+	/* check whether we can merge S with left neighbor. */
+	if (tb->lnum[0] >= vn->vn_nr_item && tb->lbytes == -1)
+		if (is_left_neighbor_in_cache(tb, h) || ((tb->rnum[0] - ((tb->rbytes == -1) ? 0 : 1)) < vn->vn_nr_item) ||	/* S can not be merged with R */
+		    !tb->FR[h]) {
+			/* set parameter to merge S[0] with its left neighbor */
+			set_parameters(tb, h, -1, 0, 0, NULL, -1, -1);
+			return CARRY_ON;
+		}
+
+	/* check whether we can merge S[0] with right neighbor. */
+	if (tb->rnum[0] >= vn->vn_nr_item && tb->rbytes == -1) {
+		set_parameters(tb, h, 0, -1, 0, NULL, -1, -1);
+		return CARRY_ON;
+	}
+
+	/* All contents of S[0] can be moved to the neighbors (L[0] & R[0]). Set
+	   parameters and return */
+	if (is_leaf_removable(tb))
+		return CARRY_ON;
+
+	/* Balancing is not required. */
+	tb->s0num = vn->vn_nr_item;
+	set_parameters(tb, h, 0, 0, 1, NULL, -1, -1);
+	return NO_BALANCING_NEEDED;
+}
 
 /* Check whether current node S[h] is balanced when Decreasing its size by
  * Deleting or Cutting.
@@ -1994,16 +2140,14 @@ static int dc_check_balance_leaf (struct tree_balance * tb, int h)
  *	       -1 - no balancing for higher levels needed;
  *	       -2 - no disk space.
  */
-static int dc_check_balance (struct tree_balance * tb, int h)
+static int dc_check_balance(struct tree_balance *tb, int h)
 {
-    if ( h )
-	return dc_check_balance_internal (tb, h);
-    else
-	return dc_check_balance_leaf (tb, h);
+	if (h)
+		return dc_check_balance_internal(tb, h);
+	else
+		return dc_check_balance_leaf(tb, h);
 }
 
-
-
 /* Check whether current node S[h] is balanced.
  * Calculate parameters for balancing for current level h.
  * Parameters:
@@ -2022,67 +2166,72 @@ static int dc_check_balance (struct tree_balance * tb, int h)
  *	       -1 - no balancing for higher levels needed;
  *	       -2 - no disk space.
  */
-static int check_balance (int mode, struct tree_balance * tb,
-			  int h, int inum, int pos_in_item,
-			  struct item_head * ins_ih)
+static int check_balance(int mode, struct tree_balance *tb,
+			 int h, int inum, int pos_in_item,
+			 struct item_head *ins_ih)
 {
-    struct virtual_node * vn;
-    
-    vn = tb->tb_vn = (struct virtual_node *)(tb->vn_buf);// + ROUND_UP(SB_BMAP_NR (tb->tb_fs) * 2 / 8 + 1, 4));
-    vn->vn_free_ptr = (char *)(tb->tb_vn + 1);
-    vn->vn_mode = mode;
-    vn->vn_affected_item_num = inum;
-    vn->vn_pos_in_item = pos_in_item;
-    vn->vn_ins_ih = ins_ih;
-    
-    if ( tb->insert_size[h] > 0 )
-	/* Calculate balance parameters when size of node is increasing. */
-	return ip_check_balance (tb, h);
-    
-    /* Calculate balance parameters when  size of node is decreasing. */
-    return dc_check_balance (tb, h);
-}
+	struct virtual_node *vn;
 
+	vn = tb->tb_vn = (struct virtual_node *)(tb->vn_buf);	// + ROUND_UP(SB_BMAP_NR (tb->tb_fs) * 2 / 8 + 1, 4));
+	vn->vn_free_ptr = (char *)(tb->tb_vn + 1);
+	vn->vn_mode = mode;
+	vn->vn_affected_item_num = inum;
+	vn->vn_pos_in_item = pos_in_item;
+	vn->vn_ins_ih = ins_ih;
+
+	if (tb->insert_size[h] > 0)
+		/* Calculate balance parameters when size of node is increasing. */
+		return ip_check_balance(tb, h);
+
+	/* Calculate balance parameters when  size of node is decreasing. */
+	return dc_check_balance(tb, h);
+}
 
 /* Check whether parent at the path is the really parent of the current node.*/
-static void get_direct_parent (struct tree_balance * p_s_tb, int n_h)
+static void get_direct_parent(struct tree_balance *p_s_tb, int n_h)
 {
-    struct buffer_head  * p_s_bh;
-    struct reiserfs_path         * p_s_path      = p_s_tb->tb_path;
-    int                   n_position,
-	n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
-    
-    /* We are in the root or in the new root. */
-    if ( n_path_offset <= FIRST_PATH_ELEMENT_OFFSET ) {
-	struct reiserfs_super_block * sb;
-	
-	if ( n_path_offset < FIRST_PATH_ELEMENT_OFFSET - 1 )
-	    reiserfs_panic ("PAP-8260: get_direct_parent: illegal offset in the path");
-
-	sb = p_s_tb->tb_fs->fs_ondisk_sb;
-	if ( PATH_OFFSET_PBUFFER(p_s_path, FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
-	     get_sb_root_block (sb) ) {
-	    /* Root is not changed. */
-	    PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1) = NULL;
-	    PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1) = 0;
-	    return;
+	struct buffer_head *p_s_bh;
+	struct reiserfs_path *p_s_path = p_s_tb->tb_path;
+	int n_position,
+	    n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h);
+
+	/* We are in the root or in the new root. */
+	if (n_path_offset <= FIRST_PATH_ELEMENT_OFFSET) {
+		struct reiserfs_super_block *sb;
+
+		if (n_path_offset < FIRST_PATH_ELEMENT_OFFSET - 1)
+			reiserfs_panic
+			    ("PAP-8260: get_direct_parent: illegal offset in the path");
+
+		sb = p_s_tb->tb_fs->fs_ondisk_sb;
+		if (PATH_OFFSET_PBUFFER(p_s_path, FIRST_PATH_ELEMENT_OFFSET)->
+		    b_blocknr == get_sb_root_block(sb)) {
+			/* Root is not changed. */
+			PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1) = NULL;
+			PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1) = 0;
+			return;
+		}
+		reiserfs_panic("get_direct_parent: root changed");
 	}
-	reiserfs_panic ("get_direct_parent: root changed");
-    }
-    
-    if ( ! B_IS_IN_TREE(p_s_bh = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1)) )
-	reiserfs_panic ("get_direct_parent: parent in the path is not in the tree");
-    
-    if ( (n_position = PATH_OFFSET_POSITION(p_s_path, n_path_offset - 1)) > B_NR_ITEMS(p_s_bh) )
-	reiserfs_panic ("get_direct_parent: wrong position in the path");
-    
-    if ( get_dc_child_blocknr (B_N_CHILD(p_s_bh, n_position)) != PATH_OFFSET_PBUFFER(p_s_path, n_path_offset)->b_blocknr )
-	reiserfs_panic ("get_direct_parent: parent in the path is not parent "
-			"of the current node in the tree");
-    
-    return ; /* Parent in the path is unlocked and really parent of the current node.  */
-}
 
+	if (!B_IS_IN_TREE
+	    (p_s_bh = PATH_OFFSET_PBUFFER(p_s_path, n_path_offset - 1)))
+		reiserfs_panic
+		    ("get_direct_parent: parent in the path is not in the tree");
+
+	if ((n_position =
+	     PATH_OFFSET_POSITION(p_s_path,
+				  n_path_offset - 1)) > B_NR_ITEMS(p_s_bh))
+		reiserfs_panic("get_direct_parent: wrong position in the path");
+
+	if (get_dc_child_blocknr(B_N_CHILD(p_s_bh, n_position)) !=
+	    PATH_OFFSET_PBUFFER(p_s_path, n_path_offset)->b_blocknr)
+		reiserfs_panic
+		    ("get_direct_parent: parent in the path is not parent "
+		     "of the current node in the tree");
+
+	return;			/* Parent in the path is unlocked and really parent of the current node.  */
+}
 
 /* Using lnum[n_h] and rnum[n_h] we should determine what neighbors
  * of S[n_h] we
@@ -2090,80 +2239,84 @@ static void get_direct_parent (struct tree_balance * p_s_tb, int n_h)
  * Returns:	SCHEDULE_OCCURRED - schedule occured while the function worked;
  *	        CARRY_ON - schedule didn't occur while the function worked;
  */
-static int get_neighbors(struct tree_balance * p_s_tb, int n_h)
+static int get_neighbors(struct tree_balance *p_s_tb, int n_h)
 {
-    int		 	n_child_position,
-	n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
-    unsigned long		n_son_number;
-    reiserfs_filsys_t * fs = p_s_tb->tb_fs;
-    struct buffer_head  * p_s_bh;
-    /*struct virtual_node * vn = p_s_tb->tb_vn;*/
-    
-    if ( p_s_tb->lnum[n_h] ) {
-	/* We need left neighbor to balance S[n_h]. */
-	p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
-	
-	n_child_position = ( p_s_bh == p_s_tb->FL[n_h] ) ? p_s_tb->lkey[n_h] :
-	    get_blkh_nr_items (B_BLK_HEAD(p_s_tb->FL[n_h]));
-	n_son_number = get_dc_child_blocknr (B_N_CHILD (p_s_tb->FL[n_h], n_child_position));
-	p_s_bh = bread(fs->fs_dev, n_son_number, fs->fs_blocksize);
-	if (!p_s_bh)
-	    return IO_ERROR;
-	brelse (p_s_tb->L[n_h]);
-	p_s_tb->L[n_h] = p_s_bh;
-    }
-
-    if ( p_s_tb->rnum[n_h] ) { /* We need right neighbor to balance S[n_path_offset]. */
-	p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
-	n_child_position = ( p_s_bh == p_s_tb->FR[n_h] ) ? p_s_tb->rkey[n_h] + 1 : 0;
-	n_son_number = get_dc_child_blocknr (B_N_CHILD (p_s_tb->FR[n_h], n_child_position));
-	p_s_bh = bread(fs->fs_dev, n_son_number, fs->fs_blocksize);
-	if (!p_s_bh)
-	    return IO_ERROR;
-
-	brelse (p_s_tb->R[n_h]);
-	p_s_tb->R[n_h] = p_s_bh;
-    }
-    return CARRY_ON;
+	int n_child_position,
+	    n_path_offset = PATH_H_PATH_OFFSET(p_s_tb->tb_path, n_h + 1);
+	unsigned long n_son_number;
+	reiserfs_filsys_t *fs = p_s_tb->tb_fs;
+	struct buffer_head *p_s_bh;
+	/*struct virtual_node * vn = p_s_tb->tb_vn; */
+
+	if (p_s_tb->lnum[n_h]) {
+		/* We need left neighbor to balance S[n_h]. */
+		p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
+
+		n_child_position =
+		    (p_s_bh ==
+		     p_s_tb->FL[n_h]) ? p_s_tb->
+		    lkey[n_h] : get_blkh_nr_items(B_BLK_HEAD(p_s_tb->FL[n_h]));
+		n_son_number =
+		    get_dc_child_blocknr(B_N_CHILD
+					 (p_s_tb->FL[n_h], n_child_position));
+		p_s_bh = bread(fs->fs_dev, n_son_number, fs->fs_blocksize);
+		if (!p_s_bh)
+			return IO_ERROR;
+		brelse(p_s_tb->L[n_h]);
+		p_s_tb->L[n_h] = p_s_bh;
+	}
+
+	if (p_s_tb->rnum[n_h]) {	/* We need right neighbor to balance S[n_path_offset]. */
+		p_s_bh = PATH_OFFSET_PBUFFER(p_s_tb->tb_path, n_path_offset);
+		n_child_position =
+		    (p_s_bh == p_s_tb->FR[n_h]) ? p_s_tb->rkey[n_h] + 1 : 0;
+		n_son_number =
+		    get_dc_child_blocknr(B_N_CHILD
+					 (p_s_tb->FR[n_h], n_child_position));
+		p_s_bh = bread(fs->fs_dev, n_son_number, fs->fs_blocksize);
+		if (!p_s_bh)
+			return IO_ERROR;
+
+		brelse(p_s_tb->R[n_h]);
+		p_s_tb->R[n_h] = p_s_bh;
+	}
+	return CARRY_ON;
 }
 
 #if 0
 void * reiserfs_kmalloc (size_t size, int flags, struct super_block * s)
 {
-  void * vp;
+	void * vp;
 
-  vp = getmem (size);
-  return vp;
+	vp = getmem (size);
+	return vp;
 }
 
 void reiserfs_kfree (/*const */void * vp, size_t size, struct super_block * s)
 {
-  freemem (vp);
-
+	freemem (vp);
 
-  kfree (vp);
+	kfree (vp);
   
-  s->u.reiserfs_sb.s_kmallocs -= size;
-  if (s->u.reiserfs_sb.s_kmallocs < 0)
-    reiserfs_warning ("vs-8302: reiserfs_kfree: allocated memory %d\n", s->u.reiserfs_sb.s_kmallocs);
+	s->u.reiserfs_sb.s_kmallocs -= size;
+	if (s->u.reiserfs_sb.s_kmallocs < 0)
+		reiserfs_warning("vs-8302: reiserfs_kfree: allocated memory %d\n",
+				 s->u.reiserfs_sb.s_kmallocs);
 
-}
 #endif
 
 
-static int get_mem_for_virtual_node (struct tree_balance * tb)
+static int get_mem_for_virtual_node(struct tree_balance *tb)
 {
-    tb->vn_buf = getmem (tb->tb_fs->fs_blocksize);
-    return CARRY_ON;
+	tb->vn_buf = getmem(tb->tb_fs->fs_blocksize);
+	return CARRY_ON;
 }
 
-
-static void free_virtual_node_mem (struct tree_balance * tb)
+static void free_virtual_node_mem(struct tree_balance *tb)
 {
-    freemem (tb->vn_buf);
+	freemem(tb->vn_buf);
 }
 
-
 /* Prepare for balancing, that is
  *	get all necessary parents, and neighbors;
  *	analyze what and where should be moved;
@@ -2192,115 +2345,106 @@ static void free_virtual_node_mem (struct tree_balance * tb)
  *             -1 - if no_disk_space 
  */
 
-
-int fix_nodes (int n_op_mode, struct tree_balance * p_s_tb,
-	       struct item_head * p_s_ins_ih)
+int fix_nodes(int n_op_mode, struct tree_balance *p_s_tb,
+	      struct item_head *p_s_ins_ih)
 {
-    int n_pos_in_item = p_s_tb->tb_path->pos_in_item;
-    int	n_ret_value,
-    	n_h,
-    	n_item_num = get_item_pos (p_s_tb->tb_path);
-    /*    struct buffer_head  * p_s_tbS0 = get_bh (p_s_tb->tb_path);*/
-    /*    struct item_head * ih = get_ih (p_s_tb->tb_path);*/
-
-
-    if (get_mem_for_virtual_node (p_s_tb) != CARRY_ON)
-	reiserfs_panic ("fix_nodes: no memory for virtual node");
-
-    /* Starting from the leaf level; for all levels n_h of the tree. */
-    for ( n_h = 0; n_h < MAX_HEIGHT && p_s_tb->insert_size[n_h]; n_h++ ) { 
-	get_direct_parent(p_s_tb, n_h);
-
-	if ( (n_ret_value = check_balance (/*th,*/ n_op_mode, p_s_tb, n_h, n_item_num,
-					   n_pos_in_item, p_s_ins_ih)) != CARRY_ON ) {
-	    if ( n_ret_value == NO_BALANCING_NEEDED ) {
-		/* No balancing for higher levels needed. */
-		if ( (n_ret_value = get_neighbors(p_s_tb, n_h)) != CARRY_ON ) {
-		    return n_ret_value;
+	int n_pos_in_item = p_s_tb->tb_path->pos_in_item;
+	int n_ret_value, n_h, n_item_num = get_item_pos(p_s_tb->tb_path);
+	/*    struct buffer_head  * p_s_tbS0 = get_bh (p_s_tb->tb_path); */
+	/*    struct item_head * ih = get_ih (p_s_tb->tb_path); */
+
+	if (get_mem_for_virtual_node(p_s_tb) != CARRY_ON)
+		reiserfs_panic("fix_nodes: no memory for virtual node");
+
+	/* Starting from the leaf level; for all levels n_h of the tree. */
+	for (n_h = 0; n_h < MAX_HEIGHT && p_s_tb->insert_size[n_h]; n_h++) {
+		get_direct_parent(p_s_tb, n_h);
+
+		if ((n_ret_value =
+		     check_balance( /*th, */ n_op_mode, p_s_tb, n_h, n_item_num,
+				   n_pos_in_item, p_s_ins_ih)) != CARRY_ON) {
+			if (n_ret_value == NO_BALANCING_NEEDED) {
+				/* No balancing for higher levels needed. */
+				if ((n_ret_value =
+				     get_neighbors(p_s_tb, n_h)) != CARRY_ON) {
+					return n_ret_value;
+				}
+				if (n_h != MAX_HEIGHT - 1)
+					p_s_tb->insert_size[n_h + 1] = 0;
+				/* ok, analysis and resource gathering are complete */
+				break;
+			}
+
+			return n_ret_value;
 		}
-		if ( n_h != MAX_HEIGHT - 1 )  
-		    p_s_tb->insert_size[n_h + 1] = 0;
-		/* ok, analysis and resource gathering are complete */
-		break;
-	    }
 
-	    return n_ret_value;
-	}
+		if ((n_ret_value = get_neighbors(p_s_tb, n_h)) != CARRY_ON) {
+			return n_ret_value;
+		}
 
-	if ( (n_ret_value = get_neighbors(p_s_tb, n_h)) != CARRY_ON ) {
-	    return n_ret_value;
-	}
+		if ((n_ret_value =
+		     get_empty_nodes( /*th, */ p_s_tb, n_h)) != CARRY_ON) {
+			return n_ret_value;	/* No disk space */
+		}
 
-	if ( (n_ret_value = get_empty_nodes(/*th,*/ p_s_tb, n_h)) != CARRY_ON ) {
-	    return n_ret_value; /* No disk space */
+		if (!PATH_H_PBUFFER(p_s_tb->tb_path, n_h)) {
+			/* We have a positive insert size but no nodes exist on this
+			   level, this means that we are creating a new root. */
+			if (n_h < MAX_HEIGHT - 1)
+				p_s_tb->insert_size[n_h + 1] = 0;
+		} else if (!PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1)) {
+			if (p_s_tb->blknum[n_h] > 1) {
+				/* The tree needs to be grown, so this node S[n_h] which
+				   is the root node is split into two nodes, and a new
+				   node (S[n_h+1]) will be created to become the root
+				   node.  */
+				p_s_tb->insert_size[n_h + 1] =
+				    (DC_SIZE +
+				     KEY_SIZE) * (p_s_tb->blknum[n_h] - 1) +
+				    DC_SIZE;
+			} else if (n_h < MAX_HEIGHT - 1)
+				p_s_tb->insert_size[n_h + 1] = 0;
+		} else
+			p_s_tb->insert_size[n_h + 1] =
+			    (DC_SIZE + KEY_SIZE) * (p_s_tb->blknum[n_h] - 1);
 	}
-    
-	if ( ! PATH_H_PBUFFER(p_s_tb->tb_path, n_h) ) {
-	    /* We have a positive insert size but no nodes exist on this
-	       level, this means that we are creating a new root. */
-	    if ( n_h < MAX_HEIGHT - 1 )
-		p_s_tb->insert_size[n_h + 1] = 0;
-	}
-	else
-	    if ( ! PATH_H_PBUFFER(p_s_tb->tb_path, n_h + 1) ) {
-		if ( p_s_tb->blknum[n_h] > 1 ) {
-		    /* The tree needs to be grown, so this node S[n_h] which
-		       is the root node is split into two nodes, and a new
-		       node (S[n_h+1]) will be created to become the root
-		       node.  */
-		    p_s_tb->insert_size[n_h + 1] = (DC_SIZE + KEY_SIZE) * (p_s_tb->blknum[n_h] - 1) + DC_SIZE;
-		}
-		else
-		    if ( n_h < MAX_HEIGHT - 1 )
-			p_s_tb->insert_size[n_h + 1] = 0;
-	    }
-	    else
-		p_s_tb->insert_size[n_h + 1] = (DC_SIZE + KEY_SIZE) * (p_s_tb->blknum[n_h] - 1);
-    }
-
-    return CARRY_ON; /* go ahead and balance */
-}
 
+	return CARRY_ON;	/* go ahead and balance */
+}
 
-void unfix_nodes (struct tree_balance * p_s_tb)
+void unfix_nodes(struct tree_balance *p_s_tb)
 {
-    struct reiserfs_path *p_s_path = p_s_tb->tb_path;
-    int		n_counter;
-    //  int i, j;
-    //struct buffer_head * bh;
-
-    /* Release path buffers. */
-    pathrelse(p_s_path);
-
-
-    for ( n_counter = 0; n_counter < MAX_HEIGHT; n_counter++ ) {
-	/* Release fathers and neighbors. */
-	brelse(p_s_tb->L[n_counter]);
-	brelse(p_s_tb->R[n_counter]);
-	brelse(p_s_tb->FL[n_counter]);
-	brelse(p_s_tb->FR[n_counter]);
-	brelse(p_s_tb->CFL[n_counter]);
-	brelse(p_s_tb->CFR[n_counter]);
-    }
-
-    /* Could be optimized. Will be done by PAP someday */
-    for ( n_counter = 0; n_counter < MAX_FEB_SIZE; n_counter++ ) {
-	if ( p_s_tb->FEB[n_counter] ) {
-	    /* release what was not used */
-	    reiserfs_free_block(p_s_tb->tb_fs, p_s_tb->FEB[n_counter]->b_blocknr);
-
-	    bforget(p_s_tb->FEB[n_counter]);
-	    /* tree balance bitmap of bitmaps has bit set already */
+	struct reiserfs_path *p_s_path = p_s_tb->tb_path;
+	int n_counter;
+	//  int i, j;
+	//struct buffer_head * bh;
+
+	/* Release path buffers. */
+	pathrelse(p_s_path);
+
+	for (n_counter = 0; n_counter < MAX_HEIGHT; n_counter++) {
+		/* Release fathers and neighbors. */
+		brelse(p_s_tb->L[n_counter]);
+		brelse(p_s_tb->R[n_counter]);
+		brelse(p_s_tb->FL[n_counter]);
+		brelse(p_s_tb->FR[n_counter]);
+		brelse(p_s_tb->CFL[n_counter]);
+		brelse(p_s_tb->CFR[n_counter]);
 	}
-	/* release used as new nodes including a new root */
-	brelse (p_s_tb->used[n_counter]);
-    }
-
-    free_virtual_node_mem (p_s_tb);
-} 
-
-
-
 
+	/* Could be optimized. Will be done by PAP someday */
+	for (n_counter = 0; n_counter < MAX_FEB_SIZE; n_counter++) {
+		if (p_s_tb->FEB[n_counter]) {
+			/* release what was not used */
+			reiserfs_free_block(p_s_tb->tb_fs,
+					    p_s_tb->FEB[n_counter]->b_blocknr);
 
+			bforget(p_s_tb->FEB[n_counter]);
+			/* tree balance bitmap of bitmaps has bit set already */
+		}
+		/* release used as new nodes including a new root */
+		brelse(p_s_tb->used[n_counter]);
+	}
 
+	free_virtual_node_mem(p_s_tb);
+}
diff --git a/reiserfscore/hashes.c b/reiserfscore/hashes.c
index 6a08072..085fddf 100644
--- a/reiserfscore/hashes.c
+++ b/reiserfscore/hashes.c
@@ -24,8 +24,6 @@
 
 #include <asm/types.h>
 
-
-
 #define DELTA 0x9E3779B9
 #define FULLROUNDS 10		/* 32 is overkill, 16 is strong crypto */
 #define PARTROUNDS 6		/* 6 gets complete mixing */
@@ -55,113 +53,82 @@ typedef __u32 u32;
 		h1 += b1;						\
 	} while(0)
 
-
 u32 keyed_hash(const signed char *msg, int len)
 {
-	u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3}; 
+	u32 k[] = { 0x9464a485, 0x542e1a94, 0x3e846bff, 0xb75bcfc3 };
 
 	u32 h0 = k[0], h1 = k[1];
 	u32 a, b, c, d;
 	u32 pad;
 	int i;
- 
 
-	pad = (u32)len | ((u32)len << 8);
+	pad = (u32) len | ((u32) len << 8);
 	pad |= pad << 16;
 
-	while(len >= 16)
-	{
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
-		b = (u32)msg[ 4]      |
-		    (u32)msg[ 5] << 8 |
-		    (u32)msg[ 6] << 16|
-		    (u32)msg[ 7] << 24;
-		c = (u32)msg[ 8]      |
-		    (u32)msg[ 9] << 8 |
-		    (u32)msg[10] << 16|
-		    (u32)msg[11] << 24;
-		d = (u32)msg[12]      |
-		    (u32)msg[13] << 8 |
-		    (u32)msg[14] << 16|
-		    (u32)msg[15] << 24;
-		
+	while (len >= 16) {
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
+		b = (u32) msg[4] |
+		    (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
+		c = (u32) msg[8] |
+		    (u32) msg[9] << 8 |
+		    (u32) msg[10] << 16 | (u32) msg[11] << 24;
+		d = (u32) msg[12] |
+		    (u32) msg[13] << 8 |
+		    (u32) msg[14] << 16 | (u32) msg[15] << 24;
+
 		TEACORE(PARTROUNDS);
 
 		len -= 16;
 		msg += 16;
 	}
 
-	if (len >= 12)
-	{
+	if (len >= 12) {
 		if (len >= 16)
-		    *(int *)0 = 0;
-
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
-		b = (u32)msg[ 4]      |
-		    (u32)msg[ 5] << 8 |
-		    (u32)msg[ 6] << 16|
-		    (u32)msg[ 7] << 24;
-		c = (u32)msg[ 8]      |
-		    (u32)msg[ 9] << 8 |
-		    (u32)msg[10] << 16|
-		    (u32)msg[11] << 24;
+			*(int *)0 = 0;
+
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
+		b = (u32) msg[4] |
+		    (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
+		c = (u32) msg[8] |
+		    (u32) msg[9] << 8 |
+		    (u32) msg[10] << 16 | (u32) msg[11] << 24;
 
 		d = pad;
-		for(i = 12; i < len; i++)
-		{
+		for (i = 12; i < len; i++) {
 			d <<= 8;
 			d |= msg[i];
 		}
-	}
-	else if (len >= 8)
-	{
+	} else if (len >= 8) {
 		if (len >= 12)
-		    *(int *)0 = 0;
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
-		b = (u32)msg[ 4]      |
-		    (u32)msg[ 5] << 8 |
-		    (u32)msg[ 6] << 16|
-		    (u32)msg[ 7] << 24;
+			*(int *)0 = 0;
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
+		b = (u32) msg[4] |
+		    (u32) msg[5] << 8 | (u32) msg[6] << 16 | (u32) msg[7] << 24;
 
 		c = d = pad;
-		for(i = 8; i < len; i++)
-		{
+		for (i = 8; i < len; i++) {
 			c <<= 8;
 			c |= msg[i];
 		}
-	}
-	else if (len >= 4)
-	{
+	} else if (len >= 4) {
 		if (len >= 8)
-		    *(int *)0 = 0;
-		a = (u32)msg[ 0]      |
-		    (u32)msg[ 1] << 8 |
-		    (u32)msg[ 2] << 16|
-		    (u32)msg[ 3] << 24;
+			*(int *)0 = 0;
+		a = (u32) msg[0] |
+		    (u32) msg[1] << 8 | (u32) msg[2] << 16 | (u32) msg[3] << 24;
 
 		b = c = d = pad;
-		for(i = 4; i < len; i++)
-		{
+		for (i = 4; i < len; i++) {
 			b <<= 8;
 			b |= msg[i];
 		}
-	}
-	else
-	{
+	} else {
 		if (len >= 4)
-		    *(int *)0 = 0;
+			*(int *)0 = 0;
 		a = b = c = d = pad;
-		for(i = 0; i < len; i++)
-		{
+		for (i = 0; i < len; i++) {
 			a <<= 8;
 			a |= msg[i];
 		}
@@ -169,83 +136,83 @@ u32 keyed_hash(const signed char *msg, int len)
 
 	TEACORE(FULLROUNDS);
 
-	return h0^h1;
+	return h0 ^ h1;
 }
 
-
-u32 yura_hash (const signed char *msg, int len)
+u32 yura_hash(const signed char *msg, int len)
 {
-    int j, pow;
-    u32 a, c;
-    int i;
-    
-    for (pow=1,i=1; i < len; i++) pow = pow * 10; 
-    
-    if (len == 1) 
-	a = msg[0]-48;
-    else
-	a = (msg[0] - 48) * pow;
-    
-    for (i=1; i < len; i++) {
-	c = msg[i] - 48; 
-	for (pow=1,j=i; j < len-1; j++) pow = pow * 10; 
-	a = a + c * pow;
-    }
-    
-    for (; i < 40; i++) {
-	c = '0' - 48; 
-	for (pow=1,j=i; j < len-1; j++) pow = pow * 10; 
-	a = a + c * pow;
-    }
-    
-    for (; i < 256; i++) {
-	c = i; 
-	for (pow=1,j=i; j < len-1; j++) pow = pow * 10; 
-	a = a + c * pow;
-    }
-    
-    a = a << 7;
-    return a;
-}
+	int j, pow;
+	u32 a, c;
+	int i;
 
+	for (pow = 1, i = 1; i < len; i++)
+		pow = pow * 10;
 
-u32 r5_hash (const signed char *msg, int len)
-{
-    u32 a=0;
-    int i;
-    
-    for (i = 0; i < len; i ++) {
-	a += msg[i] << 4;
-	a += msg[i] >> 4;
-	a *= 11;
-    } 
-    return a;
+	if (len == 1)
+		a = msg[0] - 48;
+	else
+		a = (msg[0] - 48) * pow;
+
+	for (i = 1; i < len; i++) {
+		c = msg[i] - 48;
+		for (pow = 1, j = i; j < len - 1; j++)
+			pow = pow * 10;
+		a = a + c * pow;
+	}
+
+	for (; i < 40; i++) {
+		c = '0' - 48;
+		for (pow = 1, j = i; j < len - 1; j++)
+			pow = pow * 10;
+		a = a + c * pow;
+	}
+
+	for (; i < 256; i++) {
+		c = i;
+		for (pow = 1, j = i; j < len - 1; j++)
+			pow = pow * 10;
+		a = a + c * pow;
+	}
+
+	a = a << 7;
+	return a;
 }
 
+u32 r5_hash(const signed char *msg, int len)
+{
+	u32 a = 0;
+	int i;
+
+	for (i = 0; i < len; i++) {
+		a += msg[i] << 4;
+		a += msg[i] >> 4;
+		a *= 11;
+	}
+	return a;
+}
 
 #if 0
 
 #include <stdio.h>
 
-int main (void)
+int main(void)
 {
-    char * name = 0;
-    size_t n = 0;
-
-    while (1) {
-	getline (&name, &n, stdin);
-	if (!strcmp (name, "\n"))
-	    break;
-	name [strlen (name) - 1] = 0;
-	printf ("tea %lu\n, r5 %lu\nyura %lu\n",
-		keyed_hash (name, strlen (name)) & 0x7fffff80,
-		r5_hash (name, strlen (name)) & 0x7fffff80,
-		yura_hash (name, strlen (name)) & 0x7fffff80);
-	free (name);
-	name = 0;
-	n = 0;
-    }
+	char *name = 0;
+	size_t n = 0;
+
+	while (1) {
+		getline(&name, &n, stdin);
+		if (!strcmp(name, "\n"))
+			break;
+		name[strlen(name) - 1] = 0;
+		printf("tea %lu\n, r5 %lu\nyura %lu\n",
+		       keyed_hash(name, strlen(name)) & 0x7fffff80,
+		       r5_hash(name, strlen(name)) & 0x7fffff80,
+		       yura_hash(name, strlen(name)) & 0x7fffff80);
+		free(name);
+		name = 0;
+		n = 0;
+	}
 }
 
 #endif
-
diff --git a/reiserfscore/ibalance.c b/reiserfscore/ibalance.c
index ec5f175..d374266 100644
--- a/reiserfscore/ibalance.c
+++ b/reiserfscore/ibalance.c
@@ -5,7 +5,6 @@
 
 #include "includes.h"
 
-
 /* modes of internal_shift_left, internal_shift_right and internal_insert_childs */
 #define INTERNAL_SHIFT_FROM_S_TO_L 0
 #define INTERNAL_SHIFT_FROM_R_TO_S 1
@@ -15,350 +14,358 @@
 #define INTERNAL_INSERT_TO_L 5
 #define INTERNAL_INSERT_TO_R 6
 
-static void	internal_define_dest_src_infos (
-						int shift_mode,
-						struct tree_balance * tb,
-						int h,
-						struct buffer_info * dest_bi,
-						struct buffer_info * src_bi,
-						int * d_key,
-						struct buffer_head ** cf
-						)
+static void internal_define_dest_src_infos(int shift_mode,
+					   struct tree_balance *tb,
+					   int h,
+					   struct buffer_info *dest_bi,
+					   struct buffer_info *src_bi,
+					   int *d_key, struct buffer_head **cf)
 {
-  /* define dest, src, dest parent, dest position */
-  switch (shift_mode) {
-  case INTERNAL_SHIFT_FROM_S_TO_L:	/* used in internal_shift_left */
-    src_bi->bi_bh = PATH_H_PBUFFER (tb->tb_path, h);
-    src_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-    src_bi->bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
-    dest_bi->bi_bh = tb->L[h];
-    dest_bi->bi_parent = tb->FL[h];
-    dest_bi->bi_position = get_left_neighbor_position (tb, h);
-    *d_key = tb->lkey[h];
-    *cf = tb->CFL[h];
-    break;
-  case INTERNAL_SHIFT_FROM_L_TO_S:
-    src_bi->bi_bh = tb->L[h];
-    src_bi->bi_parent = tb->FL[h];
-    src_bi->bi_position = get_left_neighbor_position (tb, h);
-    dest_bi->bi_bh = PATH_H_PBUFFER (tb->tb_path, h);
-    dest_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-    dest_bi->bi_position = PATH_H_POSITION (tb->tb_path, h + 1); /* dest position is analog of dest->b_item_order */
-    *d_key = tb->lkey[h];
-    *cf = tb->CFL[h];
-    break;
-
-  case INTERNAL_SHIFT_FROM_R_TO_S:	/* used in internal_shift_left */
-    src_bi->bi_bh = tb->R[h];
-    src_bi->bi_parent = tb->FR[h];
-    src_bi->bi_position = get_right_neighbor_position (tb, h);
-    dest_bi->bi_bh = PATH_H_PBUFFER (tb->tb_path, h);
-    dest_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-    dest_bi->bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
-    *d_key = tb->rkey[h];
-    *cf = tb->CFR[h];
-    break;
-  case INTERNAL_SHIFT_FROM_S_TO_R:
-    src_bi->bi_bh = PATH_H_PBUFFER (tb->tb_path, h);
-    src_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-    src_bi->bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
-    dest_bi->bi_bh = tb->R[h];
-    dest_bi->bi_parent = tb->FR[h];
-    dest_bi->bi_position = get_right_neighbor_position (tb, h);
-    *d_key = tb->rkey[h];
-    *cf = tb->CFR[h];
-    break;
-
-  case INTERNAL_INSERT_TO_L:
-    dest_bi->bi_bh = tb->L[h];
-    dest_bi->bi_parent = tb->FL[h];
-    dest_bi->bi_position = get_left_neighbor_position (tb, h);
-    break;
-
-  case INTERNAL_INSERT_TO_S:
-    dest_bi->bi_bh = PATH_H_PBUFFER (tb->tb_path, h);
-    dest_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-    dest_bi->bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
-    break;
-
-  case INTERNAL_INSERT_TO_R:
-    dest_bi->bi_bh = tb->R[h];
-    dest_bi->bi_parent = tb->FR[h];
-    dest_bi->bi_position = get_right_neighbor_position (tb, h);
-    break;
-
-  default:
-      reiserfs_panic ("internal_define_dest_src_infos", "shift type is unknown (%d)", shift_mode);
-  }
+	/* define dest, src, dest parent, dest position */
+	switch (shift_mode) {
+	case INTERNAL_SHIFT_FROM_S_TO_L:	/* used in internal_shift_left */
+		src_bi->bi_bh = PATH_H_PBUFFER(tb->tb_path, h);
+		src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		src_bi->bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
+		dest_bi->bi_bh = tb->L[h];
+		dest_bi->bi_parent = tb->FL[h];
+		dest_bi->bi_position = get_left_neighbor_position(tb, h);
+		*d_key = tb->lkey[h];
+		*cf = tb->CFL[h];
+		break;
+	case INTERNAL_SHIFT_FROM_L_TO_S:
+		src_bi->bi_bh = tb->L[h];
+		src_bi->bi_parent = tb->FL[h];
+		src_bi->bi_position = get_left_neighbor_position(tb, h);
+		dest_bi->bi_bh = PATH_H_PBUFFER(tb->tb_path, h);
+		dest_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		dest_bi->bi_position = PATH_H_POSITION(tb->tb_path, h + 1);	/* dest position is analog of dest->b_item_order */
+		*d_key = tb->lkey[h];
+		*cf = tb->CFL[h];
+		break;
+
+	case INTERNAL_SHIFT_FROM_R_TO_S:	/* used in internal_shift_left */
+		src_bi->bi_bh = tb->R[h];
+		src_bi->bi_parent = tb->FR[h];
+		src_bi->bi_position = get_right_neighbor_position(tb, h);
+		dest_bi->bi_bh = PATH_H_PBUFFER(tb->tb_path, h);
+		dest_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		dest_bi->bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
+		*d_key = tb->rkey[h];
+		*cf = tb->CFR[h];
+		break;
+	case INTERNAL_SHIFT_FROM_S_TO_R:
+		src_bi->bi_bh = PATH_H_PBUFFER(tb->tb_path, h);
+		src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		src_bi->bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
+		dest_bi->bi_bh = tb->R[h];
+		dest_bi->bi_parent = tb->FR[h];
+		dest_bi->bi_position = get_right_neighbor_position(tb, h);
+		*d_key = tb->rkey[h];
+		*cf = tb->CFR[h];
+		break;
+
+	case INTERNAL_INSERT_TO_L:
+		dest_bi->bi_bh = tb->L[h];
+		dest_bi->bi_parent = tb->FL[h];
+		dest_bi->bi_position = get_left_neighbor_position(tb, h);
+		break;
+
+	case INTERNAL_INSERT_TO_S:
+		dest_bi->bi_bh = PATH_H_PBUFFER(tb->tb_path, h);
+		dest_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		dest_bi->bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
+		break;
+
+	case INTERNAL_INSERT_TO_R:
+		dest_bi->bi_bh = tb->R[h];
+		dest_bi->bi_parent = tb->FR[h];
+		dest_bi->bi_position = get_right_neighbor_position(tb, h);
+		break;
+
+	default:
+		reiserfs_panic("internal_define_dest_src_infos",
+			       "shift type is unknown (%d)", shift_mode);
+	}
 }
 
-
-
 /* Insert 'count' node pointers into buffer cur before position 'to' + 1.
  * Insert count items into buffer cur before position to.
  * Items and node pointers are specified by inserted and bh respectively.
- */ 
-static void internal_insert_childs (reiserfs_filsys_t * fs, 
-				    struct buffer_info * cur_bi,
-				    int to, int count,
-				    struct item_head * inserted,
-				    struct buffer_head ** bh)
+ */
+static void internal_insert_childs(reiserfs_filsys_t *fs,
+				   struct buffer_info *cur_bi,
+				   int to, int count,
+				   struct item_head *inserted,
+				   struct buffer_head **bh)
 {
-    struct buffer_head * cur = cur_bi->bi_bh;
-    struct block_head * blkh;
-    int nr;
-    struct reiserfs_key *key;
-    struct disk_child new_dc[2];
-    struct disk_child * dc;
-    int i;
-    int from;
-    
-    if (count <= 0)
-	return;
-    
-    blkh = B_BLK_HEAD (cur);
-    nr = get_blkh_nr_items (blkh);
-    
-    /* prepare space for count disk_child */
-    dc = B_N_CHILD (cur,to+1);
-    
-    memmove (dc + count, dc, (nr+1-(to+1)) * DC_SIZE);
-    
-    /* make disk child array for insertion */
-    for (i = 0; i < count; i ++) {
-	set_dc(new_dc + i, MAX_CHILD_SIZE(bh[i]->b_size) - 
-	       get_blkh_free_space (B_BLK_HEAD (bh[i])),
-	       bh[i]->b_blocknr);
-	/*
-	set_dc_child_size (new_dc + i,
-			   MAX_CHILD_SIZE(bh[i]->b_size) - 
-			   get_blkh_free_space (B_BLK_HEAD (bh[i])));
-	set_dc_child_blocknr (new_dc + i, bh[i]->b_blocknr);*/
-    }
-    memcpy (dc, new_dc, DC_SIZE * count);
-    
-    /* prepare space for 'count' items  */
-    from = ((to == -1) ? 0 : to);
-    key = B_N_PDELIM_KEY (cur, from);
-    
-    memmove (key + count, key, (nr - from/*to*/) * KEY_SIZE + (nr + 1 + count) * DC_SIZE);
-
-    /* copy keys */
-    memcpy (key, inserted, KEY_SIZE);
-    if ( count > 1 )
-	memcpy (key + 1, inserted + 1, KEY_SIZE);
-    
-    /* sizes, item number */
-    set_blkh_nr_items (blkh, nr + count);
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) - count * (DC_SIZE + KEY_SIZE));
-
-    mark_buffer_dirty (cur);
-    
-    if (cur_bi->bi_parent) {
-	dc = B_N_CHILD (cur_bi->bi_parent,cur_bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) + count * (DC_SIZE + KEY_SIZE));
-	mark_buffer_dirty (cur_bi->bi_parent);
-    }
-    
-}
+	struct buffer_head *cur = cur_bi->bi_bh;
+	struct block_head *blkh;
+	int nr;
+	struct reiserfs_key *key;
+	struct disk_child new_dc[2];
+	struct disk_child *dc;
+	int i;
+	int from;
+
+	if (count <= 0)
+		return;
+
+	blkh = B_BLK_HEAD(cur);
+	nr = get_blkh_nr_items(blkh);
+
+	/* prepare space for count disk_child */
+	dc = B_N_CHILD(cur, to + 1);
+
+	memmove(dc + count, dc, (nr + 1 - (to + 1)) * DC_SIZE);
+
+	/* make disk child array for insertion */
+	for (i = 0; i < count; i++) {
+		set_dc(new_dc + i, MAX_CHILD_SIZE(bh[i]->b_size) -
+		       get_blkh_free_space(B_BLK_HEAD(bh[i])),
+		       bh[i]->b_blocknr);
+		/*
+		   set_dc_child_size (new_dc + i,
+		   MAX_CHILD_SIZE(bh[i]->b_size) - 
+		   get_blkh_free_space (B_BLK_HEAD (bh[i])));
+		   set_dc_child_blocknr (new_dc + i, bh[i]->b_blocknr); */
+	}
+	memcpy(dc, new_dc, DC_SIZE * count);
+
+	/* prepare space for 'count' items  */
+	from = ((to == -1) ? 0 : to);
+	key = B_N_PDELIM_KEY(cur, from);
+
+	memmove(key + count, key,
+		(nr - from /*to */ ) * KEY_SIZE + (nr + 1 + count) * DC_SIZE);
+
+	/* copy keys */
+	memcpy(key, inserted, KEY_SIZE);
+	if (count > 1)
+		memcpy(key + 1, inserted + 1, KEY_SIZE);
+
+	/* sizes, item number */
+	set_blkh_nr_items(blkh, nr + count);
+	set_blkh_free_space(blkh,
+			    get_blkh_free_space(blkh) - count * (DC_SIZE +
+								 KEY_SIZE));
+
+	mark_buffer_dirty(cur);
+
+	if (cur_bi->bi_parent) {
+		dc = B_N_CHILD(cur_bi->bi_parent, cur_bi->bi_position);
+		set_dc_child_size(dc,
+				  get_dc_child_size(dc) + count * (DC_SIZE +
+								   KEY_SIZE));
+		mark_buffer_dirty(cur_bi->bi_parent);
+	}
 
+}
 
 /* Delete del_num items and node pointers from buffer cur starting from *
  * the first_i'th item and first_p'th pointers respectively.		*/
-static void internal_delete_pointers_items (reiserfs_filsys_t * fs,
-					    struct buffer_info * cur_bi,
-					    int first_p, int first_i, 
-					    int del_num)
+static void internal_delete_pointers_items(reiserfs_filsys_t *fs,
+					   struct buffer_info *cur_bi,
+					   int first_p, int first_i,
+					   int del_num)
 {
-    struct buffer_head * cur = cur_bi->bi_bh;
-    int nr;
-    struct block_head * blkh;
-    struct reiserfs_key *key;
-    struct disk_child * dc;
-
-    if ( del_num == 0 )
-	return;
-
-    blkh = B_BLK_HEAD(cur);
-    nr = get_blkh_nr_items (blkh);
-
-    if ( first_p == 0 && del_num == nr + 1 ) {
-	make_empty_node (cur_bi);
-	return;
-    }
-
-    /* deleting */
-    dc = B_N_CHILD (cur, first_p);
-
-    memmove (dc, dc + del_num, (nr + 1 - first_p - del_num) * DC_SIZE);
-    key = B_N_PDELIM_KEY (cur, first_i);
-    memmove (key, key + del_num, (nr - first_i - del_num) * KEY_SIZE + (nr + 1 - del_num) * DC_SIZE);
-
-
-    /* sizes, item number */
-    set_blkh_nr_items (blkh, get_blkh_nr_items (blkh) - del_num);
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) +
-			 del_num * (KEY_SIZE +  DC_SIZE));
-
-    mark_buffer_dirty (cur);
- 
-    if (cur_bi->bi_parent) {
-	dc = B_N_CHILD (cur_bi->bi_parent, cur_bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) - del_num * (KEY_SIZE +  DC_SIZE));
-	mark_buffer_dirty (cur_bi->bi_parent);
-    }
-}
+	struct buffer_head *cur = cur_bi->bi_bh;
+	int nr;
+	struct block_head *blkh;
+	struct reiserfs_key *key;
+	struct disk_child *dc;
 
+	if (del_num == 0)
+		return;
+
+	blkh = B_BLK_HEAD(cur);
+	nr = get_blkh_nr_items(blkh);
+
+	if (first_p == 0 && del_num == nr + 1) {
+		make_empty_node(cur_bi);
+		return;
+	}
+
+	/* deleting */
+	dc = B_N_CHILD(cur, first_p);
+
+	memmove(dc, dc + del_num, (nr + 1 - first_p - del_num) * DC_SIZE);
+	key = B_N_PDELIM_KEY(cur, first_i);
+	memmove(key, key + del_num,
+		(nr - first_i - del_num) * KEY_SIZE + (nr + 1 -
+						       del_num) * DC_SIZE);
+
+	/* sizes, item number */
+	set_blkh_nr_items(blkh, get_blkh_nr_items(blkh) - del_num);
+	set_blkh_free_space(blkh, get_blkh_free_space(blkh) +
+			    del_num * (KEY_SIZE + DC_SIZE));
+
+	mark_buffer_dirty(cur);
+
+	if (cur_bi->bi_parent) {
+		dc = B_N_CHILD(cur_bi->bi_parent, cur_bi->bi_position);
+		set_dc_child_size(dc,
+				  get_dc_child_size(dc) - del_num * (KEY_SIZE +
+								     DC_SIZE));
+		mark_buffer_dirty(cur_bi->bi_parent);
+	}
+}
 
 /* delete n node pointers and items starting from given position */
-static void internal_delete_childs (reiserfs_filsys_t * fs,
-				    struct buffer_info * cur_bi, 
-				    int from, int n)
+static void internal_delete_childs(reiserfs_filsys_t *fs,
+				   struct buffer_info *cur_bi, int from, int n)
 {
-    int i_from;
-    
-    i_from = (from == 0) ? from : from - 1;
-    
-    /* delete n pointers starting from `from' position in CUR;
-       delete n keys starting from 'i_from' position in CUR;
-    */
-    internal_delete_pointers_items (fs, cur_bi, from, i_from, n);
-}
+	int i_from;
+
+	i_from = (from == 0) ? from : from - 1;
 
+	/* delete n pointers starting from `from' position in CUR;
+	   delete n keys starting from 'i_from' position in CUR;
+	 */
+	internal_delete_pointers_items(fs, cur_bi, from, i_from, n);
+}
 
 /* copy cpy_num node pointers and cpy_num - 1 items from buffer src to buffer dest
 * last_first == FIRST_TO_LAST means, that we copy first items from src to tail of dest
  * last_first == LAST_TO_FIRST means, that we copy last items from src to head of dest 
  */
-static void internal_copy_pointers_items (reiserfs_filsys_t * fs,
-					  struct buffer_info * dest_bi,
-					  struct buffer_head * src,
-					  int last_first, int cpy_num)
+static void internal_copy_pointers_items(reiserfs_filsys_t *fs,
+					 struct buffer_info *dest_bi,
+					 struct buffer_head *src,
+					 int last_first, int cpy_num)
 {
-    /* ATTENTION! Number of node pointers in DEST is equal to number of items in DEST *
-     * as delimiting key have already inserted to buffer dest.*/
-    struct buffer_head * dest = dest_bi->bi_bh;
-    int nr_dest, nr_src;
-    int dest_order, src_order;
-    struct block_head * blkh;
-    struct reiserfs_key *key;
-    struct disk_child * dc;
+	/* ATTENTION! Number of node pointers in DEST is equal to number of items in DEST *
+	 * as delimiting key have already inserted to buffer dest.*/
+	struct buffer_head *dest = dest_bi->bi_bh;
+	int nr_dest, nr_src;
+	int dest_order, src_order;
+	struct block_head *blkh;
+	struct reiserfs_key *key;
+	struct disk_child *dc;
 
-    nr_src = B_NR_ITEMS (src);
+	nr_src = B_NR_ITEMS(src);
 
-    if ( cpy_num == 0 )
-	return;
+	if (cpy_num == 0)
+		return;
 
-    /* coping */
-    blkh = B_BLK_HEAD (dest);
-    nr_dest = get_blkh_nr_items (blkh);
+	/* coping */
+	blkh = B_BLK_HEAD(dest);
+	nr_dest = get_blkh_nr_items(blkh);
 
-    /*dest_order = (last_first == LAST_TO_FIRST) ? 0 : nr_dest;*/
-    /*src_order = (last_first == LAST_TO_FIRST) ? (nr_src - cpy_num + 1) : 0;*/
-    (last_first == LAST_TO_FIRST) ?	(dest_order = 0, src_order = nr_src - cpy_num + 1) :
-	(dest_order = nr_dest, src_order = 0);
+	/*dest_order = (last_first == LAST_TO_FIRST) ? 0 : nr_dest; */
+	/*src_order = (last_first == LAST_TO_FIRST) ? (nr_src - cpy_num + 1) : 0; */
+	(last_first == LAST_TO_FIRST) ? (dest_order = 0, src_order =
+					 nr_src - cpy_num + 1) : (dest_order =
+								  nr_dest,
+								  src_order =
+								  0);
 
-    /* prepare space for cpy_num pointers */
-    dc = B_N_CHILD (dest, dest_order);
+	/* prepare space for cpy_num pointers */
+	dc = B_N_CHILD(dest, dest_order);
 
-    memmove (dc + cpy_num, dc, (nr_dest - dest_order) * DC_SIZE);
+	memmove(dc + cpy_num, dc, (nr_dest - dest_order) * DC_SIZE);
 
 	/* insert pointers */
-    memcpy (dc, B_N_CHILD (src, src_order), DC_SIZE * cpy_num);
-
-
-    /* prepare space for cpy_num - 1 item headers */
-    key = B_N_PDELIM_KEY(dest, dest_order);
-    memmove (key + cpy_num - 1, key,
-	     KEY_SIZE * (nr_dest - dest_order) + DC_SIZE * (nr_dest + cpy_num));
-
-
-    /* insert headers */
-    memcpy (key, B_N_PDELIM_KEY (src, src_order), KEY_SIZE * (cpy_num - 1));
-
-    /* sizes, item number */
-    set_blkh_nr_items (blkh, get_blkh_nr_items (blkh) + cpy_num - 1);
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) -
-			 (KEY_SIZE * (cpy_num - 1) + DC_SIZE * cpy_num));
-
-    mark_buffer_dirty (dest);
-    if (dest_bi->bi_parent) {
-	dc = B_N_CHILD(dest_bi->bi_parent,dest_bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) + KEY_SIZE * (cpy_num - 1) + DC_SIZE * cpy_num);
-	mark_buffer_dirty (dest_bi->bi_parent);
-    }
+	memcpy(dc, B_N_CHILD(src, src_order), DC_SIZE * cpy_num);
+
+	/* prepare space for cpy_num - 1 item headers */
+	key = B_N_PDELIM_KEY(dest, dest_order);
+	memmove(key + cpy_num - 1, key,
+		KEY_SIZE * (nr_dest - dest_order) + DC_SIZE * (nr_dest +
+							       cpy_num));
+
+	/* insert headers */
+	memcpy(key, B_N_PDELIM_KEY(src, src_order), KEY_SIZE * (cpy_num - 1));
+
+	/* sizes, item number */
+	set_blkh_nr_items(blkh, get_blkh_nr_items(blkh) + cpy_num - 1);
+	set_blkh_free_space(blkh, get_blkh_free_space(blkh) -
+			    (KEY_SIZE * (cpy_num - 1) + DC_SIZE * cpy_num));
+
+	mark_buffer_dirty(dest);
+	if (dest_bi->bi_parent) {
+		dc = B_N_CHILD(dest_bi->bi_parent, dest_bi->bi_position);
+		set_dc_child_size(dc,
+				  get_dc_child_size(dc) + KEY_SIZE * (cpy_num -
+								      1) +
+				  DC_SIZE * cpy_num);
+		mark_buffer_dirty(dest_bi->bi_parent);
+	}
 
 }
 
-
 /* Copy cpy_num node pointers and cpy_num - 1 items from buffer src to buffer dest.
  * Delete cpy_num - del_par items and node pointers from buffer src.
  * last_first == FIRST_TO_LAST means, that we copy/delete first items from src.
  * last_first == LAST_TO_FIRST means, that we copy/delete last items from src.
  */
-static void internal_move_pointers_items (reiserfs_filsys_t * fs,
-					  struct buffer_info * dest_bi, 
-					  struct buffer_info * src_bi, 
-					  int last_first, int cpy_num, int del_par)
+static void internal_move_pointers_items(reiserfs_filsys_t *fs,
+					 struct buffer_info *dest_bi,
+					 struct buffer_info *src_bi,
+					 int last_first, int cpy_num,
+					 int del_par)
 {
-    int first_pointer;
-    int first_item;
-    
-    internal_copy_pointers_items (fs, dest_bi, src_bi->bi_bh, last_first, cpy_num);
-    
-    if (last_first == FIRST_TO_LAST) {	/* shift_left occurs */
-	first_pointer = 0;
-	first_item = 0;
-	/* delete cpy_num - del_par pointers and keys starting for pointers with first_pointer, 
-	   for key - with first_item */
-	internal_delete_pointers_items (fs, src_bi, first_pointer, first_item, cpy_num - del_par);
-    } else {			/* shift_right occurs */
-	int i, j;
-	
-	i = ( cpy_num - del_par == ( j = B_NR_ITEMS(src_bi->bi_bh)) + 1 ) ? 0 : j - cpy_num + del_par;
-	
-	internal_delete_pointers_items (fs, src_bi, j + 1 - cpy_num + del_par, i, cpy_num - del_par);
-    }
+	int first_pointer;
+	int first_item;
+
+	internal_copy_pointers_items(fs, dest_bi, src_bi->bi_bh, last_first,
+				     cpy_num);
+
+	if (last_first == FIRST_TO_LAST) {	/* shift_left occurs */
+		first_pointer = 0;
+		first_item = 0;
+		/* delete cpy_num - del_par pointers and keys starting for pointers with first_pointer, 
+		   for key - with first_item */
+		internal_delete_pointers_items(fs, src_bi, first_pointer,
+					       first_item, cpy_num - del_par);
+	} else {		/* shift_right occurs */
+		int i, j;
+
+		i = (cpy_num - del_par ==
+		     (j =
+		      B_NR_ITEMS(src_bi->bi_bh)) + 1) ? 0 : j - cpy_num +
+		    del_par;
+
+		internal_delete_pointers_items(fs, src_bi,
+					       j + 1 - cpy_num + del_par, i,
+					       cpy_num - del_par);
+	}
 }
 
 /* Insert n_src'th key of buffer src before n_dest'th key of buffer dest. */
-static void internal_insert_key (reiserfs_filsys_t * fs,
-				 struct buffer_info * dest_bi, 
-				 int dest_position_before,                 /* insert key before key with n_dest number */
-				 struct buffer_head * src, 
-				 int src_position )
+static void internal_insert_key(reiserfs_filsys_t *fs, struct buffer_info *dest_bi, int dest_position_before,	/* insert key before key with n_dest number */
+				struct buffer_head *src, int src_position)
 {
-    struct buffer_head * dest = dest_bi->bi_bh;
-    int nr;
-    struct block_head * blkh;
-    struct reiserfs_key *key;
-
-    blkh = B_BLK_HEAD(dest);
-    nr = get_blkh_nr_items (blkh);
-
-    /* prepare space for inserting key */
-    key = B_N_PDELIM_KEY (dest, dest_position_before);
-    memmove (key + 1, key, (nr - dest_position_before) * KEY_SIZE + (nr + 1) * DC_SIZE);
-
-    /* insert key */
-    memcpy (key, B_N_PDELIM_KEY(src, src_position), KEY_SIZE);
-
-    /* Change dirt, free space, item number fields. */
-    set_blkh_nr_items (blkh, get_blkh_nr_items (blkh) + 1);
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) - KEY_SIZE);
-
-    mark_buffer_dirty (dest);
-
-    if (dest_bi->bi_parent) {
-	struct disk_child * dc;
-	
-	dc = B_N_CHILD(dest_bi->bi_parent,dest_bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) + KEY_SIZE);
-	mark_buffer_dirty (dest_bi->bi_parent);
-    }
-}
+	struct buffer_head *dest = dest_bi->bi_bh;
+	int nr;
+	struct block_head *blkh;
+	struct reiserfs_key *key;
 
+	blkh = B_BLK_HEAD(dest);
+	nr = get_blkh_nr_items(blkh);
 
+	/* prepare space for inserting key */
+	key = B_N_PDELIM_KEY(dest, dest_position_before);
+	memmove(key + 1, key,
+		(nr - dest_position_before) * KEY_SIZE + (nr + 1) * DC_SIZE);
+
+	/* insert key */
+	memcpy(key, B_N_PDELIM_KEY(src, src_position), KEY_SIZE);
+
+	/* Change dirt, free space, item number fields. */
+	set_blkh_nr_items(blkh, get_blkh_nr_items(blkh) + 1);
+	set_blkh_free_space(blkh, get_blkh_free_space(blkh) - KEY_SIZE);
+
+	mark_buffer_dirty(dest);
+
+	if (dest_bi->bi_parent) {
+		struct disk_child *dc;
+
+		dc = B_N_CHILD(dest_bi->bi_parent, dest_bi->bi_position);
+		set_dc_child_size(dc, get_dc_child_size(dc) + KEY_SIZE);
+		mark_buffer_dirty(dest_bi->bi_parent);
+	}
+}
 
 /* Insert d_key'th (delimiting) key from buffer cfl to tail of dest. 
  * Copy pointer_amount node pointers and pointer_amount - 1 items from buffer src to buffer dest.
@@ -366,30 +373,37 @@ static void internal_insert_key (reiserfs_filsys_t * fs,
  * Delete pointer_amount items and node pointers from buffer src.
  */
 /* this can be invoked both to shift from S to L and from R to S */
-static void internal_shift_left (int mode,	/* INTERNAL_FROM_S_TO_L | INTERNAL_FROM_R_TO_S */
-				 struct tree_balance * tb, int h,
-				 int pointer_amount)
+static void internal_shift_left(int mode,	/* INTERNAL_FROM_S_TO_L | INTERNAL_FROM_R_TO_S */
+				struct tree_balance *tb, int h,
+				int pointer_amount)
 {
-    struct buffer_info dest_bi, src_bi;
-    struct buffer_head * cf;
-    int d_key_position;
-
-    internal_define_dest_src_infos (mode, tb, h, &dest_bi, &src_bi, &d_key_position, &cf);
-
-    /*printk("pointer_amount = %d\n",pointer_amount);*/
-
-    if (pointer_amount) {
-	/* insert delimiting key from common father of dest and src to node dest into position B_NR_ITEM(dest) */
-	internal_insert_key (tb->tb_fs, &dest_bi, B_NR_ITEMS(dest_bi.bi_bh), cf, d_key_position);
-
-	if (B_NR_ITEMS(src_bi.bi_bh) == pointer_amount - 1) {
-	    if (src_bi.bi_position/*src->b_item_order*/ == 0)
-		replace_key (tb->tb_fs, cf, d_key_position, src_bi.bi_parent/*src->b_parent*/, 0);
-	} else
-	    replace_key (tb->tb_fs, cf, d_key_position, src_bi.bi_bh, pointer_amount - 1);
-    }
-    /* last parameter is del_parameter */
-    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, FIRST_TO_LAST, pointer_amount, 0);
+	struct buffer_info dest_bi, src_bi;
+	struct buffer_head *cf;
+	int d_key_position;
+
+	internal_define_dest_src_infos(mode, tb, h, &dest_bi, &src_bi,
+				       &d_key_position, &cf);
+
+	/*printk("pointer_amount = %d\n",pointer_amount); */
+
+	if (pointer_amount) {
+		/* insert delimiting key from common father of dest and src to node dest into position B_NR_ITEM(dest) */
+		internal_insert_key(tb->tb_fs, &dest_bi,
+				    B_NR_ITEMS(dest_bi.bi_bh), cf,
+				    d_key_position);
+
+		if (B_NR_ITEMS(src_bi.bi_bh) == pointer_amount - 1) {
+			if (src_bi.bi_position /*src->b_item_order */  == 0)
+				replace_key(tb->tb_fs, cf, d_key_position,
+					    src_bi.
+					    bi_parent /*src->b_parent */ , 0);
+		} else
+			replace_key(tb->tb_fs, cf, d_key_position, src_bi.bi_bh,
+				    pointer_amount - 1);
+	}
+	/* last parameter is del_parameter */
+	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
+				     FIRST_TO_LAST, pointer_amount, 0);
 
 }
 
@@ -398,55 +412,61 @@ static void internal_shift_left (int mode,	/* INTERNAL_FROM_S_TO_L | INTERNAL_FR
  * Delete n - 1 items and node pointers from buffer S[h].
  */
 /* it always shifts from S[h] to L[h] */
-static void internal_shift1_left (struct tree_balance * tb, 
-				  int h, int pointer_amount)
+static void internal_shift1_left(struct tree_balance *tb,
+				 int h, int pointer_amount)
 {
-    struct buffer_info dest_bi, src_bi;
-    struct buffer_head * cf;
-    int d_key_position;
-    
-    internal_define_dest_src_infos (INTERNAL_SHIFT_FROM_S_TO_L, tb, h, &dest_bi, &src_bi, &d_key_position, &cf);
-    
-    if ( pointer_amount > 0 ) /* insert lkey[h]-th key  from CFL[h] to left neighbor L[h] */
-	internal_insert_key (tb->tb_fs, &dest_bi, B_NR_ITEMS(dest_bi.bi_bh), cf, d_key_position);
-    
-    /* last parameter is del_parameter */
-    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, FIRST_TO_LAST, pointer_amount, 1);
-}
+	struct buffer_info dest_bi, src_bi;
+	struct buffer_head *cf;
+	int d_key_position;
+
+	internal_define_dest_src_infos(INTERNAL_SHIFT_FROM_S_TO_L, tb, h,
+				       &dest_bi, &src_bi, &d_key_position, &cf);
 
+	if (pointer_amount > 0)	/* insert lkey[h]-th key  from CFL[h] to left neighbor L[h] */
+		internal_insert_key(tb->tb_fs, &dest_bi,
+				    B_NR_ITEMS(dest_bi.bi_bh), cf,
+				    d_key_position);
+
+	/* last parameter is del_parameter */
+	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
+				     FIRST_TO_LAST, pointer_amount, 1);
+}
 
 /* Insert d_key'th (delimiting) key from buffer cfr to head of dest. 
  * Copy n node pointers and n - 1 items from buffer src to buffer dest.
  * Replace  d_key'th key in buffer cfr.
  * Delete n items and node pointers from buffer src.
  */
-static void internal_shift_right (int mode,	/* INTERNAL_FROM_S_TO_R | INTERNAL_FROM_L_TO_S */
-				  struct tree_balance * tb, int h,
-				  int pointer_amount)
+static void internal_shift_right(int mode,	/* INTERNAL_FROM_S_TO_R | INTERNAL_FROM_L_TO_S */
+				 struct tree_balance *tb, int h,
+				 int pointer_amount)
 {
-    struct buffer_info dest_bi, src_bi;
-    struct buffer_head * cf;
-    int d_key_position;
-    int nr;
-
-
-    internal_define_dest_src_infos (mode, tb, h, &dest_bi, &src_bi, &d_key_position, &cf);
-
-    nr = B_NR_ITEMS (src_bi.bi_bh);
-
-    if (pointer_amount > 0) {
-	/* insert delimiting key from common father of dest and src to dest node into position 0 */
-	internal_insert_key (tb->tb_fs, &dest_bi, 0, cf, d_key_position);
-	if (nr == pointer_amount - 1) {
-	    /* when S[h] disappers replace left delemiting key as well */
-	    if (tb->CFL[h])
-		replace_key(tb->tb_fs, cf, d_key_position, tb->CFL[h], tb->lkey[h]);
-	} else
-	    replace_key(tb->tb_fs, cf, d_key_position, src_bi.bi_bh, nr - pointer_amount);
-    }      
+	struct buffer_info dest_bi, src_bi;
+	struct buffer_head *cf;
+	int d_key_position;
+	int nr;
+
+	internal_define_dest_src_infos(mode, tb, h, &dest_bi, &src_bi,
+				       &d_key_position, &cf);
+
+	nr = B_NR_ITEMS(src_bi.bi_bh);
+
+	if (pointer_amount > 0) {
+		/* insert delimiting key from common father of dest and src to dest node into position 0 */
+		internal_insert_key(tb->tb_fs, &dest_bi, 0, cf, d_key_position);
+		if (nr == pointer_amount - 1) {
+			/* when S[h] disappers replace left delemiting key as well */
+			if (tb->CFL[h])
+				replace_key(tb->tb_fs, cf, d_key_position,
+					    tb->CFL[h], tb->lkey[h]);
+		} else
+			replace_key(tb->tb_fs, cf, d_key_position, src_bi.bi_bh,
+				    nr - pointer_amount);
+	}
 
-    /* last parameter is del_parameter */
-    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, LAST_TO_FIRST, pointer_amount, 0);
+	/* last parameter is del_parameter */
+	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
+				     LAST_TO_FIRST, pointer_amount, 0);
 }
 
 /* Insert delimiting key to R[h].
@@ -454,437 +474,473 @@ static void internal_shift_right (int mode,	/* INTERNAL_FROM_S_TO_R | INTERNAL_F
  * Delete n - 1 items and node pointers from buffer S[h].
  */
 /* it always shift from S[h] to R[h] */
-static void internal_shift1_right (struct tree_balance * tb, 
-				   int h, int pointer_amount)
+static void internal_shift1_right(struct tree_balance *tb,
+				  int h, int pointer_amount)
 {
-    struct buffer_info dest_bi, src_bi;
-    struct buffer_head * cf;
-    int d_key_position;
-
-    internal_define_dest_src_infos (INTERNAL_SHIFT_FROM_S_TO_R, tb, h, &dest_bi, &src_bi, &d_key_position, &cf);
-    
-    if (pointer_amount > 0) /* insert rkey from CFR[h] to right neighbor R[h] */
-	internal_insert_key (tb->tb_fs, &dest_bi, 0, cf, d_key_position);
-    
-    /* last parameter is del_parameter */
-    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, LAST_TO_FIRST, pointer_amount, 1);
-}
+	struct buffer_info dest_bi, src_bi;
+	struct buffer_head *cf;
+	int d_key_position;
+
+	internal_define_dest_src_infos(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
+				       &dest_bi, &src_bi, &d_key_position, &cf);
+
+	if (pointer_amount > 0)	/* insert rkey from CFR[h] to right neighbor R[h] */
+		internal_insert_key(tb->tb_fs, &dest_bi, 0, cf, d_key_position);
 
+	/* last parameter is del_parameter */
+	internal_move_pointers_items(tb->tb_fs, &dest_bi, &src_bi,
+				     LAST_TO_FIRST, pointer_amount, 1);
+}
 
 /* Delete insert_num node pointers together with their left items
  * and balance current node.*/
-static void balance_internal_when_delete (struct tree_balance * tb, 
-					  int h, int child_pos)
+static void balance_internal_when_delete(struct tree_balance *tb,
+					 int h, int child_pos)
 {
-    int insert_num;
-    int n;
-    struct buffer_head * tbSh = PATH_H_PBUFFER (tb->tb_path, h);
-    struct buffer_info bi;
+	int insert_num;
+	int n;
+	struct buffer_head *tbSh = PATH_H_PBUFFER(tb->tb_path, h);
+	struct buffer_info bi;
+
+	insert_num = tb->insert_size[h] / ((int)(DC_SIZE + KEY_SIZE));
 
-    insert_num = tb->insert_size[h] / ((int)(DC_SIZE + KEY_SIZE));
-  
-    /* delete child-node-pointer(s) together with their left item(s) */
-    bi.bi_bh = tbSh;
+	/* delete child-node-pointer(s) together with their left item(s) */
+	bi.bi_bh = tbSh;
 
-    bi.bi_parent = PATH_H_PPARENT (tb->tb_path, h);
+	bi.bi_parent = PATH_H_PPARENT(tb->tb_path, h);
 
-    bi.bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
+	bi.bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
 
-    internal_delete_childs (tb->tb_fs, &bi, child_pos, -insert_num);
+	internal_delete_childs(tb->tb_fs, &bi, child_pos, -insert_num);
 
-    n = B_NR_ITEMS(tbSh);
+	n = B_NR_ITEMS(tbSh);
 
-    if ( tb->lnum[h] == 0 && tb->rnum[h] == 0 ) {
-	if ( tb->blknum[h] == 0 ) {
-	    /* node S[h] (root of the tree) is empty now */
-	    struct buffer_head *new_root;
-	    struct reiserfs_super_block * sb;
+	if (tb->lnum[h] == 0 && tb->rnum[h] == 0) {
+		if (tb->blknum[h] == 0) {
+			/* node S[h] (root of the tree) is empty now */
+			struct buffer_head *new_root;
+			struct reiserfs_super_block *sb;
 
-	    /* choose a new root */
-	    if ( ! tb->L[h-1] || ! B_NR_ITEMS(tb->L[h-1]) )
-		new_root = tb->R[h-1];
-	    else
-		new_root = tb->L[h-1];
+			/* choose a new root */
+			if (!tb->L[h - 1] || !B_NR_ITEMS(tb->L[h - 1]))
+				new_root = tb->R[h - 1];
+			else
+				new_root = tb->L[h - 1];
 
-	    /* update super block's tree height and pointer to a root block */
-	    sb = tb->tb_fs->fs_ondisk_sb;
-	    set_sb_root_block (sb, new_root->b_blocknr);
-	    set_sb_tree_height (sb, get_sb_tree_height (sb) - 1);
+			/* update super block's tree height and pointer to a root block */
+			sb = tb->tb_fs->fs_ondisk_sb;
+			set_sb_root_block(sb, new_root->b_blocknr);
+			set_sb_tree_height(sb, get_sb_tree_height(sb) - 1);
 
-	    mark_buffer_dirty (tb->tb_fs->fs_super_bh);
-	    tb->tb_fs->fs_dirt = 1;
+			mark_buffer_dirty(tb->tb_fs->fs_super_bh);
+			tb->tb_fs->fs_dirt = 1;
 
-	    /* mark buffer S[h] not uptodate and put it in free list */
-	    reiserfs_invalidate_buffer(tb, tbSh, 1);
-	    return;
+			/* mark buffer S[h] not uptodate and put it in free list */
+			reiserfs_invalidate_buffer(tb, tbSh, 1);
+			return;
+		}
+		return;
+	}
+
+	if (tb->L[h] && tb->lnum[h] == -B_NR_ITEMS(tb->L[h]) - 1) {	/* join S[h] with L[h] */
+		internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h, n + 1);	/*tb->L[h], tb->CFL[h], tb->lkey[h], tb->S[h], n+1); */
+		reiserfs_invalidate_buffer(tb, tbSh, 1);	/* preserve not needed, internal, 1 mean free block */
+
+		return;
+	}
+
+	if (tb->R[h] && tb->rnum[h] == -B_NR_ITEMS(tb->R[h]) - 1) {	/* join S[h] with R[h] */
+		internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h, n + 1);
+		reiserfs_invalidate_buffer(tb, tbSh, 1);
+		return;
+	}
+
+	if (tb->lnum[h] < 0) {	/* borrow from left neighbor L[h] */
+		internal_shift_right(INTERNAL_SHIFT_FROM_L_TO_S, tb, h,
+				     -tb->lnum[h]);
+		return;
+	}
+
+	if (tb->rnum[h] < 0) {	/* borrow from right neighbor R[h] */
+		internal_shift_left(INTERNAL_SHIFT_FROM_R_TO_S, tb, h, -tb->rnum[h]);	/*tb->S[h], tb->CFR[h], tb->rkey[h], tb->R[h], -tb->rnum[h]); */
+		return;
 	}
-	return;
-    }
-
-    if ( tb->L[h] && tb->lnum[h] == -B_NR_ITEMS(tb->L[h]) - 1 ) { /* join S[h] with L[h] */
-	internal_shift_left (INTERNAL_SHIFT_FROM_S_TO_L, tb, h, n + 1);/*tb->L[h], tb->CFL[h], tb->lkey[h], tb->S[h], n+1);*/
-	reiserfs_invalidate_buffer(tb, tbSh, 1); /* preserve not needed, internal, 1 mean free block */
-
-	return;
-    }
-
-    if ( tb->R[h] &&  tb->rnum[h] == -B_NR_ITEMS(tb->R[h]) - 1 ) { /* join S[h] with R[h] */
-	internal_shift_right (INTERNAL_SHIFT_FROM_S_TO_R, tb, h, n + 1);
-	reiserfs_invalidate_buffer (tb, tbSh, 1);
-	return;
-    }
-
-    if ( tb->lnum[h] < 0 ) { /* borrow from left neighbor L[h] */
-	internal_shift_right (INTERNAL_SHIFT_FROM_L_TO_S, tb, h, -tb->lnum[h]);
-	return;
-    }
-
-    if ( tb->rnum[h] < 0 ) { /* borrow from right neighbor R[h] */
-	internal_shift_left (INTERNAL_SHIFT_FROM_R_TO_S, tb, h, -tb->rnum[h]);/*tb->S[h], tb->CFR[h], tb->rkey[h], tb->R[h], -tb->rnum[h]);*/
-	return;
-    }
-
-    if ( tb->lnum[h] > 0 ) { /* split S[h] into two parts and put them into neighbors */
-	internal_shift_left (INTERNAL_SHIFT_FROM_S_TO_L, tb, h, tb->lnum[h]);/*tb->L[h], tb->CFL[h], tb->lkey[h], tb->S[h], tb->lnum[h]);*/
-	internal_shift_right (INTERNAL_SHIFT_FROM_S_TO_R, tb, h, tb->rnum[h]);
-	reiserfs_invalidate_buffer (tb, tbSh, 1);
-
-	return;
-    }
-    reiserfs_panic ("balance_internal_when_delete", "unexpected tb->lnum[%d]==%d or tb->rnum[%d]==%d",
-		    h, tb->lnum[h], h, tb->rnum[h]);
-}
 
+	if (tb->lnum[h] > 0) {	/* split S[h] into two parts and put them into neighbors */
+		internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h, tb->lnum[h]);	/*tb->L[h], tb->CFL[h], tb->lkey[h], tb->S[h], tb->lnum[h]); */
+		internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
+				     tb->rnum[h]);
+		reiserfs_invalidate_buffer(tb, tbSh, 1);
+
+		return;
+	}
+	reiserfs_panic("balance_internal_when_delete",
+		       "unexpected tb->lnum[%d]==%d or tb->rnum[%d]==%d", h,
+		       tb->lnum[h], h, tb->rnum[h]);
+}
 
 /* Replace delimiting key of buffers L[h] and S[h] by the given key.*/
-void replace_lkey (struct tree_balance * tb,
-		   int h, struct item_head * key)
+void replace_lkey(struct tree_balance *tb, int h, struct item_head *key)
 {
-    if (B_NR_ITEMS(PATH_H_PBUFFER(tb->tb_path, h)) == 0)
-	return;
+	if (B_NR_ITEMS(PATH_H_PBUFFER(tb->tb_path, h)) == 0)
+		return;
 
-    memcpy (B_N_PDELIM_KEY(tb->CFL[h],tb->lkey[h]), key, KEY_SIZE);
+	memcpy(B_N_PDELIM_KEY(tb->CFL[h], tb->lkey[h]), key, KEY_SIZE);
 
-    mark_buffer_dirty (tb->CFL[h]);
+	mark_buffer_dirty(tb->CFL[h]);
 }
 
-
 /* Replace delimiting key of buffers S[h] and R[h] by the given key.*/
-void replace_rkey (struct tree_balance * tb,
-		   int h, struct item_head * key)
+void replace_rkey(struct tree_balance *tb, int h, struct item_head *key)
 {
-    memcpy (B_N_PDELIM_KEY(tb->CFR[h],tb->rkey[h]), key, KEY_SIZE);
-    
-    mark_buffer_dirty (tb->CFR[h]);
-}
+	memcpy(B_N_PDELIM_KEY(tb->CFR[h], tb->rkey[h]), key, KEY_SIZE);
 
+	mark_buffer_dirty(tb->CFR[h]);
+}
 
+int balance_internal(struct tree_balance *tb,	/* tree_balance structure               */
+		     int h,	/* level of the tree                    */
+		     int child_pos, struct item_head *insert_key,	/* key for insertion on higher level    */
+		     struct buffer_head **insert_ptr)
+{				/* node for insertion on higher level */
+	/* if inserting/pasting
+	   {
+	   child_pos is the position of the node-pointer in S[h] that      *
+	   pointed to S[h-1] before balancing of the h-1 level;            *
+	   this means that new pointers and items must be inserted AFTER *
+	   child_pos
+	   }
+	   else 
+	   {
+	   it is the position of the leftmost pointer that must be deleted (together with
+	   its corresponding key to the left of the pointer)
+	   as a result of the previous level's balancing.
+	   }
+	 */
+	struct buffer_head *tbSh = PATH_H_PBUFFER(tb->tb_path, h);
+	struct buffer_info bi;
+	int order;		/* we return this: it is 0 if there is no S[h], else it is tb->S[h]->b_item_order */
+	int insert_num, n, k;
+	struct buffer_head *S_new;
+	struct item_head new_insert_key;
+	struct buffer_head *new_insert_ptr = NULL;
+	struct item_head *new_insert_key_addr = insert_key;
+
+	order =
+	    (tbSh) ? PATH_H_POSITION(tb->tb_path,
+				     h + 1) /*tb->S[h]->b_item_order */ : 0;
+
+	/* Using insert_size[h] calculate the number insert_num of items
+	   that must be inserted to or deleted from S[h]. */
+	insert_num = tb->insert_size[h] / ((int)(KEY_SIZE + DC_SIZE));
+
+	/* Check whether insert_num is proper * */
+	/* Make balance in case insert_num < 0 */
+	if (insert_num < 0) {
+		balance_internal_when_delete(tb, h, child_pos);
+		return order;
+	}
 
-int balance_internal (struct tree_balance * tb,			/* tree_balance structure 		*/
-		      int h,					/* level of the tree 			*/
-		      int child_pos,
-		      struct item_head * insert_key,		/* key for insertion on higher level   	*/
-		      struct buffer_head ** insert_ptr)	/* node for insertion on higher level*/
-  /* if inserting/pasting
-   {
-   child_pos is the position of the node-pointer in S[h] that	 *
-   pointed to S[h-1] before balancing of the h-1 level;		 *
-   this means that new pointers and items must be inserted AFTER *
-   child_pos
-   }
-   else 
-   {
-   it is the position of the leftmost pointer that must be deleted (together with
-   its corresponding key to the left of the pointer)
-   as a result of the previous level's balancing.
-   }
-*/
-{
-    struct buffer_head * tbSh = PATH_H_PBUFFER (tb->tb_path, h);
-    struct buffer_info bi;
-    int order;		/* we return this: it is 0 if there is no S[h], else it is tb->S[h]->b_item_order */
-    int insert_num, n, k;
-    struct buffer_head * S_new;
-    struct item_head new_insert_key;
-    struct buffer_head * new_insert_ptr = NULL;
-    struct item_head * new_insert_key_addr = insert_key;
-
-    order = ( tbSh ) ? PATH_H_POSITION (tb->tb_path, h + 1)/*tb->S[h]->b_item_order*/ : 0;
-
-  /* Using insert_size[h] calculate the number insert_num of items
-     that must be inserted to or deleted from S[h]. */
-    insert_num = tb->insert_size[h]/((int)(KEY_SIZE + DC_SIZE));
-
-    /* Check whether insert_num is proper **/
-    /* Make balance in case insert_num < 0 */
-    if ( insert_num < 0 ) {
-	balance_internal_when_delete (tb, h, child_pos);
-	return order;
-    }
- 
-    k = 0;
-    if ( tb->lnum[h] > 0 ) {
-	/* shift lnum[h] items from S[h] to the left neighbor L[h].
-	   check how many of new items fall into L[h] or CFL[h] after shifting */
-	n = get_blkh_nr_items (B_BLK_HEAD(tb->L[h])); /* number of items in L[h] */
-	if ( tb->lnum[h] <= child_pos ) {
-	    /* new items don't fall into L[h] or CFL[h] */
-	    internal_shift_left (INTERNAL_SHIFT_FROM_S_TO_L, tb, h, tb->lnum[h]);
-	    child_pos -= tb->lnum[h];
-	} else if ( tb->lnum[h] > child_pos + insert_num ) {
-	    /* all new items fall into L[h] */
-	    internal_shift_left (INTERNAL_SHIFT_FROM_S_TO_L, tb, h, tb->lnum[h] - insert_num);
-
-	    /* insert insert_num keys and node-pointers into L[h] */
-	    bi.bi_bh = tb->L[h];
-	    bi.bi_parent = tb->FL[h];
-	    bi.bi_position = get_left_neighbor_position (tb, h);
-	    internal_insert_childs (tb->tb_fs, &bi,/*tb->L[h], tb->S[h-1]->b_next*/ n + child_pos + 1,
-				    insert_num,insert_key,insert_ptr);
-
-	    insert_num = 0; 
-	} else {
-	    struct disk_child * dc;
-
-	    /* some items fall into L[h] or CFL[h], but some don't fall */
-	    internal_shift1_left (tb, h, child_pos + 1);
-	    /* calculate number of new items that fall into L[h] */
-	    k = tb->lnum[h] - child_pos - 1;
-
-	    bi.bi_bh = tb->L[h];
-	    bi.bi_parent = tb->FL[h];
-	    bi.bi_position = get_left_neighbor_position (tb, h);
-	    internal_insert_childs (tb->tb_fs, &bi,/*tb->L[h], tb->S[h-1]->b_next,*/ n + child_pos + 1,k,
-				    insert_key,insert_ptr);
-
-	    replace_lkey(tb, h, insert_key + k);
-
-	    /* replace the first node-ptr in S[h] by node-ptr to insert_ptr[k] */
-	    dc = B_N_CHILD(tbSh, 0);
-
-	    set_dc(dc, MAX_CHILD_SIZE(insert_ptr[k]->b_size) - 
-		   get_blkh_free_space (B_BLK_HEAD(insert_ptr[k])), 
-		   insert_ptr[k]->b_blocknr);
-	/*	       
-	    set_dc_child_size (dc, MAX_CHILD_SIZE(insert_ptr[k]->b_size) -
-			       get_blkh_free_space (B_BLK_HEAD(insert_ptr[k])));
-	    set_dc_child_blocknr (dc, insert_ptr[k]->b_blocknr);
-	*/
-	    mark_buffer_dirty (tbSh);
-
-	    k++;
-	    insert_key += k;
-	    insert_ptr += k;
-	    insert_num -= k;
-	    child_pos = 0;
+	k = 0;
+	if (tb->lnum[h] > 0) {
+		/* shift lnum[h] items from S[h] to the left neighbor L[h].
+		   check how many of new items fall into L[h] or CFL[h] after shifting */
+		n = get_blkh_nr_items(B_BLK_HEAD(tb->L[h]));	/* number of items in L[h] */
+		if (tb->lnum[h] <= child_pos) {
+			/* new items don't fall into L[h] or CFL[h] */
+			internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h,
+					    tb->lnum[h]);
+			child_pos -= tb->lnum[h];
+		} else if (tb->lnum[h] > child_pos + insert_num) {
+			/* all new items fall into L[h] */
+			internal_shift_left(INTERNAL_SHIFT_FROM_S_TO_L, tb, h,
+					    tb->lnum[h] - insert_num);
+
+			/* insert insert_num keys and node-pointers into L[h] */
+			bi.bi_bh = tb->L[h];
+			bi.bi_parent = tb->FL[h];
+			bi.bi_position = get_left_neighbor_position(tb, h);
+			internal_insert_childs(tb->tb_fs, &bi,
+					       /*tb->L[h], tb->S[h-1]->b_next */
+					       n + child_pos + 1,
+					       insert_num, insert_key,
+					       insert_ptr);
+
+			insert_num = 0;
+		} else {
+			struct disk_child *dc;
+
+			/* some items fall into L[h] or CFL[h], but some don't fall */
+			internal_shift1_left(tb, h, child_pos + 1);
+			/* calculate number of new items that fall into L[h] */
+			k = tb->lnum[h] - child_pos - 1;
+
+			bi.bi_bh = tb->L[h];
+			bi.bi_parent = tb->FL[h];
+			bi.bi_position = get_left_neighbor_position(tb, h);
+			internal_insert_childs(tb->tb_fs, &bi,
+					       /*tb->L[h], tb->S[h-1]->b_next, */
+					       n + child_pos + 1, k,
+					       insert_key, insert_ptr);
+
+			replace_lkey(tb, h, insert_key + k);
+
+			/* replace the first node-ptr in S[h] by node-ptr to insert_ptr[k] */
+			dc = B_N_CHILD(tbSh, 0);
+
+			set_dc(dc, MAX_CHILD_SIZE(insert_ptr[k]->b_size) -
+			       get_blkh_free_space(B_BLK_HEAD(insert_ptr[k])),
+			       insert_ptr[k]->b_blocknr);
+			/*             
+			   set_dc_child_size (dc, MAX_CHILD_SIZE(insert_ptr[k]->b_size) -
+			   get_blkh_free_space (B_BLK_HEAD(insert_ptr[k])));
+			   set_dc_child_blocknr (dc, insert_ptr[k]->b_blocknr);
+			 */
+			mark_buffer_dirty(tbSh);
+
+			k++;
+			insert_key += k;
+			insert_ptr += k;
+			insert_num -= k;
+			child_pos = 0;
+		}
+	}
+	/* tb->lnum[h] > 0 */
+	if (tb->rnum[h] > 0) {
+		/*shift rnum[h] items from S[h] to the right neighbor R[h] */
+		/* check how many of new items fall into R or CFR after shifting */
+		n = get_blkh_nr_items(B_BLK_HEAD(tbSh));	/* number of items in S[h] */
+		if (n - tb->rnum[h] >= child_pos)
+			/* new items fall into S[h] */
+			/*internal_shift_right(tb,h,tbSh,tb->CFR[h],tb->rkey[h],tb->R[h],tb->rnum[h]); */
+			internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
+					     tb->rnum[h]);
+		else if (n + insert_num - tb->rnum[h] < child_pos) {
+			/* all new items fall into R[h] */
+			internal_shift_right(INTERNAL_SHIFT_FROM_S_TO_R, tb, h,
+					     tb->rnum[h] - insert_num);
+
+			/* insert insert_num keys and node-pointers into R[h] */
+			bi.bi_bh = tb->R[h];
+			bi.bi_parent = tb->FR[h];
+			bi.bi_position = get_right_neighbor_position(tb, h);
+			internal_insert_childs(tb->tb_fs, &bi,
+					       /*tb->R[h],tb->S[h-1]->b_next */
+					       child_pos - n - insert_num +
+					       tb->rnum[h] - 1,
+					       insert_num, insert_key,
+					       insert_ptr);
+			insert_num = 0;
+		} else {
+			struct disk_child *dc;
+
+			/* one of the items falls into CFR[h] */
+			internal_shift1_right(tb, h, n - child_pos + 1);
+			/* calculate number of new items that fall into R[h] */
+			k = tb->rnum[h] - n + child_pos - 1;
+
+			bi.bi_bh = tb->R[h];
+			bi.bi_parent = tb->FR[h];
+			bi.bi_position = get_right_neighbor_position(tb, h);
+			internal_insert_childs(tb->tb_fs, &bi,
+					       /*tb->R[h], tb->R[h]->b_child, */
+					       0, k, insert_key + 1,
+					       insert_ptr + 1);
+
+			replace_rkey(tb, h, insert_key + insert_num - k - 1);
+
+			/* replace the first node-ptr in R[h] by node-ptr insert_ptr[insert_num-k-1] */
+			dc = B_N_CHILD(tb->R[h], 0);
+			set_dc(dc,
+			       MAX_CHILD_SIZE(insert_ptr[insert_num - k - 1]->
+					      b_size) -
+			       get_blkh_free_space(B_BLK_HEAD
+						   (insert_ptr
+						    [insert_num - k - 1])),
+			       insert_ptr[insert_num - k - 1]->b_blocknr);
+			/*
+			   set_dc_child_size (dc, MAX_CHILD_SIZE(insert_ptr[insert_num-k-1]->b_size) -
+			   get_blkh_free_space (B_BLK_HEAD(insert_ptr[insert_num-k-1])));
+			   set_dc_child_blocknr (dc, insert_ptr[insert_num-k-1]->b_blocknr);
+			 */
+			mark_buffer_dirty(tb->R[h]);
+
+			insert_num -= (k + 1);
+		}
 	}
-    }	/* tb->lnum[h] > 0 */
-
-    if ( tb->rnum[h] > 0 ) {
-	/*shift rnum[h] items from S[h] to the right neighbor R[h]*/
-	/* check how many of new items fall into R or CFR after shifting */
-	n = get_blkh_nr_items (B_BLK_HEAD (tbSh)); /* number of items in S[h] */
-	if ( n - tb->rnum[h] >= child_pos )
-	    /* new items fall into S[h] */
-	    /*internal_shift_right(tb,h,tbSh,tb->CFR[h],tb->rkey[h],tb->R[h],tb->rnum[h]);*/
-	    internal_shift_right (INTERNAL_SHIFT_FROM_S_TO_R, tb, h, tb->rnum[h]);
-	else
-	    if ( n + insert_num - tb->rnum[h] < child_pos )
-	    {
-		/* all new items fall into R[h] */
-		internal_shift_right (INTERNAL_SHIFT_FROM_S_TO_R, tb, h, tb->rnum[h] - insert_num);
-
-		/* insert insert_num keys and node-pointers into R[h] */
-		bi.bi_bh = tb->R[h];
-		bi.bi_parent = tb->FR[h];
-		bi.bi_position = get_right_neighbor_position (tb, h);
-		internal_insert_childs (tb->tb_fs, &bi, /*tb->R[h],tb->S[h-1]->b_next*/ child_pos - n - insert_num + tb->rnum[h] - 1,
-					insert_num,insert_key,insert_ptr);
-		insert_num = 0;
-	    }
-	    else
-	    {
-		struct disk_child * dc;
-
-		/* one of the items falls into CFR[h] */
-		internal_shift1_right(tb, h, n - child_pos + 1);
-		/* calculate number of new items that fall into R[h] */
-		k = tb->rnum[h] - n + child_pos - 1;
-
-		bi.bi_bh = tb->R[h];
-		bi.bi_parent = tb->FR[h];
-		bi.bi_position = get_right_neighbor_position (tb, h);
-		internal_insert_childs (tb->tb_fs, &bi, /*tb->R[h], tb->R[h]->b_child,*/ 0, k, insert_key + 1, insert_ptr + 1);
-
-		replace_rkey(tb, h, insert_key + insert_num - k - 1);
-
-		/* replace the first node-ptr in R[h] by node-ptr insert_ptr[insert_num-k-1]*/
-		dc = B_N_CHILD(tb->R[h], 0);
-		set_dc(dc, MAX_CHILD_SIZE(insert_ptr[insert_num-k-1]->b_size) -
-		       get_blkh_free_space (B_BLK_HEAD(insert_ptr[insert_num-k-1])),
-		       insert_ptr[insert_num-k-1]->b_blocknr);
-		/*
-		set_dc_child_size (dc, MAX_CHILD_SIZE(insert_ptr[insert_num-k-1]->b_size) -
-				   get_blkh_free_space (B_BLK_HEAD(insert_ptr[insert_num-k-1])));
-		set_dc_child_blocknr (dc, insert_ptr[insert_num-k-1]->b_blocknr);
-		*/
-		mark_buffer_dirty (tb->R[h]);
-		    
-		insert_num -= (k + 1);
-	    }
-    }
 
     /** Fill new node that appears instead of S[h] **/
-    if ( ! tb->blknum[h] )
-    { /* node S[h] is empty now */
-	/* Mark buffer as invalid and put it to head of free list. */
-	reiserfs_invalidate_buffer(tb, tbSh, 1);/* do not preserve, internal node*/
-	return order;
-    }
-
-    if ( ! tbSh ) {
-	/* create new root */
-	struct disk_child  * dc;
-	struct buffer_head * tbSh_1 = PATH_H_PBUFFER (tb->tb_path, h - 1);
-	struct reiserfs_super_block * sb;
-
-	if ( tb->blknum[h] != 1 )
-	    reiserfs_panic(0, "balance_internal", "One new node required for creating the new root");
-	/* S[h] = empty buffer from the list FEB. */
-	tbSh = get_FEB (tb);
-	set_blkh_level (B_BLK_HEAD(tbSh), h + 1);
-	
-	/* Put the unique node-pointer to S[h] that points to S[h-1]. */
-
-	dc = B_N_CHILD(tbSh, 0);
-
-	set_dc(dc, MAX_CHILD_SIZE (tbSh_1->b_size) - 
-	       get_blkh_free_space (B_BLK_HEAD(tbSh_1)),
-	       tbSh_1->b_blocknr);
-	/*
-	set_dc_child_size (dc, MAX_CHILD_SIZE (tbSh_1->b_size) - get_blkh_free_space (B_BLK_HEAD(tbSh_1)));
-	set_dc_child_blocknr (dc, tbSh_1->b_blocknr);
-	*/
-	tb->insert_size[h] -= DC_SIZE;
-	set_blkh_free_space (B_BLK_HEAD(tbSh),
-			     get_blkh_free_space (B_BLK_HEAD(tbSh)) - DC_SIZE);
-
-	mark_buffer_dirty (tbSh);
-	
-	/* put new root into path structure */
-	PATH_OFFSET_PBUFFER(tb->tb_path, ILLEGAL_PATH_ELEMENT_OFFSET) = tbSh;
-	
-	/* Change root in structure super block. */
-	sb = tb->tb_fs->fs_ondisk_sb;
-	set_sb_root_block (sb, tbSh->b_blocknr);
-	set_sb_tree_height (sb, get_sb_tree_height (sb) + 1);
-	
-	mark_buffer_dirty (tb->tb_fs->fs_super_bh);
-	tb->tb_fs->fs_dirt = 1;
-    }
-    
-    if ( tb->blknum[h] == 2 ) {
-	int snum;
-	struct buffer_info dest_bi, src_bi;
+	if (!tb->blknum[h]) {	/* node S[h] is empty now */
+		/* Mark buffer as invalid and put it to head of free list. */
+		reiserfs_invalidate_buffer(tb, tbSh, 1);	/* do not preserve, internal node */
+		return order;
+	}
+
+	if (!tbSh) {
+		/* create new root */
+		struct disk_child *dc;
+		struct buffer_head *tbSh_1 = PATH_H_PBUFFER(tb->tb_path, h - 1);
+		struct reiserfs_super_block *sb;
+
+		if (tb->blknum[h] != 1)
+			reiserfs_panic(0, "balance_internal",
+				       "One new node required for creating the new root");
+		/* S[h] = empty buffer from the list FEB. */
+		tbSh = get_FEB(tb);
+		set_blkh_level(B_BLK_HEAD(tbSh), h + 1);
+
+		/* Put the unique node-pointer to S[h] that points to S[h-1]. */
 
+		dc = B_N_CHILD(tbSh, 0);
 
-	/* S_new = free buffer from list FEB */
-	S_new = get_FEB(tb);
-
-	set_blkh_level (B_BLK_HEAD(S_new), h + 1);
-
-	dest_bi.bi_bh = S_new;
-	dest_bi.bi_parent = 0;
-	dest_bi.bi_position = 0;
-	src_bi.bi_bh = tbSh;
-	src_bi.bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-	src_bi.bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
-		
-	n = get_blkh_nr_items (B_BLK_HEAD(tbSh)); /* number of items in S[h] */
-	snum = (insert_num + n + 1)/2;
-	if ( n - snum >= child_pos ) {
-	    /* new items don't fall into S_new */
-	    /*	store the delimiting key for the next level */
-	    /* new_insert_key = (n - snum)'th key in S[h] */
-	    memcpy (&new_insert_key,B_N_PDELIM_KEY(tbSh,n - snum),
-		    KEY_SIZE);
-	    /* last parameter is del_par */
-	    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, LAST_TO_FIRST, snum, 0);
-	} else if ( n + insert_num - snum < child_pos ) {
-	    /* all new items fall into S_new */
-	    /*	store the delimiting key for the next level */
-	    /* new_insert_key = (n + insert_item - snum)'th key in S[h] */
-	    memcpy(&new_insert_key,B_N_PDELIM_KEY(tbSh,n + insert_num - snum),
-		   KEY_SIZE);
-	    /* last parameter is del_par */
-	    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, LAST_TO_FIRST, snum - insert_num, 0);
-	    /*			internal_move_pointers_items(S_new,tbSh,1,snum - insert_num,0);*/
-
-	    /* insert insert_num keys and node-pointers into S_new */
-	    internal_insert_childs (tb->tb_fs, &dest_bi, /*S_new,tb->S[h-1]->b_next,*/child_pos - n - insert_num + snum - 1,
-				    insert_num,insert_key,insert_ptr);
-
-	    insert_num = 0;
-	} else {
-	    struct disk_child * dc;
-
-	    /* some items fall into S_new, but some don't fall */
-	    /* last parameter is del_par */
-	    internal_move_pointers_items (tb->tb_fs, &dest_bi, &src_bi, LAST_TO_FIRST, n - child_pos + 1, 1);
-	    /*			internal_move_pointers_items(S_new,tbSh,1,n - child_pos + 1,1);*/
-	    /* calculate number of new items that fall into S_new */
-	    k = snum - n + child_pos - 1;
-
-	    internal_insert_childs (tb->tb_fs, &dest_bi, /*S_new,*/ 0, k, insert_key + 1, insert_ptr+1);
-
-	    /* new_insert_key = insert_key[insert_num - k - 1] */
-	    memcpy(&new_insert_key,insert_key + insert_num - k - 1,
-		   KEY_SIZE);
-	    /* replace first node-ptr in S_new by node-ptr to insert_ptr[insert_num-k-1] */
-
-	    dc = B_N_CHILD(S_new,0);
-	    set_dc(dc, MAX_CHILD_SIZE(insert_ptr[insert_num-k-1]->b_size) -
-		   get_blkh_free_space (B_BLK_HEAD(insert_ptr[insert_num-k-1])),
-		   insert_ptr[insert_num-k-1]->b_blocknr);
-	    /*
-	    set_dc_child_size (dc, MAX_CHILD_SIZE(insert_ptr[insert_num-k-1]->b_size) -
-			       get_blkh_free_space (B_BLK_HEAD(insert_ptr[insert_num-k-1])));
-	    set_dc_child_blocknr (dc, insert_ptr[insert_num-k-1]->b_blocknr);
-	    */
-	    mark_buffer_dirty (S_new);
-			
-	    insert_num -= (k + 1);
+		set_dc(dc, MAX_CHILD_SIZE(tbSh_1->b_size) -
+		       get_blkh_free_space(B_BLK_HEAD(tbSh_1)),
+		       tbSh_1->b_blocknr);
+		/*
+		   set_dc_child_size (dc, MAX_CHILD_SIZE (tbSh_1->b_size) - get_blkh_free_space (B_BLK_HEAD(tbSh_1)));
+		   set_dc_child_blocknr (dc, tbSh_1->b_blocknr);
+		 */
+		tb->insert_size[h] -= DC_SIZE;
+		set_blkh_free_space(B_BLK_HEAD(tbSh),
+				    get_blkh_free_space(B_BLK_HEAD(tbSh)) -
+				    DC_SIZE);
+
+		mark_buffer_dirty(tbSh);
+
+		/* put new root into path structure */
+		PATH_OFFSET_PBUFFER(tb->tb_path, ILLEGAL_PATH_ELEMENT_OFFSET) =
+		    tbSh;
+
+		/* Change root in structure super block. */
+		sb = tb->tb_fs->fs_ondisk_sb;
+		set_sb_root_block(sb, tbSh->b_blocknr);
+		set_sb_tree_height(sb, get_sb_tree_height(sb) + 1);
+
+		mark_buffer_dirty(tb->tb_fs->fs_super_bh);
+		tb->tb_fs->fs_dirt = 1;
 	}
-	/* new_insert_ptr = node_pointer to S_new */
-	new_insert_ptr = S_new;
-	/*
-	  S_new->b_count --;
-	*/
-	/*brelse(S_new);*/
-    }
 
-    n = get_blkh_nr_items (B_BLK_HEAD(tbSh)); /*number of items in S[h] */
+	if (tb->blknum[h] == 2) {
+		int snum;
+		struct buffer_info dest_bi, src_bi;
+
+		/* S_new = free buffer from list FEB */
+		S_new = get_FEB(tb);
+
+		set_blkh_level(B_BLK_HEAD(S_new), h + 1);
+
+		dest_bi.bi_bh = S_new;
+		dest_bi.bi_parent = 0;
+		dest_bi.bi_position = 0;
+		src_bi.bi_bh = tbSh;
+		src_bi.bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		src_bi.bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
+
+		n = get_blkh_nr_items(B_BLK_HEAD(tbSh));	/* number of items in S[h] */
+		snum = (insert_num + n + 1) / 2;
+		if (n - snum >= child_pos) {
+			/* new items don't fall into S_new */
+			/*  store the delimiting key for the next level */
+			/* new_insert_key = (n - snum)'th key in S[h] */
+			memcpy(&new_insert_key, B_N_PDELIM_KEY(tbSh, n - snum),
+			       KEY_SIZE);
+			/* last parameter is del_par */
+			internal_move_pointers_items(tb->tb_fs, &dest_bi,
+						     &src_bi, LAST_TO_FIRST,
+						     snum, 0);
+		} else if (n + insert_num - snum < child_pos) {
+			/* all new items fall into S_new */
+			/*  store the delimiting key for the next level */
+			/* new_insert_key = (n + insert_item - snum)'th key in S[h] */
+			memcpy(&new_insert_key,
+			       B_N_PDELIM_KEY(tbSh, n + insert_num - snum),
+			       KEY_SIZE);
+			/* last parameter is del_par */
+			internal_move_pointers_items(tb->tb_fs, &dest_bi,
+						     &src_bi, LAST_TO_FIRST,
+						     snum - insert_num, 0);
+			/*                  internal_move_pointers_items(S_new,tbSh,1,snum - insert_num,0); */
+
+			/* insert insert_num keys and node-pointers into S_new */
+			internal_insert_childs(tb->tb_fs, &dest_bi,
+					       /*S_new,tb->S[h-1]->b_next, */
+					       child_pos - n - insert_num +
+					       snum - 1,
+					       insert_num, insert_key,
+					       insert_ptr);
+
+			insert_num = 0;
+		} else {
+			struct disk_child *dc;
+
+			/* some items fall into S_new, but some don't fall */
+			/* last parameter is del_par */
+			internal_move_pointers_items(tb->tb_fs, &dest_bi,
+						     &src_bi, LAST_TO_FIRST,
+						     n - child_pos + 1, 1);
+			/*                  internal_move_pointers_items(S_new,tbSh,1,n - child_pos + 1,1); */
+			/* calculate number of new items that fall into S_new */
+			k = snum - n + child_pos - 1;
+
+			internal_insert_childs(tb->tb_fs, &dest_bi, /*S_new, */
+					       0, k, insert_key + 1,
+					       insert_ptr + 1);
+
+			/* new_insert_key = insert_key[insert_num - k - 1] */
+			memcpy(&new_insert_key, insert_key + insert_num - k - 1,
+			       KEY_SIZE);
+			/* replace first node-ptr in S_new by node-ptr to insert_ptr[insert_num-k-1] */
+
+			dc = B_N_CHILD(S_new, 0);
+			set_dc(dc,
+			       MAX_CHILD_SIZE(insert_ptr[insert_num - k - 1]->
+					      b_size) -
+			       get_blkh_free_space(B_BLK_HEAD
+						   (insert_ptr
+						    [insert_num - k - 1])),
+			       insert_ptr[insert_num - k - 1]->b_blocknr);
+			/*
+			   set_dc_child_size (dc, MAX_CHILD_SIZE(insert_ptr[insert_num-k-1]->b_size) -
+			   get_blkh_free_space (B_BLK_HEAD(insert_ptr[insert_num-k-1])));
+			   set_dc_child_blocknr (dc, insert_ptr[insert_num-k-1]->b_blocknr);
+			 */
+			mark_buffer_dirty(S_new);
+
+			insert_num -= (k + 1);
+		}
+		/* new_insert_ptr = node_pointer to S_new */
+		new_insert_ptr = S_new;
+		/*
+		   S_new->b_count --;
+		 */
+		/*brelse(S_new); */
+	}
 
-    if ( -1 <= child_pos && child_pos <= n && insert_num > 0 ) {
-	bi.bi_bh = tbSh;
-	bi.bi_parent = PATH_H_PPARENT (tb->tb_path, h);
-	bi.bi_position = PATH_H_POSITION (tb->tb_path, h + 1);
-	if (child_pos == -1) {
-	    /* this is a little different from original do_balance:
-	       here we insert the minimal keys in the tree, that has never happened when file system works */
-	    if (tb->CFL[h-1] || insert_num != 1 || h != 1)
-		die ("balance_internal: invalid child_pos");
-	    /* insert_child (tb->S[h], tb->S[h-1], child_pos, insert_num, B_N_ITEM_HEAD(tb->S[0],0), insert_ptr);*/
-	    internal_insert_childs (tb->tb_fs, &bi, child_pos, insert_num,
-			B_N_PITEM_HEAD (PATH_PLAST_BUFFER (tb->tb_path), 0), insert_ptr);
-	} else
-	    internal_insert_childs (tb->tb_fs, &bi, child_pos,insert_num,insert_key,insert_ptr);
-    }
-
-
-    memcpy (new_insert_key_addr,&new_insert_key,KEY_SIZE);
-    insert_ptr[0] = new_insert_ptr;
-
-    return order;
-}
+	n = get_blkh_nr_items(B_BLK_HEAD(tbSh));	/*number of items in S[h] */
+
+	if (-1 <= child_pos && child_pos <= n && insert_num > 0) {
+		bi.bi_bh = tbSh;
+		bi.bi_parent = PATH_H_PPARENT(tb->tb_path, h);
+		bi.bi_position = PATH_H_POSITION(tb->tb_path, h + 1);
+		if (child_pos == -1) {
+			/* this is a little different from original do_balance:
+			   here we insert the minimal keys in the tree, that has never happened when file system works */
+			if (tb->CFL[h - 1] || insert_num != 1 || h != 1)
+				die("balance_internal: invalid child_pos");
+			/* insert_child (tb->S[h], tb->S[h-1], child_pos, insert_num, B_N_ITEM_HEAD(tb->S[0],0), insert_ptr); */
+			internal_insert_childs(tb->tb_fs, &bi, child_pos,
+					       insert_num,
+					       B_N_PITEM_HEAD(PATH_PLAST_BUFFER
+							      (tb->tb_path), 0),
+					       insert_ptr);
+		} else
+			internal_insert_childs(tb->tb_fs, &bi, child_pos,
+					       insert_num, insert_key,
+					       insert_ptr);
+	}
 
+	memcpy(new_insert_key_addr, &new_insert_key, KEY_SIZE);
+	insert_ptr[0] = new_insert_ptr;
+
+	return order;
+}
diff --git a/reiserfscore/journal.c b/reiserfscore/journal.c
index 00e1939..a7de25a 100644
--- a/reiserfscore/journal.c
+++ b/reiserfscore/journal.c
@@ -10,173 +10,182 @@
 
 /* compares description block with commit block. returns 0 if they differ, 1
    if they match */
-static int does_desc_match_commit (struct buffer_head *d_bh, 
-			    struct buffer_head *c_bh) 
+static int does_desc_match_commit(struct buffer_head *d_bh,
+				  struct buffer_head *c_bh)
 {
-    return (get_commit_trans_id (c_bh) == get_desc_trans_id (d_bh) &&
-	    get_commit_trans_len (c_bh) == get_desc_trans_len (d_bh));
+	return (get_commit_trans_id(c_bh) == get_desc_trans_id(d_bh) &&
+		get_commit_trans_len(c_bh) == get_desc_trans_len(d_bh));
 }
 
-
 /* d_bh is descriptor, return number of block where commit block of this
    transaction is to be */
-unsigned long commit_expected (reiserfs_filsys_t * fs, struct buffer_head * d_bh)
+unsigned long commit_expected(reiserfs_filsys_t *fs, struct buffer_head *d_bh)
 {
-    unsigned long offset;
-    struct journal_params * sb_jp;
-
-
-    sb_jp = sb_jp (fs->fs_ondisk_sb);
-    //desc = (struct reiserfs_journal_desc *)d_bh->b_data;
-    offset = d_bh->b_blocknr - get_jp_journal_1st_block (sb_jp);
-    return get_jp_journal_1st_block (sb_jp) + 
-	((offset + get_desc_trans_len (d_bh) + 1) % get_jp_journal_size (sb_jp));
+	unsigned long offset;
+	struct journal_params *sb_jp;
+
+	sb_jp = sb_jp(fs->fs_ondisk_sb);
+	//desc = (struct reiserfs_journal_desc *)d_bh->b_data;
+	offset = d_bh->b_blocknr - get_jp_journal_1st_block(sb_jp);
+	return get_jp_journal_1st_block(sb_jp) +
+	    ((offset + get_desc_trans_len(d_bh) +
+	      1) % get_jp_journal_size(sb_jp));
 }
 
-
 /* d_bh contains journal descriptor, returns number of block where descriptor
    block of next transaction should be */
-unsigned long next_desc_expected (reiserfs_filsys_t * fs, struct buffer_head * d_bh)
+unsigned long next_desc_expected(reiserfs_filsys_t *fs,
+				 struct buffer_head *d_bh)
 {
-    unsigned long offset;
-    struct journal_params * sb_jp;
-
-
-    sb_jp = sb_jp (fs->fs_ondisk_sb);
-    //desc = (struct reiserfs_journal_desc *)d_bh->b_data;
-    offset = d_bh->b_blocknr - get_jp_journal_1st_block (sb_jp);
-    return get_jp_journal_1st_block (sb_jp) + 
-	((offset + get_desc_trans_len (d_bh) + 2) % get_jp_journal_size (sb_jp));
+	unsigned long offset;
+	struct journal_params *sb_jp;
+
+	sb_jp = sb_jp(fs->fs_ondisk_sb);
+	//desc = (struct reiserfs_journal_desc *)d_bh->b_data;
+	offset = d_bh->b_blocknr - get_jp_journal_1st_block(sb_jp);
+	return get_jp_journal_1st_block(sb_jp) +
+	    ((offset + get_desc_trans_len(d_bh) +
+	      2) % get_jp_journal_size(sb_jp));
 }
 
 /* common checks for validness of a transaction */
-int transaction_check_content (reiserfs_filsys_t * fs, reiserfs_trans_t * trans) {
-    struct buffer_head *d_bh, *c_bh;
-    struct reiserfs_journal_desc * desc;
-    struct reiserfs_journal_commit * commit;
-    unsigned long block;
-    unsigned int trans_half, i;
-
-    d_bh = bread (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
-
-    if (!d_bh || who_is_this (d_bh->b_data, d_bh->b_size) != THE_JDESC)
-	goto error_desc_brelse;
-
-    /* read expected commit block and compare with descriptor block */
-    c_bh = bread (fs->fs_journal_dev, commit_expected (fs, d_bh), fs->fs_blocksize);
-    if (!c_bh)
-	goto error_desc_brelse;
- 
-    if (!does_desc_match_commit (d_bh, c_bh)) 
-	goto error_commit_brelse;
-
-    /* Check that all target blocks are journalable */
-    desc = (struct reiserfs_journal_desc *)(d_bh->b_data);
-    commit = (struct reiserfs_journal_commit *)(c_bh->b_data);
-
-    trans_half = journal_trans_half (d_bh->b_size);
-    for (i = 0; i < get_desc_trans_len(d_bh); i++) {
-	if (i < trans_half)
-	    block = le32_to_cpu (desc->j2_realblock[i]);
-	else
-	    block = le32_to_cpu (commit->j3_realblock[i - trans_half]);
-
-	if (not_journalable(fs, block)) 
-	    goto error_commit_brelse;
-    }
-    
-    brelse (d_bh);
-    brelse (c_bh);
-    return 1;
-    
+int transaction_check_content(reiserfs_filsys_t *fs, reiserfs_trans_t *trans)
+{
+	struct buffer_head *d_bh, *c_bh;
+	struct reiserfs_journal_desc *desc;
+	struct reiserfs_journal_commit *commit;
+	unsigned long block;
+	unsigned int trans_half, i;
+
+	d_bh = bread(fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
+
+	if (!d_bh || who_is_this(d_bh->b_data, d_bh->b_size) != THE_JDESC)
+		goto error_desc_brelse;
+
+	/* read expected commit block and compare with descriptor block */
+	c_bh =
+	    bread(fs->fs_journal_dev, commit_expected(fs, d_bh),
+		  fs->fs_blocksize);
+	if (!c_bh)
+		goto error_desc_brelse;
+
+	if (!does_desc_match_commit(d_bh, c_bh))
+		goto error_commit_brelse;
+
+	/* Check that all target blocks are journalable */
+	desc = (struct reiserfs_journal_desc *)(d_bh->b_data);
+	commit = (struct reiserfs_journal_commit *)(c_bh->b_data);
+
+	trans_half = journal_trans_half(d_bh->b_size);
+	for (i = 0; i < get_desc_trans_len(d_bh); i++) {
+		if (i < trans_half)
+			block = le32_to_cpu(desc->j2_realblock[i]);
+		else
+			block =
+			    le32_to_cpu(commit->j3_realblock[i - trans_half]);
+
+		if (not_journalable(fs, block))
+			goto error_commit_brelse;
+	}
+
+	brelse(d_bh);
+	brelse(c_bh);
+	return 1;
+
 error_commit_brelse:
-    brelse (c_bh);
+	brelse(c_bh);
 error_desc_brelse:
-    brelse(d_bh);
-    return 0;
+	brelse(d_bh);
+	return 0;
 }
 
 /* common checks for validness of a transaction */
-int transaction_check_desc(reiserfs_filsys_t * fs, struct buffer_head * d_bh) {
-    struct buffer_head * c_bh;
-    int ret = 1;
+int transaction_check_desc(reiserfs_filsys_t *fs, struct buffer_head *d_bh)
+{
+	struct buffer_head *c_bh;
+	int ret = 1;
 
-    if (!d_bh || who_is_this (d_bh->b_data, d_bh->b_size) != THE_JDESC)
-	return 0;
+	if (!d_bh || who_is_this(d_bh->b_data, d_bh->b_size) != THE_JDESC)
+		return 0;
 
-    /* read expected commit block and compare with descriptor block */
-    c_bh = bread (fs->fs_journal_dev, commit_expected (fs, d_bh), fs->fs_blocksize);
-    if (!c_bh)
-	return 0;
- 
-    if (!does_desc_match_commit (d_bh, c_bh)) 
-	ret = 0;
+	/* read expected commit block and compare with descriptor block */
+	c_bh =
+	    bread(fs->fs_journal_dev, commit_expected(fs, d_bh),
+		  fs->fs_blocksize);
+	if (!c_bh)
+		return 0;
 
-    brelse (c_bh);
-    return ret;
-}
+	if (!does_desc_match_commit(d_bh, c_bh))
+		ret = 0;
 
+	brelse(c_bh);
+	return ret;
+}
 
 /* read the journal and find the oldest and newest transactions, return number
    of transactions found */
-int get_boundary_transactions (reiserfs_filsys_t * fs,
-			       reiserfs_trans_t * oldest,
-			       reiserfs_trans_t * newest)
+int get_boundary_transactions(reiserfs_filsys_t *fs,
+			      reiserfs_trans_t *oldest,
+			      reiserfs_trans_t *newest)
 {
-    struct reiserfs_super_block * sb;
-    unsigned long j_cur;
-    unsigned long j_start;
-    unsigned long j_size;
-    struct buffer_head * d_bh;
-    __u32 newest_trans_id, oldest_trans_id, trans_id;
-    int trans_nr;
-
-    sb = fs->fs_ondisk_sb;
-    
-    j_start = get_jp_journal_1st_block (sb_jp (sb));
-    j_size = get_jp_journal_size (sb_jp (sb));
-    
-    oldest_trans_id = 0xffffffff;
-    newest_trans_id = 0;
-
-    trans_nr = 0;
-    for (j_cur = 0; j_cur < j_size; j_cur ++) {
-	d_bh = bread (fs->fs_journal_dev, j_start + j_cur, fs->fs_blocksize);
-	if (!transaction_check_desc (fs, d_bh)) {
-	    brelse (d_bh);
-	    continue;
-	}
-
-	trans_nr ++;
-
-	trans_id = get_desc_trans_id (d_bh);
-	if (trans_id < oldest_trans_id) {
-	    oldest_trans_id = trans_id;
-
-	    oldest->mount_id = get_desc_mount_id (d_bh);
-	    oldest->trans_id = get_desc_trans_id (d_bh);
-	    oldest->desc_blocknr = d_bh->b_blocknr;
-	    oldest->trans_len = get_desc_trans_len (d_bh);
-	    oldest->commit_blocknr = commit_expected (fs, d_bh);
-	    oldest->next_trans_offset = next_desc_expected (fs, d_bh) - j_start;
-	}
-
-	if (trans_id > newest_trans_id) {
-	    newest_trans_id = trans_id;
-
-	    newest->mount_id = get_desc_mount_id (d_bh);
-	    newest->trans_id = get_desc_trans_id (d_bh);
-	    newest->desc_blocknr = d_bh->b_blocknr;
-	    newest->trans_len = get_desc_trans_len (d_bh);
-	    newest->commit_blocknr = commit_expected (fs, d_bh);
-	    newest->next_trans_offset = next_desc_expected (fs, d_bh) - j_start;
+	struct reiserfs_super_block *sb;
+	unsigned long j_cur;
+	unsigned long j_start;
+	unsigned long j_size;
+	struct buffer_head *d_bh;
+	__u32 newest_trans_id, oldest_trans_id, trans_id;
+	int trans_nr;
+
+	sb = fs->fs_ondisk_sb;
+
+	j_start = get_jp_journal_1st_block(sb_jp(sb));
+	j_size = get_jp_journal_size(sb_jp(sb));
+
+	oldest_trans_id = 0xffffffff;
+	newest_trans_id = 0;
+
+	trans_nr = 0;
+	for (j_cur = 0; j_cur < j_size; j_cur++) {
+		d_bh =
+		    bread(fs->fs_journal_dev, j_start + j_cur,
+			  fs->fs_blocksize);
+		if (!transaction_check_desc(fs, d_bh)) {
+			brelse(d_bh);
+			continue;
+		}
+
+		trans_nr++;
+
+		trans_id = get_desc_trans_id(d_bh);
+		if (trans_id < oldest_trans_id) {
+			oldest_trans_id = trans_id;
+
+			oldest->mount_id = get_desc_mount_id(d_bh);
+			oldest->trans_id = get_desc_trans_id(d_bh);
+			oldest->desc_blocknr = d_bh->b_blocknr;
+			oldest->trans_len = get_desc_trans_len(d_bh);
+			oldest->commit_blocknr = commit_expected(fs, d_bh);
+			oldest->next_trans_offset =
+			    next_desc_expected(fs, d_bh) - j_start;
+		}
+
+		if (trans_id > newest_trans_id) {
+			newest_trans_id = trans_id;
+
+			newest->mount_id = get_desc_mount_id(d_bh);
+			newest->trans_id = get_desc_trans_id(d_bh);
+			newest->desc_blocknr = d_bh->b_blocknr;
+			newest->trans_len = get_desc_trans_len(d_bh);
+			newest->commit_blocknr = commit_expected(fs, d_bh);
+			newest->next_trans_offset =
+			    next_desc_expected(fs, d_bh) - j_start;
+		}
+
+		j_cur += get_desc_trans_len(d_bh) + 1;
+		brelse(d_bh);
 	}
 
-	j_cur += get_desc_trans_len (d_bh) + 1;
-	brelse (d_bh);
-    }
-
-    return trans_nr;
+	return trans_nr;
 }
 
 #define TRANS_FOUND     1
@@ -184,471 +193,482 @@ int get_boundary_transactions (reiserfs_filsys_t * fs,
 
 /* trans is a valid transaction. Look for valid transaction with smallest
    trans id which is greater than the id of the current one */
-int next_transaction (reiserfs_filsys_t * fs, reiserfs_trans_t * trans, reiserfs_trans_t break_trans)
+int next_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
+		     reiserfs_trans_t break_trans)
 {
-    struct buffer_head * d_bh, * next_d_bh;
-    int found;
-    unsigned long j_start;
-    unsigned long j_offset;
-    unsigned long block;
+	struct buffer_head *d_bh, *next_d_bh;
+	int found;
+	unsigned long j_start;
+	unsigned long j_offset;
+	unsigned long block;
+
+	j_start = get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb));
+
+	found = TRANS_NOT_FOUND;
+
+	if (trans->trans_id == break_trans.trans_id)
+		return found;
 
+	/* make sure that 'trans' is a valid transaction */
+	d_bh = bread(fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
+	if (!transaction_check_desc(fs, d_bh))
+		die("next_transaction: valid transaction is expected");
 
-    j_start = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));
+	block = next_desc_expected(fs, d_bh);
+	j_offset = block - j_start;
 
-    found = TRANS_NOT_FOUND;
+	while (1) {
+		next_d_bh = bread(fs->fs_journal_dev, block, fs->fs_blocksize);
+		if (transaction_check_desc(fs, next_d_bh))
+			break;
+
+		brelse(next_d_bh);
+		j_offset++;
+		block =
+		    j_start +
+		    (j_offset % get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)));
+	}
+
+	//next_desc = (struct reiserfs_journal_desc *)next_d_bh->b_data;
+
+	if (break_trans.trans_id >= get_desc_trans_id(next_d_bh)) {
+		/* found transaction is newer */
+		trans->mount_id = get_desc_mount_id(next_d_bh);
+		trans->trans_id = get_desc_trans_id(next_d_bh);
+		trans->desc_blocknr = next_d_bh->b_blocknr;
+		trans->trans_len = get_desc_trans_len(next_d_bh);
+		trans->commit_blocknr = commit_expected(fs, next_d_bh);
+		trans->next_trans_offset =
+		    next_desc_expected(fs, next_d_bh) - j_start;
+		found = TRANS_FOUND;
+	}
 
-    if (trans->trans_id == break_trans.trans_id)
+	brelse(d_bh);
+	brelse(next_d_bh);
 	return found;
-	
-    /* make sure that 'trans' is a valid transaction */
-    d_bh = bread (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
-    if (!transaction_check_desc (fs, d_bh))
-	die ("next_transaction: valid transaction is expected");
-
-    block = next_desc_expected (fs, d_bh);
-    j_offset = block - j_start;
-
-    while (1) {
-	next_d_bh = bread (fs->fs_journal_dev, block, fs->fs_blocksize);
-	if (transaction_check_desc (fs, next_d_bh))
-	    break;
-
-	brelse (next_d_bh);
-	j_offset ++;
-	block = j_start + (j_offset % get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)));
-    }
-
-    //next_desc = (struct reiserfs_journal_desc *)next_d_bh->b_data;
-    
-    if (break_trans.trans_id >= get_desc_trans_id (next_d_bh)) {
-	/* found transaction is newer */
-	trans->mount_id = get_desc_mount_id (next_d_bh);
-	trans->trans_id = get_desc_trans_id (next_d_bh);
-	trans->desc_blocknr = next_d_bh->b_blocknr;
-	trans->trans_len = get_desc_trans_len (next_d_bh);
-	trans->commit_blocknr = commit_expected (fs, next_d_bh);
-	trans->next_trans_offset = next_desc_expected (fs, next_d_bh) - j_start;
-	found = TRANS_FOUND;
-    }
-
-    brelse (d_bh);
-    brelse (next_d_bh);
-    return found;
 }
 
-static void read_journal_write_in_place (reiserfs_filsys_t * fs, reiserfs_trans_t * trans, unsigned int index, 
-                                         unsigned long in_journal, unsigned long in_place)
+static void read_journal_write_in_place(reiserfs_filsys_t *fs,
+					reiserfs_trans_t *trans,
+					unsigned int index,
+					unsigned long in_journal,
+					unsigned long in_place)
 {
-    struct buffer_head * j_bh, * bh;
-
-    j_bh = bread (fs->fs_journal_dev, in_journal, fs->fs_blocksize);
-    if (!j_bh) {
-	fprintf (stderr, "replay_one_transaction: transaction %lu: reading %lu block failed\n",
-		 trans->trans_id, in_journal);
-	return;
-    }
-    if (not_journalable (fs, in_place)) {
-	fprintf (stderr, "replay_one_transaction: transaction %lu: block %ld should not be journalled (%lu)\n",
-		 trans->trans_id, in_journal, in_place);
-	brelse (j_bh);
-	return;
-    }
-
-    bh = getblk (fs->fs_dev, in_place, fs->fs_blocksize);
-    
-    memcpy (bh->b_data, j_bh->b_data, bh->b_size);
-    mark_buffer_dirty (bh);
-    mark_buffer_uptodate (bh, 1);
-    bwrite (bh);
-    brelse (bh);
-    brelse (j_bh);
-    
-}
+	struct buffer_head *j_bh, *bh;
 
+	j_bh = bread(fs->fs_journal_dev, in_journal, fs->fs_blocksize);
+	if (!j_bh) {
+		fprintf(stderr,
+			"replay_one_transaction: transaction %lu: reading %lu block failed\n",
+			trans->trans_id, in_journal);
+		return;
+	}
+	if (not_journalable(fs, in_place)) {
+		fprintf(stderr,
+			"replay_one_transaction: transaction %lu: block %ld should not be journalled (%lu)\n",
+			trans->trans_id, in_journal, in_place);
+		brelse(j_bh);
+		return;
+	}
+
+	bh = getblk(fs->fs_dev, in_place, fs->fs_blocksize);
+
+	memcpy(bh->b_data, j_bh->b_data, bh->b_size);
+	mark_buffer_dirty(bh);
+	mark_buffer_uptodate(bh, 1);
+	bwrite(bh);
+	brelse(bh);
+	brelse(j_bh);
+
+}
 
 /* go through all blocks of transaction and call 'action' each of them */
-void for_each_block (reiserfs_filsys_t * fs, reiserfs_trans_t * trans,
-		     action_on_block_t action)
+void for_each_block(reiserfs_filsys_t *fs, reiserfs_trans_t *trans,
+		    action_on_block_t action)
 {
-    struct buffer_head * d_bh, * c_bh;
-    struct reiserfs_journal_desc * desc;
-    struct reiserfs_journal_commit * commit;
-    unsigned long j_start, j_offset, j_size;
-    unsigned int i, trans_half;
-    unsigned long block;
- 
-    d_bh = bread (fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
-    if (!d_bh) {
-	reiserfs_warning (stdout, "reading descriptor block %lu failed\n", trans->desc_blocknr);
-	return;
-    }
-
-    c_bh = bread (fs->fs_journal_dev, trans->commit_blocknr, fs->fs_blocksize);
-    if (!c_bh) {
-	reiserfs_warning (stdout, "reading commit block %lu failed\n", trans->commit_blocknr);
-	brelse (d_bh);
-	return;
-    }
-
-    desc = (struct reiserfs_journal_desc *)(d_bh->b_data);
-    commit = (struct reiserfs_journal_commit *)(c_bh->b_data);
-
-    /* first block of journal and size of journal */
-    j_start = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));
-    j_size = get_jp_journal_size (sb_jp (fs->fs_ondisk_sb));
-
-    /* offset in the journal where the transaction starts */
-    j_offset = trans->desc_blocknr - j_start + 1;
-
-    trans_half = journal_trans_half (d_bh->b_size);
-    for (i = 0; i < trans->trans_len; i ++, j_offset ++) {
-	if (i < trans_half)
-	    block = le32_to_cpu (desc->j2_realblock[i]);
-	else
-	    block = le32_to_cpu (commit->j3_realblock[i - trans_half]);
-	action (fs, trans, i, j_start + (j_offset % j_size), block);
-    }
-
-    brelse (d_bh);
-    brelse (c_bh);
-}
+	struct buffer_head *d_bh, *c_bh;
+	struct reiserfs_journal_desc *desc;
+	struct reiserfs_journal_commit *commit;
+	unsigned long j_start, j_offset, j_size;
+	unsigned int i, trans_half;
+	unsigned long block;
+
+	d_bh = bread(fs->fs_journal_dev, trans->desc_blocknr, fs->fs_blocksize);
+	if (!d_bh) {
+		reiserfs_warning(stdout,
+				 "reading descriptor block %lu failed\n",
+				 trans->desc_blocknr);
+		return;
+	}
 
+	c_bh =
+	    bread(fs->fs_journal_dev, trans->commit_blocknr, fs->fs_blocksize);
+	if (!c_bh) {
+		reiserfs_warning(stdout, "reading commit block %lu failed\n",
+				 trans->commit_blocknr);
+		brelse(d_bh);
+		return;
+	}
+
+	desc = (struct reiserfs_journal_desc *)(d_bh->b_data);
+	commit = (struct reiserfs_journal_commit *)(c_bh->b_data);
+
+	/* first block of journal and size of journal */
+	j_start = get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb));
+	j_size = get_jp_journal_size(sb_jp(fs->fs_ondisk_sb));
+
+	/* offset in the journal where the transaction starts */
+	j_offset = trans->desc_blocknr - j_start + 1;
+
+	trans_half = journal_trans_half(d_bh->b_size);
+	for (i = 0; i < trans->trans_len; i++, j_offset++) {
+		if (i < trans_half)
+			block = le32_to_cpu(desc->j2_realblock[i]);
+		else
+			block =
+			    le32_to_cpu(commit->j3_realblock[i - trans_half]);
+		action(fs, trans, i, j_start + (j_offset % j_size), block);
+	}
+
+	brelse(d_bh);
+	brelse(c_bh);
+}
 
 /* transaction is supposed to be valid */
-int replay_one_transaction (reiserfs_filsys_t * fs,
-			    reiserfs_trans_t * trans)
+int replay_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans)
 {
-    for_each_block (fs, trans, read_journal_write_in_place);
-    fsync(fs->fs_dev);
-    return 0;
+	for_each_block(fs, trans, read_journal_write_in_place);
+	fsync(fs->fs_dev);
+	return 0;
 }
 
-
-void for_each_transaction (reiserfs_filsys_t * fs, action_on_trans_t action)
+void for_each_transaction(reiserfs_filsys_t *fs, action_on_trans_t action)
 {
-    reiserfs_trans_t oldest, newest;
-    int ret = 0;
+	reiserfs_trans_t oldest, newest;
+	int ret = 0;
 
-    if (!get_boundary_transactions (fs, &oldest, &newest))
-	return;
+	if (!get_boundary_transactions(fs, &oldest, &newest))
+		return;
 
-    while (1) {
-	action (fs, &oldest);	
-	if ((ret = next_transaction (fs, &oldest, newest)) == TRANS_NOT_FOUND)
-	    break;
-    }
+	while (1) {
+		action(fs, &oldest);
+		if ((ret =
+		     next_transaction(fs, &oldest, newest)) == TRANS_NOT_FOUND)
+			break;
+	}
 }
 
-unsigned long get_size_of_journal_or_reserved_area(
-    struct reiserfs_super_block * sb)
+unsigned long get_size_of_journal_or_reserved_area(struct reiserfs_super_block
+						   *sb)
 {
-	if (is_reiserfs_jr_magic_string (sb))
-		return get_sb_reserved_for_journal (sb);
+	if (is_reiserfs_jr_magic_string(sb))
+		return get_sb_reserved_for_journal(sb);
 
 	/* with standard journal */
-	return get_jp_journal_size (sb_jp (sb)) + 1;
+	return get_jp_journal_size(sb_jp(sb)) + 1;
 }
 
-
-__u32 advise_journal_max_trans_len (__u32 desired, __u32 journal_size /* no j_header */, 
-    int blocksize, int verbose)
+__u32 advise_journal_max_trans_len(__u32 desired,
+				   __u32 journal_size /* no j_header */ ,
+				   int blocksize, int verbose)
 {
-    __u32 saved;
-    __u32 ratio = 1;
-
-    if (blocksize < 4096)
-	ratio = 4096/blocksize;
-	
-    saved = desired;
-    if (!desired)
-		desired = JOURNAL_TRANS_MAX/ratio;
-    
-    if (journal_size / desired < JOURNAL_MIN_RATIO)
+	__u32 saved;
+	__u32 ratio = 1;
+
+	if (blocksize < 4096)
+		ratio = 4096 / blocksize;
+
+	saved = desired;
+	if (!desired)
+		desired = JOURNAL_TRANS_MAX / ratio;
+
+	if (journal_size / desired < JOURNAL_MIN_RATIO)
 		desired = journal_size / JOURNAL_MIN_RATIO;
-    
-    if (desired > JOURNAL_TRANS_MAX/ratio)
-		desired = JOURNAL_TRANS_MAX/ratio;
-    
-    if (desired < JOURNAL_TRANS_MIN/ratio)
-		desired = JOURNAL_TRANS_MIN/ratio;
-
-    if (verbose) {
-	if (saved && saved != desired)
-		reiserfs_warning (stderr,
-		    "WARNING: wrong transaction max size (%u). Changed to %u\n", 
-		    saved, desired);
-    }
-
-    return desired;
-}
-#if 0
-    __u32 ret_val;
-    ret_val = 0;
-    if (!desired)                   ret_val = JOURNAL_TRANS_MAX;
-    if (desired<journal_size/8)     ret_val = journal_size/8;
-    if (desired>journal_size/2)     ret_val = journal_size/2;
-    if (desired>JOURNAL_TRANS_MAX)  ret_val = JOURNAL_TRANS_MAX;
-    if (ret_val) {
-        reiserfs_warning (stderr, "WARNING: Journal max trans length is wrong seting: %u, resetting to available possible %u\n",
-                          desired, ret_val);
-    } else {
-        ret_val = desired;
-    }
-    return ret_val;
+
+	if (desired > JOURNAL_TRANS_MAX / ratio)
+		desired = JOURNAL_TRANS_MAX / ratio;
+
+	if (desired < JOURNAL_TRANS_MIN / ratio)
+		desired = JOURNAL_TRANS_MIN / ratio;
+
+	if (verbose) {
+		if (saved && saved != desired)
+			reiserfs_warning(stderr,
+					 "WARNING: wrong transaction max size (%u). Changed to %u\n",
+					 saved, desired);
+	}
+
+	return desired;
 }
-#endif
 
-__u32 advise_journal_max_batch (unsigned long journal_trans_max)
+__u32 advise_journal_max_batch(unsigned long journal_trans_max)
 {
-    return journal_trans_max*JOURNAL_MAX_BATCH/JOURNAL_TRANS_MAX;
+	return journal_trans_max * JOURNAL_MAX_BATCH / JOURNAL_TRANS_MAX;
 }
 
-
-__u32 advise_journal_max_commit_age (void)
+__u32 advise_journal_max_commit_age(void)
 {
-    return JOURNAL_MAX_COMMIT_AGE;
+	return JOURNAL_MAX_COMMIT_AGE;
 }
 
-
-__u32 advise_journal_max_trans_age (void)
+__u32 advise_journal_max_trans_age(void)
 {
-    return JOURNAL_MAX_TRANS_AGE;
+	return JOURNAL_MAX_TRANS_AGE;
 }
 
-
-int reiserfs_journal_params_check (reiserfs_filsys_t * fs) {
-    struct reiserfs_journal_header * j_head;
-    struct reiserfs_super_block * sb = fs->fs_ondisk_sb;
-    
-    j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
-	
-    /* Check the superblock's journal parameters. */
-    if (!is_reiserfs_jr_magic_string (sb)) {    
-	if (get_jp_journal_dev (sb_jp(sb)) != 0 || 
-	    get_jp_journal_1st_block (sb_jp(sb)) != get_journal_start_must (fs) || 
-	    get_jp_journal_size (sb_jp(sb)) != 
-	    journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
-	{
-	    reiserfs_warning (stderr, 
-		"\nreiserfs_open_journal: wrong journal parameters found in the "
-		"super block. \nYou should run reiserfsck with --rebuild-sb to "
-		"check your superblock consistency.\n\n");
-		
-	    return 1;
+int reiserfs_journal_params_check(reiserfs_filsys_t *fs)
+{
+	struct reiserfs_journal_header *j_head;
+	struct reiserfs_super_block *sb = fs->fs_ondisk_sb;
+
+	j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
+
+	/* Check the superblock's journal parameters. */
+	if (!is_reiserfs_jr_magic_string(sb)) {
+		if (get_jp_journal_dev(sb_jp(sb)) != 0 ||
+		    get_jp_journal_1st_block(sb_jp(sb)) !=
+		    get_journal_start_must(fs)
+		    || get_jp_journal_size(sb_jp(sb)) !=
+		    journal_default_size(fs->fs_super_bh->b_blocknr,
+					 fs->fs_blocksize)) {
+			reiserfs_warning(stderr,
+					 "\nreiserfs_open_journal: wrong journal parameters found in the "
+					 "super block. \nYou should run reiserfsck with --rebuild-sb to "
+					 "check your superblock consistency.\n\n");
+
+			return 1;
+		}
 	}
-    }
-	
-    if (memcmp(&j_head->jh_journal, sb_jp (sb), sizeof(struct journal_params))) {
-	if (!is_reiserfs_jr_magic_string (sb)) {
-	    reiserfs_warning (stderr, 
-		"\nreiserfs_open_journal: journal parameters from the superblock "
-		"does not match \nto the journal headers ones. It looks like that "
-		"you created your fs with old\nreiserfsprogs. Journal header is "
-		"fixed.\n\n", fs->fs_j_file_name);
-		
-	    memcpy(&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params));
-	    mark_buffer_dirty(fs->fs_jh_bh);
-	    bwrite(fs->fs_jh_bh);
-	} else {
-	    reiserfs_warning (stderr,
-		"\nreiserfs_open_journal: journal parameters from the super block "
-		"does not match \nto journal parameters from the journal. You should "
-		"run  reiserfsck with --rebuild-sb to check your superblock consistency.\n\n");
-		
-	    return 1;	
+
+	if (memcmp
+	    (&j_head->jh_journal, sb_jp(sb), sizeof(struct journal_params))) {
+		if (!is_reiserfs_jr_magic_string(sb)) {
+			reiserfs_warning(stderr,
+					 "\nreiserfs_open_journal: journal parameters from the superblock "
+					 "does not match \nto the journal headers ones. It looks like that "
+					 "you created your fs with old\nreiserfsprogs. Journal header is "
+					 "fixed.\n\n", fs->fs_j_file_name);
+
+			memcpy(&j_head->jh_journal, sb_jp(sb),
+			       sizeof(struct journal_params));
+			mark_buffer_dirty(fs->fs_jh_bh);
+			bwrite(fs->fs_jh_bh);
+		} else {
+			reiserfs_warning(stderr,
+					 "\nreiserfs_open_journal: journal parameters from the super block "
+					 "does not match \nto journal parameters from the journal. You should "
+					 "run  reiserfsck with --rebuild-sb to check your superblock consistency.\n\n");
+
+			return 1;
+		}
 	}
-    }
-    
-    return 0;
+
+	return 0;
 }
 
 /* read journal header and make sure that it matches with the filesystem
    opened */
-int reiserfs_open_journal (reiserfs_filsys_t * fs, char * j_filename, int flags) {
-    struct reiserfs_super_block * sb;
-    __u64 count;
-    
-    sb = fs->fs_ondisk_sb;
-
-    if (!j_filename) {
-	/*
-        if (is_reiserfs_jr_magic_string (sb)) {
-            // create a special file to access journal
-            return 1;
-        } */
-	
-	j_filename = fs->fs_file_name;
-    } else if (!is_reiserfs_jr_magic_string (sb)) {
-        /* make sure that name specified is a correct name */
-	if (strcmp (j_filename, fs->fs_file_name)) {
-	    reiserfs_warning (stderr, "Filesystem with standard journal found, "
-		"wrong name of specified journal device %s \n", j_filename);
-	    return 2;
+int reiserfs_open_journal(reiserfs_filsys_t *fs, char *j_filename, int flags)
+{
+	struct reiserfs_super_block *sb;
+	__u64 count;
+
+	sb = fs->fs_ondisk_sb;
+
+	if (!j_filename) {
+		/*
+		   if (is_reiserfs_jr_magic_string (sb)) {
+		   // create a special file to access journal
+		   return 1;
+		   } */
+
+		j_filename = fs->fs_file_name;
+	} else if (!is_reiserfs_jr_magic_string(sb)) {
+		/* make sure that name specified is a correct name */
+		if (strcmp(j_filename, fs->fs_file_name)) {
+			reiserfs_warning(stderr,
+					 "Filesystem with standard journal found, "
+					 "wrong name of specified journal device %s \n",
+					 j_filename);
+			return 2;
+		}
 	}
-    }
 
-    fs->fs_journal_dev = open (j_filename, flags 
+	fs->fs_journal_dev = open(j_filename, flags
 #if defined(O_LARGEFILE)
-			       | O_LARGEFILE
+				  | O_LARGEFILE
 #endif
-			       );
-    if (fs->fs_journal_dev == -1) 
-        return -1;
-    
-    asprintf (&fs->fs_j_file_name, "%s", j_filename);
-    
-    if (get_jp_journal_size(sb_jp(sb)) < JOURNAL_MIN_SIZE) {
-	reiserfs_warning (stderr, "Journal of (%lu) block size found on "
-	    "specified journal device %s.\nMust be not less than (%lu).\n",
-	    get_jp_journal_size (sb_jp (sb)) + 1, j_filename, 
-	    JOURNAL_MIN_SIZE + 1);
-	close(fs->fs_journal_dev);
-	return 1;
-    }
-    
-    if (!(count = count_blocks (j_filename, fs->fs_blocksize))) {
-	close(fs->fs_journal_dev);
-	return -1;
-    }
-
-    if (get_jp_journal_1st_block (sb_jp (sb)) + 
-	get_jp_journal_size (sb_jp (sb)) + 1 > count) 
-    {
-	reiserfs_warning (stderr, "Detected journal on specified device %s "
-			  "does not fit to the device.\nStart block (%lu) + "
-			  "size (%lu) less than device size (%lu).\n", 
-			  j_filename, get_jp_journal_1st_block(sb_jp (sb)), 
-			  get_jp_journal_size(sb_jp (sb)) + 1, count);
-	close(fs->fs_journal_dev);
-	return 1;
-    }
-    
-    /* read journal header */
-    fs->fs_jh_bh = bread (fs->fs_journal_dev, 
-			  get_jp_journal_1st_block (sb_jp (sb)) + 
-			  get_jp_journal_size (sb_jp (sb)), 
-			  fs->fs_blocksize);
-
-    if (!fs->fs_jh_bh) {
-	reiserfs_warning (stderr, "reiserfs_open_journal: bread failed "
-			  "reading journal  header.\n");
-	close(fs->fs_journal_dev);
-	return -1;
-    }
-
-    return 0;
-}
+	    );
+	if (fs->fs_journal_dev == -1)
+		return -1;
+
+	asprintf(&fs->fs_j_file_name, "%s", j_filename);
+
+	if (get_jp_journal_size(sb_jp(sb)) < JOURNAL_MIN_SIZE) {
+		reiserfs_warning(stderr, "Journal of (%lu) block size found on "
+				 "specified journal device %s.\nMust be not less than (%lu).\n",
+				 get_jp_journal_size(sb_jp(sb)) + 1, j_filename,
+				 JOURNAL_MIN_SIZE + 1);
+		close(fs->fs_journal_dev);
+		return 1;
+	}
 
-/* initialize super block's journal related fields and journal header fields. 
- * If len is 0 - make journal of default size */
-int reiserfs_create_journal(
-    reiserfs_filsys_t * fs, 
-    char * j_device,		/* journal device name */
-    unsigned long offset,	/* journal offset on the j_device */
-    unsigned long len,		/* including journal header */
-    int transaction_max_size,
-    int force)
-{
-    struct stat st;
-    struct buffer_head * bh;
-    struct reiserfs_journal_header * jh;
-    struct reiserfs_super_block * sb;
-    unsigned long blocks;
-
-    sb = fs->fs_ondisk_sb;
-    
-    if (!j_device || !strcmp (j_device, fs->fs_file_name)) {
-	/* Journal is to be on the host device, check the amount space for the 
-	 * journal on it. */
-	len = len ? len : journal_default_size(fs->fs_super_bh->b_blocknr, 
-	    fs->fs_blocksize) + 1;
-		
-	offset = offset ? offset : get_journal_start_must(fs);
-	
-	if (offset < get_journal_start_must(fs)) {
-	    reiserfs_warning (stderr, "reiserfs_create_journal: offset is "
-		"%lu, but it cannot be less then %llu on the device %s\n", 
-		offset, get_journal_start_must(fs), j_device);
-	    return 0;
+	if (!(count = count_blocks(j_filename, fs->fs_blocksize))) {
+		close(fs->fs_journal_dev);
+		return -1;
 	}
-	
-	if (!is_block_count_correct(offset, fs->fs_blocksize, 
-	    get_sb_block_count(sb), len)) 
-	{
-	    /* host device does not contain enough blocks */
-	    reiserfs_warning (stderr, "reiserfs_create_journal: cannot create "
-		"a journal of %lu blocks with %lu offset on %u blocks\n",
-		len, offset, get_sb_block_count(sb));
-		return 0;
+
+	if (get_jp_journal_1st_block(sb_jp(sb)) +
+	    get_jp_journal_size(sb_jp(sb)) + 1 > count) {
+		reiserfs_warning(stderr,
+				 "Detected journal on specified device %s "
+				 "does not fit to the device.\nStart block (%lu) + "
+				 "size (%lu) less than device size (%lu).\n",
+				 j_filename,
+				 get_jp_journal_1st_block(sb_jp(sb)),
+				 get_jp_journal_size(sb_jp(sb)) + 1, count);
+		close(fs->fs_journal_dev);
+		return 1;
 	}
-	
-	j_device = fs->fs_file_name;
-	
-	
-	st.st_rdev = 0;
-    } else {
-	/* journal is to be on separate device */
-	if (!(blocks = count_blocks (j_device, fs->fs_blocksize)))
-		return 0;
 
-	if (!len) {
-	    /* default size of a journal on a separate device is whole device */
-	    if (blocks < offset) {
-		reiserfs_warning (stderr, "reiserfs_create_journal: offset is "
-		    "%lu, blocks on device %lu\n", offset, blocks);
-		return 0;
-	    }
-	    /* XXX jdm: This can end up being huge and could result
-	     * in an unmountable file system:
-	     * len = blocks - offset; */
-	    len = journal_default_size(fs->fs_super_bh->b_blocknr,
-	                               fs->fs_blocksize) + 1;
+	/* read journal header */
+	fs->fs_jh_bh = bread(fs->fs_journal_dev,
+			     get_jp_journal_1st_block(sb_jp(sb)) +
+			     get_jp_journal_size(sb_jp(sb)), fs->fs_blocksize);
 
+	if (!fs->fs_jh_bh) {
+		reiserfs_warning(stderr, "reiserfs_open_journal: bread failed "
+				 "reading journal  header.\n");
+		close(fs->fs_journal_dev);
+		return -1;
 	}
 
-	if (!force && len > journal_default_size (fs->fs_super_bh->b_blocknr,
-	    fs->fs_blocksize) + 1) 
-	{
-	    unsigned long journal_max = journal_max_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize);
-	    fflush(stderr);
-	    
-	    reiserfs_warning (stdout, "\n*** You've specified a journal "
-	                      "size larger than the default size of "
-	                      "%lu\n*** blocks. This may slow down "
-	                      "journal initialization and mounting "
-	                      "of\n*** the file system.%s",
-	                      journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1,
-	                      len > journal_max ? " " : "\n");
-	    if (len > journal_max)
-		reiserfs_warning (stdout, "On 32-bit systems, and on "
-		                  "64-bit systems with\n*** limited "
-		                  "memory, this may also cause the file "
-		                  "system to be unmountable.\n*** Please "
-		                  "consider using a journal size "
-		                  "<= %lu blocks.\n\nFile system creation "
-				  "failed. You may override this behavior "
-				  "with the -f option.\n", journal_max);
-		    return 0;
-	}
+	return 0;
+}
 
-	if (len < blocks)
-		reiserfs_warning (stdout, "\n\n*** Your journal device is %lu "
-		                  "blocks, but your journal is only %lu "
-				  "blocks.\n*** You may want to consider "
-				  "resizing the journal device to avoid "
-				  "wasting space.\n\n", blocks, len);
-
-	if (blocks < offset + len) {
-	    reiserfs_warning (stderr, "reiserfs_create_journal: no enough "
-		"blocks on device %lu, needed %lu\n", blocks, offset + len);
-	    return 0;
-	}
-	
-	if (stat (j_device, &st) == -1) {
-	    reiserfs_warning (stderr, "reiserfs_create_journal: stat %s failed"
-		": %s\n", j_device, strerror(errno));
-	    return 0;
-	}
+/* initialize super block's journal related fields and journal header fields. 
+ * If len is 0 - make journal of default size */
+int reiserfs_create_journal(reiserfs_filsys_t *fs, char *j_device,	/* journal device name */
+			    unsigned long offset,	/* journal offset on the j_device */
+			    unsigned long len,	/* including journal header */
+			    int transaction_max_size, int force)
+{
+	struct stat st;
+	struct buffer_head *bh;
+	struct reiserfs_journal_header *jh;
+	struct reiserfs_super_block *sb;
+	unsigned long blocks;
+
+	sb = fs->fs_ondisk_sb;
+
+	if (!j_device || !strcmp(j_device, fs->fs_file_name)) {
+		/* Journal is to be on the host device, check the amount space for the 
+		 * journal on it. */
+		len =
+		    len ? len : journal_default_size(fs->fs_super_bh->b_blocknr,
+						     fs->fs_blocksize) + 1;
+
+		offset = offset ? offset : get_journal_start_must(fs);
+
+		if (offset < get_journal_start_must(fs)) {
+			reiserfs_warning(stderr,
+					 "reiserfs_create_journal: offset is "
+					 "%lu, but it cannot be less then %llu on the device %s\n",
+					 offset, get_journal_start_must(fs),
+					 j_device);
+			return 0;
+		}
+
+		if (!is_block_count_correct(offset, fs->fs_blocksize,
+					    get_sb_block_count(sb), len)) {
+			/* host device does not contain enough blocks */
+			reiserfs_warning(stderr,
+					 "reiserfs_create_journal: cannot create "
+					 "a journal of %lu blocks with %lu offset on %u blocks\n",
+					 len, offset, get_sb_block_count(sb));
+			return 0;
+		}
+
+		j_device = fs->fs_file_name;
+
+		st.st_rdev = 0;
+	} else {
+		/* journal is to be on separate device */
+		if (!(blocks = count_blocks(j_device, fs->fs_blocksize)))
+			return 0;
+
+		if (!len) {
+			/* default size of a journal on a separate device is whole device */
+			if (blocks < offset) {
+				reiserfs_warning(stderr,
+						 "reiserfs_create_journal: offset is "
+						 "%lu, blocks on device %lu\n",
+						 offset, blocks);
+				return 0;
+			}
+			/* XXX jdm: This can end up being huge and could result
+			 * in an unmountable file system:
+			 * len = blocks - offset; */
+			len = journal_default_size(fs->fs_super_bh->b_blocknr,
+						   fs->fs_blocksize) + 1;
+
+		}
+
+		if (!force
+		    && len > journal_default_size(fs->fs_super_bh->b_blocknr,
+						  fs->fs_blocksize) + 1) {
+			unsigned long journal_max =
+			    journal_max_size(fs->fs_super_bh->b_blocknr,
+					     fs->fs_blocksize);
+			fflush(stderr);
+
+			reiserfs_warning(stdout,
+					 "\n*** You've specified a journal "
+					 "size larger than the default size of "
+					 "%lu\n*** blocks. This may slow down "
+					 "journal initialization and mounting "
+					 "of\n*** the file system.%s",
+					 journal_default_size(fs->fs_super_bh->
+							      b_blocknr,
+							      fs->
+							      fs_blocksize) + 1,
+					 len > journal_max ? " " : "\n");
+			if (len > journal_max)
+				reiserfs_warning(stdout,
+						 "On 32-bit systems, and on "
+						 "64-bit systems with\n*** limited "
+						 "memory, this may also cause the file "
+						 "system to be unmountable.\n*** Please "
+						 "consider using a journal size "
+						 "<= %lu blocks.\n\nFile system creation "
+						 "failed. You may override this behavior "
+						 "with the -f option.\n",
+						 journal_max);
+			return 0;
+		}
+
+		if (len < blocks)
+			reiserfs_warning(stdout,
+					 "\n\n*** Your journal device is %lu "
+					 "blocks, but your journal is only %lu "
+					 "blocks.\n*** You may want to consider "
+					 "resizing the journal device to avoid "
+					 "wasting space.\n\n", blocks, len);
+
+		if (blocks < offset + len) {
+			reiserfs_warning(stderr,
+					 "reiserfs_create_journal: no enough "
+					 "blocks on device %lu, needed %lu\n",
+					 blocks, offset + len);
+			return 0;
+		}
+
+		if (stat(j_device, &st) == -1) {
+			reiserfs_warning(stderr,
+					 "reiserfs_create_journal: stat %s failed"
+					 ": %s\n", j_device, strerror(errno));
+			return 0;
+		}
 /*
 	if (!S_ISBLK (st.st_mode)) {
 		reiserfs_warning (stderr, "reiserfs_create_journal: "
@@ -656,232 +676,242 @@ int reiserfs_create_journal(
 		return 0;
 	}
 */
-    }
+	}
 
-    fs->fs_journal_dev = open (j_device, O_RDWR 
+	fs->fs_journal_dev = open(j_device, O_RDWR
 #if defined(O_LARGEFILE)
-			       | O_LARGEFILE
+				  | O_LARGEFILE
 #endif
-			       );
-    if (fs->fs_journal_dev == -1) {
-	reiserfs_warning (stderr, "reiserfs_create_journal: could not open "
-	    "%s: %s\n", j_device, strerror(errno));
-	return 0;
-    }
-
-    asprintf (&fs->fs_j_file_name, "%s", j_device);
-
-    if (len < JOURNAL_MIN_SIZE + 1) {
-	reiserfs_warning (stderr, "WARNING: Journal size (%u) is less, than "
-	    "minimal supported journal size (%u).\n", len, JOURNAL_MIN_SIZE + 1);
-        return 0;
-    }
-    /* get journal header */
-    bh = getblk (fs->fs_journal_dev, offset + len - 1, fs->fs_blocksize);
-    if (!bh) {
-	reiserfs_warning (stderr, "reiserfs_create_journal: getblk failed\n");
-	return 0;
-    }
-
-    /* fill journal header */
-    jh = (struct reiserfs_journal_header *)bh->b_data;
-    set_jp_journal_1st_block(&jh->jh_journal, offset);
-    set_jp_journal_dev(&jh->jh_journal, st.st_rdev);
-    set_jp_journal_magic(&jh->jh_journal, get_random());
-
-    set_jp_journal_size(&jh->jh_journal, len - 1);
-    set_jp_journal_max_trans_len(&jh->jh_journal, advise_journal_max_trans_len(
-	transaction_max_size, len - 1, fs->fs_blocksize, 1));
-    set_jp_journal_max_batch(&jh->jh_journal, advise_journal_max_batch(
-	get_jp_journal_max_trans_len(&jh->jh_journal)));
-    set_jp_journal_max_commit_age(&jh->jh_journal, 
-	advise_journal_max_commit_age());
-    set_jp_journal_max_trans_age(&jh->jh_journal, 
-	advise_journal_max_trans_age ());
-
-    mark_buffer_uptodate (bh, 1);
-    mark_buffer_dirty (bh);
-    
-    fs->fs_jh_bh = bh;
-    
-    /* make a copy of journal header in the super block */
-    memcpy (sb_jp (sb), &jh->jh_journal, sizeof (struct journal_params));
-    mark_buffer_dirty (fs->fs_super_bh);
-
-    return 1;
-}
+	    );
+	if (fs->fs_journal_dev == -1) {
+		reiserfs_warning(stderr,
+				 "reiserfs_create_journal: could not open "
+				 "%s: %s\n", j_device, strerror(errno));
+		return 0;
+	}
+
+	asprintf(&fs->fs_j_file_name, "%s", j_device);
 
+	if (len < JOURNAL_MIN_SIZE + 1) {
+		reiserfs_warning(stderr,
+				 "WARNING: Journal size (%u) is less, than "
+				 "minimal supported journal size (%u).\n", len,
+				 JOURNAL_MIN_SIZE + 1);
+		return 0;
+	}
+	/* get journal header */
+	bh = getblk(fs->fs_journal_dev, offset + len - 1, fs->fs_blocksize);
+	if (!bh) {
+		reiserfs_warning(stderr,
+				 "reiserfs_create_journal: getblk failed\n");
+		return 0;
+	}
+
+	/* fill journal header */
+	jh = (struct reiserfs_journal_header *)bh->b_data;
+	set_jp_journal_1st_block(&jh->jh_journal, offset);
+	set_jp_journal_dev(&jh->jh_journal, st.st_rdev);
+	set_jp_journal_magic(&jh->jh_journal, get_random());
+
+	set_jp_journal_size(&jh->jh_journal, len - 1);
+	set_jp_journal_max_trans_len(&jh->jh_journal,
+				     advise_journal_max_trans_len
+				     (transaction_max_size, len - 1,
+				      fs->fs_blocksize, 1));
+	set_jp_journal_max_batch(&jh->jh_journal,
+				 advise_journal_max_batch
+				 (get_jp_journal_max_trans_len
+				  (&jh->jh_journal)));
+	set_jp_journal_max_commit_age(&jh->jh_journal,
+				      advise_journal_max_commit_age());
+	set_jp_journal_max_trans_age(&jh->jh_journal,
+				     advise_journal_max_trans_age());
+
+	mark_buffer_uptodate(bh, 1);
+	mark_buffer_dirty(bh);
+
+	fs->fs_jh_bh = bh;
+
+	/* make a copy of journal header in the super block */
+	memcpy(sb_jp(sb), &jh->jh_journal, sizeof(struct journal_params));
+	mark_buffer_dirty(fs->fs_super_bh);
+
+	return 1;
+}
 
 /* brelse journal header, flush all dirty buffers, close device, open, read
    journal header */
-void reiserfs_reopen_journal (reiserfs_filsys_t * fs, int flag)
+void reiserfs_reopen_journal(reiserfs_filsys_t *fs, int flag)
 {
-    unsigned long jh_block;
+	unsigned long jh_block;
 
+	if (!reiserfs_journal_opened(fs))
+		return;
 
-    if (!reiserfs_journal_opened (fs))
-	return;
-
-    jh_block = fs->fs_jh_bh->b_blocknr;
-    brelse (fs->fs_jh_bh);
-    flush_buffers (fs->fs_journal_dev);
-    invalidate_buffers (fs->fs_journal_dev);
-    if (close (fs->fs_journal_dev))
-	die ("reiserfs_reopen_journal: closed failed: %s", strerror(errno));
+	jh_block = fs->fs_jh_bh->b_blocknr;
+	brelse(fs->fs_jh_bh);
+	flush_buffers(fs->fs_journal_dev);
+	invalidate_buffers(fs->fs_journal_dev);
+	if (close(fs->fs_journal_dev))
+		die("reiserfs_reopen_journal: closed failed: %s",
+		    strerror(errno));
 
-    fs->fs_journal_dev = open (fs->fs_j_file_name, flag 
+	fs->fs_journal_dev = open(fs->fs_j_file_name, flag
 #if defined(O_LARGEFILE)
-			       | O_LARGEFILE
+				  | O_LARGEFILE
 #endif
-			       );
-    if (fs->fs_journal_dev == -1)
-	die ("reiserfs_reopen_journal: could not reopen journal device");
+	    );
+	if (fs->fs_journal_dev == -1)
+		die("reiserfs_reopen_journal: could not reopen journal device");
 
-    fs->fs_jh_bh = bread (fs->fs_journal_dev, jh_block, fs->fs_blocksize);
-    if (!fs->fs_jh_bh)
-	die ("reiserfs_reopen_journal: reading journal header failed");
+	fs->fs_jh_bh = bread(fs->fs_journal_dev, jh_block, fs->fs_blocksize);
+	if (!fs->fs_jh_bh)
+		die("reiserfs_reopen_journal: reading journal header failed");
 }
 
-
-int reiserfs_journal_opened (reiserfs_filsys_t * fs)
+int reiserfs_journal_opened(reiserfs_filsys_t *fs)
 {
-    return fs->fs_jh_bh ? 1 : 0;
+	return fs->fs_jh_bh ? 1 : 0;
 }
 
-
-void reiserfs_flush_journal (reiserfs_filsys_t * fs)
+void reiserfs_flush_journal(reiserfs_filsys_t *fs)
 {
-    if (!reiserfs_journal_opened (fs))
+	if (!reiserfs_journal_opened(fs))
 		return;
-    flush_buffers (fs->fs_journal_dev);
+	flush_buffers(fs->fs_journal_dev);
 }
 
-
-void reiserfs_free_journal (reiserfs_filsys_t * fs)
+void reiserfs_free_journal(reiserfs_filsys_t *fs)
 {
-    if (!reiserfs_journal_opened (fs))
+	if (!reiserfs_journal_opened(fs))
 		return;
-    brelse (fs->fs_jh_bh);
-    fs->fs_jh_bh = 0;
-    free (fs->fs_j_file_name);
-    fs->fs_j_file_name = 0;
+	brelse(fs->fs_jh_bh);
+	fs->fs_jh_bh = 0;
+	free(fs->fs_j_file_name);
+	fs->fs_j_file_name = 0;
 }
 
-
-void reiserfs_close_journal (reiserfs_filsys_t * fs)
+void reiserfs_close_journal(reiserfs_filsys_t *fs)
 {
-    reiserfs_flush_journal (fs);
-    reiserfs_free_journal (fs);
+	reiserfs_flush_journal(fs);
+	reiserfs_free_journal(fs);
 
 }
 
 /* update journal header */
-static void update_journal_header (reiserfs_filsys_t * fs, 
-				   struct buffer_head * bh_jh, 
-				   reiserfs_trans_t *trans) 
+static void update_journal_header(reiserfs_filsys_t *fs,
+				  struct buffer_head *bh_jh,
+				  reiserfs_trans_t *trans)
 {
-    struct reiserfs_journal_header * j_head;
-	
-    j_head = (struct reiserfs_journal_header *)(bh_jh->b_data);
-
-    /* update journal header */
-    set_jh_last_flushed (j_head, trans->trans_id);
-    set_jh_mount_id (j_head, trans->mount_id);
-    set_jh_replay_start_offset (j_head, trans->next_trans_offset);
-    mark_buffer_dirty (bh_jh);
-    bwrite (bh_jh);
-    fsync(fs->fs_journal_dev);
+	struct reiserfs_journal_header *j_head;
+
+	j_head = (struct reiserfs_journal_header *)(bh_jh->b_data);
+
+	/* update journal header */
+	set_jh_last_flushed(j_head, trans->trans_id);
+	set_jh_mount_id(j_head, trans->mount_id);
+	set_jh_replay_start_offset(j_head, trans->next_trans_offset);
+	mark_buffer_dirty(bh_jh);
+	bwrite(bh_jh);
+	fsync(fs->fs_journal_dev);
 }
 
 /* fixme: what should be done when not all transactions can be replayed in proper order? */
-int replay_journal (reiserfs_filsys_t * fs)
+int replay_journal(reiserfs_filsys_t *fs)
 {
-    struct buffer_head * bh;
-    struct reiserfs_journal_header * j_head;
-    reiserfs_trans_t cur, newest, control;
-    int replayed, ret;
-    struct progbar progbar;
-    int trans_count;
-
-    if (!reiserfs_journal_opened (fs))
-        reiserfs_panic ("replay_journal: journal is not opened");
-    
-    if (!is_opened_rw (fs))
-        reiserfs_panic ("replay_journal: fs is not opened with write perms");
-
-
-    reiserfs_warning (stderr, "Replaying journal: ");
-    bh = fs->fs_jh_bh;
-	
-    j_head = (struct reiserfs_journal_header *)(bh->b_data);
-    control.mount_id = get_jh_mount_id (j_head);
-    control.trans_id = get_jh_last_flushed (j_head);
-    control.desc_blocknr = get_jh_replay_start_offset (j_head);
-
-    trans_count = get_boundary_transactions (fs, &cur, &newest);
-    if (!trans_count) {
-	reiserfs_warning (stderr, "No transactions found\n");
-	return 0;
-    }
-
-    /*  Smth strange with journal header or journal. We cannot say for sure what was the last 
-	replaied transaction, but relying on JH data is preferable. */
-
-    replayed = 0;
-    ret = TRANS_FOUND;
-    
-    progbar_init(&progbar, " trans", stderr);
-    /* Looking to the first valid not replayed transaction. */
-    while (1) {
-	if (cur.mount_id == control.mount_id && 
-	    cur.trans_id > control.trans_id)
-	    break;
-
-	if ((ret = next_transaction (fs, &cur, newest)) != TRANS_FOUND)
-	    break;
-    }
-    
-    while (ret == TRANS_FOUND) {
-	/* If not the next transaction to be replayed, break out here. */
-	if ((cur.mount_id != control.mount_id) || 
-	    (cur.trans_id != control.trans_id + 1 && control.trans_id))
-	    break;
-	
-	if (!transaction_check_content(fs, &cur)) {
-	    progbar_clear(&progbar);
-	    reiserfs_warning (stderr, "Trans broken: mountid %lu, transid %lu, desc %lu, "
-		"len %lu, commit %lu, next trans offset %lu\n", cur.mount_id, cur.trans_id, 
-		cur.desc_blocknr, cur.trans_len, cur.commit_blocknr, cur.next_trans_offset);
-	    break;
+	struct buffer_head *bh;
+	struct reiserfs_journal_header *j_head;
+	reiserfs_trans_t cur, newest, control;
+	int replayed, ret;
+	struct progbar progbar;
+	int trans_count;
+
+	if (!reiserfs_journal_opened(fs))
+		reiserfs_panic("replay_journal: journal is not opened");
+
+	if (!is_opened_rw(fs))
+		reiserfs_panic
+		    ("replay_journal: fs is not opened with write perms");
+
+	reiserfs_warning(stderr, "Replaying journal: ");
+	bh = fs->fs_jh_bh;
+
+	j_head = (struct reiserfs_journal_header *)(bh->b_data);
+	control.mount_id = get_jh_mount_id(j_head);
+	control.trans_id = get_jh_last_flushed(j_head);
+	control.desc_blocknr = get_jh_replay_start_offset(j_head);
+
+	trans_count = get_boundary_transactions(fs, &cur, &newest);
+	if (!trans_count) {
+		reiserfs_warning(stderr, "No transactions found\n");
+		return 0;
 	}
 
-        reiserfs_warning (stderr, "Trans replayed: mountid %lu, transid %lu, desc %lu, "
-            "len %lu, commit %lu, next trans offset %lu\n",
-	    cur.mount_id, cur.trans_id, cur.desc_blocknr, cur.trans_len,
-	    cur.commit_blocknr, cur.next_trans_offset);
-	replay_one_transaction (fs, &cur);
-	update_journal_header (fs, bh, &cur);
-	control = cur;
-        replayed ++;
-
-	progbar_update(&progbar, "Replaying journal", replayed, trans_count,
-	               replayed);
-
-	ret = next_transaction (fs, &cur, newest);
-    }
-    progbar_clear(&progbar);
-
-    reiserfs_warning (stderr, "\rReplaying journal: Done.\nReiserfs journal '%s' in blocks [%u..%u]: %d "
-		      "transactions replayed\n", fs->fs_j_file_name, 
-		      get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)),
-		      get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) + 
-		      get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)) + 1,
-		      replayed);
-	
-    mark_buffer_dirty (fs->fs_super_bh);
-    bwrite (fs->fs_super_bh);
-	
-    update_journal_header (fs, bh, &newest);
-
-    return 0;
+	/*  Smth strange with journal header or journal. We cannot say for sure what was the last 
+	   replaied transaction, but relying on JH data is preferable. */
+
+	replayed = 0;
+	ret = TRANS_FOUND;
+
+	progbar_init(&progbar, " trans", stderr);
+	/* Looking to the first valid not replayed transaction. */
+	while (1) {
+		if (cur.mount_id == control.mount_id &&
+		    cur.trans_id > control.trans_id)
+			break;
+
+		if ((ret = next_transaction(fs, &cur, newest)) != TRANS_FOUND)
+			break;
+	}
+
+	while (ret == TRANS_FOUND) {
+		/* If not the next transaction to be replayed, break out here. */
+		if ((cur.mount_id != control.mount_id) ||
+		    (cur.trans_id != control.trans_id + 1 && control.trans_id))
+			break;
+
+		if (!transaction_check_content(fs, &cur)) {
+			progbar_clear(&progbar);
+			reiserfs_warning(stderr,
+					 "Trans broken: mountid %lu, transid %lu, desc %lu, "
+					 "len %lu, commit %lu, next trans offset %lu\n",
+					 cur.mount_id, cur.trans_id,
+					 cur.desc_blocknr, cur.trans_len,
+					 cur.commit_blocknr,
+					 cur.next_trans_offset);
+			break;
+		}
+
+		reiserfs_warning(stderr,
+				 "Trans replayed: mountid %lu, transid %lu, desc %lu, "
+				 "len %lu, commit %lu, next trans offset %lu\n",
+				 cur.mount_id, cur.trans_id, cur.desc_blocknr,
+				 cur.trans_len, cur.commit_blocknr,
+				 cur.next_trans_offset);
+		replay_one_transaction(fs, &cur);
+		update_journal_header(fs, bh, &cur);
+		control = cur;
+		replayed++;
+
+		progbar_update(&progbar, "Replaying journal", replayed,
+			       trans_count, replayed);
+
+		ret = next_transaction(fs, &cur, newest);
+	}
+	progbar_clear(&progbar);
+
+	reiserfs_warning(stderr,
+			 "\rReplaying journal: Done.\nReiserfs journal '%s' in blocks [%u..%u]: %d "
+			 "transactions replayed\n", fs->fs_j_file_name,
+			 get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)),
+			 get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) +
+			 get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)) + 1,
+			 replayed);
+
+	mark_buffer_dirty(fs->fs_super_bh);
+	bwrite(fs->fs_super_bh);
+
+	update_journal_header(fs, bh, &newest);
+
+	return 0;
 }
diff --git a/reiserfscore/lbalance.c b/reiserfscore/lbalance.c
index cf42587..e99f5bd 100644
--- a/reiserfscore/lbalance.c
+++ b/reiserfscore/lbalance.c
@@ -5,7 +5,6 @@
 
 #include "includes.h"
 
-
 /* these are used in do_balance.c */
 
 /* leaf_move_items
@@ -18,563 +17,626 @@
    leaf_paste_entries
    */
 
-
 extern struct tree_balance init_tb;
 extern int init_item_pos;
 extern int init_pos_in_item;
 extern int init_mode;
 
-
-
 /* copy copy_count entries from source directory item to dest buffer (creating new item if needed) */
-static void leaf_copy_dir_entries (reiserfs_filsys_t * fs,
-			           struct buffer_info * dest_bi, struct buffer_head * source, 
-				   int last_first, int item_num, int from, int copy_count)
+static void leaf_copy_dir_entries(reiserfs_filsys_t *fs,
+				  struct buffer_info *dest_bi,
+				  struct buffer_head *source, int last_first,
+				  int item_num, int from, int copy_count)
 {
-    struct buffer_head * dest = dest_bi->bi_bh;
-    int item_num_in_dest;		/* either the number of target item,
-					   or if we must create a new item,
-					   the number of the item we will
-					   create it next to */
-    struct item_head * ih;
-    struct reiserfs_de_head * deh;
-    int copy_records_len;			/* length of all records in item to be copied */
-    char * records;
-
-    ih = B_N_PITEM_HEAD (source, item_num);
-
-    /* length of all record to be copied and first byte of the last of them */
-    deh = B_I_DEH (source, ih);
-    if (copy_count) {
-	copy_records_len = (from ? get_deh_location (&deh[from - 1]) : get_ih_item_len (ih)) - 
-	    get_deh_location (&deh[from + copy_count - 1]);
-	records = source->b_data + get_ih_location (ih) + get_deh_location (&deh[from + copy_count - 1]);
-    } else {
-	copy_records_len = 0;
-	records = 0;
-    }
-
-    /* when copy last to first, dest buffer can contain 0 items */
-    item_num_in_dest = (last_first == LAST_TO_FIRST) ? (( B_NR_ITEMS(dest) ) ? 0 : -1) : (B_NR_ITEMS(dest) - 1);
-
-    /* if there are no items in dest or the first/last item in dest is not item of the same directory */
-    if ( (item_num_in_dest == - 1) ||
-	 (last_first == FIRST_TO_LAST && are_items_mergeable (B_N_PITEM_HEAD (dest, item_num_in_dest), ih, dest->b_size) == 0) ||
-	 (last_first == LAST_TO_FIRST && are_items_mergeable (ih, B_N_PITEM_HEAD (dest, item_num_in_dest), dest->b_size) == 0)) {
-	/* create new item in dest */
-	struct item_head new_ih;
-
-	/* form item header */
-	memcpy (&new_ih.ih_key, &ih->ih_key, KEY_SIZE);
-
-	/* calculate item len */
-	set_ih_item_len (&new_ih, DEH_SIZE * copy_count + copy_records_len);
-	set_ih_entry_count (&new_ih, 0);
-    
-	if (last_first == LAST_TO_FIRST) {
-	    /* form key by the following way */
-	    if (from < get_ih_entry_count (ih)) {
-		set_key_offset_v1 (&new_ih.ih_key, get_deh_offset (&deh[from]));
-	    } else {
-		/* no entries will be copied to this item in this function */
-		set_key_offset_v1 (&new_ih.ih_key, MAX_KEY1_OFFSET);
-	    }
-	    set_key_uniqueness (&new_ih.ih_key, DIRENTRY_UNIQUENESS);
+	struct buffer_head *dest = dest_bi->bi_bh;
+	int item_num_in_dest;	/* either the number of target item,
+				   or if we must create a new item,
+				   the number of the item we will
+				   create it next to */
+	struct item_head *ih;
+	struct reiserfs_de_head *deh;
+	int copy_records_len;	/* length of all records in item to be copied */
+	char *records;
+
+	ih = B_N_PITEM_HEAD(source, item_num);
+
+	/* length of all record to be copied and first byte of the last of them */
+	deh = B_I_DEH(source, ih);
+	if (copy_count) {
+		copy_records_len =
+		    (from ? get_deh_location(&deh[from - 1]) :
+		     get_ih_item_len(ih)) - get_deh_location(&deh[from +
+								  copy_count -
+								  1]);
+		records =
+		    source->b_data + get_ih_location(ih) +
+		    get_deh_location(&deh[from + copy_count - 1]);
+	} else {
+		copy_records_len = 0;
+		records = 0;
+	}
+
+	/* when copy last to first, dest buffer can contain 0 items */
+	item_num_in_dest =
+	    (last_first ==
+	     LAST_TO_FIRST) ? ((B_NR_ITEMS(dest)) ? 0 : -1) : (B_NR_ITEMS(dest)
+							       - 1);
+
+	/* if there are no items in dest or the first/last item in dest is not item of the same directory */
+	if ((item_num_in_dest == -1) ||
+	    (last_first == FIRST_TO_LAST
+	     && are_items_mergeable(B_N_PITEM_HEAD(dest, item_num_in_dest), ih,
+				    dest->b_size) == 0)
+	    || (last_first == LAST_TO_FIRST
+		&& are_items_mergeable(ih,
+				       B_N_PITEM_HEAD(dest, item_num_in_dest),
+				       dest->b_size) == 0)) {
+		/* create new item in dest */
+		struct item_head new_ih;
+
+		/* form item header */
+		memcpy(&new_ih.ih_key, &ih->ih_key, KEY_SIZE);
+
+		/* calculate item len */
+		set_ih_item_len(&new_ih,
+				DEH_SIZE * copy_count + copy_records_len);
+		set_ih_entry_count(&new_ih, 0);
+
+		if (last_first == LAST_TO_FIRST) {
+			/* form key by the following way */
+			if (from < get_ih_entry_count(ih)) {
+				set_key_offset_v1(&new_ih.ih_key,
+						  get_deh_offset(&deh[from]));
+			} else {
+				/* no entries will be copied to this item in this function */
+				set_key_offset_v1(&new_ih.ih_key,
+						  MAX_KEY1_OFFSET);
+			}
+			set_key_uniqueness(&new_ih.ih_key, DIRENTRY_UNIQUENESS);
+		}
+		set_ih_key_format(&new_ih, get_ih_key_format(ih));
+		set_ih_flags(&new_ih, get_ih_flags(ih));
+
+		/* insert item into dest buffer */
+		leaf_insert_into_buf(fs, dest_bi,
+				     (last_first ==
+				      LAST_TO_FIRST) ? 0 : B_NR_ITEMS(dest),
+				     &new_ih, NULL, 0);
+	} else {
+		/* prepare space for entries */
+		leaf_paste_in_buffer(fs, dest_bi,
+				     (last_first ==
+				      FIRST_TO_LAST) ? (B_NR_ITEMS(dest) -
+							1) : 0,
+				     0xffff /*MAX_US_INT */ ,
+				     DEH_SIZE * copy_count + copy_records_len,
+				     records, 0);
 	}
-	set_ih_key_format (&new_ih, get_ih_key_format (ih));
-	set_ih_flags (&new_ih, get_ih_flags (ih));
-    
-	/* insert item into dest buffer */
-	leaf_insert_into_buf (fs, dest_bi, (last_first == LAST_TO_FIRST) ? 0 : B_NR_ITEMS(dest), &new_ih, NULL, 0);
-    } else {
-	/* prepare space for entries */
-	leaf_paste_in_buffer (fs, dest_bi, (last_first == FIRST_TO_LAST) ? (B_NR_ITEMS(dest) - 1) : 0, 0xffff /*MAX_US_INT */,
-			      DEH_SIZE * copy_count + copy_records_len, records, 0);
-    }
-  
-    item_num_in_dest = (last_first == FIRST_TO_LAST) ? (B_NR_ITEMS(dest)-1) : 0;
-  
-    leaf_paste_entries (dest_bi->bi_bh, item_num_in_dest,
-			(last_first == FIRST_TO_LAST) ? get_ih_entry_count (B_N_PITEM_HEAD (dest, item_num_in_dest)) : 0,
-			copy_count, deh + from, records,
-			DEH_SIZE * copy_count + copy_records_len
-	);
-}
 
+	item_num_in_dest =
+	    (last_first == FIRST_TO_LAST) ? (B_NR_ITEMS(dest) - 1) : 0;
+
+	leaf_paste_entries(dest_bi->bi_bh, item_num_in_dest,
+			   (last_first ==
+			    FIRST_TO_LAST) ?
+			   get_ih_entry_count(B_N_PITEM_HEAD
+					      (dest, item_num_in_dest)) : 0,
+			   copy_count, deh + from, records,
+			   DEH_SIZE * copy_count + copy_records_len);
+}
 
 /* Copy the first (if last_first == FIRST_TO_LAST) or last (last_first == LAST_TO_FIRST) item or 
    part of it or nothing (see the return 0 below) from SOURCE to the end 
    (if last_first) or beginning (!last_first) of the DEST */
 /* returns 1 if anything was copied, else 0 */
-static int leaf_copy_boundary_item (reiserfs_filsys_t * fs,
-                                    struct buffer_info * dest_bi, struct buffer_head * src, int last_first,
-				    int bytes_or_entries)
+static int leaf_copy_boundary_item(reiserfs_filsys_t *fs,
+				   struct buffer_info *dest_bi,
+				   struct buffer_head *src, int last_first,
+				   int bytes_or_entries)
 {
-    struct buffer_head * dest = dest_bi->bi_bh;
-    int dest_nr_item, src_nr_item; /* number of items in the source and destination buffers */
-    struct item_head * ih;
-    struct item_head * dih;
-  
-    dest_nr_item = B_NR_ITEMS(dest);
-  
-    if ( last_first == FIRST_TO_LAST ) {
-	/* if ( DEST is empty or first item of SOURCE and last item of DEST are the items of different objects
-	   or of different types ) then there is no need to treat this item differently from the other items
-	   that we copy, so we return */
-	ih = B_N_PITEM_HEAD (src, 0);
-	dih = B_N_PITEM_HEAD (dest, dest_nr_item - 1);
-	if (!dest_nr_item || (are_items_mergeable (dih, ih, src->b_size) == 0))
-	    /* there is nothing to merge */
-	    return 0;
-      
-	if ( I_IS_DIRECTORY_ITEM(ih) ) {
-	    if ( bytes_or_entries == -1 )
-		/* copy all entries to dest */
-		bytes_or_entries = get_ih_entry_count(ih);
-	    leaf_copy_dir_entries (fs, dest_bi, src, FIRST_TO_LAST, 0, 0, bytes_or_entries);
-	    return 1;
-	}
-      
-	/* copy part of the body of the first item of SOURCE to the end of the body of the last item of the DEST
-	   part defined by 'bytes_or_entries'; if bytes_or_entries == -1 copy whole body; don't create new item header
-	*/
-	if ( bytes_or_entries == -1 )
-	    bytes_or_entries = get_ih_item_len (ih);
-
-	/* merge first item (or its part) of src buffer with the last
-	   item of dest buffer. Both are of the same file */
-	leaf_paste_in_buffer (fs, dest_bi, dest_nr_item - 1, get_ih_item_len (dih),
-		bytes_or_entries, B_I_PITEM(src,ih), 0);
-      
-	if (I_IS_INDIRECT_ITEM(dih)) {
-	    if (bytes_or_entries == get_ih_item_len (ih))
-		//dih->u.ih_free_space = ih->u.ih_free_space;
-		set_ih_free_space (dih, get_ih_free_space (ih));
+	struct buffer_head *dest = dest_bi->bi_bh;
+	int dest_nr_item, src_nr_item;	/* number of items in the source and destination buffers */
+	struct item_head *ih;
+	struct item_head *dih;
+
+	dest_nr_item = B_NR_ITEMS(dest);
+
+	if (last_first == FIRST_TO_LAST) {
+		/* if ( DEST is empty or first item of SOURCE and last item of DEST are the items of different objects
+		   or of different types ) then there is no need to treat this item differently from the other items
+		   that we copy, so we return */
+		ih = B_N_PITEM_HEAD(src, 0);
+		dih = B_N_PITEM_HEAD(dest, dest_nr_item - 1);
+		if (!dest_nr_item
+		    || (are_items_mergeable(dih, ih, src->b_size) == 0))
+			/* there is nothing to merge */
+			return 0;
+
+		if (I_IS_DIRECTORY_ITEM(ih)) {
+			if (bytes_or_entries == -1)
+				/* copy all entries to dest */
+				bytes_or_entries = get_ih_entry_count(ih);
+			leaf_copy_dir_entries(fs, dest_bi, src, FIRST_TO_LAST,
+					      0, 0, bytes_or_entries);
+			return 1;
+		}
+
+		/* copy part of the body of the first item of SOURCE to the end of the body of the last item of the DEST
+		   part defined by 'bytes_or_entries'; if bytes_or_entries == -1 copy whole body; don't create new item header
+		 */
+		if (bytes_or_entries == -1)
+			bytes_or_entries = get_ih_item_len(ih);
+
+		/* merge first item (or its part) of src buffer with the last
+		   item of dest buffer. Both are of the same file */
+		leaf_paste_in_buffer(fs, dest_bi, dest_nr_item - 1,
+				     get_ih_item_len(dih), bytes_or_entries,
+				     B_I_PITEM(src, ih), 0);
+
+		if (I_IS_INDIRECT_ITEM(dih)) {
+			if (bytes_or_entries == get_ih_item_len(ih))
+				//dih->u.ih_free_space = ih->u.ih_free_space;
+				set_ih_free_space(dih, get_ih_free_space(ih));
+		}
+
+		return 1;
 	}
-    
-	return 1;
-    }
-  
 
-    /* copy boundary item to right (last_first == LAST_TO_FIRST) */
+	/* copy boundary item to right (last_first == LAST_TO_FIRST) */
 
-    /* ( DEST is empty or last item of SOURCE and first item of DEST
-       are the items of different object or of different types )
-    */
-    src_nr_item = B_NR_ITEMS (src);
-    ih = B_N_PITEM_HEAD (src, src_nr_item - 1);
-    dih = B_N_PITEM_HEAD (dest, 0);
-
-    if (!dest_nr_item || are_items_mergeable (ih, dih, src->b_size) == 0)
-	return 0;
-  
-    if ( I_IS_DIRECTORY_ITEM(ih)) {
-	if ( bytes_or_entries == -1 )
-	    /* bytes_or_entries = entries number in last item body of SOURCE */
-	    bytes_or_entries = get_ih_entry_count(ih);
-    
-	leaf_copy_dir_entries (fs, dest_bi, src, LAST_TO_FIRST, src_nr_item - 1, get_ih_entry_count(ih) - bytes_or_entries, 
-			       bytes_or_entries);
-	return 1;
-    }
+	/* ( DEST is empty or last item of SOURCE and first item of DEST
+	   are the items of different object or of different types )
+	 */
+	src_nr_item = B_NR_ITEMS(src);
+	ih = B_N_PITEM_HEAD(src, src_nr_item - 1);
+	dih = B_N_PITEM_HEAD(dest, 0);
 
-    /* copy part of the body of the last item of SOURCE to the begin of the body of the first item of the DEST;
-       part defined by 'bytes_or_entries'; if byte_or_entriess == -1 copy whole body; change first item key of the DEST;
-       don't create new item header
-    */
-  
-    if ( bytes_or_entries == -1 ) {
-	/* bytes_or_entries = length of last item body of SOURCE */
-	bytes_or_entries = get_ih_item_len (ih);
-
-	/* change first item key of the DEST */
-	//dih->ih_key.k_offset = ih->ih_key.k_offset;
-	set_offset (key_format (&dih->ih_key), &dih->ih_key, get_offset (&ih->ih_key));
-
-	/* item becomes non-mergeable */
-	/* or mergeable if left item was */
-	//dih->ih_key.k_uniqueness = ih->ih_key.k_uniqueness;
-	set_type (key_format (&dih->ih_key), &dih->ih_key, get_type (&ih->ih_key));
-    } else {
-	/* merge to right only part of item */
-	/* change first item key of the DEST */
-	if ( I_IS_DIRECT_ITEM(dih) ) {
-	    //dih->ih_key.k_offset -= bytes_or_entries;
-	    set_offset (key_format (&dih->ih_key), &dih->ih_key, get_offset (&dih->ih_key) - bytes_or_entries);
+	if (!dest_nr_item || are_items_mergeable(ih, dih, src->b_size) == 0)
+		return 0;
+
+	if (I_IS_DIRECTORY_ITEM(ih)) {
+		if (bytes_or_entries == -1)
+			/* bytes_or_entries = entries number in last item body of SOURCE */
+			bytes_or_entries = get_ih_entry_count(ih);
+
+		leaf_copy_dir_entries(fs, dest_bi, src, LAST_TO_FIRST,
+				      src_nr_item - 1,
+				      get_ih_entry_count(ih) - bytes_or_entries,
+				      bytes_or_entries);
+		return 1;
+	}
+
+	/* copy part of the body of the last item of SOURCE to the begin of the body of the first item of the DEST;
+	   part defined by 'bytes_or_entries'; if byte_or_entriess == -1 copy whole body; change first item key of the DEST;
+	   don't create new item header
+	 */
+
+	if (bytes_or_entries == -1) {
+		/* bytes_or_entries = length of last item body of SOURCE */
+		bytes_or_entries = get_ih_item_len(ih);
+
+		/* change first item key of the DEST */
+		//dih->ih_key.k_offset = ih->ih_key.k_offset;
+		set_offset(key_format(&dih->ih_key), &dih->ih_key,
+			   get_offset(&ih->ih_key));
+
+		/* item becomes non-mergeable */
+		/* or mergeable if left item was */
+		//dih->ih_key.k_uniqueness = ih->ih_key.k_uniqueness;
+		set_type(key_format(&dih->ih_key), &dih->ih_key,
+			 get_type(&ih->ih_key));
 	} else {
-	    //dih->ih_key.k_offset -= ((bytes_or_entries/UNFM_P_SIZE)*dest->b_size);
-	    set_offset (key_format (&dih->ih_key), &dih->ih_key, 
-			get_offset (&dih->ih_key) - ((bytes_or_entries/UNFM_P_SIZE)*dest->b_size));
+		/* merge to right only part of item */
+		/* change first item key of the DEST */
+		if (I_IS_DIRECT_ITEM(dih)) {
+			//dih->ih_key.k_offset -= bytes_or_entries;
+			set_offset(key_format(&dih->ih_key), &dih->ih_key,
+				   get_offset(&dih->ih_key) - bytes_or_entries);
+		} else {
+			//dih->ih_key.k_offset -= ((bytes_or_entries/UNFM_P_SIZE)*dest->b_size);
+			set_offset(key_format(&dih->ih_key), &dih->ih_key,
+				   get_offset(&dih->ih_key) -
+				   ((bytes_or_entries / UNFM_P_SIZE) *
+				    dest->b_size));
+		}
 	}
-    }
-  
-    leaf_paste_in_buffer (fs, dest_bi, 0, 0, bytes_or_entries, B_I_PITEM(src,ih) + get_ih_item_len (ih) - bytes_or_entries, 0);
-    return 1;
-}
 
+	leaf_paste_in_buffer(fs, dest_bi, 0, 0, bytes_or_entries,
+			     B_I_PITEM(src,
+				       ih) + get_ih_item_len(ih) -
+			     bytes_or_entries, 0);
+	return 1;
+}
 
 /* copy cpy_mun items from buffer src to buffer dest
  * last_first == FIRST_TO_LAST means, that we copy cpy_num  items beginning from first-th item in src to tail of dest
  * last_first == LAST_TO_FIRST means, that we copy cpy_num  items beginning from first-th item in src to head of dest
  */
-static void leaf_copy_items_entirely (reiserfs_filsys_t * fs, struct buffer_info * dest_bi, 
-                                      struct buffer_head * src, int last_first,
-				      int first, int cpy_num)
+static void leaf_copy_items_entirely(reiserfs_filsys_t *fs,
+				     struct buffer_info *dest_bi,
+				     struct buffer_head *src, int last_first,
+				     int first, int cpy_num)
 {
-    struct buffer_head * dest;
-    int nr;
-    int dest_before;
-    int last_loc, last_inserted_loc, location;
-    int i, j;
-    struct block_head * blkh;
-    struct item_head * ih;
-
-    dest = dest_bi->bi_bh;
-
-    if (cpy_num == 0)
-	return;
-
-    blkh = B_BLK_HEAD(dest);
-    nr = get_blkh_nr_items (blkh);
-  
-    /* we will insert items before 0-th or nr-th item in dest buffer. It depends of last_first parameter */
-    dest_before = (last_first == LAST_TO_FIRST) ? 0 : nr;
-
-    /* location of head of first new item */
-    ih = B_N_PITEM_HEAD (dest, dest_before);
-
-    /* prepare space for headers */
-    memmove (ih + cpy_num, ih, (nr-dest_before) * IH_SIZE);
-
-    /* copy item headers */
-    memcpy (ih, B_N_PITEM_HEAD (src, first), cpy_num * IH_SIZE);
-
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) - IH_SIZE * cpy_num);
-
-    /* location of unmovable item */
-    j = location = (dest_before == 0) ? dest->b_size : get_ih_location (ih-1);
-    for (i = dest_before; i < nr + cpy_num; i ++) {
-	location -= get_ih_item_len (&ih[i-dest_before]);
-	set_ih_location (&ih[i-dest_before], location);
-    }
-
-    /* prepare space for items */
-    last_loc = get_ih_location (&ih[nr+cpy_num-1-dest_before]);
-    last_inserted_loc = get_ih_location (&ih[cpy_num-1]);
-
-    /* check free space */
-    memmove (dest->b_data + last_loc,
-	     dest->b_data + last_loc + j - last_inserted_loc,
-	     last_inserted_loc - last_loc);
-
-    /* copy items */
-    memcpy (dest->b_data + last_inserted_loc, B_N_PITEM(src,(first + cpy_num - 1)),
-	    j - last_inserted_loc);
-
-    /* sizes, item number */
-    set_blkh_nr_items (blkh, get_blkh_nr_items (blkh) + cpy_num);
-    set_blkh_free_space (blkh, 
-			 get_blkh_free_space (blkh) - (j - last_inserted_loc));
-  
-    mark_buffer_dirty (dest);
-
-    if (dest_bi->bi_parent) {
-	struct disk_child * dc;
-	dc = B_N_CHILD (dest_bi->bi_parent, dest_bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) + j - last_inserted_loc + IH_SIZE * cpy_num);
-	mark_buffer_dirty(dest_bi->bi_parent);
-    }
-}
+	struct buffer_head *dest;
+	int nr;
+	int dest_before;
+	int last_loc, last_inserted_loc, location;
+	int i, j;
+	struct block_head *blkh;
+	struct item_head *ih;
+
+	dest = dest_bi->bi_bh;
+
+	if (cpy_num == 0)
+		return;
+
+	blkh = B_BLK_HEAD(dest);
+	nr = get_blkh_nr_items(blkh);
+
+	/* we will insert items before 0-th or nr-th item in dest buffer. It depends of last_first parameter */
+	dest_before = (last_first == LAST_TO_FIRST) ? 0 : nr;
+
+	/* location of head of first new item */
+	ih = B_N_PITEM_HEAD(dest, dest_before);
+
+	/* prepare space for headers */
+	memmove(ih + cpy_num, ih, (nr - dest_before) * IH_SIZE);
 
+	/* copy item headers */
+	memcpy(ih, B_N_PITEM_HEAD(src, first), cpy_num * IH_SIZE);
+
+	set_blkh_free_space(blkh,
+			    get_blkh_free_space(blkh) - IH_SIZE * cpy_num);
+
+	/* location of unmovable item */
+	j = location =
+	    (dest_before == 0) ? dest->b_size : get_ih_location(ih - 1);
+	for (i = dest_before; i < nr + cpy_num; i++) {
+		location -= get_ih_item_len(&ih[i - dest_before]);
+		set_ih_location(&ih[i - dest_before], location);
+	}
+
+	/* prepare space for items */
+	last_loc = get_ih_location(&ih[nr + cpy_num - 1 - dest_before]);
+	last_inserted_loc = get_ih_location(&ih[cpy_num - 1]);
+
+	/* check free space */
+	memmove(dest->b_data + last_loc,
+		dest->b_data + last_loc + j - last_inserted_loc,
+		last_inserted_loc - last_loc);
+
+	/* copy items */
+	memcpy(dest->b_data + last_inserted_loc,
+	       B_N_PITEM(src, (first + cpy_num - 1)), j - last_inserted_loc);
+
+	/* sizes, item number */
+	set_blkh_nr_items(blkh, get_blkh_nr_items(blkh) + cpy_num);
+	set_blkh_free_space(blkh,
+			    get_blkh_free_space(blkh) - (j -
+							 last_inserted_loc));
+
+	mark_buffer_dirty(dest);
+
+	if (dest_bi->bi_parent) {
+		struct disk_child *dc;
+		dc = B_N_CHILD(dest_bi->bi_parent, dest_bi->bi_position);
+		set_dc_child_size(dc,
+				  get_dc_child_size(dc) + j -
+				  last_inserted_loc + IH_SIZE * cpy_num);
+		mark_buffer_dirty(dest_bi->bi_parent);
+	}
+}
 
 /* This function splits the (liquid) item into two items (useful when
    shifting part of an item into another node.) */
-static void leaf_item_bottle (reiserfs_filsys_t * fs,
-			      struct buffer_info * dest_bi, struct buffer_head * src, int last_first,
-			      int item_num, int cpy_bytes)
+static void leaf_item_bottle(reiserfs_filsys_t *fs,
+			     struct buffer_info *dest_bi,
+			     struct buffer_head *src, int last_first,
+			     int item_num, int cpy_bytes)
 {
-    struct buffer_head * dest = dest_bi->bi_bh;
-    struct item_head * ih;
-  
-    if ( last_first == FIRST_TO_LAST ) {
-	/* if ( if item in position item_num in buffer SOURCE is directory item ) */
-	if (I_IS_DIRECTORY_ITEM(ih = B_N_PITEM_HEAD(src,item_num)))
-	    leaf_copy_dir_entries (fs, dest_bi, src, FIRST_TO_LAST, item_num, 0, cpy_bytes);
-	else {
-	    struct item_head n_ih;
-      
-	    /* copy part of the body of the item number 'item_num' of SOURCE to the end of the DEST 
-	       part defined by 'cpy_bytes'; create new item header; change old item_header (????);
-	       n_ih = new item_header;
-	    */
-	    memcpy (&n_ih, ih, IH_SIZE);
-	    set_ih_item_len (&n_ih, cpy_bytes);
-	    if (I_IS_INDIRECT_ITEM(ih)) {
-		//n_ih.u.ih_free_space = 0;
-		set_ih_free_space (&n_ih, 0);;
-	    }
-
-	    //n_ih.ih_version = ih->ih_version;
-	    set_ih_key_format (&n_ih, get_ih_key_format (ih));
-	    set_ih_flags (&n_ih, get_ih_flags (ih));
-	    leaf_insert_into_buf (fs, dest_bi, B_NR_ITEMS(dest), &n_ih, B_N_PITEM (src, item_num), 0);
-	}
-    } else {
-	/*  if ( if item in position item_num in buffer SOURCE is directory item ) */
-	if (I_IS_DIRECTORY_ITEM(ih = B_N_PITEM_HEAD (src, item_num)))
-	    leaf_copy_dir_entries (fs, dest_bi, src, LAST_TO_FIRST, item_num, get_ih_entry_count(ih) - cpy_bytes, cpy_bytes);
-	else {
-	    struct item_head n_ih;
-      
-	    /* copy part of the body of the item number 'item_num' of SOURCE to the begin of the DEST 
-	       part defined by 'cpy_bytes'; create new item header;
-	       n_ih = new item_header;
-	    */
-	    memcpy (&n_ih, ih, SHORT_KEY_SIZE);
-      
-	    if (I_IS_DIRECT_ITEM(ih)) {
-		//n_ih.ih_key.k_offset = ih->ih_key.k_offset + ih->ih_item_len - cpy_bytes;
-		set_offset (key_format (&ih->ih_key), &n_ih.ih_key, get_offset (&ih->ih_key) + get_ih_item_len (ih) - cpy_bytes);
-		//n_ih.ih_key.k_uniqueness = TYPE_DIRECT;
-		set_type (key_format (&ih->ih_key), &n_ih.ih_key, TYPE_DIRECT);
-		//n_ih.u.ih_free_space = USHRT_MAX;
-		set_ih_free_space (&n_ih, USHRT_MAX);
-	    } else {
-		/* indirect item */
-		//n_ih.ih_key.k_offset = ih->ih_key.k_offset + (ih->ih_item_len - cpy_bytes) / UNFM_P_SIZE * dest->b_size;
-		set_offset (key_format (&ih->ih_key), &n_ih.ih_key,
-			    get_offset (&ih->ih_key) + (get_ih_item_len (ih) - cpy_bytes) / UNFM_P_SIZE * dest->b_size);
-		//n_ih.ih_key.k_uniqueness = TYPE_INDIRECT;
-		set_type (key_format (&ih->ih_key), &n_ih.ih_key, TYPE_INDIRECT);
-		//n_ih.u.ih_free_space = ih->u.ih_free_space;
-		set_ih_free_space (&n_ih, get_ih_free_space (ih));
-	    }
-      
-	    /* set item length */
-	    set_ih_item_len (&n_ih, cpy_bytes);
-	    //n_ih.ih_version = ih->ih_version;
-	    set_ih_key_format (&n_ih, get_ih_key_format (ih));
-	    set_ih_flags (&n_ih, get_ih_flags (ih));
-	    leaf_insert_into_buf (fs, dest_bi, 0, &n_ih, B_N_PITEM(src,item_num) + get_ih_item_len (ih) - cpy_bytes, 0);
+	struct buffer_head *dest = dest_bi->bi_bh;
+	struct item_head *ih;
+
+	if (last_first == FIRST_TO_LAST) {
+		/* if ( if item in position item_num in buffer SOURCE is directory item ) */
+		if (I_IS_DIRECTORY_ITEM(ih = B_N_PITEM_HEAD(src, item_num)))
+			leaf_copy_dir_entries(fs, dest_bi, src, FIRST_TO_LAST,
+					      item_num, 0, cpy_bytes);
+		else {
+			struct item_head n_ih;
+
+			/* copy part of the body of the item number 'item_num' of SOURCE to the end of the DEST 
+			   part defined by 'cpy_bytes'; create new item header; change old item_header (????);
+			   n_ih = new item_header;
+			 */
+			memcpy(&n_ih, ih, IH_SIZE);
+			set_ih_item_len(&n_ih, cpy_bytes);
+			if (I_IS_INDIRECT_ITEM(ih)) {
+				//n_ih.u.ih_free_space = 0;
+				set_ih_free_space(&n_ih, 0);;
+			}
+			//n_ih.ih_version = ih->ih_version;
+			set_ih_key_format(&n_ih, get_ih_key_format(ih));
+			set_ih_flags(&n_ih, get_ih_flags(ih));
+			leaf_insert_into_buf(fs, dest_bi, B_NR_ITEMS(dest),
+					     &n_ih, B_N_PITEM(src, item_num),
+					     0);
+		}
+	} else {
+		/*  if ( if item in position item_num in buffer SOURCE is directory item ) */
+		if (I_IS_DIRECTORY_ITEM(ih = B_N_PITEM_HEAD(src, item_num)))
+			leaf_copy_dir_entries(fs, dest_bi, src, LAST_TO_FIRST,
+					      item_num,
+					      get_ih_entry_count(ih) -
+					      cpy_bytes, cpy_bytes);
+		else {
+			struct item_head n_ih;
+
+			/* copy part of the body of the item number 'item_num' of SOURCE to the begin of the DEST 
+			   part defined by 'cpy_bytes'; create new item header;
+			   n_ih = new item_header;
+			 */
+			memcpy(&n_ih, ih, SHORT_KEY_SIZE);
+
+			if (I_IS_DIRECT_ITEM(ih)) {
+				//n_ih.ih_key.k_offset = ih->ih_key.k_offset + ih->ih_item_len - cpy_bytes;
+				set_offset(key_format(&ih->ih_key),
+					   &n_ih.ih_key,
+					   get_offset(&ih->ih_key) +
+					   get_ih_item_len(ih) - cpy_bytes);
+				//n_ih.ih_key.k_uniqueness = TYPE_DIRECT;
+				set_type(key_format(&ih->ih_key), &n_ih.ih_key,
+					 TYPE_DIRECT);
+				//n_ih.u.ih_free_space = USHRT_MAX;
+				set_ih_free_space(&n_ih, USHRT_MAX);
+			} else {
+				/* indirect item */
+				//n_ih.ih_key.k_offset = ih->ih_key.k_offset + (ih->ih_item_len - cpy_bytes) / UNFM_P_SIZE * dest->b_size;
+				set_offset(key_format(&ih->ih_key),
+					   &n_ih.ih_key,
+					   get_offset(&ih->ih_key) +
+					   (get_ih_item_len(ih) -
+					    cpy_bytes) / UNFM_P_SIZE *
+					   dest->b_size);
+				//n_ih.ih_key.k_uniqueness = TYPE_INDIRECT;
+				set_type(key_format(&ih->ih_key), &n_ih.ih_key,
+					 TYPE_INDIRECT);
+				//n_ih.u.ih_free_space = ih->u.ih_free_space;
+				set_ih_free_space(&n_ih, get_ih_free_space(ih));
+			}
+
+			/* set item length */
+			set_ih_item_len(&n_ih, cpy_bytes);
+			//n_ih.ih_version = ih->ih_version;
+			set_ih_key_format(&n_ih, get_ih_key_format(ih));
+			set_ih_flags(&n_ih, get_ih_flags(ih));
+			leaf_insert_into_buf(fs, dest_bi, 0, &n_ih,
+					     B_N_PITEM(src,
+						       item_num) +
+					     get_ih_item_len(ih) - cpy_bytes,
+					     0);
+		}
 	}
-    }
 }
 
-
 /* If cpy_bytes equals minus one than copy cpy_num whole items from SOURCE to DEST.
    If cpy_bytes not equal to minus one than copy cpy_num-1 whole items from SOURCE to DEST.
    From last item copy cpy_num bytes for regular item and cpy_num directory entries for
    directory item. */
-static int leaf_copy_items (reiserfs_filsys_t * fs,
-                            struct buffer_info * dest_bi, struct buffer_head * src,
-			    int last_first, int cpy_num,
-			    int cpy_bytes)
+static int leaf_copy_items(reiserfs_filsys_t *fs,
+			   struct buffer_info *dest_bi, struct buffer_head *src,
+			   int last_first, int cpy_num, int cpy_bytes)
 {
-    int pos, i, src_nr_item, bytes;
-
-    if ( cpy_num == 0 )
-	return 0;
- 
-    if ( last_first == FIRST_TO_LAST ) {
-	/* copy items to left */
-	pos = 0;
-	if ( cpy_num == 1 )
-	    bytes = cpy_bytes;
-	else
-	    bytes = -1;
-   
-	/* copy the first item or it part or nothing to the end of the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,0,bytes)) */
-	i = leaf_copy_boundary_item (fs, dest_bi, src, FIRST_TO_LAST, bytes);
-	cpy_num -= i;
-	if ( cpy_num == 0 )
-	    return i;
-	pos += i;
-	if ( cpy_bytes == -1 )
-	    /* copy first cpy_num items starting from position 'pos' of SOURCE to end of DEST */
-	    leaf_copy_items_entirely(fs, dest_bi, src, FIRST_TO_LAST, pos, cpy_num);
-	else {
-	    /* copy first cpy_num-1 items starting from position 'pos-1' of the SOURCE to the end of the DEST */
-	    leaf_copy_items_entirely(fs, dest_bi, src, FIRST_TO_LAST, pos, cpy_num-1);
-	     
-	    /* copy part of the item which number is cpy_num+pos-1 to the end of the DEST */
-	    leaf_item_bottle (fs, dest_bi, src, FIRST_TO_LAST, cpy_num+pos-1, cpy_bytes);
-	} 
-    } else {
-	/* copy items to right */
-	src_nr_item = B_NR_ITEMS (src);
-	if ( cpy_num == 1 )
-	    bytes = cpy_bytes;
-	else
-	    bytes = -1;
-   
-	/* copy the last item or it part or nothing to the begin of the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,1,bytes)); */
-	i = leaf_copy_boundary_item (fs, dest_bi, src, LAST_TO_FIRST, bytes);
-   
-	cpy_num -= i;
-	if ( cpy_num == 0 )
-	    return i;
-   
-	pos = src_nr_item - cpy_num - i;
-	if ( cpy_bytes == -1 ) {
-	    /* starting from position 'pos' copy last cpy_num items of SOURCE to begin of DEST */
-	    leaf_copy_items_entirely(fs, dest_bi, src, LAST_TO_FIRST, pos, cpy_num);
+	int pos, i, src_nr_item, bytes;
+
+	if (cpy_num == 0)
+		return 0;
+
+	if (last_first == FIRST_TO_LAST) {
+		/* copy items to left */
+		pos = 0;
+		if (cpy_num == 1)
+			bytes = cpy_bytes;
+		else
+			bytes = -1;
+
+		/* copy the first item or it part or nothing to the end of the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,0,bytes)) */
+		i = leaf_copy_boundary_item(fs, dest_bi, src, FIRST_TO_LAST,
+					    bytes);
+		cpy_num -= i;
+		if (cpy_num == 0)
+			return i;
+		pos += i;
+		if (cpy_bytes == -1)
+			/* copy first cpy_num items starting from position 'pos' of SOURCE to end of DEST */
+			leaf_copy_items_entirely(fs, dest_bi, src,
+						 FIRST_TO_LAST, pos, cpy_num);
+		else {
+			/* copy first cpy_num-1 items starting from position 'pos-1' of the SOURCE to the end of the DEST */
+			leaf_copy_items_entirely(fs, dest_bi, src,
+						 FIRST_TO_LAST, pos,
+						 cpy_num - 1);
+
+			/* copy part of the item which number is cpy_num+pos-1 to the end of the DEST */
+			leaf_item_bottle(fs, dest_bi, src, FIRST_TO_LAST,
+					 cpy_num + pos - 1, cpy_bytes);
+		}
 	} else {
-	    /* copy last cpy_num-1 items starting from position 'pos+1' of the SOURCE to the begin of the DEST; */
-	    leaf_copy_items_entirely(fs, dest_bi, src, LAST_TO_FIRST, pos+1, cpy_num-1);
-
-	    /* copy part of the item which number is pos to the begin of the DEST */
-	    leaf_item_bottle (fs, dest_bi, src, LAST_TO_FIRST, pos, cpy_bytes);
+		/* copy items to right */
+		src_nr_item = B_NR_ITEMS(src);
+		if (cpy_num == 1)
+			bytes = cpy_bytes;
+		else
+			bytes = -1;
+
+		/* copy the last item or it part or nothing to the begin of the DEST (i = leaf_copy_boundary_item(DEST,SOURCE,1,bytes)); */
+		i = leaf_copy_boundary_item(fs, dest_bi, src, LAST_TO_FIRST,
+					    bytes);
+
+		cpy_num -= i;
+		if (cpy_num == 0)
+			return i;
+
+		pos = src_nr_item - cpy_num - i;
+		if (cpy_bytes == -1) {
+			/* starting from position 'pos' copy last cpy_num items of SOURCE to begin of DEST */
+			leaf_copy_items_entirely(fs, dest_bi, src,
+						 LAST_TO_FIRST, pos, cpy_num);
+		} else {
+			/* copy last cpy_num-1 items starting from position 'pos+1' of the SOURCE to the begin of the DEST; */
+			leaf_copy_items_entirely(fs, dest_bi, src,
+						 LAST_TO_FIRST, pos + 1,
+						 cpy_num - 1);
+
+			/* copy part of the item which number is pos to the begin of the DEST */
+			leaf_item_bottle(fs, dest_bi, src, LAST_TO_FIRST, pos,
+					 cpy_bytes);
+		}
 	}
-    }
-    return i;
+	return i;
 }
 
-
 /* there are types of coping: from S[0] to L[0], from S[0] to R[0],
    from R[0] to L[0]. for each of these we have to define parent and
    positions of destination and source buffers */
-static void leaf_define_dest_src_infos (int shift_mode, struct tree_balance * tb, struct buffer_info * dest_bi,
-					struct buffer_info * src_bi, int * first_last,
-					struct buffer_head * Snew)
+static void leaf_define_dest_src_infos(int shift_mode, struct tree_balance *tb,
+				       struct buffer_info *dest_bi,
+				       struct buffer_info *src_bi,
+				       int *first_last,
+				       struct buffer_head *Snew)
 {
-    /* define dest, src, dest parent, dest position */
-    switch (shift_mode) {
-    case LEAF_FROM_S_TO_L:    /* it is used in leaf_shift_left */
-	src_bi->bi_bh = PATH_PLAST_BUFFER (tb->tb_path);
-	src_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-	src_bi->bi_position = PATH_H_B_ITEM_ORDER (tb->tb_path, 0);	/* src->b_item_order */
-	dest_bi->bi_bh = tb->L[0];
-	dest_bi->bi_parent = tb->FL[0];
-	dest_bi->bi_position = get_left_neighbor_position (tb, 0);
-	*first_last = FIRST_TO_LAST;
-	break;
-
-    case LEAF_FROM_S_TO_R:  /* it is used in leaf_shift_right */
-	src_bi->bi_bh = PATH_PLAST_BUFFER (tb->tb_path);
-	src_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-	src_bi->bi_position = PATH_H_B_ITEM_ORDER (tb->tb_path, 0);
-	dest_bi->bi_bh = tb->R[0];
-	dest_bi->bi_parent = tb->FR[0];
-	dest_bi->bi_position = get_right_neighbor_position (tb, 0);
-	*first_last = LAST_TO_FIRST;
-	break;
-
-    case LEAF_FROM_R_TO_L:  /* it is used in balance_leaf_when_delete */
-	src_bi->bi_bh = tb->R[0];
-	src_bi->bi_parent = tb->FR[0];
-	src_bi->bi_position = get_right_neighbor_position (tb, 0);
-	dest_bi->bi_bh = tb->L[0];
-	dest_bi->bi_parent = tb->FL[0];
-	dest_bi->bi_position = get_left_neighbor_position (tb, 0);
-	*first_last = FIRST_TO_LAST;
-	break;
-    
-    case LEAF_FROM_L_TO_R:  /* it is used in balance_leaf_when_delete */
-	src_bi->bi_bh = tb->L[0];
-	src_bi->bi_parent = tb->FL[0];
-	src_bi->bi_position = get_left_neighbor_position (tb, 0);
-	dest_bi->bi_bh = tb->R[0];
-	dest_bi->bi_parent = tb->FR[0];
-	dest_bi->bi_position = get_right_neighbor_position (tb, 0);
-	*first_last = LAST_TO_FIRST;
-	break;
-
-    case LEAF_FROM_S_TO_SNEW:
-	src_bi->bi_bh = PATH_PLAST_BUFFER (tb->tb_path);
-	src_bi->bi_parent = PATH_H_PPARENT (tb->tb_path, 0);
-	src_bi->bi_position = PATH_H_B_ITEM_ORDER (tb->tb_path, 0);
-	dest_bi->bi_bh = Snew;
-	dest_bi->bi_parent = 0;
-	dest_bi->bi_position = 0;
-	*first_last = LAST_TO_FIRST;
-	break;
-    
-    default:
-	reiserfs_panic (0, "vs-10250: leaf_define_dest_src_infos: shift type is unknown (%d)", shift_mode);
-    }
+	/* define dest, src, dest parent, dest position */
+	switch (shift_mode) {
+	case LEAF_FROM_S_TO_L:	/* it is used in leaf_shift_left */
+		src_bi->bi_bh = PATH_PLAST_BUFFER(tb->tb_path);
+		src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, 0);
+		src_bi->bi_position = PATH_H_B_ITEM_ORDER(tb->tb_path, 0);	/* src->b_item_order */
+		dest_bi->bi_bh = tb->L[0];
+		dest_bi->bi_parent = tb->FL[0];
+		dest_bi->bi_position = get_left_neighbor_position(tb, 0);
+		*first_last = FIRST_TO_LAST;
+		break;
+
+	case LEAF_FROM_S_TO_R:	/* it is used in leaf_shift_right */
+		src_bi->bi_bh = PATH_PLAST_BUFFER(tb->tb_path);
+		src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, 0);
+		src_bi->bi_position = PATH_H_B_ITEM_ORDER(tb->tb_path, 0);
+		dest_bi->bi_bh = tb->R[0];
+		dest_bi->bi_parent = tb->FR[0];
+		dest_bi->bi_position = get_right_neighbor_position(tb, 0);
+		*first_last = LAST_TO_FIRST;
+		break;
+
+	case LEAF_FROM_R_TO_L:	/* it is used in balance_leaf_when_delete */
+		src_bi->bi_bh = tb->R[0];
+		src_bi->bi_parent = tb->FR[0];
+		src_bi->bi_position = get_right_neighbor_position(tb, 0);
+		dest_bi->bi_bh = tb->L[0];
+		dest_bi->bi_parent = tb->FL[0];
+		dest_bi->bi_position = get_left_neighbor_position(tb, 0);
+		*first_last = FIRST_TO_LAST;
+		break;
+
+	case LEAF_FROM_L_TO_R:	/* it is used in balance_leaf_when_delete */
+		src_bi->bi_bh = tb->L[0];
+		src_bi->bi_parent = tb->FL[0];
+		src_bi->bi_position = get_left_neighbor_position(tb, 0);
+		dest_bi->bi_bh = tb->R[0];
+		dest_bi->bi_parent = tb->FR[0];
+		dest_bi->bi_position = get_right_neighbor_position(tb, 0);
+		*first_last = LAST_TO_FIRST;
+		break;
+
+	case LEAF_FROM_S_TO_SNEW:
+		src_bi->bi_bh = PATH_PLAST_BUFFER(tb->tb_path);
+		src_bi->bi_parent = PATH_H_PPARENT(tb->tb_path, 0);
+		src_bi->bi_position = PATH_H_B_ITEM_ORDER(tb->tb_path, 0);
+		dest_bi->bi_bh = Snew;
+		dest_bi->bi_parent = 0;
+		dest_bi->bi_position = 0;
+		*first_last = LAST_TO_FIRST;
+		break;
+
+	default:
+		reiserfs_panic(0,
+			       "vs-10250: leaf_define_dest_src_infos: shift type is unknown (%d)",
+			       shift_mode);
+	}
 }
 
-
-
-
 /* copy mov_num items and mov_bytes of the (mov_num-1)th item to
    neighbor. Delete them from source */
-int leaf_move_items (int shift_mode, struct tree_balance * tb, 
-		     int mov_num, int mov_bytes, struct buffer_head * Snew)
+int leaf_move_items(int shift_mode, struct tree_balance *tb,
+		    int mov_num, int mov_bytes, struct buffer_head *Snew)
 {
-    int ret_value;
-    struct buffer_info dest_bi, src_bi;
-    int first_last;
+	int ret_value;
+	struct buffer_info dest_bi, src_bi;
+	int first_last;
 
-    leaf_define_dest_src_infos (shift_mode, tb, &dest_bi, &src_bi, &first_last, Snew);
+	leaf_define_dest_src_infos(shift_mode, tb, &dest_bi, &src_bi,
+				   &first_last, Snew);
 
-    ret_value = leaf_copy_items (tb->tb_fs, &dest_bi, src_bi.bi_bh, first_last, mov_num, mov_bytes);
+	ret_value =
+	    leaf_copy_items(tb->tb_fs, &dest_bi, src_bi.bi_bh, first_last,
+			    mov_num, mov_bytes);
 
-    leaf_delete_items (tb->tb_fs, &src_bi, first_last, (first_last == FIRST_TO_LAST) ? 0 : 
-		       (B_NR_ITEMS(src_bi.bi_bh) - mov_num), mov_num, mov_bytes);
+	leaf_delete_items(tb->tb_fs, &src_bi, first_last,
+			  (first_last ==
+			   FIRST_TO_LAST) ? 0 : (B_NR_ITEMS(src_bi.bi_bh) -
+						 mov_num), mov_num, mov_bytes);
 
-  
-    return ret_value;
+	return ret_value;
 }
 
-
 /* Shift shift_num items (and shift_bytes of last shifted item if shift_bytes != -1)
    from S[0] to L[0] and replace the delimiting key */
-int leaf_shift_left (struct tree_balance * tb, int shift_num, int shift_bytes)
+int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes)
 {
-    struct buffer_head * S0 = PATH_PLAST_BUFFER (tb->tb_path);
-    int i;
-
-    /* move shift_num (and shift_bytes bytes) items from S[0] to left neighbor L[0] */
-    i = leaf_move_items (LEAF_FROM_S_TO_L, tb, shift_num, shift_bytes, 0);
+	struct buffer_head *S0 = PATH_PLAST_BUFFER(tb->tb_path);
+	int i;
+
+	/* move shift_num (and shift_bytes bytes) items from S[0] to left neighbor L[0] */
+	i = leaf_move_items(LEAF_FROM_S_TO_L, tb, shift_num, shift_bytes, 0);
+
+	if (shift_num) {
+		if (B_NR_ITEMS(S0) == 0) {
+			/* everything is moved from S[0] */
+			if (PATH_H_POSITION(tb->tb_path, 1) == 0)
+				replace_key(tb->tb_fs, tb->CFL[0], tb->lkey[0],
+					    PATH_H_PPARENT(tb->tb_path, 0), 0);
+		} else {
+			/* replace lkey in CFL[0] by 0-th key from S[0]; */
+			replace_key(tb->tb_fs, tb->CFL[0], tb->lkey[0], S0, 0);
 
-    if ( shift_num ) {
-	if (B_NR_ITEMS (S0) == 0) { 
-	    /* everything is moved from S[0] */
-	    if (PATH_H_POSITION (tb->tb_path, 1) == 0)
-		replace_key(tb->tb_fs, tb->CFL[0], tb->lkey[0], PATH_H_PPARENT (tb->tb_path, 0), 0);
-	} else {
-	    /* replace lkey in CFL[0] by 0-th key from S[0]; */
-	    replace_key(tb->tb_fs, tb->CFL[0], tb->lkey[0], S0, 0);
-      
+		}
 	}
-    }
-  
-    return i;
-}
-
-
-
 
+	return i;
+}
 
 /* CLEANING STOPPED HERE */
 
-
-
-
 /* Shift shift_num (shift_bytes) items from S[0] to the right neighbor, and replace the delimiting key */
-int leaf_shift_right (struct tree_balance * tb, int shift_num, int shift_bytes)
+int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes)
 {
-    int ret_value;
+	int ret_value;
 
-    /* move shift_num (and shift_bytes) items from S[0] to right neighbor R[0] */
-    ret_value = leaf_move_items (LEAF_FROM_S_TO_R, tb, shift_num, shift_bytes, 0);
+	/* move shift_num (and shift_bytes) items from S[0] to right neighbor R[0] */
+	ret_value =
+	    leaf_move_items(LEAF_FROM_S_TO_R, tb, shift_num, shift_bytes, 0);
 
-    /* replace rkey in CFR[0] by the 0-th key from R[0] */
-    if (shift_num) {
-	replace_key(tb->tb_fs, tb->CFR[0], tb->rkey[0], tb->R[0], 0);
-    }
+	/* replace rkey in CFR[0] by the 0-th key from R[0] */
+	if (shift_num) {
+		replace_key(tb->tb_fs, tb->CFR[0], tb->rkey[0], tb->R[0], 0);
+	}
 
-    return ret_value;
+	return ret_value;
 }
 
-
-
-static void leaf_delete_items_entirely (reiserfs_filsys_t * sb,
-					/*struct reiserfs_transaction_handle *th,*/
-					struct buffer_info * bi,
-					int first,
-					int del_num);
+static void leaf_delete_items_entirely(reiserfs_filsys_t *sb,
+				       /*struct reiserfs_transaction_handle *th, */
+				       struct buffer_info *bi,
+				       int first, int del_num);
 /*  If del_bytes == -1, starting from position 'first' delete del_num items in whole in buffer CUR.
     If not. 
     If last_first == 0. Starting from position 'first' delete del_num-1 items in whole. Delete part of body of
@@ -582,279 +644,297 @@ static void leaf_delete_items_entirely (reiserfs_filsys_t * sb,
     If last_first == 1. Starting from position 'first+1' delete del_num-1 items in whole. Delete part of body of
     the last item . Part defined by del_bytes. Don't delete last item header.
 */
-void leaf_delete_items (reiserfs_filsys_t * fs,
-			struct buffer_info * cur_bi,
-			int last_first, 
-			int first, int del_num, int del_bytes)
+void leaf_delete_items(reiserfs_filsys_t *fs,
+		       struct buffer_info *cur_bi,
+		       int last_first, int first, int del_num, int del_bytes)
 {
-    struct buffer_head * bh;
-    int item_amount = B_NR_ITEMS (bh = cur_bi->bi_bh);
-    
-    if ( del_num == 0 )
-	return;
-    
-    if ( first == 0 && del_num == item_amount && del_bytes == -1 ) {
-	make_empty_node (cur_bi);
-	mark_buffer_dirty (bh);
-	return;
-    }
-    
-    if ( del_bytes == -1 )
-	/* delete del_num items beginning from item in position first */
-	leaf_delete_items_entirely (fs, cur_bi, first, del_num);
-    else {
-	if ( last_first == FIRST_TO_LAST ) {
-	    /* delete del_num-1 items beginning from item in position first  */
-	    leaf_delete_items_entirely (fs, cur_bi, first, del_num-1);
-	    
-	    /* delete the part of the first item of the bh do not
-	       delete item header */
-	    leaf_cut_from_buffer (fs, cur_bi, 0, 0, del_bytes);
-	} else  {
-	    struct item_head * ih;
-	    int len;
-	    
-	    /* delete del_num-1 items beginning from item in position first+1  */
-	    leaf_delete_items_entirely (fs, cur_bi, first+1, del_num-1);
-	    
-	    if (I_IS_DIRECTORY_ITEM(ih = B_N_PITEM_HEAD(bh, B_NR_ITEMS(bh)-1))) 	/* the last item is directory  */
-	        /* len = numbers of directory entries in this item */
-	        len = get_ih_entry_count(ih);
-	    else
-		/* len = body len of item */
- 	        len = get_ih_item_len (ih);
-	    
-	    /* delete the part of the last item of the bh 
-	       do not delete item header
-	    */
-	    leaf_cut_from_buffer (fs, cur_bi, B_NR_ITEMS(bh) - 1, len - del_bytes, del_bytes);
+	struct buffer_head *bh;
+	int item_amount = B_NR_ITEMS(bh = cur_bi->bi_bh);
+
+	if (del_num == 0)
+		return;
+
+	if (first == 0 && del_num == item_amount && del_bytes == -1) {
+		make_empty_node(cur_bi);
+		mark_buffer_dirty(bh);
+		return;
 	}
-    }
-}
 
+	if (del_bytes == -1)
+		/* delete del_num items beginning from item in position first */
+		leaf_delete_items_entirely(fs, cur_bi, first, del_num);
+	else {
+		if (last_first == FIRST_TO_LAST) {
+			/* delete del_num-1 items beginning from item in position first  */
+			leaf_delete_items_entirely(fs, cur_bi, first,
+						   del_num - 1);
+
+			/* delete the part of the first item of the bh do not
+			   delete item header */
+			leaf_cut_from_buffer(fs, cur_bi, 0, 0, del_bytes);
+		} else {
+			struct item_head *ih;
+			int len;
+
+			/* delete del_num-1 items beginning from item in position first+1  */
+			leaf_delete_items_entirely(fs, cur_bi, first + 1,
+						   del_num - 1);
+
+			if (I_IS_DIRECTORY_ITEM
+			    (ih = B_N_PITEM_HEAD(bh, B_NR_ITEMS(bh) - 1)))
+				/* the last item is directory  */
+				/* len = numbers of directory entries in this item */
+				len = get_ih_entry_count(ih);
+			else
+				/* len = body len of item */
+				len = get_ih_item_len(ih);
+
+			/* delete the part of the last item of the bh 
+			   do not delete item header
+			 */
+			leaf_cut_from_buffer(fs, cur_bi, B_NR_ITEMS(bh) - 1,
+					     len - del_bytes, del_bytes);
+		}
+	}
+}
 
 /* insert item into the leaf node in position before */
-void leaf_insert_into_buf (reiserfs_filsys_t * s,
-			   struct buffer_info * bi,
-			   int before,
-			   struct item_head * inserted_item_ih,
-			   const char * inserted_item_body,
-			   int zeros_number
-			   )
+void leaf_insert_into_buf(reiserfs_filsys_t *s,
+			  struct buffer_info *bi,
+			  int before,
+			  struct item_head *inserted_item_ih,
+			  const char *inserted_item_body, int zeros_number)
 {
-    struct buffer_head * bh = bi->bi_bh;
-    int nr;
-    struct block_head * blkh;
-    struct item_head * ih;
-    int i;
-    int last_loc, unmoved_loc;
-    char * to;
-
-    blkh = B_BLK_HEAD (bh);
-    nr = get_blkh_nr_items (blkh);
-
-    /* get item new item must be inserted before */
-    ih = B_N_PITEM_HEAD (bh, before);
-
-    /* prepare space for the body of new item */
-    last_loc = nr ? get_ih_location (&ih[nr - before - 1]) : bh->b_size;
-    unmoved_loc = before ? get_ih_location (ih-1) : bh->b_size;
-
-    memmove (bh->b_data + last_loc - get_ih_item_len (inserted_item_ih), 
-	     bh->b_data + last_loc, unmoved_loc - last_loc);
-
-    to = bh->b_data + unmoved_loc - get_ih_item_len (inserted_item_ih);
-    memset (to, 0, zeros_number);
-    to += zeros_number;
-
-    /* copy body to prepared space */
-    if (inserted_item_body)
-	//if (mem_mode == REISERFS_USER_MEM)
-	//  copy_from_user (to, inserted_item_body, inserted_item_ih->ih_item_len - zeros_number);
-	//else {
-	memmove (to, inserted_item_body, get_ih_item_len (inserted_item_ih) - zeros_number);
-    //}
-    else
-	memset(to, '\0', get_ih_item_len (inserted_item_ih) - zeros_number);
-  
-    /* insert item header */
-    memmove (ih + 1, ih, IH_SIZE * (nr - before));
-    memmove (ih, inserted_item_ih, IH_SIZE);
-  
-    /* change locations */
-    for (i = before; i < nr + 1; i ++) {
-	unmoved_loc -= get_ih_item_len (&ih[i-before]);
-	set_ih_location (&ih[i-before], unmoved_loc);
-    }
-  
-    /* sizes, free space, item number */
-    set_blkh_nr_items (blkh, get_blkh_nr_items (blkh) + 1);
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) -
-			 (IH_SIZE + get_ih_item_len (inserted_item_ih)));
-
-    mark_buffer_dirty(bh) ;
-
-    if (bi->bi_parent) { 
-	struct disk_child * dc;
-
-	dc = B_N_CHILD (bi->bi_parent, bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) + IH_SIZE + get_ih_item_len (inserted_item_ih));
-	mark_buffer_dirty(bi->bi_parent) ;
-    }
-
-    if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF)
-	reiserfs_panic ("leaf_insert_into_buf: bad leaf %lu: %b", bh->b_blocknr, bh);
-}
+	struct buffer_head *bh = bi->bi_bh;
+	int nr;
+	struct block_head *blkh;
+	struct item_head *ih;
+	int i;
+	int last_loc, unmoved_loc;
+	char *to;
+
+	blkh = B_BLK_HEAD(bh);
+	nr = get_blkh_nr_items(blkh);
+
+	/* get item new item must be inserted before */
+	ih = B_N_PITEM_HEAD(bh, before);
+
+	/* prepare space for the body of new item */
+	last_loc = nr ? get_ih_location(&ih[nr - before - 1]) : bh->b_size;
+	unmoved_loc = before ? get_ih_location(ih - 1) : bh->b_size;
+
+	memmove(bh->b_data + last_loc - get_ih_item_len(inserted_item_ih),
+		bh->b_data + last_loc, unmoved_loc - last_loc);
+
+	to = bh->b_data + unmoved_loc - get_ih_item_len(inserted_item_ih);
+	memset(to, 0, zeros_number);
+	to += zeros_number;
+
+	/* copy body to prepared space */
+	if (inserted_item_body)
+		//if (mem_mode == REISERFS_USER_MEM)
+		//  copy_from_user (to, inserted_item_body, inserted_item_ih->ih_item_len - zeros_number);
+		//else {
+		memmove(to, inserted_item_body,
+			get_ih_item_len(inserted_item_ih) - zeros_number);
+	//}
+	else
+		memset(to, '\0',
+		       get_ih_item_len(inserted_item_ih) - zeros_number);
+
+	/* insert item header */
+	memmove(ih + 1, ih, IH_SIZE * (nr - before));
+	memmove(ih, inserted_item_ih, IH_SIZE);
 
+	/* change locations */
+	for (i = before; i < nr + 1; i++) {
+		unmoved_loc -= get_ih_item_len(&ih[i - before]);
+		set_ih_location(&ih[i - before], unmoved_loc);
+	}
+
+	/* sizes, free space, item number */
+	set_blkh_nr_items(blkh, get_blkh_nr_items(blkh) + 1);
+	set_blkh_free_space(blkh, get_blkh_free_space(blkh) -
+			    (IH_SIZE + get_ih_item_len(inserted_item_ih)));
+
+	mark_buffer_dirty(bh);
+
+	if (bi->bi_parent) {
+		struct disk_child *dc;
+
+		dc = B_N_CHILD(bi->bi_parent, bi->bi_position);
+		set_dc_child_size(dc,
+				  get_dc_child_size(dc) + IH_SIZE +
+				  get_ih_item_len(inserted_item_ih));
+		mark_buffer_dirty(bi->bi_parent);
+	}
+
+	if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF)
+		reiserfs_panic("leaf_insert_into_buf: bad leaf %lu: %b",
+			       bh->b_blocknr, bh);
+}
 
 /* paste paste_size bytes to affected_item_num-th item. 
    When item is a directory, this only prepare space for new entries */
-void leaf_paste_in_buffer (reiserfs_filsys_t * fs,
-			   struct buffer_info * bi,
-			   int affected_item_num,
-			   int pos_in_item,
-			   int paste_size,
-			   const char * body,
-			   int zeros_number)
+void leaf_paste_in_buffer(reiserfs_filsys_t *fs,
+			  struct buffer_info *bi,
+			  int affected_item_num,
+			  int pos_in_item,
+			  int paste_size, const char *body, int zeros_number)
 {
-    struct buffer_head * bh = bi->bi_bh;
-    int nr;
-    struct block_head * blkh;
-    struct item_head * ih;
-    int i;
-    int last_loc, unmoved_loc;
-
-
-    blkh = B_BLK_HEAD (bh);
-    nr = get_blkh_nr_items (blkh);
-
-    /* item to be appended */
-    ih = B_N_PITEM_HEAD(bh, affected_item_num);
-
-    last_loc = get_ih_location (&ih[nr - affected_item_num - 1]);
-    unmoved_loc = affected_item_num ? get_ih_location (ih-1) : bh->b_size;  
-
-    /* prepare space */
-    memmove (bh->b_data + last_loc - paste_size, bh->b_data + last_loc,
-	     unmoved_loc - last_loc);
-
-
-    /* change locations */
-    for (i = affected_item_num; i < nr; i ++)
-	set_ih_location (&ih[i-affected_item_num], get_ih_location (&ih[i-affected_item_num]) - paste_size);
-
-    if ( body ) {
-	if (!I_IS_DIRECTORY_ITEM(ih)) {
-	    //if (mem_mode == REISERFS_USER_MEM) {
-	    //memset (bh->b_data + unmoved_loc - paste_size, 0, zeros_number);
-	    //copy_from_user (bh->b_data + unmoved_loc - paste_size + zeros_number, body, paste_size - zeros_number);
-	    //} else 
-	    {
-		if (!pos_in_item) {
-		    /* shift data to right */
-		    memmove (bh->b_data + get_ih_location (ih) + paste_size, 
-			     bh->b_data + get_ih_location (ih), get_ih_item_len (ih));
-		    /* paste data in the head of item */
-		    memset (bh->b_data + get_ih_location (ih), 0, zeros_number);
-		    memcpy (bh->b_data + get_ih_location (ih) + zeros_number, body, paste_size - zeros_number);
-		} else {
-		    memset (bh->b_data + unmoved_loc - paste_size, 0, zeros_number);
-		    memcpy (bh->b_data + unmoved_loc - paste_size + zeros_number, body, paste_size - zeros_number);
+	struct buffer_head *bh = bi->bi_bh;
+	int nr;
+	struct block_head *blkh;
+	struct item_head *ih;
+	int i;
+	int last_loc, unmoved_loc;
+
+	blkh = B_BLK_HEAD(bh);
+	nr = get_blkh_nr_items(blkh);
+
+	/* item to be appended */
+	ih = B_N_PITEM_HEAD(bh, affected_item_num);
+
+	last_loc = get_ih_location(&ih[nr - affected_item_num - 1]);
+	unmoved_loc = affected_item_num ? get_ih_location(ih - 1) : bh->b_size;
+
+	/* prepare space */
+	memmove(bh->b_data + last_loc - paste_size, bh->b_data + last_loc,
+		unmoved_loc - last_loc);
+
+	/* change locations */
+	for (i = affected_item_num; i < nr; i++)
+		set_ih_location(&ih[i - affected_item_num],
+				get_ih_location(&ih[i - affected_item_num]) -
+				paste_size);
+
+	if (body) {
+		if (!I_IS_DIRECTORY_ITEM(ih)) {
+			//if (mem_mode == REISERFS_USER_MEM) {
+			//memset (bh->b_data + unmoved_loc - paste_size, 0, zeros_number);
+			//copy_from_user (bh->b_data + unmoved_loc - paste_size + zeros_number, body, paste_size - zeros_number);
+			//} else 
+			{
+				if (!pos_in_item) {
+					/* shift data to right */
+					memmove(bh->b_data +
+						get_ih_location(ih) +
+						paste_size,
+						bh->b_data +
+						get_ih_location(ih),
+						get_ih_item_len(ih));
+					/* paste data in the head of item */
+					memset(bh->b_data + get_ih_location(ih),
+					       0, zeros_number);
+					memcpy(bh->b_data +
+					       get_ih_location(ih) +
+					       zeros_number, body,
+					       paste_size - zeros_number);
+				} else {
+					memset(bh->b_data + unmoved_loc -
+					       paste_size, 0, zeros_number);
+					memcpy(bh->b_data + unmoved_loc -
+					       paste_size + zeros_number, body,
+					       paste_size - zeros_number);
+				}
+			}
 		}
-	    }
-	}
-    }
-    else
-	memset(bh->b_data + unmoved_loc - paste_size,'\0',paste_size);
+	} else
+		memset(bh->b_data + unmoved_loc - paste_size, '\0', paste_size);
 
-    set_ih_item_len (ih, get_ih_item_len (ih) + paste_size);
+	set_ih_item_len(ih, get_ih_item_len(ih) + paste_size);
 
-    /* change free space */
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) - paste_size);
+	/* change free space */
+	set_blkh_free_space(blkh, get_blkh_free_space(blkh) - paste_size);
 
-    mark_buffer_dirty(bh) ;
+	mark_buffer_dirty(bh);
 
-    if (bi->bi_parent) { 
-	struct disk_child * dc;
+	if (bi->bi_parent) {
+		struct disk_child *dc;
 
-	dc = B_N_CHILD (bi->bi_parent, bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) + paste_size);
-	mark_buffer_dirty(bi->bi_parent);
-    }
-    if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF)
-	reiserfs_panic ("leaf_paste_in_buffer: bad leaf %lu: %b", bh->b_blocknr, bh);
+		dc = B_N_CHILD(bi->bi_parent, bi->bi_position);
+		set_dc_child_size(dc, get_dc_child_size(dc) + paste_size);
+		mark_buffer_dirty(bi->bi_parent);
+	}
+	if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF)
+		reiserfs_panic("leaf_paste_in_buffer: bad leaf %lu: %b",
+			       bh->b_blocknr, bh);
 }
 
-
 /* cuts DEL_COUNT entries beginning from FROM-th entry. Directory item
    does not have free space, so it moves DEHs and remaining records as
    necessary. Return value is size of removed part of directory item
    in bytes. */
-static int leaf_cut_entries (struct buffer_head * bh,
-			     struct item_head * ih, 
-			     int from, int del_count)
+static int leaf_cut_entries(struct buffer_head *bh,
+			    struct item_head *ih, int from, int del_count)
 {
-    char * item;
-    struct reiserfs_de_head * deh;
-    int prev_record_offset;	/* offset of record, that is (from-1)th */
-    char * prev_record;		/* */
-    int cut_records_len;		/* length of all removed records */
-    int i;
-    int entry_count;
-
-
-    /* first byte of item */
-    item = B_I_PITEM (bh, ih);
-
-    /* entry head array */
-    deh = B_I_DEH (bh, ih);
-    entry_count = get_ih_entry_count (ih);
-
-    if (del_count == 0) {
-	int shift;
-	int last_location;
-
-	last_location = get_deh_location (deh + entry_count - 1);
-	shift = last_location - DEH_SIZE * entry_count;
-	
-	memmove (deh + entry_count, item + last_location,
-		 get_ih_item_len (ih) - last_location);
-	for (i = 0; i < entry_count; i ++)
-	    set_deh_location (&deh[i], get_deh_location (&deh[i]) - shift);
-
-	return shift;
-    }
-
-    /* first byte of remaining entries, those are BEFORE cut entries
-       (prev_record) and length of all removed records (cut_records_len) */
-    prev_record_offset = (from ? get_deh_location (&deh[from - 1]) : get_ih_item_len (ih));
-    cut_records_len = prev_record_offset/*from_record*/ - get_deh_location (&deh[from + del_count - 1]);
-    prev_record = item + prev_record_offset;
-
-
-    /* adjust locations of remaining entries */
-    for (i = get_ih_entry_count (ih) - 1; i > from + del_count - 1; i --) {
-	set_deh_location (deh + i, get_deh_location (deh + i) - (DEH_SIZE * del_count));
-    }
-
-    for (i = 0; i < from; i ++) {
-	set_deh_location (deh + i, get_deh_location (deh + i) - (DEH_SIZE * del_count + cut_records_len));
-    }
-
-    set_ih_entry_count (ih, get_ih_entry_count (ih) - del_count);
-
-    /* shift entry head array and entries those are AFTER removed entries */
-    memmove ((char *)(deh + from),
-	     deh + from + del_count, 
-	     prev_record - cut_records_len - (char *)(deh + from + del_count));
-  
-    /* shift records, those are BEFORE removed entries */
-    memmove (prev_record - cut_records_len - DEH_SIZE * del_count,
-	     prev_record, item + get_ih_item_len (ih) - prev_record);
-
-    return DEH_SIZE * del_count + cut_records_len;
-}
+	char *item;
+	struct reiserfs_de_head *deh;
+	int prev_record_offset;	/* offset of record, that is (from-1)th */
+	char *prev_record;	/* */
+	int cut_records_len;	/* length of all removed records */
+	int i;
+	int entry_count;
+
+	/* first byte of item */
+	item = B_I_PITEM(bh, ih);
+
+	/* entry head array */
+	deh = B_I_DEH(bh, ih);
+	entry_count = get_ih_entry_count(ih);
+
+	if (del_count == 0) {
+		int shift;
+		int last_location;
+
+		last_location = get_deh_location(deh + entry_count - 1);
+		shift = last_location - DEH_SIZE * entry_count;
+
+		memmove(deh + entry_count, item + last_location,
+			get_ih_item_len(ih) - last_location);
+		for (i = 0; i < entry_count; i++)
+			set_deh_location(&deh[i],
+					 get_deh_location(&deh[i]) - shift);
+
+		return shift;
+	}
+
+	/* first byte of remaining entries, those are BEFORE cut entries
+	   (prev_record) and length of all removed records (cut_records_len) */
+	prev_record_offset =
+	    (from ? get_deh_location(&deh[from - 1]) : get_ih_item_len(ih));
+	cut_records_len =
+	    prev_record_offset /*from_record */  -
+	    get_deh_location(&deh[from + del_count - 1]);
+	prev_record = item + prev_record_offset;
+
+	/* adjust locations of remaining entries */
+	for (i = get_ih_entry_count(ih) - 1; i > from + del_count - 1; i--) {
+		set_deh_location(deh + i,
+				 get_deh_location(deh + i) -
+				 (DEH_SIZE * del_count));
+	}
 
+	for (i = 0; i < from; i++) {
+		set_deh_location(deh + i,
+				 get_deh_location(deh + i) -
+				 (DEH_SIZE * del_count + cut_records_len));
+	}
+
+	set_ih_entry_count(ih, get_ih_entry_count(ih) - del_count);
+
+	/* shift entry head array and entries those are AFTER removed entries */
+	memmove((char *)(deh + from),
+		deh + from + del_count,
+		prev_record - cut_records_len - (char *)(deh + from +
+							 del_count));
+
+	/* shift records, those are BEFORE removed entries */
+	memmove(prev_record - cut_records_len - DEH_SIZE * del_count,
+		prev_record, item + get_ih_item_len(ih) - prev_record);
+
+	return DEH_SIZE * del_count + cut_records_len;
+}
 
 /*  when cut item is part of regular file
         pos_in_item - first byte that must be cut
@@ -864,253 +944,262 @@ static int leaf_cut_entries (struct buffer_head * bh,
         pos_in_item - number of first deleted entry
         cut_size - count of deleted entries
     */
-void leaf_cut_from_buffer (reiserfs_filsys_t * fs,
-			   struct buffer_info * bi, int cut_item_num,
-			   int pos_in_item, int cut_size)
+void leaf_cut_from_buffer(reiserfs_filsys_t *fs,
+			  struct buffer_info *bi, int cut_item_num,
+			  int pos_in_item, int cut_size)
 {
-    int nr;
-    struct buffer_head * bh = bi->bi_bh;
-    struct block_head * blkh;
-    struct item_head * ih;
-    int last_loc, unmoved_loc;
-    int i;
-
-    blkh = B_BLK_HEAD (bh);
-    nr = get_blkh_nr_items (blkh);
-
-    /* item head of truncated item */
-    ih = B_N_PITEM_HEAD (bh, cut_item_num);
-
-    if (I_IS_DIRECTORY_ITEM (ih)) {
-        /* first cut entry ()*/
-        cut_size = leaf_cut_entries (bh, ih, pos_in_item, cut_size);
-        if (pos_in_item == 0) {
-            /* change item key by key of first entry in the item */
-	    set_key_offset_v1 (&ih->ih_key, get_deh_offset (B_I_DEH (bh, ih)));
-            /*memcpy (&ih->ih_key.k_offset, &(B_I_DEH (bh, ih)->deh_offset), SHORT_KEY_SIZE);*/
-	}
-    } else {
-        /* item is direct or indirect */
-        /* shift item body to left if cut is from the head of item */
-        if (pos_in_item == 0) {
-	    memmove (bh->b_data + get_ih_location (ih),
-		     bh->b_data + get_ih_location (ih) + cut_size,
-		     get_ih_item_len (ih) - cut_size);
-
-            /* change key of item */
-            if (I_IS_DIRECT_ITEM(ih)) {
-                //ih->ih_key.k_offset += cut_size;
-                set_offset (key_format (&ih->ih_key), &ih->ih_key, get_offset (&ih->ih_key) + cut_size);
-            } else {
-                //ih->ih_key.k_offset += (cut_size / UNFM_P_SIZE) * bh->b_size;
-                set_offset (key_format (&ih->ih_key), &ih->ih_key, 
-			    get_offset (&ih->ih_key) + (cut_size / UNFM_P_SIZE) * bh->b_size);
-	    }
+	int nr;
+	struct buffer_head *bh = bi->bi_bh;
+	struct block_head *blkh;
+	struct item_head *ih;
+	int last_loc, unmoved_loc;
+	int i;
+
+	blkh = B_BLK_HEAD(bh);
+	nr = get_blkh_nr_items(blkh);
+
+	/* item head of truncated item */
+	ih = B_N_PITEM_HEAD(bh, cut_item_num);
+
+	if (I_IS_DIRECTORY_ITEM(ih)) {
+		/* first cut entry () */
+		cut_size = leaf_cut_entries(bh, ih, pos_in_item, cut_size);
+		if (pos_in_item == 0) {
+			/* change item key by key of first entry in the item */
+			set_key_offset_v1(&ih->ih_key,
+					  get_deh_offset(B_I_DEH(bh, ih)));
+			/*memcpy (&ih->ih_key.k_offset, &(B_I_DEH (bh, ih)->deh_offset), SHORT_KEY_SIZE); */
+		}
+	} else {
+		/* item is direct or indirect */
+		/* shift item body to left if cut is from the head of item */
+		if (pos_in_item == 0) {
+			memmove(bh->b_data + get_ih_location(ih),
+				bh->b_data + get_ih_location(ih) + cut_size,
+				get_ih_item_len(ih) - cut_size);
+
+			/* change key of item */
+			if (I_IS_DIRECT_ITEM(ih)) {
+				//ih->ih_key.k_offset += cut_size;
+				set_offset(key_format(&ih->ih_key), &ih->ih_key,
+					   get_offset(&ih->ih_key) + cut_size);
+			} else {
+				//ih->ih_key.k_offset += (cut_size / UNFM_P_SIZE) * bh->b_size;
+				set_offset(key_format(&ih->ih_key), &ih->ih_key,
+					   get_offset(&ih->ih_key) +
+					   (cut_size / UNFM_P_SIZE) *
+					   bh->b_size);
+			}
+		}
 	}
-    }
-  
-
-    /* location of the last item */
-    last_loc = get_ih_location (&ih[nr - cut_item_num - 1]);
-
-    /* location of the item, which is remaining at the same place */
-    unmoved_loc = cut_item_num ? get_ih_location (ih-1) : bh->b_size;
-
-
-    /* shift */
-    memmove (bh->b_data + last_loc + cut_size, bh->b_data + last_loc,
-	       unmoved_loc - last_loc - cut_size);
-
-    /* change item length */
-    set_ih_item_len (ih, get_ih_item_len (ih) - cut_size);
-  
-    if (I_IS_INDIRECT_ITEM(ih)) {
-        if (pos_in_item)
-            //ih->u.ih_free_space = 0;
-            set_ih_free_space (ih, 0);
-    }
-
-    /* change locations */
-    for (i = cut_item_num; i < nr; i ++) {
-	set_ih_location (&ih[i-cut_item_num], get_ih_location (&ih[i-cut_item_num]) + cut_size);
-    }
-
-    /* size, free space */
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) + cut_size);
-
-    mark_buffer_dirty(bh);
-    
-    if (bi->bi_parent) {
-	struct disk_child * dc;
-
-	dc = B_N_CHILD (bi->bi_parent, bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) - cut_size);
-	mark_buffer_dirty(bi->bi_parent);
-    }
-    if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF &&
-	is_a_leaf(bh->b_data, bh->b_size) != HAS_IH_ARRAY)
-	reiserfs_panic ("leaf_cut_from_buffer: bad leaf %lu: %b",
-			bh->b_blocknr, bh);
-}
 
+	/* location of the last item */
+	last_loc = get_ih_location(&ih[nr - cut_item_num - 1]);
 
-/* delete del_num items from buffer starting from the first'th item */
-static void leaf_delete_items_entirely (reiserfs_filsys_t * fs,
-					struct buffer_info * bi,
-					int first, int del_num)
-{
-    struct buffer_head * bh = bi->bi_bh;
-    int nr;
-    int i, j;
-    int last_loc, last_removed_loc;
-    struct block_head * blkh;
-    struct item_head * ih;
-
-    if (del_num == 0)
-	return;
-    
-    blkh = B_BLK_HEAD (bh);
-    nr = get_blkh_nr_items (blkh);
-
-    if (first == 0 && del_num == nr) {
-	/* this does not work */
-	make_empty_node (bi);
-	
-	mark_buffer_dirty(bh);
-	return;
-    }
-    
-    ih = B_N_PITEM_HEAD (bh, first);
-    
-    /* location of unmovable item */
-    j = (first == 0) ? bh->b_size : get_ih_location (ih-1);
-    
-    /* delete items */
-    last_loc = get_ih_location (&ih[nr - 1 - first]);
-    last_removed_loc = get_ih_location (&ih[del_num-1]);
-    
-    memmove (bh->b_data + last_loc + j - last_removed_loc,
-	     bh->b_data + last_loc, last_removed_loc - last_loc);
-    
-    /* delete item headers */
-    memmove (ih, ih + del_num, (nr - first - del_num) * IH_SIZE);
-    
-    /* change item location */
-    for (i = first; i < nr - del_num; i ++) {
-	set_ih_location (&ih[i-first], get_ih_location (&ih[i-first]) + j - last_removed_loc);
-    }
-    
-    /* sizes, item number */
-    set_blkh_nr_items (blkh, get_blkh_nr_items (blkh)/*nr*/ - del_num);
-    set_blkh_free_space (blkh, get_blkh_free_space (blkh) + j - last_removed_loc + IH_SIZE * del_num);
-    
-    mark_buffer_dirty(bh);
-    
-    if (bi->bi_parent) {
-	struct disk_child * dc;
-
-	dc = B_N_CHILD (bi->bi_parent, bi->bi_position);
-	set_dc_child_size (dc, get_dc_child_size (dc) - 
-	    (j - last_removed_loc + IH_SIZE * del_num));
-	mark_buffer_dirty(bi->bi_parent);
-    }
-    if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF &&
-	is_a_leaf(bh->b_data, bh->b_size) != HAS_IH_ARRAY)
-	reiserfs_panic ("leaf_delete_items_entirely: bad leaf %lu: %b", bh->b_blocknr, bh);
-}
+	/* location of the item, which is remaining at the same place */
+	unmoved_loc = cut_item_num ? get_ih_location(ih - 1) : bh->b_size;
 
+	/* shift */
+	memmove(bh->b_data + last_loc + cut_size, bh->b_data + last_loc,
+		unmoved_loc - last_loc - cut_size);
 
+	/* change item length */
+	set_ih_item_len(ih, get_ih_item_len(ih) - cut_size);
 
+	if (I_IS_INDIRECT_ITEM(ih)) {
+		if (pos_in_item)
+			//ih->u.ih_free_space = 0;
+			set_ih_free_space(ih, 0);
+	}
 
+	/* change locations */
+	for (i = cut_item_num; i < nr; i++) {
+		set_ih_location(&ih[i - cut_item_num],
+				get_ih_location(&ih[i - cut_item_num]) +
+				cut_size);
+	}
 
-/* paste new_entry_count entries (new_dehs, records) into position before to item_num-th item */
-void leaf_paste_entries (struct buffer_head * bh,
-			 int item_num, int before, int new_entry_count,
-			 struct reiserfs_de_head * new_dehs,
-			 const char * records, int paste_size)
+	/* size, free space */
+	set_blkh_free_space(blkh, get_blkh_free_space(blkh) + cut_size);
+
+	mark_buffer_dirty(bh);
+
+	if (bi->bi_parent) {
+		struct disk_child *dc;
+
+		dc = B_N_CHILD(bi->bi_parent, bi->bi_position);
+		set_dc_child_size(dc, get_dc_child_size(dc) - cut_size);
+		mark_buffer_dirty(bi->bi_parent);
+	}
+	if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF &&
+	    is_a_leaf(bh->b_data, bh->b_size) != HAS_IH_ARRAY)
+		reiserfs_panic("leaf_cut_from_buffer: bad leaf %lu: %b",
+			       bh->b_blocknr, bh);
+}
+
+/* delete del_num items from buffer starting from the first'th item */
+static void leaf_delete_items_entirely(reiserfs_filsys_t *fs,
+				       struct buffer_info *bi,
+				       int first, int del_num)
 {
-    struct item_head * ih;
-    char * item;
-    struct reiserfs_de_head * deh;
-    char * insert_point;
-    int i, old_entry_num;
+	struct buffer_head *bh = bi->bi_bh;
+	int nr;
+	int i, j;
+	int last_loc, last_removed_loc;
+	struct block_head *blkh;
+	struct item_head *ih;
 
-    if (new_entry_count == 0)
-        return;
+	if (del_num == 0)
+		return;
 
-    ih = B_N_PITEM_HEAD(bh, item_num);
+	blkh = B_BLK_HEAD(bh);
+	nr = get_blkh_nr_items(blkh);
 
-    /* first byte of dest item */
-    item = B_I_PITEM (bh, ih);
+	if (first == 0 && del_num == nr) {
+		/* this does not work */
+		make_empty_node(bi);
 
-    /* entry head array */
-    deh = B_I_DEH (bh, ih);
+		mark_buffer_dirty(bh);
+		return;
+	}
 
-    /* new records will be pasted at this point */
-    insert_point = item + (before ? get_deh_location (&deh[before - 1]) : (get_ih_item_len (ih) - paste_size));
+	ih = B_N_PITEM_HEAD(bh, first);
 
-    /* adjust locations of records that will be AFTER new records */
-    for (i = get_ih_entry_count (ih) - 1; i >= before; i --)
-	set_deh_location (deh + i, get_deh_location (deh + i) + DEH_SIZE * new_entry_count);
+	/* location of unmovable item */
+	j = (first == 0) ? bh->b_size : get_ih_location(ih - 1);
 
-    /* adjust locations of records that will be BEFORE new records */
-    for (i = 0; i < before; i ++)
-	set_deh_location (deh + i, get_deh_location (deh + i) + paste_size);
+	/* delete items */
+	last_loc = get_ih_location(&ih[nr - 1 - first]);
+	last_removed_loc = get_ih_location(&ih[del_num - 1]);
 
-    old_entry_num = get_ih_entry_count (ih);
-    //I_ENTRY_COUNT(ih) += new_entry_count;
-    set_ih_entry_count (ih, old_entry_num + new_entry_count);
+	memmove(bh->b_data + last_loc + j - last_removed_loc,
+		bh->b_data + last_loc, last_removed_loc - last_loc);
 
-    /* prepare space for pasted records */
-    memmove (insert_point + paste_size, insert_point, item + (get_ih_item_len (ih) - paste_size) - insert_point);
+	/* delete item headers */
+	memmove(ih, ih + del_num, (nr - first - del_num) * IH_SIZE);
 
-    /* copy new records */
-    memcpy (insert_point + DEH_SIZE * new_entry_count, records,
-	    paste_size - DEH_SIZE * new_entry_count);
-  
-    /* prepare space for new entry heads */
-    deh += before;
-    memmove ((char *)(deh + new_entry_count), deh, insert_point - (char *)deh);
+	/* change item location */
+	for (i = first; i < nr - del_num; i++) {
+		set_ih_location(&ih[i - first],
+				get_ih_location(&ih[i - first]) + j -
+				last_removed_loc);
+	}
 
-    /* copy new entry heads */
-    memcpy (deh, new_dehs, DEH_SIZE * new_entry_count);
+	/* sizes, item number */
+	set_blkh_nr_items(blkh, get_blkh_nr_items(blkh) /*nr */ -del_num);
+	set_blkh_free_space(blkh,
+			    get_blkh_free_space(blkh) + j - last_removed_loc +
+			    IH_SIZE * del_num);
 
-    /* set locations of new records */
-    for (i = 0; i < new_entry_count; i ++)
-	set_deh_location (deh + i,
-			  get_deh_location (deh + i) + (- get_deh_location (&new_dehs[new_entry_count - 1]) +
-							insert_point + DEH_SIZE * new_entry_count - item));
+	mark_buffer_dirty(bh);
 
+	if (bi->bi_parent) {
+		struct disk_child *dc;
 
-    /* change item key if neccessary (when we paste before 0-th entry */
-    if (!before)
-	set_key_offset_v1 (&ih->ih_key, get_deh_offset (new_dehs));
+		dc = B_N_CHILD(bi->bi_parent, bi->bi_position);
+		set_dc_child_size(dc, get_dc_child_size(dc) -
+				  (j - last_removed_loc + IH_SIZE * del_num));
+		mark_buffer_dirty(bi->bi_parent);
+	}
+	if (is_a_leaf(bh->b_data, bh->b_size) != THE_LEAF &&
+	    is_a_leaf(bh->b_data, bh->b_size) != HAS_IH_ARRAY)
+		reiserfs_panic("leaf_delete_items_entirely: bad leaf %lu: %b",
+			       bh->b_blocknr, bh);
 }
 
-
+/* paste new_entry_count entries (new_dehs, records) into position before to item_num-th item */
+void leaf_paste_entries(struct buffer_head *bh,
+			int item_num, int before, int new_entry_count,
+			struct reiserfs_de_head *new_dehs,
+			const char *records, int paste_size)
+{
+	struct item_head *ih;
+	char *item;
+	struct reiserfs_de_head *deh;
+	char *insert_point;
+	int i, old_entry_num;
+
+	if (new_entry_count == 0)
+		return;
+
+	ih = B_N_PITEM_HEAD(bh, item_num);
+
+	/* first byte of dest item */
+	item = B_I_PITEM(bh, ih);
+
+	/* entry head array */
+	deh = B_I_DEH(bh, ih);
+
+	/* new records will be pasted at this point */
+	insert_point =
+	    item +
+	    (before ? get_deh_location(&deh[before - 1])
+	     : (get_ih_item_len(ih) - paste_size));
+
+	/* adjust locations of records that will be AFTER new records */
+	for (i = get_ih_entry_count(ih) - 1; i >= before; i--)
+		set_deh_location(deh + i,
+				 get_deh_location(deh + i) +
+				 DEH_SIZE * new_entry_count);
+
+	/* adjust locations of records that will be BEFORE new records */
+	for (i = 0; i < before; i++)
+		set_deh_location(deh + i,
+				 get_deh_location(deh + i) + paste_size);
+
+	old_entry_num = get_ih_entry_count(ih);
+	//I_ENTRY_COUNT(ih) += new_entry_count;
+	set_ih_entry_count(ih, old_entry_num + new_entry_count);
+
+	/* prepare space for pasted records */
+	memmove(insert_point + paste_size, insert_point,
+		item + (get_ih_item_len(ih) - paste_size) - insert_point);
+
+	/* copy new records */
+	memcpy(insert_point + DEH_SIZE * new_entry_count, records,
+	       paste_size - DEH_SIZE * new_entry_count);
+
+	/* prepare space for new entry heads */
+	deh += before;
+	memmove((char *)(deh + new_entry_count), deh,
+		insert_point - (char *)deh);
+
+	/* copy new entry heads */
+	memcpy(deh, new_dehs, DEH_SIZE * new_entry_count);
+
+	/* set locations of new records */
+	for (i = 0; i < new_entry_count; i++)
+		set_deh_location(deh + i,
+				 get_deh_location(deh + i) +
+				 (-get_deh_location
+				  (&new_dehs[new_entry_count - 1]) +
+				  insert_point + DEH_SIZE * new_entry_count -
+				  item));
+
+	/* change item key if neccessary (when we paste before 0-th entry */
+	if (!before)
+		set_key_offset_v1(&ih->ih_key, get_deh_offset(new_dehs));
+}
 
 /* wrappers for operations on one separated node */
 
-void delete_item (reiserfs_filsys_t * fs,
-		  struct buffer_head * bh, int item_num)
+void delete_item(reiserfs_filsys_t *fs, struct buffer_head *bh, int item_num)
 {
-    struct buffer_info bi;
+	struct buffer_info bi;
 
-    bi.bi_bh = bh;
-    bi.bi_parent = 0;
-    bi.bi_position = 0;
-    leaf_delete_items_entirely (fs, &bi, item_num, 1);
+	bi.bi_bh = bh;
+	bi.bi_parent = 0;
+	bi.bi_position = 0;
+	leaf_delete_items_entirely(fs, &bi, item_num, 1);
 }
 
-
-void cut_entry (reiserfs_filsys_t * fs, struct buffer_head * bh,
-		int item_num, int entry_num, int del_count)
+void cut_entry(reiserfs_filsys_t *fs, struct buffer_head *bh,
+	       int item_num, int entry_num, int del_count)
 {
-    struct buffer_info bi;
+	struct buffer_info bi;
 
-    bi.bi_bh = bh;
-    bi.bi_parent = 0;
-    bi.bi_position = 0;
-    leaf_cut_from_buffer (fs, &bi, item_num, entry_num, del_count);
+	bi.bi_bh = bh;
+	bi.bi_parent = 0;
+	bi.bi_position = 0;
+	leaf_cut_from_buffer(fs, &bi, item_num, entry_num, del_count);
 }
-
diff --git a/reiserfscore/node_formats.c b/reiserfscore/node_formats.c
index 5fe5c7a..5d51075 100644
--- a/reiserfscore/node_formats.c
+++ b/reiserfscore/node_formats.c
@@ -5,703 +5,707 @@
 
 #include "includes.h"
 
-int leaf_count_ih(char * buf, int blocksize) {
-    struct item_head * ih;
-    int prev_location;
-    int nr;
-
-    /* look at the table of item head */
-    prev_location = blocksize;
-    ih = (struct item_head *)(buf + BLKH_SIZE);
-    nr = 0;
-    while (1) {
-	if (get_ih_location (ih) + get_ih_item_len (ih) != prev_location)
-	    break;
-	if (get_ih_location (ih) < IH_SIZE * (nr + 1) + BLKH_SIZE)
-	    break;
-	if (get_ih_item_len (ih) > MAX_ITEM_LEN (blocksize))
-	    break;
-	prev_location = get_ih_location (ih);
-	ih ++;
-	nr ++;
-    }
-    
-    return nr;
-}
-
-int leaf_free_space_estimate(char * buf, int blocksize) {
-    struct block_head * blkh;
-    struct item_head * ih;
-    int nr;
-    
-    blkh = (struct block_head *)buf;
-    nr = get_blkh_nr_items(blkh);    
-    ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
-    
-    return (nr ? get_ih_location (ih) : blocksize) - BLKH_SIZE - IH_SIZE * nr;
-}
-
-static int leaf_blkh_correct(char * buf, int blocksize) {
-    struct block_head * blkh;
-    unsigned int nr;
-
-    blkh = (struct block_head *)buf;
-    if (!is_leaf_block_head (buf))
-	return 0;
-
-    nr = get_blkh_nr_items(blkh);
-    if (nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN)))
-	/* item number is too big or too small */
-	return 0;
+int leaf_count_ih(char *buf, int blocksize)
+{
+	struct item_head *ih;
+	int prev_location;
+	int nr;
+
+	/* look at the table of item head */
+	prev_location = blocksize;
+	ih = (struct item_head *)(buf + BLKH_SIZE);
+	nr = 0;
+	while (1) {
+		if (get_ih_location(ih) + get_ih_item_len(ih) != prev_location)
+			break;
+		if (get_ih_location(ih) < IH_SIZE * (nr + 1) + BLKH_SIZE)
+			break;
+		if (get_ih_item_len(ih) > MAX_ITEM_LEN(blocksize))
+			break;
+		prev_location = get_ih_location(ih);
+		ih++;
+		nr++;
+	}
 
-    return leaf_free_space_estimate(buf, blocksize) == get_blkh_free_space (blkh);
+	return nr;
 }
 
-int is_a_leaf(char * buf, int blocksize) {
-    struct block_head * blkh;
-    int counted;
-    
-    blkh = (struct block_head *)buf;
-    if (!is_leaf_block_head (buf))
-	return 0;
+int leaf_free_space_estimate(char *buf, int blocksize)
+{
+	struct block_head *blkh;
+	struct item_head *ih;
+	int nr;
+
+	blkh = (struct block_head *)buf;
+	nr = get_blkh_nr_items(blkh);
+	ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
 
-    counted = leaf_count_ih(buf, blocksize);
-    
-    /* if leaf block header is ok, check item count also. */
-    if (leaf_blkh_correct(buf, blocksize))
-	return counted >= get_blkh_nr_items (blkh) ? THE_LEAF : HAS_IH_ARRAY;
-    
-    /* leaf block header is corrupted, it is ih_array if some items were detected.*/
-    return counted ? HAS_IH_ARRAY : 0;
+	return (nr ? get_ih_location(ih) : blocksize) - BLKH_SIZE -
+	    IH_SIZE * nr;
 }
 
-int leaf_item_number_estimate(struct buffer_head * bh) {
-    struct block_head * blkh;
-    int nr;
-    
-    nr = leaf_count_ih(bh->b_data, bh->b_size);
-    blkh = (struct block_head *)bh->b_data;
+static int leaf_blkh_correct(char *buf, int blocksize)
+{
+	struct block_head *blkh;
+	unsigned int nr;
+
+	blkh = (struct block_head *)buf;
+	if (!is_leaf_block_head(buf))
+		return 0;
 
-    return nr >= get_blkh_nr_items (blkh) ? get_blkh_nr_items (blkh) : nr;
+	nr = get_blkh_nr_items(blkh);
+	if (nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN)))
+		/* item number is too big or too small */
+		return 0;
+
+	return leaf_free_space_estimate(buf,
+					blocksize) == get_blkh_free_space(blkh);
 }
 
-#if 0
-/* this only checks block header and item head array (ih_location-s
-   and ih_item_len-s). Item internals are not checked */
-int does_node_look_like_a_leaf (char * buf, int blocksize)
+int is_a_leaf(char *buf, int blocksize)
 {
-    struct block_head * blkh;
-    struct item_head * ih;
-    int used_space;
-    int prev_location;
-    int i;
-    int nr;
+	struct block_head *blkh;
+	int counted;
 
-    blkh = (struct block_head *)buf;
-    if (!is_leaf_block_head (buf))
-	return 0;
+	blkh = (struct block_head *)buf;
+	if (!is_leaf_block_head(buf))
+		return 0;
 
-    nr = get_blkh_nr_items (blkh);
-    if (nr < 0 || nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN)))
-	/* item number is too big or too small */
-	return 0;
+	counted = leaf_count_ih(buf, blocksize);
 
-    ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
-    used_space = BLKH_SIZE + IH_SIZE * nr + (blocksize - (nr ? get_ih_location (ih) : blocksize));
+	/* if leaf block header is ok, check item count also. */
+	if (leaf_blkh_correct(buf, blocksize))
+		return counted >=
+		    get_blkh_nr_items(blkh) ? THE_LEAF : HAS_IH_ARRAY;
 
-    if (used_space != blocksize - get_blkh_free_space (blkh))
-	/* free space does not match to calculated amount of use space */
-	return 0;
+	/* leaf block header is corrupted, it is ih_array if some items were detected. */
+	return counted ? HAS_IH_ARRAY : 0;
+}
 
-    // FIXME: it is_leaf will hit performance too much - we may have
-    // return 1 here
+int leaf_item_number_estimate(struct buffer_head *bh)
+{
+	struct block_head *blkh;
+	int nr;
 
-    /* check tables of item heads */
-    ih = (struct item_head *)(buf + BLKH_SIZE);
-    prev_location = blocksize;
-    for (i = 0; i < nr; i ++, ih ++) {
-	/* items of zero length are allowed - they may exist for short time
-           during balancing */
-	if (get_ih_location (ih) > blocksize || get_ih_location (ih) < IH_SIZE * nr)
-	    return 0;
-	if (/*ih_item_len (ih) < 1 ||*/ get_ih_item_len (ih) > MAX_ITEM_LEN (blocksize))
-	    return 0;
-	if (prev_location - get_ih_location (ih) != get_ih_item_len (ih))
-	    return 0;
-	prev_location = get_ih_location (ih);
-    }
+	nr = leaf_count_ih(bh->b_data, bh->b_size);
+	blkh = (struct block_head *)bh->b_data;
 
-    // one may imagine much more checks
-    return 1;
+	return nr >= get_blkh_nr_items(blkh) ? get_blkh_nr_items(blkh) : nr;
+}
+
+#if 0
+/* this only checks block header and item head array (ih_location-s
+   and ih_item_len-s). Item internals are not checked */
+int does_node_look_like_a_leaf(char *buf, int blocksize)
+{
+	struct block_head *blkh;
+	struct item_head *ih;
+	int used_space;
+	int prev_location;
+	int i;
+	int nr;
+
+	blkh = (struct block_head *)buf;
+	if (!is_leaf_block_head(buf))
+		return 0;
+
+	nr = get_blkh_nr_items(blkh);
+	if (nr < 0 || nr > ((blocksize - BLKH_SIZE) / (IH_SIZE + MIN_ITEM_LEN)))
+		/* item number is too big or too small */
+		return 0;
+
+	ih = (struct item_head *)(buf + BLKH_SIZE) + nr - 1;
+	used_space =
+	    BLKH_SIZE + IH_SIZE * nr + (blocksize -
+					(nr ? get_ih_location(ih) : blocksize));
+
+	if (used_space != blocksize - get_blkh_free_space(blkh))
+		/* free space does not match to calculated amount of use space */
+		return 0;
+
+	// FIXME: it is_leaf will hit performance too much - we may have
+	// return 1 here
+
+	/* check tables of item heads */
+	ih = (struct item_head *)(buf + BLKH_SIZE);
+	prev_location = blocksize;
+	for (i = 0; i < nr; i++, ih++) {
+		/* items of zero length are allowed - they may exist for short time
+		   during balancing */
+		if (get_ih_location(ih) > blocksize
+		    || get_ih_location(ih) < IH_SIZE * nr)
+			return 0;
+		if ( /*ih_item_len (ih) < 1 || */ get_ih_item_len(ih) >
+		    MAX_ITEM_LEN(blocksize))
+			return 0;
+		if (prev_location - get_ih_location(ih) != get_ih_item_len(ih))
+			return 0;
+		prev_location = get_ih_location(ih);
+	}
+
+	// one may imagine much more checks
+	return 1;
 }
 
 /* check ih_item_len and ih_location. Should be useful when block head is
    corrupted */
-static int does_node_have_ih_array (char * buf, int blocksize)
-{
-    struct item_head * ih;
-    int prev_location;
-    int nr;
-
-    /* look at the table of item head */
-    prev_location = blocksize;
-    ih = (struct item_head *)(buf + BLKH_SIZE);
-    nr = 0;
-    while (1) {
-	if (get_ih_location (ih) + get_ih_item_len (ih) != prev_location)
-	    break;
-
-	prev_location = get_ih_location (ih);
-	ih ++;
-	nr ++;
-    }
-    if (nr < 2)
-	return 0;
-    return nr;
+static int does_node_have_ih_array(char *buf, int blocksize)
+{
+	struct item_head *ih;
+	int prev_location;
+	int nr;
+
+	/* look at the table of item head */
+	prev_location = blocksize;
+	ih = (struct item_head *)(buf + BLKH_SIZE);
+	nr = 0;
+	while (1) {
+		if (get_ih_location(ih) + get_ih_item_len(ih) != prev_location)
+			break;
+
+		prev_location = get_ih_location(ih);
+		ih++;
+		nr++;
+	}
+	if (nr < 2)
+		return 0;
+	return nr;
 }
 #endif
 
 /* returns 1 if buf looks like an internal node, 0 otherwise */
-static int is_correct_internal (char * buf, int blocksize)
+static int is_correct_internal(char *buf, int blocksize)
 {
-    struct block_head * blkh;
-    unsigned int nr;
-    int used_space;
+	struct block_head *blkh;
+	unsigned int nr;
+	int used_space;
 
-    blkh = (struct block_head *)buf;
+	blkh = (struct block_head *)buf;
 
-    if (!is_internal_block_head (buf))
-	return 0;
-    
-    nr = get_blkh_nr_items (blkh);
-    if (nr > (blocksize - BLKH_SIZE - DC_SIZE) / (KEY_SIZE + DC_SIZE))
-	/* for internal which is not root we might check min number of keys */
-	return 0;
+	if (!is_internal_block_head(buf))
+		return 0;
 
-    used_space = BLKH_SIZE + KEY_SIZE * nr + DC_SIZE * (nr + 1);
-    if (used_space != blocksize - get_blkh_free_space (blkh))
-	return 0;
+	nr = get_blkh_nr_items(blkh);
+	if (nr > (blocksize - BLKH_SIZE - DC_SIZE) / (KEY_SIZE + DC_SIZE))
+		/* for internal which is not root we might check min number of keys */
+		return 0;
 
-    // one may imagine much more checks
-    return 1;
-}
+	used_space = BLKH_SIZE + KEY_SIZE * nr + DC_SIZE * (nr + 1);
+	if (used_space != blocksize - get_blkh_free_space(blkh))
+		return 0;
 
+	// one may imagine much more checks
+	return 1;
+}
 
 // make sure that bh contains formatted node of reiserfs tree of
 // 'level'-th level
-int is_tree_node (struct buffer_head * bh, int level)
+int is_tree_node(struct buffer_head *bh, int level)
 {
-    if (B_LEVEL (bh) != level)
-	return 0;
-    if (is_leaf_node (bh))
-	return is_a_leaf(bh->b_data, bh->b_size);
+	if (B_LEVEL(bh) != level)
+		return 0;
+	if (is_leaf_node(bh))
+		return is_a_leaf(bh->b_data, bh->b_size);
 
-    return is_correct_internal (bh->b_data, bh->b_size);
+	return is_correct_internal(bh->b_data, bh->b_size);
 }
 
-
-static int is_desc_block (char * buf, unsigned long buf_size)
+static int is_desc_block(char *buf, unsigned long buf_size)
 {
-    struct reiserfs_journal_desc *desc = (struct reiserfs_journal_desc *)buf;
-    if (!memcmp(buf + buf_size - 12, JOURNAL_DESC_MAGIC, 8) &&
-	le32_to_cpu (desc->j2_len) > 0)
-	return 1;
-    return 0;
+	struct reiserfs_journal_desc *desc =
+	    (struct reiserfs_journal_desc *)buf;
+	if (!memcmp(buf + buf_size - 12, JOURNAL_DESC_MAGIC, 8)
+	    && le32_to_cpu(desc->j2_len) > 0)
+		return 1;
+	return 0;
 }
 
-
-int is_reiserfs_3_5_magic_string (struct reiserfs_super_block * rs)
+int is_reiserfs_3_5_magic_string(struct reiserfs_super_block *rs)
 {
-    return (!strncmp (rs->s_v1.s_magic, REISERFS_3_5_SUPER_MAGIC_STRING, 
-		      strlen ( REISERFS_3_5_SUPER_MAGIC_STRING)));
+	return (!strncmp(rs->s_v1.s_magic, REISERFS_3_5_SUPER_MAGIC_STRING,
+			 strlen(REISERFS_3_5_SUPER_MAGIC_STRING)));
 }
 
-
-int is_reiserfs_3_6_magic_string (struct reiserfs_super_block * rs)
+int is_reiserfs_3_6_magic_string(struct reiserfs_super_block *rs)
 {
-    return (!strncmp (rs->s_v1.s_magic, REISERFS_3_6_SUPER_MAGIC_STRING, 
-		      strlen ( REISERFS_3_6_SUPER_MAGIC_STRING)));
+	return (!strncmp(rs->s_v1.s_magic, REISERFS_3_6_SUPER_MAGIC_STRING,
+			 strlen(REISERFS_3_6_SUPER_MAGIC_STRING)));
 }
 
-
-int is_reiserfs_jr_magic_string (struct reiserfs_super_block * rs)
+int is_reiserfs_jr_magic_string(struct reiserfs_super_block *rs)
 {
-    return (!strncmp (rs->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING, 
-		      strlen ( REISERFS_JR_SUPER_MAGIC_STRING)));
+	return (!strncmp(rs->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING,
+			 strlen(REISERFS_JR_SUPER_MAGIC_STRING)));
 }
 
-
-int is_any_reiserfs_magic_string (struct reiserfs_super_block * rs)
+int is_any_reiserfs_magic_string(struct reiserfs_super_block *rs)
 {
-    if (is_reiserfs_3_5_magic_string (rs) ||
-	is_reiserfs_3_6_magic_string (rs) ||
-	is_reiserfs_jr_magic_string (rs))
-	return 1;
-    return 0;
+	if (is_reiserfs_3_5_magic_string(rs) ||
+	    is_reiserfs_3_6_magic_string(rs) || is_reiserfs_jr_magic_string(rs))
+		return 1;
+	return 0;
 }
 
-
-int get_reiserfs_format (struct reiserfs_super_block * sb)
+int get_reiserfs_format(struct reiserfs_super_block *sb)
 {
-    /* after conversion to 3.6 format we change magic correctly, 
-       but do not change sb_format. When we create non-standard journal 
-       field format in sb get adjusted correctly. Thereby, for standard 
-       journal we should rely on magic and for non-standard - on format */
-    if (is_reiserfs_3_5_magic_string (sb) ||
-	(is_reiserfs_jr_magic_string (sb) && 
-	 get_sb_version (sb) == REISERFS_FORMAT_3_5))
-	return REISERFS_FORMAT_3_5;
+	/* after conversion to 3.6 format we change magic correctly, 
+	   but do not change sb_format. When we create non-standard journal 
+	   field format in sb get adjusted correctly. Thereby, for standard 
+	   journal we should rely on magic and for non-standard - on format */
+	if (is_reiserfs_3_5_magic_string(sb) ||
+	    (is_reiserfs_jr_magic_string(sb) &&
+	     get_sb_version(sb) == REISERFS_FORMAT_3_5))
+		return REISERFS_FORMAT_3_5;
 
-    if (is_reiserfs_3_6_magic_string (sb) ||
-	(is_reiserfs_jr_magic_string (sb) &&
-	 get_sb_version (sb) == REISERFS_FORMAT_3_6))
-	return REISERFS_FORMAT_3_6;
+	if (is_reiserfs_3_6_magic_string(sb) ||
+	    (is_reiserfs_jr_magic_string(sb) &&
+	     get_sb_version(sb) == REISERFS_FORMAT_3_6))
+		return REISERFS_FORMAT_3_6;
 
-    return REISERFS_FORMAT_UNKNOWN;
+	return REISERFS_FORMAT_UNKNOWN;
 }
 
-
-
-int reiserfs_super_block_size (struct reiserfs_super_block * sb)
+int reiserfs_super_block_size(struct reiserfs_super_block *sb)
 {
-    switch (get_reiserfs_format (sb)) {
-    case REISERFS_FORMAT_3_5:
-	return SB_SIZE_V1;
-    case REISERFS_FORMAT_3_6:
-	return SB_SIZE;
-    }
-    reiserfs_panic ("Unknown format found");
-    return 0;
+	switch (get_reiserfs_format(sb)) {
+	case REISERFS_FORMAT_3_5:
+		return SB_SIZE_V1;
+	case REISERFS_FORMAT_3_6:
+		return SB_SIZE;
+	}
+	reiserfs_panic("Unknown format found");
+	return 0;
 }
 
 /* this one had signature in different place of the super_block
    structure */
-int is_prejournaled_reiserfs (struct reiserfs_super_block * rs)
+int is_prejournaled_reiserfs(struct reiserfs_super_block *rs)
 {
-    return (!strncmp((char*)rs + REISERFS_SUPER_MAGIC_STRING_OFFSET_NJ,
-		     REISERFS_3_5_SUPER_MAGIC_STRING,
-		     strlen(REISERFS_3_5_SUPER_MAGIC_STRING)));
+	return (!strncmp((char *)rs + REISERFS_SUPER_MAGIC_STRING_OFFSET_NJ,
+			 REISERFS_3_5_SUPER_MAGIC_STRING,
+			 strlen(REISERFS_3_5_SUPER_MAGIC_STRING)));
 }
 
-int does_look_like_super_block (struct reiserfs_super_block * sb) {
-    if (!is_any_reiserfs_magic_string (sb))
-    	return 0;
-    
-    if (!is_blocksize_correct(get_sb_block_size (sb)))
-	return 0;
-	
-    return 1;
-}
+int does_look_like_super_block(struct reiserfs_super_block *sb)
+{
+	if (!is_any_reiserfs_magic_string(sb))
+		return 0;
 
+	if (!is_blocksize_correct(get_sb_block_size(sb)))
+		return 0;
+
+	return 1;
+}
 
 /* returns code of reiserfs metadata block (leaf, internal, super
    block, journal descriptor), unformatted */
-int who_is_this (char * buf, int blocksize)
+int who_is_this(char *buf, int blocksize)
 {
-    int res;
-    
-    /* super block? */
-    if (does_look_like_super_block ((void *)buf))
-	return THE_SUPER;
+	int res;
 
-    if ((res = is_a_leaf(buf, blocksize)))
-	/* if block head and item head array seem matching (node level, free
-           space, item number, item locations and length), then it is THE_LEAF,
-	  otherwise, it is HAS_IH_ARRAY */
-	return res;
+	/* super block? */
+	if (does_look_like_super_block((void *)buf))
+		return THE_SUPER;
 
-    if (is_correct_internal (buf, blocksize))
-	return THE_INTERNAL;
+	if ((res = is_a_leaf(buf, blocksize)))
+		/* if block head and item head array seem matching (node level, free
+		   space, item number, item locations and length), then it is THE_LEAF,
+		   otherwise, it is HAS_IH_ARRAY */
+		return res;
 
+	if (is_correct_internal(buf, blocksize))
+		return THE_INTERNAL;
 
-    /* journal descriptor block? */
-    if (is_desc_block (buf, blocksize))
-	return THE_JDESC;
+	/* journal descriptor block? */
+	if (is_desc_block(buf, blocksize))
+		return THE_JDESC;
 
-    /* contents of buf does not look like reiserfs metadata. Bitmaps
-       are possible here */
-    return THE_UNKNOWN;
+	/* contents of buf does not look like reiserfs metadata. Bitmaps
+	   are possible here */
+	return THE_UNKNOWN;
 }
 
-
-char * which_block (int code)
+char *which_block(int code)
 {
-    static char * leaf = "leaf";
-    static char * broken_leaf = "broken leaf";
-    static char * internal = "internal";
-    static char * other = "unknown";
-
-    switch (code) {
-    case THE_LEAF:
-	return leaf;
-    case HAS_IH_ARRAY:
-	return broken_leaf;
-    case THE_INTERNAL:
-	return internal;
-    }
-    return other;
+	static char *leaf = "leaf";
+	static char *broken_leaf = "broken leaf";
+	static char *internal = "internal";
+	static char *other = "unknown";
+
+	switch (code) {
+	case THE_LEAF:
+		return leaf;
+	case HAS_IH_ARRAY:
+		return broken_leaf;
+	case THE_INTERNAL:
+		return internal;
+	}
+	return other;
 }
 
-
 /** */
-int block_of_journal (reiserfs_filsys_t * fs, unsigned long block) {
-    if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb)) {
-	/* standard journal */
-	if (block >= get_journal_start_must (fs) &&
-	    block <= get_journal_start_must (fs) + get_jp_journal_size (sb_jp (fs->fs_ondisk_sb)))
-	    return 1;
-	return 0;
-    }
-    
-    if (get_sb_reserved_for_journal (fs->fs_ondisk_sb))
-	/* there is space reserved for the journal on the host device */
-	if (block >= get_journal_start_must (fs) && 
-	    block < get_journal_start_must (fs) + get_sb_reserved_for_journal (fs->fs_ondisk_sb))
-	    return 1;
+int block_of_journal(reiserfs_filsys_t *fs, unsigned long block)
+{
+	if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb)) {
+		/* standard journal */
+		if (block >= get_journal_start_must(fs) &&
+		    block <=
+		    get_journal_start_must(fs) +
+		    get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)))
+			return 1;
+		return 0;
+	}
 
-    return 0;
-}
+	if (get_sb_reserved_for_journal(fs->fs_ondisk_sb))
+		/* there is space reserved for the journal on the host device */
+		if (block >= get_journal_start_must(fs) &&
+		    block <
+		    get_journal_start_must(fs) +
+		    get_sb_reserved_for_journal(fs->fs_ondisk_sb))
+			return 1;
 
+	return 0;
+}
 
-int block_of_bitmap (reiserfs_filsys_t * fs, unsigned long block)
+int block_of_bitmap(reiserfs_filsys_t *fs, unsigned long block)
 {
-    if (spread_bitmaps (fs)) {
-	if (!(block % (fs->fs_blocksize * 8)))
-	    /* bitmap block */
-	    return 1;
-	return (block == (REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize + 1)) ;
-    } else {
-	/* bitmap in */
-	return (block > 2ul && block < 3ul + reiserfs_fs_bmap_nr(fs)) ? 1 : 0;
-    }
-    return 0;
+	if (spread_bitmaps(fs)) {
+		if (!(block % (fs->fs_blocksize * 8)))
+			/* bitmap block */
+			return 1;
+		return (block ==
+			(REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize + 1));
+	} else {
+		/* bitmap in */
+		return (block > 2ul
+			&& block < 3ul + reiserfs_fs_bmap_nr(fs)) ? 1 : 0;
+	}
+	return 0;
 }
 
-
 /* check whether 'block' can be pointed to by an indirect item */
-int not_data_block (reiserfs_filsys_t * fs, unsigned long block)
+int not_data_block(reiserfs_filsys_t *fs, unsigned long block)
 {
-    if (block_of_bitmap (fs, block))
-	/* it is one of bitmap blocks */
-	return 1;
+	if (block_of_bitmap(fs, block))
+		/* it is one of bitmap blocks */
+		return 1;
 
-    if (block_of_journal (fs, block))
-	/* block of journal area */
-	return 1;
+	if (block_of_journal(fs, block))
+		/* block of journal area */
+		return 1;
 
-    if (block <= fs->fs_super_bh->b_blocknr)
-	/* either super block or a block from skipped area at the
-           beginning of filesystem */
-	return 1;
+	if (block <= fs->fs_super_bh->b_blocknr)
+		/* either super block or a block from skipped area at the
+		   beginning of filesystem */
+		return 1;
 
-    return 0;
+	return 0;
 }
 
-
 /* check whether 'block' can be logged */
-int not_journalable (reiserfs_filsys_t * fs, unsigned long block)
-{   
-    /* we should not update SB with journal copy during fsck */
-    if (block < fs->fs_super_bh->b_blocknr)
-	return 1;
+int not_journalable(reiserfs_filsys_t *fs, unsigned long block)
+{
+	/* we should not update SB with journal copy during fsck */
+	if (block < fs->fs_super_bh->b_blocknr)
+		return 1;
 
-    if (block_of_journal (fs, block))
-	return 1;
+	if (block_of_journal(fs, block))
+		return 1;
 
-    if (block >= get_sb_block_count (fs->fs_ondisk_sb))
-	return 1;
+	if (block >= get_sb_block_count(fs->fs_ondisk_sb))
+		return 1;
 
-    return 0;
+	return 0;
 }
 
 // in reiserfs version 0 (undistributed bitmap)
 // FIXME: what if number of bitmaps is 15?
-unsigned int get_journal_old_start_must (reiserfs_filsys_t * fs) {
-    return (REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 1 + 
-	get_sb_bmap_nr (fs->fs_ondisk_sb);
+unsigned int get_journal_old_start_must(reiserfs_filsys_t *fs)
+{
+	return (REISERFS_OLD_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 1 +
+	    get_sb_bmap_nr(fs->fs_ondisk_sb);
 }
 
-unsigned int get_journal_new_start_must (reiserfs_filsys_t * fs)
+unsigned int get_journal_new_start_must(reiserfs_filsys_t *fs)
 {
-    return (REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 2;
+	return (REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize) + 2;
 }
 
-unsigned int get_journal_start_must(reiserfs_filsys_t * fs) {
-    if (is_old_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
-    	return get_journal_old_start_must (fs);
+unsigned int get_journal_start_must(reiserfs_filsys_t *fs)
+{
+	if (is_old_sb_location(fs->fs_super_bh->b_blocknr, fs->fs_blocksize))
+		return get_journal_old_start_must(fs);
 
-    return get_journal_new_start_must(fs);
+	return get_journal_new_start_must(fs);
 }
 
-__u32 get_bytes_number (struct item_head * ih, int blocksize) {
-    switch (get_type (&ih->ih_key)) {
-    case TYPE_DIRECT:
-	return get_ih_item_len (ih);
-    case TYPE_INDIRECT:
-	return I_UNFM_NUM(ih) * blocksize;// - get_ih_free_space (ih);
-    case TYPE_STAT_DATA:
-    case TYPE_DIRENTRY:
+__u32 get_bytes_number(struct item_head * ih, int blocksize)
+{
+	switch (get_type(&ih->ih_key)) {
+	case TYPE_DIRECT:
+		return get_ih_item_len(ih);
+	case TYPE_INDIRECT:
+		return I_UNFM_NUM(ih) * blocksize;	// - get_ih_free_space (ih);
+	case TYPE_STAT_DATA:
+	case TYPE_DIRENTRY:
+		return 0;
+	}
+	reiserfs_warning(stderr,
+			 "get_bytes_number: called for wrong type of item %h",
+			 ih);
 	return 0;
-    }
-    reiserfs_warning (stderr, "get_bytes_number: called for wrong type of item %h", ih);
-    return 0;
 }
 
-
-int check_item_f (reiserfs_filsys_t * fs, struct item_head * ih, char * item);
+int check_item_f(reiserfs_filsys_t *fs, struct item_head *ih, char *item);
 
 /* ih_key, ih_location and ih_item_len seem correct, check other fields */
-static int does_ih_look_correct (struct item_head * ih)
+static int does_ih_look_correct(struct item_head *ih)
 {
-    int ih_key_format;
-    int key_key_format;
-
-    /* key format from item_head */
-    ih_key_format = get_ih_key_format (ih);
-    if (ih_key_format != KEY_FORMAT_1 && ih_key_format != KEY_FORMAT_2)
-	return 0;
-
-    /* key format calculated on key */
-    key_key_format = key_format (&ih->ih_key);
-    if (is_stat_data_ih (ih)) {
-	/* for stat data we can not find key format from a key itself, so look at
-           the item length */
-	if (get_ih_item_len (ih) == SD_SIZE)
-	    key_key_format = KEY_FORMAT_2;
-	else if (get_ih_item_len (ih) == SD_V1_SIZE)
-	    key_key_format = KEY_FORMAT_1;
-	else
-	    return 0;
-    }
-    if (key_key_format != ih_key_format)
-	return 0;
+	int ih_key_format;
+	int key_key_format;
+
+	/* key format from item_head */
+	ih_key_format = get_ih_key_format(ih);
+	if (ih_key_format != KEY_FORMAT_1 && ih_key_format != KEY_FORMAT_2)
+		return 0;
+
+	/* key format calculated on key */
+	key_key_format = key_format(&ih->ih_key);
+	if (is_stat_data_ih(ih)) {
+		/* for stat data we can not find key format from a key itself, so look at
+		   the item length */
+		if (get_ih_item_len(ih) == SD_SIZE)
+			key_key_format = KEY_FORMAT_2;
+		else if (get_ih_item_len(ih) == SD_V1_SIZE)
+			key_key_format = KEY_FORMAT_1;
+		else
+			return 0;
+	}
+	if (key_key_format != ih_key_format)
+		return 0;
 
-    /* we do not check ih_format.fsck_need as fsck might change it. So,
-       debugreiserfs -p will have to dump it */
-    return 1;
+	/* we do not check ih_format.fsck_need as fsck might change it. So,
+	   debugreiserfs -p will have to dump it */
+	return 1;
 }
 
 /* check item length, ih_free_space for pure 3.5 format, unformatted node
    pointers */
-static int is_bad_indirect (reiserfs_filsys_t * fs, struct item_head * ih, char * item,
-			    check_unfm_func_t check_unfm_func)
+static int is_bad_indirect(reiserfs_filsys_t *fs, struct item_head *ih,
+			   char *item, check_unfm_func_t check_unfm_func)
 {
-    unsigned int i;
-    __u32 * ind = (__u32 *)item;
+	unsigned int i;
+	__u32 *ind = (__u32 *) item;
 
-    if (get_ih_item_len (ih) % UNFM_P_SIZE)
-	return 1;
+	if (get_ih_item_len(ih) % UNFM_P_SIZE)
+		return 1;
 
-    for (i = 0; i < I_UNFM_NUM (ih); i ++) {
-	if (!ind [i])
-	    continue;
-	if (check_unfm_func && check_unfm_func (fs, d32_get (ind, i)))
-	    return 1;
-    }
+	for (i = 0; i < I_UNFM_NUM(ih); i++) {
+		if (!ind[i])
+			continue;
+		if (check_unfm_func && check_unfm_func(fs, d32_get(ind, i)))
+			return 1;
+	}
 
-    if (fs->fs_format == REISERFS_FORMAT_3_5) {
-	/* check ih_free_space for 3.5 format only */
-	if (get_ih_free_space (ih) > fs->fs_blocksize - 1)
-	    return 1;
-    }
-    
-    return 0;
-}
+	if (fs->fs_format == REISERFS_FORMAT_3_5) {
+		/* check ih_free_space for 3.5 format only */
+		if (get_ih_free_space(ih) > fs->fs_blocksize - 1)
+			return 1;
+	}
 
+	return 0;
+}
 
 static const struct {
-    hashf_t func;
-    char * name;
-} hashes[] = {{0, "not set"},
-	      {keyed_hash, "\"tea\""},
-	      {yura_hash, "\"rupasov\""},
-	      {r5_hash, "\"r5\""}};        
+	hashf_t func;
+	char *name;
+} hashes[] = { {
+0, "not set"}, {
+keyed_hash, "\"tea\""}, {
+yura_hash, "\"rupasov\""}, {
+r5_hash, "\"r5\""}};
 
 #define HASH_AMOUNT (sizeof (hashes) / sizeof (hashes [0]))
 
-
-
-int known_hashes (void)
+int known_hashes(void)
 {
-    return HASH_AMOUNT;
+	return HASH_AMOUNT;
 }
 
-
 #define good_name(hashfn,name,namelen,deh_offset) \
 (hash_value (hashfn, name, namelen) == GET_HASH_VALUE (deh_offset))
 
-
 /* this also sets hash function */
-int is_properly_hashed (reiserfs_filsys_t * fs,
-			char * name, int namelen, __u32 offset)
+int is_properly_hashed(reiserfs_filsys_t *fs,
+		       char *name, int namelen, __u32 offset)
 {
-    unsigned int i;
+	unsigned int i;
 
-    if (namelen == 1 && name[0] == '.') {
-	if (offset == DOT_OFFSET)
-	    return 1;
-	return 0;
-    }
+	if (namelen == 1 && name[0] == '.') {
+		if (offset == DOT_OFFSET)
+			return 1;
+		return 0;
+	}
 
-    if (namelen == 2 && name[0] == '.' && name[1] == '.') {
-	if (offset == DOT_DOT_OFFSET)
-	    return 1;
-	return 0;
-    }
-
-    if (hash_func_is_unknown (fs)) {
-	/* try to find what hash function the name is sorted with */
-	for (i = 1; i < HASH_AMOUNT; i ++) {
-	    if (good_name (hashes [i].func, name, namelen, offset)) {
-		if (!hash_func_is_unknown (fs)) {
-		    /* two or more hash functions give the same value for this
-                       name */
-		    fprintf (stderr, "Detecting hash code: could not detect hash with name \"%.*s\"\n",
-			     namelen, name);
-		    reiserfs_hash (fs) = 0;
-		    return 1;
-		}
+	if (namelen == 2 && name[0] == '.' && name[1] == '.') {
+		if (offset == DOT_DOT_OFFSET)
+			return 1;
+		return 0;
+	}
 
-		/* set hash function */
- 		reiserfs_hash(fs) = hashes [i].func;
- 	    }
- 	}
+	if (hash_func_is_unknown(fs)) {
+		/* try to find what hash function the name is sorted with */
+		for (i = 1; i < HASH_AMOUNT; i++) {
+			if (good_name(hashes[i].func, name, namelen, offset)) {
+				if (!hash_func_is_unknown(fs)) {
+					/* two or more hash functions give the same value for this
+					   name */
+					fprintf(stderr,
+						"Detecting hash code: could not detect hash with name \"%.*s\"\n",
+						namelen, name);
+					reiserfs_hash(fs) = 0;
+					return 1;
+				}
+
+				/* set hash function */
+				reiserfs_hash(fs) = hashes[i].func;
+			}
+		}
 
-        if (hash_func_is_unknown (fs)) {
-            return 0;
-        }
-    }
+		if (hash_func_is_unknown(fs)) {
+			return 0;
+		}
+	}
 
-    if (good_name (reiserfs_hash(fs), name, namelen, offset))
-	return 1;
+	if (good_name(reiserfs_hash(fs), name, namelen, offset))
+		return 1;
 
-    return 0;
+	return 0;
 }
 
-
-int find_hash_in_use (char * name, int namelen, __u32 offset, unsigned int code_to_try_first)
+int find_hash_in_use(char *name, int namelen, __u32 offset,
+		     unsigned int code_to_try_first)
 {
-    unsigned int i;
+	unsigned int i;
 
-    if (!namelen || !name[0])
-	return UNSET_HASH;
+	if (!namelen || !name[0])
+		return UNSET_HASH;
 
-    if (code_to_try_first) {
-	if (good_name (hashes [code_to_try_first].func, name, namelen, offset))
-	    return code_to_try_first;
-    }
-    
-    for (i = 1; i < HASH_AMOUNT; i ++) {
-	if (i == code_to_try_first)
-	    continue;
-	if (good_name (hashes [i].func, name, namelen, offset))
-	    return i;
-    }
-
-    /* not matching hash found */
-    return UNSET_HASH;
-}
+	if (code_to_try_first) {
+		if (good_name
+		    (hashes[code_to_try_first].func, name, namelen, offset))
+			return code_to_try_first;
+	}
 
+	for (i = 1; i < HASH_AMOUNT; i++) {
+		if (i == code_to_try_first)
+			continue;
+		if (good_name(hashes[i].func, name, namelen, offset))
+			return i;
+	}
 
-char * code2name(unsigned int code) {
-    if (code >= HASH_AMOUNT || code < 0)
-        return 0;
-    return hashes [code].name;
+	/* not matching hash found */
+	return UNSET_HASH;
 }
 
+char *code2name(unsigned int code)
+{
+	if (code >= HASH_AMOUNT || code < 0)
+		return 0;
+	return hashes[code].name;
+}
 
-int func2code (hashf_t func)
+int func2code(hashf_t func)
 {
-    unsigned int i;
-    
-    for (i = 0; i < HASH_AMOUNT; i ++)
-	if (func == hashes [i].func)
-	    return i;
+	unsigned int i;
 
-    reiserfs_panic ("func2code: no hashes matches this function\n");
-    return 0;
-}
+	for (i = 0; i < HASH_AMOUNT; i++)
+		if (func == hashes[i].func)
+			return i;
 
+	reiserfs_panic("func2code: no hashes matches this function\n");
+	return 0;
+}
 
-hashf_t code2func(unsigned int code) {
-    if (code >= HASH_AMOUNT) {
-	reiserfs_warning (stderr, "code2func: wrong hash code %d.\n"
-			  "Using default %s hash function\n", code,
-			  code2name (DEFAULT_HASH));
-	code = DEFAULT_HASH;
-    }
-    return hashes [code].func;
+hashf_t code2func(unsigned int code)
+{
+	if (code >= HASH_AMOUNT) {
+		reiserfs_warning(stderr, "code2func: wrong hash code %d.\n"
+				 "Using default %s hash function\n", code,
+				 code2name(DEFAULT_HASH));
+		code = DEFAULT_HASH;
+	}
+	return hashes[code].func;
 }
 
+hashf_t name2func(char *hash)
+{
+	unsigned int i;
 
-hashf_t name2func (char * hash) {
-    unsigned int i;
- 
-    for (i = 0; i < HASH_AMOUNT; i ++)
-	if (!strcmp (hash, hashes [i].name))
-	    return hashes [i].func;
-    return 0;
+	for (i = 0; i < HASH_AMOUNT; i++)
+		if (!strcmp(hash, hashes[i].name))
+			return hashes[i].func;
+	return 0;
 }
 
-
-int dir_entry_bad_location (struct reiserfs_de_head * deh, struct item_head * ih, int first)
+int dir_entry_bad_location(struct reiserfs_de_head *deh, struct item_head *ih,
+			   int first)
 {
-    if (get_deh_location (deh) < DEH_SIZE * get_ih_entry_count (ih))
-	return 1;
-    
-    if (get_deh_location (deh) >= get_ih_item_len (ih))
-	return 1;
+	if (get_deh_location(deh) < DEH_SIZE * get_ih_entry_count(ih))
+		return 1;
 
-    if (!first && get_deh_location (deh) >= get_deh_location (deh - 1))
-	return 1;
+	if (get_deh_location(deh) >= get_ih_item_len(ih))
+		return 1;
 
-    return 0;
-}
+	if (!first && get_deh_location(deh) >= get_deh_location(deh - 1))
+		return 1;
 
+	return 0;
+}
 
 /* the only corruption which is not considered fatal - is hash mismatching. If
    bad_dir is set - directory item having such names is considered bad */
-static int is_bad_directory (reiserfs_filsys_t * fs, struct item_head * ih, char * item,
-			     int bad_dir)
-{
-    int i;
-    int namelen;
-    struct reiserfs_de_head * deh = (struct reiserfs_de_head *)item;
-    __u32 prev_offset = 0;
-    __u16 prev_location = get_ih_item_len (ih);
-    
-    for (i = 0; i < get_ih_entry_count (ih); i ++, deh ++) {
-	if (get_deh_location (deh) >= prev_location)
-	    return 1;
-	prev_location = get_deh_location (deh);
-	    
-	namelen = name_in_entry_length (ih, deh, i);
-	if (namelen > (int)REISERFS_MAX_NAME_LEN(fs->fs_blocksize))
-	    return 1;
-	
-	if (get_deh_offset (deh) <= prev_offset)
-	    return 1;
-	prev_offset = get_deh_offset (deh);
-	
-	/* check hash value */
-	if (!is_properly_hashed (fs, item + prev_location, namelen, prev_offset)) {
-	    if (bad_dir)
-		/* make is_bad_leaf to not insert whole leaf. Node will be
-		   marked not-insertable and put into tree item by item in
-		   pass 2 */
-		return 1;
+static int is_bad_directory(reiserfs_filsys_t *fs, struct item_head *ih,
+			    char *item, int bad_dir)
+{
+	int i;
+	int namelen;
+	struct reiserfs_de_head *deh = (struct reiserfs_de_head *)item;
+	__u32 prev_offset = 0;
+	__u16 prev_location = get_ih_item_len(ih);
+
+	for (i = 0; i < get_ih_entry_count(ih); i++, deh++) {
+		if (get_deh_location(deh) >= prev_location)
+			return 1;
+		prev_location = get_deh_location(deh);
+
+		namelen = name_in_entry_length(ih, deh, i);
+		if (namelen > (int)REISERFS_MAX_NAME_LEN(fs->fs_blocksize))
+			return 1;
+
+		if (get_deh_offset(deh) <= prev_offset)
+			return 1;
+		prev_offset = get_deh_offset(deh);
+
+		/* check hash value */
+		if (!is_properly_hashed
+		    (fs, item + prev_location, namelen, prev_offset)) {
+			if (bad_dir)
+				/* make is_bad_leaf to not insert whole leaf. Node will be
+				   marked not-insertable and put into tree item by item in
+				   pass 2 */
+				return 1;
+		}
 	}
-    }
 
-    return 0;
+	return 0;
 }
 
-
 /* used by debugreisrefs -p only yet */
-int is_it_bad_item (reiserfs_filsys_t * fs, struct item_head * ih, char * item,
-		    check_unfm_func_t check_unfm, int bad_dir)
+int is_it_bad_item(reiserfs_filsys_t *fs, struct item_head *ih, char *item,
+		   check_unfm_func_t check_unfm, int bad_dir)
 {
-    int retval;
+	int retval;
 
 /*
     if (!does_key_look_correct (fs, &ih->ih_key))
@@ -710,148 +714,143 @@ int is_it_bad_item (reiserfs_filsys_t * fs, struct item_head * ih, char * item,
     if (!does_ih_look_correct (ih))
 	return 1;
 */
-    if (!does_ih_look_correct (ih))
-	return 1;
+	if (!does_ih_look_correct(ih))
+		return 1;
 
-    
-    if (is_stat_data_ih (ih) || is_direct_ih (ih))
-	return 0;
+	if (is_stat_data_ih(ih) || is_direct_ih(ih))
+		return 0;
 
-    if (is_direntry_ih (ih)) {
-	retval =  is_bad_directory (fs, ih, item, bad_dir);
-	/*
-	if (retval)
-	reiserfs_warning (stderr, "is_bad_directory %H\n", ih);*/
-	return retval;
-    }
-    if (is_indirect_ih (ih)) {
-	retval = is_bad_indirect (fs, ih, item, check_unfm);
-	/*
-	if (retval)
-	reiserfs_warning (stderr, "is_bad_indirect %H\n", ih);*/
-	return retval;
-    }
+	if (is_direntry_ih(ih)) {
+		retval = is_bad_directory(fs, ih, item, bad_dir);
+		/*
+		   if (retval)
+		   reiserfs_warning (stderr, "is_bad_directory %H\n", ih); */
+		return retval;
+	}
+	if (is_indirect_ih(ih)) {
+		retval = is_bad_indirect(fs, ih, item, check_unfm);
+		/*
+		   if (retval)
+		   reiserfs_warning (stderr, "is_bad_indirect %H\n", ih); */
+		return retval;
+	}
 
-    return 1;
+	return 1;
 }
 
-
 /* prepare new or old stat data for the new directory */
-void make_dir_stat_data (int blocksize, int key_format, 
-			 __u32 dirid, __u32 objectid, 
-			 struct item_head * ih, void * sd)
+void make_dir_stat_data(int blocksize, int key_format,
+			__u32 dirid, __u32 objectid,
+			struct item_head *ih, void *sd)
 {
-    memset (ih, 0, IH_SIZE);
-    set_key_dirid (&ih->ih_key, dirid);
-    set_key_objectid (&ih->ih_key, objectid);
-    set_key_offset_v1 (&ih->ih_key, SD_OFFSET);
-    set_key_uniqueness (&ih->ih_key, 0);
-
-    set_ih_key_format (ih, key_format);
-    set_ih_free_space (ih, MAX_US_INT);
-
-
-    if (key_format == KEY_FORMAT_2) {
-        struct stat_data *sd_v2 = (struct stat_data *)sd;
-
-	set_ih_item_len (ih, SD_SIZE);
-        set_sd_v2_mode (sd_v2, S_IFDIR + 0755);
-        set_sd_v2_nlink (sd_v2, 2);
-        set_sd_v2_uid (sd_v2, 0);
-        set_sd_v2_gid (sd_v2, 0);
-        set_sd_v2_size (sd_v2, EMPTY_DIR_SIZE);
-        set_sd_v2_atime (sd_v2, time(NULL));
-        sd_v2->sd_ctime = sd_v2->sd_mtime = sd_v2->sd_atime; /* all le */
-        set_sd_v2_rdev (sd_v2, 0);
-        set_sd_v2_blocks (sd_v2, dir_size2st_blocks (EMPTY_DIR_SIZE));
-    }else{
-        struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
-
-	set_ih_item_len (ih, SD_V1_SIZE);
-        set_sd_v1_mode(sd_v1, S_IFDIR + 0755);
-        set_sd_v1_nlink(sd_v1, 2);
-        set_sd_v1_uid (sd_v1, 0);
-        set_sd_v1_gid (sd_v1, 0);
-        set_sd_v1_size(sd_v1, EMPTY_DIR_SIZE_V1);
-        set_sd_v1_atime(sd_v1, time(NULL));
-        sd_v1->sd_ctime = sd_v1->sd_mtime = sd_v1->sd_atime; /* all le */
-        set_sd_v1_blocks(sd_v1, dir_size2st_blocks(EMPTY_DIR_SIZE_V1));
-        set_sd_v1_first_direct_byte(sd_v1, NO_BYTES_IN_DIRECT_ITEM);
-    }
+	memset(ih, 0, IH_SIZE);
+	set_key_dirid(&ih->ih_key, dirid);
+	set_key_objectid(&ih->ih_key, objectid);
+	set_key_offset_v1(&ih->ih_key, SD_OFFSET);
+	set_key_uniqueness(&ih->ih_key, 0);
+
+	set_ih_key_format(ih, key_format);
+	set_ih_free_space(ih, MAX_US_INT);
+
+	if (key_format == KEY_FORMAT_2) {
+		struct stat_data *sd_v2 = (struct stat_data *)sd;
+
+		set_ih_item_len(ih, SD_SIZE);
+		set_sd_v2_mode(sd_v2, S_IFDIR + 0755);
+		set_sd_v2_nlink(sd_v2, 2);
+		set_sd_v2_uid(sd_v2, 0);
+		set_sd_v2_gid(sd_v2, 0);
+		set_sd_v2_size(sd_v2, EMPTY_DIR_SIZE);
+		set_sd_v2_atime(sd_v2, time(NULL));
+		sd_v2->sd_ctime = sd_v2->sd_mtime = sd_v2->sd_atime;	/* all le */
+		set_sd_v2_rdev(sd_v2, 0);
+		set_sd_v2_blocks(sd_v2, dir_size2st_blocks(EMPTY_DIR_SIZE));
+	} else {
+		struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)sd;
+
+		set_ih_item_len(ih, SD_V1_SIZE);
+		set_sd_v1_mode(sd_v1, S_IFDIR + 0755);
+		set_sd_v1_nlink(sd_v1, 2);
+		set_sd_v1_uid(sd_v1, 0);
+		set_sd_v1_gid(sd_v1, 0);
+		set_sd_v1_size(sd_v1, EMPTY_DIR_SIZE_V1);
+		set_sd_v1_atime(sd_v1, time(NULL));
+		sd_v1->sd_ctime = sd_v1->sd_mtime = sd_v1->sd_atime;	/* all le */
+		set_sd_v1_blocks(sd_v1, dir_size2st_blocks(EMPTY_DIR_SIZE_V1));
+		set_sd_v1_first_direct_byte(sd_v1, NO_BYTES_IN_DIRECT_ITEM);
+	}
 }
 
-
-static void _empty_dir_item (int format, char * body, __u32 dirid, __u32 objid,
-			     __u32 par_dirid, __u32 par_objid)
+static void _empty_dir_item(int format, char *body, __u32 dirid, __u32 objid,
+			    __u32 par_dirid, __u32 par_objid)
 {
-    struct reiserfs_de_head * deh;
-    __u16 state;
-
-    memset (body, 0, (format == KEY_FORMAT_2 ? EMPTY_DIR_SIZE : EMPTY_DIR_SIZE_V1));
-    deh = (struct reiserfs_de_head *)body;
-    
-    /* direntry header of "." */
-    set_deh_offset (deh, DOT_OFFSET);
-    set_deh_dirid (deh, dirid);
-    set_deh_objectid (deh, objid);
-    state = (1 << DEH_Visible2);
-    set_deh_state (deh, state);
-
-    /* direntry header of ".." */
-    set_deh_offset (deh + 1, DOT_DOT_OFFSET);
-    /* key of ".." for the root directory */
-    set_deh_dirid (deh + 1, par_dirid);
-    set_deh_objectid (deh + 1, par_objid);
-    set_deh_state (deh + 1, state);
+	struct reiserfs_de_head *deh;
+	__u16 state;
+
+	memset(body, 0,
+	       (format == KEY_FORMAT_2 ? EMPTY_DIR_SIZE : EMPTY_DIR_SIZE_V1));
+	deh = (struct reiserfs_de_head *)body;
+
+	/* direntry header of "." */
+	set_deh_offset(deh, DOT_OFFSET);
+	set_deh_dirid(deh, dirid);
+	set_deh_objectid(deh, objid);
+	state = (1 << DEH_Visible2);
+	set_deh_state(deh, state);
+
+	/* direntry header of ".." */
+	set_deh_offset(deh + 1, DOT_DOT_OFFSET);
+	/* key of ".." for the root directory */
+	set_deh_dirid(deh + 1, par_dirid);
+	set_deh_objectid(deh + 1, par_objid);
+	set_deh_state(deh + 1, state);
+
+	if (format == KEY_FORMAT_2) {
+		set_deh_location(deh, EMPTY_DIR_SIZE - ROUND_UP(strlen(".")));
+		set_deh_location(deh + 1,
+				 get_deh_location(deh) -
+				 ROUND_UP(strlen("..")));
+	} else {
+		set_deh_location(deh, EMPTY_DIR_SIZE_V1 - strlen("."));
+		set_deh_location(deh + 1, get_deh_location(deh) - strlen(".."));
+	}
 
-    if (format == KEY_FORMAT_2) {
-	set_deh_location (deh, EMPTY_DIR_SIZE - ROUND_UP (strlen (".")));
-	set_deh_location (deh + 1, get_deh_location (deh) - ROUND_UP (strlen ("..")));
-    } else {
-	set_deh_location (deh, EMPTY_DIR_SIZE_V1 - strlen ("."));
-	set_deh_location (deh + 1, get_deh_location (deh) - strlen (".."));
-    }
+	/* copy ".." and "." */
+	memcpy(body + get_deh_location(deh), ".", 1);
+	memcpy(body + get_deh_location(deh + 1), "..", 2);
 
-    /* copy ".." and "." */
-    memcpy (body + get_deh_location (deh), ".", 1);
-    memcpy (body + get_deh_location (deh + 1), "..", 2);
-    
 }
 
-
-void make_empty_dir_item_v1 (char * body, __u32 dirid, __u32 objid,
-			     __u32 par_dirid, __u32 par_objid)
+void make_empty_dir_item_v1(char *body, __u32 dirid, __u32 objid,
+			    __u32 par_dirid, __u32 par_objid)
 {
-    _empty_dir_item (KEY_FORMAT_1, body, dirid, objid, par_dirid, par_objid);
+	_empty_dir_item(KEY_FORMAT_1, body, dirid, objid, par_dirid, par_objid);
 }
 
-
-void make_empty_dir_item (char * body, __u32 dirid, __u32 objid,
-			  __u32 par_dirid, __u32 par_objid)
+void make_empty_dir_item(char *body, __u32 dirid, __u32 objid,
+			 __u32 par_dirid, __u32 par_objid)
 {
-    _empty_dir_item (KEY_FORMAT_2, body, dirid, objid, par_dirid, par_objid);
+	_empty_dir_item(KEY_FORMAT_2, body, dirid, objid, par_dirid, par_objid);
 }
 
-
-
 /* for every item call common action and an action corresponding to
    item type */
-void for_every_item (struct buffer_head * bh, item_head_action_t action,
-		     item_action_t * actions)
+void for_every_item(struct buffer_head *bh, item_head_action_t action,
+		    item_action_t *actions)
 {
-    int i;
-    struct item_head * ih;
-    item_action_t iaction;
-
-    ih = B_N_PITEM_HEAD (bh, 0);
-    for (i = 0; i < get_blkh_nr_items (B_BLK_HEAD (bh)); i ++, ih ++) {
-	if (action)
-	    action (ih);
-
-	iaction = actions[get_type (&ih->ih_key)];
-	if (iaction)
-	    iaction (bh, ih);
-    }
+	int i;
+	struct item_head *ih;
+	item_action_t iaction;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	for (i = 0; i < get_blkh_nr_items(B_BLK_HEAD(bh)); i++, ih++) {
+		if (action)
+			action(ih);
+
+		iaction = actions[get_type(&ih->ih_key)];
+		if (iaction)
+			iaction(bh, ih);
+	}
 }
 
 #if __BYTE_ORDER == __LITTLE_ENDIAN
@@ -861,446 +860,462 @@ void for_every_item (struct buffer_head * bh, item_head_action_t action,
 # define set_key_type_v2(key,val)   (void)(key->u.k2_offset_v2.k_type = (val))
 #elif __BYTE_ORDER == __BIG_ENDIAN
 typedef union {
-    struct offset_v2 offset_v2;
-    __u64 linear;
+	struct offset_v2 offset_v2;
+	__u64 linear;
 } __attribute__ ((__packed__)) offset_v2_esafe_overlay;
 
-static inline __u64 get_key_offset_v2 (const struct reiserfs_key *key)
+static inline __u64 get_key_offset_v2(const struct reiserfs_key *key)
 {
-    offset_v2_esafe_overlay tmp =
-                        *(offset_v2_esafe_overlay *) (&(key->u.k2_offset_v2));
-    tmp.linear = le64_to_cpu( tmp.linear );
-    return tmp.offset_v2.k_offset;
+	offset_v2_esafe_overlay tmp =
+	    *(offset_v2_esafe_overlay *) (&(key->u.k2_offset_v2));
+	tmp.linear = le64_to_cpu(tmp.linear);
+	return tmp.offset_v2.k_offset;
 }
 
-static inline __u32 get_key_type_v2 (const struct reiserfs_key *key)
+static inline __u32 get_key_type_v2(const struct reiserfs_key *key)
 {
-    offset_v2_esafe_overlay tmp =
-                        *(offset_v2_esafe_overlay *) (&(key->u.k2_offset_v2));
-    tmp.linear = le64_to_cpu( tmp.linear );
-    return tmp.offset_v2.k_type;
+	offset_v2_esafe_overlay tmp =
+	    *(offset_v2_esafe_overlay *) (&(key->u.k2_offset_v2));
+	tmp.linear = le64_to_cpu(tmp.linear);
+	return tmp.offset_v2.k_type;
 }
 
-static inline void set_key_offset_v2 (struct reiserfs_key *key, __u64 offset)
+static inline void set_key_offset_v2(struct reiserfs_key *key, __u64 offset)
 {
-    offset_v2_esafe_overlay *tmp =
-                        (offset_v2_esafe_overlay *)(&(key->u.k2_offset_v2));
-    tmp->linear = le64_to_cpu(tmp->linear);
-    tmp->offset_v2.k_offset = offset;
-    tmp->linear = cpu_to_le64(tmp->linear);
+	offset_v2_esafe_overlay *tmp =
+	    (offset_v2_esafe_overlay *) (&(key->u.k2_offset_v2));
+	tmp->linear = le64_to_cpu(tmp->linear);
+	tmp->offset_v2.k_offset = offset;
+	tmp->linear = cpu_to_le64(tmp->linear);
 }
 
-static inline void set_key_type_v2 (struct reiserfs_key *key, __u32 type)
+static inline void set_key_type_v2(struct reiserfs_key *key, __u32 type)
 {
-    offset_v2_esafe_overlay *tmp =
-                        (offset_v2_esafe_overlay *)(&(key->u.k2_offset_v2));
-    if (type > 15)
-        reiserfs_panic ("set_key_type_v2: type is too big %d", type);
+	offset_v2_esafe_overlay *tmp =
+	    (offset_v2_esafe_overlay *) (&(key->u.k2_offset_v2));
+	if (type > 15)
+		reiserfs_panic("set_key_type_v2: type is too big %d", type);
 
-    tmp->linear = le64_to_cpu(tmp->linear);
-    tmp->offset_v2.k_type = type;
-    tmp->linear = cpu_to_le64(tmp->linear);
+	tmp->linear = le64_to_cpu(tmp->linear);
+	tmp->offset_v2.k_type = type;
+	tmp->linear = cpu_to_le64(tmp->linear);
 }
 #else
 # error "nuxi/pdp-endian archs are not supported"
 #endif
 
-static inline int is_key_format_1 (int type) {
-    return ( (type == 0 || type == 15) ? 1 : 0);
+static inline int is_key_format_1(int type)
+{
+	return ((type == 0 || type == 15) ? 1 : 0);
 }
 
 /* old keys (on i386) have k_offset_v2.k_type == 15 (direct and
    indirect) or == 0 (dir items and stat data) */
 
 /* */
-int key_format (const struct reiserfs_key *key)
+int key_format(const struct reiserfs_key *key)
 {
-    int type;
+	int type;
 
-    type = get_key_type_v2 (key);
+	type = get_key_type_v2(key);
 
-    if (is_key_format_1 (type))
-	return KEY_FORMAT_1;
+	if (is_key_format_1(type))
+		return KEY_FORMAT_1;
 
-    return KEY_FORMAT_2;
+	return KEY_FORMAT_2;
 }
 
+unsigned long long get_offset(const struct reiserfs_key *key)
+{
+	if (key_format(key) == KEY_FORMAT_1)
+		return get_key_offset_v1(key);
 
-unsigned long long get_offset (const struct reiserfs_key *key) {
-    if (key_format (key) == KEY_FORMAT_1)
-	return get_key_offset_v1 (key);
-
-    return get_key_offset_v2 (key);
+	return get_key_offset_v2(key);
 }
 
-
-int uniqueness2type (__u32 uniqueness)
+int uniqueness2type(__u32 uniqueness)
 {
-    switch (uniqueness) {
-    case V1_SD_UNIQUENESS: return TYPE_STAT_DATA;
-    case V1_INDIRECT_UNIQUENESS: return TYPE_INDIRECT;
-    case V1_DIRECT_UNIQUENESS: return TYPE_DIRECT;
-    case V1_DIRENTRY_UNIQUENESS: return TYPE_DIRENTRY;
-    }
-    return TYPE_UNKNOWN;
+	switch (uniqueness) {
+	case V1_SD_UNIQUENESS:
+		return TYPE_STAT_DATA;
+	case V1_INDIRECT_UNIQUENESS:
+		return TYPE_INDIRECT;
+	case V1_DIRECT_UNIQUENESS:
+		return TYPE_DIRECT;
+	case V1_DIRENTRY_UNIQUENESS:
+		return TYPE_DIRENTRY;
+	}
+	return TYPE_UNKNOWN;
 }
 
-
-__u32 type2uniqueness (int type)
+__u32 type2uniqueness(int type)
 {
-    switch (type) {
-    case TYPE_STAT_DATA: return V1_SD_UNIQUENESS;
-    case TYPE_INDIRECT: return V1_INDIRECT_UNIQUENESS;
-    case TYPE_DIRECT: return V1_DIRECT_UNIQUENESS;
-    case TYPE_DIRENTRY: return V1_DIRENTRY_UNIQUENESS;
-    } 
-    return V1_UNKNOWN_UNIQUENESS;
+	switch (type) {
+	case TYPE_STAT_DATA:
+		return V1_SD_UNIQUENESS;
+	case TYPE_INDIRECT:
+		return V1_INDIRECT_UNIQUENESS;
+	case TYPE_DIRECT:
+		return V1_DIRECT_UNIQUENESS;
+	case TYPE_DIRENTRY:
+		return V1_DIRENTRY_UNIQUENESS;
+	}
+	return V1_UNKNOWN_UNIQUENESS;
 }
 
-
-int get_type (const struct reiserfs_key *key)
+int get_type(const struct reiserfs_key *key)
 {
-    int type_v2 = get_key_type_v2 (key);
+	int type_v2 = get_key_type_v2(key);
 
-    if (is_key_format_1 (type_v2))
-	return uniqueness2type (get_key_uniqueness (key));
+	if (is_key_format_1(type_v2))
+		return uniqueness2type(get_key_uniqueness(key));
 
-    return type_v2;
+	return type_v2;
 }
 
-
-char * key_of_what (const struct reiserfs_key *key)
+char *key_of_what(const struct reiserfs_key *key)
 {
-    switch (get_type (key)) {
-    case TYPE_STAT_DATA: return "SD";
-    case TYPE_INDIRECT: return "IND";
-    case TYPE_DIRECT: return "DRCT";
-    case TYPE_DIRENTRY: return "DIR";
-    default: return "???";
-    }
+	switch (get_type(key)) {
+	case TYPE_STAT_DATA:
+		return "SD";
+	case TYPE_INDIRECT:
+		return "IND";
+	case TYPE_DIRECT:
+		return "DRCT";
+	case TYPE_DIRENTRY:
+		return "DIR";
+	default:
+		return "???";
+	}
 }
 
-
-int type_unknown (struct reiserfs_key *key)
+int type_unknown(struct reiserfs_key *key)
 {
-    int type = get_type (key);
-    
-    switch (type) {
-    case TYPE_STAT_DATA:
-    case TYPE_INDIRECT:
-    case TYPE_DIRECT:
-    case TYPE_DIRENTRY:
-	return 0;
-    default:
-	break;
-    }
-    return 1;
+	int type = get_type(key);
+
+	switch (type) {
+	case TYPE_STAT_DATA:
+	case TYPE_INDIRECT:
+	case TYPE_DIRECT:
+	case TYPE_DIRENTRY:
+		return 0;
+	default:
+		break;
+	}
+	return 1;
 }
 
-
 // this sets key format as well as type of item key belongs to
 //
-void set_type (int format, struct reiserfs_key *key, int type)
+void set_type(int format, struct reiserfs_key *key, int type)
 {
-    if (format == KEY_FORMAT_1)
-	set_key_uniqueness (key, type2uniqueness (type));
-    else
-	set_key_type_v2 (key, type);
+	if (format == KEY_FORMAT_1)
+		set_key_uniqueness(key, type2uniqueness(type));
+	else
+		set_key_type_v2(key, type);
 }
 
-
 // 
-void set_offset (int format, struct reiserfs_key *key, loff_t offset)
+void set_offset(int format, struct reiserfs_key *key, loff_t offset)
 {
-    if (format == KEY_FORMAT_1)
-	set_key_offset_v1 (key, offset);
-    else
-	set_key_offset_v2 (key, offset);
-	
-}
+	if (format == KEY_FORMAT_1)
+		set_key_offset_v1(key, offset);
+	else
+		set_key_offset_v2(key, offset);
 
+}
 
-void set_type_and_offset (int format, struct reiserfs_key *key, loff_t offset, int type)
+void set_type_and_offset(int format, struct reiserfs_key *key, loff_t offset,
+			 int type)
 {
-    set_type (format, key, type);
-    set_offset (format, key, offset);
+	set_type(format, key, type);
+	set_offset(format, key, offset);
 }
 
-
 /* length of the directory entry in directory item. This define calculates
    length of i-th directory entry using directory entry locations from dir
    entry head. When it calculates length of 0-th directory entry, it uses
    length of whole item in place of entry location of the non-existent
    following entry in the calculation.  See picture above.*/
 
-
 // NOTE: this is not name length. This is length of whole entry
-int entry_length (struct item_head * ih, struct reiserfs_de_head * deh, int pos_in_item)
+int entry_length(struct item_head *ih, struct reiserfs_de_head *deh,
+		 int pos_in_item)
 {
-    if (pos_in_item)
-	return (get_deh_location (deh - 1) - get_deh_location (deh));
-    return (get_ih_item_len (ih) - get_deh_location (deh));
+	if (pos_in_item)
+		return (get_deh_location(deh - 1) - get_deh_location(deh));
+	return (get_ih_item_len(ih) - get_deh_location(deh));
 }
 
-
-char * name_in_entry (struct reiserfs_de_head * deh, int pos_in_item)
+char *name_in_entry(struct reiserfs_de_head *deh, int pos_in_item)
 {
-    return ((char *)(deh - pos_in_item) + get_deh_location(deh));
+	return ((char *)(deh - pos_in_item) + get_deh_location(deh));
 }
 
-int name_in_entry_length (struct item_head * ih,
-		 struct reiserfs_de_head * deh, int pos_in_item)
+int name_in_entry_length(struct item_head *ih,
+			 struct reiserfs_de_head *deh, int pos_in_item)
 {
-    int len, i;
-    char * name;
+	int len, i;
+	char *name;
 
-    len = entry_length (ih, deh, pos_in_item);
-    name = name_in_entry (deh, pos_in_item);
+	len = entry_length(ih, deh, pos_in_item);
+	name = name_in_entry(deh, pos_in_item);
 
-    // name might be padded with 0s
-    i = 0;
-    while (name[i] && i < len)
-	i++;
+	// name might be padded with 0s
+	i = 0;
+	while (name[i] && i < len)
+		i++;
 
-    return i;
+	return i;
 }
 
-int name_length (char * name, int key_format)
+int name_length(char *name, int key_format)
 {
-    if (key_format == KEY_FORMAT_2)
-    	return ROUND_UP (strlen(name));
-    else if (key_format == KEY_FORMAT_1)
-    	return strlen(name);
+	if (key_format == KEY_FORMAT_2)
+		return ROUND_UP(strlen(name));
+	else if (key_format == KEY_FORMAT_1)
+		return strlen(name);
 
-    return -1;
+	return -1;
 }
 
 /* key format is stored in 12 bits starting from 0-th of item_head's ih2_format*/
-__u16 get_ih_key_format (const struct item_head * ih)
+__u16 get_ih_key_format(const struct item_head * ih)
 {
-    get_bit_field_XX (16, &ih->ih_format, 0, 12);
+	get_bit_field_XX(16, &ih->ih_format, 0, 12);
 }
 
-
-__u16 get_ih_flags (const struct item_head * ih)
+__u16 get_ih_flags(const struct item_head *ih)
 {
-    get_bit_field_XX (16, &ih->ih_format, 12, 4);
+	get_bit_field_XX(16, &ih->ih_format, 12, 4);
 }
 
-
-void set_ih_key_format (struct item_head * ih, __u16 val)
+void set_ih_key_format(struct item_head *ih, __u16 val)
 {
-    set_bit_field_XX (16, &ih->ih_format, val, 0, 12);
+	set_bit_field_XX(16, &ih->ih_format, val, 0, 12);
 }
 
-
-void set_ih_flags (struct item_head * ih, __u16 val)
+void set_ih_flags(struct item_head *ih, __u16 val)
 {
-    set_bit_field_XX (16, &ih->ih_format, val, 12, 4);
+	set_bit_field_XX(16, &ih->ih_format, val, 12, 4);
 }
 
-
-
 /* access to fields of stat data (both v1 and v2) */
 
-void get_set_sd_field (int field, struct item_head * ih, void * sd,
-		       void * value, int set)
-{
-    if (get_ih_key_format (ih) == KEY_FORMAT_1) {
-	struct stat_data_v1 * sd_v1 = sd;
-
-	switch (field) {
-	case GET_SD_MODE:
-	    if (set)
-		sd_v1->sd_mode = cpu_to_le16 (*(__u16 *)value);
-	    else
-		*(__u16 *)value = le16_to_cpu (sd_v1->sd_mode);
-	    break;
-
-	case GET_SD_SIZE:
-	    /* value must point to 64 bit int */
-	    if (set)
-		sd_v1->sd_size = cpu_to_le32 (*(__u64 *)value);
-	    else
-		*(__u64 *)value = le32_to_cpu (sd_v1->sd_size);
-	    break;
-
-	case GET_SD_BLOCKS:
-	    if (set)
-		sd_v1->u.sd_blocks = cpu_to_le32 (*(__u32 *)value);
-	    else
-		*(__u32 *)value = le32_to_cpu (sd_v1->u.sd_blocks);
-	    break;
-
-	case GET_SD_NLINK:
-	    /* value must point to 32 bit int */
-	    if (set)
-		sd_v1->sd_nlink = cpu_to_le16 (*(__u32 *)value);
-	    else
-		*(__u32 *)value = le16_to_cpu (sd_v1->sd_nlink);
-	    break;
-
-	case GET_SD_FIRST_DIRECT_BYTE:
-	    if (set)
-		sd_v1->sd_first_direct_byte = cpu_to_le32 (*(__u32 *)value);
-	    else
-		*(__u32 *)value = le32_to_cpu (sd_v1->sd_first_direct_byte);
-	    break;
-	    
-	default:
-	    reiserfs_panic ("get_set_sd_field: unknown field of old stat data");
-	}
-    } else {
-	struct stat_data * sd_v2 = sd;
-
-	switch (field) {
-	case GET_SD_MODE:
-	    if (set)
-		sd_v2->sd_mode = cpu_to_le16 (*(__u16 *)value);
-	    else
-		*(__u16 *)value = le16_to_cpu (sd_v2->sd_mode);
-	    break;
-
-	case GET_SD_SIZE:
-	    if (set)
-		sd_v2->sd_size = cpu_to_le64 (*(__u64 *)value);
-	    else
-		*(__u64 *)value = le64_to_cpu (sd_v2->sd_size);
-	    break;
-
-	case GET_SD_BLOCKS:
-	    if (set)
-		sd_v2->sd_blocks = cpu_to_le32 (*(__u32 *)value);
-	    else
-		*(__u32 *)value = le32_to_cpu (sd_v2->sd_blocks);
-	    break;
-
-	case GET_SD_NLINK:
-	    if (set)
-		sd_v2->sd_nlink = cpu_to_le32 (*(__u32 *)value);
-	    else
-		*(__u32 *)value = le32_to_cpu (sd_v2->sd_nlink);
-	    break;
-
-	case GET_SD_FIRST_DIRECT_BYTE:
-	default:
-	    reiserfs_panic ("get_set_sd_field: unknown field of new stat data");
+void get_set_sd_field(int field, struct item_head *ih, void *sd,
+		      void *value, int set)
+{
+	if (get_ih_key_format(ih) == KEY_FORMAT_1) {
+		struct stat_data_v1 *sd_v1 = sd;
+
+		switch (field) {
+		case GET_SD_MODE:
+			if (set)
+				sd_v1->sd_mode = cpu_to_le16(*(__u16 *) value);
+			else
+				*(__u16 *) value = le16_to_cpu(sd_v1->sd_mode);
+			break;
+
+		case GET_SD_SIZE:
+			/* value must point to 64 bit int */
+			if (set)
+				sd_v1->sd_size = cpu_to_le32(*(__u64 *) value);
+			else
+				*(__u64 *) value = le32_to_cpu(sd_v1->sd_size);
+			break;
+
+		case GET_SD_BLOCKS:
+			if (set)
+				sd_v1->u.sd_blocks =
+				    cpu_to_le32(*(__u32 *) value);
+			else
+				*(__u32 *) value =
+				    le32_to_cpu(sd_v1->u.sd_blocks);
+			break;
+
+		case GET_SD_NLINK:
+			/* value must point to 32 bit int */
+			if (set)
+				sd_v1->sd_nlink = cpu_to_le16(*(__u32 *) value);
+			else
+				*(__u32 *) value = le16_to_cpu(sd_v1->sd_nlink);
+			break;
+
+		case GET_SD_FIRST_DIRECT_BYTE:
+			if (set)
+				sd_v1->sd_first_direct_byte =
+				    cpu_to_le32(*(__u32 *) value);
+			else
+				*(__u32 *) value =
+				    le32_to_cpu(sd_v1->sd_first_direct_byte);
+			break;
+
+		default:
+			reiserfs_panic
+			    ("get_set_sd_field: unknown field of old stat data");
+		}
+	} else {
+		struct stat_data *sd_v2 = sd;
+
+		switch (field) {
+		case GET_SD_MODE:
+			if (set)
+				sd_v2->sd_mode = cpu_to_le16(*(__u16 *) value);
+			else
+				*(__u16 *) value = le16_to_cpu(sd_v2->sd_mode);
+			break;
+
+		case GET_SD_SIZE:
+			if (set)
+				sd_v2->sd_size = cpu_to_le64(*(__u64 *) value);
+			else
+				*(__u64 *) value = le64_to_cpu(sd_v2->sd_size);
+			break;
+
+		case GET_SD_BLOCKS:
+			if (set)
+				sd_v2->sd_blocks =
+				    cpu_to_le32(*(__u32 *) value);
+			else
+				*(__u32 *) value =
+				    le32_to_cpu(sd_v2->sd_blocks);
+			break;
+
+		case GET_SD_NLINK:
+			if (set)
+				sd_v2->sd_nlink = cpu_to_le32(*(__u32 *) value);
+			else
+				*(__u32 *) value = le32_to_cpu(sd_v2->sd_nlink);
+			break;
+
+		case GET_SD_FIRST_DIRECT_BYTE:
+		default:
+			reiserfs_panic
+			    ("get_set_sd_field: unknown field of new stat data");
+		}
 	}
-    }
 }
 
-int comp_ids (const void * p1, const void * p2)
+int comp_ids(const void *p1, const void *p2)
 {
-    __u32 id1 = le32_to_cpu(*(__u32 *)p1) ;
-    __u32 id2 = le32_to_cpu(*(__u32 *)p2) ;
+	__u32 id1 = le32_to_cpu(*(__u32 *) p1);
+	__u32 id2 = le32_to_cpu(*(__u32 *) p2);
 
-    if (id1 < id2)
-        return -1;
-    if (id1 > id2)
-        return 1 ;
-    return 0 ;
+	if (id1 < id2)
+		return -1;
+	if (id1 > id2)
+		return 1;
+	return 0;
 }
 
 /* functions to manipulate with super block's objectid map */
 
-int is_objectid_used (reiserfs_filsys_t * fs, __u32 objectid)
+int is_objectid_used(reiserfs_filsys_t *fs, __u32 objectid)
 {
-    __u32 * objectid_map;
-    __u32 count = get_sb_oid_cursize(fs->fs_ondisk_sb);
-    int ret;
-    __u32 pos;
-    __u32 le_id = cpu_to_le32(objectid);
+	__u32 *objectid_map;
+	__u32 count = get_sb_oid_cursize(fs->fs_ondisk_sb);
+	int ret;
+	__u32 pos;
+	__u32 le_id = cpu_to_le32(objectid);
 
+	objectid_map =
+	    (__u32 *) ((char *)fs->fs_ondisk_sb +
+		       reiserfs_super_block_size(fs->fs_ondisk_sb));
 
-    objectid_map = (__u32 *)((char *)fs->fs_ondisk_sb + reiserfs_super_block_size (fs->fs_ondisk_sb));
-    
-    ret = reiserfs_bin_search(&le_id, objectid_map, count, sizeof(__u32), &pos, comp_ids);
+	ret =
+	    reiserfs_bin_search(&le_id, objectid_map, count, sizeof(__u32),
+				&pos, comp_ids);
 
-    /* if the position returned is odd, the oid is in use */
-    if (ret == POSITION_NOT_FOUND)
-	return (pos & 1) ;
+	/* if the position returned is odd, the oid is in use */
+	if (ret == POSITION_NOT_FOUND)
+		return (pos & 1);
 
-    /* if the position returned is even, the oid is in use */
-    return !(pos & 1) ;
+	/* if the position returned is even, the oid is in use */
+	return !(pos & 1);
 }
 
-
-void mark_objectid_used (reiserfs_filsys_t * fs, __u32 objectid)
+void mark_objectid_used(reiserfs_filsys_t *fs, __u32 objectid)
 {
-    int i;
-    __u32 * objectid_map;
-    int cursize;
-
+	int i;
+	__u32 *objectid_map;
+	int cursize;
 
-    if (is_objectid_used (fs, objectid)) {
-	return;
-    }
-
-    objectid_map = (__u32 *)((char *)fs->fs_ondisk_sb + reiserfs_super_block_size (fs->fs_ondisk_sb));
-    cursize = get_sb_oid_cursize (fs->fs_ondisk_sb);
-
-    for (i = 0; i < cursize; i += 2) {
-	if (objectid >= le32_to_cpu (objectid_map [i]) &&
-	    objectid < le32_to_cpu (objectid_map [i + 1]))
-	    /* it is used */
-	    return;
-	
-	if (objectid + 1 == le32_to_cpu (objectid_map[i])) {
-	    /* size of objectid map does not change */
-	    objectid_map[i] = cpu_to_le32 (objectid);
-	    return;
+	if (is_objectid_used(fs, objectid)) {
+		return;
 	}
-	
-	if (objectid == le32_to_cpu (objectid_map[i + 1])) {
-	    /* size of objectid map is decreased */
-	    objectid_map [i + 1] = cpu_to_le32 (le32_to_cpu (objectid_map [i + 1]) + 1);
-
-	    if (i + 2 < cursize) {
-		if (objectid_map[i + 1] == objectid_map[i + 2]) {
-		    memmove (objectid_map + i + 1, objectid_map + i + 1 + 2, 
-			     (cursize - (i + 2 + 2 - 1)) * sizeof (__u32));
-		    set_sb_oid_cursize (fs->fs_ondisk_sb, cursize - 2);
+
+	objectid_map =
+	    (__u32 *) ((char *)fs->fs_ondisk_sb +
+		       reiserfs_super_block_size(fs->fs_ondisk_sb));
+	cursize = get_sb_oid_cursize(fs->fs_ondisk_sb);
+
+	for (i = 0; i < cursize; i += 2) {
+		if (objectid >= le32_to_cpu(objectid_map[i]) &&
+		    objectid < le32_to_cpu(objectid_map[i + 1]))
+			/* it is used */
+			return;
+
+		if (objectid + 1 == le32_to_cpu(objectid_map[i])) {
+			/* size of objectid map does not change */
+			objectid_map[i] = cpu_to_le32(objectid);
+			return;
 		}
-	    }
-	    return;
-	}
-	
-	if (objectid < le32_to_cpu (objectid_map[i])) {
-	    /* size of objectid map must be increased */
-	    if (cursize == get_sb_oid_maxsize (fs->fs_ondisk_sb)) {
-		/* here all objectids between objectid and objectid_map[i] get
-                   used */
-		objectid_map[i] = cpu_to_le32 (objectid);
-		return;
-	    } else {
-		memmove (objectid_map + i + 2, objectid_map + i, (cursize - i) * sizeof (__u32));
-		set_sb_oid_cursize (fs->fs_ondisk_sb, cursize + 2);
-	    }
-	    
-	    objectid_map[i] = cpu_to_le32 (objectid);
-	    objectid_map[i+1] = cpu_to_le32 (objectid + 1);
-	    return;
+
+		if (objectid == le32_to_cpu(objectid_map[i + 1])) {
+			/* size of objectid map is decreased */
+			objectid_map[i + 1] =
+			    cpu_to_le32(le32_to_cpu(objectid_map[i + 1]) + 1);
+
+			if (i + 2 < cursize) {
+				if (objectid_map[i + 1] == objectid_map[i + 2]) {
+					memmove(objectid_map + i + 1,
+						objectid_map + i + 1 + 2,
+						(cursize -
+						 (i + 2 + 2 -
+						  1)) * sizeof(__u32));
+					set_sb_oid_cursize(fs->fs_ondisk_sb,
+							   cursize - 2);
+				}
+			}
+			return;
+		}
+
+		if (objectid < le32_to_cpu(objectid_map[i])) {
+			/* size of objectid map must be increased */
+			if (cursize == get_sb_oid_maxsize(fs->fs_ondisk_sb)) {
+				/* here all objectids between objectid and objectid_map[i] get
+				   used */
+				objectid_map[i] = cpu_to_le32(objectid);
+				return;
+			} else {
+				memmove(objectid_map + i + 2, objectid_map + i,
+					(cursize - i) * sizeof(__u32));
+				set_sb_oid_cursize(fs->fs_ondisk_sb,
+						   cursize + 2);
+			}
+
+			objectid_map[i] = cpu_to_le32(objectid);
+			objectid_map[i + 1] = cpu_to_le32(objectid + 1);
+			return;
+		}
+
 	}
-	
-    }
-    
-    /* append to current objectid map, if we have space */
-    if (i < get_sb_oid_maxsize (fs->fs_ondisk_sb)) {
-	objectid_map[i] = cpu_to_le32 (objectid);
-	objectid_map[i + 1] = cpu_to_le32 (objectid + 1);
-	set_sb_oid_cursize (fs->fs_ondisk_sb, cursize + 2);
-    } else if (i == get_sb_oid_maxsize (fs->fs_ondisk_sb)) {
-	objectid_map[i - 1] = cpu_to_le32 (objectid + 1);
-    } else
-	die ("mark_objectid_as_used: objectid map corrupted");
-    
-    return;
-}
 
+	/* append to current objectid map, if we have space */
+	if (i < get_sb_oid_maxsize(fs->fs_ondisk_sb)) {
+		objectid_map[i] = cpu_to_le32(objectid);
+		objectid_map[i + 1] = cpu_to_le32(objectid + 1);
+		set_sb_oid_cursize(fs->fs_ondisk_sb, cursize + 2);
+	} else if (i == get_sb_oid_maxsize(fs->fs_ondisk_sb)) {
+		objectid_map[i - 1] = cpu_to_le32(objectid + 1);
+	} else
+		die("mark_objectid_as_used: objectid map corrupted");
 
-int is_blocksize_correct (unsigned int blocksize)
-{
-    return ((((blocksize & -blocksize) == blocksize) 
-	&& (blocksize >= 512) && (blocksize <= 8192)));
+	return;
 }
 
+int is_blocksize_correct(unsigned int blocksize)
+{
+	return ((((blocksize & -blocksize) == blocksize)
+		 && (blocksize >= 512) && (blocksize <= 8192)));
+}
diff --git a/reiserfscore/prints.c b/reiserfscore/prints.c
index 3d75366..dc12775 100644
--- a/reiserfscore/prints.c
+++ b/reiserfscore/prints.c
@@ -18,17 +18,16 @@
 
 #ifndef HAVE_REGISTER_PRINTF_SPECIFIER
 #define register_printf_specifier(x, y, z) register_printf_function(x, y, z)
-static int arginfo_ptr (const struct printf_info *info, size_t n,
-			int *argtypes)
+static int arginfo_ptr(const struct printf_info *info, size_t n, int *argtypes)
 #else
-static int arginfo_ptr (const struct printf_info *info, size_t n,
-			int *argtypes, int *size)
+static int arginfo_ptr(const struct printf_info *info, size_t n,
+		       int *argtypes, int *size)
 #endif
 {
 	if (n > 0) {
 		argtypes[0] = PA_FLAG_PTR;
 #ifdef HAVE_REGISTER_PRINTF_SPECIFIER
-		size[0] = sizeof (void *);
+		size[0] = sizeof(void *);
 #endif
 	}
 	return 1;
@@ -45,1002 +44,1066 @@ static int arginfo_ptr (const struct printf_info *info, size_t n,
 
 
 /* %b */
-static int print_block_head (FILE * stream,
-			     const struct printf_info *info,
-			     const void *const *args)
+static int print_block_head(FILE * stream,
+			    const struct printf_info *info,
+			    const void *const *args)
 {
-    const struct buffer_head * bh;
-    char * buffer;
-    int len;
-
-    bh = *((const struct buffer_head **)(args[0]));
-    len = asprintf (&buffer, "level=%d, nr_items=%d, free_space=%d rdkey",
-		    B_LEVEL (bh), B_NR_ITEMS (bh), B_FREE_SPACE (bh));
-    FPRINTF;
+	const struct buffer_head *bh;
+	char *buffer;
+	int len;
+
+	bh = *((const struct buffer_head **)(args[0]));
+	len = asprintf(&buffer, "level=%d, nr_items=%d, free_space=%d rdkey",
+		       B_LEVEL(bh), B_NR_ITEMS(bh), B_FREE_SPACE(bh));
+	FPRINTF;
 }
 
-
 /* %K */
-static int print_short_key (FILE * stream,
-			    const struct printf_info *info,
-			    const void *const *args)
+static int print_short_key(FILE * stream,
+			   const struct printf_info *info,
+			   const void *const *args)
 {
-    const struct reiserfs_key *key;
-    char * buffer;
-    int len;
-
-    key = *((const struct reiserfs_key **)(args[0]));
-    len = asprintf (&buffer, "[%u %u]", get_key_dirid (key),
-		    get_key_objectid (key));
-    FPRINTF;
+	const struct reiserfs_key *key;
+	char *buffer;
+	int len;
+
+	key = *((const struct reiserfs_key **)(args[0]));
+	len = asprintf(&buffer, "[%u %u]", get_key_dirid(key),
+		       get_key_objectid(key));
+	FPRINTF;
 }
 
-
 /* %k */
-static int print_key (FILE * stream,
-		      const struct printf_info *info,
-		      const void *const *args)
+static int print_key(FILE * stream,
+		     const struct printf_info *info, const void *const *args)
 {
-    const struct reiserfs_key *key;
-    char * buffer;
-    int len;
-
-    key = *((const struct reiserfs_key **)(args[0]));
-    len = asprintf (&buffer, "[%u %u 0x%Lx %s (%d)]",  
-		    get_key_dirid (key), get_key_objectid (key),
-		    (unsigned long long)get_offset (key), key_of_what (key), get_type (key));
-    FPRINTF;
+	const struct reiserfs_key *key;
+	char *buffer;
+	int len;
+
+	key = *((const struct reiserfs_key **)(args[0]));
+	len = asprintf(&buffer, "[%u %u 0x%Lx %s (%d)]",
+		       get_key_dirid(key), get_key_objectid(key),
+		       (unsigned long long)get_offset(key), key_of_what(key),
+		       get_type(key));
+	FPRINTF;
 }
 
-
 /* %H */
-static int print_item_head (FILE * stream,
-			    const struct printf_info *info,
-			    const void *const *args)
+static int print_item_head(FILE * stream,
+			   const struct printf_info *info,
+			   const void *const *args)
 {
-    const struct item_head * ih;
-    char * buffer;
-    int len;
-
-    ih = *((const struct item_head **)(args[0]));
-    len = asprintf (&buffer, "%u %u 0x%Lx %s (%d), "
-		    "len %u, location %u entry count %u, fsck need %u, format %s",
-		    get_key_dirid (&ih->ih_key), get_key_objectid (&ih->ih_key),
-		    (unsigned long long)get_offset (&ih->ih_key), key_of_what (&ih->ih_key),
-		    get_type (&ih->ih_key), get_ih_item_len (ih), get_ih_location (ih),
-		    get_ih_entry_count (ih), get_ih_flags (ih),
-		    get_ih_key_format (ih) == KEY_FORMAT_2 ? "new" : 
-		    ((get_ih_key_format (ih) == KEY_FORMAT_1) ? "old" : "BAD"));
-    FPRINTF;
+	const struct item_head *ih;
+	char *buffer;
+	int len;
+
+	ih = *((const struct item_head **)(args[0]));
+	len = asprintf(&buffer, "%u %u 0x%Lx %s (%d), "
+		       "len %u, location %u entry count %u, fsck need %u, format %s",
+		       get_key_dirid(&ih->ih_key),
+		       get_key_objectid(&ih->ih_key),
+		       (unsigned long long)get_offset(&ih->ih_key),
+		       key_of_what(&ih->ih_key), get_type(&ih->ih_key),
+		       get_ih_item_len(ih), get_ih_location(ih),
+		       get_ih_entry_count(ih), get_ih_flags(ih),
+		       get_ih_key_format(ih) ==
+		       KEY_FORMAT_2 ? "new"
+		       : ((get_ih_key_format(ih) ==
+			   KEY_FORMAT_1) ? "old" : "BAD"));
+	FPRINTF;
 }
 
-
-static int print_disk_child (FILE * stream,
-			     const struct printf_info *info,
-			     const void *const *args)
+static int print_disk_child(FILE * stream,
+			    const struct printf_info *info,
+			    const void *const *args)
 {
-    const struct disk_child * dc;
-    char * buffer;
-    int len;
-
-    dc = *((const struct disk_child **)(args[0]));
-    len = asprintf (&buffer, "[dc_number=%u, dc_size=%u]", get_dc_child_blocknr (dc),
-		    get_dc_child_size (dc));
-    FPRINTF;
+	const struct disk_child *dc;
+	char *buffer;
+	int len;
+
+	dc = *((const struct disk_child **)(args[0]));
+	len =
+	    asprintf(&buffer, "[dc_number=%u, dc_size=%u]",
+		     get_dc_child_blocknr(dc), get_dc_child_size(dc));
+	FPRINTF;
 }
 
-
-char ftypelet (mode_t mode)
+char ftypelet(mode_t mode)
 {
-    if (S_ISBLK (mode))
-	return 'b';
-    if (S_ISCHR (mode))
-	return 'c';
-    if (S_ISDIR (mode))
-	return 'd';
-    if (S_ISREG (mode))
-	return '-';
-    if (S_ISFIFO (mode))
-	return 'p';
-    if (S_ISLNK (mode))
-	return 'l';
-    if (S_ISSOCK (mode))
-	return 's';
-    return '?';
+	if (S_ISBLK(mode))
+		return 'b';
+	if (S_ISCHR(mode))
+		return 'c';
+	if (S_ISDIR(mode))
+		return 'd';
+	if (S_ISREG(mode))
+		return '-';
+	if (S_ISFIFO(mode))
+		return 'p';
+	if (S_ISLNK(mode))
+		return 'l';
+	if (S_ISSOCK(mode))
+		return 's';
+	return '?';
 }
 
-
-static int rwx (FILE * stream, mode_t mode)
+static int rwx(FILE * stream, mode_t mode)
 {
-    return fprintf (stream, "%c%c%c",
-		    (mode & S_IRUSR) ? 'r' : '-',
-		    (mode & S_IWUSR) ? 'w' : '-',
-		    (mode & S_IXUSR) ? 'x' : '-');
+	return fprintf(stream, "%c%c%c",
+		       (mode & S_IRUSR) ? 'r' : '-',
+		       (mode & S_IWUSR) ? 'w' : '-',
+		       (mode & S_IXUSR) ? 'x' : '-');
 }
 
-
 /* %M */
-static int print_sd_mode (FILE * stream,
-			  const struct printf_info *info,
-			  const void *const *args)
+static int print_sd_mode(FILE * stream,
+			 const struct printf_info *info,
+			 const void *const *args)
 {
-    int len = 0;
-    __u16 mode;
-
-    mode = *(mode_t *)args[0];
-    len = fprintf (stream, "%c", ftypelet (mode));
-    len += rwx (stream, (mode & 0700) << 0);
-    len += rwx (stream, (mode & 0070) << 3);
-    len += rwx (stream, (mode & 0007) << 6);
-    return len;
+	int len = 0;
+	__u16 mode;
+
+	mode = *(mode_t *) args[0];
+	len = fprintf(stream, "%c", ftypelet(mode));
+	len += rwx(stream, (mode & 0700) << 0);
+	len += rwx(stream, (mode & 0070) << 3);
+	len += rwx(stream, (mode & 0007) << 6);
+	return len;
 }
 
 /* %U */
-static int print_sd_uuid (FILE * stream,
-			  const struct printf_info *info,
-			  const void *const *args)
+static int print_sd_uuid(FILE * stream,
+			 const struct printf_info *info,
+			 const void *const *args)
 {
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-    const unsigned char *uuid = *((const unsigned char **)(args[0]));
-    char buf[37];
+	const unsigned char *uuid = *((const unsigned char **)(args[0]));
+	char buf[37];
 
-    buf[36] = '\0';
-    uuid_unparse(uuid, buf);
-    return fprintf(stream, "%s", buf);
+	buf[36] = '\0';
+	uuid_unparse(uuid, buf);
+	return fprintf(stream, "%s", buf);
 #else
-    return fprintf(stream, "<no libuuid installed>");
+	return fprintf(stream, "<no libuuid installed>");
 #endif
 }
 
-void reiserfs_warning (FILE * fp, const char * fmt, ...) 
+void reiserfs_warning(FILE * fp, const char *fmt, ...)
 {
-    static int registered = 0;
-    va_list args;
-
-    if (!registered) {
-	registered = 1;
-	
-	register_printf_specifier ('K', print_short_key, arginfo_ptr);
-	register_printf_specifier ('k', print_key, arginfo_ptr);
-	register_printf_specifier ('H', print_item_head, arginfo_ptr);
-	register_printf_specifier ('b', print_block_head, arginfo_ptr);
-	register_printf_specifier ('y', print_disk_child, arginfo_ptr);
-	register_printf_specifier ('M', print_sd_mode, arginfo_ptr);
-	register_printf_specifier ('U', print_sd_uuid, arginfo_ptr);
-    }
-
-    va_start (args, fmt);
-    vfprintf (fp, fmt, args);
-    va_end (args);
-}
+	static int registered = 0;
+	va_list args;
+
+	if (!registered) {
+		registered = 1;
+
+		register_printf_specifier('K', print_short_key, arginfo_ptr);
+		register_printf_specifier('k', print_key, arginfo_ptr);
+		register_printf_specifier('H', print_item_head, arginfo_ptr);
+		register_printf_specifier('b', print_block_head, arginfo_ptr);
+		register_printf_specifier('y', print_disk_child, arginfo_ptr);
+		register_printf_specifier('M', print_sd_mode, arginfo_ptr);
+		register_printf_specifier('U', print_sd_uuid, arginfo_ptr);
+	}
 
+	va_start(args, fmt);
+	vfprintf(fp, fmt, args);
+	va_end(args);
+}
 
-static char * vi_type (struct virtual_item * vi)
+static char *vi_type(struct virtual_item *vi)
 {
-    static char *types[]={"directory", "direct", "indirect", "stat data"};
-
-    if (vi->vi_type & VI_TYPE_STAT_DATA)
-	return types[3];
-    if (vi->vi_type & VI_TYPE_INDIRECT)
-	return types[2];
-    if (vi->vi_type & VI_TYPE_DIRECT)
-	return types[1];
-    if (vi->vi_type & VI_TYPE_DIRECTORY)
-	return types[0];
-
-    reiserfs_panic ("vi_type: 6000: unknown type (0x%x)", vi->vi_type);
-    return NULL;
+	static char *types[] =
+	    { "directory", "direct", "indirect", "stat data" };
+
+	if (vi->vi_type & VI_TYPE_STAT_DATA)
+		return types[3];
+	if (vi->vi_type & VI_TYPE_INDIRECT)
+		return types[2];
+	if (vi->vi_type & VI_TYPE_DIRECT)
+		return types[1];
+	if (vi->vi_type & VI_TYPE_DIRECTORY)
+		return types[0];
+
+	reiserfs_panic("vi_type: 6000: unknown type (0x%x)", vi->vi_type);
+	return NULL;
 }
 
-
-void print_virtual_node (struct virtual_node * vn)
+void print_virtual_node(struct virtual_node *vn)
 {
-    int i, j;
-  
-    printf ("VIRTUAL NODE CONTAINS %d items, has size %d,%s,%s, ITEM_POS=%d POS_IN_ITEM=%d MODE=\'%c\'\n",
-	    vn->vn_nr_item, vn->vn_size,
-	    (vn->vn_vi[0].vi_type & VI_TYPE_LEFT_MERGEABLE )? "left mergeable" : "", 
-	    (vn->vn_vi[vn->vn_nr_item - 1].vi_type & VI_TYPE_RIGHT_MERGEABLE) ? "right mergeable" : "",
-	    vn->vn_affected_item_num, vn->vn_pos_in_item, vn->vn_mode);
-
-
-    for (i = 0; i < vn->vn_nr_item; i ++) {
-	printf ("%s %d %d", vi_type (&vn->vn_vi[i]), i, vn->vn_vi[i].vi_item_len);
-	if (vn->vn_vi[i].vi_entry_sizes)
-	{
-	    printf ("It is directory with %d entries: ", vn->vn_vi[i].vi_entry_count);
-	    for (j = 0; j < vn->vn_vi[i].vi_entry_count; j ++)
-		printf ("%d ", vn->vn_vi[i].vi_entry_sizes[j]);
+	int i, j;
+
+	printf
+	    ("VIRTUAL NODE CONTAINS %d items, has size %d,%s,%s, ITEM_POS=%d POS_IN_ITEM=%d MODE=\'%c\'\n",
+	     vn->vn_nr_item, vn->vn_size,
+	     (vn->vn_vi[0].
+	      vi_type & VI_TYPE_LEFT_MERGEABLE) ? "left mergeable" : "",
+	     (vn->vn_vi[vn->vn_nr_item - 1].
+	      vi_type & VI_TYPE_RIGHT_MERGEABLE) ? "right mergeable" : "",
+	     vn->vn_affected_item_num, vn->vn_pos_in_item, vn->vn_mode);
+
+	for (i = 0; i < vn->vn_nr_item; i++) {
+		printf("%s %d %d", vi_type(&vn->vn_vi[i]), i,
+		       vn->vn_vi[i].vi_item_len);
+		if (vn->vn_vi[i].vi_entry_sizes) {
+			printf("It is directory with %d entries: ",
+			       vn->vn_vi[i].vi_entry_count);
+			for (j = 0; j < vn->vn_vi[i].vi_entry_count; j++)
+				printf("%d ", vn->vn_vi[i].vi_entry_sizes[j]);
+		}
+		printf("\n");
 	}
-	printf ("\n");
-    }
 }
 
-
-void print_path (struct tree_balance * tb, struct reiserfs_path *path)
+void print_path(struct tree_balance *tb, struct reiserfs_path *path)
 {
-    int offset = path->path_length;
-    struct buffer_head * bh;
-
-    printf ("Offset    Bh     (b_blocknr, b_count) Position Nr_item\n");
-    while ( offset > ILLEGAL_PATH_ELEMENT_OFFSET ) {
-	bh = PATH_OFFSET_PBUFFER (path, offset);
-	printf ("%6d %10p (%9lu, %7d) %8d %7d\n", offset, 
-		bh, bh ? bh->b_blocknr : 0, bh ? bh->b_count : 0,
-		PATH_OFFSET_POSITION (path, offset), bh ? B_NR_ITEMS (bh) : -1);
-	
-	offset --;
-    }
+	int offset = path->path_length;
+	struct buffer_head *bh;
+
+	printf("Offset    Bh     (b_blocknr, b_count) Position Nr_item\n");
+	while (offset > ILLEGAL_PATH_ELEMENT_OFFSET) {
+		bh = PATH_OFFSET_PBUFFER(path, offset);
+		printf("%6d %10p (%9lu, %7d) %8d %7d\n", offset,
+		       bh, bh ? bh->b_blocknr : 0, bh ? bh->b_count : 0,
+		       PATH_OFFSET_POSITION(path, offset),
+		       bh ? B_NR_ITEMS(bh) : -1);
+
+		offset--;
+	}
 }
 
-
-
-void print_directory_item (FILE * fp, reiserfs_filsys_t * fs,
-			   struct buffer_head * bh, struct item_head * ih)
+void print_directory_item(FILE * fp, reiserfs_filsys_t *fs,
+			  struct buffer_head *bh, struct item_head *ih)
 {
-    int i;
-    int namelen;
-    struct reiserfs_de_head * deh;
-    char * name;
+	int i;
+	int namelen;
+	struct reiserfs_de_head *deh;
+	char *name;
 /*    static char namebuf [80];*/
 
-    if (!I_IS_DIRECTORY_ITEM (ih))
-	return;
-
-    //printk ("\n%2%-25s%-30s%-15s%-15s%-15s\n", "    Name", "length", "Object key", "Hash", "Gen number", "Status");
-    reiserfs_warning (fp, "%3s: %-25s%s%-22s%-12s%s\n", "###", "Name", "length", "    Object key", "   Hash", "Gen number");
-    deh = B_I_DEH (bh, ih);
-    for (i = 0; i < get_ih_entry_count (ih); i ++, deh ++) {
-	if (dir_entry_bad_location (deh, ih, i == 0 ? 1 : 0)) {
-	    reiserfs_warning (fp, "%3d: wrong entry location %u, deh_offset %u\n",
-			      i, get_deh_location (deh), get_deh_offset (deh));
-	    continue;
+	if (!I_IS_DIRECTORY_ITEM(ih))
+		return;
+
+	//printk ("\n%2%-25s%-30s%-15s%-15s%-15s\n", "    Name", "length", "Object key", "Hash", "Gen number", "Status");
+	reiserfs_warning(fp, "%3s: %-25s%s%-22s%-12s%s\n", "###", "Name",
+			 "length", "    Object key", "   Hash", "Gen number");
+	deh = B_I_DEH(bh, ih);
+	for (i = 0; i < get_ih_entry_count(ih); i++, deh++) {
+		if (dir_entry_bad_location(deh, ih, i == 0 ? 1 : 0)) {
+			reiserfs_warning(fp,
+					 "%3d: wrong entry location %u, deh_offset %u\n",
+					 i, get_deh_location(deh),
+					 get_deh_offset(deh));
+			continue;
+		}
+		if (i
+		    && dir_entry_bad_location(deh - 1, ih,
+					      ((i - 1) == 0) ? 1 : 0))
+			/* previous entry has bad location so we can not calculate entry
+			   length */
+			namelen = 25;
+		else
+			namelen = name_in_entry_length(ih, deh, i);
+
+		name = name_in_entry(deh, i);
+		reiserfs_warning(fp,
+				 "%3d: \"%-25.*s\"(%3d)%20K%12d%5d, loc %u, state %x %s\n",
+				 i, namelen, name, namelen,
+				 (struct reiserfs_key *)&(deh->deh2_dir_id),
+				 GET_HASH_VALUE(get_deh_offset(deh)),
+				 GET_GENERATION_NUMBER(get_deh_offset(deh)),
+				 get_deh_location(deh), get_deh_state(deh),
+				 code2name(find_hash_in_use
+					   (name, namelen, get_deh_offset(deh),
+					    fs ? get_sb_hash_code(fs->
+								  fs_ondisk_sb)
+					    : UNSET_HASH)));
+		/*fs ? (is_properly_hashed (fs, name, namelen, deh_offset (deh)) ? "" : "(BROKEN)") : "??"); */
 	}
-	if (i && dir_entry_bad_location (deh - 1, ih, ((i - 1) == 0) ? 1 : 0))
-	    /* previous entry has bad location so we can not calculate entry
-               length */
-	    namelen = 25;
-	else
-	    namelen = name_in_entry_length (ih, deh, i);
-
-	name = name_in_entry (deh, i);
-	reiserfs_warning (fp, "%3d: \"%-25.*s\"(%3d)%20K%12d%5d, loc %u, state %x %s\n", 
-			  i, namelen, name, namelen,
-			  (struct reiserfs_key *)&(deh->deh2_dir_id),
-			  GET_HASH_VALUE (get_deh_offset (deh)),
-			  GET_GENERATION_NUMBER (get_deh_offset (deh)),
-			  get_deh_location (deh), get_deh_state (deh),
-			  code2name (find_hash_in_use (name, namelen, get_deh_offset (deh),
-						       fs ? get_sb_hash_code (fs->fs_ondisk_sb) : UNSET_HASH)));
-	/*fs ? (is_properly_hashed (fs, name, namelen, deh_offset (deh)) ? "" : "(BROKEN)") : "??");*/
-    }
 }
 
-
 //
 // 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 (le32_to_cpu (start) == INT_MAX)
-	return 1;
+	if (le32_to_cpu(start) == INT_MAX)
+		return 1;
 
-    if (start == 0 && new == 0) {
-	(*len) ++;
-	return 0;
-    }
-    if (start != 0 && (le32_to_cpu (start) + *len) == le32_to_cpu (new)) {
-	(*len) ++;
-	return 0;
-    }
-    return 1;
+	if (start == 0 && new == 0) {
+		(*len)++;
+		return 0;
+	}
+	if (start != 0 && (le32_to_cpu(start) + *len) == le32_to_cpu(new)) {
+		(*len)++;
+		return 0;
+	}
+	return 1;
 }
 
-static void print_sequence (FILE * fp, __u32 start, int len)
+static void print_sequence(FILE * fp, __u32 start, int len)
 {
-    if (start == INT_MAX)
-	return;
+	if (start == INT_MAX)
+		return;
 
-    if (len == 1)
-	reiserfs_warning (fp, " %u", le32_to_cpu (start));
-    else
-	reiserfs_warning (fp, " %u(%d)", le32_to_cpu (start), len);
+	if (len == 1)
+		reiserfs_warning(fp, " %u", le32_to_cpu(start));
+	else
+		reiserfs_warning(fp, " %u(%d)", le32_to_cpu(start), len);
 }
 
-
-void print_indirect_item (FILE * fp, struct buffer_head * bh, int item_num)
+void print_indirect_item(FILE * fp, struct buffer_head *bh, int item_num)
 {
-    struct item_head * ih;
-    unsigned int j;
-    __u32 * unp, prev = INT_MAX;
-    int num = 0;
-
-    ih = B_N_PITEM_HEAD (bh, item_num);
-    unp = (__u32 *)B_I_PITEM (bh, ih);
-
-    if (get_ih_item_len (ih) % UNFM_P_SIZE)
-	reiserfs_warning (fp, "print_indirect_item: invalid item len");  
-
-    reiserfs_warning (fp, "%d pointer%s\n[", I_UNFM_NUM (ih),
-                      I_UNFM_NUM (ih) != 1 ? "s" : "" );
-    for (j = 0; j < I_UNFM_NUM (ih); j ++) {
-	if (sequence_finished (prev, &num, d32_get(unp, j))) {
-	    print_sequence (fp, prev, num);
-	    start_new_sequence (&prev, &num, d32_get(unp, j));
+	struct item_head *ih;
+	unsigned int j;
+	__u32 *unp, prev = INT_MAX;
+	int num = 0;
+
+	ih = B_N_PITEM_HEAD(bh, item_num);
+	unp = (__u32 *) B_I_PITEM(bh, ih);
+
+	if (get_ih_item_len(ih) % UNFM_P_SIZE)
+		reiserfs_warning(fp, "print_indirect_item: invalid item len");
+
+	reiserfs_warning(fp, "%d pointer%s\n[", I_UNFM_NUM(ih),
+			 I_UNFM_NUM(ih) != 1 ? "s" : "");
+	for (j = 0; j < I_UNFM_NUM(ih); j++) {
+		if (sequence_finished(prev, &num, d32_get(unp, j))) {
+			print_sequence(fp, prev, num);
+			start_new_sequence(&prev, &num, d32_get(unp, j));
+		}
 	}
-    }
-    print_sequence (fp, prev, num);
-    reiserfs_warning (fp, "]\n");
+	print_sequence(fp, prev, num);
+	reiserfs_warning(fp, "]\n");
 }
 
-
 char timebuf[256];
 
-char * timestamp (time_t t)
+char *timestamp(time_t t)
 {
-    strftime (timebuf, 256, "%d/%Y %T", localtime (&t));
-    return timebuf;
+	strftime(timebuf, 256, "%d/%Y %T", localtime(&t));
+	return timebuf;
 }
 
-static int print_stat_data (FILE * fp, struct buffer_head * bh, struct item_head * ih, int alltimes)
+static int print_stat_data(FILE * fp, struct buffer_head *bh,
+			   struct item_head *ih, int alltimes)
 {
-    int retval;
-    
-
-    /* we cannot figure out if it is new stat data or old by key_format
-       macro. Stat data's key looks identical in both formats */
-    if (get_ih_key_format (ih) == KEY_FORMAT_1) {
-        struct stat_data_v1 * sd_v1 = (struct stat_data_v1 *)B_I_PITEM (bh, ih);
-	reiserfs_warning (fp, "(OLD SD), mode %M, size %u, nlink %u, uid %u, FDB %u, mtime %s blocks %u",
-		sd_v1_mode(sd_v1), sd_v1_size(sd_v1), sd_v1_nlink(sd_v1),
-                sd_v1_uid(sd_v1), sd_v1_first_direct_byte(sd_v1), timestamp
-                (sd_v1_mtime(sd_v1)), sd_v1_blocks(sd_v1));
-	retval = (S_ISLNK (sd_v1_mode(sd_v1))) ? 1 : 0;
-        if (alltimes)
-            reiserfs_warning (fp, "%s %s\n", timestamp (sd_v1_ctime(sd_v1)),
-                timestamp (sd_v1_atime(sd_v1)));
-    } else {
-        struct stat_data * sd = (struct stat_data *)B_I_PITEM (bh, ih);
-	reiserfs_warning (fp, "(NEW SD), mode %M, size %Lu, nlink %u, mtime %s blocks %u, uid %u",
-		sd_v2_mode(sd), sd_v2_size(sd), sd_v2_nlink(sd),
-		timestamp (sd_v2_mtime(sd)), sd_v2_blocks(sd), sd_v2_uid(sd));
-	retval = (S_ISLNK (sd_v2_mode(sd))) ? 1 : 0;
-        if (alltimes)
-            reiserfs_warning (fp, "%s %s\n", timestamp (sd_v2_ctime(sd)),
-                timestamp (sd_v2_atime(sd)));
-    }
-
-    reiserfs_warning (fp, "\n");
-    return retval;
-}
+	int retval;
+
+	/* we cannot figure out if it is new stat data or old by key_format
+	   macro. Stat data's key looks identical in both formats */
+	if (get_ih_key_format(ih) == KEY_FORMAT_1) {
+		struct stat_data_v1 *sd_v1 =
+		    (struct stat_data_v1 *)B_I_PITEM(bh, ih);
+		reiserfs_warning(fp,
+				 "(OLD SD), mode %M, size %u, nlink %u, uid %u, FDB %u, mtime %s blocks %u",
+				 sd_v1_mode(sd_v1), sd_v1_size(sd_v1),
+				 sd_v1_nlink(sd_v1), sd_v1_uid(sd_v1),
+				 sd_v1_first_direct_byte(sd_v1),
+				 timestamp(sd_v1_mtime(sd_v1)),
+				 sd_v1_blocks(sd_v1));
+		retval = (S_ISLNK(sd_v1_mode(sd_v1))) ? 1 : 0;
+		if (alltimes)
+			reiserfs_warning(fp, "%s %s\n",
+					 timestamp(sd_v1_ctime(sd_v1)),
+					 timestamp(sd_v1_atime(sd_v1)));
+	} else {
+		struct stat_data *sd = (struct stat_data *)B_I_PITEM(bh, ih);
+		reiserfs_warning(fp,
+				 "(NEW SD), mode %M, size %Lu, nlink %u, mtime %s blocks %u, uid %u",
+				 sd_v2_mode(sd), sd_v2_size(sd),
+				 sd_v2_nlink(sd), timestamp(sd_v2_mtime(sd)),
+				 sd_v2_blocks(sd), sd_v2_uid(sd));
+		retval = (S_ISLNK(sd_v2_mode(sd))) ? 1 : 0;
+		if (alltimes)
+			reiserfs_warning(fp, "%s %s\n",
+					 timestamp(sd_v2_ctime(sd)),
+					 timestamp(sd_v2_atime(sd)));
+	}
 
+	reiserfs_warning(fp, "\n");
+	return retval;
+}
 
 /* used by debugreiserfs/scan.c */
-void reiserfs_print_item (FILE * fp, struct buffer_head * bh,
-			  struct item_head * ih)
+void reiserfs_print_item(FILE * fp, struct buffer_head *bh,
+			 struct item_head *ih)
 {
-    reiserfs_warning (fp, "block %lu, item %d: %H\n",
-	bh->b_blocknr, (ih - B_N_PITEM_HEAD (bh, 0))/sizeof(struct item_head), ih);
-    if (is_stat_data_ih (ih)) {
-	print_stat_data (fp, bh, ih, 0/*all times*/);
-	return;
-    }
-    if (is_indirect_ih (ih)) {
-	print_indirect_item (fp, bh, ih - B_N_PITEM_HEAD (bh, 0));
-	return;
-    }
-    if (is_direct_ih (ih)) {
-	reiserfs_warning (fp, "direct item: block %lu, start %d, %d bytes\n",
-			  bh->b_blocknr, get_ih_location (ih), get_ih_item_len (ih));
-	return;
-    }
-
-    print_directory_item (fp, 0, bh, ih);    
-}
+	reiserfs_warning(fp, "block %lu, item %d: %H\n",
+			 bh->b_blocknr,
+			 (ih -
+			  B_N_PITEM_HEAD(bh, 0)) / sizeof(struct item_head),
+			 ih);
+	if (is_stat_data_ih(ih)) {
+		print_stat_data(fp, bh, ih, 0 /*all times */ );
+		return;
+	}
+	if (is_indirect_ih(ih)) {
+		print_indirect_item(fp, bh, ih - B_N_PITEM_HEAD(bh, 0));
+		return;
+	}
+	if (is_direct_ih(ih)) {
+		reiserfs_warning(fp,
+				 "direct item: block %lu, start %d, %d bytes\n",
+				 bh->b_blocknr, get_ih_location(ih),
+				 get_ih_item_len(ih));
+		return;
+	}
 
+	print_directory_item(fp, 0, bh, ih);
+}
 
 /* this prints internal nodes (4 keys/items in line) (dc_number,
    dc_size)[k_dirid, k_objectid, k_offset, k_uniqueness](dc_number,
    dc_size)...*/
-static int print_internal (FILE * fp, struct buffer_head * bh, int first, int last)
+static int print_internal(FILE * fp, struct buffer_head *bh, int first,
+			  int last)
 {
-    struct reiserfs_key *key;
-    struct disk_child * dc;
-    int i;
-    int from, to;
+	struct reiserfs_key *key;
+	struct disk_child *dc;
+	int i;
+	int from, to;
 
-    if (!is_internal_node (bh))
-	return 1;
+	if (!is_internal_node(bh))
+		return 1;
 
-    if (first == -1) {
-	from = 0;
-	to = B_NR_ITEMS (bh);
-    } else {
-	from = first;
-	to = last < B_NR_ITEMS (bh) ? last : B_NR_ITEMS (bh);
-    }
-
-    reiserfs_warning (fp, "INTERNAL NODE (%lu) contains %b\n",  bh->b_blocknr, bh);
-
-    dc = B_N_CHILD (bh, from);
-    reiserfs_warning (fp, "PTR %d: %y ", from, dc);
-
-    for (i = from, key = B_N_PDELIM_KEY (bh, from), dc ++; i < to; i ++, key ++, dc ++) {
-	reiserfs_warning (fp, "KEY %d: %20k PTR %d: %20y ", i, key, i + 1, dc);
-	if (i && i % 4 == 0)
-	    reiserfs_warning (fp, "\n");
-    }
-    reiserfs_warning (fp, "\n");
-    return 0;
-}
+	if (first == -1) {
+		from = 0;
+		to = B_NR_ITEMS(bh);
+	} else {
+		from = first;
+		to = last < B_NR_ITEMS(bh) ? last : B_NR_ITEMS(bh);
+	}
 
+	reiserfs_warning(fp, "INTERNAL NODE (%lu) contains %b\n", bh->b_blocknr,
+			 bh);
 
+	dc = B_N_CHILD(bh, from);
+	reiserfs_warning(fp, "PTR %d: %y ", from, dc);
+
+	for (i = from, key = B_N_PDELIM_KEY(bh, from), dc++; i < to;
+	     i++, key++, dc++) {
+		reiserfs_warning(fp, "KEY %d: %20k PTR %d: %20y ", i, key,
+				 i + 1, dc);
+		if (i && i % 4 == 0)
+			reiserfs_warning(fp, "\n");
+	}
+	reiserfs_warning(fp, "\n");
+	return 0;
+}
 
 static int is_symlink = 0;
-static int print_leaf (FILE * fp, reiserfs_filsys_t * fs, struct buffer_head * bh,
-		       int print_mode, int first, int last)
+static int print_leaf(FILE * fp, reiserfs_filsys_t *fs, struct buffer_head *bh,
+		      int print_mode, int first, int last)
 {
-    struct item_head * ih;
-    int i;
-    int from, to;
-    int real_nr, nr;
-
-    if (!is_tree_node (bh, DISK_LEAF_NODE_LEVEL))
-	return 1;
-    
-    ih = B_N_PITEM_HEAD (bh,0);
-    real_nr = leaf_count_ih(bh->b_data, bh->b_size);
-    nr = get_blkh_nr_items((struct block_head *)bh->b_data);
-
-    reiserfs_warning (fp,
-		      "\n===================================================================\n");
-    reiserfs_warning (fp, "LEAF NODE (%lu) contains %b (real items %d)\n",
-		      bh->b_blocknr, bh, real_nr);
-
-    if (!(print_mode & PRINT_TREE_DETAILS)) {
-	reiserfs_warning (fp, "FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
-			   &(ih->ih_key), &((ih + real_nr - 1)->ih_key));
-	return 0;
-    }
-
-    if (first < 0 || first > real_nr - 1) 
-	from = 0;
-    else 
-	from = first;
-
-    if (last < 0 || last > real_nr)
-	to = real_nr;
-    else
-	to = last;
-
-
-    reiserfs_warning (fp,
-		       "-------------------------------------------------------------------------------\n"
-		       "|###|type|ilen|f/sp| loc|fmt|fsck|                   key                      |\n"
-		       "|   |    |    |e/cn|    |   |need|                                            |\n");
-    for (i = from; i < to; i++) {
-	reiserfs_warning (fp,
-			  "-------------------------------------------------------------------------------\n"
-			  "|%3d|%30H|%s\n", i, ih + i, i >= nr ? " DELETED" : "");
-
-	if (I_IS_STAT_DATA_ITEM(ih+i)) {
-	    is_symlink = print_stat_data (fp, bh, ih + i, 0/*all times*/);
-	    continue;
+	struct item_head *ih;
+	int i;
+	int from, to;
+	int real_nr, nr;
+
+	if (!is_tree_node(bh, DISK_LEAF_NODE_LEVEL))
+		return 1;
+
+	ih = B_N_PITEM_HEAD(bh, 0);
+	real_nr = leaf_count_ih(bh->b_data, bh->b_size);
+	nr = get_blkh_nr_items((struct block_head *)bh->b_data);
+
+	reiserfs_warning(fp,
+			 "\n===================================================================\n");
+	reiserfs_warning(fp, "LEAF NODE (%lu) contains %b (real items %d)\n",
+			 bh->b_blocknr, bh, real_nr);
+
+	if (!(print_mode & PRINT_TREE_DETAILS)) {
+		reiserfs_warning(fp, "FIRST ITEM_KEY: %k, LAST ITEM KEY: %k\n",
+				 &(ih->ih_key), &((ih + real_nr - 1)->ih_key));
+		return 0;
 	}
 
-	if (I_IS_DIRECTORY_ITEM(ih+i)) {
-	    print_directory_item (fp, fs, bh, ih+i);
-	    continue;
-	}
+	if (first < 0 || first > real_nr - 1)
+		from = 0;
+	else
+		from = first;
 
-	if (I_IS_INDIRECT_ITEM(ih+i)) {
-	    print_indirect_item (fp, bh, i);
-	    continue;
-	}
+	if (last < 0 || last > real_nr)
+		to = real_nr;
+	else
+		to = last;
+
+	reiserfs_warning(fp,
+			 "-------------------------------------------------------------------------------\n"
+			 "|###|type|ilen|f/sp| loc|fmt|fsck|                   key                      |\n"
+			 "|   |    |    |e/cn|    |   |need|                                            |\n");
+	for (i = from; i < to; i++) {
+		reiserfs_warning(fp,
+				 "-------------------------------------------------------------------------------\n"
+				 "|%3d|%30H|%s\n", i, ih + i,
+				 i >= nr ? " DELETED" : "");
+
+		if (I_IS_STAT_DATA_ITEM(ih + i)) {
+			is_symlink =
+			    print_stat_data(fp, bh, ih + i, 0 /*all times */ );
+			continue;
+		}
+
+		if (I_IS_DIRECTORY_ITEM(ih + i)) {
+			print_directory_item(fp, fs, bh, ih + i);
+			continue;
+		}
 
-	if (I_IS_DIRECT_ITEM(ih+i)) {
-	    int j = 0;
-	    if (is_symlink || print_mode & PRINT_DIRECT_ITEMS) {
-		reiserfs_warning (fp, "\"");
-		while (j < get_ih_item_len (&ih[i])) {
-		    if (B_I_PITEM(bh,ih+i)[j] == 10)
-			reiserfs_warning (fp, "\\n");
-		    else
-			reiserfs_warning (fp, "%c", B_I_PITEM(bh,ih+i)[j]);
-		    j ++;
+		if (I_IS_INDIRECT_ITEM(ih + i)) {
+			print_indirect_item(fp, bh, i);
+			continue;
+		}
+
+		if (I_IS_DIRECT_ITEM(ih + i)) {
+			int j = 0;
+			if (is_symlink || print_mode & PRINT_DIRECT_ITEMS) {
+				reiserfs_warning(fp, "\"");
+				while (j < get_ih_item_len(&ih[i])) {
+					if (B_I_PITEM(bh, ih + i)[j] == 10)
+						reiserfs_warning(fp, "\\n");
+					else
+						reiserfs_warning(fp, "%c",
+								 B_I_PITEM(bh,
+									   ih +
+									   i)
+								 [j]);
+					j++;
+				}
+				reiserfs_warning(fp, "\"\n");
+			}
+			continue;
 		}
-		reiserfs_warning (fp, "\"\n");
-	    }
-	    continue;
 	}
-    }
-    reiserfs_warning (fp, "===================================================================\n");
-    return 0;
+	reiserfs_warning(fp,
+			 "===================================================================\n");
+	return 0;
 }
 
-
-void print_journal_params (FILE * fp, struct journal_params * jp)
+void print_journal_params(FILE * fp, struct journal_params *jp)
 {
-    reiserfs_warning (fp, "\tDevice [0x%x]\n", get_jp_journal_dev (jp));
-    reiserfs_warning (fp, "\tMagic [0x%x]\n", get_jp_journal_magic (jp));
-
-    reiserfs_warning (fp, "\tSize %u blocks (including 1 for journal header) (first block %u)\n",
-		      get_jp_journal_size (jp) + 1,
-		      get_jp_journal_1st_block (jp));
-    reiserfs_warning (fp, "\tMax transaction length %u blocks\n", get_jp_journal_max_trans_len (jp));
-    reiserfs_warning (fp, "\tMax batch size %u blocks\n", get_jp_journal_max_batch (jp));
-    reiserfs_warning (fp, "\tMax commit age %u\n", get_jp_journal_max_commit_age (jp));
-    /*reiserfs_warning (fp, "\tMax transaction age %u\n", get_jp_journal_max_trans_age (jp));*/
+	reiserfs_warning(fp, "\tDevice [0x%x]\n", get_jp_journal_dev(jp));
+	reiserfs_warning(fp, "\tMagic [0x%x]\n", get_jp_journal_magic(jp));
+
+	reiserfs_warning(fp,
+			 "\tSize %u blocks (including 1 for journal header) (first block %u)\n",
+			 get_jp_journal_size(jp) + 1,
+			 get_jp_journal_1st_block(jp));
+	reiserfs_warning(fp, "\tMax transaction length %u blocks\n",
+			 get_jp_journal_max_trans_len(jp));
+	reiserfs_warning(fp, "\tMax batch size %u blocks\n",
+			 get_jp_journal_max_batch(jp));
+	reiserfs_warning(fp, "\tMax commit age %u\n",
+			 get_jp_journal_max_commit_age(jp));
+	/*reiserfs_warning (fp, "\tMax transaction age %u\n", get_jp_journal_max_trans_age (jp)); */
 }
 
 /* return 1 if this is not super block */
-int print_super_block (FILE * fp, reiserfs_filsys_t * fs, char * file_name,
-			      struct buffer_head * bh, int short_print)
+int print_super_block(FILE * fp, reiserfs_filsys_t *fs, char *file_name,
+		      struct buffer_head *bh, int short_print)
 {
-    struct reiserfs_super_block * sb = (struct reiserfs_super_block *)(bh->b_data);
-    dev_t rdev;
-    int format = 0;
-    __u16 state;
-    time_t last_check = get_sb_v2_lastcheck(sb);
-    char last_check_buf[26];
-
-    if (!does_look_like_super_block (sb))
-	return 1;
-
-    rdev = misc_device_rdev(file_name);
-
-    reiserfs_warning (fp, "Reiserfs super block in block %lu on 0x%x of ",
-		      bh->b_blocknr, rdev);
-    switch (get_reiserfs_format (sb)) {
-    case REISERFS_FORMAT_3_5:
-	reiserfs_warning (fp, "format 3.5 with ");
-        format = 1;
-	break;
-    case REISERFS_FORMAT_3_6:
-	reiserfs_warning (fp, "format 3.6 with ");
-        format = 2;
-	break;
-    default:
-	reiserfs_warning (fp, "unknown format with ");
-	break;
-    }
-    if (is_reiserfs_jr_magic_string (sb))
-	reiserfs_warning (fp, "non-");
-    reiserfs_warning (fp, "standard journal\n");
-    if (short_print) {
-	reiserfs_warning (fp, "Blocks (total/free): %u/%u by %d bytes\n",
-		get_sb_block_count (sb), get_sb_free_blocks (sb), get_sb_block_size (sb));
-    } else {
-	reiserfs_warning (fp, "Count of blocks on the device: %u\n", get_sb_block_count (sb));
-	reiserfs_warning (fp, "Number of bitmaps: %u", get_sb_bmap_nr (sb));
-	if (get_sb_bmap_nr (sb) != reiserfs_fs_bmap_nr(fs))
-		reiserfs_warning (fp, " (really uses %u)", reiserfs_fs_bmap_nr(fs));
-	reiserfs_warning (fp, "\nBlocksize: %d\n", get_sb_block_size (sb));
-	reiserfs_warning (fp, "Free blocks (count of blocks - used [journal, "
-		      "bitmaps, data, reserved] blocks): %u\n", get_sb_free_blocks (sb));
-	reiserfs_warning (fp, "Root block: %u\n", get_sb_root_block (sb));
-    }
-    reiserfs_warning (fp, "Filesystem is %sclean\n",
-		      (get_sb_umount_state (sb) == FS_CLEANLY_UMOUNTED) ? "" : "NOT ");
-
-    if (short_print)
-    	return 0;
-    reiserfs_warning (fp, "Tree height: %d\n", get_sb_tree_height (sb));
-    reiserfs_warning (fp, "Hash function used to sort names: %s\n",
-		      code2name (get_sb_hash_code (sb)));
-    reiserfs_warning (fp, "Objectid map size %d, max %d\n", get_sb_oid_cursize (sb),
-		      get_sb_oid_maxsize (sb));
-    reiserfs_warning (fp, "Journal parameters:\n");
-    print_journal_params (fp, sb_jp (sb));
-    reiserfs_warning (fp, "Blocks reserved by journal: %u\n",
-		      get_sb_reserved_for_journal (sb));
-    state = get_sb_fs_state (sb);
-    reiserfs_warning (fp, "Fs state field: 0x%x:\n", state);
-    if ((state & FS_FATAL) == FS_FATAL)
-	reiserfs_warning (fp, "\tFATAL corruptions exist.\n");
-    if ((state & FS_ERROR) == FS_ERROR)
-	reiserfs_warning (fp, "\t some corruptions exist.\n");
-    if ((state & IO_ERROR) == IO_ERROR)
-	reiserfs_warning (fp, "\tI/O corruptions exist.\n");
-
-    reiserfs_warning (fp, "sb_version: %u\n", get_sb_version (sb));
-    if (format == 2) {
-        reiserfs_warning (fp, "inode generation number: %u\n", get_sb_v2_inode_generation (sb));
-        reiserfs_warning (fp, "UUID: %U\n", sb->s_uuid);
-        reiserfs_warning (fp, "LABEL: %.16s\n", sb->s_label);
-        reiserfs_warning (fp, "Set flags in SB:\n");
-	if ((get_sb_v2_flag (sb, reiserfs_attrs_cleared)))
-	    reiserfs_warning (fp, "\tATTRIBUTES CLEAN\n");
-	reiserfs_warning(fp, "Mount count: %u\n",
-			 get_sb_v2_mnt_count(sb));
-	reiserfs_warning(fp, "Maximum mount count: ");
-	if (get_sb_v2_max_mnt_count(sb) &&
-	    get_sb_v2_max_mnt_count(sb) != USHRT_MAX)
-		reiserfs_warning(fp, "%u\n", get_sb_v2_max_mnt_count(sb));
-	else if (get_sb_v2_max_mnt_count(sb) == USHRT_MAX)
-		reiserfs_warning(fp, "Administratively disabled.\n");
-	else
-		reiserfs_warning(fp, "Disabled. Run fsck.reiserfs(8) or use tunefs.reiserfs(8) to enable.\n");
-	if (last_check) {
-		ctime_r(&last_check, last_check_buf);
-		reiserfs_warning(fp, "Last fsck run: %s", last_check_buf);
-	} else
-		reiserfs_warning(fp, "Last fsck run: Never with a version "
-				 "that supports this feature.\n");
-	reiserfs_warning(fp, "Check interval in days: ");
-	if (get_sb_v2_check_interval(sb) &&
-	    get_sb_v2_check_interval(sb) != UINT_MAX)
-		reiserfs_warning(fp, "%u\n",
-			 get_sb_v2_check_interval(sb) / (24*60*60));
-	else if (get_sb_v2_check_interval(sb) == UINT_MAX)
-		reiserfs_warning(fp, "Administratively disabled.\n");
-	else
-		reiserfs_warning(fp, "Disabled. Run fsck.reiserfs(8) or use tunefs.reiserfs(8) to enable.\n");
-    }
+	struct reiserfs_super_block *sb =
+	    (struct reiserfs_super_block *)(bh->b_data);
+	dev_t rdev;
+	int format = 0;
+	__u16 state;
+	time_t last_check = get_sb_v2_lastcheck(sb);
+	char last_check_buf[26];
+
+	if (!does_look_like_super_block(sb))
+		return 1;
+
+	rdev = misc_device_rdev(file_name);
+
+	reiserfs_warning(fp, "Reiserfs super block in block %lu on 0x%x of ",
+			 bh->b_blocknr, rdev);
+	switch (get_reiserfs_format(sb)) {
+	case REISERFS_FORMAT_3_5:
+		reiserfs_warning(fp, "format 3.5 with ");
+		format = 1;
+		break;
+	case REISERFS_FORMAT_3_6:
+		reiserfs_warning(fp, "format 3.6 with ");
+		format = 2;
+		break;
+	default:
+		reiserfs_warning(fp, "unknown format with ");
+		break;
+	}
+	if (is_reiserfs_jr_magic_string(sb))
+		reiserfs_warning(fp, "non-");
+	reiserfs_warning(fp, "standard journal\n");
+	if (short_print) {
+		reiserfs_warning(fp, "Blocks (total/free): %u/%u by %d bytes\n",
+				 get_sb_block_count(sb), get_sb_free_blocks(sb),
+				 get_sb_block_size(sb));
+	} else {
+		reiserfs_warning(fp, "Count of blocks on the device: %u\n",
+				 get_sb_block_count(sb));
+		reiserfs_warning(fp, "Number of bitmaps: %u",
+				 get_sb_bmap_nr(sb));
+		if (get_sb_bmap_nr(sb) != reiserfs_fs_bmap_nr(fs))
+			reiserfs_warning(fp, " (really uses %u)",
+					 reiserfs_fs_bmap_nr(fs));
+		reiserfs_warning(fp, "\nBlocksize: %d\n",
+				 get_sb_block_size(sb));
+		reiserfs_warning(fp,
+				 "Free blocks (count of blocks - used [journal, "
+				 "bitmaps, data, reserved] blocks): %u\n",
+				 get_sb_free_blocks(sb));
+		reiserfs_warning(fp, "Root block: %u\n", get_sb_root_block(sb));
+	}
+	reiserfs_warning(fp, "Filesystem is %sclean\n",
+			 (get_sb_umount_state(sb) ==
+			  FS_CLEANLY_UMOUNTED) ? "" : "NOT ");
+
+	if (short_print)
+		return 0;
+	reiserfs_warning(fp, "Tree height: %d\n", get_sb_tree_height(sb));
+	reiserfs_warning(fp, "Hash function used to sort names: %s\n",
+			 code2name(get_sb_hash_code(sb)));
+	reiserfs_warning(fp, "Objectid map size %d, max %d\n",
+			 get_sb_oid_cursize(sb), get_sb_oid_maxsize(sb));
+	reiserfs_warning(fp, "Journal parameters:\n");
+	print_journal_params(fp, sb_jp(sb));
+	reiserfs_warning(fp, "Blocks reserved by journal: %u\n",
+			 get_sb_reserved_for_journal(sb));
+	state = get_sb_fs_state(sb);
+	reiserfs_warning(fp, "Fs state field: 0x%x:\n", state);
+	if ((state & FS_FATAL) == FS_FATAL)
+		reiserfs_warning(fp, "\tFATAL corruptions exist.\n");
+	if ((state & FS_ERROR) == FS_ERROR)
+		reiserfs_warning(fp, "\t some corruptions exist.\n");
+	if ((state & IO_ERROR) == IO_ERROR)
+		reiserfs_warning(fp, "\tI/O corruptions exist.\n");
+
+	reiserfs_warning(fp, "sb_version: %u\n", get_sb_version(sb));
+	if (format == 2) {
+		reiserfs_warning(fp, "inode generation number: %u\n",
+				 get_sb_v2_inode_generation(sb));
+		reiserfs_warning(fp, "UUID: %U\n", sb->s_uuid);
+		reiserfs_warning(fp, "LABEL: %.16s\n", sb->s_label);
+		reiserfs_warning(fp, "Set flags in SB:\n");
+		if ((get_sb_v2_flag(sb, reiserfs_attrs_cleared)))
+			reiserfs_warning(fp, "\tATTRIBUTES CLEAN\n");
+		reiserfs_warning(fp, "Mount count: %u\n",
+				 get_sb_v2_mnt_count(sb));
+		reiserfs_warning(fp, "Maximum mount count: ");
+		if (get_sb_v2_max_mnt_count(sb) &&
+		    get_sb_v2_max_mnt_count(sb) != USHRT_MAX)
+			reiserfs_warning(fp, "%u\n",
+					 get_sb_v2_max_mnt_count(sb));
+		else if (get_sb_v2_max_mnt_count(sb) == USHRT_MAX)
+			reiserfs_warning(fp, "Administratively disabled.\n");
+		else
+			reiserfs_warning(fp,
+					 "Disabled. Run fsck.reiserfs(8) or use tunefs.reiserfs(8) to enable.\n");
+		if (last_check) {
+			ctime_r(&last_check, last_check_buf);
+			reiserfs_warning(fp, "Last fsck run: %s",
+					 last_check_buf);
+		} else
+			reiserfs_warning(fp,
+					 "Last fsck run: Never with a version "
+					 "that supports this feature.\n");
+		reiserfs_warning(fp, "Check interval in days: ");
+		if (get_sb_v2_check_interval(sb) &&
+		    get_sb_v2_check_interval(sb) != UINT_MAX)
+			reiserfs_warning(fp, "%u\n",
+					 get_sb_v2_check_interval(sb) / (24 *
+									 60 *
+									 60));
+		else if (get_sb_v2_check_interval(sb) == UINT_MAX)
+			reiserfs_warning(fp, "Administratively disabled.\n");
+		else
+			reiserfs_warning(fp,
+					 "Disabled. Run fsck.reiserfs(8) or use tunefs.reiserfs(8) to enable.\n");
+	}
 
-    return 0;
+	return 0;
 }
 
-
-void print_filesystem_state (FILE * fp, reiserfs_filsys_t * fs)
+void print_filesystem_state(FILE * fp, reiserfs_filsys_t *fs)
 {
-    reiserfs_warning (fp, "\nFilesystem state: ");
-    if (reiserfs_is_fs_consistent (fs))
-	reiserfs_warning (fp, "consistent\n\n");
-    else
-	reiserfs_warning (fp, "consistency is not checked after last mounting\n\n");
+	reiserfs_warning(fp, "\nFilesystem state: ");
+	if (reiserfs_is_fs_consistent(fs))
+		reiserfs_warning(fp, "consistent\n\n");
+	else
+		reiserfs_warning(fp,
+				 "consistency is not checked after last mounting\n\n");
 }
 
-
-
-static int print_desc_block (FILE * fp, struct buffer_head * bh)
+static int print_desc_block(FILE * fp, struct buffer_head *bh)
 {
-    if (memcmp(get_jd_magic (bh), JOURNAL_DESC_MAGIC, 8))
-	return 1;
+	if (memcmp(get_jd_magic(bh), JOURNAL_DESC_MAGIC, 8))
+		return 1;
 
-    reiserfs_warning (fp, "Desc block %lu (j_trans_id %ld, j_mount_id %ld, j_len %ld)\n",
-		      bh->b_blocknr, get_desc_trans_id (bh),
-		      get_desc_mount_id (bh), get_desc_trans_len (bh));
+	reiserfs_warning(fp,
+			 "Desc block %lu (j_trans_id %ld, j_mount_id %ld, j_len %ld)\n",
+			 bh->b_blocknr, get_desc_trans_id(bh),
+			 get_desc_mount_id(bh), get_desc_trans_len(bh));
 
-    return 0;
+	return 0;
 }
 
-
-void print_block (FILE * fp, reiserfs_filsys_t * fs, 
-		  struct buffer_head * bh, ...)//int print_mode, int first, int last)
+void print_block(FILE * fp, reiserfs_filsys_t *fs, struct buffer_head *bh, ...)	//int print_mode, int first, int last)
 {
-    va_list args;
-    int mode, first, last;
-    char * file_name;
-
-    va_start (args, bh);
-
-    if ( ! bh ) {
-	reiserfs_warning (stderr, "print_block: buffer is NULL\n");
-	return;
-    }
-
-    mode = va_arg (args, int);
-    first = va_arg (args, int);
-    last = va_arg (args, int);
-    file_name = (fs) ? fs->fs_file_name : NULL ;
-    if (print_desc_block (fp, bh))
-        if (print_super_block (fp, fs, file_name, bh, 0))
-	    if (print_leaf (fp, fs, bh, mode, first, last))
-		if (print_internal (fp, bh, first, last))
-		    reiserfs_warning (fp, "Block %lu contains unformatted data\n", bh->b_blocknr);
-}
+	va_list args;
+	int mode, first, last;
+	char *file_name;
 
+	va_start(args, bh);
 
-void print_tb (int mode, int item_pos, int pos_in_item, struct tree_balance * tb, char * mes)
-{
-  unsigned int h = 0;
-  struct buffer_head * tbSh, * tbFh;
+	if (!bh) {
+		reiserfs_warning(stderr, "print_block: buffer is NULL\n");
+		return;
+	}
+
+	mode = va_arg(args, int);
+	first = va_arg(args, int);
+	last = va_arg(args, int);
+	file_name = (fs) ? fs->fs_file_name : NULL;
+	if (print_desc_block(fp, bh))
+		if (print_super_block(fp, fs, file_name, bh, 0))
+			if (print_leaf(fp, fs, bh, mode, first, last))
+				if (print_internal(fp, bh, first, last))
+					reiserfs_warning(fp,
+							 "Block %lu contains unformatted data\n",
+							 bh->b_blocknr);
+}
 
+void print_tb(int mode, int item_pos, int pos_in_item, struct tree_balance *tb,
+	      char *mes)
+{
+	unsigned int h = 0;
+	struct buffer_head *tbSh, *tbFh;
 
-  if (!tb)
-    return;
+	if (!tb)
+		return;
 
-  printf ("\n********************** PRINT_TB for %s *******************\n", mes);
-  printf ("MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n", mode, item_pos, pos_in_item);
-  printf ("*********************************************************************\n");
+	printf("\n********************** PRINT_TB for %s *******************\n",
+	       mes);
+	printf("MODE=%c, ITEM_POS=%d POS_IN_ITEM=%d\n", mode, item_pos,
+	       pos_in_item);
+	printf
+	    ("*********************************************************************\n");
 
-  printf ("* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n");
+	printf
+	    ("* h *    S    *    L    *    R    *   F   *   FL  *   FR  *  CFL  *  CFR  *\n");
 /*
 01234567890123456789012345678901234567890123456789012345678901234567890123456789
        1        2         3         4         5         6         7         8
   printk ("*********************************************************************\n");
 */
-  
-  
-  for (h = 0; h < sizeof(tb->insert_size) / sizeof (tb->insert_size[0]); h ++) {
-    if (PATH_H_PATH_OFFSET (tb->tb_path, h) <= tb->tb_path->path_length && 
-	PATH_H_PATH_OFFSET (tb->tb_path, h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
-      tbSh = PATH_H_PBUFFER (tb->tb_path, h);
-      tbFh = PATH_H_PPARENT (tb->tb_path, h);
-    } else {
-      /*      printk ("print_tb: h=%d, PATH_H_PATH_OFFSET=%d, path_length=%d\n", 
-	      h, PATH_H_PATH_OFFSET (tb->tb_path, h), tb->tb_path->path_length);*/
-      tbSh = 0;
-      tbFh = 0;
-    }
-    printf ("* %u * %3lu(%2lu) * %3lu(%2lu) * %3lu(%2lu) * %5lu * %5lu * %5lu * %5lu * %5lu *\n",
-	    h, 
-	    tbSh ? tbSh->b_blocknr : ~0ul,
-	    tbSh ? tbSh->b_count : ~0ul,
-	    tb->L[h] ? tb->L[h]->b_blocknr : ~0ul,
-	    tb->L[h] ? tb->L[h]->b_count : ~0ul,
-	    tb->R[h] ? tb->R[h]->b_blocknr : ~0ul,
-	    tb->R[h] ? tb->R[h]->b_count : ~0ul,
-	    tbFh ? tbFh->b_blocknr : ~0ul,
-	    tb->FL[h] ? tb->FL[h]->b_blocknr : ~0ul,
-	    tb->FR[h] ? tb->FR[h]->b_blocknr : ~0ul,
-	    tb->CFL[h] ? tb->CFL[h]->b_blocknr : ~0ul,
-	    tb->CFR[h] ? tb->CFR[h]->b_blocknr : ~0ul);
-  }
-
-  printf ("*********************************************************************\n");
-
-
-  /* print balance parameters for leaf level */
-  h = 0;
-  printf ("* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n");
-  printf ("* %d * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
-	  h, tb->insert_size[h], tb->lnum[h], tb->lbytes, tb->rnum[h],tb->rbytes, tb->blknum[h], 
-	  tb->s0num, tb->s1num,tb->s1bytes,  tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[h], tb->rkey[h]);
-
-
-/* this prints balance parameters for non-leaf levels */
-  do {
-    h++;
-    printf ("* %d * %4d * %2d *    * %2d *    * %2d *\n",
-    h, tb->insert_size[h], tb->lnum[h], tb->rnum[h], tb->blknum[h]);
-  } while (tb->insert_size[h]);
 
-  printf ("*********************************************************************\n");
+	for (h = 0; h < sizeof(tb->insert_size) / sizeof(tb->insert_size[0]);
+	     h++) {
+		if (PATH_H_PATH_OFFSET(tb->tb_path, h) <=
+		    tb->tb_path->path_length
+		    && PATH_H_PATH_OFFSET(tb->tb_path,
+					  h) > ILLEGAL_PATH_ELEMENT_OFFSET) {
+			tbSh = PATH_H_PBUFFER(tb->tb_path, h);
+			tbFh = PATH_H_PPARENT(tb->tb_path, h);
+		} else {
+			/*      printk ("print_tb: h=%d, PATH_H_PATH_OFFSET=%d, path_length=%d\n", 
+			   h, PATH_H_PATH_OFFSET (tb->tb_path, h), tb->tb_path->path_length); */
+			tbSh = 0;
+			tbFh = 0;
+		}
+		printf
+		    ("* %u * %3lu(%2lu) * %3lu(%2lu) * %3lu(%2lu) * %5lu * %5lu * %5lu * %5lu * %5lu *\n",
+		     h, tbSh ? tbSh->b_blocknr : ~0ul,
+		     tbSh ? tbSh->b_count : ~0ul,
+		     tb->L[h] ? tb->L[h]->b_blocknr : ~0ul,
+		     tb->L[h] ? tb->L[h]->b_count : ~0ul,
+		     tb->R[h] ? tb->R[h]->b_blocknr : ~0ul,
+		     tb->R[h] ? tb->R[h]->b_count : ~0ul,
+		     tbFh ? tbFh->b_blocknr : ~0ul,
+		     tb->FL[h] ? tb->FL[h]->b_blocknr : ~0ul,
+		     tb->FR[h] ? tb->FR[h]->b_blocknr : ~0ul,
+		     tb->CFL[h] ? tb->CFL[h]->b_blocknr : ~0ul,
+		     tb->CFR[h] ? tb->CFR[h]->b_blocknr : ~0ul);
+	}
 
+	printf
+	    ("*********************************************************************\n");
 
-  /* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
-  for (h = 0; h < sizeof (tb->FEB) / sizeof (tb->FEB[0]); h++)
-    printf("%s%p (%lu %d)", h == 0 ? "FEB list: " : ", ", tb->FEB[h], tb->FEB[h] ? tb->FEB[h]->b_blocknr : 0,
-	    tb->FEB[h] ? tb->FEB[h]->b_count : 0);
-  printf ("\n");
+	/* print balance parameters for leaf level */
+	h = 0;
+	printf
+	    ("* h * size * ln * lb * rn * rb * blkn * s0 * s1 * s1b * s2 * s2b * curb * lk * rk *\n");
+	printf
+	    ("* %d * %4d * %2d * %2d * %2d * %2d * %4d * %2d * %2d * %3d * %2d * %3d * %4d * %2d * %2d *\n",
+	     h, tb->insert_size[h], tb->lnum[h], tb->lbytes, tb->rnum[h],
+	     tb->rbytes, tb->blknum[h], tb->s0num, tb->s1num, tb->s1bytes,
+	     tb->s2num, tb->s2bytes, tb->cur_blknum, tb->lkey[h], tb->rkey[h]);
 
-  printf ("********************** END OF PRINT_TB *******************\n\n");
+/* this prints balance parameters for non-leaf levels */
+	do {
+		h++;
+		printf("* %d * %4d * %2d *    * %2d *    * %2d *\n",
+		       h, tb->insert_size[h], tb->lnum[h], tb->rnum[h],
+		       tb->blknum[h]);
+	} while (tb->insert_size[h]);
+
+	printf
+	    ("*********************************************************************\n");
+
+	/* print FEB list (list of buffers in form (bh (b_blocknr, b_count), that will be used for new nodes) */
+	for (h = 0; h < sizeof(tb->FEB) / sizeof(tb->FEB[0]); h++)
+		printf("%s%p (%lu %d)", h == 0 ? "FEB list: " : ", ",
+		       tb->FEB[h], tb->FEB[h] ? tb->FEB[h]->b_blocknr : 0,
+		       tb->FEB[h] ? tb->FEB[h]->b_count : 0);
+	printf("\n");
+
+	printf
+	    ("********************** END OF PRINT_TB *******************\n\n");
 }
 
-
-static void print_bmap_block (FILE * fp, int i, unsigned long block, char * map, int blocks, int silent, int blocksize)
+static void print_bmap_block(FILE * fp, int i, unsigned long block, char *map,
+			     int blocks, int silent, int blocksize)
 {
-    int j, k;
-    int bits = blocksize * 8;
-    int zeros = 0, ones = 0;
-  
-
-    reiserfs_warning (fp, "#%d: block %lu: ", i, block);
-
-    blocks = blocksize * 8;
-
-    if (misc_test_bit (0, map)) {
-	/* first block addressed by this bitmap block is used */
-	ones ++;
-	if (!silent)
-	    reiserfs_warning (fp, "Busy (%d-", i * bits);
-	for (j = 1; j < blocks; j ++) {
-	    while (misc_test_bit (j, map)) {
-		ones ++;
-		if (j == blocks - 1) {
-		    if (!silent)
-			reiserfs_warning (fp, "%d)\n", j + i * bits);
-		    goto end;
+	int j, k;
+	int bits = blocksize * 8;
+	int zeros = 0, ones = 0;
+
+	reiserfs_warning(fp, "#%d: block %lu: ", i, block);
+
+	blocks = blocksize * 8;
+
+	if (misc_test_bit(0, map)) {
+		/* first block addressed by this bitmap block is used */
+		ones++;
+		if (!silent)
+			reiserfs_warning(fp, "Busy (%d-", i * bits);
+		for (j = 1; j < blocks; j++) {
+			while (misc_test_bit(j, map)) {
+				ones++;
+				if (j == blocks - 1) {
+					if (!silent)
+						reiserfs_warning(fp, "%d)\n",
+								 j + i * bits);
+					goto end;
+				}
+				j++;
+			}
+			if (!silent)
+				reiserfs_warning(fp, "%d) Free(%d-",
+						 j - 1 + i * bits,
+						 j + i * bits);
+
+			while (!misc_test_bit(j, map)) {
+				zeros++;
+				if (j == blocks - 1) {
+					if (!silent)
+						reiserfs_warning(fp, "%d)\n",
+								 j + i * bits);
+					goto end;
+				}
+				j++;
+			}
+			if (!silent)
+				reiserfs_warning(fp, "%d) Busy(%d-",
+						 j - 1 + i * bits,
+						 j + i * bits);
+
+			j--;
+end:
+			/* to make gcc 3.2 do not sware here */ ;
 		}
-		j++;
-	    }
-	    if (!silent)
-		reiserfs_warning (fp, "%d) Free(%d-", j - 1 + i * bits, j + i * bits);
-
-	    while (!misc_test_bit (j, map)) {
-		zeros ++;
-		if (j == blocks - 1) {
-		    if (!silent)
-			reiserfs_warning (fp, "%d)\n", j + i * bits);
-		    goto end;
-		}
-		j++;
-	    }
-	    if (!silent)
-		reiserfs_warning (fp, "%d) Busy(%d-", j - 1 + i * bits, j + i * bits);
-
-	    j --;
-	end:
-	    /* to make gcc 3.2 do not sware here */;
-	}
-    } else {
-	/* first block addressed by this bitmap is free */
-	zeros ++;
-	if (!silent)
-	    reiserfs_warning (fp, "Free (%d-", i * bits);
-	for (j = 1; j < blocks; j ++) {
-	    k = 0;
-	    while (!misc_test_bit (j, map)) {
-		k ++;
-		if (j == blocks - 1) {
-		    if (!silent)
-			reiserfs_warning (fp, "%d)\n", j + i * bits);
-		    zeros += k;
-		    goto end2;
-		}
-		j++;
-	    }
-	    zeros += k;
-	    if (!silent)
-		reiserfs_warning (fp, "%d) Busy(%d-", j - 1 + i * bits, j + i * bits);
-	    
-	    k = 0;
-	    while (misc_test_bit (j, map)) {
-		ones ++;
-		if (j == blocks - 1) {
-		    if (!silent)
-			reiserfs_warning (fp, "%d)\n", j + i * bits);
-		    ones += k;
-		    goto end2;
+	} else {
+		/* first block addressed by this bitmap is free */
+		zeros++;
+		if (!silent)
+			reiserfs_warning(fp, "Free (%d-", i * bits);
+		for (j = 1; j < blocks; j++) {
+			k = 0;
+			while (!misc_test_bit(j, map)) {
+				k++;
+				if (j == blocks - 1) {
+					if (!silent)
+						reiserfs_warning(fp, "%d)\n",
+								 j + i * bits);
+					zeros += k;
+					goto end2;
+				}
+				j++;
+			}
+			zeros += k;
+			if (!silent)
+				reiserfs_warning(fp, "%d) Busy(%d-",
+						 j - 1 + i * bits,
+						 j + i * bits);
+
+			k = 0;
+			while (misc_test_bit(j, map)) {
+				ones++;
+				if (j == blocks - 1) {
+					if (!silent)
+						reiserfs_warning(fp, "%d)\n",
+								 j + i * bits);
+					ones += k;
+					goto end2;
+				}
+				j++;
+			}
+			ones += k;
+			if (!silent)
+				reiserfs_warning(fp, "%d) Free(%d-",
+						 j - 1 + i * bits,
+						 j + i * bits);
+
+			j--;
+end2:
+			/* to make gcc 3.2 do not sware here */ ;
 		}
-		j++;
-	    }
-	    ones += k;
-	    if (!silent)
-		reiserfs_warning (fp, "%d) Free(%d-", j - 1 + i * bits, j + i * bits);
-	
-	    j --;
-	end2:
-	    /* to make gcc 3.2 do not sware here */;
 	}
-    }
 
-    reiserfs_warning (fp, "used %d, free %d\n", ones, zeros);
+	reiserfs_warning(fp, "used %d, free %d\n", ones, zeros);
 }
 
-
 /* read bitmap of disk and print details */
-void print_bmap (FILE * fp, reiserfs_filsys_t * fs, int silent)
+void print_bmap(FILE * fp, reiserfs_filsys_t *fs, int silent)
 {
-    struct reiserfs_super_block * sb;
-    int bmap_nr;
-    int i;
-    int bits_per_block;
-    int blocks;
-    unsigned long block;
-    struct buffer_head * bh;
-
-
-    sb = fs->fs_ondisk_sb;
-    bmap_nr = reiserfs_fs_bmap_nr(fs);
-    bits_per_block = fs->fs_blocksize * 8;
-    blocks = bits_per_block;
-
-    reiserfs_warning (fp, "Bitmap blocks are:\n");
-    block = fs->fs_super_bh->b_blocknr + 1;
-    for (i = 0; i < bmap_nr; i ++) {
-	bh = bread (fs->fs_dev, block, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (stderr, "print_bmap: bread failed for %d: %lu\n", i, block);
-	    continue;
+	struct reiserfs_super_block *sb;
+	int bmap_nr;
+	int i;
+	int bits_per_block;
+	int blocks;
+	unsigned long block;
+	struct buffer_head *bh;
+
+	sb = fs->fs_ondisk_sb;
+	bmap_nr = reiserfs_fs_bmap_nr(fs);
+	bits_per_block = fs->fs_blocksize * 8;
+	blocks = bits_per_block;
+
+	reiserfs_warning(fp, "Bitmap blocks are:\n");
+	block = fs->fs_super_bh->b_blocknr + 1;
+	for (i = 0; i < bmap_nr; i++) {
+		bh = bread(fs->fs_dev, block, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(stderr,
+					 "print_bmap: bread failed for %d: %lu\n",
+					 i, block);
+			continue;
+		}
+		if (i == bmap_nr - 1)
+			if (get_sb_block_count(sb) % bits_per_block)
+				blocks =
+				    get_sb_block_count(sb) % bits_per_block;
+		print_bmap_block(fp, i, block, bh->b_data, blocks, silent,
+				 fs->fs_blocksize);
+		brelse(bh);
+
+		if (spread_bitmaps(fs))
+			block =
+			    (block / (fs->fs_blocksize * 8) +
+			     1) * (fs->fs_blocksize * 8);
+		else
+			block++;
+
 	}
-	if (i == bmap_nr - 1)
-	    if (get_sb_block_count (sb) % bits_per_block)
-		blocks = get_sb_block_count (sb) % bits_per_block;
-	print_bmap_block (fp, i, block, bh->b_data, blocks, silent, fs->fs_blocksize);
-	brelse (bh);
-
-	if (spread_bitmaps (fs))
-	    block = (block / (fs->fs_blocksize * 8) + 1) * (fs->fs_blocksize * 8);
-	else
-	    block ++;
-	
-    }
 }
 
-
-
-void print_objectid_map (FILE * fp, reiserfs_filsys_t * fs)
+void print_objectid_map(FILE * fp, reiserfs_filsys_t *fs)
 {
-    int i;
-    struct reiserfs_super_block * sb;
-    __u32 * omap;
-
-
-    sb = fs->fs_ondisk_sb;
-    if (fs->fs_format == REISERFS_FORMAT_3_6)
-	omap = (__u32 *)(sb + 1);
-    else if (fs->fs_format == REISERFS_FORMAT_3_5)
-	omap = (__u32 *)((struct reiserfs_super_block_v1 *)sb + 1);
-    else {
-	reiserfs_warning (fp, "print_objectid_map: proper signature is not found\n");
-	return;
-    }
-	
-    reiserfs_warning (fp, "Map of objectids (super block size %d)\n",
-		      (char *)omap - (char *)sb);
-      
-    for (i = 0; i < get_sb_oid_cursize (sb); i ++) {
-	if (i % 2 == 0) {
-	    reiserfs_warning(fp, "busy(%u-%u) ", le32_to_cpu (omap[i]),
-			     le32_to_cpu (omap[i+1]) - 1); 
-	} else {
-	    reiserfs_warning(fp, "free(%u-%u) ", le32_to_cpu (omap[i]),
-			    ((i+1) == get_sb_oid_cursize (sb)) ? 
-			    ~(__u32)0 : (le32_to_cpu (omap[i+1]) - 1));
+	int i;
+	struct reiserfs_super_block *sb;
+	__u32 *omap;
+
+	sb = fs->fs_ondisk_sb;
+	if (fs->fs_format == REISERFS_FORMAT_3_6)
+		omap = (__u32 *) (sb + 1);
+	else if (fs->fs_format == REISERFS_FORMAT_3_5)
+		omap = (__u32 *) ((struct reiserfs_super_block_v1 *)sb + 1);
+	else {
+		reiserfs_warning(fp,
+				 "print_objectid_map: proper signature is not found\n");
+		return;
 	}
-    }
 
-    reiserfs_warning (fp, "\nObject id array has size %d (max %d):", 
-		      get_sb_oid_cursize (sb), get_sb_oid_maxsize (sb));
-  
-    for (i = 0; i < get_sb_oid_cursize (sb); i ++)
-	reiserfs_warning (fp, "%s%u ", i % 2 ? "" : "*", le32_to_cpu (omap[i])); 
-    reiserfs_warning (fp, "\n");
+	reiserfs_warning(fp, "Map of objectids (super block size %d)\n",
+			 (char *)omap - (char *)sb);
+
+	for (i = 0; i < get_sb_oid_cursize(sb); i++) {
+		if (i % 2 == 0) {
+			reiserfs_warning(fp, "busy(%u-%u) ",
+					 le32_to_cpu(omap[i]),
+					 le32_to_cpu(omap[i + 1]) - 1);
+		} else {
+			reiserfs_warning(fp, "free(%u-%u) ",
+					 le32_to_cpu(omap[i]),
+					 ((i + 1) ==
+					  get_sb_oid_cursize(sb)) ? ~(__u32) 0
+					 : (le32_to_cpu(omap[i + 1]) - 1));
+		}
+	}
 
-}
+	reiserfs_warning(fp, "\nObject id array has size %d (max %d):",
+			 get_sb_oid_cursize(sb), get_sb_oid_maxsize(sb));
 
+	for (i = 0; i < get_sb_oid_cursize(sb); i++)
+		reiserfs_warning(fp, "%s%u ", i % 2 ? "" : "*",
+				 le32_to_cpu(omap[i]));
+	reiserfs_warning(fp, "\n");
 
-void print_journal_header (reiserfs_filsys_t * fs)
-{
-    struct reiserfs_journal_header * j_head;
-
-
-    j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
-    reiserfs_warning (stdout, "Journal header (block #%lu of %s):\n"
-		      "\tj_last_flush_trans_id %ld\n"
-		      "\tj_first_unflushed_offset %ld\n"
-		      "\tj_mount_id %ld\n", 
-		      fs->fs_jh_bh->b_blocknr, fs->fs_j_file_name,
-		      get_jh_last_flushed (j_head),
-		      get_jh_replay_start_offset (j_head),
-		      get_jh_mount_id (j_head));
-    print_journal_params (stdout, &j_head->jh_journal);
 }
 
+void print_journal_header(reiserfs_filsys_t *fs)
+{
+	struct reiserfs_journal_header *j_head;
+
+	j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
+	reiserfs_warning(stdout, "Journal header (block #%lu of %s):\n"
+			 "\tj_last_flush_trans_id %ld\n"
+			 "\tj_first_unflushed_offset %ld\n"
+			 "\tj_mount_id %ld\n",
+			 fs->fs_jh_bh->b_blocknr, fs->fs_j_file_name,
+			 get_jh_last_flushed(j_head),
+			 get_jh_replay_start_offset(j_head),
+			 get_jh_mount_id(j_head));
+	print_journal_params(stdout, &j_head->jh_journal);
+}
 
-static void print_trans_element (reiserfs_filsys_t * fs, reiserfs_trans_t * trans,
-				 unsigned int index, unsigned long in_journal, 
-				 unsigned long in_place)
+static void print_trans_element(reiserfs_filsys_t *fs,
+				reiserfs_trans_t *trans, unsigned int index,
+				unsigned long in_journal,
+				unsigned long in_place)
 {
-    if (index % 8 == 0)
-	reiserfs_warning (stdout, "#%d\t", index);
+	if (index % 8 == 0)
+		reiserfs_warning(stdout, "#%d\t", index);
 
-    reiserfs_warning (stdout, "%lu->%lu%s ",  in_journal, in_place,
-		      block_of_bitmap (fs, in_place) ? "B" : "");
-    if ((index + 1) % 8 == 0 || index == trans->trans_len - 1)
-	reiserfs_warning (stdout, "\n");
+	reiserfs_warning(stdout, "%lu->%lu%s ", in_journal, in_place,
+			 block_of_bitmap(fs, in_place) ? "B" : "");
+	if ((index + 1) % 8 == 0 || index == trans->trans_len - 1)
+		reiserfs_warning(stdout, "\n");
 }
 
-
-void print_one_transaction (reiserfs_filsys_t * fs, reiserfs_trans_t * trans)
+void print_one_transaction(reiserfs_filsys_t *fs, reiserfs_trans_t *trans)
 {
-    reiserfs_warning (stdout, "Mountid %u, transid %u, desc %lu, length %u, commit %lu\n",
-		      trans->mount_id, trans->trans_id,
-		      trans->desc_blocknr,
-		      trans->trans_len, trans->commit_blocknr);
-    for_each_block (fs, trans, print_trans_element);
+	reiserfs_warning(stdout,
+			 "Mountid %u, transid %u, desc %lu, length %u, commit %lu\n",
+			 trans->mount_id, trans->trans_id, trans->desc_blocknr,
+			 trans->trans_len, trans->commit_blocknr);
+	for_each_block(fs, trans, print_trans_element);
 }
 
-
 /* print all valid transactions and found dec blocks */
-void print_journal (reiserfs_filsys_t * fs)
+void print_journal(reiserfs_filsys_t *fs)
 {
-    if (!reiserfs_journal_opened (fs)) {
-	reiserfs_warning (stderr, "print_journal: journal is not opened\n");
-	return;
-    }
-    print_journal_header (fs);
+	if (!reiserfs_journal_opened(fs)) {
+		reiserfs_warning(stderr,
+				 "print_journal: journal is not opened\n");
+		return;
+	}
+	print_journal_header(fs);
 
-    for_each_transaction (fs, print_one_transaction);
+	for_each_transaction(fs, print_one_transaction);
 }
-
diff --git a/reiserfscore/reiserfslib.c b/reiserfscore/reiserfslib.c
index ee556e3..e75b7bb 100644
--- a/reiserfscore/reiserfslib.c
+++ b/reiserfscore/reiserfslib.c
@@ -9,1069 +9,1100 @@
 #include <linux/kdev_t.h>
 #include <time.h>
 
-struct reiserfs_key root_dir_key = {0, 0, {{0, 0},}};
-struct reiserfs_key parent_root_dir_key = {0, 0, {{0, 0},}};
-struct reiserfs_key lost_found_dir_key = {0, 0, {{0, 0}, }};
-struct reiserfs_key badblock_key = {BADBLOCK_DIRID, BADBLOCK_OBJID, {{0, 0},}};
+struct reiserfs_key root_dir_key = { 0, 0, {{0, 0},} };
+struct reiserfs_key parent_root_dir_key = { 0, 0, {{0, 0},} };
+struct reiserfs_key lost_found_dir_key = { 0, 0, {{0, 0},} };
+struct reiserfs_key badblock_key =
+    { BADBLOCK_DIRID, BADBLOCK_OBJID, {{0, 0},} };
 
 __u16 root_dir_format = 0;
 __u16 lost_found_dir_format = 0;
 
-static void make_const_keys (void)
+static void make_const_keys(void)
 {
-    set_key_dirid (&root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
-    set_key_objectid (&root_dir_key, REISERFS_ROOT_OBJECTID);
+	set_key_dirid(&root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
+	set_key_objectid(&root_dir_key, REISERFS_ROOT_OBJECTID);
 
-    set_key_dirid (&parent_root_dir_key, 0);
-    set_key_objectid (&parent_root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
+	set_key_dirid(&parent_root_dir_key, 0);
+	set_key_objectid(&parent_root_dir_key, REISERFS_ROOT_PARENT_OBJECTID);
 }
 
-
-
 /* reiserfs needs at least: enough blocks for journal, 64 k at the beginning,
    one block for super block, bitmap block and root block. Note that first
    bitmap block must point to all of them */
-int is_block_count_correct (unsigned long journal_offset, unsigned int block_size,
-    unsigned long block_count, unsigned long journal_size)
+int is_block_count_correct(unsigned long journal_offset,
+			   unsigned int block_size, unsigned long block_count,
+			   unsigned long journal_size)
 {
-    unsigned long blocks;
-
-    /* RESERVED, MD RAID SBs, super block, bitmap, root, journal size with journal header */
-    blocks = journal_offset + journal_size;
-
-    /* we have a limit: skipped area, super block, journal and root block
-    all have to be addressed by one first bitmap */
-    if (blocks > block_size * 8)
-    	return 0;
-    	
-    if (blocks > block_count)
-    	return 0;
-    	
-    return 1;
+	unsigned long blocks;
+
+	/* RESERVED, MD RAID SBs, super block, bitmap, root, journal size with journal header */
+	blocks = journal_offset + journal_size;
+
+	/* we have a limit: skipped area, super block, journal and root block
+	   all have to be addressed by one first bitmap */
+	if (blocks > block_size * 8)
+		return 0;
+
+	if (blocks > block_count)
+		return 0;
+
+	return 1;
 }
 
 /* read super block. fixme: only 4k blocks, pre-journaled format
    is refused. Journal and bitmap are to be opened separately.
    skip_check is set to 1 if checks of openned SB should be omitted.*/
-reiserfs_filsys_t * reiserfs_open (char * filename, int flags, 
-				   int *error, void * vp, int check)
+reiserfs_filsys_t *reiserfs_open(char *filename, int flags,
+				 int *error, void *vp, int check)
 {
-    reiserfs_filsys_t * fs;
-    struct buffer_head * bh;
-    struct reiserfs_super_block * sb;
-    int fd;
-    unsigned int i;
+	reiserfs_filsys_t *fs;
+	struct buffer_head *bh;
+	struct reiserfs_super_block *sb;
+	int fd;
+	unsigned int i;
 
-    /* convert root dir key and parent root dir key to little endian format */
-    make_const_keys ();
+	/* convert root dir key and parent root dir key to little endian format */
+	make_const_keys();
 
-    if (error) 
-	*error = 0;
+	if (error)
+		*error = 0;
 
-    fd = open (filename, flags 
+	fd = open(filename, flags
 #if defined(O_LARGEFILE)
-	       | O_LARGEFILE
+		  | O_LARGEFILE
 #endif
-	       );
-    if (fd == -1) {
-	if (error)
-	    *error = errno;
-	return 0;
-    }
-
-    fs = getmem (sizeof (*fs));
-    fs->fs_dev = fd;
-    fs->fs_vp = vp;
-    asprintf (&fs->fs_file_name, "%s", filename);
-    
-    /* reiserfs super block is either in 16-th or in 2-nd 4k block of the
-       device */
-    for (i = 2; i < 17; i += 14) {
-	bh = bread (fd, i, 4096);
-	if (!bh) {
-	    reiserfs_warning (stderr, "reiserfs_open: bread failed reading block %d\n", i);
-	} else {
-	    sb = (struct reiserfs_super_block *)bh->b_data;
-	    
-	    if (is_any_reiserfs_magic_string(sb))
-		goto found;
+	    );
+	if (fd == -1) {
+		if (error)
+			*error = errno;
+		return 0;
+	}
 
-	    /* reiserfs signature is not found at the i-th 4k block */
-	    brelse (bh);
+	fs = getmem(sizeof(*fs));
+	fs->fs_dev = fd;
+	fs->fs_vp = vp;
+	asprintf(&fs->fs_file_name, "%s", filename);
+
+	/* reiserfs super block is either in 16-th or in 2-nd 4k block of the
+	   device */
+	for (i = 2; i < 17; i += 14) {
+		bh = bread(fd, i, 4096);
+		if (!bh) {
+			reiserfs_warning(stderr,
+					 "reiserfs_open: bread failed reading block %d\n",
+					 i);
+		} else {
+			sb = (struct reiserfs_super_block *)bh->b_data;
+
+			if (is_any_reiserfs_magic_string(sb))
+				goto found;
+
+			/* reiserfs signature is not found at the i-th 4k block */
+			brelse(bh);
+		}
 	}
-    }
-
-    reiserfs_warning(stderr, 
-	"\nreiserfs_open: the reiserfs superblock cannot be found on %s.\n", filename);
-    
-    freemem (fs);
-    close (fd);
-    fs = NULL;
-    return fs;
-
- found:
-
-    if (!is_blocksize_correct(get_sb_block_size(sb))) {
-	reiserfs_warning(stderr, "reiserfs_open: a superblock with wrong parameters "
-			 "was found in the block (%d).\n", i);
-	freemem (fs);
-	close (fd);
-	brelse(bh);
-	return NULL;
-    }
-
-    if (check) {
-	/* A few checks of found super block. */
-	struct buffer_head *tmp_bh;
-	
-	tmp_bh = bread (fd, get_sb_block_count(sb) - 1, get_sb_block_size(sb));
-	
-	if (!tmp_bh) {
-	    reiserfs_warning (stderr, "\n%s: Your partition is not big enough to contain the \n"
-		    "filesystem of (%lu) blocks as was specified in the found super block.\n", 
-		    __FUNCTION__,  get_sb_block_count(sb) - 1);
-	    
-	    freemem (fs);
-	    close (fd);
-	    brelse(bh);
-	    return NULL;
+
+	reiserfs_warning(stderr,
+			 "\nreiserfs_open: the reiserfs superblock cannot be found on %s.\n",
+			 filename);
+
+	freemem(fs);
+	close(fd);
+	fs = NULL;
+	return fs;
+
+found:
+
+	if (!is_blocksize_correct(get_sb_block_size(sb))) {
+		reiserfs_warning(stderr,
+				 "reiserfs_open: a superblock with wrong parameters "
+				 "was found in the block (%d).\n", i);
+		freemem(fs);
+		close(fd);
+		brelse(bh);
+		return NULL;
 	}
-	
-	brelse(tmp_bh);
-    }
-   
-    fs->fs_blocksize = get_sb_block_size (sb);
-    
-    /* check block size on the filesystem */
-    if (fs->fs_blocksize != 4096) {
-	i = bh->b_blocknr * 4096 / fs->fs_blocksize;
-	brelse (bh);
-	bh = bread (fd, i, fs->fs_blocksize);
-	if (!bh) {
-	    reiserfs_warning (stderr, "reiserfs_open: bread failed reading block %d, size %d\n",
-			      i, fs->fs_blocksize);
-	    freemem (fs);
-	    return 0;
+
+	if (check) {
+		/* A few checks of found super block. */
+		struct buffer_head *tmp_bh;
+
+		tmp_bh =
+		    bread(fd, get_sb_block_count(sb) - 1,
+			  get_sb_block_size(sb));
+
+		if (!tmp_bh) {
+			reiserfs_warning(stderr,
+					 "\n%s: Your partition is not big enough to contain the \n"
+					 "filesystem of (%lu) blocks as was specified in the found super block.\n",
+					 __FUNCTION__,
+					 get_sb_block_count(sb) - 1);
+
+			freemem(fs);
+			close(fd);
+			brelse(bh);
+			return NULL;
+		}
+
+		brelse(tmp_bh);
 	}
-	sb = (struct reiserfs_super_block *)bh->b_data;
-    }
 
-    fs->fs_hash_function = code2func (get_sb_hash_code (sb));
-    fs->fs_super_bh = bh;
-    fs->fs_ondisk_sb = sb;
-    fs->fs_flags = flags; /* O_RDONLY or O_RDWR */
+	fs->fs_blocksize = get_sb_block_size(sb);
+
+	/* check block size on the filesystem */
+	if (fs->fs_blocksize != 4096) {
+		i = bh->b_blocknr * 4096 / fs->fs_blocksize;
+		brelse(bh);
+		bh = bread(fd, i, fs->fs_blocksize);
+		if (!bh) {
+			reiserfs_warning(stderr,
+					 "reiserfs_open: bread failed reading block %d, size %d\n",
+					 i, fs->fs_blocksize);
+			freemem(fs);
+			return 0;
+		}
+		sb = (struct reiserfs_super_block *)bh->b_data;
+	}
 
-    fs->fs_format = get_reiserfs_format (sb);
+	fs->fs_hash_function = code2func(get_sb_hash_code(sb));
+	fs->fs_super_bh = bh;
+	fs->fs_ondisk_sb = sb;
+	fs->fs_flags = flags;	/* O_RDONLY or O_RDWR */
 
-    
-    /*reiserfs_read_bitmap_blocks(fs);*/
-    if (flags & O_RDWR)
-	fs->fs_dirt  = 1;
-    else
-	fs->fs_dirt = 0;
+	fs->fs_format = get_reiserfs_format(sb);
 
-    return fs;
-}
+	/*reiserfs_read_bitmap_blocks(fs); */
+	if (flags & O_RDWR)
+		fs->fs_dirt = 1;
+	else
+		fs->fs_dirt = 0;
 
+	return fs;
+}
 
 /* creates buffer for super block and fills it up with fields which are
    constant for given size and version of a filesystem */
-reiserfs_filsys_t * reiserfs_create (char * filename,
-				     int version,
-				     unsigned long block_count, 
-				     int block_size, 
-				     int default_journal, 
-				     int new_format)
+reiserfs_filsys_t *reiserfs_create(char *filename,
+				   int version,
+				   unsigned long block_count,
+				   int block_size,
+				   int default_journal, int new_format)
 {
-    reiserfs_filsys_t * fs;
-    unsigned int bmap_nr = reiserfs_bmap_nr(block_count, block_size);;
-    time_t now;
+	reiserfs_filsys_t *fs;
+	unsigned int bmap_nr = reiserfs_bmap_nr(block_count, block_size);;
+	time_t now;
 
+	/* convert root dir key and parent root dir key to little endian format */
+	make_const_keys();
 
-    /* convert root dir key and parent root dir key to little endian format */
-    make_const_keys ();
-
-
-    if (count_blocks (filename, block_size) < block_count) {
-	reiserfs_warning (stderr, "reiserfs_create: no enough blocks on device\n");
-	return 0;
-    }
+	if (count_blocks(filename, block_size) < block_count) {
+		reiserfs_warning(stderr,
+				 "reiserfs_create: no enough blocks on device\n");
+		return 0;
+	}
 
-    if (!is_block_count_correct (REISERFS_DISK_OFFSET_IN_BYTES / block_size, 
-	block_size, block_count, 0)) 
-    {
-	reiserfs_warning (stderr, "reiserfs_create: can not create that small "
-	    "(%u blocks) filesystem\n", block_count);
-	return 0;
-    }
+	if (!is_block_count_correct(REISERFS_DISK_OFFSET_IN_BYTES / block_size,
+				    block_size, block_count, 0)) {
+		reiserfs_warning(stderr,
+				 "reiserfs_create: can not create that small "
+				 "(%u blocks) filesystem\n", block_count);
+		return 0;
+	}
 
-    fs = getmem (sizeof (*fs));
-    if (!fs) {
-	reiserfs_warning (stderr, "reiserfs_create: getmem failed\n");
-	return 0;
-    }
+	fs = getmem(sizeof(*fs));
+	if (!fs) {
+		reiserfs_warning(stderr, "reiserfs_create: getmem failed\n");
+		return 0;
+	}
 
-    fs->fs_dev = open (filename, O_RDWR | O_EXCL
+	fs->fs_dev = open(filename, O_RDWR | O_EXCL
 #if defined(O_LARGEFILE)
-		       | O_LARGEFILE
+			  | O_LARGEFILE
 #endif
-		       );
-    if (fs->fs_dev == -1) {
-	reiserfs_warning (stderr, "reiserfs_create: could not open %s: %s\n",
-			  filename, strerror(errno));
-	freemem (fs);
-	return 0;
-    }
-
-    fs->fs_blocksize = block_size;
-    asprintf (&fs->fs_file_name, "%s", filename);
-    fs->fs_format = version;
-
-    if (new_format)
-        fs->fs_super_bh = getblk (fs->fs_dev, 
-	    REISERFS_DISK_OFFSET_IN_BYTES / block_size, block_size);
-    else 
-        fs->fs_super_bh = getblk (fs->fs_dev, 
-	    REISERFS_OLD_DISK_OFFSET_IN_BYTES / block_size, block_size);
-    
-    if (!fs->fs_super_bh) {
-	reiserfs_warning (stderr, "reiserfs_create: getblk failed\n");
-	return 0;
-    }
-
-    mark_buffer_uptodate (fs->fs_super_bh, 1);
-    
-    fs->fs_ondisk_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
-    memset (fs->fs_ondisk_sb, 0, block_size);
-    
-    /* fill super block fields which are constant for given version and block count */
-    set_sb_block_count (fs->fs_ondisk_sb, block_count);
-    /* sb_free_blocks */
-    /* sb_root_block */
-    /* sb_journal_1st_block */
-    /* sb_journal_dev */
-    /* sb_orig_journal_size */
-    /* sb_joural_magic */
-    /* sb_journal magic_F */
-    /* sb_mount_id */
-    /* sb_not_used0 */
-    /* sb_generation_number */    
-    set_sb_block_size (fs->fs_ondisk_sb, block_size);
-    switch (version) {
-    case REISERFS_FORMAT_3_5:
-	set_sb_oid_maxsize (fs->fs_ondisk_sb, 
-	    (block_size - SB_SIZE_V1) / sizeof(__u32) / 2 * 2);
-	/* sb_oid_cursize */
-	/* sb_state */
-	memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_3_5_SUPER_MAGIC_STRING,
-		strlen (REISERFS_3_5_SUPER_MAGIC_STRING));
-	break;
-
-    case REISERFS_FORMAT_3_6:
-	set_sb_oid_maxsize (fs->fs_ondisk_sb, 
-	    (block_size - SB_SIZE) / sizeof(__u32) / 2 * 2);
-	/* sb_oid_cursize */
-	/* sb_state */
-        memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_3_6_SUPER_MAGIC_STRING,
-                strlen (REISERFS_3_6_SUPER_MAGIC_STRING));
-	break;
-    }
-    if (!default_journal)
-        memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING,
-                strlen (REISERFS_JR_SUPER_MAGIC_STRING));
-
-    /* sb_fsck_state */
-    /* sb_hash_function_code */
-    /* sb_tree_height */
-
-    set_sb_bmap_nr (fs->fs_ondisk_sb,
-                    reiserfs_bmap_over(bmap_nr) ? 0 : bmap_nr);
-
-    set_sb_version (fs->fs_ondisk_sb, version);
-    set_sb_v2_lastcheck(fs->fs_ondisk_sb, time(&now));
-    set_sb_v2_check_interval(fs->fs_ondisk_sb, DEFAULT_CHECK_INTERVAL);
-    set_sb_v2_mnt_count(fs->fs_ondisk_sb, 1);
-    set_sb_v2_max_mnt_count(fs->fs_ondisk_sb, DEFAULT_MAX_MNT_COUNT);
-
-    /* sb_not_used1 */
-
-    mark_buffer_dirty (fs->fs_super_bh);
-    fs->fs_dirt = 1;
-
-    return fs;
-}
+	    );
+	if (fs->fs_dev == -1) {
+		reiserfs_warning(stderr,
+				 "reiserfs_create: could not open %s: %s\n",
+				 filename, strerror(errno));
+		freemem(fs);
+		return 0;
+	}
 
+	fs->fs_blocksize = block_size;
+	asprintf(&fs->fs_file_name, "%s", filename);
+	fs->fs_format = version;
 
-int no_reiserfs_found (reiserfs_filsys_t * fs)
-{
-    return (fs == NULL || fs->fs_blocksize == 0) ? 1 : 0;
-}
+	if (new_format)
+		fs->fs_super_bh = getblk(fs->fs_dev,
+					 REISERFS_DISK_OFFSET_IN_BYTES /
+					 block_size, block_size);
+	else
+		fs->fs_super_bh = getblk(fs->fs_dev,
+					 REISERFS_OLD_DISK_OFFSET_IN_BYTES /
+					 block_size, block_size);
 
+	if (!fs->fs_super_bh) {
+		reiserfs_warning(stderr, "reiserfs_create: getblk failed\n");
+		return 0;
+	}
 
-int new_format (reiserfs_filsys_t * fs)
-{
-    return fs->fs_super_bh->b_blocknr != 2;
+	mark_buffer_uptodate(fs->fs_super_bh, 1);
+
+	fs->fs_ondisk_sb =
+	    (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
+	memset(fs->fs_ondisk_sb, 0, block_size);
+
+	/* fill super block fields which are constant for given version and block count */
+	set_sb_block_count(fs->fs_ondisk_sb, block_count);
+	/* sb_free_blocks */
+	/* sb_root_block */
+	/* sb_journal_1st_block */
+	/* sb_journal_dev */
+	/* sb_orig_journal_size */
+	/* sb_joural_magic */
+	/* sb_journal magic_F */
+	/* sb_mount_id */
+	/* sb_not_used0 */
+	/* sb_generation_number */
+	set_sb_block_size(fs->fs_ondisk_sb, block_size);
+	switch (version) {
+	case REISERFS_FORMAT_3_5:
+		set_sb_oid_maxsize(fs->fs_ondisk_sb,
+				   (block_size -
+				    SB_SIZE_V1) / sizeof(__u32) / 2 * 2);
+		/* sb_oid_cursize */
+		/* sb_state */
+		memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+		       REISERFS_3_5_SUPER_MAGIC_STRING,
+		       strlen(REISERFS_3_5_SUPER_MAGIC_STRING));
+		break;
+
+	case REISERFS_FORMAT_3_6:
+		set_sb_oid_maxsize(fs->fs_ondisk_sb,
+				   (block_size -
+				    SB_SIZE) / sizeof(__u32) / 2 * 2);
+		/* sb_oid_cursize */
+		/* sb_state */
+		memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+		       REISERFS_3_6_SUPER_MAGIC_STRING,
+		       strlen(REISERFS_3_6_SUPER_MAGIC_STRING));
+		break;
+	}
+	if (!default_journal)
+		memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+		       REISERFS_JR_SUPER_MAGIC_STRING,
+		       strlen(REISERFS_JR_SUPER_MAGIC_STRING));
+
+	/* sb_fsck_state */
+	/* sb_hash_function_code */
+	/* sb_tree_height */
+
+	set_sb_bmap_nr(fs->fs_ondisk_sb,
+		       reiserfs_bmap_over(bmap_nr) ? 0 : bmap_nr);
+
+	set_sb_version(fs->fs_ondisk_sb, version);
+	set_sb_v2_lastcheck(fs->fs_ondisk_sb, time(&now));
+	set_sb_v2_check_interval(fs->fs_ondisk_sb, DEFAULT_CHECK_INTERVAL);
+	set_sb_v2_mnt_count(fs->fs_ondisk_sb, 1);
+	set_sb_v2_max_mnt_count(fs->fs_ondisk_sb, DEFAULT_MAX_MNT_COUNT);
+
+	/* sb_not_used1 */
+
+	mark_buffer_dirty(fs->fs_super_bh);
+	fs->fs_dirt = 1;
+
+	return fs;
 }
 
+int no_reiserfs_found(reiserfs_filsys_t *fs)
+{
+	return (fs == NULL || fs->fs_blocksize == 0) ? 1 : 0;
+}
 
-int spread_bitmaps (reiserfs_filsys_t * fs)
+int new_format(reiserfs_filsys_t *fs)
 {
-    return fs->fs_super_bh->b_blocknr != 2;
+	return fs->fs_super_bh->b_blocknr != 2;
 }
 
+int spread_bitmaps(reiserfs_filsys_t *fs)
+{
+	return fs->fs_super_bh->b_blocknr != 2;
+}
 
 /* 0 means: do not guarantee that fs is consistent */
-int reiserfs_is_fs_consistent (reiserfs_filsys_t * fs)
+int reiserfs_is_fs_consistent(reiserfs_filsys_t *fs)
 {
-    if (get_sb_umount_state (fs->fs_ondisk_sb) == FS_CLEANLY_UMOUNTED &&
-	get_sb_fs_state (fs->fs_ondisk_sb) == FS_CONSISTENT)
-	return 1;
-    return 0;
+	if (get_sb_umount_state(fs->fs_ondisk_sb) == FS_CLEANLY_UMOUNTED &&
+	    get_sb_fs_state(fs->fs_ondisk_sb) == FS_CONSISTENT)
+		return 1;
+	return 0;
 }
 
 /* flush bitmap, brelse super block, flush all dirty buffers, close and open
    again the device, read super block */
-static void reiserfs_only_reopen (reiserfs_filsys_t * fs, int flag)
+static void reiserfs_only_reopen(reiserfs_filsys_t *fs, int flag)
 {
-    unsigned long super_block;
-
-
-    /*  reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs);*/
-    super_block = fs->fs_super_bh->b_blocknr;                
-    brelse (fs->fs_super_bh);
-    flush_buffers (fs->fs_dev);
-    
-    invalidate_buffers (fs->fs_dev);
-    if (close (fs->fs_dev))
-	die ("reiserfs_reopen: closed failed: %s", strerror(errno));
-    
-    fs->fs_dev = open (fs->fs_file_name, flag 
+	unsigned long super_block;
+
+	/*  reiserfs_flush_to_ondisk_bitmap (fs->fs_bitmap2, fs); */
+	super_block = fs->fs_super_bh->b_blocknr;
+	brelse(fs->fs_super_bh);
+	flush_buffers(fs->fs_dev);
+
+	invalidate_buffers(fs->fs_dev);
+	if (close(fs->fs_dev))
+		die("reiserfs_reopen: closed failed: %s", strerror(errno));
+
+	fs->fs_dev = open(fs->fs_file_name, flag
 #if defined(O_LARGEFILE)
-		       | O_LARGEFILE
+			  | O_LARGEFILE
 #endif
-		       );
-    if (fs->fs_dev == -1)
-	die ("reiserfs_reopen: could not reopen device: %s", strerror(errno));
-
-    fs->fs_super_bh = bread (fs->fs_dev, super_block, fs->fs_blocksize);
-    if (!fs->fs_super_bh)
-	die ("reiserfs_reopen: reading super block failed");
-    fs->fs_ondisk_sb = (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
-    fs->fs_flags = flag; /* O_RDONLY or O_RDWR */
-    
-    if (flag & O_RDWR)
-	fs->fs_dirt  = 1;
-    else
-	fs->fs_dirt = 0;
+	    );
+	if (fs->fs_dev == -1)
+		die("reiserfs_reopen: could not reopen device: %s",
+		    strerror(errno));
+
+	fs->fs_super_bh = bread(fs->fs_dev, super_block, fs->fs_blocksize);
+	if (!fs->fs_super_bh)
+		die("reiserfs_reopen: reading super block failed");
+	fs->fs_ondisk_sb =
+	    (struct reiserfs_super_block *)fs->fs_super_bh->b_data;
+	fs->fs_flags = flag;	/* O_RDONLY or O_RDWR */
+
+	if (flag & O_RDWR)
+		fs->fs_dirt = 1;
+	else
+		fs->fs_dirt = 0;
 }
 
-void reiserfs_reopen (reiserfs_filsys_t * fs, int flag)
+void reiserfs_reopen(reiserfs_filsys_t *fs, int flag)
 {
-    reiserfs_only_reopen (fs, flag);
-    reiserfs_reopen_journal (fs, flag);
+	reiserfs_only_reopen(fs, flag);
+	reiserfs_reopen_journal(fs, flag);
 }
 
-int is_opened_rw (reiserfs_filsys_t * fs)
+int is_opened_rw(reiserfs_filsys_t *fs)
 {
-    if ((fs->fs_flags) & O_RDWR)
-	return 1;
-    return 0;
+	if ((fs->fs_flags) & O_RDWR)
+		return 1;
+	return 0;
 }
 
-
 /* flush all changes made on a filesystem */
-void reiserfs_flush (reiserfs_filsys_t * fs)
+void reiserfs_flush(reiserfs_filsys_t *fs)
 {
-    if (fs->fs_dirt) {
-	reiserfs_flush_journal (fs);
-	flush_buffers (fs->fs_dev);
-    }
-    fs->fs_dirt = 0;
+	if (fs->fs_dirt) {
+		reiserfs_flush_journal(fs);
+		flush_buffers(fs->fs_dev);
+	}
+	fs->fs_dirt = 0;
 }
 
-
 /* free all memory involved into manipulating with filesystem */
-void reiserfs_free (reiserfs_filsys_t * fs)
+void reiserfs_free(reiserfs_filsys_t *fs)
 {
-    reiserfs_free_journal (fs);
-    reiserfs_free_ondisk_bitmap (fs);
+	reiserfs_free_journal(fs);
+	reiserfs_free_ondisk_bitmap(fs);
 
-    /* release super block and memory used by filesystem handler */
-    brelse (fs->fs_super_bh);
-    fs->fs_super_bh = 0;
+	/* release super block and memory used by filesystem handler */
+	brelse(fs->fs_super_bh);
+	fs->fs_super_bh = 0;
 
-    free_buffers ();
+	free_buffers();
 
-    free (fs->fs_file_name);
-    fs->fs_file_name = 0;
-    freemem (fs);
+	free(fs->fs_file_name);
+	fs->fs_file_name = 0;
+	freemem(fs);
 }
 
-
 /* this closes everything: journal. bitmap and the fs itself */
-void reiserfs_close (reiserfs_filsys_t * fs)
+void reiserfs_close(reiserfs_filsys_t *fs)
 {
-    reiserfs_close_journal (fs);
-    reiserfs_close_ondisk_bitmap (fs);
+	reiserfs_close_journal(fs);
+	reiserfs_close_ondisk_bitmap(fs);
 
-    reiserfs_flush (fs);
-    reiserfs_free (fs);
-    fsync(fs->fs_dev);
+	reiserfs_flush(fs);
+	reiserfs_free(fs);
+	fsync(fs->fs_dev);
 }
 
-
-int reiserfs_new_blocknrs (reiserfs_filsys_t * fs, 
-			   unsigned long * free_blocknrs, 
-			   unsigned long start, 
-			   int amount_needed)
+int reiserfs_new_blocknrs(reiserfs_filsys_t *fs,
+			  unsigned long *free_blocknrs,
+			  unsigned long start, int amount_needed)
 {
-    if (fs->block_allocator)
-	return fs->block_allocator (fs, free_blocknrs, start, amount_needed);
-    die ("block allocator is not defined\n");
-    return 0;
+	if (fs->block_allocator)
+		return fs->block_allocator(fs, free_blocknrs, start,
+					   amount_needed);
+	die("block allocator is not defined\n");
+	return 0;
 }
 
-
-int reiserfs_free_block (reiserfs_filsys_t * fs, unsigned long block)
+int reiserfs_free_block(reiserfs_filsys_t *fs, unsigned long block)
 {
-    if (fs->block_deallocator)
-	return fs->block_deallocator (fs, block);
-    die ("block deallocator is not defined\n");
-    return 0;
+	if (fs->block_deallocator)
+		return fs->block_deallocator(fs, block);
+	die("block deallocator is not defined\n");
+	return 0;
 }
 
-static int reiserfs_search_by_key_x (reiserfs_filsys_t * fs, struct reiserfs_key *key,
-				     struct reiserfs_path *path, int key_length)
+static int reiserfs_search_by_key_x(reiserfs_filsys_t *fs,
+				    struct reiserfs_key *key,
+				    struct reiserfs_path *path, int key_length)
 {
-    struct buffer_head * bh;   
-    unsigned long block;
-    struct reiserfs_path_element * curr;
-    int retval;
-    
-
-    block = get_sb_root_block (fs->fs_ondisk_sb);
-    if (not_data_block(fs, block))
-	return IO_ERROR;
-    
-    path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
-    while (1) {
-	curr = PATH_OFFSET_PELEMENT (path, ++ path->path_length);
-	bh = curr->pe_buffer = bread (fs->fs_dev, block, fs->fs_blocksize);
-        if (bh == 0) {
-	    path->path_length --;
-	    pathrelse (path);
-	    return ITEM_NOT_FOUND;
-	}
-	retval = reiserfs_bin_search (key, B_N_PKEY (bh, 0), B_NR_ITEMS (bh),
-				      is_leaf_node (bh) ? IH_SIZE : KEY_SIZE,
-				      &curr->pe_position,
-				      key_length == 4 ?
-					comp_keys : comp_keys_3);
-	if (retval == POSITION_FOUND) {
-	    /* key found, return if this is leaf level */
-	    if (is_leaf_node (bh)) {
-		path->pos_in_item = 0;
-		return ITEM_FOUND;
-	    }
-	    curr->pe_position ++;
-	} else {
-	    /* key not found in the node */
-	    if (is_leaf_node (bh))
-		return ITEM_NOT_FOUND;
-	}
-	block = get_dc_child_blocknr (B_N_CHILD (bh, curr->pe_position));
+	struct buffer_head *bh;
+	unsigned long block;
+	struct reiserfs_path_element *curr;
+	int retval;
+
+	block = get_sb_root_block(fs->fs_ondisk_sb);
 	if (not_data_block(fs, block))
 		return IO_ERROR;
-    }
-    printf ("search_by_key: you can not get here\n");
-    return ITEM_NOT_FOUND;
-}
 
+	path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
+	while (1) {
+		curr = PATH_OFFSET_PELEMENT(path, ++path->path_length);
+		bh = curr->pe_buffer =
+		    bread(fs->fs_dev, block, fs->fs_blocksize);
+		if (bh == 0) {
+			path->path_length--;
+			pathrelse(path);
+			return ITEM_NOT_FOUND;
+		}
+		retval =
+		    reiserfs_bin_search(key, B_N_PKEY(bh, 0), B_NR_ITEMS(bh),
+					is_leaf_node(bh) ? IH_SIZE : KEY_SIZE,
+					&curr->pe_position,
+					key_length ==
+					4 ? comp_keys : comp_keys_3);
+		if (retval == POSITION_FOUND) {
+			/* key found, return if this is leaf level */
+			if (is_leaf_node(bh)) {
+				path->pos_in_item = 0;
+				return ITEM_FOUND;
+			}
+			curr->pe_position++;
+		} else {
+			/* key not found in the node */
+			if (is_leaf_node(bh))
+				return ITEM_NOT_FOUND;
+		}
+		block = get_dc_child_blocknr(B_N_CHILD(bh, curr->pe_position));
+		if (not_data_block(fs, block))
+			return IO_ERROR;
+	}
+	printf("search_by_key: you can not get here\n");
+	return ITEM_NOT_FOUND;
+}
 
-int reiserfs_search_by_key_3 (reiserfs_filsys_t * fs, struct reiserfs_key *key,
-			      struct reiserfs_path *path)
+int reiserfs_search_by_key_3(reiserfs_filsys_t *fs, struct reiserfs_key *key,
+			     struct reiserfs_path *path)
 {
-    return reiserfs_search_by_key_x (fs, key, path, 3);
+	return reiserfs_search_by_key_x(fs, key, path, 3);
 }
 
-
-int reiserfs_search_by_key_4 (reiserfs_filsys_t * fs, struct reiserfs_key *key,
-			      struct reiserfs_path *path)
+int reiserfs_search_by_key_4(reiserfs_filsys_t *fs, struct reiserfs_key *key,
+			     struct reiserfs_path *path)
 {
-    return reiserfs_search_by_key_x (fs, key, path, 4);
+	return reiserfs_search_by_key_x(fs, key, path, 4);
 }
 
-
 /* key is key of byte in the regular file. This searches in tree
    through items and in the found item as well */
-int usearch_by_position (reiserfs_filsys_t * s, struct reiserfs_key *key,
-			 int version, struct reiserfs_path *path)
+int usearch_by_position(reiserfs_filsys_t *s, struct reiserfs_key *key,
+			int version, struct reiserfs_path *path)
 {
-    struct buffer_head * bh;
-    struct item_head * ih;
-    struct reiserfs_key *next_key;
+	struct buffer_head *bh;
+	struct item_head *ih;
+	struct reiserfs_key *next_key;
 
-    if (reiserfs_search_by_key_3 (s, key, path) == ITEM_FOUND) {
-    	ih = get_ih (path);
+	if (reiserfs_search_by_key_3(s, key, path) == ITEM_FOUND) {
+		ih = get_ih(path);
 
-	if (!is_direct_ih (ih) && !is_indirect_ih (ih))
-	    return DIRECTORY_FOUND;
+		if (!is_direct_ih(ih) && !is_indirect_ih(ih))
+			return DIRECTORY_FOUND;
 
-	path->pos_in_item = 0;
-	return POSITION_FOUND;
-    }
+		path->pos_in_item = 0;
+		return POSITION_FOUND;
+	}
+
+	bh = get_bh(path);
+	ih = get_ih(path);
+
+	if (PATH_LAST_POSITION(path) == 0) {
+		/* previous item does not exist, that means we are in leftmost leaf of
+		 * the tree */
+		if (!not_of_one_file(&ih->ih_key, key)) {
+			if (!is_direct_ih(ih) && !is_indirect_ih(ih))
+				return DIRECTORY_FOUND;
+			return POSITION_NOT_FOUND;
+		}
+		return FILE_NOT_FOUND;
+	}
+
+	/* take previous item */
+	PATH_LAST_POSITION(path)--;
+	ih--;
+
+	if (not_of_one_file(&ih->ih_key, key) || is_stat_data_ih(ih)) {
+		/* previous item belongs to another object or is a stat data, check
+		 * next item */
+		PATH_LAST_POSITION(path)++;
+		if (PATH_LAST_POSITION(path) < B_NR_ITEMS(bh))
+			/* next key is in the same node */
+			next_key = B_N_PKEY(bh, PATH_LAST_POSITION(path));
+		else
+			next_key = uget_rkey(path);
+		if (next_key == 0 || not_of_one_file(next_key, key)) {
+			/* there is no any part of such file in the tree */
+			path->pos_in_item = 0;
+			return FILE_NOT_FOUND;
+		}
 
-    bh = get_bh (path);
-    ih = get_ih (path);
+		if (is_direntry_key(next_key)) {
+			reiserfs_warning(stderr,
+					 "usearch_by_position: looking for %k found a directory with the same key\n",
+					 next_key);
+			return DIRECTORY_FOUND;
+		}
 
+		/* next item is the part of this file */
+		path->pos_in_item = 0;
+		return POSITION_NOT_FOUND;
+	}
 
-    if (PATH_LAST_POSITION (path) == 0) {
-	/* previous item does not exist, that means we are in leftmost leaf of
-	 * the tree */
-	if (!not_of_one_file (&ih->ih_key, key)) {
-	    if (!is_direct_ih (ih) && !is_indirect_ih (ih))
+	if (is_direntry_ih(ih)) {
 		return DIRECTORY_FOUND;
-	    return POSITION_NOT_FOUND;
 	}
-	return FILE_NOT_FOUND;
-    }
-
-    /* take previous item */
-    PATH_LAST_POSITION (path) --;
-    ih --;
-
-    if (not_of_one_file (&ih->ih_key, key) || is_stat_data_ih(ih)) {
-	/* previous item belongs to another object or is a stat data, check
-	 * next item */
-	PATH_LAST_POSITION (path) ++;
-	if (PATH_LAST_POSITION (path) < B_NR_ITEMS (bh))
-	    /* next key is in the same node */
-	    next_key = B_N_PKEY (bh, PATH_LAST_POSITION (path));
-	else
-	    next_key = uget_rkey (path);
-	if (next_key == 0 || not_of_one_file (next_key, key)) {
-	    /* there is no any part of such file in the tree */
-	    path->pos_in_item = 0;
-	    return FILE_NOT_FOUND;
+
+	if (is_stat_data_ih(ih)) {
+		PATH_LAST_POSITION(path)++;
+		return FILE_NOT_FOUND;
 	}
 
-	if (is_direntry_key (next_key)) {
-	    reiserfs_warning (stderr, "usearch_by_position: looking for %k found a directory with the same key\n",
-		      next_key);
-	    return DIRECTORY_FOUND;
+	/* previous item is part of desired file */
+	if (I_K_KEY_IN_ITEM(ih, key, bh->b_size)) {
+		path->pos_in_item = get_offset(key) - get_offset(&ih->ih_key);
+		if (is_indirect_ih(ih))
+			path->pos_in_item /= bh->b_size;
+		return POSITION_FOUND;
 	}
 
-	/* next item is the part of this file */
-	path->pos_in_item = 0;
+	path->pos_in_item =
+	    is_indirect_ih(ih) ? I_UNFM_NUM(ih) : get_ih_item_len(ih);
 	return POSITION_NOT_FOUND;
-    }
-
-    if (is_direntry_ih (ih)) {
-	return DIRECTORY_FOUND;
-    }
-
-    if (is_stat_data_ih(ih)) {
-	PATH_LAST_POSITION (path) ++;
-	return FILE_NOT_FOUND;
-    }
-
-    /* previous item is part of desired file */
-    if (I_K_KEY_IN_ITEM (ih, key, bh->b_size)) {
-	path->pos_in_item = get_offset (key) - get_offset (&ih->ih_key);
-	if (is_indirect_ih (ih) )
-	    path->pos_in_item /= bh->b_size;
-	return POSITION_FOUND;
-    }
-
-    path->pos_in_item = is_indirect_ih (ih) ? I_UNFM_NUM (ih) : get_ih_item_len (ih);
-    return POSITION_NOT_FOUND;
 }
 
-static int comp_dir_entries (const void * p1, const void * p2)
+static int comp_dir_entries(const void *p1, const void *p2)
 {
-    __u32 off1, off2;
-
-    off1 = d32_get((__u32 *)p1, 0);
-    off2 = *(__u32 *)p2;
-    
-    if (off1 < off2)
-	return -1;
-    if (off1 > off2)
-	return 1;
-    return 0;
+	__u32 off1, off2;
+
+	off1 = d32_get((__u32 *) p1, 0);
+	off2 = *(__u32 *) p2;
+
+	if (off1 < off2)
+		return -1;
+	if (off1 > off2)
+		return 1;
+	return 0;
 }
 
-struct reiserfs_key *uget_lkey (struct reiserfs_path *path)
+struct reiserfs_key *uget_lkey(struct reiserfs_path *path)
 {
-    int pos, offset = path->path_length;
-    struct buffer_head * bh;
-
-    if (offset < FIRST_PATH_ELEMENT_OFFSET)
-	die ("uget_lkey: illegal offset in the path (%d)", offset);
-
-
-    /* While not higher in path than first element. */
-    while (offset-- > FIRST_PATH_ELEMENT_OFFSET) {
-	if (! buffer_uptodate (PATH_OFFSET_PBUFFER (path, offset)) )
-	    die ("uget_lkey: parent is not uptodate");
-	
-	/* Parent at the path is not in the tree now. */
-	if (! B_IS_IN_TREE (bh = PATH_OFFSET_PBUFFER (path, offset)))
-	    die ("uget_lkey: buffer on the path is not in tree");
-
-	/* Check whether position in the parent is correct. */
-	if ((pos = PATH_OFFSET_POSITION (path, offset)) > B_NR_ITEMS (bh))
-	    die ("uget_lkey: invalid position (%d) in the path", pos);
-
-	/* Check whether parent at the path really points to the child. */
-	if (get_dc_child_blocknr (B_N_CHILD (bh, pos)) != PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr)
-	    die ("uget_lkey: invalid block number (%d). Must be %ld",
-		 get_dc_child_blocknr (B_N_CHILD (bh, pos)), PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr);
-	
-	/* Return delimiting key if position in the parent is not equal to zero. */
-	if (pos)
-	    return B_N_PDELIM_KEY(bh, pos - 1);
-    }
-
-    /* there is no left delimiting key */
-    return 0;
+	int pos, offset = path->path_length;
+	struct buffer_head *bh;
+
+	if (offset < FIRST_PATH_ELEMENT_OFFSET)
+		die("uget_lkey: illegal offset in the path (%d)", offset);
+
+	/* While not higher in path than first element. */
+	while (offset-- > FIRST_PATH_ELEMENT_OFFSET) {
+		if (!buffer_uptodate(PATH_OFFSET_PBUFFER(path, offset)))
+			die("uget_lkey: parent is not uptodate");
+
+		/* Parent at the path is not in the tree now. */
+		if (!B_IS_IN_TREE(bh = PATH_OFFSET_PBUFFER(path, offset)))
+			die("uget_lkey: buffer on the path is not in tree");
+
+		/* Check whether position in the parent is correct. */
+		if ((pos = PATH_OFFSET_POSITION(path, offset)) > B_NR_ITEMS(bh))
+			die("uget_lkey: invalid position (%d) in the path",
+			    pos);
+
+		/* Check whether parent at the path really points to the child. */
+		if (get_dc_child_blocknr(B_N_CHILD(bh, pos)) !=
+		    PATH_OFFSET_PBUFFER(path, offset + 1)->b_blocknr)
+			die("uget_lkey: invalid block number (%d). Must be %ld",
+			    get_dc_child_blocknr(B_N_CHILD(bh, pos)),
+			    PATH_OFFSET_PBUFFER(path, offset + 1)->b_blocknr);
+
+		/* Return delimiting key if position in the parent is not equal to zero. */
+		if (pos)
+			return B_N_PDELIM_KEY(bh, pos - 1);
+	}
+
+	/* there is no left delimiting key */
+	return 0;
 }
 
-struct reiserfs_key *uget_rkey (struct reiserfs_path *path)
+struct reiserfs_key *uget_rkey(struct reiserfs_path *path)
 {
-    int pos, offset = path->path_length;
-    struct buffer_head * bh;
-
-    if (offset < FIRST_PATH_ELEMENT_OFFSET)
-	die ("uget_rkey: illegal offset in the path (%d)", offset);
-
-    while (offset-- > FIRST_PATH_ELEMENT_OFFSET) {
-	if (! buffer_uptodate (PATH_OFFSET_PBUFFER (path, offset)))
-	    die ("uget_rkey: parent is not uptodate");
-
-	/* Parent at the path is not in the tree now. */
-	if (! B_IS_IN_TREE (bh = PATH_OFFSET_PBUFFER (path, offset)))
-	    die ("uget_rkey: buffer on the path is not in tree");
-
-	/* Check whether position in the parrent is correct. */
-	if ((pos = PATH_OFFSET_POSITION (path, offset)) > B_NR_ITEMS (bh))
-	    die ("uget_rkey: invalid position (%d) in the path", pos);
-
-	/* Check whether parent at the path really points to the child. */
-	if (get_dc_child_blocknr (B_N_CHILD (bh, pos)) != PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr)
-	    die ("uget_rkey: invalid block number (%d). Must be %ld",
-		 get_dc_child_blocknr (B_N_CHILD (bh, pos)), PATH_OFFSET_PBUFFER (path, offset + 1)->b_blocknr);
-	
-	/* Return delimiting key if position in the parent is not the last one. */
-	if (pos != B_NR_ITEMS (bh))
-	    return B_N_PDELIM_KEY (bh, pos);
-    }
-    
-    /* there is no right delimiting key */
-    return 0;
+	int pos, offset = path->path_length;
+	struct buffer_head *bh;
+
+	if (offset < FIRST_PATH_ELEMENT_OFFSET)
+		die("uget_rkey: illegal offset in the path (%d)", offset);
+
+	while (offset-- > FIRST_PATH_ELEMENT_OFFSET) {
+		if (!buffer_uptodate(PATH_OFFSET_PBUFFER(path, offset)))
+			die("uget_rkey: parent is not uptodate");
+
+		/* Parent at the path is not in the tree now. */
+		if (!B_IS_IN_TREE(bh = PATH_OFFSET_PBUFFER(path, offset)))
+			die("uget_rkey: buffer on the path is not in tree");
+
+		/* Check whether position in the parrent is correct. */
+		if ((pos = PATH_OFFSET_POSITION(path, offset)) > B_NR_ITEMS(bh))
+			die("uget_rkey: invalid position (%d) in the path",
+			    pos);
+
+		/* Check whether parent at the path really points to the child. */
+		if (get_dc_child_blocknr(B_N_CHILD(bh, pos)) !=
+		    PATH_OFFSET_PBUFFER(path, offset + 1)->b_blocknr)
+			die("uget_rkey: invalid block number (%d). Must be %ld",
+			    get_dc_child_blocknr(B_N_CHILD(bh, pos)),
+			    PATH_OFFSET_PBUFFER(path, offset + 1)->b_blocknr);
+
+		/* Return delimiting key if position in the parent is not the last one. */
+		if (pos != B_NR_ITEMS(bh))
+			return B_N_PDELIM_KEY(bh, pos);
+	}
+
+	/* there is no right delimiting key */
+	return 0;
 }
 
-struct reiserfs_key *reiserfs_next_key (struct reiserfs_path *path) {
-    if (get_item_pos (path) < B_NR_ITEMS (get_bh (path)) - 1)
-	return B_N_PKEY (get_bh (path), get_item_pos (path) + 1);
+struct reiserfs_key *reiserfs_next_key(struct reiserfs_path *path)
+{
+	if (get_item_pos(path) < B_NR_ITEMS(get_bh(path)) - 1)
+		return B_N_PKEY(get_bh(path), get_item_pos(path) + 1);
 
-    return uget_rkey (path);
+	return uget_rkey(path);
 }
 
-
 /* NOTE: this only should be used to look for keys who exists */
-int reiserfs_search_by_entry_key (reiserfs_filsys_t * fs, struct reiserfs_key *key, 
-				  struct reiserfs_path *path)
+int reiserfs_search_by_entry_key(reiserfs_filsys_t *fs,
+				 struct reiserfs_key *key,
+				 struct reiserfs_path *path)
 {
-    struct buffer_head * bh;
-    int item_pos;
-    struct item_head * ih;
-    struct reiserfs_key tmpkey;
-    __u32 offset;
-
-    if (reiserfs_search_by_key_4 (fs, key, path) == ITEM_FOUND) {
-        path->pos_in_item = 0;
-        return POSITION_FOUND;
-    }
-
-    bh = get_bh (path);
-    item_pos = get_item_pos (path);
-    ih = get_ih (path);
-
-    if (item_pos == 0) {
-	/* key is less than the smallest key in the tree */
-	if (not_of_one_file (&(ih->ih_key), key))
-	    /* there are no items of that directory */
-	    return DIRECTORY_NOT_FOUND;
-
-	if (!is_direntry_ih (ih)) {
-	    reiserfs_panic ("reiserfs_search_by_entry_key: found item "
-			    "is not of directory type %H", ih);
+	struct buffer_head *bh;
+	int item_pos;
+	struct item_head *ih;
+	struct reiserfs_key tmpkey;
+	__u32 offset;
+
+	if (reiserfs_search_by_key_4(fs, key, path) == ITEM_FOUND) {
+		path->pos_in_item = 0;
+		return POSITION_FOUND;
 	}
 
-	/* key we looked for should be here */
-        path->pos_in_item = 0;
+	bh = get_bh(path);
+	item_pos = get_item_pos(path);
+	ih = get_ih(path);
+
+	if (item_pos == 0) {
+		/* key is less than the smallest key in the tree */
+		if (not_of_one_file(&(ih->ih_key), key))
+			/* there are no items of that directory */
+			return DIRECTORY_NOT_FOUND;
+
+		if (!is_direntry_ih(ih)) {
+			reiserfs_panic
+			    ("reiserfs_search_by_entry_key: found item "
+			     "is not of directory type %H", ih);
+		}
+
+		/* key we looked for should be here */
+		path->pos_in_item = 0;
+		return POSITION_NOT_FOUND;
+	}
+
+	/* take previous item */
+	item_pos--;
+	ih--;
+	PATH_LAST_POSITION(path)--;
+
+	if (not_of_one_file(&(ih->ih_key), key) || !is_direntry_ih(ih)) {
+		/* previous item belongs to another object or is stat data, check next
+		   item */
+
+		item_pos++;
+		PATH_LAST_POSITION(path)++;
+
+		if (item_pos < B_NR_ITEMS(bh)) {
+			/* next item is in the same node */
+			ih++;
+			if (not_of_one_file(&(ih->ih_key), key)) {
+				/* there are no items of that directory */
+				path->pos_in_item = 0;
+				return DIRECTORY_NOT_FOUND;
+			}
+
+			if (!is_direntry_ih(ih))
+				reiserfs_panic
+				    ("_search_by_entry_key: %k is not a directory",
+				     key);
+		} else {
+			/* next item is in right neighboring node */
+			struct reiserfs_key *next_key = uget_rkey(path);
+
+			if (next_key == 0 || not_of_one_file(next_key, key)) {
+				/* there are no items of that directory */
+				path->pos_in_item = 0;
+				return DIRECTORY_NOT_FOUND;
+			}
+
+			if (!is_direntry_key(next_key))
+				reiserfs_panic
+				    ("_search_by_entry_key: %k is not a directory",
+				     key);
+
+			/* we got right delimiting key - search for it - the entry will be
+			   pasted in position 0 */
+			copy_key(&tmpkey, next_key);
+			pathrelse(path);
+			if (reiserfs_search_by_key_4(fs, &tmpkey, path) !=
+			    ITEM_FOUND || PATH_LAST_POSITION(path) != 0)
+				reiserfs_panic
+				    ("_search_by_entry_key: item corresponding to delimiting key %k not found",
+				     &tmpkey);
+		}
+
+		/* next item is the part of this directory */
+		path->pos_in_item = 0;
+		return POSITION_NOT_FOUND;
+	}
+
+	/* previous item is part of desired directory */
+	offset = get_key_offset_v1(key);
+	if (reiserfs_bin_search
+	    (&offset, B_I_DEH(bh, ih), get_ih_entry_count(ih), DEH_SIZE,
+	     &(path->pos_in_item), comp_dir_entries) == POSITION_FOUND)
+		return POSITION_FOUND;
+
 	return POSITION_NOT_FOUND;
-    }
-
-    /* take previous item */
-    item_pos --;
-    ih --;
-    PATH_LAST_POSITION (path) --;
-
-    if (not_of_one_file (&(ih->ih_key), key) || !is_direntry_ih (ih)) {
-        /* previous item belongs to another object or is stat data, check next
-           item */
-
-	item_pos ++;
-	PATH_LAST_POSITION (path) ++;
-
-        if (item_pos < B_NR_ITEMS (bh)) {
-	    /* next item is in the same node */
-	    ih ++;
-            if (not_of_one_file (&(ih->ih_key), key)) {
-		/* there are no items of that directory */
-                path->pos_in_item = 0;
-                return DIRECTORY_NOT_FOUND;
-            }
-
-            if (!is_direntry_ih (ih))
-		reiserfs_panic ("_search_by_entry_key: %k is not a directory",
-				key);
-        } else {
-	    /* next item is in right neighboring node */
-            struct reiserfs_key *next_key = uget_rkey (path);
-
-            if (next_key == 0 || not_of_one_file (next_key, key)) {
-                /* there are no items of that directory */
-                path->pos_in_item = 0;
-                return DIRECTORY_NOT_FOUND;
-            }
-
-            if (!is_direntry_key (next_key))
-		reiserfs_panic ("_search_by_entry_key: %k is not a directory",
-				key);
-
-            /* we got right delimiting key - search for it - the entry will be
-	       pasted in position 0 */
-            copy_key (&tmpkey, next_key);
-            pathrelse (path);
-            if (reiserfs_search_by_key_4 (fs, &tmpkey, path) != ITEM_FOUND || PATH_LAST_POSITION (path) != 0)
-                reiserfs_panic ("_search_by_entry_key: item corresponding to delimiting key %k not found",
-				&tmpkey);
-        }
-
-        /* next item is the part of this directory */
-        path->pos_in_item = 0;
-        return POSITION_NOT_FOUND;
-    }
-
-    /* previous item is part of desired directory */
-    offset = get_key_offset_v1 (key);
-    if (reiserfs_bin_search (&offset, B_I_DEH (bh, ih), get_ih_entry_count (ih),
-			     DEH_SIZE, &(path->pos_in_item), comp_dir_entries) == POSITION_FOUND)
-	return POSITION_FOUND;
-
-    return POSITION_NOT_FOUND;
 }
 
-
-void init_tb_struct (struct tree_balance * tb, reiserfs_filsys_t * fs,
-			     struct reiserfs_path *path, int size)
+void init_tb_struct(struct tree_balance *tb, reiserfs_filsys_t *fs,
+		    struct reiserfs_path *path, int size)
 {
-    memset (tb, '\0', sizeof(struct tree_balance));
-    tb->tb_fs = fs;
-    tb->tb_path = path;
+	memset(tb, '\0', sizeof(struct tree_balance));
+	tb->tb_fs = fs;
+	tb->tb_path = path;
 
-    PATH_OFFSET_PBUFFER(path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
-    PATH_OFFSET_POSITION(path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
-    tb->insert_size[0] = size;
+	PATH_OFFSET_PBUFFER(path, ILLEGAL_PATH_ELEMENT_OFFSET) = NULL;
+	PATH_OFFSET_POSITION(path, ILLEGAL_PATH_ELEMENT_OFFSET) = 0;
+	tb->insert_size[0] = size;
 }
 
-
-int reiserfs_remove_entry (reiserfs_filsys_t * fs, struct reiserfs_key *key)
+int reiserfs_remove_entry(reiserfs_filsys_t *fs, struct reiserfs_key *key)
 {
-    struct reiserfs_path path;
-    struct tree_balance tb;
-    struct item_head * ih;
-    struct reiserfs_de_head * deh;
+	struct reiserfs_path path;
+	struct tree_balance tb;
+	struct item_head *ih;
+	struct reiserfs_de_head *deh;
 
-    if (reiserfs_search_by_entry_key (fs, key, &path) != POSITION_FOUND) {
-	pathrelse (&path);
-	return 1;
-    }
-
-    ih = get_ih (&path);
-    if (get_ih_entry_count (ih) == 1) {
-	init_tb_struct (&tb, fs, &path, -(IH_SIZE + get_ih_item_len (ih)));
-	if (fix_nodes (M_DELETE, &tb, 0) != CARRY_ON) {
-	    unfix_nodes (&tb);
-	    return 1;
+	if (reiserfs_search_by_entry_key(fs, key, &path) != POSITION_FOUND) {
+		pathrelse(&path);
+		return 1;
 	}
-	do_balance (&tb, 0, 0, M_DELETE, 0);
-	return 0;
-    }
-
-    deh = B_I_DEH (get_bh (&path), ih) + path.pos_in_item;
-    init_tb_struct (&tb, fs, &path, -(DEH_SIZE + entry_length (ih, deh, path.pos_in_item)));
-    if (fix_nodes (M_CUT, &tb, 0) != CARRY_ON) {
-	unfix_nodes (&tb);
-	return 1;
-    }
-    do_balance (&tb, 0, 0, M_CUT, 0);
-    return 0;
-}
 
+	ih = get_ih(&path);
+	if (get_ih_entry_count(ih) == 1) {
+		init_tb_struct(&tb, fs, &path,
+			       -(IH_SIZE + get_ih_item_len(ih)));
+		if (fix_nodes(M_DELETE, &tb, 0) != CARRY_ON) {
+			unfix_nodes(&tb);
+			return 1;
+		}
+		do_balance(&tb, 0, 0, M_DELETE, 0);
+		return 0;
+	}
 
+	deh = B_I_DEH(get_bh(&path), ih) + path.pos_in_item;
+	init_tb_struct(&tb, fs, &path,
+		       -(DEH_SIZE + entry_length(ih, deh, path.pos_in_item)));
+	if (fix_nodes(M_CUT, &tb, 0) != CARRY_ON) {
+		unfix_nodes(&tb);
+		return 1;
+	}
+	do_balance(&tb, 0, 0, M_CUT, 0);
+	return 0;
+}
 
-void reiserfs_paste_into_item (reiserfs_filsys_t * fs, struct reiserfs_path *path,
-			       const void * body, int size)
+void reiserfs_paste_into_item(reiserfs_filsys_t *fs,
+			      struct reiserfs_path *path, const void *body,
+			      int size)
 {
-    struct tree_balance tb;
-  
-    init_tb_struct (&tb, fs, path, size);
+	struct tree_balance tb;
 
-    if (fix_nodes (M_PASTE, &tb, 0/*ih*/) != CARRY_ON)
-	reiserfs_panic ("reiserfs_paste_into_item: fix_nodes failed");
+	init_tb_struct(&tb, fs, path, size);
 
-    do_balance (&tb, 0, body, M_PASTE, 0/*zero num*/);
-}
+	if (fix_nodes(M_PASTE, &tb, 0 /*ih */ ) != CARRY_ON)
+		reiserfs_panic("reiserfs_paste_into_item: fix_nodes failed");
 
+	do_balance(&tb, 0, body, M_PASTE, 0 /*zero num */ );
+}
 
-void reiserfs_insert_item (reiserfs_filsys_t * fs, struct reiserfs_path *path,
-			   struct item_head * ih, const void * body)
+void reiserfs_insert_item(reiserfs_filsys_t *fs, struct reiserfs_path *path,
+			  struct item_head *ih, const void *body)
 {
-    struct tree_balance tb;
-    
-    init_tb_struct (&tb, fs, path, IH_SIZE + get_ih_item_len(ih));
-    if (fix_nodes (M_INSERT, &tb, ih) != CARRY_ON)
-	die ("reiserfs_insert_item: fix_nodes failed");
+	struct tree_balance tb;
 
-    do_balance (&tb, ih, body, M_INSERT, 0/*zero num*/);
-}
+	init_tb_struct(&tb, fs, path, IH_SIZE + get_ih_item_len(ih));
+	if (fix_nodes(M_INSERT, &tb, ih) != CARRY_ON)
+		die("reiserfs_insert_item: fix_nodes failed");
 
+	do_balance(&tb, ih, body, M_INSERT, 0 /*zero num */ );
+}
 
 /*===========================================================================*/
 
-__u32 hash_value (hashf_t func, char * name, int namelen)
+__u32 hash_value(hashf_t func, char *name, int namelen)
 {
-    __u32 res;
+	__u32 res;
 
-    res = func (name, namelen);
-    res = GET_HASH_VALUE(res);
-    if (res == 0)
-	res = 128;
+	res = func(name, namelen);
+	res = GET_HASH_VALUE(res);
+	if (res == 0)
+		res = 128;
 
-    return res;
+	return res;
 }
 
-
 /* if name is found in a directory - return 1 and set path to the name,
    otherwise return 0 and pathrelse path */
-int reiserfs_locate_entry (reiserfs_filsys_t * fs, struct reiserfs_key *dir, char * name,
-			   struct reiserfs_path *path)
+int reiserfs_locate_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
+			  char *name, struct reiserfs_path *path)
 {
-    struct reiserfs_key entry_key;
-    struct item_head * ih;
-    struct reiserfs_de_head * deh;
-    int i, retval;
-    struct reiserfs_key *rdkey;
-    
-    set_key_dirid (&entry_key, get_key_dirid (dir));
-    set_key_objectid (&entry_key, get_key_objectid (dir));
-    set_key_offset_v1 (&entry_key, 0);
-    set_key_uniqueness (&entry_key, DIRENTRY_UNIQUENESS);
-
- 
-    if (reiserfs_search_by_entry_key (fs, &entry_key, path) == DIRECTORY_NOT_FOUND) {
-	pathrelse (path);
-	return 0;
-    }
-
-    do {
-	ih = get_ih (path);
-	deh = B_I_DEH (get_bh (path), ih) + path->pos_in_item;
-	for (i = path->pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
-	    /* the name in directory has the same hash as the given name */
-	    if ((name_in_entry_length (ih, deh, i) == (int)strlen (name)) &&
-		!memcmp (name_in_entry (deh, i), name, strlen (name))) {
-		path->pos_in_item = i;
-		return 1;
-	    }
+	struct reiserfs_key entry_key;
+	struct item_head *ih;
+	struct reiserfs_de_head *deh;
+	int i, retval;
+	struct reiserfs_key *rdkey;
+
+	set_key_dirid(&entry_key, get_key_dirid(dir));
+	set_key_objectid(&entry_key, get_key_objectid(dir));
+	set_key_offset_v1(&entry_key, 0);
+	set_key_uniqueness(&entry_key, DIRENTRY_UNIQUENESS);
+
+	if (reiserfs_search_by_entry_key(fs, &entry_key, path) ==
+	    DIRECTORY_NOT_FOUND) {
+		pathrelse(path);
+		return 0;
 	}
 
-	rdkey = uget_rkey (path);
-	if (!rdkey || not_of_one_file (rdkey, dir)) {
-	    pathrelse (path);
-	    return 0;
-	}
-	
-	if (!is_direntry_key (rdkey))
-	    reiserfs_panic ("reiserfs_locate_entry: can not find name in broken directory yet");
+	do {
+		ih = get_ih(path);
+		deh = B_I_DEH(get_bh(path), ih) + path->pos_in_item;
+		for (i = path->pos_in_item; i < get_ih_entry_count(ih);
+		     i++, deh++) {
+			/* the name in directory has the same hash as the given name */
+			if ((name_in_entry_length(ih, deh, i) ==
+			     (int)strlen(name))
+			    && !memcmp(name_in_entry(deh, i), name,
+				       strlen(name))) {
+				path->pos_in_item = i;
+				return 1;
+			}
+		}
 
-	/* first name of that item may be a name we are looking for */
-	entry_key = *rdkey;
-	pathrelse (path);
-	retval = reiserfs_search_by_entry_key (fs, &entry_key, path);
-	if (retval != POSITION_FOUND)
-	    reiserfs_panic ("reiserfs_locate_entry: wrong delimiting key in the tree");
+		rdkey = uget_rkey(path);
+		if (!rdkey || not_of_one_file(rdkey, dir)) {
+			pathrelse(path);
+			return 0;
+		}
 
-    } while (1);
+		if (!is_direntry_key(rdkey))
+			reiserfs_panic
+			    ("reiserfs_locate_entry: can not find name in broken directory yet");
 
-    return 0;
-    
-}
+		/* first name of that item may be a name we are looking for */
+		entry_key = *rdkey;
+		pathrelse(path);
+		retval = reiserfs_search_by_entry_key(fs, &entry_key, path);
+		if (retval != POSITION_FOUND)
+			reiserfs_panic
+			    ("reiserfs_locate_entry: wrong delimiting key in the tree");
 
+	} while (1);
+
+	return 0;
+
+}
 
 /* returns 0 if name is not found in a directory and 1 if name is
    found. Stores key found in the entry in 'key'. Returns minimal not used
    generation counter in 'min_gen_counter'. dies if found object is not a
    directory. */
-int reiserfs_find_entry (reiserfs_filsys_t * fs, struct reiserfs_key *dir, char * name, 
-			 unsigned int * min_gen_counter, struct reiserfs_key *key)
+int reiserfs_find_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
+			char *name, unsigned int *min_gen_counter,
+			struct reiserfs_key *key)
 {
-    struct reiserfs_key entry_key;
-    int retval;
-    int i;
-    INITIALIZE_REISERFS_PATH(path);
-    struct item_head * ih;
-    struct reiserfs_de_head * deh;
-    struct reiserfs_key *rdkey;
-    __u32 hash;
-
-
-    set_key_dirid (&entry_key, get_key_dirid (dir));
-    set_key_objectid (&entry_key, get_key_objectid (dir));
-    if (!strcmp (name, "."))
-	hash = DOT_OFFSET;
-    else if (!strcmp (name, ".."))
-	hash = DOT_DOT_OFFSET;
-    else
-	hash = hash_value (reiserfs_hash (fs), name, strlen (name));
-    set_key_offset_v1 (&entry_key, hash);
-    set_key_uniqueness (&entry_key, DIRENTRY_UNIQUENESS);
+	struct reiserfs_key entry_key;
+	int retval;
+	int i;
+	INITIALIZE_REISERFS_PATH(path);
+	struct item_head *ih;
+	struct reiserfs_de_head *deh;
+	struct reiserfs_key *rdkey;
+	__u32 hash;
+
+	set_key_dirid(&entry_key, get_key_dirid(dir));
+	set_key_objectid(&entry_key, get_key_objectid(dir));
+	if (!strcmp(name, "."))
+		hash = DOT_OFFSET;
+	else if (!strcmp(name, ".."))
+		hash = DOT_DOT_OFFSET;
+	else
+		hash = hash_value(reiserfs_hash(fs), name, strlen(name));
+	set_key_offset_v1(&entry_key, hash);
+	set_key_uniqueness(&entry_key, DIRENTRY_UNIQUENESS);
 
-    *min_gen_counter = 0;
+	*min_gen_counter = 0;
 
-    if (reiserfs_search_by_entry_key (fs, &entry_key, &path) == DIRECTORY_NOT_FOUND) {
-	pathrelse (&path);
-	return 0;
-    }
-	
-    do {
-	ih = get_ih (&path);
-	deh = B_I_DEH (get_bh (&path), ih) + path.pos_in_item;
-	for (i = path.pos_in_item; i < get_ih_entry_count (ih); i ++, deh ++) {
-	    if (GET_HASH_VALUE (get_deh_offset (deh)) != GET_HASH_VALUE (hash)) {
-		/* all entries having the same hash were scanned */
-		pathrelse (&path);
+	if (reiserfs_search_by_entry_key(fs, &entry_key, &path) ==
+	    DIRECTORY_NOT_FOUND) {
+		pathrelse(&path);
 		return 0;
-	    }
-			
-	    if (GET_GENERATION_NUMBER (get_deh_offset (deh)) == *min_gen_counter)
-		(*min_gen_counter) ++;
-			
-	    if ((name_in_entry_length (ih, deh, i) == (int)strlen (name)) &&
-	        (!memcmp (name_in_entry (deh, i), name, strlen (name)))) {
-		/* entry found in the directory */
-		if (key) {
-		    memset (key, 0, sizeof (struct reiserfs_key));
-		    set_key_dirid (key, get_deh_dirid (deh));
-		    set_key_objectid (key, get_deh_objectid (deh));
-		}
-		pathrelse (&path);
-		return 1;//get_deh_objectid (deh) ? get_deh_objectid (deh) : 1;
-	    }
 	}
-		
-	rdkey = uget_rkey (&path);
-	if (!rdkey || not_of_one_file (rdkey, dir)) {
-	    pathrelse (&path);
-	    return 0;
-	}
-		
-	if (!is_direntry_key (rdkey))
-	    reiserfs_panic ("reiserfs_find_entry: can not find name in broken directory yet");
-		
-	/* next item is the item of the directory we are looking name in */
-	if (GET_HASH_VALUE (get_offset (rdkey)) != hash) {
-	    /* but there is no names with given hash */
-	    pathrelse (&path);
-	    return 0;
-	}
-		
-	/* first name of that item may be a name we are looking for */
-	entry_key = *rdkey;
-	pathrelse (&path);
-	retval = reiserfs_search_by_entry_key (fs, &entry_key, &path);
-	if (retval != POSITION_FOUND)
-	    reiserfs_panic ("reiserfs_find_entry: wrong delimiting key in the tree");
-		
-    } while (1);
-    
-    return 0;
-}
 
+	do {
+		ih = get_ih(&path);
+		deh = B_I_DEH(get_bh(&path), ih) + path.pos_in_item;
+		for (i = path.pos_in_item; i < get_ih_entry_count(ih);
+		     i++, deh++) {
+			if (GET_HASH_VALUE(get_deh_offset(deh)) !=
+			    GET_HASH_VALUE(hash)) {
+				/* all entries having the same hash were scanned */
+				pathrelse(&path);
+				return 0;
+			}
+
+			if (GET_GENERATION_NUMBER(get_deh_offset(deh)) ==
+			    *min_gen_counter)
+				(*min_gen_counter)++;
+
+			if ((name_in_entry_length(ih, deh, i) ==
+			     (int)strlen(name))
+			    &&
+			    (!memcmp
+			     (name_in_entry(deh, i), name, strlen(name)))) {
+				/* entry found in the directory */
+				if (key) {
+					memset(key, 0,
+					       sizeof(struct reiserfs_key));
+					set_key_dirid(key, get_deh_dirid(deh));
+					set_key_objectid(key,
+							 get_deh_objectid(deh));
+				}
+				pathrelse(&path);
+				return 1;	//get_deh_objectid (deh) ? get_deh_objectid (deh) : 1;
+			}
+		}
+
+		rdkey = uget_rkey(&path);
+		if (!rdkey || not_of_one_file(rdkey, dir)) {
+			pathrelse(&path);
+			return 0;
+		}
+
+		if (!is_direntry_key(rdkey))
+			reiserfs_panic
+			    ("reiserfs_find_entry: can not find name in broken directory yet");
+
+		/* next item is the item of the directory we are looking name in */
+		if (GET_HASH_VALUE(get_offset(rdkey)) != hash) {
+			/* but there is no names with given hash */
+			pathrelse(&path);
+			return 0;
+		}
+
+		/* first name of that item may be a name we are looking for */
+		entry_key = *rdkey;
+		pathrelse(&path);
+		retval = reiserfs_search_by_entry_key(fs, &entry_key, &path);
+		if (retval != POSITION_FOUND)
+			reiserfs_panic
+			    ("reiserfs_find_entry: wrong delimiting key in the tree");
+
+	} while (1);
+
+	return 0;
+}
 
 /* compose directory entry: dir entry head and name itself */
-char * make_entry (char * entry, char * name, struct reiserfs_key *key, __u32 offset)
+char *make_entry(char *entry, char *name, struct reiserfs_key *key,
+		 __u32 offset)
 {
-    struct reiserfs_de_head * deh;
-    __u16 state;
-	
-    if (!entry)
-	entry = getmem (DEH_SIZE + ROUND_UP (strlen (name)));
-
-    memset (entry, 0, DEH_SIZE + ROUND_UP (strlen (name)));
-    deh = (struct reiserfs_de_head *)entry;
-	
-    set_deh_location (deh, 0);
-    set_deh_offset (deh, offset);
-    state = (1 << DEH_Visible2);
-    set_deh_state (deh, state);
-	
-    /* key of object entry will point to */
-    set_deh_dirid (deh, get_key_dirid (key));
-    set_deh_objectid (deh, get_key_objectid (key));
-	
-    memcpy ((char *)(deh + 1), name, strlen (name));
-    return entry;
-}
+	struct reiserfs_de_head *deh;
+	__u16 state;
+
+	if (!entry)
+		entry = getmem(DEH_SIZE + ROUND_UP(strlen(name)));
+
+	memset(entry, 0, DEH_SIZE + ROUND_UP(strlen(name)));
+	deh = (struct reiserfs_de_head *)entry;
+
+	set_deh_location(deh, 0);
+	set_deh_offset(deh, offset);
+	state = (1 << DEH_Visible2);
+	set_deh_state(deh, state);
 
+	/* key of object entry will point to */
+	set_deh_dirid(deh, get_key_dirid(key));
+	set_deh_objectid(deh, get_key_objectid(key));
+
+	memcpy((char *)(deh + 1), name, strlen(name));
+	return entry;
+}
 
 /* add new name into a directory. If it exists in a directory - do
    nothing */
-int reiserfs_add_entry (reiserfs_filsys_t * fs, struct reiserfs_key *dir, char * name, int name_len,
-			struct reiserfs_key *key, __u16 fsck_need)
+int reiserfs_add_entry(reiserfs_filsys_t *fs, struct reiserfs_key *dir,
+		       char *name, int name_len, struct reiserfs_key *key,
+		       __u16 fsck_need)
 {
-    struct item_head entry_ih = {{0,}, };
-    char * entry;
-    int retval;
-    INITIALIZE_REISERFS_PATH(path);
-    unsigned int gen_counter;
-    int item_len;
-    __u32 hash;
-
-    if (reiserfs_find_entry (fs, dir, name, &gen_counter, 0))
-	/* entry is in the directory already or directory was not found */
-	return 0;
+	struct item_head entry_ih = { {0,}, };
+	char *entry;
+	int retval;
+	INITIALIZE_REISERFS_PATH(path);
+	unsigned int gen_counter;
+	int item_len;
+	__u32 hash;
+
+	if (reiserfs_find_entry(fs, dir, name, &gen_counter, 0))
+		/* entry is in the directory already or directory was not found */
+		return 0;
 
-    /* compose entry key to look for its place in the tree */
-    set_key_dirid (&(entry_ih.ih_key), get_key_dirid (dir));
-    set_key_objectid (&(entry_ih.ih_key), get_key_objectid (dir));
-    if (!strcmp (name, "."))
-	hash = DOT_OFFSET;
-    else if (!strcmp (name, ".."))
-	hash = DOT_DOT_OFFSET;
-    else
-	hash = hash_value (reiserfs_hash (fs), name, strlen (name)) + gen_counter;
-    set_key_offset_v1 (&(entry_ih.ih_key), hash);
-    set_key_uniqueness (&(entry_ih.ih_key), DIRENTRY_UNIQUENESS);
+	/* compose entry key to look for its place in the tree */
+	set_key_dirid(&(entry_ih.ih_key), get_key_dirid(dir));
+	set_key_objectid(&(entry_ih.ih_key), get_key_objectid(dir));
+	if (!strcmp(name, "."))
+		hash = DOT_OFFSET;
+	else if (!strcmp(name, ".."))
+		hash = DOT_DOT_OFFSET;
+	else
+		hash =
+		    hash_value(reiserfs_hash(fs), name,
+			       strlen(name)) + gen_counter;
+	set_key_offset_v1(&(entry_ih.ih_key), hash);
+	set_key_uniqueness(&(entry_ih.ih_key), DIRENTRY_UNIQUENESS);
 
-    set_ih_key_format (&entry_ih, KEY_FORMAT_1);
-    set_ih_entry_count (&entry_ih, 1);
+	set_ih_key_format(&entry_ih, KEY_FORMAT_1);
+	set_ih_entry_count(&entry_ih, 1);
 
-    item_len = DEH_SIZE + name_len;
+	item_len = DEH_SIZE + name_len;
 /*
     if (get_reiserfs_format (fs->fs_ondisk_sb) == REISERFS_FORMAT_3_5)
 	item_len = DEH_SIZE + strlen (name);
@@ -1081,387 +1112,396 @@ int reiserfs_add_entry (reiserfs_filsys_t * fs, struct reiserfs_key *dir, char *
 	reiserfs_panic ("unknown fs format");
 */
 
-    set_ih_item_len (&entry_ih, item_len);
+	set_ih_item_len(&entry_ih, item_len);
 
-    /* fsck may need to insert item which was not reached yet */
-    set_ih_flags (&entry_ih, fsck_need);
+	/* fsck may need to insert item which was not reached yet */
+	set_ih_flags(&entry_ih, fsck_need);
 
-    entry = make_entry (0, name, key, get_offset (&(entry_ih.ih_key)));
+	entry = make_entry(0, name, key, get_offset(&(entry_ih.ih_key)));
 
-    retval = reiserfs_search_by_entry_key (fs, &(entry_ih.ih_key), &path);
-    switch (retval) {
-    case POSITION_NOT_FOUND:
-	reiserfs_paste_into_item (fs, &path, entry, item_len);
-	break;
+	retval = reiserfs_search_by_entry_key(fs, &(entry_ih.ih_key), &path);
+	switch (retval) {
+	case POSITION_NOT_FOUND:
+		reiserfs_paste_into_item(fs, &path, entry, item_len);
+		break;
 
-    case DIRECTORY_NOT_FOUND:
-	set_deh_location ((struct reiserfs_de_head *)entry, DEH_SIZE);
-	reiserfs_insert_item (fs, &path, &entry_ih, entry);
-	break;
+	case DIRECTORY_NOT_FOUND:
+		set_deh_location((struct reiserfs_de_head *)entry, DEH_SIZE);
+		reiserfs_insert_item(fs, &path, &entry_ih, entry);
+		break;
 
-    default:
-	reiserfs_panic ("reiserfs_add_entry: looking for %k (inserting name \"%s\") "
-			"search_by_entry_key returned %d",
-			&(entry_ih.ih_key), name, retval);
-    }
+	default:
+		reiserfs_panic
+		    ("reiserfs_add_entry: looking for %k (inserting name \"%s\") "
+		     "search_by_entry_key returned %d", &(entry_ih.ih_key),
+		     name, retval);
+	}
 
-    freemem (entry);
-    return item_len;
+	freemem(entry);
+	return item_len;
 }
 
-
-void copy_key (void * to, void * from)
+void copy_key(void *to, void *from)
 {
-    memcpy (to, from, KEY_SIZE);
+	memcpy(to, from, KEY_SIZE);
 }
 
-
-void copy_short_key (void * to, void * from)
+void copy_short_key(void *to, void *from)
 {
-    memcpy (to, from, SHORT_KEY_SIZE);
+	memcpy(to, from, SHORT_KEY_SIZE);
 }
 
-
-void copy_item_head(void * p_v_to, void * p_v_from)
+void copy_item_head(void *p_v_to, void *p_v_from)
 {
-    memcpy (p_v_to, p_v_from, IH_SIZE);
+	memcpy(p_v_to, p_v_from, IH_SIZE);
 }
 
-
 /* inserts new or old stat data of a directory (unreachable, nlinks == 0) */
-int create_dir_sd (reiserfs_filsys_t * fs,
-		    struct reiserfs_path *path, struct reiserfs_key *key,
-		    void (*modify_item)(struct item_head *, void *))
+int create_dir_sd(reiserfs_filsys_t *fs,
+		  struct reiserfs_path *path, struct reiserfs_key *key,
+		  void (*modify_item) (struct item_head *, void *))
 {
-    struct item_head ih;
-    struct stat_data sd;
-    int key_format;
+	struct item_head ih;
+	struct stat_data sd;
+	int key_format;
 
-    if (fs->fs_format == REISERFS_FORMAT_3_5)
-	key_format = KEY_FORMAT_1;
-    else
-	key_format = KEY_FORMAT_2;
-
-    memset(&sd, 0, sizeof(sd));
-    make_dir_stat_data (fs->fs_blocksize, key_format, get_key_dirid (key),
-			get_key_objectid (key), &ih, &sd);
-    
-    /* if calling user is not root set the owner of the root entry
-     * to the calling user */
-    if(getuid()) {
-	if (key_format == KEY_FORMAT_1) {
-	    struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)&sd;
-	    set_sd_v1_uid (sd_v1, getuid());
-	    set_sd_v1_gid (sd_v1, getgid());
-	} else {
-	    set_sd_v2_uid (&sd, getuid());
-	    set_sd_v2_gid (&sd, getgid());
+	if (fs->fs_format == REISERFS_FORMAT_3_5)
+		key_format = KEY_FORMAT_1;
+	else
+		key_format = KEY_FORMAT_2;
+
+	memset(&sd, 0, sizeof(sd));
+	make_dir_stat_data(fs->fs_blocksize, key_format, get_key_dirid(key),
+			   get_key_objectid(key), &ih, &sd);
+
+	/* if calling user is not root set the owner of the root entry
+	 * to the calling user */
+	if (getuid()) {
+		if (key_format == KEY_FORMAT_1) {
+			struct stat_data_v1 *sd_v1 = (struct stat_data_v1 *)&sd;
+			set_sd_v1_uid(sd_v1, getuid());
+			set_sd_v1_gid(sd_v1, getgid());
+		} else {
+			set_sd_v2_uid(&sd, getuid());
+			set_sd_v2_gid(&sd, getgid());
+		}
 	}
-    }
 
-    if (modify_item)
-	modify_item (&ih, &sd);
+	if (modify_item)
+		modify_item(&ih, &sd);
 #if 0
-    /* set nlink count to 0 and make the item unreachable */
-    zero_nlink (&ih, &sd, 0);
-    mark_item_unreachable (&ih);
+	/* set nlink count to 0 and make the item unreachable */
+	zero_nlink(&ih, &sd, 0);
+	mark_item_unreachable(&ih);
 #endif
-    reiserfs_insert_item (fs, path, &ih, &sd);
-    return key_format;
+	reiserfs_insert_item(fs, path, &ih, &sd);
+	return key_format;
 }
 
+void make_sure_root_dir_exists(reiserfs_filsys_t *fs,
+			       void (*modify_item) (struct item_head *, void *),
+			       int ih_flags)
+{
+	INITIALIZE_REISERFS_PATH(path);
 
+	/* is there root's stat data */
+	if (reiserfs_search_by_key_4(fs, &root_dir_key, &path) ==
+	    ITEM_NOT_FOUND) {
+		root_dir_format =
+		    create_dir_sd(fs, &path, &root_dir_key, modify_item);
+	} else {
+		struct item_head *ih = get_ih(&path);
 
-void make_sure_root_dir_exists (reiserfs_filsys_t * fs,
-				void (*modify_item)(struct item_head *, void *),
-				int ih_flags)
-{
-    INITIALIZE_REISERFS_PATH(path);
-
-
-    /* is there root's stat data */
-    if (reiserfs_search_by_key_4 (fs, &root_dir_key, &path) == ITEM_NOT_FOUND) {	
-	root_dir_format = create_dir_sd (fs, &path, &root_dir_key, modify_item);
-    } else {
-    	struct item_head * ih = get_ih (&path);
-    	
-    	if (!is_stat_data_ih (ih))
-	    reiserfs_panic ("It must be root's stat data %k\n", &ih->ih_key);
-	
-        root_dir_format = (get_ih_item_len (get_ih (&path)) == SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
-	pathrelse (&path);
-    }
-
-    /* add "." and ".." if any of them do not exist. Last two
-       parameters say: 0 - entry is not added on lost_found pass and 1
-       - mark item unreachable */
-
-    reiserfs_add_entry (fs, &root_dir_key, ".", name_length (".", root_dir_format),
-    		&root_dir_key, ih_flags);
-    reiserfs_add_entry (fs, &root_dir_key, "..", name_length ("..", root_dir_format),
-    		&parent_root_dir_key, ih_flags);
+		if (!is_stat_data_ih(ih))
+			reiserfs_panic("It must be root's stat data %k\n",
+				       &ih->ih_key);
+
+		root_dir_format =
+		    (get_ih_item_len(get_ih(&path)) ==
+		     SD_SIZE) ? KEY_FORMAT_2 : KEY_FORMAT_1;
+		pathrelse(&path);
+	}
+
+	/* add "." and ".." if any of them do not exist. Last two
+	   parameters say: 0 - entry is not added on lost_found pass and 1
+	   - mark item unreachable */
+
+	reiserfs_add_entry(fs, &root_dir_key, ".",
+			   name_length(".", root_dir_format), &root_dir_key,
+			   ih_flags);
+	reiserfs_add_entry(fs, &root_dir_key, "..",
+			   name_length("..", root_dir_format),
+			   &parent_root_dir_key, ih_flags);
 }
 
-int block_size_ok (int blocksize, int force)
+int block_size_ok(int blocksize, int force)
 {
-    int pagesize = getpagesize();
-    if (blocksize > 4096) {
-        reiserfs_warning (stderr, "Block sizes larger than 4k are not "
-                          "supported on all architectures.\n");
-        if (blocksize > pagesize)
-            reiserfs_warning (stderr, "The newly created filesystem will not "
-                              "be mountable on this system.\n");
-        else
-            reiserfs_warning (stderr, "The newly created filesystem may not "
-                              "be mountable on other systems.\n");
-        check_forcing_ask_confirmation (force);
-    } else if (blocksize < 4096) {
-        reiserfs_warning (stderr, "Block sizes smaller than 4k "
-			  "are not supported.\n");
-	return 0;
-    }
+	int pagesize = getpagesize();
+	if (blocksize > 4096) {
+		reiserfs_warning(stderr, "Block sizes larger than 4k are not "
+				 "supported on all architectures.\n");
+		if (blocksize > pagesize)
+			reiserfs_warning(stderr,
+					 "The newly created filesystem will not "
+					 "be mountable on this system.\n");
+		else
+			reiserfs_warning(stderr,
+					 "The newly created filesystem may not "
+					 "be mountable on other systems.\n");
+		check_forcing_ask_confirmation(force);
+	} else if (blocksize < 4096) {
+		reiserfs_warning(stderr, "Block sizes smaller than 4k "
+				 "are not supported.\n");
+		return 0;
+	}
 
-    return 1;
+	return 1;
 }
 
-
 /* we only can use a file for filesystem or journal if it is either not
    mounted block device or regular file and we are forced to use it */
-int can_we_format_it (char * device_name, int force)
+int can_we_format_it(char *device_name, int force)
 {
-    mode_t mode;
-    dev_t rdev;
-
-
-    if (misc_device_mounted(device_name) > 0) {
-	/* device looks mounted */
-	reiserfs_warning (stderr, "'%s' looks mounted.", device_name);
-	check_forcing_ask_confirmation (force);
-    }
-
-    mode = misc_device_mode(device_name);
-    rdev = misc_device_rdev(device_name);
-
-    if (!S_ISBLK (mode)) {
-	/* file is not a block device */
-	reiserfs_warning (stderr, "%s is not a block special device\n", device_name);
-	check_forcing_ask_confirmation (force);
-    } else {
-	if ((IDE_DISK_MAJOR (major(rdev)) && minor(rdev) % 64 == 0) ||
-	    (SCSI_BLK_MAJOR (major(rdev)) && minor(rdev) % 16 == 0)) {
-	    /* /dev/hda or similar */
-	    reiserfs_warning (stderr, "%s is entire device, not just one partition!\n",
-		    device_name);
-	    check_forcing_ask_confirmation (force);
+	mode_t mode;
+	dev_t rdev;
+
+	if (misc_device_mounted(device_name) > 0) {
+		/* device looks mounted */
+		reiserfs_warning(stderr, "'%s' looks mounted.", device_name);
+		check_forcing_ask_confirmation(force);
 	}
-    }
 
-    return 1;
+	mode = misc_device_mode(device_name);
+	rdev = misc_device_rdev(device_name);
+
+	if (!S_ISBLK(mode)) {
+		/* file is not a block device */
+		reiserfs_warning(stderr, "%s is not a block special device\n",
+				 device_name);
+		check_forcing_ask_confirmation(force);
+	} else {
+		if ((IDE_DISK_MAJOR(major(rdev)) && minor(rdev) % 64 == 0) ||
+		    (SCSI_BLK_MAJOR(major(rdev)) && minor(rdev) % 16 == 0)) {
+			/* /dev/hda or similar */
+			reiserfs_warning(stderr,
+					 "%s is entire device, not just one partition!\n",
+					 device_name);
+			check_forcing_ask_confirmation(force);
+		}
+	}
+
+	return 1;
 }
 
-int create_badblock_bitmap (reiserfs_filsys_t * fs, char * badblocks_file) {
-    FILE * fd;
-    char buf[128];
-    __u32 blocknr;
-    int count;
+int create_badblock_bitmap(reiserfs_filsys_t *fs, char *badblocks_file)
+{
+	FILE *fd;
+	char buf[128];
+	__u32 blocknr;
+	int count;
 
-    fs->fs_badblocks_bm = reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
-    reiserfs_bitmap_zero (fs->fs_badblocks_bm);
+	fs->fs_badblocks_bm =
+	    reiserfs_create_bitmap(get_sb_block_count(fs->fs_ondisk_sb));
+	reiserfs_bitmap_zero(fs->fs_badblocks_bm);
 
-    if (!badblocks_file)
-	return 0;
-    
-    fd = fopen (badblocks_file, "r");
-
-    if (fd == NULL) {
-        fprintf (stderr, "%s: Failed to open the given badblock file '%s'.\n\n",
-        	__FUNCTION__, badblocks_file);
-        return 1;
-    }
-
-
-    while (!feof (fd)) {
-	if (fgets(buf, sizeof(buf), fd) == NULL)
-	    break;
-	count = sscanf(buf, "%u", &blocknr);
-	
-	if (count <= 0)
-	    continue;
-
-	if (blocknr >= get_sb_block_count (fs->fs_ondisk_sb)) {
-	    fprintf (stderr, "%s: block number (%u) points out of fs size "
-		     "(%u).\n", __FUNCTION__, blocknr, 
-		     get_sb_block_count(fs->fs_ondisk_sb));
-	} else if (not_data_block (fs, blocknr)) {
-	    fprintf (stderr, "%s: block number (%u) belongs to system "
-		     "reiserfs area. It cannot be relocated.\n", 
-		     __FUNCTION__, blocknr);
-	    return 1;
-	} else {
-	    reiserfs_bitmap_set_bit (fs->fs_badblocks_bm, blocknr);
-	} 
-    }
+	if (!badblocks_file)
+		return 0;
+
+	fd = fopen(badblocks_file, "r");
 
-    fclose (fd);
+	if (fd == NULL) {
+		fprintf(stderr,
+			"%s: Failed to open the given badblock file '%s'.\n\n",
+			__FUNCTION__, badblocks_file);
+		return 1;
+	}
 
-    return 0;
+	while (!feof(fd)) {
+		if (fgets(buf, sizeof(buf), fd) == NULL)
+			break;
+		count = sscanf(buf, "%u", &blocknr);
+
+		if (count <= 0)
+			continue;
+
+		if (blocknr >= get_sb_block_count(fs->fs_ondisk_sb)) {
+			fprintf(stderr,
+				"%s: block number (%u) points out of fs size "
+				"(%u).\n", __FUNCTION__, blocknr,
+				get_sb_block_count(fs->fs_ondisk_sb));
+		} else if (not_data_block(fs, blocknr)) {
+			fprintf(stderr,
+				"%s: block number (%u) belongs to system "
+				"reiserfs area. It cannot be relocated.\n",
+				__FUNCTION__, blocknr);
+			return 1;
+		} else {
+			reiserfs_bitmap_set_bit(fs->fs_badblocks_bm, blocknr);
+		}
+	}
+
+	fclose(fd);
+
+	return 0;
 }
 
-void badblock_list(reiserfs_filsys_t * fs, badblock_func_t action, void *data) {
-    struct reiserfs_path badblock_path;
-    struct reiserfs_key rd_key = badblock_key;
-    struct reiserfs_key *key;
-    
-    badblock_path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
-    set_type_and_offset (KEY_FORMAT_2, &badblock_key, 1, TYPE_INDIRECT);
-    
-    while (1) {
-	    if (reiserfs_search_by_key_4 (fs, &rd_key, &badblock_path) == IO_ERROR) {
-		fprintf (stderr, "%s: Some problems while searching by the key "
-			 "occured. Probably due to tree corruptions.\n",
-			 __FUNCTION__);
-		pathrelse (&badblock_path);
-		break;
-	    }
-		    
+void badblock_list(reiserfs_filsys_t *fs, badblock_func_t action, void *data)
+{
+	struct reiserfs_path badblock_path;
+	struct reiserfs_key rd_key = badblock_key;
+	struct reiserfs_key *key;
+
+	badblock_path.path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
+	set_type_and_offset(KEY_FORMAT_2, &badblock_key, 1, TYPE_INDIRECT);
+
+	while (1) {
+		if (reiserfs_search_by_key_4(fs, &rd_key, &badblock_path) ==
+		    IO_ERROR) {
+			fprintf(stderr,
+				"%s: Some problems while searching by the key "
+				"occured. Probably due to tree corruptions.\n",
+				__FUNCTION__);
+			pathrelse(&badblock_path);
+			break;
+		}
 
-	    if (get_blkh_nr_items (B_BLK_HEAD (get_bh (&badblock_path))) <= 
-		PATH_LAST_POSITION (&badblock_path)) 
-	    {
-		pathrelse (&badblock_path);
-		break;
-	    }
+		if (get_blkh_nr_items(B_BLK_HEAD(get_bh(&badblock_path))) <=
+		    PATH_LAST_POSITION(&badblock_path)) {
+			pathrelse(&badblock_path);
+			break;
+		}
 
-	    rd_key = get_ih(&badblock_path)->ih_key;
+		rd_key = get_ih(&badblock_path)->ih_key;
 
-	    if (get_key_dirid(&rd_key) != BADBLOCK_DIRID || 
-		get_key_objectid(&rd_key) != BADBLOCK_OBJID ||
-		!KEY_IS_INDIRECT_KEY(&rd_key)) 
-	    {
-		pathrelse (&badblock_path);
-		break;
-	    }
-	
-	    if ((key = reiserfs_next_key(&badblock_path)))
-		rd_key = *key;
-	    else
-	        memset(&rd_key, 0, sizeof(rd_key));
-	    
-	    action(fs, &badblock_path, data);
-
-	    if (get_key_dirid(&rd_key) == 0)
-		break;
-    }
+		if (get_key_dirid(&rd_key) != BADBLOCK_DIRID ||
+		    get_key_objectid(&rd_key) != BADBLOCK_OBJID ||
+		    !KEY_IS_INDIRECT_KEY(&rd_key)) {
+			pathrelse(&badblock_path);
+			break;
+		}
+
+		if ((key = reiserfs_next_key(&badblock_path)))
+			rd_key = *key;
+		else
+			memset(&rd_key, 0, sizeof(rd_key));
+
+		action(fs, &badblock_path, data);
+
+		if (get_key_dirid(&rd_key) == 0)
+			break;
+	}
 }
 
 static void callback_badblock_rm(reiserfs_filsys_t *fs,
-				 struct reiserfs_path *badblock_path, 
-				 void *data) 
+				 struct reiserfs_path *badblock_path,
+				 void *data)
 {
 	struct tree_balance tb;
-	struct item_head * tmp_ih;
+	struct item_head *tmp_ih;
 
 	tmp_ih = get_ih(badblock_path);
-	memset (get_item (badblock_path), 0, get_ih_item_len (tmp_ih));
+	memset(get_item(badblock_path), 0, get_ih_item_len(tmp_ih));
 
-	init_tb_struct (&tb, fs, badblock_path, 
-			-(IH_SIZE + get_ih_item_len(PATH_PITEM_HEAD(badblock_path))));
+	init_tb_struct(&tb, fs, badblock_path,
+		       -(IH_SIZE +
+			 get_ih_item_len(PATH_PITEM_HEAD(badblock_path))));
 
-	if (fix_nodes (M_DELETE, &tb, 0) != CARRY_ON)
-		die ("%s: fix_nodes failed", __FUNCTION__);
+	if (fix_nodes(M_DELETE, &tb, 0) != CARRY_ON)
+		die("%s: fix_nodes failed", __FUNCTION__);
 
-	do_balance (/*tb.transaction_handle,*/ &tb, 0, 0, M_DELETE, 0/*zero num*/);
+	do_balance( /*tb.transaction_handle, */ &tb, 0, 0, M_DELETE,
+		   0 /*zero num */ );
 }
 
-void mark_badblock(reiserfs_filsys_t *fs, 
-		   struct reiserfs_path *badblock_path, 
-		   void *data) 
+void mark_badblock(reiserfs_filsys_t *fs,
+		   struct reiserfs_path *badblock_path, void *data)
 {
 	struct item_head *tmp_ih;
 	__u32 *ind_item;
 	__u32 i;
 
 	if (!fs->fs_badblocks_bm)
-	    create_badblock_bitmap(fs, NULL);
-	
+		create_badblock_bitmap(fs, NULL);
+
 	tmp_ih = get_ih(badblock_path);
-	ind_item = (__u32 *)get_item(badblock_path);
+	ind_item = (__u32 *) get_item(badblock_path);
 
 	for (i = 0; i < I_UNFM_NUM(tmp_ih); i++) {
-		reiserfs_bitmap_set_bit(fs->fs_badblocks_bm, 
+		reiserfs_bitmap_set_bit(fs->fs_badblocks_bm,
 					d32_get(ind_item, i));
 	}
-	
-	pathrelse (badblock_path);
+
+	pathrelse(badblock_path);
 }
 
-void add_badblock_list (reiserfs_filsys_t * fs, int replace) {
-    struct tree_balance tb;
-    struct reiserfs_path badblock_path;
-    struct item_head badblock_ih;
-    __u32 ni;
-
-    __u64 offset;
-    __u32 i, j;
-
-    if (fs->fs_badblocks_bm == NULL)
-    	return;
-
-    /* delete all items with badblock_key */
-    if (replace)
-	badblock_list(fs, callback_badblock_rm, NULL);
-
-    memset(&badblock_ih, 0, sizeof(badblock_ih));
-    set_ih_key_format (&badblock_ih, KEY_FORMAT_2);
-    set_ih_item_len (&badblock_ih, UNFM_P_SIZE);
-    set_ih_free_space (&badblock_ih, 0);
-    set_ih_location (&badblock_ih, 0);
-    set_key_dirid (&badblock_ih.ih_key, BADBLOCK_DIRID);
-    set_key_objectid (&badblock_ih.ih_key, BADBLOCK_OBJID);
-    set_type (KEY_FORMAT_2, &badblock_ih.ih_key, TYPE_INDIRECT);
-
-    j = 0;
-
-    /* insert all badblock pointers */
-    for (i = 0; i < fs->fs_badblocks_bm->bm_bit_size; i++) {
-        int retval;
-
-	if (!reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i))	
-	    continue;
-	
-	offset = j * fs->fs_blocksize + 1;
-	set_offset (KEY_FORMAT_2, &badblock_ih.ih_key, offset);
-	ni = cpu_to_le32 (i);
-	
-	retval = usearch_by_position (fs, &badblock_ih.ih_key, 
-				      key_format(&badblock_ih.ih_key), 
-				      &badblock_path);
+void add_badblock_list(reiserfs_filsys_t *fs, int replace)
+{
+	struct tree_balance tb;
+	struct reiserfs_path badblock_path;
+	struct item_head badblock_ih;
+	__u32 ni;
 
-	switch (retval) {
-	case (FILE_NOT_FOUND):
-		init_tb_struct (&tb, fs, &badblock_path, 
-				IH_SIZE + get_ih_item_len(&badblock_ih));
-		
-		if (fix_nodes (M_INSERT, &tb, &badblock_ih) != CARRY_ON)
-		    die ("reiserfsck_insert_item: fix_nodes failed");
-		
-		do_balance (&tb, &badblock_ih, (void *)&ni , M_INSERT, 0);
+	__u64 offset;
+	__u32 i, j;
 
-		break;
-	
-	case (POSITION_NOT_FOUND):
-	case (POSITION_FOUND):
-		/* Insert the new item to the found position. */
-	
-		init_tb_struct (&tb, fs, &badblock_path, UNFM_P_SIZE);
-		
-		if (fix_nodes (M_PASTE, &tb, 0) != CARRY_ON)
-		    die ("reiserfsck_paste_into_item: fix_nodes failed");
-
-		do_balance (&tb, 0, (const char *)&ni, M_PASTE, 0);
-		break;
+	if (fs->fs_badblocks_bm == NULL)
+		return;
+
+	/* delete all items with badblock_key */
+	if (replace)
+		badblock_list(fs, callback_badblock_rm, NULL);
+
+	memset(&badblock_ih, 0, sizeof(badblock_ih));
+	set_ih_key_format(&badblock_ih, KEY_FORMAT_2);
+	set_ih_item_len(&badblock_ih, UNFM_P_SIZE);
+	set_ih_free_space(&badblock_ih, 0);
+	set_ih_location(&badblock_ih, 0);
+	set_key_dirid(&badblock_ih.ih_key, BADBLOCK_DIRID);
+	set_key_objectid(&badblock_ih.ih_key, BADBLOCK_OBJID);
+	set_type(KEY_FORMAT_2, &badblock_ih.ih_key, TYPE_INDIRECT);
+
+	j = 0;
+
+	/* insert all badblock pointers */
+	for (i = 0; i < fs->fs_badblocks_bm->bm_bit_size; i++) {
+		int retval;
+
+		if (!reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i))
+			continue;
+
+		offset = j * fs->fs_blocksize + 1;
+		set_offset(KEY_FORMAT_2, &badblock_ih.ih_key, offset);
+		ni = cpu_to_le32(i);
+
+		retval = usearch_by_position(fs, &badblock_ih.ih_key,
+					     key_format(&badblock_ih.ih_key),
+					     &badblock_path);
+
+		switch (retval) {
+		case (FILE_NOT_FOUND):
+			init_tb_struct(&tb, fs, &badblock_path,
+				       IH_SIZE + get_ih_item_len(&badblock_ih));
+
+			if (fix_nodes(M_INSERT, &tb, &badblock_ih) != CARRY_ON)
+				die("reiserfsck_insert_item: fix_nodes failed");
+
+			do_balance(&tb, &badblock_ih, (void *)&ni, M_INSERT, 0);
+
+			break;
+
+		case (POSITION_NOT_FOUND):
+		case (POSITION_FOUND):
+			/* Insert the new item to the found position. */
+
+			init_tb_struct(&tb, fs, &badblock_path, UNFM_P_SIZE);
+
+			if (fix_nodes(M_PASTE, &tb, 0) != CARRY_ON)
+				die("reiserfsck_paste_into_item: fix_nodes failed");
+
+			do_balance(&tb, 0, (const char *)&ni, M_PASTE, 0);
+			break;
+		}
+
+		j++;
 	}
-	
-	j++;
-    }
 }
diff --git a/reiserfscore/stree.c b/reiserfscore/stree.c
index 3f246b8..23992c1 100644
--- a/reiserfscore/stree.c
+++ b/reiserfscore/stree.c
@@ -37,14 +37,12 @@
  */
 #include "includes.h"
 
-
 /* Does the buffer contain a disk block which is in the tree. */
-inline int B_IS_IN_TREE (struct buffer_head * p_s_bh)
+inline int B_IS_IN_TREE(struct buffer_head *p_s_bh)
 {
-    return ( get_blkh_level (B_BLK_HEAD (p_s_bh)) != FREE_LEVEL );
+	return (get_blkh_level(B_BLK_HEAD(p_s_bh)) != FREE_LEVEL);
 }
 
-
 /*
  Compare keys using REISERFS_SHORT_KEY_LEN fields.
  Returns:  -1 if key1 < key2
@@ -52,78 +50,75 @@ inline int B_IS_IN_TREE (struct buffer_head * p_s_bh)
             1 if key1 > key2
 */
 
-int comp_short_keys (const void * k1, const void * k2)
+int comp_short_keys(const void *k1, const void *k2)
 {
-    int n_key_length = REISERFS_SHORT_KEY_LEN;
-    __u32 * p_s_key1 = (__u32 *)k1;
-    __u32 * p_s_key2 = (__u32 *)k2;
-    __u32 u1, u2;
-
-    for( ; n_key_length--; ++p_s_key1, ++p_s_key2 ) {
-	u1 = d32_get(p_s_key1, 0) ;
-	u2 = d32_get(p_s_key2, 0) ;
-	if ( u1 < u2 )
-	    return -1;
-	if ( u1 > u2 )
-	    return 1;
-    }
-
-    return 0;
-}
+	int n_key_length = REISERFS_SHORT_KEY_LEN;
+	__u32 *p_s_key1 = (__u32 *) k1;
+	__u32 *p_s_key2 = (__u32 *) k2;
+	__u32 u1, u2;
+
+	for (; n_key_length--; ++p_s_key1, ++p_s_key2) {
+		u1 = d32_get(p_s_key1, 0);
+		u2 = d32_get(p_s_key2, 0);
+		if (u1 < u2)
+			return -1;
+		if (u1 > u2)
+			return 1;
+	}
 
+	return 0;
+}
 
-int comp_keys_3 (const void * p1, const void * p2)
+int comp_keys_3(const void *p1, const void *p2)
 {
-    int retval;
-    const struct reiserfs_key *k1 = p1;
-    const struct reiserfs_key *k2 = p2;
-    loff_t off1, off2;
-
-    retval = comp_short_keys (k1, k2);
-    if (retval)
-	return retval;
-    off1 = get_offset(k1) ;
-    off2 = get_offset(k2) ;
-    if (off1 < off2)
-	return -1;
-
-    if (off1 > off2)
-	return 1;
+	int retval;
+	const struct reiserfs_key *k1 = p1;
+	const struct reiserfs_key *k2 = p2;
+	loff_t off1, off2;
+
+	retval = comp_short_keys(k1, k2);
+	if (retval)
+		return retval;
+	off1 = get_offset(k1);
+	off2 = get_offset(k2);
+	if (off1 < off2)
+		return -1;
+
+	if (off1 > off2)
+		return 1;
 
-    return 0;
+	return 0;
 }
 
-
 /*
  Compare keys using all 4 key fields.
  Returns:  -1 if key1 < key2
             0 if key1 = key2
             1 if key1 > key2
 */
-int comp_keys (const void * p1, const void * p2)
+int comp_keys(const void *p1, const void *p2)
 {
-    int retval;
-    const struct reiserfs_key *k1 = p1;
-    const struct reiserfs_key *k2 = p2;
-    __u32 u1, u2;
+	int retval;
+	const struct reiserfs_key *k1 = p1;
+	const struct reiserfs_key *k2 = p2;
+	__u32 u1, u2;
 
-    retval = comp_keys_3 (k1, k2);
-    if (retval)
-	return retval;
+	retval = comp_keys_3(k1, k2);
+	if (retval)
+		return retval;
 
-    u1 = get_type (k1);
-    u2 = get_type (k2);
+	u1 = get_type(k1);
+	u2 = get_type(k2);
 
-    if (u1 < u2)
-        return -1;
+	if (u1 < u2)
+		return -1;
 
-    if (u1 > u2)
-        return 1;
+	if (u1 > u2)
+		return 1;
 
-    return 0;
+	return 0;
 }
 
-
 /**************************************************************************
  *  Binary search toolkit function                                        *
  *  Search for an item in the array by the item key                       *
@@ -138,42 +133,51 @@ int comp_keys (const void * p1, const void * p2)
  there are no possible items, and we have not found it. With each examination we
  cut the number of possible items it could be by one more than half rounded down,
  or we find it. */
-int bin_search (
-              void    * p_v_key,    /* Key to search for.                   */
-	      void    * p_v_base,   /* First item in the array.             */
-	      int       p_n_num,    /* Number of items in the array.        */
-	      int       p_n_width,  /* Item size in the array.
-				       searched. Lest the reader be
-				       confused, note that this is crafted
-				       as a general function, and when it
-				       is applied specifically to the array
-				       of item headers in a node, p_n_width
-				       is actually the item header size not
-				       the item size.                      */
-	      unsigned int     * p_n_pos     /* Number of the searched
-						for element. */
-            ) {
-    int   n_rbound, n_lbound, n_j;
-
-    for ( n_j = ((n_rbound = p_n_num - 1) + (n_lbound = 0))/2; n_lbound <= n_rbound; n_j = (n_rbound + n_lbound)/2 )
-	switch( COMP_KEYS((struct reiserfs_key *)((char * )p_v_base + n_j * p_n_width), p_v_key) )  {
-	case -1: n_lbound = n_j + 1; continue;
-	case  1: n_rbound = n_j - 1; continue;
-	case  0: *p_n_pos = n_j;     return ITEM_FOUND; /* Key found in the array.  */
-	}
-
-    /* bin_search did not find given key, it returns position of key,
-     that is minimal and greater than the given one. */
-    *p_n_pos = n_lbound;
-    return ITEM_NOT_FOUND;
+int bin_search(void *p_v_key,	/* Key to search for.                   */
+	       void *p_v_base,	/* First item in the array.             */
+	       int p_n_num,	/* Number of items in the array.        */
+	       int p_n_width,	/* Item size in the array.
+				   searched. Lest the reader be
+				   confused, note that this is crafted
+				   as a general function, and when it
+				   is applied specifically to the array
+				   of item headers in a node, p_n_width
+				   is actually the item header size not
+				   the item size.                      */
+	       unsigned int *p_n_pos	/* Number of the searched
+					   for element. */
+    )
+{
+	int n_rbound, n_lbound, n_j;
+
+	for (n_j = ((n_rbound = p_n_num - 1) + (n_lbound = 0)) / 2;
+	     n_lbound <= n_rbound; n_j = (n_rbound + n_lbound) / 2)
+		switch (COMP_KEYS
+			((struct reiserfs_key *)((char *)p_v_base +
+						 n_j * p_n_width), p_v_key)) {
+		case -1:
+			n_lbound = n_j + 1;
+			continue;
+		case 1:
+			n_rbound = n_j - 1;
+			continue;
+		case 0:
+			*p_n_pos = n_j;
+			return ITEM_FOUND;	/* Key found in the array.  */
+		}
+
+	/* bin_search did not find given key, it returns position of key,
+	   that is minimal and greater than the given one. */
+	*p_n_pos = n_lbound;
+	return ITEM_NOT_FOUND;
 }
 
 /* Minimal possible key. It is never in the tree. */
-struct reiserfs_key  MIN_KEY = {0, 0, {{0, 0},}};
+struct reiserfs_key MIN_KEY = { 0, 0, {{0, 0},} };
 
 /* Maximal possible key. It is never in the tree. */
-struct reiserfs_key  MAX_KEY = {0xffffffff, 0xffffffff, {{0xffffffff, 0xffffffff},}};
-
+struct reiserfs_key MAX_KEY =
+    { 0xffffffff, 0xffffffff, {{0xffffffff, 0xffffffff},} };
 
 /* Get delimiting key of the buffer by looking for it in the buffers in the
    path, starting from the bottom of the path, and going upwards.  We must
@@ -181,73 +185,82 @@ struct reiserfs_key  MAX_KEY = {0xffffffff, 0xffffffff, {{0xffffffff, 0xffffffff
    there is no delimiting key in the tree (buffer is first or last buffer in
    tree), and in this case we return a special key, either MIN_KEY or
    MAX_KEY. */
-struct reiserfs_key *get_lkey (struct reiserfs_path *p_s_chk_path,
-		       reiserfs_filsys_t * fs)
+struct reiserfs_key *get_lkey(struct reiserfs_path *p_s_chk_path,
+			      reiserfs_filsys_t *fs)
 {
-    struct reiserfs_super_block * sb;
-    int  n_position, n_path_offset = p_s_chk_path->path_length;
-    struct buffer_head  * p_s_parent;
-  
-    sb = fs->fs_ondisk_sb;
-
-    /* While not higher in path than first element. */
-    while ( n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET ) {
-	/* Parent at the path is not in the tree now. */
-	if ( ! B_IS_IN_TREE(p_s_parent = PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)) )
-	    return &MAX_KEY;
-	/* Check whether position in the parent is correct. */
-	if ( (n_position = PATH_OFFSET_POSITION(p_s_chk_path, n_path_offset)) > B_NR_ITEMS(p_s_parent) )
-	    return &MAX_KEY;
-	/* Check whether parent at the path really points to the child. */
-	if ( get_dc_child_blocknr (B_N_CHILD (p_s_parent, n_position)) !=
-	     PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset + 1)->b_blocknr )
-	    return &MAX_KEY;
-	/* Return delimiting key if position in the parent is not equal to zero. */
-	if ( n_position )
-	    return B_N_PDELIM_KEY(p_s_parent, n_position - 1);
-    }
-    /* Return MIN_KEY if we are in the root of the buffer tree. */
-    if ( PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
-	 get_sb_root_block (sb) )
-	return &MIN_KEY;
-    return  &MAX_KEY;
+	struct reiserfs_super_block *sb;
+	int n_position, n_path_offset = p_s_chk_path->path_length;
+	struct buffer_head *p_s_parent;
+
+	sb = fs->fs_ondisk_sb;
+
+	/* While not higher in path than first element. */
+	while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
+		/* Parent at the path is not in the tree now. */
+		if (!B_IS_IN_TREE
+		    (p_s_parent =
+		     PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)))
+			return &MAX_KEY;
+		/* Check whether position in the parent is correct. */
+		if ((n_position =
+		     PATH_OFFSET_POSITION(p_s_chk_path,
+					  n_path_offset)) >
+		    B_NR_ITEMS(p_s_parent))
+			return &MAX_KEY;
+		/* Check whether parent at the path really points to the child. */
+		if (get_dc_child_blocknr(B_N_CHILD(p_s_parent, n_position)) !=
+		    PATH_OFFSET_PBUFFER(p_s_chk_path,
+					n_path_offset + 1)->b_blocknr)
+			return &MAX_KEY;
+		/* Return delimiting key if position in the parent is not equal to zero. */
+		if (n_position)
+			return B_N_PDELIM_KEY(p_s_parent, n_position - 1);
+	}
+	/* Return MIN_KEY if we are in the root of the buffer tree. */
+	if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
+	    b_blocknr == get_sb_root_block(sb))
+		return &MIN_KEY;
+	return &MAX_KEY;
 }
 
-
 /* Get delimiting key of the buffer at the path and its right neighbor. */
-struct reiserfs_key *get_rkey (struct reiserfs_path *p_s_chk_path,
-		       reiserfs_filsys_t * fs)
+struct reiserfs_key *get_rkey(struct reiserfs_path *p_s_chk_path,
+			      reiserfs_filsys_t *fs)
 {
-    struct reiserfs_super_block * sb;
-    int                   n_position,
-	n_path_offset = p_s_chk_path->path_length;
-    struct buffer_head  * p_s_parent;
-
-    sb = fs->fs_ondisk_sb;
-
-    while ( n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET ) {
-	/* Parent at the path is not in the tree now. */
-	if ( ! B_IS_IN_TREE(p_s_parent = PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)) )
-	    return &MIN_KEY;
-	/* Check whether position in the parrent is correct. */
-	if ( (n_position = PATH_OFFSET_POSITION(p_s_chk_path, n_path_offset)) > B_NR_ITEMS(p_s_parent) )
-	    return &MIN_KEY;
-	/* Check whether parent at the path really points to the child. */
-	if ( get_dc_child_blocknr (B_N_CHILD (p_s_parent, n_position)) !=
-	     PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset + 1)->b_blocknr )
-	    return &MIN_KEY;
-	/* Return delimiting key if position in the parent is not the last one. */
-	if ( n_position != B_NR_ITEMS(p_s_parent) )
-	    return B_N_PDELIM_KEY(p_s_parent, n_position);
-    }
-    /* Return MAX_KEY if we are in the root of the buffer tree. */
-    if ( PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->b_blocknr ==
-	 get_sb_root_block (sb) )
-	return &MAX_KEY;
-    return  &MIN_KEY;
+	struct reiserfs_super_block *sb;
+	int n_position, n_path_offset = p_s_chk_path->path_length;
+	struct buffer_head *p_s_parent;
+
+	sb = fs->fs_ondisk_sb;
+
+	while (n_path_offset-- > FIRST_PATH_ELEMENT_OFFSET) {
+		/* Parent at the path is not in the tree now. */
+		if (!B_IS_IN_TREE
+		    (p_s_parent =
+		     PATH_OFFSET_PBUFFER(p_s_chk_path, n_path_offset)))
+			return &MIN_KEY;
+		/* Check whether position in the parrent is correct. */
+		if ((n_position =
+		     PATH_OFFSET_POSITION(p_s_chk_path,
+					  n_path_offset)) >
+		    B_NR_ITEMS(p_s_parent))
+			return &MIN_KEY;
+		/* Check whether parent at the path really points to the child. */
+		if (get_dc_child_blocknr(B_N_CHILD(p_s_parent, n_position)) !=
+		    PATH_OFFSET_PBUFFER(p_s_chk_path,
+					n_path_offset + 1)->b_blocknr)
+			return &MIN_KEY;
+		/* Return delimiting key if position in the parent is not the last one. */
+		if (n_position != B_NR_ITEMS(p_s_parent))
+			return B_N_PDELIM_KEY(p_s_parent, n_position);
+	}
+	/* Return MAX_KEY if we are in the root of the buffer tree. */
+	if (PATH_OFFSET_PBUFFER(p_s_chk_path, FIRST_PATH_ELEMENT_OFFSET)->
+	    b_blocknr == get_sb_root_block(sb))
+		return &MAX_KEY;
+	return &MIN_KEY;
 }
 
-
 /* Check whether a key is contained in the tree rooted from a buffer at a
    path.  This works by looking at the left and right delimiting keys for the
    buffer in the last path_element in the path.  These delimiting keys are
@@ -255,30 +268,29 @@ struct reiserfs_key *get_rkey (struct reiserfs_path *p_s_chk_path,
    the first or last node in the tree order then one of the delimiting keys
    may be absent, and in this case get_lkey and get_rkey return a special key
    which is MIN_KEY or MAX_KEY. */
-static  inline  int key_in_buffer (
-    struct reiserfs_path         * p_s_chk_path, /* Path which should be checked.  */
-    struct reiserfs_key          * p_s_key,      /* Key which should be checked.   */
-    reiserfs_filsys_t  * fs        /* Super block pointer.           */
-    ) {
+static inline int key_in_buffer(struct reiserfs_path *p_s_chk_path,	/* Path which should be checked.  */
+				struct reiserfs_key *p_s_key,	/* Key which should be checked.   */
+				reiserfs_filsys_t *fs	/* Super block pointer.           */
+    )
+{
 
-    if ( COMP_KEYS(get_lkey(p_s_chk_path, fs), p_s_key) == 1 )
-	return 0;
-    if ( COMP_KEYS(p_s_key, get_rkey(p_s_chk_path, fs)) != -1 )
-	return 0;
-    return 1;
+	if (COMP_KEYS(get_lkey(p_s_chk_path, fs), p_s_key) == 1)
+		return 0;
+	if (COMP_KEYS(p_s_key, get_rkey(p_s_chk_path, fs)) != -1)
+		return 0;
+	return 1;
 }
 
 /* Release all buffers in the path. */
-void  pathrelse (struct reiserfs_path *p_s_search_path) 
+void pathrelse(struct reiserfs_path *p_s_search_path)
 {
-    int n_path_offset = p_s_search_path->path_length;
-    
-    while ( n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET )
-	brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
+	int n_path_offset = p_s_search_path->path_length;
 
-    p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
-}
+	while (n_path_offset > ILLEGAL_PATH_ELEMENT_OFFSET)
+		brelse(PATH_OFFSET_PBUFFER(p_s_search_path, n_path_offset--));
 
+	p_s_search_path->path_length = ILLEGAL_PATH_ELEMENT_OFFSET;
+}
 
 /**************************************************************************
  * Algorithm   SearchByKey                                                *
@@ -302,115 +314,121 @@ void  pathrelse (struct reiserfs_path *p_s_search_path)
    key.  search_by_key returns a path that must be checked for the
    correctness of the top of the path but need not be checked for the
    correctness of the bottom of the path */
-int search_by_key (reiserfs_filsys_t * fs,
-		   struct reiserfs_key *p_s_key,        /* Key to search */
-		   struct reiserfs_path *p_s_search_path,/* This structure was
-						    allocated and
-						    initialized by the
-						    calling
-						    function. It is
-						    filled up by this
-						    function.  */
-		   int  n_stop_level)   /* How far down the tree to search.*/
-{
-    struct reiserfs_super_block * sb;
-    unsigned int n_block_number,
-	expected_level,
-	n_block_size    = fs->fs_blocksize;
-    struct buffer_head  *       p_s_bh;
-    struct reiserfs_path_element *       p_s_last_element;
-    int				n_retval;
-
-
-    sb = fs->fs_ondisk_sb;
-    n_block_number = get_sb_root_block (sb);
-    expected_level = get_sb_tree_height (sb);
-    
-    /* As we add each node to a path we increase its count.  This
-       means that we must be careful to release all nodes in a path
-       before we either discard the path struct or re-use the path
-       struct, as we do here. */
-    pathrelse (p_s_search_path);
-
-
-    /* With each iteration of this loop we search through the items in
-       the current node, and calculate the next current node(next path
-       element) for the next iteration of this loop.. */
-    while ( 1 ) {
-
-	/* prep path to have another element added to it. */
-	p_s_last_element = PATH_OFFSET_PELEMENT(p_s_search_path, ++p_s_search_path->path_length);
-	expected_level --;
-
-	/* Read the next tree node, and set the last element in the
-           path to have a pointer to it. */
-	if ( ! (p_s_bh = p_s_last_element->pe_buffer =
-		bread (fs->fs_dev, n_block_number, n_block_size)) ) {
-	    p_s_search_path->path_length --;
-	    pathrelse(p_s_search_path);
-	    return IO_ERROR;
-	}
-
-	/* It is possible that schedule occured. We must check whether
-	   the key to search is still in the tree rooted from the
-	   current buffer. If not then repeat search from the root. */
-	if (!B_IS_IN_TREE (p_s_bh) || 
-	    ! key_in_buffer(p_s_search_path, p_s_key, fs))
-	    reiserfs_panic ("search_by_key: something wrong with the tree");
-
-	/* make sure, that the node contents look like a node of
-           certain level */
-	if (!is_tree_node (p_s_bh, expected_level)) {
-	    print_block (stderr, 0, p_s_bh, 3, -1, -1);
-	    reiserfs_panic ("search_by_key: expected level %d", expected_level);
+int search_by_key(reiserfs_filsys_t *fs, struct reiserfs_key *p_s_key,	/* Key to search */
+		  struct reiserfs_path *p_s_search_path,	/* This structure was
+								   allocated and
+								   initialized by the
+								   calling
+								   function. It is
+								   filled up by this
+								   function.  */
+		  int n_stop_level)
+{				/* How far down the tree to search. */
+	struct reiserfs_super_block *sb;
+	unsigned int n_block_number,
+	    expected_level, n_block_size = fs->fs_blocksize;
+	struct buffer_head *p_s_bh;
+	struct reiserfs_path_element *p_s_last_element;
+	int n_retval;
+
+	sb = fs->fs_ondisk_sb;
+	n_block_number = get_sb_root_block(sb);
+	expected_level = get_sb_tree_height(sb);
+
+	/* As we add each node to a path we increase its count.  This
+	   means that we must be careful to release all nodes in a path
+	   before we either discard the path struct or re-use the path
+	   struct, as we do here. */
+	pathrelse(p_s_search_path);
+
+	/* With each iteration of this loop we search through the items in
+	   the current node, and calculate the next current node(next path
+	   element) for the next iteration of this loop.. */
+	while (1) {
+
+		/* prep path to have another element added to it. */
+		p_s_last_element =
+		    PATH_OFFSET_PELEMENT(p_s_search_path,
+					 ++p_s_search_path->path_length);
+		expected_level--;
+
+		/* Read the next tree node, and set the last element in the
+		   path to have a pointer to it. */
+		if (!(p_s_bh = p_s_last_element->pe_buffer =
+		      bread(fs->fs_dev, n_block_number, n_block_size))) {
+			p_s_search_path->path_length--;
+			pathrelse(p_s_search_path);
+			return IO_ERROR;
+		}
+
+		/* It is possible that schedule occured. We must check whether
+		   the key to search is still in the tree rooted from the
+		   current buffer. If not then repeat search from the root. */
+		if (!B_IS_IN_TREE(p_s_bh) ||
+		    !key_in_buffer(p_s_search_path, p_s_key, fs))
+			reiserfs_panic
+			    ("search_by_key: something wrong with the tree");
+
+		/* make sure, that the node contents look like a node of
+		   certain level */
+		if (!is_tree_node(p_s_bh, expected_level)) {
+			print_block(stderr, 0, p_s_bh, 3, -1, -1);
+			reiserfs_panic("search_by_key: expected level %d",
+				       expected_level);
+		}
+
+		/* ok, we have acquired next formatted node in the tree */
+		n_retval =
+		    bin_search(p_s_key, B_N_PITEM_HEAD(p_s_bh, 0),
+			       B_NR_ITEMS(p_s_bh),
+			       is_leaf_node(p_s_bh) ? IH_SIZE : KEY_SIZE,
+			       &(p_s_last_element->pe_position));
+		if (get_blkh_level(B_BLK_HEAD(p_s_bh)) == n_stop_level)
+			return n_retval;
+
+		/* we are not in the stop level */
+		if (n_retval == ITEM_FOUND)
+			/* item has been found, so we choose the pointer which is
+			   to the right of the found one */
+			p_s_last_element->pe_position++;
+
+		/* if item was not found we choose the position which is to
+		   the left of the found item. This requires no code,
+		   bin_search did it already. */
+
+		/* So we have chosen a position in the current node which is
+		   an internal node.  Now we calculate child block number by
+		   position in the node. */
+		n_block_number =
+		    get_dc_child_blocknr(B_N_CHILD
+					 (p_s_bh,
+					  p_s_last_element->pe_position));
 	}
-
-	/* ok, we have acquired next formatted node in the tree */
-	n_retval = bin_search (p_s_key, B_N_PITEM_HEAD(p_s_bh, 0), B_NR_ITEMS(p_s_bh),
-			       is_leaf_node (p_s_bh) ? IH_SIZE : KEY_SIZE, &(p_s_last_element->pe_position));
-	if (get_blkh_level (B_BLK_HEAD (p_s_bh)) == n_stop_level)
-	    return n_retval;
-
-	/* we are not in the stop level */
-	if (n_retval == ITEM_FOUND)
-	    /* item has been found, so we choose the pointer which is
-               to the right of the found one */
-	    p_s_last_element->pe_position++;
-
-	/* if item was not found we choose the position which is to
-	   the left of the found item. This requires no code,
-	   bin_search did it already.*/
-
-	/* So we have chosen a position in the current node which is
-	   an internal node.  Now we calculate child block number by
-	   position in the node. */
-	n_block_number = get_dc_child_blocknr (B_N_CHILD (p_s_bh, p_s_last_element->pe_position));
-    }
 }
 
-
-int bin_search_in_dir_item (struct item_head * ih, struct reiserfs_de_head * deh, 
-			    struct reiserfs_key *key, int * pos_in_item)
+int bin_search_in_dir_item(struct item_head *ih, struct reiserfs_de_head *deh,
+			   struct reiserfs_key *key, int *pos_in_item)
 {
-    int rbound, lbound, j;
-
-    lbound = 0;
-    rbound = get_ih_entry_count (ih) - 1;
-
-    for (j = (rbound + lbound) / 2; lbound <= rbound; j = (rbound + lbound) / 2) {
-	if (get_offset (key) < get_deh_offset (deh + j)) {
-	    rbound = j - 1;
-	    continue;
+	int rbound, lbound, j;
+
+	lbound = 0;
+	rbound = get_ih_entry_count(ih) - 1;
+
+	for (j = (rbound + lbound) / 2; lbound <= rbound;
+	     j = (rbound + lbound) / 2) {
+		if (get_offset(key) < get_deh_offset(deh + j)) {
+			rbound = j - 1;
+			continue;
+		}
+		if (get_offset(key) > get_deh_offset(deh + j)) {
+			lbound = j + 1;
+			continue;
+		}
+		/* key found */
+		*pos_in_item = j;
+		return POSITION_FOUND;
 	}
-	if (get_offset (key) > get_deh_offset (deh + j)) {
-	    lbound = j + 1;
-	    continue;
-	}
-	/* key found */
-	*pos_in_item = j;
-	return POSITION_FOUND;
-    }
-    
-    *pos_in_item = lbound;
-    return POSITION_NOT_FOUND;
+
+	*pos_in_item = lbound;
+	return POSITION_NOT_FOUND;
 }
diff --git a/resize_reiserfs/do_shrink.c b/resize_reiserfs/do_shrink.c
index b63cfa4..6b6371b 100644
--- a/resize_reiserfs/do_shrink.c
+++ b/resize_reiserfs/do_shrink.c
@@ -6,9 +6,9 @@
 #include "resize.h"
 #include <time.h>
 
-static unsigned long int_node_cnt   = 0, int_moved_cnt   = 0;
-static unsigned long leaf_node_cnt  = 0, leaf_moved_cnt  = 0;
-static unsigned long unfm_node_cnt  = 0, unfm_moved_cnt  = 0;
+static unsigned long int_node_cnt = 0, int_moved_cnt = 0;
+static unsigned long leaf_node_cnt = 0, leaf_moved_cnt = 0;
+static unsigned long unfm_node_cnt = 0, unfm_moved_cnt = 0;
 static unsigned long total_node_cnt = 0;
 static unsigned long total_moved_cnt = 0;
 
@@ -16,25 +16,25 @@ static unsigned long unused_block;
 static unsigned long blocks_used;
 static int block_count_mismatch = 0;
 
-static reiserfs_bitmap_t * bmp;
-static struct reiserfs_super_block * ondisk_sb;
+static reiserfs_bitmap_t *bmp;
+static struct reiserfs_super_block *ondisk_sb;
 
 /* abnornal exit from block reallocation process */
-static void quit_resizer(reiserfs_filsys_t * fs)
+static void quit_resizer(reiserfs_filsys_t *fs)
 {
 	/* save changes to bitmap blocks */
-	reiserfs_close (fs);
+	reiserfs_close(fs);
 	/* leave fs in ERROR state */
 	reiserfs_exit(1, "fs shrinking was not completed successfully, "
 		      "run reiserfsck.");
 }
 
 /* block moving */
-static unsigned long move_generic_block(reiserfs_filsys_t * fs, 
-					unsigned long block, 
+static unsigned long move_generic_block(reiserfs_filsys_t *fs,
+					unsigned long block,
 					unsigned long bnd, int h)
 {
-    struct buffer_head * bh, * bh2;
+	struct buffer_head *bh, *bh2;
 
 	/* primitive fsck */
 	if (block > get_sb_block_count(ondisk_sb)) {
@@ -42,31 +42,32 @@ static unsigned long move_generic_block(reiserfs_filsys_t * fs,
 			"(%lu) found.\n", block);
 		quit_resizer(fs);
 	}
-	
+
 	/* progress bar, 3D style :) */
 	if (opt_verbose)
-	    print_how_far(stderr, &total_node_cnt, blocks_used, 1, 0);
+		print_how_far(stderr, &total_node_cnt, blocks_used, 1, 0);
 	else
-	    total_node_cnt ++;
+		total_node_cnt++;
 
 	/* infinite loop check */
-	if( total_node_cnt > blocks_used && !block_count_mismatch) {
-		fputs("resize_reiserfs: warning: block count exeeded\n",stderr);
+	if (total_node_cnt > blocks_used && !block_count_mismatch) {
+		fputs("resize_reiserfs: warning: block count exeeded\n",
+		      stderr);
 		block_count_mismatch = 1;
 	}
 
-	if (block < bnd) /* block will not be moved */
+	if (block < bnd)	/* block will not be moved */
 		return 0;
-	
-	/* move wrong block */ 
+
+	/* move wrong block */
 	bh = bread(fs->fs_dev, block, fs->fs_blocksize);
 
 	if (!bh)
-	    reiserfs_exit (1, "move_generic_block: bread failed.\n");
+		reiserfs_exit(1, "move_generic_block: bread failed.\n");
 
 	reiserfs_bitmap_find_zero_bit(bmp, &unused_block);
 	if (unused_block == 0 || unused_block >= bnd) {
-		fputs ("resize_reiserfs: can\'t find free block\n", stderr);
+		fputs("resize_reiserfs: can\'t find free block\n", stderr);
 		quit_resizer(fs);
 	}
 
@@ -77,7 +78,7 @@ static unsigned long move_generic_block(reiserfs_filsys_t * fs,
 	reiserfs_bitmap_set_bit(bmp, unused_block);
 
 	brelse(bh);
-	mark_buffer_uptodate(bh2,1);
+	mark_buffer_uptodate(bh2, 1);
 	mark_buffer_dirty(bh2);
 	bwrite(bh2);
 	brelse(bh2);
@@ -86,83 +87,97 @@ static unsigned long move_generic_block(reiserfs_filsys_t * fs,
 	return unused_block;
 }
 
-static unsigned long move_unformatted_block(reiserfs_filsys_t * fs, unsigned long block, unsigned long bnd, int h)
+static unsigned long move_unformatted_block(reiserfs_filsys_t *fs,
+					    unsigned long block,
+					    unsigned long bnd, int h)
 {
 	unsigned long b;
 	unfm_node_cnt++;
 	b = move_generic_block(fs, block, bnd, h);
 	if (b)
 		unfm_moved_cnt++;
-	return b;		
+	return b;
 }
 
-
 /* recursive function processing all tree nodes */
-static unsigned long move_formatted_block(reiserfs_filsys_t * fs, unsigned long block, unsigned long bnd, int h)
+static unsigned long move_formatted_block(reiserfs_filsys_t *fs,
+					  unsigned long block,
+					  unsigned long bnd, int h)
 {
-	struct buffer_head * bh;
+	struct buffer_head *bh;
 	struct item_head *ih;
 	unsigned long new_blocknr = 0;
 	int node_is_internal = 0;
 	unsigned int i, j;
-	
+
 	bh = bread(fs->fs_dev, block, fs->fs_blocksize);
 	if (!bh)
-	    reiserfs_exit (1, "move_formatted_block: bread failed");
-	
-	if (is_leaf_node (bh)) {
-		
+		reiserfs_exit(1, "move_formatted_block: bread failed");
+
+	if (is_leaf_node(bh)) {
+
 		leaf_node_cnt++;
-		
+
 		for (i = 0; i < B_NR_ITEMS(bh); i++) {
 			ih = B_N_PITEM_HEAD(bh, i);
-			
+
 			/* skip the bad blocks. */
-			if (get_key_objectid (&ih->ih_key) == BADBLOCK_OBJID &&
-			    get_key_dirid (&ih->ih_key) == BADBLOCK_DIRID)
+			if (get_key_objectid(&ih->ih_key) == BADBLOCK_OBJID &&
+			    get_key_dirid(&ih->ih_key) == BADBLOCK_DIRID)
 				continue;
-			
+
 			if (is_indirect_ih(ih)) {
-				__u32 * indirect;
+				__u32 *indirect;
 
-				indirect = (__u32 *)B_I_PITEM (bh, ih);
+				indirect = (__u32 *) B_I_PITEM(bh, ih);
 				for (j = 0; j < I_UNFM_NUM(ih); j++) {
-					unsigned long  unfm_block;
+					unsigned long unfm_block;
 
-					if (d32_get (indirect, j) == 0) /* hole */
+					if (d32_get(indirect, j) == 0)	/* hole */
 						continue;
-					unfm_block = move_unformatted_block(fs, d32_get (indirect, j), bnd, h + 1);
+					unfm_block =
+					    move_unformatted_block(fs,
+								   d32_get
+								   (indirect,
+								    j), bnd,
+								   h + 1);
 					if (unfm_block) {
-						d32_put (indirect, j, unfm_block);
+						d32_put(indirect, j,
+							unfm_block);
 						mark_buffer_dirty(bh);
 					}
 				}
-			}	
+			}
 		}
-	} else if (is_internal_node (bh)) { /* internal node */
-		
+	} else if (is_internal_node(bh)) {	/* internal node */
+
 		int_node_cnt++;
 		node_is_internal = 1;
-		
-		for (i=0; i <= B_NR_ITEMS(bh); i++) {
+
+		for (i = 0; i <= B_NR_ITEMS(bh); i++) {
 			unsigned long moved_block;
-			moved_block = move_formatted_block(fs, get_dc_child_blocknr (B_N_CHILD (bh, i)), bnd, h+1);
+			moved_block =
+			    move_formatted_block(fs,
+						 get_dc_child_blocknr(B_N_CHILD
+								      (bh, i)),
+						 bnd, h + 1);
 			if (moved_block) {
-			    	set_dc_child_blocknr (B_N_CHILD (bh, i), moved_block);
+				set_dc_child_blocknr(B_N_CHILD(bh, i),
+						     moved_block);
 				mark_buffer_dirty(bh);
 			}
-		}	
+		}
 	} else {
-		DIE ("block (%lu) has invalid format\n", block);
+		DIE("block (%lu) has invalid format\n", block);
 	}
-	
+
 	if (buffer_dirty(bh)) {
-		mark_buffer_uptodate(bh,1);
+		mark_buffer_uptodate(bh, 1);
 		bwrite(bh);
 	}
-	
-	brelse(bh);	
-	
+
+	brelse(bh);
+
 	new_blocknr = move_generic_block(fs, block, bnd, h);
 	if (new_blocknr) {
 		if (node_is_internal)
@@ -170,40 +185,38 @@ static unsigned long move_formatted_block(reiserfs_filsys_t * fs, unsigned long
 		else
 			leaf_moved_cnt++;
 	}
-	
+
 	return new_blocknr;
 }
 
-int shrink_fs(reiserfs_filsys_t * fs, long long int blocks)
+int shrink_fs(reiserfs_filsys_t *fs, long long int blocks)
 {
 	unsigned long n_root_block;
 	unsigned int bmap_nr_new;
 	unsigned long bad_count;
-	
+
 	ondisk_sb = fs->fs_ondisk_sb;
-	
-	
+
 	bmap_nr_new = (blocks - 1) / (8 * fs->fs_blocksize) + 1;
 
 	/* is shrinking possible ? */
-	if (get_sb_block_count(ondisk_sb) - blocks > 
-	    get_sb_free_blocks(ondisk_sb) + reiserfs_fs_bmap_nr(fs) - bmap_nr_new)
-	{
-	    fprintf(stderr, "resize_reiserfs: can\'t shrink fs; too many "
-		"blocks already allocated\n");
-	    return -1;
+	if (get_sb_block_count(ondisk_sb) - blocks >
+	    get_sb_free_blocks(ondisk_sb) + reiserfs_fs_bmap_nr(fs) -
+	    bmap_nr_new) {
+		fprintf(stderr,
+			"resize_reiserfs: can\'t shrink fs; too many "
+			"blocks already allocated\n");
+		return -1;
 	}
 
 	/* warn about alpha version */
 	{
 		int c;
 
-		printf(
-		    "You are running BETA version of reiserfs shrinker.\n"
-		    "This version is only for testing or VERY CAREFUL use.\n"
-		    "Backup of you data is recommended.\n\n"
-		    "Do you want to continue? [y/N]:"
-		);
+		printf("You are running BETA version of reiserfs shrinker.\n"
+		       "This version is only for testing or VERY CAREFUL use.\n"
+		       "Backup of you data is recommended.\n\n"
+		       "Do you want to continue? [y/N]:");
 		fflush(stdout);
 		c = getchar();
 		if (c != 'y' && c != 'Y')
@@ -211,24 +224,22 @@ int shrink_fs(reiserfs_filsys_t * fs, long long int blocks)
 	}
 
 	reiserfs_reopen(fs, O_RDWR);
-	if (reiserfs_open_ondisk_bitmap (fs))
-	    reiserfs_exit(1, "cannot open ondisk bitmap");
+	if (reiserfs_open_ondisk_bitmap(fs))
+		reiserfs_exit(1, "cannot open ondisk bitmap");
 	bmp = fs->fs_bitmap2;
 	ondisk_sb = fs->fs_ondisk_sb;
 
-	set_sb_fs_state (fs->fs_ondisk_sb, FS_ERROR);
+	set_sb_fs_state(fs->fs_ondisk_sb, FS_ERROR);
 	mark_buffer_uptodate(fs->fs_super_bh, 1);
 	mark_buffer_dirty(fs->fs_super_bh);
 	bwrite(fs->fs_super_bh);
 
-	/* calculate number of data blocks */		
-	blocks_used = 
-	    get_sb_block_count(fs->fs_ondisk_sb)
+	/* calculate number of data blocks */
+	blocks_used = get_sb_block_count(fs->fs_ondisk_sb)
 	    - get_sb_free_blocks(fs->fs_ondisk_sb)
 	    - reiserfs_fs_bmap_nr(fs)
-	    - get_jp_journal_size(sb_jp (fs->fs_ondisk_sb))
-	    - REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize
-	    - 2; /* superblock itself and 1 descriptor after the journal */
+	    - get_jp_journal_size(sb_jp(fs->fs_ondisk_sb))
+	    - REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize - 2;	/* superblock itself and 1 descriptor after the journal */
 
 	unused_block = 1;
 
@@ -237,64 +248,64 @@ int shrink_fs(reiserfs_filsys_t * fs, long long int blocks)
 		fflush(stdout);
 	}
 
-	n_root_block = move_formatted_block(fs, get_sb_root_block(ondisk_sb), 
-	    blocks, 0);
-	
+	n_root_block = move_formatted_block(fs, get_sb_root_block(ondisk_sb),
+					    blocks, 0);
+
 	if (n_root_block)
-	    set_sb_root_block (ondisk_sb, n_root_block);
+		set_sb_root_block(ondisk_sb, n_root_block);
 
 	if (opt_verbose)
-	    printf ("\n\nnodes processed (moved):\n"
-		    "int        %lu (%lu),\n"
-		    "leaves     %lu (%lu),\n" 
-		    "unfm       %lu (%lu),\n"
-		    "total      %lu (%lu).\n\n",
-		    int_node_cnt, int_moved_cnt,
-		    leaf_node_cnt, leaf_moved_cnt, 
-		    unfm_node_cnt, unfm_moved_cnt,
-		    (unsigned long)total_node_cnt, total_moved_cnt);
+		printf("\n\nnodes processed (moved):\n"
+		       "int        %lu (%lu),\n"
+		       "leaves     %lu (%lu),\n"
+		       "unfm       %lu (%lu),\n"
+		       "total      %lu (%lu).\n\n",
+		       int_node_cnt, int_moved_cnt,
+		       leaf_node_cnt, leaf_moved_cnt,
+		       unfm_node_cnt, unfm_moved_cnt,
+		       (unsigned long)total_node_cnt, total_moved_cnt);
 
 	if (block_count_mismatch) {
-	    fprintf(stderr, "resize_reiserfs: data block count %lu"
-		    " doesn\'t match data block count %lu from super block\n",
-		    (unsigned long)total_node_cnt, blocks_used);
+		fprintf(stderr, "resize_reiserfs: data block count %lu"
+			" doesn\'t match data block count %lu from super block\n",
+			(unsigned long)total_node_cnt, blocks_used);
 	}
 
 	{
-	    unsigned long l;
-
-	    /* make sure that none of truncated block are in use */
-	    printf("check for used blocks in truncated region\n");
-	    for (l = blocks; l < fs->fs_bitmap2->bm_bit_size; l ++) {
-		if ((l % (fs->fs_blocksize * 8)) == 0)
-		    continue;
-		if (reiserfs_bitmap_test_bit (fs->fs_bitmap2, l))
-		    printf ("<%lu>", l);
-	    }
-	    printf("\n");
+		unsigned long l;
+
+		/* make sure that none of truncated block are in use */
+		printf("check for used blocks in truncated region\n");
+		for (l = blocks; l < fs->fs_bitmap2->bm_bit_size; l++) {
+			if ((l % (fs->fs_blocksize * 8)) == 0)
+				continue;
+			if (reiserfs_bitmap_test_bit(fs->fs_bitmap2, l))
+				printf("<%lu>", l);
+		}
+		printf("\n");
 	}
 
 	badblock_list(fs, mark_badblock, NULL);
-	
+
 	if (fs->fs_badblocks_bm) {
 		bad_count = reiserfs_bitmap_ones(fs->fs_badblocks_bm);
-		reiserfs_shrink_bitmap (fs->fs_badblocks_bm, blocks);
+		reiserfs_shrink_bitmap(fs->fs_badblocks_bm, blocks);
 		add_badblock_list(fs, 1);
 		bad_count -= reiserfs_bitmap_ones(fs->fs_badblocks_bm);
 	} else
 		bad_count = 0;
-	
-	reiserfs_shrink_bitmap (fs->fs_bitmap2, blocks);
-
-	set_sb_free_blocks (ondisk_sb, get_sb_free_blocks(ondisk_sb)
-			    - (get_sb_block_count(ondisk_sb) - blocks)
-			    + (reiserfs_fs_bmap_nr(fs) - bmap_nr_new)
-			    + bad_count);
-	set_sb_block_count (ondisk_sb, blocks);
-	set_sb_bmap_nr (ondisk_sb, bmap_nr_new);
-
-	set_sb_bmap_nr (fs->fs_ondisk_sb,
-	                reiserfs_bmap_over(bmap_nr_new) ? 0 : bmap_nr_new);
+
+	reiserfs_shrink_bitmap(fs->fs_bitmap2, blocks);
+
+	set_sb_free_blocks(ondisk_sb, get_sb_free_blocks(ondisk_sb)
+			   - (get_sb_block_count(ondisk_sb) - blocks)
+			   + (reiserfs_fs_bmap_nr(fs) - bmap_nr_new)
+			   + bad_count);
+	set_sb_block_count(ondisk_sb, blocks);
+	set_sb_bmap_nr(ondisk_sb, bmap_nr_new);
+
+	set_sb_bmap_nr(fs->fs_ondisk_sb,
+		       reiserfs_bmap_over(bmap_nr_new) ? 0 : bmap_nr_new);
 
 	return 0;
 }
diff --git a/resize_reiserfs/fe.c b/resize_reiserfs/fe.c
index 5b65117..b37611e 100644
--- a/resize_reiserfs/fe.c
+++ b/resize_reiserfs/fe.c
@@ -6,23 +6,21 @@
 #include "resize.h"
 
 /* the front-end for kernel on-line resizer */
-int resize_fs_online(char * devname, long long int blocks) {
+int resize_fs_online(char *devname, long long int blocks)
+{
 	struct mntent *mnt;
 	char buf[40];
-	
+
 	/* Find the mount entry. */
 	if ((mnt = misc_mntent(devname)) == NULL)
-		die ("resize_reiserfs: can't find mount entry\n");
+		die("resize_reiserfs: can't find mount entry\n");
 
-	sprintf(buf,"resize=%lld", blocks);
+	sprintf(buf, "resize=%lld", blocks);
 
 	if (mount(mnt->mnt_fsname, mnt->mnt_dir, mnt->mnt_type,
-		  (unsigned long)(MS_MGC_VAL << 16 | MS_REMOUNT), buf)) 
-	{
-		die ("resize_reiserfs: remount failed: %s\n", 
-		     strerror(errno));
+		  (unsigned long)(MS_MGC_VAL << 16 | MS_REMOUNT), buf)) {
+		die("resize_reiserfs: remount failed: %s\n", strerror(errno));
 	}
 
 	return 0;
 }
-
diff --git a/resize_reiserfs/resize.h b/resize_reiserfs/resize.h
index 0d901f8..afa6b78 100644
--- a/resize_reiserfs/resize.h
+++ b/resize_reiserfs/resize.h
@@ -32,8 +32,8 @@
 #define DIE(form, args...) die("%s: " form "\n", g_progname , ## args)
 
 /* reiserfs_resize.c */
-extern struct buffer_head * g_sb_bh;
-extern char * g_progname;
+extern struct buffer_head *g_sb_bh;
+extern char *g_progname;
 
 extern int opt_force;
 extern int opt_verbose;
@@ -41,7 +41,7 @@ extern int opt_nowrite;
 extern int opt_safe;
 
 /* fe.c */
-extern int resize_fs_online(char * devname, long long int blocks);
+extern int resize_fs_online(char *devname, long long int blocks);
 
 /* do_shrink.c */
 extern int shrink_fs(reiserfs_filsys_t *, long long int blocks);
diff --git a/resize_reiserfs/resize_reiserfs.c b/resize_reiserfs/resize_reiserfs.c
index 14ae427..6802084 100644
--- a/resize_reiserfs/resize_reiserfs.c
+++ b/resize_reiserfs/resize_reiserfs.c
@@ -17,334 +17,342 @@
 
 int opt_banner = 0;
 int opt_force = 0;
-int opt_verbose = 1;			/* now "verbose" option is default */
+int opt_verbose = 1;		/* now "verbose" option is default */
 int opt_nowrite = 0;
 int opt_safe = 0;
 int opt_skipj = 0;
 
-char * g_progname;
+char *g_progname;
 
 /* calculate the new fs size (in blocks) from old fs size and the string
    representation of new size */
-static long long int calc_new_fs_size(unsigned long count, 
-				      unsigned int bs, 
-				      char *bytes_str)
+static long long int calc_new_fs_size(unsigned long count,
+				      unsigned int bs, char *bytes_str)
 {
-    long long int bytes;
-    long long int blocks;
-    char *end;
-    int rel;
-
-    end = bytes_str + strlen(bytes_str) - 1;
-    rel = bytes_str[0] == '+' || bytes_str[0] == '-';
-    bytes = strtoll(bytes_str, &bytes_str, 10);
-    
-    /* Some error occured while convertion or the specified 
-       string is not valid. */
-    if (bytes == LONG_LONG_MIN || bytes == LONG_LONG_MAX || 
-	(bytes_str != end && bytes_str != end + 1))
-	return -EINVAL;
-
-    switch (*end) {
-    case 'G':
-    case 'g':
-	bytes *= 1024;
-    case 'M':
-    case 'm':
-	bytes *= 1024;
-    case 'K':
-    case 'k':
-	bytes *= 1024;
-    }
-	
-    blocks = bytes / bs;
-
-    return rel ? count + blocks : blocks;
+	long long int bytes;
+	long long int blocks;
+	char *end;
+	int rel;
+
+	end = bytes_str + strlen(bytes_str) - 1;
+	rel = bytes_str[0] == '+' || bytes_str[0] == '-';
+	bytes = strtoll(bytes_str, &bytes_str, 10);
+
+	/* Some error occured while convertion or the specified 
+	   string is not valid. */
+	if (bytes == LONG_LONG_MIN || bytes == LONG_LONG_MAX ||
+	    (bytes_str != end && bytes_str != end + 1))
+		return -EINVAL;
+
+	switch (*end) {
+	case 'G':
+	case 'g':
+		bytes *= 1024;
+	case 'M':
+	case 'm':
+		bytes *= 1024;
+	case 'K':
+	case 'k':
+		bytes *= 1024;
+	}
+
+	blocks = bytes / bs;
+
+	return rel ? count + blocks : blocks;
 }
 
 /* print some fs parameters */
-static void sb_report(struct reiserfs_super_block * sb1,
-		      struct reiserfs_super_block * sb2)
+static void sb_report(struct reiserfs_super_block *sb1,
+		      struct reiserfs_super_block *sb2)
 {
-    printf(
-	"ReiserFS report:\n"
-	"blocksize             %u\n"
-	"block count           %u (%u)\n"
-	"free blocks           %u (%u)\n"
-	"bitmap block count    %u (%u)\n", 
-	get_sb_block_size(sb1),
-	get_sb_block_count(sb1), get_sb_block_count(sb2),
-	get_sb_free_blocks(sb1), get_sb_free_blocks(sb2),
-	get_sb_bmap_nr(sb1), get_sb_bmap_nr(sb2));
+	printf("ReiserFS report:\n"
+	       "blocksize             %u\n"
+	       "block count           %u (%u)\n"
+	       "free blocks           %u (%u)\n"
+	       "bitmap block count    %u (%u)\n",
+	       get_sb_block_size(sb1),
+	       get_sb_block_count(sb1), get_sb_block_count(sb2),
+	       get_sb_free_blocks(sb1), get_sb_free_blocks(sb2),
+	       get_sb_bmap_nr(sb1), get_sb_bmap_nr(sb2));
 };
 
 /* conditional bwrite */
-static int bwrite_cond (struct buffer_head * bh)
+static int bwrite_cond(struct buffer_head *bh)
 {
-    if(!opt_nowrite) { 
-	mark_buffer_uptodate(bh,1);
-	mark_buffer_dirty(bh);
-	bwrite(bh);
-    }
-    return 0;
+	if (!opt_nowrite) {
+		mark_buffer_uptodate(bh, 1);
+		mark_buffer_dirty(bh);
+		bwrite(bh);
+	}
+	return 0;
 }
 
-
 /* the first one of the most important functions */
-static int expand_fs (reiserfs_filsys_t * fs, long long int block_count_new) {
-    unsigned int bmap_nr_new, bmap_nr_old;
-    struct reiserfs_super_block * sb;
-    unsigned int i;
-
+static int expand_fs(reiserfs_filsys_t *fs, long long int block_count_new)
+{
+	unsigned int bmap_nr_new, bmap_nr_old;
+	struct reiserfs_super_block *sb;
+	unsigned int i;
 
-    reiserfs_reopen(fs, O_RDWR);
-    if (reiserfs_open_ondisk_bitmap (fs))
-	reiserfs_exit(1, "cannot open ondisk bitmap");
+	reiserfs_reopen(fs, O_RDWR);
+	if (reiserfs_open_ondisk_bitmap(fs))
+		reiserfs_exit(1, "cannot open ondisk bitmap");
 
-    sb = fs->fs_ondisk_sb;
+	sb = fs->fs_ondisk_sb;
 
-    set_sb_fs_state (fs->fs_ondisk_sb, FS_ERROR);
+	set_sb_fs_state(fs->fs_ondisk_sb, FS_ERROR);
 
-    bwrite_cond(fs->fs_super_bh);
+	bwrite_cond(fs->fs_super_bh);
 
+	if (reiserfs_expand_bitmap(fs->fs_bitmap2, block_count_new))
+		reiserfs_exit(1, "cannot expand bitmap\n");
 
-    if (reiserfs_expand_bitmap(fs->fs_bitmap2, block_count_new))
-	reiserfs_exit(1, "cannot expand bitmap\n");
+	/* count bitmap blocks in new fs */
+	bmap_nr_new = (block_count_new - 1) / (fs->fs_blocksize * 8) + 1;
+	bmap_nr_old = reiserfs_fs_bmap_nr(fs);
 
+	/* update super block buffer */
+	set_sb_free_blocks(sb, get_sb_free_blocks(sb) +
+			   (block_count_new - get_sb_block_count(sb)) -
+			   (bmap_nr_new - bmap_nr_old));
+	set_sb_block_count(sb, block_count_new);
 
-    /* count bitmap blocks in new fs */
-    bmap_nr_new = (block_count_new - 1) / (fs->fs_blocksize * 8) + 1;
-    bmap_nr_old = reiserfs_fs_bmap_nr(fs);
-	
-    /* update super block buffer*/
-    set_sb_free_blocks (sb, get_sb_free_blocks(sb) + 
-			(block_count_new - get_sb_block_count(sb)) - 
-			(bmap_nr_new - bmap_nr_old));
-    set_sb_block_count (sb, block_count_new);
+	set_sb_bmap_nr(fs->fs_ondisk_sb,
+		       reiserfs_bmap_over(bmap_nr_new) ? 0 : bmap_nr_new);
 
-    set_sb_bmap_nr (fs->fs_ondisk_sb,
-                    reiserfs_bmap_over(bmap_nr_new) ? 0 : bmap_nr_new);
+	/* mark new bitmap blocks as used */
+	for (i = bmap_nr_old; i < bmap_nr_new; i++)
+		reiserfs_bitmap_set_bit(fs->fs_bitmap2,
+					i * fs->fs_blocksize * 8);
 
-    /* mark new bitmap blocks as used */
-    for (i = bmap_nr_old; i < bmap_nr_new; i++)
-	reiserfs_bitmap_set_bit (fs->fs_bitmap2, i * fs->fs_blocksize * 8);
+	/* normally, this is done by reiserfs_bitmap_set_bit, but if we
+	 ** haven't actually added any bitmap blocks, the bitmap won't be dirtied.
+	 **
+	 ** In memory, reiserfsprogs puts zeros for the bits past the end of
+	 ** the old filesystem.  But, on disk that bitmap is full of ones.  
+	 ** we explicitly dirty the bitmap here to make sure the zeros get written
+	 ** to disk
+	 */
+	fs->fs_bitmap2->bm_dirty = 1;
 
-    /* normally, this is done by reiserfs_bitmap_set_bit, but if we
-    ** haven't actually added any bitmap blocks, the bitmap won't be dirtied.
-    **
-    ** In memory, reiserfsprogs puts zeros for the bits past the end of
-    ** the old filesystem.  But, on disk that bitmap is full of ones.  
-    ** we explicitly dirty the bitmap here to make sure the zeros get written
-    ** to disk
-    */
-    fs->fs_bitmap2->bm_dirty = 1 ;
-    
-    return 0;
+	return 0;
 }
 
-static int resizer_check_fs_size(reiserfs_filsys_t *fs, long long int new_size) {
-    if (new_size < 0) {
-	    reiserfs_warning(stderr, "\nresizer_reiserfs: the new size "
-			     "value is wrong.\n\n");
-	    return new_size;
-    }
-    
-    if (new_size == get_sb_block_count(fs->fs_ondisk_sb)) {
-	reiserfs_warning (stderr, "%s already is of the needed size. "
-			  "Nothing to be done\n\n", fs->fs_file_name);
-	return 1;
-    }
-
-    if (new_size < get_sb_block_count(fs->fs_ondisk_sb)) {
-	if (misc_device_mounted(fs->fs_file_name) > 0) {
-	    reiserfs_warning (stderr, "Can't shrink filesystem on-line.\n\n");
-	    return 1;
+static int resizer_check_fs_size(reiserfs_filsys_t *fs, long long int new_size)
+{
+	if (new_size < 0) {
+		reiserfs_warning(stderr, "\nresizer_reiserfs: the new size "
+				 "value is wrong.\n\n");
+		return new_size;
 	}
-    }
-
-    if (new_size >= get_sb_block_count(fs->fs_ondisk_sb)) {
-	loff_t offset = (loff_t)new_size * fs->fs_blocksize - 1;
-	
-	if(!valid_offset(fs->fs_dev, offset)) {
-	    reiserfs_warning (stderr, "%s is of %lu blocks size only with "
-			      "reiserfs of %u blocks\nsize on it. You are "
-			      "trying to expand reiserfs up to %lu blocks "
-			      "size.\nYou probably forgot to expand your "
-			      "partition size.\n\n", fs->fs_file_name,
-			      count_blocks(fs->fs_file_name, fs->fs_blocksize),
-			      get_sb_block_count(fs->fs_ondisk_sb), new_size);
-	    return 1;
+
+	if (new_size == get_sb_block_count(fs->fs_ondisk_sb)) {
+		reiserfs_warning(stderr, "%s already is of the needed size. "
+				 "Nothing to be done\n\n", fs->fs_file_name);
+		return 1;
 	}
-    }
 
-    return 0;
+	if (new_size < get_sb_block_count(fs->fs_ondisk_sb)) {
+		if (misc_device_mounted(fs->fs_file_name) > 0) {
+			reiserfs_warning(stderr,
+					 "Can't shrink filesystem on-line.\n\n");
+			return 1;
+		}
+	}
+
+	if (new_size >= get_sb_block_count(fs->fs_ondisk_sb)) {
+		loff_t offset = (loff_t) new_size * fs->fs_blocksize - 1;
+
+		if (!valid_offset(fs->fs_dev, offset)) {
+			reiserfs_warning(stderr,
+					 "%s is of %lu blocks size only with "
+					 "reiserfs of %u blocks\nsize on it. You are "
+					 "trying to expand reiserfs up to %lu blocks "
+					 "size.\nYou probably forgot to expand your "
+					 "partition size.\n\n",
+					 fs->fs_file_name,
+					 count_blocks(fs->fs_file_name,
+						      fs->fs_blocksize),
+					 get_sb_block_count(fs->fs_ondisk_sb),
+					 new_size);
+			return 1;
+		}
+	}
+
+	return 0;
 }
 
-int main(int argc, char *argv[]) {
-    char * bytes_count_str = NULL;
-    char * devname;
-    char * jdevice_name = NULL;
-    reiserfs_filsys_t * fs;
-    struct reiserfs_super_block * sb;
-
-    int c;
-    int error;
-
-    struct reiserfs_super_block *sb_old;
-
-    long long int block_count_new;
-
-    g_progname = basename(argv[0]);
-    
-    if (argc < 2)
-	print_usage_and_exit();
-	
-    while ((c = getopt(argc, argv, "fvcqks:j:V")) != EOF) {
-	switch (c) {
-	case 's' :
-	    if (!optarg)
-		reiserfs_exit(1, "Missing argument to -s option");
-	    bytes_count_str = optarg;
-	    break;
-	case 'j' :
-	    if (!optarg) 
-		reiserfs_exit(1, "Missing argument to -j option");
-	    jdevice_name = optarg;
-	case 'f':
-	    opt_force = 1;
-	    break;		 
-	case 'v':
-	    opt_verbose++; 
-	    break;
-	case 'n':
-	    /* no nowrite option at this moment */
-	    /* opt_nowrite = 1; */
-	    break;
-	case 'c':
-	    opt_safe = 1;
-	    break;
-	case 'q':
-	    opt_verbose = 0;
-	    break;
-	case 'k':
-	    opt_skipj = 1;
-	    break;
-	case 'V':
-	    opt_banner++;
-	    break;
-	default:
-	    print_usage_and_exit ();
+int main(int argc, char *argv[])
+{
+	char *bytes_count_str = NULL;
+	char *devname;
+	char *jdevice_name = NULL;
+	reiserfs_filsys_t *fs;
+	struct reiserfs_super_block *sb;
+
+	int c;
+	int error;
+
+	struct reiserfs_super_block *sb_old;
+
+	long long int block_count_new;
+
+	g_progname = basename(argv[0]);
+
+	if (argc < 2)
+		print_usage_and_exit();
+
+	while ((c = getopt(argc, argv, "fvcqks:j:V")) != EOF) {
+		switch (c) {
+		case 's':
+			if (!optarg)
+				reiserfs_exit(1,
+					      "Missing argument to -s option");
+			bytes_count_str = optarg;
+			break;
+		case 'j':
+			if (!optarg)
+				reiserfs_exit(1,
+					      "Missing argument to -j option");
+			jdevice_name = optarg;
+		case 'f':
+			opt_force = 1;
+			break;
+		case 'v':
+			opt_verbose++;
+			break;
+		case 'n':
+			/* no nowrite option at this moment */
+			/* opt_nowrite = 1; */
+			break;
+		case 'c':
+			opt_safe = 1;
+			break;
+		case 'q':
+			opt_verbose = 0;
+			break;
+		case 'k':
+			opt_skipj = 1;
+			break;
+		case 'V':
+			opt_banner++;
+			break;
+		default:
+			print_usage_and_exit();
+		}
 	}
-    }
 
-    print_banner (g_progname);
-    
-    if (opt_banner)
-	exit(0);
-    
+	print_banner(g_progname);
 
-    devname = argv[optind];
+	if (opt_banner)
+		exit(0);
 
-    fs = reiserfs_open(devname, O_RDONLY, &error, 0, 1);
-    if (!fs) {
-	if (error) {
-		reiserfs_exit(1, "cannot open '%s': %s", 
-			      devname, strerror(error));
-        } else {
-		exit(1);
+	devname = argv[optind];
+
+	fs = reiserfs_open(devname, O_RDONLY, &error, 0, 1);
+	if (!fs) {
+		if (error) {
+			reiserfs_exit(1, "cannot open '%s': %s",
+				      devname, strerror(error));
+		} else {
+			exit(1);
+		}
 	}
-    }
-
-    if (reiserfs_open_journal (fs, jdevice_name, O_RDWR | O_LARGEFILE)) {
-	reiserfs_exit(1, "Failed to open the journal device (%s).", 
-		      jdevice_name);
-    }
-    
-    if (reiserfs_journal_params_check(fs)) {
-	if (!opt_skipj) {
-	    reiserfs_exit(1, "Wrong journal parameters detected on (%s)", 
-			  jdevice_name);
-	} else {
-	    reiserfs_close_journal(fs);
+
+	if (reiserfs_open_journal(fs, jdevice_name, O_RDWR | O_LARGEFILE)) {
+		reiserfs_exit(1, "Failed to open the journal device (%s).",
+			      jdevice_name);
 	}
-    }
 
-    /* forced to continue without journal available/specified */
+	if (reiserfs_journal_params_check(fs)) {
+		if (!opt_skipj) {
+			reiserfs_exit(1,
+				      "Wrong journal parameters detected on (%s)",
+				      jdevice_name);
+		} else {
+			reiserfs_close_journal(fs);
+		}
+	}
 
-    if (no_reiserfs_found (fs)) {
-	reiserfs_exit(1, "no reiserfs found on the device.");
-    }
-    
-    if (!spread_bitmaps (fs)) {
-	reiserfs_exit(1, "cannot resize reiserfs in old (not spread "
-		      "bitmap) format.");
-    }
+	/* forced to continue without journal available/specified */
 
-    sb = fs->fs_ondisk_sb;
+	if (no_reiserfs_found(fs)) {
+		reiserfs_exit(1, "no reiserfs found on the device.");
+	}
 
-    /* If size change was specified by user, calculate it, 
-       otherwise take the whole device. */
-    block_count_new = bytes_count_str ? 
-	    calc_new_fs_size(get_sb_block_count(sb), 
+	if (!spread_bitmaps(fs)) {
+		reiserfs_exit(1, "cannot resize reiserfs in old (not spread "
+			      "bitmap) format.");
+	}
+
+	sb = fs->fs_ondisk_sb;
+
+	/* If size change was specified by user, calculate it, 
+	   otherwise take the whole device. */
+	block_count_new = bytes_count_str ?
+	    calc_new_fs_size(get_sb_block_count(sb),
 			     fs->fs_blocksize, bytes_count_str) :
 	    count_blocks(devname, fs->fs_blocksize);
 
-    if (resizer_check_fs_size(fs, block_count_new))
-	return 1;
+	if (resizer_check_fs_size(fs, block_count_new))
+		return 1;
+
+	if (misc_device_mounted(devname) > 0) {
+		reiserfs_close(fs);
+		error = resize_fs_online(devname, block_count_new);
+		reiserfs_warning(stderr,
+				 "\n\nresize_reiserfs: On-line resizing %s.\n\n",
+				 error ? "failed" : "finished successfully");
+		return error;
+	}
+
+	if (!reiserfs_is_fs_consistent(fs)) {
+		reiserfs_warning(stderr,
+				 "\n\nresize_reiserfs: run reiserfsck --check "
+				 "first\n\n");
+		reiserfs_close(fs);
+		return 1;
+	}
+
+	if (get_sb_umount_state(sb) != FS_CLEANLY_UMOUNTED)
+		/* fixme: shouldn't we check for something like: fsck guarantees: fs is ok */
+		reiserfs_exit(1, "the file system isn't in valid state.");
+
+	/* Needed to keep idiot compiler from issuing false warning */
+	sb_old = 0;
+
+	/* save SB for reporting */
+	if (opt_verbose) {
+		sb_old = getmem(SB_SIZE);
+		memcpy(sb_old, fs->fs_ondisk_sb, SB_SIZE);
+	}
+
+	error = (block_count_new > get_sb_block_count(fs->fs_ondisk_sb)) ?
+	    expand_fs(fs, block_count_new) : shrink_fs(fs, block_count_new);
+	if (error) {
+		reiserfs_warning(stderr,
+				 "\n\nresize_reiserfs: Resizing failed.\n\n ");
+		return error;
+	}
+
+	if (opt_verbose) {
+		sb_report(fs->fs_ondisk_sb, sb_old);
+		freemem(sb_old);
+	}
+
+	set_sb_fs_state(fs->fs_ondisk_sb, FS_CONSISTENT);
+	bwrite_cond(fs->fs_super_bh);
 
-    if (misc_device_mounted(devname) > 0) {
+	if (opt_verbose) {
+		printf("\nSyncing..");
+		fflush(stdout);
+	}
 	reiserfs_close(fs);
-	error = resize_fs_online(devname, block_count_new);
-	reiserfs_warning(stderr, "\n\nresize_reiserfs: On-line resizing %s.\n\n",
-			 error ? "failed" : "finished successfully");
-	return error;
-    }
-
-    if (!reiserfs_is_fs_consistent (fs)) {
-	reiserfs_warning (stderr, "\n\nresize_reiserfs: run reiserfsck --check "
-	    "first\n\n");
-	reiserfs_close (fs);
-	return 1;
-    }
-
-    if (get_sb_umount_state(sb) != FS_CLEANLY_UMOUNTED)
-	/* fixme: shouldn't we check for something like: fsck guarantees: fs is ok */
-	reiserfs_exit(1, "the file system isn't in valid state.");
-		
-    /* Needed to keep idiot compiler from issuing false warning */
-    sb_old = 0;		
-    
-    /* save SB for reporting */
-    if(opt_verbose) {
-	sb_old = getmem(SB_SIZE);
-	memcpy(sb_old, fs->fs_ondisk_sb, SB_SIZE);
-    }
-
-    error = (block_count_new > get_sb_block_count(fs->fs_ondisk_sb)) ? 
-	expand_fs(fs, block_count_new) : shrink_fs(fs, block_count_new);
-    if (error) {
-	reiserfs_warning(stderr, "\n\nresize_reiserfs: Resizing failed.\n\n ");
-	return error;
-    }
-
-    if(opt_verbose) {
-	sb_report(fs->fs_ondisk_sb, sb_old);
-	freemem(sb_old);
-    }
-
-    set_sb_fs_state (fs->fs_ondisk_sb, FS_CONSISTENT);
-    bwrite_cond(fs->fs_super_bh);
-	
-    if (opt_verbose) {
-	printf("\nSyncing..");
-	fflush(stdout);
-    }
-    reiserfs_close (fs);
-    if (opt_verbose)
-	printf("done\n");
-	
-    reiserfs_warning(stderr, "\n\nresize_reiserfs: Resizing finished "
-	"successfully.\n\n ");
-    
-    return 0;
+	if (opt_verbose)
+		printf("done\n");
+
+	reiserfs_warning(stderr, "\n\nresize_reiserfs: Resizing finished "
+			 "successfully.\n\n ");
+
+	return 0;
 }
diff --git a/tune/tune.c b/tune/tune.c
index 0facbcb..0f24237 100644
--- a/tune/tune.c
+++ b/tune/tune.c
@@ -16,59 +16,58 @@
 
 char *program_name;
 
-static void message( const char * fmt, ... ) 
-	__attribute__ ((format (printf, 1, 2)));
+static void message(const char *fmt, ...)
+    __attribute__ ((format(printf, 1, 2)));
 
-static void message( const char * fmt, ... )
+static void message(const char *fmt, ...)
 {
-    char *buf;
-    va_list args;
-	
-    buf = NULL;
-    va_start( args, fmt );
-    vasprintf( &buf, fmt, args );
-    va_end( args );
-
-    if( buf ) {
-	fprintf( stderr, "%s: %s\n", program_name, buf );
-	free( buf );
-    }
-}
+	char *buf;
+	va_list args;
 
+	buf = NULL;
+	va_start(args, fmt);
+	vasprintf(&buf, fmt, args);
+	va_end(args);
+
+	if (buf) {
+		fprintf(stderr, "%s: %s\n", program_name, buf);
+		free(buf);
+	}
+}
 
-reiserfs_filsys_t * fs;
+reiserfs_filsys_t *fs;
 
 static void print_usage_and_exit(void)
 {
-    message ("Usage: %s [options] device [block-count]\n"
-	     "\n"
-	     "Options:\n\n"
-	     "  -j | --journal-device file\tcurrent journal device\n"
-	     "  --journal-new-device file\tnew journal device\n"
-	     "  -o | --journal-new-offset N\tnew journal offset in blocks\n"
-	     "  -s | --journal-new-size N\tnew journal size in blocks\n"
-	     "  -t | --trans-max-size N\tnew journal max transaction size in blocks\n"
-	     "  --no-journal-available\tcurrent journal is not available\n"
-	     "  --make-journal-standard\tnew journal to be standard\n"
-	     /*"\t-p | --keep-old-journal-param  (keep parametrs from old journal to new one)\n"*/
-	     "  -b | --add-badblocks file\tadd to bad block list\n"
-	     "  -B | --badblocks file\t\tset the bad block list\n"
-	     "  -u | --uuid UUID|random\tset new UUID\n"
-	     "  -l | --label LABEL\t\tset new label\n"
-	     "  -f | --force\t\t\tforce tuning, less confirmations\n"
-	     "  -c | --check-interval\t\tset interval in days for fsck -a to check,\n"
-	     "                       \t\t\"disable\" to disable check,\n"
-	     "                       \t\tor \"default\" to restore default\n"
-	     "  -C | --time-last-checked\tset the time the filesystem was last checked\n"
-	     "                          \t(now or YYYYMMDD[HH[MM[SS]]])\n"
-	     "  -m | --max-mnt-count\t\tset maximum number of mounts before fsck -a\n"
-	     "                      \t\tchecks, \"disable\" to disable check,\n"
-	     "                      \t\tor \"default\" to restore default\n"
-	     "  -M | --mnt-count\t\tset the number of times the filesystem\n"
-	     "                  \t\thas been mounted\n"
-	     "  -h | --help\t\t\tprint help and exit\n"
-	     "  -V\t\t\t\tprint version and exit\n", program_name);
-    exit (1);
+	message("Usage: %s [options] device [block-count]\n"
+		"\n"
+		"Options:\n\n"
+		"  -j | --journal-device file\tcurrent journal device\n"
+		"  --journal-new-device file\tnew journal device\n"
+		"  -o | --journal-new-offset N\tnew journal offset in blocks\n"
+		"  -s | --journal-new-size N\tnew journal size in blocks\n"
+		"  -t | --trans-max-size N\tnew journal max transaction size in blocks\n"
+		"  --no-journal-available\tcurrent journal is not available\n"
+		"  --make-journal-standard\tnew journal to be standard\n"
+		/*"\t-p | --keep-old-journal-param  (keep parametrs from old journal to new one)\n" */
+		"  -b | --add-badblocks file\tadd to bad block list\n"
+		"  -B | --badblocks file\t\tset the bad block list\n"
+		"  -u | --uuid UUID|random\tset new UUID\n"
+		"  -l | --label LABEL\t\tset new label\n"
+		"  -f | --force\t\t\tforce tuning, less confirmations\n"
+		"  -c | --check-interval\t\tset interval in days for fsck -a to check,\n"
+		"                       \t\t\"disable\" to disable check,\n"
+		"                       \t\tor \"default\" to restore default\n"
+		"  -C | --time-last-checked\tset the time the filesystem was last checked\n"
+		"                          \t(now or YYYYMMDD[HH[MM[SS]]])\n"
+		"  -m | --max-mnt-count\t\tset maximum number of mounts before fsck -a\n"
+		"                      \t\tchecks, \"disable\" to disable check,\n"
+		"                      \t\tor \"default\" to restore default\n"
+		"  -M | --mnt-count\t\tset the number of times the filesystem\n"
+		"                  \t\thas been mounted\n"
+		"  -h | --help\t\t\tprint help and exit\n"
+		"  -V\t\t\t\tprint version and exit\n", program_name);
+	exit(1);
 }
 
 unsigned long Journal_size = 0;
@@ -81,158 +80,175 @@ int Offset = 0;
 __u16 Options = 0;
 int Force = 0;
 int Bads = 0;
-char * LABEL;
+char *LABEL;
 unsigned char UUID[16];
-char * badblocks_file;
+char *badblocks_file;
 
 /* If specified paramenters defines the standard journal, make it standard. */
-static int should_make_journal_standard (reiserfs_filsys_t * fs, char * j_new_dev_name)
+static int should_make_journal_standard(reiserfs_filsys_t *fs,
+					char *j_new_dev_name)
 {
-    if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
-	return 0;
+	if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
+		return 0;
 /*    
     if (!user_confirmed (stderr, "ATTENTION! Filesystem with non-standard journal "
 			 "found. Continue? (y/n):", "y\n")) {
 	exit(1);
     }
-*/  
-    /* make sure journal is on main device, it has default size
-     and the file system has non-standard magic */
- 
-    if (j_new_dev_name) {
-	/* new journal was specified - check if it is available */
-	if (strcmp (j_new_dev_name, fs->fs_file_name))
-	    return 0;
-	
-	if (Journal_size && Journal_size != 
-	    journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1) 
-	    return 0;
-	
-	if (Max_trans_size && (Max_trans_size != JOURNAL_TRANS_MAX))
-		return 0;	
-    } else {
-	/* new journal was not specified - check ondisk journal params */
-	
-	if (get_sb_reserved_for_journal(fs->fs_ondisk_sb) < 
-	    journal_default_size (fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1)
-	{
-	    message ("Can not create standard journal of the size %llu",
-		     journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1);
-	    return 0;
+*/
+	/* make sure journal is on main device, it has default size
+	   and the file system has non-standard magic */
+
+	if (j_new_dev_name) {
+		/* new journal was specified - check if it is available */
+		if (strcmp(j_new_dev_name, fs->fs_file_name))
+			return 0;
+
+		if (Journal_size && Journal_size !=
+		    journal_default_size(fs->fs_super_bh->b_blocknr,
+					 fs->fs_blocksize) + 1)
+			return 0;
+
+		if (Max_trans_size && (Max_trans_size != JOURNAL_TRANS_MAX))
+			return 0;
+	} else {
+		/* new journal was not specified - check ondisk journal params */
+
+		if (get_sb_reserved_for_journal(fs->fs_ondisk_sb) <
+		    journal_default_size(fs->fs_super_bh->b_blocknr,
+					 fs->fs_blocksize) + 1) {
+			message
+			    ("Can not create standard journal of the size %llu",
+			     journal_default_size(fs->fs_super_bh->b_blocknr,
+						  fs->fs_blocksize) + 1);
+			return 0;
+		}
 	}
-    }
 
-    return 1;
+	return 1;
 }
 
-static int set_standard_journal_params (reiserfs_filsys_t * fs)
+static int set_standard_journal_params(reiserfs_filsys_t *fs)
 {
-    struct buffer_head * bh;
-
-    /* ondisk superblock update */
-
-    if (get_sb_version(fs->fs_ondisk_sb) == 0)
-	memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_3_5_SUPER_MAGIC_STRING,
-		strlen (REISERFS_3_5_SUPER_MAGIC_STRING));
-    else if (get_sb_version(fs->fs_ondisk_sb) == 2)
-	memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_3_6_SUPER_MAGIC_STRING,
-		strlen (REISERFS_3_6_SUPER_MAGIC_STRING));
-    else {
-	message ("Can not set standard reiserfs magic: unknown format found %u,"
-		 " try reiserfsck first", get_sb_version(fs->fs_ondisk_sb));
-	return 0;
-    }
-    
-    set_jp_journal_1st_block (sb_jp(fs->fs_ondisk_sb), get_journal_start_must (fs));
-    set_jp_journal_dev (sb_jp(fs->fs_ondisk_sb), 0);
-    set_jp_journal_size (sb_jp(fs->fs_ondisk_sb), journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize));
-
-    if (get_jp_journal_max_trans_len(sb_jp(fs->fs_ondisk_sb)) != JOURNAL_TRANS_MAX)
-	set_jp_journal_max_trans_len(sb_jp(fs->fs_ondisk_sb), JOURNAL_TRANS_MAX);
-    if (get_jp_journal_max_batch(sb_jp(fs->fs_ondisk_sb)) != JOURNAL_MAX_BATCH)
-	set_jp_journal_max_batch(sb_jp(fs->fs_ondisk_sb), JOURNAL_MAX_BATCH);
-    if (get_jp_journal_max_commit_age(sb_jp(fs->fs_ondisk_sb)) != JOURNAL_MAX_COMMIT_AGE)
-	set_jp_journal_max_commit_age(sb_jp(fs->fs_ondisk_sb), JOURNAL_MAX_COMMIT_AGE);
-    if (get_jp_journal_max_trans_age(sb_jp(fs->fs_ondisk_sb)) != JOURNAL_MAX_TRANS_AGE)
-	set_jp_journal_max_trans_age(sb_jp(fs->fs_ondisk_sb), JOURNAL_MAX_TRANS_AGE);
-    set_sb_reserved_for_journal (fs->fs_ondisk_sb, 0);
-    
-    /* journal_header update */
-    bh = getblk(fs->fs_journal_dev, 
-	    get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) + 
-	    get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)), fs->fs_blocksize);
-    
-    if (!bh) {
-	message ("Cannot get the journal header block. getblk failed.\n");
-	return 0;
-    }
-    ((struct reiserfs_journal_header *)(bh->b_data))->jh_journal = *(sb_jp(fs->fs_ondisk_sb));
-    mark_buffer_uptodate (bh, 1);
-    mark_buffer_dirty (bh);
-    bwrite(bh);
-    brelse(bh);
+	struct buffer_head *bh;
+
+	/* ondisk superblock update */
+
+	if (get_sb_version(fs->fs_ondisk_sb) == 0)
+		memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+		       REISERFS_3_5_SUPER_MAGIC_STRING,
+		       strlen(REISERFS_3_5_SUPER_MAGIC_STRING));
+	else if (get_sb_version(fs->fs_ondisk_sb) == 2)
+		memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+		       REISERFS_3_6_SUPER_MAGIC_STRING,
+		       strlen(REISERFS_3_6_SUPER_MAGIC_STRING));
+	else {
+		message
+		    ("Can not set standard reiserfs magic: unknown format found %u,"
+		     " try reiserfsck first", get_sb_version(fs->fs_ondisk_sb));
+		return 0;
+	}
+
+	set_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb),
+				 get_journal_start_must(fs));
+	set_jp_journal_dev(sb_jp(fs->fs_ondisk_sb), 0);
+	set_jp_journal_size(sb_jp(fs->fs_ondisk_sb),
+			    journal_default_size(fs->fs_super_bh->b_blocknr,
+						 fs->fs_blocksize));
+
+	if (get_jp_journal_max_trans_len(sb_jp(fs->fs_ondisk_sb)) !=
+	    JOURNAL_TRANS_MAX)
+		set_jp_journal_max_trans_len(sb_jp(fs->fs_ondisk_sb),
+					     JOURNAL_TRANS_MAX);
+	if (get_jp_journal_max_batch(sb_jp(fs->fs_ondisk_sb)) !=
+	    JOURNAL_MAX_BATCH)
+		set_jp_journal_max_batch(sb_jp(fs->fs_ondisk_sb),
+					 JOURNAL_MAX_BATCH);
+	if (get_jp_journal_max_commit_age(sb_jp(fs->fs_ondisk_sb)) !=
+	    JOURNAL_MAX_COMMIT_AGE)
+		set_jp_journal_max_commit_age(sb_jp(fs->fs_ondisk_sb),
+					      JOURNAL_MAX_COMMIT_AGE);
+	if (get_jp_journal_max_trans_age(sb_jp(fs->fs_ondisk_sb)) !=
+	    JOURNAL_MAX_TRANS_AGE)
+		set_jp_journal_max_trans_age(sb_jp(fs->fs_ondisk_sb),
+					     JOURNAL_MAX_TRANS_AGE);
+	set_sb_reserved_for_journal(fs->fs_ondisk_sb, 0);
+
+	/* journal_header update */
+	bh = getblk(fs->fs_journal_dev,
+		    get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb)) +
+		    get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)),
+		    fs->fs_blocksize);
+
+	if (!bh) {
+		message
+		    ("Cannot get the journal header block. getblk failed.\n");
+		return 0;
+	}
+	((struct reiserfs_journal_header *)(bh->b_data))->jh_journal =
+	    *(sb_jp(fs->fs_ondisk_sb));
+	mark_buffer_uptodate(bh, 1);
+	mark_buffer_dirty(bh);
+	bwrite(bh);
+	brelse(bh);
 
-    return 1;
+	return 1;
 }
 
-void zero_journal (reiserfs_filsys_t * fs)
+void zero_journal(reiserfs_filsys_t *fs)
 {
-    unsigned int i;
-    struct buffer_head * bh;
-    unsigned long done;
-    unsigned long start, len;
-
-
-    fprintf (stderr, "Initializing journal - ");
-
-    start = get_jp_journal_1st_block (sb_jp (fs->fs_ondisk_sb));
-    len = get_jp_journal_size (sb_jp (fs->fs_ondisk_sb));
-    done = 0;
-    for (i = 0; i < len; i ++) {
-        print_how_far (stderr, &done, len, 1, 1/*be quiet*/);
-        bh = getblk (fs->fs_journal_dev, start + i, fs->fs_blocksize);
-	if (!bh)
-	    die ("zero_journal: getblk failed");
-        memset (bh->b_data, 0, bh->b_size);
-        mark_buffer_dirty (bh);
-        mark_buffer_uptodate (bh, 1);
-        bwrite (bh);
-        brelse (bh);
-    }
+	unsigned int i;
+	struct buffer_head *bh;
+	unsigned long done;
+	unsigned long start, len;
+
+	fprintf(stderr, "Initializing journal - ");
+
+	start = get_jp_journal_1st_block(sb_jp(fs->fs_ondisk_sb));
+	len = get_jp_journal_size(sb_jp(fs->fs_ondisk_sb));
+	done = 0;
+	for (i = 0; i < len; i++) {
+		print_how_far(stderr, &done, len, 1, 1 /*be quiet */ );
+		bh = getblk(fs->fs_journal_dev, start + i, fs->fs_blocksize);
+		if (!bh)
+			die("zero_journal: getblk failed");
+		memset(bh->b_data, 0, bh->b_size);
+		mark_buffer_dirty(bh);
+		mark_buffer_uptodate(bh, 1);
+		bwrite(bh);
+		brelse(bh);
+	}
 
-    fprintf (stderr, "\n");
-    fflush (stderr);
+	fprintf(stderr, "\n");
+	fflush(stderr);
 }
 
-
-static int str2int (char * str)
+static int str2int(char *str)
 {
-    int val;
-    char * tmp;
-
-    val = (int) strtol (str, &tmp, 0);
-    if (*tmp)
-	die ("%s: strtol is unable to make an integer of %s\n", program_name, str);
-    return val;
+	int val;
+	char *tmp;
+
+	val = (int)strtol(str, &tmp, 0);
+	if (*tmp)
+		die("%s: strtol is unable to make an integer of %s\n",
+		    program_name, str);
+	return val;
 }
 
-
-static void set_transaction_max_size (char * str)
+static void set_transaction_max_size(char *str)
 {
-    Max_trans_size = str2int( str );
+	Max_trans_size = str2int(str);
 }
 
-
 /* journal must fit into number of blocks pointed by first bitmap */
-static void set_journal_device_size (char * str)
+static void set_journal_device_size(char *str)
 {
-    Journal_size = str2int (str) ;
+	Journal_size = str2int(str);
 }
 
-
-static void set_offset_in_journal_device (char * str)
+static void set_offset_in_journal_device(char *str)
 {
-    Offset = str2int( str );
+	Offset = str2int(str);
 }
 
 static void set_max_mnt_count(char *str)
@@ -268,590 +284,630 @@ static void set_time_last_checked(char *str)
 		Time_last_checked = parse_time(str);
 
 	if (Time_last_checked == 0)
-		print_usage_and_exit ();
+		print_usage_and_exit();
 }
 
-static void callback_new_badblocks(reiserfs_filsys_t *fs, 
-				   struct reiserfs_path *badblock_path, 
-				   void *data) 
+static void callback_new_badblocks(reiserfs_filsys_t *fs,
+				   struct reiserfs_path *badblock_path,
+				   void *data)
 {
 	struct item_head *tmp_ih;
 	__u32 *ind_item, i;
 
 	tmp_ih = get_ih(badblock_path);
-	ind_item = (__u32 *)get_item(badblock_path);
+	ind_item = (__u32 *) get_item(badblock_path);
 
 	for (i = 0; i < I_UNFM_NUM(tmp_ih); i++) {
-		if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, 
-					     d32_get (ind_item, i)))
-		{
-			message("Block %u is marked as bad already.", 
-				d32_get (ind_item, i));
-			
-			reiserfs_bitmap_clear_bit(fs->fs_badblocks_bm, 
-						  d32_get (ind_item, i));
+		if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm,
+					     d32_get(ind_item, i))) {
+			message("Block %u is marked as bad already.",
+				d32_get(ind_item, i));
+
+			reiserfs_bitmap_clear_bit(fs->fs_badblocks_bm,
+						  d32_get(ind_item, i));
 		}
 	}
-	
-	pathrelse (badblock_path);
+
+	pathrelse(badblock_path);
 }
 
-static void callback_clear_badblocks(reiserfs_filsys_t *fs, 
-				     struct reiserfs_path *badblock_path, 
-				     void *data) 
+static void callback_clear_badblocks(reiserfs_filsys_t *fs,
+				     struct reiserfs_path *badblock_path,
+				     void *data)
 {
 	struct item_head *tmp_ih;
 	__u32 *ind_item, i;
 
 	tmp_ih = get_ih(badblock_path);
-	ind_item = (__u32 *)get_item(badblock_path);
+	ind_item = (__u32 *) get_item(badblock_path);
 
 	for (i = 0; i < I_UNFM_NUM(tmp_ih); i++) {
-		reiserfs_bitmap_clear_bit(fs->fs_bitmap2, 
-					  d32_get(ind_item, i));
+		reiserfs_bitmap_clear_bit(fs->fs_bitmap2, d32_get(ind_item, i));
 	}
-	
-	pathrelse (badblock_path);
+
+	pathrelse(badblock_path);
 }
 
-static void add_badblocks(reiserfs_filsys_t *fs) {
+static void add_badblocks(reiserfs_filsys_t *fs)
+{
 	unsigned long i, marked = 0;
-	
-	if (reiserfs_open_ondisk_bitmap (fs) < 0) {
-	    message("Failed to open reiserfs ondisk bitmap.\n");
-	    reiserfs_close(fs);
-	    exit(1);
+
+	if (reiserfs_open_ondisk_bitmap(fs) < 0) {
+		message("Failed to open reiserfs ondisk bitmap.\n");
+		reiserfs_close(fs);
+		exit(1);
 	}
-	
-	if (create_badblock_bitmap (fs, badblocks_file)) {
-	    message("Failed to initialize the bad block bitmap.\n");
-	    reiserfs_close(fs);
-	    exit(1);
+
+	if (create_badblock_bitmap(fs, badblocks_file)) {
+		message("Failed to initialize the bad block bitmap.\n");
+		reiserfs_close(fs);
+		exit(1);
 	}
-	
+
 	if (Bads == 1)
 		badblock_list(fs, callback_new_badblocks, NULL);
 	else
 		badblock_list(fs, callback_clear_badblocks, NULL);
-	
-	for (i = 0; i < get_sb_block_count (fs->fs_ondisk_sb); i ++) {
-	    if (reiserfs_bitmap_test_bit (fs->fs_badblocks_bm, i)) {
-		if (!reiserfs_bitmap_test_bit (fs->fs_bitmap2, i)) {
-		    reiserfs_bitmap_set_bit (fs->fs_bitmap2, i);
-		    marked++;
-		} else {
-		    /* Check that this is a block  */
-		    message("Bad block %lu is used already in reiserfs tree. "
-			    "To mark it as a bad block use reiserfsck\n"
-			    "--fix-fixable with -B option.", i);
 
-		    reiserfs_bitmap_clear_bit (fs->fs_badblocks_bm, i);
+	for (i = 0; i < get_sb_block_count(fs->fs_ondisk_sb); i++) {
+		if (reiserfs_bitmap_test_bit(fs->fs_badblocks_bm, i)) {
+			if (!reiserfs_bitmap_test_bit(fs->fs_bitmap2, i)) {
+				reiserfs_bitmap_set_bit(fs->fs_bitmap2, i);
+				marked++;
+			} else {
+				/* Check that this is a block  */
+				message
+				    ("Bad block %lu is used already in reiserfs tree. "
+				     "To mark it as a bad block use reiserfsck\n"
+				     "--fix-fixable with -B option.", i);
+
+				reiserfs_bitmap_clear_bit(fs->fs_badblocks_bm,
+							  i);
+			}
 		}
-	    }
 	}
-	
+
 	if (marked) {
-		set_sb_free_blocks(fs->fs_ondisk_sb, get_sb_free_blocks(fs->fs_ondisk_sb) - 
+		set_sb_free_blocks(fs->fs_ondisk_sb,
+				   get_sb_free_blocks(fs->fs_ondisk_sb) -
 				   fs->fs_badblocks_bm->bm_set_bits);
 		mark_buffer_dirty(fs->fs_super_bh);
 	}
-	
+
 	if (Bads == 1) {
 		/* fs->fs_badblocks_bm contains blocks which are not in the bad 
 		   block list yet. Merge it with what is in the tree already. */
 		badblock_list(fs, mark_badblock, NULL);
 	}
-	
+
 	if (marked) {
 		add_badblock_list(fs, 1);
 	}
-	
+
 	message("%lu blocks were marked as bad.", marked);
 }
 
-int main (int argc, char **argv)
+int main(int argc, char **argv)
 {
-    reiserfs_filsys_t * fs;
-    char * device_name;
-    char * jdevice_name;
-    char * j_new_device_name;
-    int c;
-    static int flag;
-    struct reiserfs_journal_header * j_head;
-    reiserfs_trans_t old, new;
-    int Is_journal_or_maxtrans_size_specified = 0;
-
-    program_name = strrchr( argv[ 0 ], '/' );
-
-    if (program_name)
-	program_name++;
-    else 
-	program_name = argv[ 0 ];
-    
-    if (argc < 2)
-	print_usage_and_exit ();
-    
-    device_name = 0;
-    jdevice_name = 0;
-    j_new_device_name = 0;
-
-    memset(UUID, 0, 16);
-    
-    while (1) {
-	static struct option options[] = {
-	    {"help", no_argument, 0, 'h'},
-	    {"journal-device", required_argument, 0, 'j'},
-	    {"journal-new-device", required_argument, &flag, OPT_NEW_J},
-	    {"journal-new-size", required_argument, 0, 's'},
-	    {"trans-max-size", required_argument, 0, 't'},
-	    {"journal-new-offset", required_argument, 0, 'o'},
-	    {"no-journal-available", no_argument, &flag, OPT_SKIP_J},
-	    /*{"keep-old-journal-param", no_argument, 0, 'p'},*/
-	    {"uuid", required_argument, 0, 'u'},
-	    {"label", required_argument, 0, 'l'},
-	    {"add-badblocks", required_argument, 0, 'b'},
-	    {"badblocks", required_argument, 0, 'B'},
-	    {"force", no_argument, 0, 'f'},
-	    {"make-journal-standard", no_argument, &flag, OPT_STANDARD},
-	    {"check-interval", required_argument, 0, 'c'},
-	    {"time-last-checked", required_argument, 0, 'C'},
-	    {"max-mount-count", required_argument, 0, 'm'},
-	    {"mount-count", required_argument, 0, 'M'},
-	    {0, 0, 0, 0}
-	};
-	int option_index;
-      
-	c = getopt_long (argc, argv, "hj:s:t:o:fu:l:b:B:Vc:C:m:M:",
-			 options, &option_index);
-	if (c == -1)
-	    break;
-	
-	switch (c) {
-	case 0:
-	    /* long-only optins */
-	    if (flag == OPT_NEW_J) {
-		Options |= OPT_NEW_J;
-		j_new_device_name = optarg;
-	    }
-	    if (flag == OPT_SKIP_J) {
-		Options |= OPT_SKIP_J;
-	    }
-	    if (flag == OPT_STANDARD) {
-		Options |=OPT_STANDARD;
-	    } 
-	    break;
-	case 'j': /* --journal-device */
-	    jdevice_name = optarg;
-	    break;
-
-	case 's': /* --journal-new-size */
-	    set_journal_device_size (optarg);
-	    Is_journal_or_maxtrans_size_specified = 1;
-	    break;
-	    
-	case 't': /* --trans-max-size */
-	    set_transaction_max_size (optarg);
-	    Is_journal_or_maxtrans_size_specified = 1;
-	    break;
-	    
-	case 'o': /* --offset */
-	    set_offset_in_journal_device (optarg);
-	    break;
-	    
-	case 'f':
-	    /* forces replacing standard journal with non-standard
-	       one. Specified more than once - allows to avoid asking for
-	       confirmation */
-	    Force ++;
-	    break;
-	case 'b': /* --add-badblocks */
-	    asprintf (&badblocks_file, "%s", optarg);
-	    Bads = 1;
-	    break;
-	case 'B': /* --badblocks */
-	    asprintf (&badblocks_file, "%s", optarg);
-	    Bads = 2;
-	    break;
-	case 'u':
-	    /* UUID */
+	reiserfs_filsys_t *fs;
+	char *device_name;
+	char *jdevice_name;
+	char *j_new_device_name;
+	int c;
+	static int flag;
+	struct reiserfs_journal_header *j_head;
+	reiserfs_trans_t old, new;
+	int Is_journal_or_maxtrans_size_specified = 0;
+
+	program_name = strrchr(argv[0], '/');
+
+	if (program_name)
+		program_name++;
+	else
+		program_name = argv[0];
+
+	if (argc < 2)
+		print_usage_and_exit();
+
+	device_name = 0;
+	jdevice_name = 0;
+	j_new_device_name = 0;
+
+	memset(UUID, 0, 16);
+
+	while (1) {
+		static struct option options[] = {
+			{"help", no_argument, 0, 'h'},
+			{"journal-device", required_argument, 0, 'j'},
+			{"journal-new-device", required_argument, &flag,
+			 OPT_NEW_J},
+			{"journal-new-size", required_argument, 0, 's'},
+			{"trans-max-size", required_argument, 0, 't'},
+			{"journal-new-offset", required_argument, 0, 'o'},
+			{"no-journal-available", no_argument, &flag,
+			 OPT_SKIP_J},
+			/*{"keep-old-journal-param", no_argument, 0, 'p'}, */
+			{"uuid", required_argument, 0, 'u'},
+			{"label", required_argument, 0, 'l'},
+			{"add-badblocks", required_argument, 0, 'b'},
+			{"badblocks", required_argument, 0, 'B'},
+			{"force", no_argument, 0, 'f'},
+			{"make-journal-standard", no_argument, &flag,
+			 OPT_STANDARD},
+			{"check-interval", required_argument, 0, 'c'},
+			{"time-last-checked", required_argument, 0, 'C'},
+			{"max-mount-count", required_argument, 0, 'm'},
+			{"mount-count", required_argument, 0, 'M'},
+			{0, 0, 0, 0}
+		};
+		int option_index;
+
+		c = getopt_long(argc, argv, "hj:s:t:o:fu:l:b:B:Vc:C:m:M:",
+				options, &option_index);
+		if (c == -1)
+			break;
+
+		switch (c) {
+		case 0:
+			/* long-only optins */
+			if (flag == OPT_NEW_J) {
+				Options |= OPT_NEW_J;
+				j_new_device_name = optarg;
+			}
+			if (flag == OPT_SKIP_J) {
+				Options |= OPT_SKIP_J;
+			}
+			if (flag == OPT_STANDARD) {
+				Options |= OPT_STANDARD;
+			}
+			break;
+		case 'j':	/* --journal-device */
+			jdevice_name = optarg;
+			break;
+
+		case 's':	/* --journal-new-size */
+			set_journal_device_size(optarg);
+			Is_journal_or_maxtrans_size_specified = 1;
+			break;
+
+		case 't':	/* --trans-max-size */
+			set_transaction_max_size(optarg);
+			Is_journal_or_maxtrans_size_specified = 1;
+			break;
+
+		case 'o':	/* --offset */
+			set_offset_in_journal_device(optarg);
+			break;
+
+		case 'f':
+			/* forces replacing standard journal with non-standard
+			   one. Specified more than once - allows to avoid asking for
+			   confirmation */
+			Force++;
+			break;
+		case 'b':	/* --add-badblocks */
+			asprintf(&badblocks_file, "%s", optarg);
+			Bads = 1;
+			break;
+		case 'B':	/* --badblocks */
+			asprintf(&badblocks_file, "%s", optarg);
+			Bads = 2;
+			break;
+		case 'u':
+			/* UUID */
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-	    if (!strcmp(optarg, "random")) {
-		uuid_generate(UUID);
-	    } else {
-		if (uuid_parse(optarg, UUID) < 0) {
-		    message ("Invalid UUID '%s' was specified\n", optarg);
-		    return 1;
-		}
-	    }
+			if (!strcmp(optarg, "random")) {
+				uuid_generate(UUID);
+			} else {
+				if (uuid_parse(optarg, UUID) < 0) {
+					message
+					    ("Invalid UUID '%s' was specified\n",
+					     optarg);
+					return 1;
+				}
+			}
 #else
-	    message ("Cannot set the UUID, uuidlib was not found "
-		     "by configure.\n");
-	    return 1;
+			message("Cannot set the UUID, uuidlib was not found "
+				"by configure.\n");
+			return 1;
 #endif
-            break;
-	case 'l':
-	    /* LABEL */
-	    LABEL = optarg;
-            break;
-	case 'V':
-	    print_banner("reiserfstune");
-	    exit(0);
-	case 'h':
-	    print_usage_and_exit();
-	    break;
-	case 'c':
-	    set_check_interval(optarg);
-	    break;
-	case 'C':
-	    set_time_last_checked(optarg);
-	    break;
-	case 'm':
-	    set_max_mnt_count(optarg);
-	    break;
-	case 'M':
-	    set_mnt_count(optarg);
-	    break;
+			break;
+		case 'l':
+			/* LABEL */
+			LABEL = optarg;
+			break;
+		case 'V':
+			print_banner("reiserfstune");
+			exit(0);
+		case 'h':
+			print_usage_and_exit();
+			break;
+		case 'c':
+			set_check_interval(optarg);
+			break;
+		case 'C':
+			set_time_last_checked(optarg);
+			break;
+		case 'm':
+			set_max_mnt_count(optarg);
+			break;
+		case 'M':
+			set_mnt_count(optarg);
+			break;
 
 #if 0
-	case 'J': /* --journal-new-device */
-	    Options |= OPT_NEW_J;
-	    j_new_device_name = optarg;
-	    break;
-
-	case 'u':  /* --no-journal-available */
-	    Options |= OPT_SKIPJ;
-	    break;
-
-	case 'p':  /* --keep-old-journal-param */
-	    Options |= OPT_KEEPO;
-	    break;
-#endif    
-	default:
-	    print_usage_and_exit();
+		case 'J':	/* --journal-new-device */
+			Options |= OPT_NEW_J;
+			j_new_device_name = optarg;
+			break;
+
+		case 'u':	/* --no-journal-available */
+			Options |= OPT_SKIPJ;
+			break;
+
+		case 'p':	/* --keep-old-journal-param */
+			Options |= OPT_KEEPO;
+			break;
+#endif
+		default:
+			print_usage_and_exit();
+		}
 	}
-    }
-    
-    if (optind != argc - 1)
-	print_usage_and_exit ();
 
-    /* device to be formatted */
-    device_name = argv [optind];
-
-    fs = reiserfs_open (device_name, O_RDONLY, 0, NULL, 1);
-    if (no_reiserfs_found(fs)) {
-	message ("Cannot open reiserfs on %s", device_name);
-        return 1;
-    }
+	if (optind != argc - 1)
+		print_usage_and_exit();
 
-    /* journal was opened or it wasn't opened but the option
-       --no-journal-available has been specified by user */
+	/* device to be formatted */
+	device_name = argv[optind];
 
-    /* make sure filesystem is not mounted */
-    if (misc_device_mounted(fs->fs_file_name) > 0) {
-	/* fixme: it can not be mounted, btw */
-        message ("Reiserfstune is not allowed to be run on mounted filesystem.");
-	reiserfs_close (fs);
-        return 1;
-    }
-    
-    if (!reiserfs_is_fs_consistent (fs)) {
-	message ("Filesystem looks not cleanly umounted, check the consistency first.\n");
-	reiserfs_close (fs);
-	return 1;
-    }
+	fs = reiserfs_open(device_name, O_RDONLY, 0, NULL, 1);
+	if (no_reiserfs_found(fs)) {
+		message("Cannot open reiserfs on %s", device_name);
+		return 1;
+	}
 
-    reiserfs_reopen (fs, O_RDWR);
-    
-    if (badblocks_file) {
-	add_badblocks(fs);
-	
-	reiserfs_close(fs);
-	exit(0);
-    }
-    
-    if (!jdevice_name && !(Options & OPT_SKIP_J)) {
-	message ("Journal device has not been specified. Assuming journal is on the main "
-	    "device (%s).\n", device_name);
-        jdevice_name = device_name;
-    }
+	/* journal was opened or it wasn't opened but the option
+	   --no-journal-available has been specified by user */
 
-    if (jdevice_name && (Options & OPT_SKIP_J)) {
-	message ("Either specify journal device, "
-		 "or choose the option --no-journal-available");
-	return 1;
-    }
-    
-    if (j_new_device_name && (Options & OPT_STANDARD)) {
-	/* New device was specified and --make-journal-standard was also. */
-	message ("Either specify new journal device, "
-		 "or choose the option --make-journal-standard");
-	return 1;
-    }
-    
-    /* now we try to open journal, it makes sence if there is no the flag
-       NEED_TUNE  in ondisk superblock and --no-journal available is not 
-       specified. */
-    if (get_jp_journal_magic(sb_jp(fs->fs_ondisk_sb)) != NEED_TUNE && 
-	!(Options & OPT_SKIP_J)) 
-    {
-	if (reiserfs_open_journal (fs, jdevice_name, O_RDWR 
-#if defined(O_LARGEFILE)
-				   | O_LARGEFILE
-#endif
-				   )) 
-	{
-	    message ("Failed to open the journal device (%s).", jdevice_name);
-	    return 1;
+	/* make sure filesystem is not mounted */
+	if (misc_device_mounted(fs->fs_file_name) > 0) {
+		/* fixme: it can not be mounted, btw */
+		message
+		    ("Reiserfstune is not allowed to be run on mounted filesystem.");
+		reiserfs_close(fs);
+		return 1;
 	}
 
-	if (reiserfs_journal_params_check(fs)) {
-	    message ("Unable to open old journal. Wrong journal parameters.");
-	    reiserfs_close (fs);
-	    return 1;
-	}
-    }
-    
-    /* in spite of journal was opened, the file system can be non-consistent or
-       there are non-replayed transaction in journal, 
-       make sure it isn't (if there is no the flag NEED_TUNE in ondisk superblock */
-    if (get_jp_journal_magic(sb_jp(fs->fs_ondisk_sb)) != NEED_TUNE &&
-	reiserfs_journal_opened (fs)) {
-	j_head = (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
-	if (get_boundary_transactions(fs, &old, &new)) {
-	    if (new.trans_id != get_jh_last_flushed(j_head)) {
-		message ("There are non-replayed transaction in old journal,"
-			 " check filesystem consistency first");
-		reiserfs_close (fs);
+	if (!reiserfs_is_fs_consistent(fs)) {
+		message
+		    ("Filesystem looks not cleanly umounted, check the consistency first.\n");
+		reiserfs_close(fs);
 		return 1;
-	    }
 	}
-	if (!reiserfs_is_fs_consistent (fs)) {
-	    message ("Check filesystem consistency first");
-	    reiserfs_close (fs);
-	    return 1;
-	} 
-    }
 
-    /* set UUID and LABEL if specified */
-    if (fs->fs_format == REISERFS_FORMAT_3_6) {
-	int need_dirty = 0;
-#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-        if (!uuid_is_null(UUID)) {
-	    memcpy (fs->fs_ondisk_sb->s_uuid, UUID, 16);
-	    need_dirty = 1;
-	}
-#endif	
-	if (LABEL != NULL) {
-	    if (strlen (LABEL) > 16)
-	        message ("Specified LABEL is longer then 16 characters, will be truncated\n");
-	    strncpy (fs->fs_ondisk_sb->s_label, LABEL, 16);
-	    need_dirty = 1;
+	reiserfs_reopen(fs, O_RDWR);
+
+	if (badblocks_file) {
+		add_badblocks(fs);
+
+		reiserfs_close(fs);
+		exit(0);
 	}
-	if (Max_mnt_count &&
-	    Max_mnt_count != get_sb_v2_max_mnt_count(fs->fs_ondisk_sb)) {
-		if (Max_mnt_count <= 0)
-			reiserfs_exit(1, "max-mnt-count must be > 0\n");
-		set_sb_v2_max_mnt_count(fs->fs_ondisk_sb, Max_mnt_count);
-		need_dirty = 1;
+
+	if (!jdevice_name && !(Options & OPT_SKIP_J)) {
+		message
+		    ("Journal device has not been specified. Assuming journal is on the main "
+		     "device (%s).\n", device_name);
+		jdevice_name = device_name;
 	}
 
-	if (Mnt_count &&
-	    Mnt_count != get_sb_v2_mnt_count(fs->fs_ondisk_sb)) {
-		if (Max_mnt_count <= 0)
-			reiserfs_exit(1, "max-mnt-count must be > 0\n");
-		set_sb_v2_mnt_count(fs->fs_ondisk_sb, Mnt_count);
-		need_dirty = 1;
+	if (jdevice_name && (Options & OPT_SKIP_J)) {
+		message("Either specify journal device, "
+			"or choose the option --no-journal-available");
+		return 1;
 	}
 
-	if (Check_interval &&
-	    Check_interval != get_sb_v2_check_interval(fs->fs_ondisk_sb)) {
-		if (Check_interval <= 0)
-			reiserfs_exit(1, "check-interval must be > 0\n");
-		set_sb_v2_check_interval(fs->fs_ondisk_sb,
-					       Check_interval);
-		need_dirty = 1;
+	if (j_new_device_name && (Options & OPT_STANDARD)) {
+		/* New device was specified and --make-journal-standard was also. */
+		message("Either specify new journal device, "
+			"or choose the option --make-journal-standard");
+		return 1;
 	}
-	if (Time_last_checked &&
-	    Time_last_checked != get_sb_v2_lastcheck(fs->fs_ondisk_sb)) {
-		set_sb_v2_lastcheck(fs->fs_ondisk_sb, Time_last_checked);
-		need_dirty = 1;
+
+	/* now we try to open journal, it makes sence if there is no the flag
+	   NEED_TUNE  in ondisk superblock and --no-journal available is not 
+	   specified. */
+	if (get_jp_journal_magic(sb_jp(fs->fs_ondisk_sb)) != NEED_TUNE &&
+	    !(Options & OPT_SKIP_J)) {
+		if (reiserfs_open_journal(fs, jdevice_name, O_RDWR
+#if defined(O_LARGEFILE)
+					  | O_LARGEFILE
+#endif
+		    )) {
+			message("Failed to open the journal device (%s).",
+				jdevice_name);
+			return 1;
+		}
+
+		if (reiserfs_journal_params_check(fs)) {
+			message
+			    ("Unable to open old journal. Wrong journal parameters.");
+			reiserfs_close(fs);
+			return 1;
+		}
 	}
 
-	if (need_dirty) {
-	    mark_buffer_dirty (fs->fs_super_bh);
-	    fs->fs_dirt = 1;
+	/* in spite of journal was opened, the file system can be non-consistent or
+	   there are non-replayed transaction in journal, 
+	   make sure it isn't (if there is no the flag NEED_TUNE in ondisk superblock */
+	if (get_jp_journal_magic(sb_jp(fs->fs_ondisk_sb)) != NEED_TUNE &&
+	    reiserfs_journal_opened(fs)) {
+		j_head =
+		    (struct reiserfs_journal_header *)(fs->fs_jh_bh->b_data);
+		if (get_boundary_transactions(fs, &old, &new)) {
+			if (new.trans_id != get_jh_last_flushed(j_head)) {
+				message
+				    ("There are non-replayed transaction in old journal,"
+				     " check filesystem consistency first");
+				reiserfs_close(fs);
+				return 1;
+			}
+		}
+		if (!reiserfs_is_fs_consistent(fs)) {
+			message("Check filesystem consistency first");
+			reiserfs_close(fs);
+			return 1;
+		}
 	}
-    } else {
+
+	/* set UUID and LABEL if specified */
+	if (fs->fs_format == REISERFS_FORMAT_3_6) {
+		int need_dirty = 0;
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
-        if (!uuid_is_null(UUID))
-            reiserfs_exit (1, "UUID cannot be specified for 3.5 format\n");
+		if (!uuid_is_null(UUID)) {
+			memcpy(fs->fs_ondisk_sb->s_uuid, UUID, 16);
+			need_dirty = 1;
+		}
 #endif
-        if (LABEL)
-            reiserfs_exit (1, "LABEL cannot be specified for 3.5 format\n");
+		if (LABEL != NULL) {
+			if (strlen(LABEL) > 16)
+				message
+				    ("Specified LABEL is longer then 16 characters, will be truncated\n");
+			strncpy(fs->fs_ondisk_sb->s_label, LABEL, 16);
+			need_dirty = 1;
+		}
+		if (Max_mnt_count &&
+		    Max_mnt_count !=
+		    get_sb_v2_max_mnt_count(fs->fs_ondisk_sb)) {
+			if (Max_mnt_count <= 0)
+				reiserfs_exit(1, "max-mnt-count must be > 0\n");
+			set_sb_v2_max_mnt_count(fs->fs_ondisk_sb,
+						Max_mnt_count);
+			need_dirty = 1;
+		}
 
-	if (Max_mnt_count)
-	    reiserfs_exit (1, "max-mnt-count cannot be specified for 3.5 format\n");
-	if (Check_interval)
-	    reiserfs_exit (1, "check-interval cannot be specified for 3.5 format\n");
-    }
+		if (Mnt_count &&
+		    Mnt_count != get_sb_v2_mnt_count(fs->fs_ondisk_sb)) {
+			if (Max_mnt_count <= 0)
+				reiserfs_exit(1, "max-mnt-count must be > 0\n");
+			set_sb_v2_mnt_count(fs->fs_ondisk_sb, Mnt_count);
+			need_dirty = 1;
+		}
+
+		if (Check_interval &&
+		    Check_interval !=
+		    get_sb_v2_check_interval(fs->fs_ondisk_sb)) {
+			if (Check_interval <= 0)
+				reiserfs_exit(1,
+					      "check-interval must be > 0\n");
+			set_sb_v2_check_interval(fs->fs_ondisk_sb,
+						 Check_interval);
+			need_dirty = 1;
+		}
+		if (Time_last_checked &&
+		    Time_last_checked !=
+		    get_sb_v2_lastcheck(fs->fs_ondisk_sb)) {
+			set_sb_v2_lastcheck(fs->fs_ondisk_sb,
+					    Time_last_checked);
+			need_dirty = 1;
+		}
 
+		if (need_dirty) {
+			mark_buffer_dirty(fs->fs_super_bh);
+			fs->fs_dirt = 1;
+		}
+	} else {
+#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
+		if (!uuid_is_null(UUID))
+			reiserfs_exit(1,
+				      "UUID cannot be specified for 3.5 format\n");
+#endif
+		if (LABEL)
+			reiserfs_exit(1,
+				      "LABEL cannot be specified for 3.5 format\n");
+
+		if (Max_mnt_count)
+			reiserfs_exit(1,
+				      "max-mnt-count cannot be specified for 3.5 format\n");
+		if (Check_interval)
+			reiserfs_exit(1,
+				      "check-interval cannot be specified for 3.5 format\n");
+	}
 
-    if (!j_new_device_name) {
-	
-	/* new journal device hasn't been specified */
-	printf ("Current parameters:\n");
-	print_filesystem_state (stdout, fs);
-	print_block (stdout, fs, fs->fs_super_bh);
+	if (!j_new_device_name) {
+
+		/* new journal device hasn't been specified */
+		printf("Current parameters:\n");
+		print_filesystem_state(stdout, fs);
+		print_block(stdout, fs, fs->fs_super_bh);
+
+		if ((Options & OPT_STANDARD)
+		    && should_make_journal_standard(fs, j_new_device_name)) {
+			if (!user_confirmed
+			    (stderr,
+			     "ATTENTION! Filesystem with "
+			     "non-standard journal found. Continue? (y/n):",
+			     "y\n")) {
+				exit(1);
+			}
+
+			fs->fs_journal_dev = fs->fs_dev;
+			if (set_standard_journal_params(fs)) {
+				printf("\nNew parameters:\n");
+				print_filesystem_state(stdout, fs);
+				print_block(stdout, fs, fs->fs_super_bh);
+				printf("New journal parameters:\n");
+				print_journal_params(stdout,
+						     sb_jp(fs->fs_ondisk_sb));
+				mark_buffer_dirty(fs->fs_super_bh);
+				mark_buffer_uptodate(fs->fs_super_bh, 1);
+				reiserfs_close(fs);
+				printf("Syncing..");
+				fflush(stdout);
+				sync();
+				printf("ok\n");
+				return 0;
+			}
+		}
 
-	if ((Options & OPT_STANDARD)
-	    && should_make_journal_standard(fs, j_new_device_name)) 
-	{
-	    if (!user_confirmed (stderr, "ATTENTION! Filesystem with "
-		"non-standard journal found. Continue? (y/n):", "y\n")) 
-	    {
-		exit(1);
-	    }
-
-	    fs->fs_journal_dev = fs->fs_dev;
-	    if (set_standard_journal_params (fs)) {
-		printf ("\nNew parameters:\n");
-		print_filesystem_state (stdout, fs);
-		print_block (stdout, fs, fs->fs_super_bh);
-		printf ("New journal parameters:\n");
-		print_journal_params (stdout, sb_jp (fs->fs_ondisk_sb));
-		mark_buffer_dirty (fs->fs_super_bh);
-		mark_buffer_uptodate (fs->fs_super_bh, 1);
-		reiserfs_close (fs);
-		printf ("Syncing.."); fflush (stdout);
-		sync ();
-		printf ("ok\n");
-		return 0;
-	    }
+		if (Is_journal_or_maxtrans_size_specified) {
+			/* new journal device hasn't been specified, but
+			   journal size or max transaction size have been, so we suppose
+			   that journal device remains the same */
+			if (!reiserfs_journal_opened(fs)) {
+				message
+				    ("Cannot set up new paramenters for not specified journal.");
+				return 1;
+			}
+
+			j_new_device_name = jdevice_name;
+		} else {
+			/* the only parameter has been specified is device_name, so
+			   there is nothing to do */
+			reiserfs_close(fs);
+			return 0;
+		}
 	}
-	
-	if (Is_journal_or_maxtrans_size_specified) {
-	    /* new journal device hasn't been specified, but
-	       journal size or max transaction size have been, so we suppose
-	       that journal device remains the same */
-	    if (!reiserfs_journal_opened (fs)) {
-		message("Cannot set up new paramenters for not specified journal.");
+
+	/* new journal device has been specified */
+	/* make sure new journal device is block device file */
+	if (!can_we_format_it(j_new_device_name, Force)) {
+		reiserfs_close(fs);
 		return 1;
-	    }
-	
-	    j_new_device_name = jdevice_name;
-	} else {	
-	    /* the only parameter has been specified is device_name, so
-	       there is nothing to do */
-	    reiserfs_close (fs);
-	    return 0;
 	}
-    }
-		    
-    /* new journal device has been specified */
-    /* make sure new journal device is block device file */
-    if (!can_we_format_it (j_new_device_name, Force)) {
-	reiserfs_close (fs);
-        return 1;
-    }
 
-    if (!strcmp (device_name, j_new_device_name)) {
-	unsigned long reserved, journal_size;
-	/* we have to put journal on main device. It is only possible if there
-	   is enough space reserved by mkreiserfs */
+	if (!strcmp(device_name, j_new_device_name)) {
+		unsigned long reserved, journal_size;
+		/* we have to put journal on main device. It is only possible if there
+		   is enough space reserved by mkreiserfs */
+
+		if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb))
+			/* standard journal */
+			reserved =
+			    get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)) + 1;
+		else
+			/* non-standard journal */
+			reserved =
+			    get_sb_reserved_for_journal(fs->fs_ondisk_sb);
+
+		journal_size = Journal_size;
+
+		if (!journal_size) {
+			journal_size =
+			    journal_default_size(fs->fs_super_bh->b_blocknr,
+						 fs->fs_blocksize) + 1;
+			message
+			    ("Journal size has not been specified. Assuming it is the default size (%lu)",
+			     journal_size);
+		}
 
-	if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb))
-	    /* standard journal */
-	    reserved = get_jp_journal_size(sb_jp(fs->fs_ondisk_sb)) + 1;
-	else
-	    /* non-standard journal */
-	    reserved = get_sb_reserved_for_journal (fs->fs_ondisk_sb);
-		
-	journal_size = Journal_size;
-	
-	if (!journal_size) {
-	    journal_size = journal_default_size(fs->fs_super_bh->b_blocknr, fs->fs_blocksize) + 1;
-	    message("Journal size has not been specified. Assuming it is the default size (%lu)", 
-		journal_size);
-	}
-	
 /*	journal_size = (Journal_size ? Journal_size : // specified
 			(fs->fs_blocksize == 1024 ? (fs->fs_blocksize) * 8 - 3 -
 			 REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize :
 			 JOURNAL_DEFAULT_SIZE + 1));	// default
 */
-	if (journal_size + Offset > get_journal_start_must (fs) + reserved) {
-		message ("There is no enough space reserved for journal on main "
-			 "device (journal_size=%lu, reserved=%lu)\n", journal_size,
-			 reserved);
-	    reiserfs_close (fs);
-	    return 1;
+		if (journal_size + Offset >
+		    get_journal_start_must(fs) + reserved) {
+			message
+			    ("There is no enough space reserved for journal on main "
+			     "device (journal_size=%lu, reserved=%lu)\n",
+			     journal_size, reserved);
+			reiserfs_close(fs);
+			return 1;
+		}
 	}
-    }
 
-    message ("Current journal parameters:");
-    print_journal_params (stdout, sb_jp (fs->fs_ondisk_sb));
-
-    if (!is_reiserfs_jr_magic_string (fs->fs_ondisk_sb)) {
-	/* we have standard journal, so check if we can convert it
-	   to non-standard one */
-	
-	/*
-	if (!should_make_journal_non_standard (Force)) {
-	    reiserfs_close (fs);
-	    return 1;
+	message("Current journal parameters:");
+	print_journal_params(stdout, sb_jp(fs->fs_ondisk_sb));
+
+	if (!is_reiserfs_jr_magic_string(fs->fs_ondisk_sb)) {
+		/* we have standard journal, so check if we can convert it
+		   to non-standard one */
+
+		/*
+		   if (!should_make_journal_non_standard (Force)) {
+		   reiserfs_close (fs);
+		   return 1;
+		   }
+		 */
+
+		if (is_reiserfs_3_6_magic_string(fs->fs_ondisk_sb))
+			set_sb_version(fs->fs_ondisk_sb, REISERFS_FORMAT_3_6);
+		else if (is_reiserfs_3_5_magic_string(fs->fs_ondisk_sb))
+			set_sb_version(fs->fs_ondisk_sb, REISERFS_FORMAT_3_5);
+		else {
+			message
+			    ("Could not convert from unknown version, try reiserfsck first");
+			reiserfs_close(fs);
+			return 1;
+		}
+
+		memcpy(fs->fs_ondisk_sb->s_v1.s_magic,
+		       REISERFS_JR_SUPER_MAGIC_STRING,
+		       strlen(REISERFS_JR_SUPER_MAGIC_STRING));
+		set_sb_reserved_for_journal(fs->fs_ondisk_sb,
+					    get_jp_journal_size(sb_jp
+								(fs->
+								 fs_ondisk_sb))
+					    + 1);
 	}
-	*/
-	
-        if (is_reiserfs_3_6_magic_string (fs->fs_ondisk_sb))
-	    set_sb_version (fs->fs_ondisk_sb, REISERFS_FORMAT_3_6);
-        else if (is_reiserfs_3_5_magic_string (fs->fs_ondisk_sb))
-	    set_sb_version (fs->fs_ondisk_sb, REISERFS_FORMAT_3_5);
-        else {
-            message ("Could not convert from unknown version, try reiserfsck first");
-	    reiserfs_close (fs);
-            return 1;
-        }
-        
-	memcpy (fs->fs_ondisk_sb->s_v1.s_magic, REISERFS_JR_SUPER_MAGIC_STRING,
-		strlen (REISERFS_JR_SUPER_MAGIC_STRING));
-	set_sb_reserved_for_journal (fs->fs_ondisk_sb,
-		get_jp_journal_size (sb_jp(fs->fs_ondisk_sb)) + 1);
-    }
 
-    /* now we are going to close old journal and to create a new one */
-    reiserfs_close_journal (fs);
+	/* now we are going to close old journal and to create a new one */
+	reiserfs_close_journal(fs);
 
-    if (!reiserfs_create_journal (fs, j_new_device_name, Offset,
-				  Journal_size, Max_trans_size, Force)) {
-	message ("Could not create new journal");
-	reiserfs_close (fs);
-        return 1;
-    }
+	if (!reiserfs_create_journal(fs, j_new_device_name, Offset,
+				     Journal_size, Max_trans_size, Force)) {
+		message("Could not create new journal");
+		reiserfs_close(fs);
+		return 1;
+	}
+
+	if (should_make_journal_standard(fs, j_new_device_name))
+		set_standard_journal_params(fs);
 
-    if (should_make_journal_standard (fs, j_new_device_name))
-	set_standard_journal_params (fs);
+	message("New journal parameters:");
+	print_journal_params(stdout, sb_jp(fs->fs_ondisk_sb));
 
-    message ("New journal parameters:");
-    print_journal_params (stdout, sb_jp (fs->fs_ondisk_sb));
+	print_block(stdout, fs, fs->fs_super_bh);
 
-    print_block (stdout, fs, fs->fs_super_bh);
+	if (Force < 2) {
+		message
+		    ("ATTENTION: YOU ARE ABOUT TO SETUP THE NEW JOURNAL FOR THE \"%s\"!\n"
+		     "AREA OF \"%s\" DEDICATED FOR JOURNAL WILL BE ZEROED!",
+		     device_name, j_new_device_name);
 
-    if (Force < 2) {
-        message ("ATTENTION: YOU ARE ABOUT TO SETUP THE NEW JOURNAL FOR THE \"%s\"!\n"
-                 "AREA OF \"%s\" DEDICATED FOR JOURNAL WILL BE ZEROED!",
-		 device_name, j_new_device_name);
-        
-        if (!user_confirmed (stderr, "Continue (y/n):", "y\n")) {
-            return 1;
+		if (!user_confirmed(stderr, "Continue (y/n):", "y\n")) {
+			return 1;
+		}
 	}
-    }
 
-    zero_journal (fs);    
-    reiserfs_close (fs);
-    
-    printf ("Syncing.."); fflush (stdout);
-    sync ();
-    printf ("ok\n");
+	zero_journal(fs);
+	reiserfs_close(fs);
+
+	printf("Syncing..");
+	fflush(stdout);
+	sync();
+	printf("ok\n");
 
-    return 0;
+	return 0;
 }