reiserfsprogs patch queue

@@ -656,8 +656,10 @@ int main (int argc, char **argv)
 
     print_banner (program_name);
 
-    misc_print_credit(stdout);
-    printf("\n");
+    if (!(mode & QUIET_MODE)) {
+	misc_print_credit(stdout);
+	printf("\n");
+    }
     
     if (mode & QUIET_MODE)
 	fclose(stdout);

@@ -740,7 +742,6 @@ int main (int argc, char **argv)
 
 
     invalidate_other_formats (fs->fs_dev);
-
     zero_journal (fs);
 
     reiserfs_close (fs);

@@ -751,11 +752,7 @@ int main (int argc, char **argv)
  
     if (mode & DEBUG_MODE)
 	return 0;
-    
-    printf("\nTell your friends to use a kernel based on 2.4.18 or "
-	"later, and especially not a\nkernel based on 2.4.9, "
-	"when you use reiserFS. Have fun.\n\n");
-        
+
     printf("ReiserFS is successfully created on %s.\n", device_name);
 
     return 0;

@@ -686,6 +686,9 @@ int main (int argc, char **argv)
     
     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))

@@ -1175,6 +1175,24 @@ void make_sure_root_dir_exists (reiserfs
     		&parent_root_dir_key, ih_flags);
 }
 
+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);
+    }
+
+    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 */

@@ -15,7 +15,7 @@
 /* 2 bytes for the counter */
 #define BM_SIZE				(ALLOC_SIZE - sizeof(__u16))
 #define BM_INTERVAL			(BM_SIZE * 8)
-#define INDEX_COUNT			(MAX_ID / BM_INTERVAL)
+#define INDEX_COUNT			((MAX_ID / BM_INTERVAL) + 1)
 
 #define id_map_interval(map, id)	(map->index + (id / BM_INTERVAL))
 

@@ -346,7 +346,7 @@ int reiserfs_open_journal (reiserfs_fils
 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 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);

@@ -702,7 +702,7 @@ int main (int argc, char **argv)
     }
 		
     if (!reiserfs_create_journal (fs, jdevice_name, Offset, Journal_size, 
-	Max_trans_size)) 
+	Max_trans_size, force))
     {
         return 1;
     }

62 lines not on this page · raw message

@@ -710,7 +710,7 @@ int main (int argc, char **argv)
     reiserfs_close_journal (fs);
 
     if (!reiserfs_create_journal (fs, j_new_device_name, Offset,
-				  Journal_size, Max_trans_size)) {
+				  Journal_size, Max_trans_size, Force)) {
 	message ("Could not create new journal");
 	reiserfs_close (fs);
         return 1;

@@ -924,21 +924,6 @@ static void clean_attributes (reiserfs_f
 
 }
 
-/* Do not allow buffers to be flushed after finishing to avoid another bitmap 
- * reading on mounting. */
-static void fsck_sleep() {
-    int res;
-    
-    res = fork();
-    
-    if (res == -1) {
-	reiserfs_panic ("reiserfsck: Fork failed: %s", strerror(errno));
-    } else if (res == 0) {
-	/* Make the child process to sleep for 5 secs. */
-	sleep(5);
-    }
-}
-
 static int auto_check (reiserfs_filsys_t *fs) {
     __u16 state;
     int retval = 0;

@@ -1005,8 +990,6 @@ static int auto_check (reiserfs_filsys_t
     
     clean_after_dma_check(fs->fs_dev, &dma_info);
     
-    fsck_sleep();
-    
     reiserfs_close (fs);
     /* do not do anything else. */    
     exit (EXIT_OK);

@@ -206,7 +206,7 @@ reiserfs_filsys_t * reiserfs_create (cha
 	return 0;
     }
 
-    fs->fs_dev = open (filename, O_RDWR 
+    fs->fs_dev = open (filename, O_RDWR | O_EXCL
 #if defined(O_LARGEFILE)
 		       | O_LARGEFILE
 #endif

@@ -27,6 +27,7 @@
 #include <stdarg.h>
 #include <string.h>
 #include <errno.h>
+#include <limits.h>
 #include <sys/utsname.h>
 
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)

@@ -434,6 +435,21 @@ static int str2int (char * str)
     return val;
 }
 
+static __u64 str2u64 (char *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_block_size (char * str, int *b_size)
 {

@@ -537,7 +553,7 @@ int main (int argc, char **argv)
     int force = 0;
     char * device_name = NULL;
     char * jdevice_name = NULL;
-    unsigned long fs_size = 0;
+    __u64 fs_size = 0;
     int c;
     static int flag;
 

@@ -672,7 +688,7 @@ int main (int argc, char **argv)
     
     if (optind == argc - 2) {
         /* number of blocks for filesystem is specified */
-        fs_size = str2int (argv[optind + 1]);
+        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)))

@@ -681,6 +697,27 @@ int main (int argc, char **argv)
         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;
+	} else {
+	    fprintf(stderr, "Exiting.\n\n");
+	    exit(1);
+	}
+    }
+
     if (is_journal_default (device_name, jdevice_name, Block_size))
         Create_default_journal = 1;
     

@@ -157,7 +157,7 @@ static void edit_super_block (reiserfs_f
 		strncpy (fs->fs_ondisk_sb->s_v1.s_magic, str, n > 10 ? 10 : n);
     
     /* __u16 sb_fsck_state; */
-    printf ("\tFielsystem state: current: %u: new:", get_sb_fs_state (fs->fs_ondisk_sb));
+    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);

@@ -809,7 +809,7 @@ void do_bitmap_corruption (reiserfs_fils
 	struct buffer_head * bh;
 	unsigned int i;
 
-	nr_bitmap_to_corrupt = (unsigned long)get_rand (1, get_sb_bmap_nr (fs->fs_ondisk_sb) - 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);

@@ -581,13 +581,12 @@ static void pack_frozen_data (reiserfs_f
     /* 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).. ", 
-		      get_sb_bmap_nr (fs->fs_ondisk_sb));
+    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 < get_sb_bmap_nr (fs->fs_ondisk_sb); i ++) {
+    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);

@@ -142,9 +142,10 @@ static void init_control_bitmap (reiserf
     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(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.");
 

@@ -161,7 +162,7 @@ static void init_control_bitmap (reiserf
 
     /* bitmaps */
     block = fs->fs_super_bh->b_blocknr + 1;
-    for (i = 0; i < get_sb_bmap_nr (fs->fs_ondisk_sb); i ++) {
+    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
         we_met_it (block);
 
 	if (spread_bitmaps (fs))

@@ -1802,7 +1802,7 @@ static void init_source_bitmap (reiserfs
     block = fs->fs_super_bh->b_blocknr + 1;
 
     reserved = fsck_source_bitmap(fs)->bm_bit_size;
-    for (i = 0; i < get_sb_bmap_nr (fs->fs_ondisk_sb); i ++) {
+    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 */
 	

@@ -483,7 +483,7 @@ static void init_new_bitmap (reiserfs_fi
 
     /* mark bitmap blocks as used */
     block = fs->fs_super_bh->b_blocknr + 1;
-    for (i = 0; i < get_sb_bmap_nr (fs->fs_ondisk_sb); i ++) {
+    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);

@@ -178,7 +178,7 @@ void rebuild_sb (reiserfs_filsys_t * fs,
     int magic_was_found = 0;
     unsigned long block_count = 0;
     __u16 p_oid_maxsize;
-    __u16 p_bmap_nr;
+    unsigned int bmap_nr;
     __u32 p_jp_journal_1st_block = 0;
     __u32 p_jp_dev_size = 0;
     int standard_journal = -1;

@@ -446,12 +446,16 @@ void rebuild_sb (reiserfs_filsys_t * fs,
 	set_sb_oid_maxsize (sb, p_oid_maxsize);
     }
 
-    p_bmap_nr = (block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8);
-    if (get_sb_bmap_nr (sb) != p_bmap_nr) {
-	fsck_log("rebuild-sb: wrong bitmap number occured (%lu), fixed (%lu)\n", 
-		get_sb_bmap_nr (sb), p_bmap_nr);
-	set_sb_bmap_nr (sb, 
-		(block_count + (fs->fs_blocksize * 8 - 1)) / (fs->fs_blocksize * 8));
+    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);
     }
 
     if (get_sb_root_block (sb) > block_count) {

@@ -152,6 +152,9 @@ void mark_badblock(reiserfs_filsys_t *fs
 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))
 
 extern struct key root_dir_key;
 extern struct key parent_root_dir_key;

@@ -166,6 +169,7 @@ int reiserfs_create_ondisk_bitmap (reise
 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);

@@ -223,7 +223,7 @@ static void make_bitmap (reiserfs_filsys
     /* mark bitmaps as used */
     block = fs->fs_super_bh->b_blocknr + 1;
 
-    for (i = 0; i < get_sb_bmap_nr (sb); i ++) {
+    for (i = 0; i < reiserfs_fs_bmap_nr(fs); i ++) {
 	reiserfs_bitmap_set_bit (fs->fs_bitmap2, block);
 	marked ++;
 	if (spread_bitmaps (fs))

@@ -350,8 +350,11 @@ static void report (reiserfs_filsys_t * 
     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\n", get_sb_bmap_nr (sb));
-        reiserfs_warning (stdout, "Root block: %u\n", get_sb_root_block (sb));
+        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));

@@ -685,25 +685,35 @@ void reiserfs_free_ondisk_bitmap (reiser
     }
 }
 
-
 /* read bitmap blocks */
 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 (get_sb_block_count (fs->fs_ondisk_sb));
+    fs->fs_bitmap2 = reiserfs_create_bitmap (blocks);
     if (!fs->fs_bitmap2)
 	return -1;
 
-    if ((get_sb_block_count (fs->fs_ondisk_sb) + fs->fs_blocksize * 8 - 1) / 
-	(fs->fs_blocksize * 8) != 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");
+    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);
 }

@@ -720,7 +730,6 @@ int reiserfs_create_ondisk_bitmap (reise
     return 1;
 }
 
-
 void reiserfs_close_ondisk_bitmap (reiserfs_filsys_t * fs)
 {
     if (!fs->fs_bitmap2)

@@ -372,7 +372,7 @@ int block_of_bitmap (reiserfs_filsys_t *
 	return (block == (REISERFS_DISK_OFFSET_IN_BYTES / fs->fs_blocksize + 1)) ;
     } else {
 	/* bitmap in */
-	return (block > 2ul && block < 3ul + get_sb_bmap_nr(fs->fs_ondisk_sb)) ? 1 : 0;
+	return (block > 2ul && block < 3ul + reiserfs_fs_bmap_nr(fs)) ? 1 : 0;
     }
     return 0;
 }

@@ -641,8 +641,10 @@ int print_super_block (FILE * fp, reiser
 		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\n", get_sb_bmap_nr (sb));
-	reiserfs_warning (fp, "Blocksize: %d\n", get_sb_block_size (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));

@@ -916,7 +918,7 @@ void print_bmap (FILE * fp, reiserfs_fil
 
 
     sb = fs->fs_ondisk_sb;
-    bmap_nr = get_sb_bmap_nr (sb);
+    bmap_nr = reiserfs_fs_bmap_nr(fs);
     bits_per_block = fs->fs_blocksize * 8;
     blocks = bits_per_block;
 

@@ -160,6 +160,7 @@ reiserfs_filsys_t * reiserfs_open (char 
     fs->fs_flags = flags; /* O_RDONLY or O_RDWR */
 
     fs->fs_format = get_reiserfs_format (sb);
+
     
     /*reiserfs_read_bitmap_blocks(fs);*/
     if (flags & O_RDWR)

@@ -181,6 +182,7 @@ reiserfs_filsys_t * reiserfs_create (cha
 				     int new_format)
 {
     reiserfs_filsys_t * fs;
+    unsigned int bmap_nr = reiserfs_bmap_nr(block_count, block_size);;
 
 
     /* convert root dir key and parent root dir key to little endian format */

@@ -278,8 +280,10 @@ reiserfs_filsys_t * reiserfs_create (cha
     /* sb_fsck_state */
     /* sb_hash_function_code */
     /* sb_tree_height */
+
     set_sb_bmap_nr (fs->fs_ondisk_sb,
-		    (block_count + (block_size * 8 - 1)) / (block_size * 8));
+                    reiserfs_bmap_over(bmap_nr) ? 0 : bmap_nr);
+
     set_sb_version (fs->fs_ondisk_sb, version);
     /* sb_not_used1 */
 

@@ -187,8 +187,7 @@ int shrink_fs(reiserfs_filsys_t * fs, lo
 
 	/* is shrinking possible ? */
 	if (get_sb_block_count(ondisk_sb) - blocks > 
-	    get_sb_free_blocks(ondisk_sb) + get_sb_bmap_nr(ondisk_sb) - 
-	    bmap_nr_new) 
+	    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");

@@ -226,7 +225,7 @@ int shrink_fs(reiserfs_filsys_t * fs, lo
 	blocks_used = 
 	    get_sb_block_count(fs->fs_ondisk_sb)
 	    - get_sb_free_blocks(fs->fs_ondisk_sb)
-	    - get_sb_bmap_nr(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 */

@@ -289,10 +288,13 @@ int shrink_fs(reiserfs_filsys_t * fs, lo
 
 	set_sb_free_blocks (ondisk_sb, get_sb_free_blocks(ondisk_sb)
 			    - (get_sb_block_count(ondisk_sb) - blocks)
-			    + (get_sb_bmap_nr(ondisk_sb) - bmap_nr_new)
+			    + (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;
 }

@@ -114,14 +114,16 @@ static int expand_fs (reiserfs_filsys_t 
 
     /* count bitmap blocks in new fs */
     bmap_nr_new = (block_count_new - 1) / (fs->fs_blocksize * 8) + 1;
-    bmap_nr_old = get_sb_bmap_nr(sb);
+    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 (sb, 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++)

@@ -62,7 +62,8 @@ int main (int argc, char * argv []);
 #define OPT_SAVE_PASSES_DUMP            1 << 7
 #define OPT_SAVE_ROLLBACK               1 << 8
 #define OPT_YES				1 << 9
-#define BADBLOCKS_FILE               	1 << 10
+#define BADBLOCKS_FILE			1 << 10
+#define OPT_FORCE			1 << 11
 
 
 /* pass0.c */

138 lines not on this page · raw message

@@ -0,0 +1,15 @@
+/*
+ * Copyright 1996-2004 by Hans Reiser, licensing governed by
+ * reiserfsprogs/README
+ */
+
+/* nothing abount reiserfs here */
+
+#ifndef TIME_H
+#define TIME_H
+
+#include <time.h>
+
+time_t parse_time(char *str);
+
+#endif /* TIME_H */

@@ -194,7 +194,11 @@ struct reiserfs_super_block
 /* 80 */     __u32 s_flags;                /* Right now used only by inode-attributes, if enabled */
 /* 84 */    unsigned char s_uuid[16];      /* filesystem unique identifier */
 /*100 */    unsigned char s_label[16];     /* filesystem volume label */
-/*116 */    char s_unused[88] ;            /* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
+/*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__));;

@@ -258,6 +262,22 @@ typedef enum {
 #define get_sb_v2_inode_generation(sb)		get_le32 (sb, sb_inode_generation)
 #define set_sb_v2_inode_generation(sb,val)	set_le32 (sb, sb_inode_generation, val)
 
+#define get_sb_v2_mnt_count(sb)		get_le16 (sb, s_mnt_count)
+#define set_sb_v2_mnt_count(sb,val)	set_le16 (sb, s_mnt_count, val)
+
+#define get_sb_v2_max_mnt_count(sb)				\
+	get_le16 (sb, s_max_mnt_count)
+#define set_sb_v2_max_mnt_count(sb,val)			\
+	set_le16 (sb, s_max_mnt_count, val)
+
+#define get_sb_v2_lastcheck(sb)		get_le32 (sb, s_lastcheck)
+#define set_sb_v2_lastcheck(sb,val)		set_le32 (sb, s_lastcheck, val)
+
+#define get_sb_v2_check_interval(sb)				\
+	get_le32 (sb, s_check_interval)
+#define set_sb_v2_check_interval(sb,val)			\
+	set_le32 (sb, s_check_interval, val)
+
 #define get_sb_v2_flags(sb)		get_le32 (sb, s_flags)
 #define set_sb_v2_flags(sb, val)	set_le32 (sb, s_flags, val)
 

@@ -269,6 +289,9 @@ typedef enum {
 #define journal_is_relocated(sb)        get_jp_journal_dev(sb_jp (sb))
 */
 
+#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. */

@@ -0,0 +1,36 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "misc.h"
+#include "reiserfs_lib.h"
+
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+
+time_t parse_time(char *str)
+{
+	struct tm ts;
+
+	if (strcmp(str, "now") == 0) {
+		return (time(0));
+	}
+	memset(&ts, 0, sizeof (ts));
+#ifdef HAVE_STRPTIME
+	strptime(str, "%Y%m%d%H%M%S", &ts);
+#else
+	sscanf(str, "%4d%2d%2d%2d%2d%2d", &ts.tm_year, &ts.tm_mon,
+	       &ts.tm_mday, &ts.tm_hour, &ts.tm_min, &ts.tm_sec);
+	ts.tm_year -= 1900;
+	ts.tm_mon -= 1;
+	if (ts.tm_year < 0 || ts.tm_mon < 0 || ts.tm_mon > 11 ||
+	    ts.tm_mday < 0 || ts.tm_mday > 31 || ts.tm_hour > 23 ||
+	    ts.tm_min > 59 || ts.tm_sec > 61)
+		ts.tm_mday = 0;
+#endif
+	if (ts.tm_mday == 0)
+		reiserfs_warning(stderr, "Couldn't parse date/time "
+		                 "specifier: %s", str);
+	return (mktime(&ts));
+}

@@ -9,6 +9,8 @@
 #include <stdarg.h>
 #include <limits.h>
 #include <printf.h>
+#include <limits.h>
+#include <time.h>
 
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
 #  include <uuid/uuid.h>

@@ -612,6 +614,8 @@ int print_super_block (FILE * fp, reiser
     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;

@@ -680,6 +684,31 @@ int print_super_block (FILE * fp, reiser
         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;

@@ -7,6 +7,7 @@
 
 #include "includes.h"
 #include <linux/kdev_t.h>
+#include <time.h>
 
 struct key root_dir_key = {0, 0, {{0, 0},}};
 struct key parent_root_dir_key = {0, 0, {{0, 0},}};

@@ -183,6 +184,7 @@ reiserfs_filsys_t * reiserfs_create (cha
 {
     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 */

@@ -285,6 +287,11 @@ reiserfs_filsys_t * reiserfs_create (cha
                     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);

188 lines not on this page · raw message

@@ -62,7 +62,8 @@ int main (int argc, char * argv []);
 #define OPT_SAVE_PASSES_DUMP            1 << 7
 #define OPT_SAVE_ROLLBACK               1 << 8
 #define OPT_YES				1 << 9
-#define BADBLOCKS_FILE               	1 << 10
+#define BADBLOCKS_FILE			1 << 10
+#define OPT_FORCE			1 << 11
 
 
 /* pass0.c */

138 lines not on this page · raw message

@@ -0,0 +1,15 @@
+/*
+ * Copyright 1996-2004 by Hans Reiser, licensing governed by
+ * reiserfsprogs/README
+ */
+
+/* nothing abount reiserfs here */
+
+#ifndef TIME_H
+#define TIME_H
+
+#include <time.h>
+
+time_t parse_time(char *str);
+
+#endif /* TIME_H */

@@ -202,7 +202,11 @@ struct reiserfs_super_block
 /* 80 */     __u32 s_flags;                /* Right now used only by inode-attributes, if enabled */
 /* 84 */    unsigned char s_uuid[16];      /* filesystem unique identifier */
 /*100 */    unsigned char s_label[16];     /* filesystem volume label */
-/*116 */    char s_unused[88] ;            /* zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()
+/*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__));;

@@ -266,6 +270,22 @@ typedef enum {
 #define get_sb_v2_inode_generation(sb)		get_le32 (sb, sb_inode_generation)
 #define set_sb_v2_inode_generation(sb,val)	set_le32 (sb, sb_inode_generation, val)
 
+#define get_sb_v2_mnt_count(sb)		get_le16 (sb, s_mnt_count)
+#define set_sb_v2_mnt_count(sb,val)	set_le16 (sb, s_mnt_count, val)
+
+#define get_sb_v2_max_mnt_count(sb)				\
+	get_le16 (sb, s_max_mnt_count)
+#define set_sb_v2_max_mnt_count(sb,val)			\
+	set_le16 (sb, s_max_mnt_count, val)
+
+#define get_sb_v2_lastcheck(sb)		get_le32 (sb, s_lastcheck)
+#define set_sb_v2_lastcheck(sb,val)		set_le32 (sb, s_lastcheck, val)
+
+#define get_sb_v2_check_interval(sb)				\
+	get_le32 (sb, s_check_interval)
+#define set_sb_v2_check_interval(sb,val)			\
+	set_le32 (sb, s_check_interval, val)
+
 #define get_sb_v2_flags(sb)		get_le32 (sb, s_flags)
 #define set_sb_v2_flags(sb, val)	set_le32 (sb, s_flags, val)
 

@@ -277,6 +297,9 @@ typedef enum {
 #define journal_is_relocated(sb)        get_jp_journal_dev(sb_jp (sb))
 */
 
+#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. */

@@ -0,0 +1,37 @@
+#define _XOPEN_SOURCE
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "misc.h"
+#include "reiserfs_lib.h"
+
+#include <time.h>
+#include <stdio.h>
+#include <string.h>
+
+time_t parse_time(char *str)
+{
+	struct tm ts;
+
+	if (strcmp(str, "now") == 0) {
+		return (time(0));
+	}
+	memset(&ts, 0, sizeof (ts));
+#ifdef HAVE_STRPTIME
+	strptime(str, "%Y%m%d%H%M%S", &ts);
+#else
+	sscanf(str, "%4d%2d%2d%2d%2d%2d", &ts.tm_year, &ts.tm_mon,
+	       &ts.tm_mday, &ts.tm_hour, &ts.tm_min, &ts.tm_sec);
+	ts.tm_year -= 1900;
+	ts.tm_mon -= 1;
+	if (ts.tm_year < 0 || ts.tm_mon < 0 || ts.tm_mon > 11 ||
+	    ts.tm_mday < 0 || ts.tm_mday > 31 || ts.tm_hour > 23 ||
+	    ts.tm_min > 59 || ts.tm_sec > 61)
+		ts.tm_mday = 0;
+#endif
+	if (ts.tm_mday == 0)
+		reiserfs_warning(stderr, "Couldn't parse date/time "
+		                 "specifier: %s", str);
+	return (mktime(&ts));
+}

@@ -9,6 +9,8 @@
 #include <stdarg.h>
 #include <limits.h>
 #include <printf.h>
+#include <limits.h>
+#include <time.h>
 
 #if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
 #  include <uuid/uuid.h>

@@ -612,6 +614,8 @@ int print_super_block (FILE * fp, reiser
     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;

@@ -680,6 +684,31 @@ int print_super_block (FILE * fp, reiser
         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;

@@ -7,6 +7,7 @@
 
 #include "includes.h"
 #include <linux/kdev_t.h>
+#include <time.h>
 
 struct key root_dir_key = {0, 0, {{0, 0},}};
 struct key parent_root_dir_key = {0, 0, {{0, 0},}};

@@ -183,6 +184,7 @@ reiserfs_filsys_t * reiserfs_create (cha
 {
     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 */

@@ -285,6 +287,11 @@ reiserfs_filsys_t * reiserfs_create (cha
                     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);

188 lines not on this page · raw message

@@ -92,6 +92,7 @@ void reiserfs_read_bitmap_blocks (reiser
 void reiserfs_free_bitmap_blocks (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);
 //unsigned long min_block_amount (int block_size, unsigned long journal_size);

@@ -686,6 +686,9 @@ int main (int argc, char **argv)
     
     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))

@@ -1175,6 +1175,24 @@ void make_sure_root_dir_exists (reiserfs
     		&parent_root_dir_key, ih_flags);
 }
 
+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);
+    }
+
+    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 */

@@ -1124,7 +1124,7 @@ void check_fs_tree (reiserfs_filsys_t * 
 {
     before_check_fs_tree (fs);
     
-    fsck_progress ("Checking internal tree..");
+    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) */

@@ -4,6 +4,7 @@
  */
 
 #include "fsck.h"
+#include "progbar.h"
 
 struct tree_balance * cur_tb = 0;
 

@@ -196,6 +197,9 @@ void pass_through_tree (reiserfs_filsys_
     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)) {

@@ -223,6 +227,8 @@ void pass_through_tree (reiserfs_filsys_
 	    }
 	    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 */

@@ -279,4 +285,5 @@ void pass_through_tree (reiserfs_filsys_
         block = first_child (path[h]);
         h ++;
     }
+    spinner_clear(&spinner);
 }

@@ -0,0 +1,32 @@
+#ifndef _PROGBAR_H_
+#define _PROGBAR_H_
+
+enum {
+	E2F_FLAG_PROG_SUPPRESS = 1,
+	E2F_FLAG_PROG_BAR = 2,
+};
+
+struct progbar {
+	char units[16];
+	int progress_pos;
+	int progress_last_percent;
+	time_t progress_last_time;
+	int flags;
+	FILE *file;
+};
+
+struct spinner {
+	int count;
+	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 spinner_init(struct spinner *spinner, FILE *fp);
+void spinner_touch(struct spinner *spinner);
+void spinner_clear(struct spinner *spinner);
+
+#endif /* _PROGBAR_H_ */

117 lines not on this page · raw message

@@ -6,6 +6,7 @@
 #define _GNU_SOURCE
 
 #include "includes.h"
+#include "progbar.h"
 
 /* compares description block with commit block. returns 0 if they differ, 1
    if they match */

@@ -799,6 +800,8 @@ int replay_journal (reiserfs_filsys_t * 
     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");

@@ -806,7 +809,8 @@ int replay_journal (reiserfs_filsys_t * 
     if (!is_opened_rw (fs))
         reiserfs_panic ("replay_journal: fs is not opened with write perms");
 
-    reiserfs_warning (stderr, "Replaying journal..\n");
+
+    reiserfs_warning (stderr, "Replaying journal: ");
     bh = fs->fs_jh_bh;
 	
     j_head = (struct reiserfs_journal_header *)(bh->b_data);

@@ -819,12 +823,15 @@ int replay_journal (reiserfs_filsys_t * 
 	return 0;
     }
 
+    trans_count = newest.trans_id - cur.trans_id;
+
     /*  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 && 

@@ -842,6 +849,7 @@ int replay_journal (reiserfs_filsys_t * 
 	    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);

@@ -857,10 +865,14 @@ int replay_journal (reiserfs_filsys_t * 
 	control = cur;
         replayed ++;
 
+	progbar_update(&progbar, "Replaying journal", replayed, trans_count,
+	               replayed);
+
 	ret = next_transaction (fs, &cur, newest);
     }
+    progbar_clear(&progbar);
 
-    reiserfs_warning (stderr, "Reiserfs journal '%s' in blocks [%u..%u]: %d "
+    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)) + 

@@ -38,14 +38,22 @@
 # define extern_inline
 #endif
 
-#include <asm/unaligned.h>
-
 #ifndef get_unaligned
-#if defined(__ppc__) || defined(ppc) || defined(__ppc) || \
-    defined(__PPC) || defined(powerpc) || defined(__powerpc__)
-#	define get_unaligned(ptr)	(*(ptr))
-#	define put_unaligned(val,ptr)	((void)(*(ptr) = (val)))
+#define get_unaligned(ptr)				\
+({							\
+        __typeof__(*(ptr)) __tmp;			\
+        memcpy(&__tmp, (ptr), sizeof(*(ptr)));		\
+        __tmp;						\
+})
 #endif
+
+#ifndef put_unaligned
+#define put_unaligned(val, ptr)				\
+({							\
+        __typeof__(*(ptr)) __tmp = (val);		\
+        memcpy((ptr), &__tmp, sizeof(*(ptr)));		\
+        (void)0;					\
+})
 #endif
 
 #define get_leXX(xx,p,field)	(le##xx##_to_cpu ((p)->field))