Hello community,
here is the log from the commit of package reiserfs
checked in at Tue Aug 14 03:07:26 CEST 2007.
--------
--- reiserfs/reiserfs.changes 2007-08-06 19:40:02.000000000 +0200
+++ /mounts/work_src_done/STABLE/reiserfs/reiserfs.changes 2007-08-13 21:02:25.617749000 +0200
@@ -1,0 +2,5 @@
+Mon Aug 13 21:02:03 CEST 2007 - jeffm@suse.com
+
+- Fixes for file systems >= 8 TiB
+
+-------------------------------------------------------------------
New:
----
reiserfsprogs-enforce-block-limit.diff
reiserfsprogs-large-fs.diff
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Other differences:
------------------
++++++ reiserfs.spec ++++++
--- /var/tmp/diff_new_pack.Y20182/_old 2007-08-14 03:07:14.000000000 +0200
+++ /var/tmp/diff_new_pack.Y20182/_new 2007-08-14 03:07:14.000000000 +0200
@@ -16,7 +16,7 @@
Conflicts: libreiserfs-progs
Supplements: filesystem(reiserfs)
Version: 3.6.19
-Release: 78
+Release: 81
Summary: Reiser File System utilities
License: GPL v2 or later
Group: System/Filesystems
@@ -32,6 +32,8 @@
Patch8: reiserfsprogs-reorder-libs.diff
Patch9: reiserfsprogs-mkfs-use-o_excl.diff
Patch10: reiserfs.unaligned.patch
+Patch11: reiserfsprogs-large-fs.diff
+Patch12: reiserfsprogs-enforce-block-limit.diff
BuildRoot: %{_tmppath}/%{name}-%{version}-build
%description
@@ -53,6 +55,8 @@
%patch8 -p1
%patch9 -p1
%patch10 -p1
+%patch11 -p1
+%patch12 -p1
%build
autoreconf
@@ -76,6 +80,8 @@
rm -rf $RPM_BUILD_ROOT
%changelog
+* Mon Aug 13 2007 - jeffm@suse.com
+- Fixes for file systems >= 8 TiB
* Mon Aug 06 2007 - olh@suse.de
- remove inclusion of asm/unaligned.h
use a copy of asm-generic/unaligned.h instead
++++++ reiserfsprogs-enforce-block-limit.diff ++++++
From: Jeff Mahoney
Subject: [PATCH] reiserfsprogs: enforce 2^32-1 block limit
Currently, mkreiserfs on a block device >= 16 TiB will fail with this error:
reiserfs_create_journal: cannot create a journal of 8193 blocks with
18 offset on 0 blocks
The message doesn't adequately describe that the problem is that reiserfs
supports file system sizes up to 2^32-1 blocks, and it silently overflows.
This patch treats the block device size, as well as the <blocks> command
line parameter as __u64's, so that they can be safely compared to UINT_MAX.
If the block device is too large, we warn the user, offer to truncate the
file system to 2^32-1 blocks, and confirm. This is overridable by the -f
option, which will elect to truncate automatically.
If the user has specified a block count that is too large, we fail always
since the user has provided invalid input.
Signed-off-by: Jeff Mahoney
--- a/mkreiserfs/mkreiserfs.c 2007-08-08 10:20:25.000000000 -0400
+++ b/mkreiserfs/mkreiserfs.c 2007-08-13 14:33:00.000000000 -0400
@@ -28,6 +28,7 @@
#include
#include
#include
+#include
#if defined(HAVE_LIBUUID) && defined(HAVE_UUID_UUID_H)
# include
@@ -436,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)
{
@@ -539,7 +551,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;
@@ -674,7 +686,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)))
@@ -683,6 +695,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;
++++++ reiserfsprogs-large-fs.diff ++++++
From: Jeff Mahoney
Subject: [PATCH] reiserfsprogs: Support for file systems > 8 TB
The reiserfs disk format tries to support large file systems, but falls
short in the superblock format where it contains the number of bitmaps
in the file system as a 16 bit value. This limits the file system size
to 65536 bitmap blocks, which can describe 8TiB - 128MiB.
The following patch is somewhat of a backport of the bitmap tracking
behavior in reiserfsprogs 3.6.20. It calculates the bmap count on the
fly rather than depending on the superblock value.
It also teaches fsck to detect and adjust s_bmap_nr when it's not zero
but describes a file system larger than 8 TB. In order to do this, many
places which use get_sb_bmap_nr() directly need to use the calculated
value instead.
Signed-off-by: Jeff Mahoney
---
debugreiserfs/corruption.c | 4 ++--
debugreiserfs/pack.c | 5 ++---
fsck/check_tree.c | 5 +++--
fsck/pass0.c | 2 +-
fsck/pass1.c | 2 +-
fsck/super.c | 18 +++++++++++-------
include/reiserfs_lib.h | 4 ++++
mkreiserfs/mkreiserfs.c | 9 ++++++---
reiserfscore/bitmap.c | 29 +++++++++++++++++++----------
reiserfscore/node_formats.c | 2 +-
reiserfscore/prints.c | 8 +++++---
reiserfscore/reiserfslib.c | 6 +++++-
resize_reiserfs/do_shrink.c | 10 ++++++----
resize_reiserfs/resize_reiserfs.c | 6 ++++--
14 files changed, 70 insertions(+), 40 deletions(-)
diff -rup a/debugreiserfs/corruption.c b/debugreiserfs/corruption.c
--- a/debugreiserfs/corruption.c 2004-08-19 05:31:49.000000000 -0400
+++ b/debugreiserfs/corruption.c 2007-08-08 15:53:06.000000000 -0400
@@ -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);
diff -rup a/debugreiserfs/pack.c b/debugreiserfs/pack.c
--- a/debugreiserfs/pack.c 2004-05-24 18:50:01.000000000 -0400
+++ b/debugreiserfs/pack.c 2007-08-08 15:46:27.000000000 -0400
@@ -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);
diff -rup a/fsck/check_tree.c b/fsck/check_tree.c
--- a/fsck/check_tree.c 2007-08-08 15:33:40.000000000 -0400
+++ b/fsck/check_tree.c 2007-08-08 15:55:19.000000000 -0400
@@ -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))
diff -rup a/fsck/pass0.c b/fsck/pass0.c
--- a/fsck/pass0.c 2004-10-04 13:11:34.000000000 -0400
+++ b/fsck/pass0.c 2007-08-08 15:42:28.000000000 -0400
@@ -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 */
diff -rup a/fsck/pass1.c b/fsck/pass1.c
--- a/fsck/pass1.c 2004-10-04 12:19:22.000000000 -0400
+++ b/fsck/pass1.c 2007-08-08 15:42:39.000000000 -0400
@@ -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);
diff -rup a/fsck/super.c b/fsck/super.c
--- a/fsck/super.c 2004-10-13 09:05:15.000000000 -0400
+++ b/fsck/super.c 2007-08-08 15:54:09.000000000 -0400
@@ -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) {
diff -rup a/include/reiserfs_lib.h b/include/reiserfs_lib.h
--- a/include/reiserfs_lib.h 2007-08-08 15:33:40.000000000 -0400
+++ b/include/reiserfs_lib.h 2007-08-08 15:50:58.000000000 -0400
@@ -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);
diff -rup a/mkreiserfs/mkreiserfs.c b/mkreiserfs/mkreiserfs.c
--- a/mkreiserfs/mkreiserfs.c 2007-08-08 15:33:40.000000000 -0400
+++ b/mkreiserfs/mkreiserfs.c 2007-08-08 15:50:04.000000000 -0400
@@ -222,7 +222,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))
@@ -349,8 +349,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));
diff -rup a/reiserfscore/bitmap.c b/reiserfscore/bitmap.c
--- a/reiserfscore/bitmap.c 2004-08-19 06:10:45.000000000 -0400
+++ b/reiserfscore/bitmap.c 2007-08-08 15:51:29.000000000 -0400
@@ -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)
diff -rup a/reiserfscore/node_formats.c b/reiserfscore/node_formats.c
--- a/reiserfscore/node_formats.c 2004-09-29 11:15:58.000000000 -0400
+++ b/reiserfscore/node_formats.c 2007-08-08 15:43:00.000000000 -0400
@@ -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;
}
diff -rup a/reiserfscore/prints.c b/reiserfscore/prints.c
--- a/reiserfscore/prints.c 2004-09-16 08:23:11.000000000 -0400
+++ b/reiserfscore/prints.c 2007-08-08 15:43:29.000000000 -0400
@@ -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;
diff -rup a/reiserfscore/reiserfslib.c b/reiserfscore/reiserfslib.c
--- a/reiserfscore/reiserfslib.c 2007-08-08 15:33:40.000000000 -0400
+++ b/reiserfscore/reiserfslib.c 2007-08-08 15:45:46.000000000 -0400
@@ -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 */
diff -rup a/resize_reiserfs/do_shrink.c b/resize_reiserfs/do_shrink.c
--- a/resize_reiserfs/do_shrink.c 2004-08-19 07:27:54.000000000 -0400
+++ b/resize_reiserfs/do_shrink.c 2007-08-08 15:55:59.000000000 -0400
@@ -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;
}
diff -rup a/resize_reiserfs/resize_reiserfs.c b/resize_reiserfs/resize_reiserfs.c
--- a/resize_reiserfs/resize_reiserfs.c 2004-08-19 07:47:13.000000000 -0400
+++ b/resize_reiserfs/resize_reiserfs.c 2007-08-08 15:55:45.000000000 -0400
@@ -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++)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Remember to have fun...
---------------------------------------------------------------------
To unsubscribe, e-mail: opensuse-commit+unsubscribe@opensuse.org
For additional commands, e-mail: opensuse-commit+help@opensuse.org