[RFC][PATCH 6/12] handling of 64-bit block counts in e2fsprofs

Valerie Clement
2007-06-11T16:41:23Z

[-- Attachment #1: Type: text/plain, Size: 1848 bytes --]

This patch allows to handle 64-bit block counts.
It introduces new macros to access block counts stored in the superblock.

debugfs/debugfs.c | 4 +-
debugfs/logdump.c | 2 -
debugfs/lsdel.c | 2 -
debugfs/set_fields.c | 3 +
debugfs/unused.c | 2 -
e2fsck/badblocks.c | 4 +-
e2fsck/journal.c | 4 +-
e2fsck/pass1.c | 16 ++++----
e2fsck/pass2.c | 4 +-
e2fsck/pass5.c | 24 ++++++-------
e2fsck/super.c | 22 ++++++------
e2fsck/unix.c | 10 ++---
lib/e2p/ls.c | 8 ++--
lib/ext2fs/alloc.c | 6 +--
lib/ext2fs/alloc_stats.c | 2 -
lib/ext2fs/bb_inode.c | 2 -
lib/ext2fs/bitmaps.c | 4 +-
lib/ext2fs/block.c | 6 +--
lib/ext2fs/bmove.c | 2 -
lib/ext2fs/closefs.c | 2 -
lib/ext2fs/ext2_fs.h | 52 ++++++++++++++++++++++++++++
lib/ext2fs/ext2fs.h | 6 +--
lib/ext2fs/ext_attr.c | 2 -
lib/ext2fs/extent.c | 4 +-
lib/ext2fs/initialize.c | 26 +++++++-------
lib/ext2fs/openfs.c | 4 +-
lib/ext2fs/read_bb.c | 2 -
lib/ext2fs/read_bb_file.c | 2 -
lib/ext2fs/rw_bitmaps.c | 2 -
lib/ext2fs/swapfs.c | 3 +
lib/ext2fs/tst_badblocks.c | 2 -
lib/ext2fs/tst_iscan.c | 2 -
misc/e2image.c | 2 -
misc/mke2fs.c | 62 ++++++++++++++++++----------------
misc/tune2fs.c | 12 +++---
misc/util.c | 12 +++---
resize/main.c | 2 -
resize/online.c | 11 +++---
resize/resize2fs.c | 81
+++++++++++++++++++++++----------------------
39 files changed, 243 insertions(+), 175 deletions(-)

[-- Attachment #2: 06-handle-s_blocks_count_hi-in-superblock --]
[-- Type: text/plain, Size: 60979 bytes --]

Index: e2fsprogs-1.39-tyt3-v6/debugfs/debugfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/debugfs/debugfs.c 2007-06-11 12:48:47.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/debugfs/debugfs.c 2007-06-11 12:48:52.000000000 +0200
@@ -232,8 +232,8 @@ void do_init_filesys(int argc, char **ar
return;

memset(&param, 0, sizeof(struct ext2_super_block));
- param.s_blocks_count = parse_ulong(argv[2], argv[0],
- "blocks count", &err);
+ EXT2_BLOCKS_COUNT_SET(&param, parse_ulong(argv[2], argv[0],
+ "blocks count", &err));
if (err)
return;
retval = ext2fs_initialize(argv[1], 0, &param,
Index: e2fsprogs-1.39-tyt3-v6/debugfs/logdump.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/debugfs/logdump.c 2007-06-11 12:48:47.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/debugfs/logdump.c 2007-06-11 12:48:52.000000000 +0200
@@ -366,7 +366,7 @@ static void dump_journal(char *cmdname,
fprintf(out_file, "\tuuid=%s\n", jsb_buffer);
fprintf(out_file, "\tblocksize=%d\n", blocksize);
fprintf(out_file, "\tjournal data size %lu\n",
- sb->s_blocks_count);
+ EXT2_BLOCKS_COUNT(sb));
}
}

Index: e2fsprogs-1.39-tyt3-v6/debugfs/lsdel.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/debugfs/lsdel.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/debugfs/lsdel.c 2007-06-11 12:48:52.000000000 +0200
@@ -57,7 +57,7 @@ static int lsdel_proc(ext2_filsys fs,
lsd->num_blocks++;

if (*block_nr < fs->super->s_first_data_block ||
- *block_nr >= fs->super->s_blocks_count) {
+ *block_nr >= EXT2_BLOCKS_COUNT(fs->super)) {
lsd->bad_blocks++;
return BLOCK_ABORT;
}
Index: e2fsprogs-1.39-tyt3-v6/debugfs/set_fields.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/debugfs/set_fields.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/debugfs/set_fields.c 2007-06-11 12:48:52.000000000 +0200
@@ -61,8 +61,11 @@ static errcode_t parse_bmap(struct field
static struct field_set_info super_fields[] = {
{ "inodes_count", &set_sb.s_inodes_count, 4, parse_uint },
{ "blocks_count", &set_sb.s_blocks_count, 4, parse_uint },
+ { "blocks_count_hi", &set_sb.s_blocks_count_hi, 4, parse_uint },
{ "r_blocks_count", &set_sb.s_r_blocks_count, 4, parse_uint },
+ { "r_blocks_count_hi", &set_sb.s_r_blocks_count_hi, 4, parse_uint },
{ "free_blocks_count", &set_sb.s_free_blocks_count, 4, parse_uint },
+ { "free_blocks_hi", &set_sb.s_free_blocks_hi, 4, parse_uint },
{ "free_inodes_count", &set_sb.s_free_inodes_count, 4, parse_uint },
{ "first_data_block", &set_sb.s_first_data_block, 4, parse_uint },
{ "log_block_size", &set_sb.s_log_block_size, 4, parse_uint },
Index: e2fsprogs-1.39-tyt3-v6/debugfs/unused.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/debugfs/unused.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/debugfs/unused.c 2007-06-11 12:48:52.000000000 +0200
@@ -36,7 +36,7 @@ void do_dump_unused(int argc EXT2FS_ATTR
return;

for (blk=current_fs->super->s_first_data_block;
- blk < current_fs->super->s_blocks_count; blk++) {
+ blk < EXT2_BLOCKS_COUNT(current_fs->super); blk++) {
if (ext2fs_test_block_bitmap(current_fs->block_map,blk))
continue;
retval = io_channel_read_blk(current_fs->io, blk, 1, buf);
Index: e2fsprogs-1.39-tyt3-v6/e2fsck/badblocks.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/badblocks.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/badblocks.c 2007-06-11 12:48:52.000000000 +0200
@@ -75,7 +75,7 @@ void read_bad_blocks_file(e2fsck_t ctx,
sprintf(buf, "badblocks -b %d -X %s%s%s %d", fs->blocksize,
(ctx->options & E2F_OPT_PREEN) ? "" : "-s ",
(ctx->options & E2F_OPT_WRITECHECK) ? "-n " : "",
- fs->device_name, fs->super->s_blocks_count-1);
+ fs->device_name, EXT2_BLOCKS_COUNT(fs->super) - 1);
f = popen(buf, "r");
if (!f) {
com_err("read_bad_blocks_file", errno,
@@ -124,7 +124,7 @@ static int check_bb_inode_blocks(ext2_fi
/*
* If the block number is outrageous, clear it and ignore it.
*/
- if (*block_nr >= fs->super->s_blocks_count ||
+ if (*block_nr >= EXT2_BLOCKS_COUNT(fs->super)||
*block_nr < fs->super->s_first_data_block) {
printf(_("Warning: illegal block %u found in bad block inode. "
"Cleared.\n"), *block_nr);
Index: e2fsprogs-1.39-tyt3-v6/e2fsck/journal.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/journal.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/journal.c 2007-06-11 12:48:52.000000000 +0200
@@ -280,7 +280,7 @@ static errcode_t e2fsck_get_journal(e2fs
continue;
}
if (blk < sb->s_first_data_block ||
- blk >= sb->s_blocks_count) {
+ blk >= EXT2_BLOCKS_COUNT(sb)) {
retval = EXT2_ET_BAD_BLOCK_NUM;
goto try_backup_journal;
}
@@ -372,7 +372,7 @@ static errcode_t e2fsck_get_journal(e2fs
goto errout;
}

- journal->j_maxlen = jsuper.s_blocks_count;
+ journal->j_maxlen = EXT2_BLOCKS_COUNT(&jsuper);
start++;
}

Index: e2fsprogs-1.39-tyt3-v6/e2fsck/pass1.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/pass1.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/pass1.c 2007-06-11 12:48:52.000000000 +0200
@@ -182,7 +182,7 @@ int e2fsck_pass1_check_symlink(ext2_fils
if ((inode->i_size >= fs->blocksize) ||
(blocks != fs->blocksize >> 9) ||
(inode->i_block[0] < fs->super->s_first_data_block) ||
- (inode->i_block[0] >= fs->super->s_blocks_count))
+ (inode->i_block[0] >= EXT2_BLOCKS_COUNT(fs->super)))
return 0;

for (i = 1; i < EXT2_N_BLOCKS; i++)
@@ -406,7 +406,7 @@ static void check_is_really_dir(e2fsck_t
not_device++;

if (blk < ctx->fs->super->s_first_data_block ||
- blk >= ctx->fs->super->s_blocks_count ||
+ blk >= EXT2_BLOCKS_COUNT(ctx->fs->super) ||
ext2fs_fast_test_block_bitmap(ctx->block_found_map, blk))
return; /* Invalid block, can't be dir */
}
@@ -1342,7 +1342,7 @@ static int check_ext_attr(e2fsck_t ctx,
*/
if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) ||
(blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= EXT2_BLOCKS_COUNT(fs->super))) {
mark_inode_bad(ctx, ino);
return 0;
}
@@ -1511,7 +1511,7 @@ static int handle_htree(e2fsck_t ctx, st
block_buf, htree_blk_iter_cb, &blk);
if (((blk == 0) ||
(blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) &&
+ (blk >= EXT2_BLOCKS_COUNT(fs->super))) &&
fix_problem(ctx, PR_1_HTREE_BADROOT, pctx))
return 1;

@@ -1867,8 +1867,8 @@ static char *describe_illegal_block(ext2
if (block < super) {
sprintf(problem, "< FIRSTBLOCK (%u)", super);
return(problem);
- } else if (block >= fs->super->s_blocks_count) {
- sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count);
+ } else if (block >= EXT2_BLOCKS_COUNT(fs->super)) {
+ sprintf(problem, "> BLOCKS (%u)", EXT2_BLOCKS_COUNT(fs->super));
return(problem);
}
for (i = 0; i < fs->group_desc_count; i++) {
@@ -1999,7 +1999,7 @@ static int process_block(ext2_filsys fs,
problem = PR_1_TOOBIG_SYMLINK;

if (blk < fs->super->s_first_data_block ||
- blk >= fs->super->s_blocks_count)
+ blk >= EXT2_BLOCKS_COUNT(fs->super))
problem = PR_1_ILLEGAL_BLOCK_NUM;

if (!problem && IND_BLKCNT(blockcnt) && p->ino != EXT2_RESIZE_INO) {
@@ -2116,7 +2116,7 @@ static int process_bad_block(ext2_filsys
pctx->blkcount = blockcnt;

if ((blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= EXT2_BLOCKS_COUNT(fs->super))) {
if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) {
*block_nr = 0;
return BLOCK_CHANGED;
Index: e2fsprogs-1.39-tyt3-v6/e2fsck/pass2.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/pass2.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/pass2.c 2007-06-11 12:48:52.000000000 +0200
@@ -1100,7 +1100,7 @@ static int deallocate_inode_block(ext2_f
if (HOLE_BLKADDR(*block_nr))
return 0;
if ((*block_nr < fs->super->s_first_data_block) ||
- (*block_nr >= fs->super->s_blocks_count))
+ (*block_nr >= EXT2_BLOCKS_COUNT(fs->super)))
return 0;
ext2fs_unmark_block_bitmap(ctx->block_found_map, *block_nr);
ext2fs_block_alloc_stats(fs, *block_nr, -1);
@@ -1300,7 +1300,7 @@ extern int e2fsck_process_bad_inode(e2fs

if (inode.i_file_acl &&
((inode.i_file_acl < fs->super->s_first_data_block) ||
- (inode.i_file_acl >= fs->super->s_blocks_count))) {
+ (inode.i_file_acl >= EXT2_BLOCKS_COUNT(fs->super)))) {
if (fix_problem(ctx, PR_2_FILE_ACL_BAD, &pctx)) {
inode.i_file_acl = 0;
inode_modified++;
Index: e2fsprogs-1.39-tyt3-v6/e2fsck/pass5.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/pass5.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/pass5.c 2007-06-11 12:48:52.000000000 +0200
@@ -114,8 +114,8 @@ static void check_block_bitmaps(e2fsck_t
blk_t i, super;
int *free_array;
int group = 0;
- unsigned int blocks = 0;
- unsigned int free_blocks = 0;
+ blk_t blocks = 0;
+ blk_t free_blocks = 0;
int group_free = 0;
int actual, bitmap;
struct problem_context pctx;
@@ -130,11 +130,11 @@ static void check_block_bitmaps(e2fsck_t

if ((fs->super->s_first_data_block <
ext2fs_get_block_bitmap_start(ctx->block_found_map)) ||
- (fs->super->s_blocks_count-1 >
+ (EXT2_BLOCKS_COUNT(fs->super)-1 >
ext2fs_get_block_bitmap_end(ctx->block_found_map))) {
pctx.num = 1;
pctx.blk = fs->super->s_first_data_block;
- pctx.blk2 = fs->super->s_blocks_count -1;
+ pctx.blk2 = EXT2_BLOCKS_COUNT(fs->super) -1;
pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map);
pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
@@ -145,11 +145,11 @@ static void check_block_bitmaps(e2fsck_t

if ((fs->super->s_first_data_block <
ext2fs_get_block_bitmap_start(fs->block_map)) ||
- (fs->super->s_blocks_count-1 >
+ (EXT2_BLOCKS_COUNT(fs->super)-1 >
ext2fs_get_block_bitmap_end(fs->block_map))) {
pctx.num = 2;
pctx.blk = fs->super->s_first_data_block;
- pctx.blk2 = fs->super->s_blocks_count -1;
+ pctx.blk2 = EXT2_BLOCKS_COUNT(fs->super) -1;
pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map);
pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
@@ -170,7 +170,7 @@ redo_counts:
skip_group++;
super = fs->super->s_first_data_block;
for (i = fs->super->s_first_data_block;
- i < fs->super->s_blocks_count;
+ i < EXT2_BLOCKS_COUNT(fs->super);
i++) {
actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i);

@@ -230,7 +230,7 @@ redo_counts:
}
blocks ++;
if ((blocks == fs->super->s_blocks_per_group) ||
- (i == fs->super->s_blocks_count-1)) {
+ (i == EXT2_BLOCKS_COUNT(fs->super)-1)) {
free_array[group] = group_free;
group ++;
blocks = 0;
@@ -242,7 +242,7 @@ redo_counts:
fs->group_desc_count*2))
goto errout;
if (lazy_bg &&
- (i != fs->super->s_blocks_count-1) &&
+ (i != EXT2_BLOCKS_COUNT(fs->super)-1) &&
(fs->group_desc[group].bg_flags &
EXT2_BG_BLOCK_UNINIT))
skip_group++;
@@ -291,13 +291,13 @@ redo_counts:
ext2fs_unmark_valid(fs);
}
}
- if (free_blocks != fs->super->s_free_blocks_count) {
+ if (free_blocks != EXT2_FREE_BLOCKS_COUNT(fs->super)) {
pctx.group = 0;
- pctx.blk = fs->super->s_free_blocks_count;
+ pctx.blk = EXT2_FREE_BLOCKS_COUNT(fs->super);
pctx.blk2 = free_blocks;

if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
- fs->super->s_free_blocks_count = free_blocks;
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super, free_blocks);
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
Index: e2fsprogs-1.39-tyt3-v6/e2fsck/super.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/super.c 2007-06-11 12:48:47.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/super.c 2007-06-11 12:48:52.000000000 +0200
@@ -90,7 +90,7 @@ static int release_inode_block(ext2_fils
return 0;

if ((blk < fs->super->s_first_data_block) ||
- (blk >= fs->super->s_blocks_count)) {
+ (blk >= EXT2_BLOCKS_COUNT(fs->super))) {
fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx);
return_abort:
pb->abort = 1;
@@ -388,7 +388,7 @@ static void check_resize_inode(e2fsck_t
if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count ||
!(inode.i_mode & LINUX_S_IFREG) ||
(blk < fs->super->s_first_data_block ||
- blk >= fs->super->s_blocks_count)) {
+ blk >= EXT2_BLOCKS_COUNT(fs->super))) {
resize_inode_invalid:
if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) {
memset(&inode, 0, sizeof(inode));
@@ -508,10 +508,10 @@ void check_super_block(e2fsck_t ctx)
*/
check_super_value(ctx, "inodes_count", sb->s_inodes_count,
MIN_CHECK, 1, 0);
- check_super_value(ctx, "blocks_count", sb->s_blocks_count,
+ check_super_value(ctx, "blocks_count", EXT2_BLOCKS_COUNT(sb),
MIN_CHECK, 1, 0);
check_super_value(ctx, "first_data_block", sb->s_first_data_block,
- MAX_CHECK, 0, sb->s_blocks_count);
+ MAX_CHECK, 0, EXT2_BLOCKS_COUNT(sb));
check_super_value(ctx, "log_block_size", sb->s_log_block_size,
MIN_CHECK | MAX_CHECK, 0,
EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE);
@@ -524,8 +524,8 @@ void check_super_block(e2fsck_t ctx)
MIN_CHECK | MAX_CHECK, 8, bpg_max);
check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group,
MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max);
- check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count,
- MAX_CHECK, 0, sb->s_blocks_count / 2);
+ check_super_value(ctx, "r_blocks_count", EXT2_R_BLOCKS_COUNT(sb),
+ MAX_CHECK, 0, EXT2_BLOCKS_COUNT(sb) / 2);
check_super_value(ctx, "reserved_gdt_blocks",
sb->s_reserved_gdt_blocks, MAX_CHECK, 0,
fs->blocksize/4);
@@ -549,8 +549,8 @@ void check_super_block(e2fsck_t ctx)
return;
}
if ((pctx.errcode != EXT2_ET_UNIMPLEMENTED) &&
- (ctx->num_blocks < sb->s_blocks_count)) {
- pctx.blk = sb->s_blocks_count;
+ (ctx->num_blocks < EXT2_BLOCKS_COUNT(sb))) {
+ pctx.blk = EXT2_BLOCKS_COUNT(sb);
pctx.blk2 = ctx->num_blocks;
if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) {
ctx->flags |= E2F_FLAG_ABORT;
@@ -655,18 +655,18 @@ void check_super_block(e2fsck_t ctx)
* inodes; if the filesystem is not unmounted cleanly, the
* global counts may not be accurate.
*/
- if ((free_blocks != sb->s_free_blocks_count) ||
+ if ((free_blocks != EXT2_FREE_BLOCKS_COUNT(sb)) ||
(free_inodes != sb->s_free_inodes_count)) {
if (ctx->options & E2F_OPT_READONLY)
ext2fs_unmark_valid(fs);
else {
- sb->s_free_blocks_count = free_blocks;
+ EXT2_FREE_BLOCKS_COUNT_SET(sb, free_blocks);
sb->s_free_inodes_count = free_inodes;
ext2fs_mark_super_dirty(fs);
}
}

- if ((sb->s_free_blocks_count > sb->s_blocks_count) ||
+ if ((EXT2_FREE_BLOCKS_COUNT(sb) > EXT2_BLOCKS_COUNT(sb)) ||
(sb->s_free_inodes_count > sb->s_inodes_count))
ext2fs_unmark_valid(fs);

Index: e2fsprogs-1.39-tyt3-v6/e2fsck/unix.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/e2fsck/unix.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/e2fsck/unix.c 2007-06-11 12:48:52.000000000 +0200
@@ -110,9 +110,9 @@ static void show_stats(e2fsck_t ctx)
inodes = fs->super->s_inodes_count;
inodes_used = (fs->super->s_inodes_count -
fs->super->s_free_inodes_count);
- blocks = fs->super->s_blocks_count;
- blocks_used = (fs->super->s_blocks_count -
- fs->super->s_free_blocks_count);
+ blocks = EXT2_BLOCKS_COUNT(fs->super);
+ blocks_used = (EXT2_BLOCKS_COUNT(fs->super) -
+ EXT2_FREE_BLOCKS_COUNT(fs->super));

frag_percent = (10000 * ctx->fs_fragmented) / inodes_used;
frag_percent = (frag_percent + 5) / 10;
@@ -302,8 +302,8 @@ static void check_if_skip(e2fsck_t ctx)
printf(_("%s: clean, %u/%u files, %u/%u blocks"), ctx->device_name,
fs->super->s_inodes_count - fs->super->s_free_inodes_count,
fs->super->s_inodes_count,
- fs->super->s_blocks_count - fs->super->s_free_blocks_count,
- fs->super->s_blocks_count);
+ EXT2_BLOCKS_COUNT(fs->super) - EXT2_FREE_BLOCKS_COUNT(fs->super),
+ EXT2_BLOCKS_COUNT(fs->super));
next_check = 100000;
if (fs->super->s_max_mnt_count > 0) {
next_check = fs->super->s_max_mnt_count - fs->super->s_mnt_count;
Index: e2fsprogs-1.39-tyt3-v6/lib/e2p/ls.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/e2p/ls.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/e2p/ls.c 2007-06-11 12:48:52.000000000 +0200
@@ -215,9 +215,11 @@ void list_super2(struct ext2_super_block
fprintf(f, "Filesystem OS type: %s\n", str);
free(str);
fprintf(f, "Inode count: %u\n", sb->s_inodes_count);
- fprintf(f, "Block count: %u\n", sb->s_blocks_count);
- fprintf(f, "Reserved block count: %u\n", sb->s_r_blocks_count);
- fprintf(f, "Free blocks: %u\n", sb->s_free_blocks_count);
+ fprintf(f, "Block count: %u\n", EXT2_BLOCKS_COUNT(sb));
+ fprintf(f, "Reserved block count: %u\n",
+ EXT2_R_BLOCKS_COUNT(sb));
+ fprintf(f, "Free blocks: %u\n",
+ EXT2_FREE_BLOCKS_COUNT(sb));
fprintf(f, "Free inodes: %u\n", sb->s_free_inodes_count);
fprintf(f, "First block: %u\n", sb->s_first_data_block);
fprintf(f, "Block size: %u\n", EXT2_BLOCK_SIZE(sb));
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/alloc.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/alloc.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/alloc.c 2007-06-11 12:48:52.000000000 +0200
@@ -84,7 +84,7 @@ errcode_t ext2fs_new_block(ext2_filsys f
map = fs->block_map;
if (!map)
return EXT2_ET_NO_BLOCK_BITMAP;
- if (!goal || (goal >= fs->super->s_blocks_count))
+ if (!goal || (goal >= EXT2_BLOCKS_COUNT(fs->super)))
goal = fs->super->s_first_data_block;
i = goal;
do {
@@ -93,7 +93,7 @@ errcode_t ext2fs_new_block(ext2_filsys f
return 0;
}
i++;
- if (i >= fs->super->s_blocks_count)
+ if (i >= EXT2_BLOCKS_COUNT(fs->super))
i = fs->super->s_first_data_block;
} while (i != goal);
return EXT2_ET_BLOCK_ALLOC_FAIL;
@@ -160,7 +160,7 @@ errcode_t ext2fs_get_free_blocks(ext2_fi
if (!num)
num = 1;
do {
- if (b+num-1 > fs->super->s_blocks_count)
+ if (b+num-1 > EXT2_BLOCKS_COUNT(fs->super))
b = fs->super->s_first_data_block;
if (ext2fs_fast_test_block_bitmap_range(map, b, num)) {
*ret = b;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/alloc_stats.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/alloc_stats.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/alloc_stats.c 2007-06-11 12:48:52.000000000 +0200
@@ -46,7 +46,7 @@ void ext2fs_block_alloc_stats(ext2_filsy
else
ext2fs_unmark_block_bitmap(fs->block_map, blk);
fs->group_desc[group].bg_free_blocks_count -= inuse;
- fs->super->s_free_blocks_count -= inuse;
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super, EXT2_FREE_BLOCKS_COUNT(fs->super) - inuse);
ext2fs_mark_super_dirty(fs);
ext2fs_mark_bb_dirty(fs);
}
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/bb_inode.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/bb_inode.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/bb_inode.c 2007-06-11 12:48:52.000000000 +0200
@@ -166,7 +166,7 @@ static int clear_bad_block_proc(ext2_fil
/*
* If the block number is outrageous, clear it and ignore it.
*/
- if (*block_nr >= fs->super->s_blocks_count ||
+ if (*block_nr >= EXT2_BLOCKS_COUNT(fs->super) ||
*block_nr < fs->super->s_first_data_block) {
*block_nr = 0;
return BLOCK_CHANGED;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/bitmaps.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/bitmaps.c 2007-06-11 12:48:50.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/bitmaps.c 2007-06-11 12:48:52.000000000 +0200
@@ -137,7 +137,7 @@ errcode_t ext2fs_allocate_block_bitmap(e
fs->write_bitmaps = ext2fs_write_bitmaps;

start = fs->super->s_first_data_block;
- end = fs->super->s_blocks_count-1;
+ end = EXT2_BLOCKS_COUNT(fs->super) - 1;
real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)
* fs->group_desc_count)-1 + start;

@@ -263,7 +263,7 @@ errcode_t ext2fs_allocate_block_bitmap(e
fs->write_bitmaps = ext2fs_write_bitmaps;

start = fs->super->s_first_data_block;
- end = fs->super->s_blocks_count-1;
+ end = EXT2_BLOCKS_COUNT(fs->super) - 1;
real_end = (EXT2_BLOCKS_PER_GROUP(fs->super)
* fs->group_desc_count)-1 + start;

Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/block.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/block.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/block.c 2007-06-11 12:48:52.000000000 +0200
@@ -317,7 +317,7 @@ static int block_iterate_ind(blk_t *ind_
ctx->bcount += limit;
return ret;
}
- if (*ind_block >= ctx->fs->super->s_blocks_count ||
+ if (*ind_block >= EXT2_BLOCKS_COUNT(ctx->fs->super) ||
*ind_block < ctx->fs->super->s_first_data_block) {
ctx->errcode = EXT2_ET_BAD_IND_BLOCK;
ret |= BLOCK_ERROR;
@@ -391,7 +391,7 @@ static int block_iterate_dind(blk_t *din
ctx->bcount += limit*limit;
return ret;
}
- if (*dind_block >= ctx->fs->super->s_blocks_count ||
+ if (*dind_block >= EXT2_BLOCKS_COUNT(ctx->fs->super) ||
*dind_block < ctx->fs->super->s_first_data_block) {
ctx->errcode = EXT2_ET_BAD_DIND_BLOCK;
ret |= BLOCK_ERROR;
@@ -467,7 +467,7 @@ static int block_iterate_tind(blk_t *tin
ctx->bcount += limit*limit*limit;
return ret;
}
- if (*tind_block >= ctx->fs->super->s_blocks_count ||
+ if (*tind_block >= EXT2_BLOCKS_COUNT(ctx->fs->super) ||
*tind_block < ctx->fs->super->s_first_data_block) {
ctx->errcode = EXT2_ET_BAD_TIND_BLOCK;
ret |= BLOCK_ERROR;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/bmove.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/bmove.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/bmove.c 2007-06-11 12:48:52.000000000 +0200
@@ -50,7 +50,7 @@ static int process_block(ext2_filsys fs,
*/
if (ext2fs_test_block_bitmap(pb->reserve, block)) {
do {
- if (++block >= fs->super->s_blocks_count)
+ if (++block >= EXT2_BLOCKS_COUNT(fs->super))
block = fs->super->s_first_data_block;
if (block == orig) {
pb->error = EXT2_ET_BLOCK_ALLOC_FAIL;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/closefs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/closefs.c 2007-06-11 12:48:47.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/closefs.c 2007-06-11 12:48:52.000000000 +0200
@@ -66,7 +66,7 @@ int ext2fs_super_and_bgd_loc(ext2_filsys
fs->desc_blocks + fs->super->s_reserved_gdt_blocks;

if (group == fs->group_desc_count-1) {
- numblocks = (fs->super->s_blocks_count -
+ numblocks = (EXT2_BLOCKS_COUNT(fs->super) -
fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if (!numblocks)
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/ext2_fs.h
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/ext2_fs.h 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/ext2_fs.h 2007-06-11 12:48:52.000000000 +0200
@@ -217,7 +217,11 @@ struct ext2_dx_countlimit {
/*
* Macro-instructions used to manage group descriptors
*/
+#ifdef _EXT4FS_
+#define EXT2_BLOCKS_PER_GROUP(s) ((__u64)EXT2_SB(s)->s_blocks_per_group)
+#else
#define EXT2_BLOCKS_PER_GROUP(s) (EXT2_SB(s)->s_blocks_per_group)
+#endif
#define EXT2_INODES_PER_GROUP(s) (EXT2_SB(s)->s_inodes_per_group)
#define EXT2_INODES_PER_BLOCK(s) (EXT2_BLOCK_SIZE(s)/EXT2_INODE_SIZE(s))
/* limits imposed by 16-bit value gd_free_{blocks,inode}_count */
@@ -573,6 +577,54 @@ struct ext2_super_block {
__u32 s_reserved[167]; /* Padding to the end of the block */
};

+#ifdef _EXT4FS_
+#define EXT2_BLOCKS_COUNT(s) \
+ ((s)->s_blocks_count + ((__u64)(s)->s_blocks_count_hi << 32))
+
+#define EXT2_BLOCKS_COUNT_SET(s, v) \
+ do { \
+ (s)->s_blocks_count = (v); \
+ (s)->s_blocks_count_hi = (v) >> 32; \
+ } while (0)
+
+#define EXT2_R_BLOCKS_COUNT(s) \
+ ((s)->s_r_blocks_count + ((__u64)(s)->s_r_blocks_count_hi << 32))
+
+#define EXT2_R_BLOCKS_COUNT_SET(s, v) \
+ do { \
+ (s)->s_r_blocks_count = (v); \
+ (s)->s_r_blocks_count_hi = (v) >> 32; \
+ } while (0)
+
+#define EXT2_FREE_BLOCKS_COUNT(s) \
+ ((s)->s_free_blocks_count + ((__u64)(s)->s_free_blocks_hi << 32))
+
+#define EXT2_FREE_BLOCKS_COUNT_SET(s, v) \
+ do { \
+ (s)->s_free_blocks_count = (v); \
+ (s)->s_free_blocks_hi = (v) >> 32; \
+ } while (0)
+#else
+#define EXT2_BLOCKS_COUNT(s) ((s)->s_blocks_count)
+#define EXT2_R_BLOCKS_COUNT(s) ((s)->s_r_blocks_count)
+#define EXT2_FREE_BLOCKS_COUNT(s) ((s)->s_free_blocks_count)
+
+#define EXT2_BLOCKS_COUNT_SET(s, v) \
+ do { \
+ (s)->s_blocks_count = (v); \
+ } while (0)
+
+#define EXT2_R_BLOCKS_COUNT_SET(s, v) \
+ do { \
+ (s)->s_r_blocks_count = (v); \
+ } while (0)
+
+#define EXT2_FREE_BLOCKS_COUNT_SET(s, v) \
+ do { \
+ (s)->s_free_blocks_count = (v); \
+ } while (0)
+#endif
+
/*
* Codes for operating systems
*/
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/ext2fs.h
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/ext2fs.h 2007-06-11 12:48:50.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/ext2fs.h 2007-06-11 12:48:52.000000000 +0200
@@ -1091,7 +1091,7 @@ extern blk_t ext2fs_group_first_block(ex
extern blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group);
extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
struct ext2_inode *inode);
-extern unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b);
+extern unsigned long ext2fs_div_ceil(unsigned long a, unsigned long b);

/*
* The actual inlined functions definitions themselves...
@@ -1271,7 +1271,7 @@ _INLINE_ blk_t ext2fs_group_first_block(
_INLINE_ blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group)
{
return (group == fs->group_desc_count - 1 ?
- fs->super->s_blocks_count - 1 :
+ EXT2_BLOCKS_COUNT(fs->super) - 1 :
ext2fs_group_first_block(fs, group) +
(fs->super->s_blocks_per_group - 1));
}
@@ -1286,7 +1286,7 @@ _INLINE_ blk_t ext2fs_inode_data_blocks(
/*
* This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b)
*/
-_INLINE_ unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b)
+_INLINE_ unsigned long ext2fs_div_ceil(unsigned long a, unsigned long b)
{
if (!a)
return 0;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/ext_attr.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/ext_attr.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/ext_attr.c 2007-06-11 12:48:52.000000000 +0200
@@ -74,7 +74,7 @@ errcode_t ext2fs_adjust_ea_refcount(ext2
struct ext2_ext_attr_header *header;
char *buf = 0;

- if ((blk >= fs->super->s_blocks_count) ||
+ if ((blk >= EXT2_BLOCKS_COUNT(fs->super)) ||
(blk < fs->super->s_first_data_block))
return EXT2_ET_BAD_EA_BLOCK_NUM;

Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/initialize.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/initialize.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/initialize.c 2007-06-11 12:48:52.000000000 +0200
@@ -75,8 +75,8 @@ static unsigned int calc_reserved_gdt_bl
/* We set it at 1024x the current filesystem size, or
* the upper block count limit (2^32), whichever is lower.
*/
- if (sb->s_blocks_count < max_blocks / 1024)
- max_blocks = sb->s_blocks_count * 1024;
+ if (EXT2_BLOCKS_COUNT(sb) < max_blocks / 1024)
+ max_blocks = EXT2_BLOCKS_COUNT(sb) * 1024;
rsv_groups = ext2fs_div_ceil(max_blocks - sb->s_first_data_block, bpg);
rsv_gdb = ext2fs_div_ceil(rsv_groups, gdpb) - fs->desc_blocks;
if (rsv_gdb > EXT2_ADDR_PER_BLOCK(sb))
@@ -107,7 +107,7 @@ errcode_t ext2fs_initialize(const char *
char *buf;
char c;

- if (!param || !param->s_blocks_count)
+ if (!param || !EXT2_BLOCKS_COUNT(param))
return EXT2_ET_INVALID_ARGUMENT;

retval = ext2fs_get_mem(sizeof(struct struct_ext2_filsys), &fs);
@@ -186,9 +186,9 @@ errcode_t ext2fs_initialize(const char *
super->s_blocks_per_group = EXT2_MAX_BLOCKS_PER_GROUP(super);
super->s_frags_per_group = super->s_blocks_per_group * frags_per_block;

- super->s_blocks_count = param->s_blocks_count;
- super->s_r_blocks_count = param->s_r_blocks_count;
- if (super->s_r_blocks_count >= param->s_blocks_count) {
+ EXT2_BLOCKS_COUNT_SET(super, EXT2_BLOCKS_COUNT(param));
+ EXT2_R_BLOCKS_COUNT_SET(super, EXT2_R_BLOCKS_COUNT(param));
+ if (EXT2_R_BLOCKS_COUNT(super) >= EXT2_BLOCKS_COUNT(param)) {
retval = EXT2_ET_INVALID_ARGUMENT;
goto cleanup;
}
@@ -205,7 +205,7 @@ errcode_t ext2fs_initialize(const char *
}

retry:
- fs->group_desc_count = ext2fs_div_ceil(super->s_blocks_count -
+ fs->group_desc_count = ext2fs_div_ceil(EXT2_BLOCKS_COUNT(super) -
super->s_first_data_block,
EXT2_BLOCKS_PER_GROUP(super));
if (fs->group_desc_count == 0) {
@@ -216,7 +216,7 @@ retry:
EXT2_DESC_PER_BLOCK(super));

i = fs->blocksize >= 4096 ? 1 : 4096 / fs->blocksize;
- set_field(s_inodes_count, super->s_blocks_count / i);
+ set_field(s_inodes_count, EXT2_BLOCKS_COUNT(super) / i);

/*
* Make sure we have at least EXT2_FIRST_INO + 1 inodes, so
@@ -236,7 +236,7 @@ retry:
if (super->s_blocks_per_group >= 256) {
/* Try again with slightly different parameters */
super->s_blocks_per_group -= 8;
- super->s_blocks_count = param->s_blocks_count;
+ EXT2_BLOCKS_COUNT_SET(super, EXT2_BLOCKS_COUNT(param));
super->s_frags_per_group = super->s_blocks_per_group *
frags_per_block;
goto retry;
@@ -318,12 +318,12 @@ ipg_retry:
* necessary data structures. If not, we need to get rid of
* it.
*/
- rem = ((super->s_blocks_count - super->s_first_data_block) %
+ rem = ((EXT2_BLOCKS_COUNT(super) - super->s_first_data_block) %
super->s_blocks_per_group);
if ((fs->group_desc_count == 1) && rem && (rem < overhead))
return EXT2_ET_TOOSMALL;
if (rem && (rem < overhead+50)) {
- super->s_blocks_count -= rem;
+ EXT2_BLOCKS_COUNT_SET(super, EXT2_BLOCKS_COUNT(super) - rem);
goto retry;
}

@@ -363,11 +363,11 @@ ipg_retry:
* inode table have not been allocated (and in fact won't be
* by this routine), they are accounted for nevertheless.
*/
- super->s_free_blocks_count = 0;
+ EXT2_FREE_BLOCKS_COUNT_SET(super, 0ULL);
for (i = 0; i < fs->group_desc_count; i++) {
numblocks = ext2fs_reserve_super_and_bgd(fs, i, fs->block_map);

- super->s_free_blocks_count += numblocks;
+ EXT2_FREE_BLOCKS_COUNT_SET(super, EXT2_FREE_BLOCKS_COUNT(super) + numblocks);
fs->group_desc[i].bg_free_blocks_count = numblocks;
fs->group_desc[i].bg_free_inodes_count =
fs->super->s_inodes_per_group;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/openfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/openfs.c 2007-06-11 12:48:47.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/openfs.c 2007-06-11 12:48:52.000000000 +0200
@@ -53,7 +53,7 @@ blk_t ext2fs_descriptor_block_loc(ext2_f
*/
if (group_block != fs->super->s_first_data_block &&
((ret_blk + fs->super->s_blocks_per_group) <
- fs->super->s_blocks_count))
+ EXT2_BLOCKS_COUNT(fs->super)))
ret_blk += fs->super->s_blocks_per_group;
return ret_blk;
}
@@ -267,7 +267,7 @@ errcode_t ext2fs_open2(const char *name,
retval = EXT2_ET_CORRUPT_SUPERBLOCK;
goto cleanup;
}
- fs->group_desc_count = ext2fs_div_ceil(fs->super->s_blocks_count -
+ fs->group_desc_count = ext2fs_div_ceil(EXT2_BLOCKS_COUNT(fs->super) -
fs->super->s_first_data_block,
blocks_per_group);
fs->desc_blocks = ext2fs_div_ceil(fs->group_desc_count,
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/read_bb.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/read_bb.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/read_bb.c 2007-06-11 12:48:52.000000000 +0200
@@ -49,7 +49,7 @@ static int mark_bad_block(ext2_filsys fs
return 0;

if ((*block_nr < fs->super->s_first_data_block) ||
- (*block_nr >= fs->super->s_blocks_count))
+ (*block_nr >= EXT2_BLOCKS_COUNT(fs->super)))
return 0; /* Ignore illegal blocks */

rb->err = ext2fs_badblocks_list_add(rb->bb_list, *block_nr);
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/read_bb_file.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/read_bb_file.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/read_bb_file.c 2007-06-11 12:48:52.000000000 +0200
@@ -59,7 +59,7 @@ errcode_t ext2fs_read_bb_FILE2(ext2_fils
continue;
if (fs &&
((blockno < fs->super->s_first_data_block) ||
- (blockno >= fs->super->s_blocks_count))) {
+ (blockno >= EXT2_BLOCKS_COUNT(fs->super)))) {
if (invalid)
(invalid)(fs, blockno, buf, priv_data);
continue;
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/rw_bitmaps.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/rw_bitmaps.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/rw_bitmaps.c 2007-06-11 12:48:52.000000000 +0200
@@ -101,7 +101,7 @@ static errcode_t write_bitmaps(ext2_fils
memcpy(block_buf, block_bitmap, block_nbytes);
if (i == fs->group_desc_count - 1) {
/* Force bitmap padding for the last group */
- nbits = ((fs->super->s_blocks_count
+ nbits = ((EXT2_BLOCKS_COUNT(fs->super)
- fs->super->s_first_data_block)
% EXT2_BLOCKS_PER_GROUP(fs->super));
if (nbits)
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/swapfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/swapfs.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/swapfs.c 2007-06-11 12:48:52.000000000 +0200
@@ -26,8 +26,11 @@ void ext2fs_swap_super(struct ext2_super
int i;
sb->s_inodes_count = ext2fs_swab32(sb->s_inodes_count);
sb->s_blocks_count = ext2fs_swab32(sb->s_blocks_count);
+ sb->s_blocks_count_hi = ext2fs_swab32(sb->s_blocks_count_hi);
sb->s_r_blocks_count = ext2fs_swab32(sb->s_r_blocks_count);
+ sb->s_r_blocks_count_hi = ext2fs_swab32(sb->s_r_blocks_count_hi);
sb->s_free_blocks_count = ext2fs_swab32(sb->s_free_blocks_count);
+ sb->s_free_blocks_hi = ext2fs_swab32(sb->s_free_blocks_hi);
sb->s_free_inodes_count = ext2fs_swab32(sb->s_free_inodes_count);
sb->s_first_data_block = ext2fs_swab32(sb->s_first_data_block);
sb->s_log_block_size = ext2fs_swab32(sb->s_log_block_size);
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/tst_badblocks.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/tst_badblocks.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/tst_badblocks.c 2007-06-11 12:48:52.000000000 +0200
@@ -227,7 +227,7 @@ int file_test_invalid(badblocks_list bb)
fs->super = malloc(SUPERBLOCK_SIZE);
memset(fs->super, 0, SUPERBLOCK_SIZE);
fs->super->s_first_data_block = 1;
- fs->super->s_blocks_count = 100;
+ EXT2_BLOCKS_COUNT_SET(fs->super, 100);

f = tmpfile();
if (!f) {
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/tst_iscan.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/tst_iscan.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/tst_iscan.c 2007-06-11 12:48:52.000000000 +0200
@@ -71,7 +71,7 @@ static void setup(void)
initialize_ext2_error_table();

memset(&param, 0, sizeof(param));
- param.s_blocks_count = 12000;
+ EXT2_BLOCKS_COUNT_SET(&param, 12000);

test_io_cb_read_blk = test_read_blk;
Index: e2fsprogs-1.39-tyt3-v6/misc/e2image.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/misc/e2image.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/misc/e2image.c 2007-06-11 12:48:52.000000000 +0200
@@ -411,7 +411,7 @@ static void output_meta_data_blocks(ext2
exit(1);
}
memset(zero_buf, 0, fs->blocksize);
- for (blk = 0; blk < fs->super->s_blocks_count; blk++) {
+ for (blk = 0; blk < EXT2_BLOCKS_COUNT(fs->super); blk++) {
if ((blk >= fs->super->s_first_data_block) &&
ext2fs_test_block_bitmap(meta_block_map, blk)) {
retval = io_channel_read_blk(fs->io, blk, 1, buf);
Index: e2fsprogs-1.39-tyt3-v6/misc/mke2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/misc/mke2fs.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/misc/mke2fs.c 2007-06-11 12:48:52.000000000 +0200
@@ -192,7 +192,7 @@ static void test_disk(ext2_filsys fs, ba

sprintf(buf, "badblocks -b %d -X %s%s%s %u", fs->blocksize,
quiet ? "" : "-s ", (cflag > 1) ? "-w " : "",
- fs->device_name, fs->super->s_blocks_count-1);
+ fs->device_name, EXT2_BLOCKS_COUNT(fs->super) - 1);
if (verbose)
printf(_("Running command: %s\n"), buf);
f = popen(buf, "r");
@@ -263,7 +263,7 @@ _("Warning: the backup superblock/group
group_bad++;
group = ext2fs_group_of_blk(fs, group_block+j);
fs->group_desc[group].bg_free_blocks_count++;
- fs->super->s_free_blocks_count++;
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super, EXT2_FREE_BLOCKS_COUNT(fs->super) + 1);
}
}
group_block += fs->super->s_blocks_per_group;
@@ -472,7 +472,8 @@ static void setup_lazy_bg(ext2_filsys fs
if (bg->bg_free_blocks_count == blks) {
bg->bg_free_blocks_count = 0;
bg->bg_flags |= EXT2_BG_BLOCK_UNINIT;
- sb->s_free_blocks_count -= blks;
+ EXT2_FREE_BLOCKS_COUNT_SET(sb,
+ EXT2_FREE_BLOCKS_COUNT(sb) - blks);
}
}
}
@@ -624,7 +625,7 @@ static void create_journal_dev(ext2_fils
int count;

retval = ext2fs_create_journal_superblock(fs,
- fs->super->s_blocks_count, 0, &buf);
+ EXT2_BLOCKS_COUNT(fs->super), 0, &buf);
if (retval) {
com_err("create_journal_dev", retval,
_("while initializing journal superblock"));
@@ -634,9 +635,9 @@ static void create_journal_dev(ext2_fils
memset(&progress, 0, sizeof(progress));
else
progress_init(&progress, _("Zeroing journal device: "),
- fs->super->s_blocks_count);
+ EXT2_BLOCKS_COUNT(fs->super));

- retval = zero_blocks(fs, 0, fs->super->s_blocks_count,
+ retval = zero_blocks(fs, 0, EXT2_BLOCKS_COUNT(fs->super),
&progress, &blk, &count);
if (retval) {
com_err("create_journal_dev", retval,
@@ -666,9 +667,9 @@ static void show_stats(ext2_filsys fs)
dgrp_t i;
int need, col_left;

- if (fs_param.s_blocks_count != s->s_blocks_count)
+ if (EXT2_BLOCKS_COUNT(&fs_param) != EXT2_BLOCKS_COUNT(s))
fprintf(stderr, _("warning: %u blocks unused.\n\n"),
- fs_param.s_blocks_count - s->s_blocks_count);
+ EXT2_BLOCKS_COUNT(&fs_param) - EXT2_BLOCKS_COUNT(s));

memset(buf, 0, sizeof(buf));
strncpy(buf, s->s_volume_name, sizeof(s->s_volume_name));
@@ -683,10 +684,10 @@ static void show_stats(ext2_filsys fs)
printf(_("Fragment size=%u (log=%u)\n"), fs->fragsize,
s->s_log_frag_size);
printf(_("%u inodes, %u blocks\n"), s->s_inodes_count,
- s->s_blocks_count);
+ EXT2_BLOCKS_COUNT(s));
printf(_("%u blocks (%2.2f%%) reserved for the super user\n"),
- s->s_r_blocks_count,
- 100.0 * s->s_r_blocks_count / s->s_blocks_count);
+ EXT2_R_BLOCKS_COUNT(s),
+ 100.0 * EXT2_R_BLOCKS_COUNT(s) / EXT2_BLOCKS_COUNT(s));
printf(_("First data block=%u\n"), s->s_first_data_block);
if (s->s_reserved_gdt_blocks)
printf(_("Maximum filesystem blocks=%lu\n"),
@@ -811,7 +812,7 @@ static void parse_extended_opts(struct e
r_usage++;
continue;
}
- if (resize <= param->s_blocks_count) {
+ if (resize <= EXT2_BLOCKS_COUNT(param)) {
fprintf(stderr,
_("The resize maximum must be greater "
"than the filesystem size.\n"));
@@ -825,7 +826,7 @@ static void parse_extended_opts(struct e
bpg = blocksize * 8;
gdpb = EXT2_DESC_PER_BLOCK(param);
group_desc_count =
- ext2fs_div_ceil(param->s_blocks_count, bpg);
+ ext2fs_div_ceil(EXT2_BLOCKS_COUNT(param), bpg);
desc_blocks = (group_desc_count +
gdpb - 1) / gdpb;
rsv_groups = ext2fs_div_ceil(resize, bpg);
@@ -1200,9 +1201,10 @@ static void PRS(int argc, char *argv[])
blocksize, sys_page_size);
}
if (optind < argc) {
- fs_param.s_blocks_count = parse_num_blocks(argv[optind++],
- fs_param.s_log_block_size);
- if (!fs_param.s_blocks_count) {
+ EXT2_BLOCKS_COUNT_SET(&fs_param,
+ parse_num_blocks(argv[optind++],
+ fs_param.s_log_block_size));
+ if (!EXT2_BLOCKS_COUNT(&fs_param)) {
com_err(program_name, 0, _("invalid blocks count - %s"),
argv[optind - 1]);
exit(1);
@@ -1217,8 +1219,8 @@ static void PRS(int argc, char *argv[])

fs_param.s_log_frag_size = fs_param.s_log_block_size;

- if (noaction && fs_param.s_blocks_count) {
- dev_size = fs_param.s_blocks_count;
+ if (noaction && (EXT2_BLOCKS_COUNT(&fs_param))) {
+ dev_size = EXT2_BLOCKS_COUNT(&fs_param);
retval = 0;
} else {
retry:
@@ -1239,7 +1241,7 @@ static void PRS(int argc, char *argv[])
_("while trying to determine filesystem size"));
exit(1);
}
- if (!fs_param.s_blocks_count) {
+ if (!EXT2_BLOCKS_COUNT(&fs_param)) {
if (retval == EXT2_ET_UNIMPLEMENTED) {
com_err(program_name, 0,
_("Couldn't determine device size; you "
@@ -1259,20 +1261,20 @@ static void PRS(int argc, char *argv[])
));
exit(1);
}
- fs_param.s_blocks_count = dev_size;
+ EXT2_BLOCKS_COUNT_SET(&fs_param, dev_size);
if (sys_page_size > EXT2_BLOCK_SIZE(&fs_param))
fs_param.s_blocks_count &= ~((sys_page_size /
EXT2_BLOCK_SIZE(&fs_param))-1);
}

- } else if (!force && (fs_param.s_blocks_count > dev_size)) {
+ } else if (!force && (EXT2_BLOCKS_COUNT(&fs_param) > dev_size)) {
com_err(program_name, 0,
_("Filesystem larger than apparent device size."));
proceed_question();
}

if (!fs_type) {
- int megs = (__u64)fs_param.s_blocks_count *
+ int megs = EXT2_BLOCKS_COUNT(&fs_param) *
(EXT2_BLOCK_SIZE(&fs_param) / 1024) / 1024;

if (fs_param.s_feature_incompat &
@@ -1383,7 +1385,8 @@ static void PRS(int argc, char *argv[])
if ((blocksize < 0) && (use_bsize < (-blocksize)))
use_bsize = -blocksize;
blocksize = use_bsize;
- fs_param.s_blocks_count /= blocksize / 1024;
+ EXT2_BLOCKS_COUNT_SET(&fs_param,
+ EXT2_BLOCKS_COUNT(&fs_param) / (blocksize / 1024));
}

if (inode_ratio == 0) {
@@ -1425,7 +1428,7 @@ static void PRS(int argc, char *argv[])
}
}

- if (!force && fs_param.s_blocks_count >= ((unsigned) 1 << 31)) {
+ if (!force && EXT2_BLOCKS_COUNT(&fs_param) >= ((unsigned) 1 << 31)) {
com_err(program_name, 0,
_("Filesystem too large. No more than 2**31-1 blocks\n"
"\t (8TB using a blocksize of 4k) are currently supported."));
@@ -1466,7 +1469,7 @@ static void PRS(int argc, char *argv[])
/* Make sure number of inodes specified will fit in 32 bits */
if (num_inodes == 0) {
__u64 n;
- n = (__u64) fs_param.s_blocks_count * blocksize / inode_ratio;
+ n = EXT2_BLOCKS_COUNT(&fs_param) * blocksize / inode_ratio;
if (n > ~0U) {
com_err(program_name, 0,
_("too many inodes (%llu), raise inode ratio?"), n);
@@ -1482,14 +1485,15 @@ static void PRS(int argc, char *argv[])
* Calculate number of inodes based on the inode ratio
*/
fs_param.s_inodes_count = num_inodes ? num_inodes :
- ((__u64) fs_param.s_blocks_count * blocksize)
+ ((__u64) EXT2_BLOCKS_COUNT(&fs_param) * blocksize)
/ inode_ratio;

/*
* Calculate number of blocks to reserve
*/
- fs_param.s_r_blocks_count = e2p_percent(reserved_ratio,
- fs_param.s_blocks_count);
+ EXT2_R_BLOCKS_COUNT_SET(
+ &fs_param, e2p_percent(
+ reserved_ratio, EXT2_BLOCKS_COUNT(&fs_param)));
}

int main (int argc, char *argv[])
@@ -1620,7 +1624,7 @@ int main (int argc, char *argv[])
} else {
/* rsv must be a power of two (64kB is MD RAID sb alignment) */
unsigned int rsv = 65536 / fs->blocksize;
- unsigned long blocks = fs->super->s_blocks_count;
+ unsigned long blocks = EXT2_BLOCKS_COUNT(fs->super);
unsigned long start;
blk_t ret_blk;

Index: e2fsprogs-1.39-tyt3-v6/misc/tune2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/misc/tune2fs.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/misc/tune2fs.c 2007-06-11 12:48:52.000000000 +0200
@@ -213,7 +213,7 @@ static int release_blocks_proc(ext2_fils
ext2fs_unmark_block_bitmap(fs->block_map,block);
group = ext2fs_group_of_blk(fs, block);
fs->group_desc[group].bg_free_blocks_count++;
- fs->super->s_free_blocks_count++;
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super, EXT2_FREE_BLOCKS_COUNT(fs->super) + 1);
return 0;
}

@@ -824,20 +824,20 @@ int main (int argc, char ** argv)
printf (_("Setting interval between checks to %lu seconds\n"), interval);
}
if (m_flag) {
- sb->s_r_blocks_count = e2p_percent(reserved_ratio,
- sb->s_blocks_count);
+ EXT2_R_BLOCKS_COUNT_SET(sb,
+ e2p_percent(reserved_ratio, EXT2_BLOCKS_COUNT(sb)));
ext2fs_mark_super_dirty(fs);
printf (_("Setting reserved blocks percentage to %g%% (%u blocks)\n"),
- reserved_ratio, sb->s_r_blocks_count);
+ reserved_ratio, EXT2_R_BLOCKS_COUNT(sb));
}
if (r_flag) {
- if (reserved_blocks >= sb->s_blocks_count/2) {
+ if (reserved_blocks >= EXT2_BLOCKS_COUNT(sb)/2) {
com_err (program_name, 0,
_("reserved blocks count is too big (%lu)"),
reserved_blocks);
exit (1);
}
- sb->s_r_blocks_count = reserved_blocks;
+ EXT2_R_BLOCKS_COUNT_SET(sb, reserved_blocks);
ext2fs_mark_super_dirty(fs);
printf (_("Setting reserved blocks count to %lu\n"),
reserved_blocks);
Index: e2fsprogs-1.39-tyt3-v6/misc/util.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/misc/util.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/misc/util.c 2007-06-11 12:48:52.000000000 +0200
@@ -253,7 +253,7 @@ int figure_journal_size(int size, ext2_f
{
blk_t j_blocks;

- if (fs->super->s_blocks_count < 2048) {
+ if (EXT2_BLOCKS_COUNT(fs->super) < 2048) {
fputs(_("\nFilesystem too small for a journal\n"), stderr);
return 0;
}
@@ -268,7 +268,7 @@ int figure_journal_size(int size, ext2_f
j_blocks);
exit(1);
}
- if (j_blocks > fs->super->s_free_blocks_count / 2) {
+ if (j_blocks > EXT2_FREE_BLOCKS_COUNT(fs->super) / 2) {
fputs(_("\nJournal size too big for filesystem.\n"),
stderr);
exit(1);
@@ -276,13 +276,13 @@ int figure_journal_size(int size, ext2_f
return j_blocks;
}

- if (fs->super->s_blocks_count < 32768)
+ if (EXT2_FREE_BLOCKS_COUNT(fs->super) < 32768)
j_blocks = 1400;
- else if (fs->super->s_blocks_count < 256*1024)
+ else if (EXT2_FREE_BLOCKS_COUNT(fs->super) < 256*1024)
j_blocks = 4096;
- else if (fs->super->s_blocks_count < 512*1024)
+ else if (EXT2_FREE_BLOCKS_COUNT(fs->super) < 512*1024)
j_blocks = 8192;
- else if (fs->super->s_blocks_count < 1024*1024)
+ else if (EXT2_FREE_BLOCKS_COUNT(fs->super) < 1024*1024)
j_blocks = 16384;
else
j_blocks = 32768;
Index: e2fsprogs-1.39-tyt3-v6/resize/main.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/resize/main.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/resize/main.c 2007-06-11 12:48:52.000000000 +0200
@@ -374,7 +374,7 @@ int main (int argc, char ** argv)
fs->blocksize / 1024, new_size);
exit(1);
}
- if (new_size == fs->super->s_blocks_count) {
+ if (new_size == EXT2_BLOCKS_COUNT(fs->super)) {
fprintf(stderr, _("The filesystem is already %u blocks "
"long. Nothing to do!\n\n"), new_size);
exit(0);
Index: e2fsprogs-1.39-tyt3-v6/resize/online.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/resize/online.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/resize/online.c 2007-06-11 12:48:52.000000000 +0200
@@ -32,9 +32,9 @@ errcode_t online_resize_fs(ext2_filsys f
printf(_("Filesystem at %s is mounted on %s; "
"on-line resizing required\n"), fs->device_name, mtpt);

- if (*new_size < sb->s_blocks_count) {
+ if (*new_size < EXT2_BLOCKS_COUNT(sb)) {
printf(_("On-line shrinking from %u to %u not supported.\n"),
- sb->s_blocks_count, *new_size);
+ EXT2_BLOCKS_COUNT(sb), *new_size);
exit(1);
}

@@ -64,7 +64,7 @@ errcode_t online_resize_fs(ext2_filsys f
exit(1);
}

- size=sb->s_blocks_count;
+ size=EXT2_BLOCKS_COUNT(sb);
if (ioctl(fd, EXT2_IOC_GROUP_EXTEND, &size)) {
if (errno == EPERM)
com_err(program_name, 0,
@@ -78,7 +78,8 @@ errcode_t online_resize_fs(ext2_filsys f
exit(1);
}

- r_frac = ext2fs_div_ceil(100 * sb->s_r_blocks_count, sb->s_blocks_count);
+ r_frac = ext2fs_div_ceil(100 * EXT2_R_BLOCKS_COUNT(sb),
+ EXT2_BLOCKS_COUNT(sb));

retval = ext2fs_read_bitmaps(fs);
if (retval)
@@ -121,7 +122,7 @@ errcode_t online_resize_fs(ext2_filsys f
input.inode_table = new_fs->group_desc[i].bg_inode_table;
input.blocks_count = sb->s_blocks_per_group;
if (i == new_fs->group_desc_count-1) {
- input.blocks_count = new_fs->super->s_blocks_count -
+ input.blocks_count = EXT2_BLOCKS_COUNT(new_fs->super) -
sb->s_first_data_block -
(i * sb->s_blocks_per_group);
}
Index: e2fsprogs-1.39-tyt3-v6/resize/resize2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/resize/resize2fs.c 2007-06-11 12:48:47.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/resize/resize2fs.c 2007-06-11 12:48:52.000000000 +0200
@@ -34,6 +34,7 @@
*/

#include "resize2fs.h"
+#include "e2p/e2p.h"
#include <time.h>

#ifdef __linux__ /* Kludge for debugging */
@@ -100,7 +101,7 @@ errcode_t resize_fs(ext2_filsys fs, blk_
if (retval)
goto errout;

- *new_size = rfs->new_fs->super->s_blocks_count;
+ *new_size = EXT2_BLOCKS_COUNT(rfs->new_fs->super);

retval = blocks_to_move(rfs);
if (retval)
@@ -109,8 +110,8 @@ errcode_t resize_fs(ext2_filsys fs, blk_
#ifdef RESIZE2FS_DEBUG
if (rfs->flags & RESIZE_DEBUG_BMOVE)
printf("Number of free blocks: %u/%u, Needed: %d\n",
- rfs->old_fs->super->s_free_blocks_count,
- rfs->new_fs->super->s_free_blocks_count,
+ EXT2_FREE_BLOCKS_COUNT(rfs->old_fs->super),
+ EXT2_FREE_BLOCKS_COUNT(rfs->new_fs->super),
rfs->needed_blocks);
#endif

@@ -188,10 +189,10 @@ errcode_t adjust_fs_info(ext2_filsys fs,
int has_super;
__u64 new_inodes; /* u64 to check for overflow */

- fs->super->s_blocks_count = new_size;
+ EXT2_BLOCKS_COUNT_SET(fs->super, new_size);

retry:
- fs->group_desc_count = ext2fs_div_ceil(fs->super->s_blocks_count -
+ fs->group_desc_count = ext2fs_div_ceil(EXT2_BLOCKS_COUNT(fs->super) -
fs->super->s_first_data_block,
EXT2_BLOCKS_PER_GROUP(fs->super));
if (fs->group_desc_count == 0)
@@ -216,12 +217,12 @@ retry:
* necessary data structures. If not, we need to get rid of
* it.
*/
- rem = (fs->super->s_blocks_count - fs->super->s_first_data_block) %
+ rem = (EXT2_BLOCKS_COUNT(fs->super) - fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if ((fs->group_desc_count == 1) && rem && (rem < overhead))
return EXT2_ET_TOOSMALL;
if (rem && (rem < overhead+50)) {
- fs->super->s_blocks_count -= rem;
+ EXT2_BLOCKS_COUNT_SET(fs->super, EXT2_BLOCKS_COUNT(fs->super) - rem);
goto retry;
}
/*
@@ -239,21 +240,23 @@ retry:
/*
* Adjust the number of free blocks
*/
- blk = old_fs->super->s_blocks_count;
- if (blk > fs->super->s_blocks_count)
- fs->super->s_free_blocks_count -=
- (blk - fs->super->s_blocks_count);
+ blk = EXT2_BLOCKS_COUNT(old_fs->super);
+ if (blk > EXT2_BLOCKS_COUNT(fs->super))
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super,
+ EXT2_FREE_BLOCKS_COUNT(fs->super) -
+ (blk - EXT2_BLOCKS_COUNT(fs->super)));
else
- fs->super->s_free_blocks_count +=
- (fs->super->s_blocks_count - blk);
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super,
+ EXT2_FREE_BLOCKS_COUNT(fs->super) +
+ (EXT2_BLOCKS_COUNT(fs->super) - blk));

/*
* Adjust the number of reserved blocks
*/
- blk = (__u64)old_fs->super->s_r_blocks_count * 100 /
- old_fs->super->s_blocks_count;
- fs->super->s_r_blocks_count = e2p_percent(blk,
- fs->super->s_blocks_count);
+ blk = EXT2_R_BLOCKS_COUNT(old_fs->super) * 100 /
+ EXT2_BLOCKS_COUNT(old_fs->super);
+ EXT2_R_BLOCKS_COUNT_SET(
+ fs->super, e2p_percent(blk, EXT2_BLOCKS_COUNT(fs->super)));

/*
* Adjust the bitmaps for size
@@ -266,7 +269,7 @@ retry:
real_end = ((EXT2_BLOCKS_PER_GROUP(fs->super)
* fs->group_desc_count)) - 1 +
fs->super->s_first_data_block;
- retval = ext2fs_resize_block_bitmap(fs->super->s_blocks_count-1,
+ retval = ext2fs_resize_block_bitmap(EXT2_BLOCKS_COUNT(fs->super)-1,
real_end, fs->block_map);

if (retval) goto errout;
@@ -323,13 +326,13 @@ retry:
/*
* Fix the count of the last (old) block group
*/
- old_numblocks = (old_fs->super->s_blocks_count -
+ old_numblocks = (EXT2_BLOCKS_COUNT(old_fs->super) -
old_fs->super->s_first_data_block) %
old_fs->super->s_blocks_per_group;
if (!old_numblocks)
old_numblocks = old_fs->super->s_blocks_per_group;
if (old_fs->group_desc_count == fs->group_desc_count) {
- numblocks = (fs->super->s_blocks_count -
+ numblocks = (EXT2_BLOCKS_COUNT(fs->super) -
fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if (!numblocks)
@@ -369,7 +372,7 @@ retry:
adjblocks = 0;

if (i == fs->group_desc_count-1) {
- numblocks = (fs->super->s_blocks_count -
+ numblocks = (EXT2_BLOCKS_COUNT(fs->super) -
fs->super->s_first_data_block) %
fs->super->s_blocks_per_group;
if (!numblocks)
@@ -406,7 +409,7 @@ retry:
adjblocks += 2 + fs->inode_blocks_per_group;

numblocks -= adjblocks;
- fs->super->s_free_blocks_count -= adjblocks;
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super, EXT2_FREE_BLOCKS_COUNT(fs->super) - adjblocks);
fs->super->s_free_inodes_count +=
fs->super->s_inodes_per_group;
fs->group_desc[i].bg_free_blocks_count = numblocks;
@@ -634,7 +637,7 @@ static errcode_t blocks_to_move(ext2_res

fs = rfs->new_fs;
old_fs = rfs->old_fs;
- if (old_fs->super->s_blocks_count > fs->super->s_blocks_count)
+ if (EXT2_BLOCKS_COUNT(old_fs->super) > EXT2_BLOCKS_COUNT(fs->super))
fs = rfs->old_fs;

retval = ext2fs_allocate_block_bitmap(fs, _("reserved blocks"),
@@ -662,8 +665,8 @@ static errcode_t blocks_to_move(ext2_res
* If we're shrinking the filesystem, we need to move all of
* the blocks that don't fit any more
*/
- for (blk = fs->super->s_blocks_count;
- blk < old_fs->super->s_blocks_count; blk++) {
+ for (blk = EXT2_BLOCKS_COUNT(fs->super);
+ blk < EXT2_BLOCKS_COUNT(old_fs->super); blk++) {
if (ext2fs_test_block_bitmap(old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) {
ext2fs_mark_block_bitmap(rfs->move_blocks, blk);
@@ -860,9 +863,9 @@ static void init_block_alloc(ext2_resize
rfs->new_blk = rfs->new_fs->super->s_first_data_block;
#if 0
/* HACK for testing */
- if (rfs->new_fs->super->s_blocks_count >
- rfs->old_fs->super->s_blocks_count)
- rfs->new_blk = rfs->old_fs->super->s_blocks_count;
+ if (EXT2_BLOCKS_COUNT(rfs->new_fs->super) >
+ EXT2_BLOCKS_COUNT(rfs->old_fs->super))
+ rfs->new_blk = EXT2_BLOCKS_COUNT(rfs->old_fs->super);
#endif
}

@@ -871,7 +874,7 @@ static blk_t get_new_block(ext2_resize_t
ext2_filsys fs = rfs->new_fs;

while (1) {
- if (rfs->new_blk >= fs->super->s_blocks_count) {
+ if (rfs->new_blk >= EXT2_BLOCKS_COUNT(fs->super)) {
if (rfs->alloc_state == DESPERATION)
return 0;

@@ -888,7 +891,7 @@ static blk_t get_new_block(ext2_resize_t
ext2fs_test_block_bitmap(rfs->reserve_blocks,
rfs->new_blk) ||
((rfs->alloc_state == AVOID_OLD) &&
- (rfs->new_blk < rfs->old_fs->super->s_blocks_count) &&
+ (rfs->new_blk < EXT2_BLOCKS_COUNT(rfs->old_fs->super)) &&
ext2fs_test_block_bitmap(rfs->old_fs->block_map,
rfs->new_blk))) {
rfs->new_blk++;
@@ -932,7 +935,7 @@ static errcode_t block_mover(ext2_resize
to_move = moved = 0;
init_block_alloc(rfs);
for (blk = old_fs->super->s_first_data_block;
- blk < old_fs->super->s_blocks_count; blk++) {
+ blk < EXT2_BLOCKS_COUNT(old_fs->super); blk++) {
if (!ext2fs_test_block_bitmap(old_fs->block_map, blk))
continue;
if (!ext2fs_test_block_bitmap(rfs->move_blocks, blk))
@@ -1126,10 +1129,10 @@ static errcode_t inode_scan_and_fix(ext2
* is larger. We need to do this to avoid catching an error
* by the block iterator routines
*/
- orig_size = rfs->old_fs->super->s_blocks_count;
- if (orig_size < rfs->new_fs->super->s_blocks_count)
- rfs->old_fs->super->s_blocks_count =
- rfs->new_fs->super->s_blocks_count;
+ orig_size = EXT2_BLOCKS_COUNT(rfs->old_fs->super);
+ if (orig_size < EXT2_BLOCKS_COUNT(rfs->new_fs->super))
+ EXT2_BLOCKS_COUNT_SET(rfs->old_fs->super,
+ EXT2_BLOCKS_COUNT(rfs->new_fs->super));

retval = ext2fs_open_inode_scan(rfs->old_fs, 0, &scan);
if (retval) goto errout;
@@ -1238,7 +1241,7 @@ static errcode_t inode_scan_and_fix(ext2
io_channel_flush(rfs->old_fs->io);

errout:
- rfs->old_fs->super->s_blocks_count = orig_size;
+ EXT2_BLOCKS_COUNT_SET(rfs->old_fs->super, orig_size);
if (rfs->bmap) {
ext2fs_free_extent_table(rfs->bmap);
rfs->bmap = 0;
@@ -1565,21 +1568,21 @@ static errcode_t ext2fs_calculate_summar
* First calculate the block statistics
*/
for (blk = fs->super->s_first_data_block;
- blk < fs->super->s_blocks_count; blk++) {
+ blk < EXT2_BLOCKS_COUNT(fs->super); blk++) {
if (!ext2fs_fast_test_block_bitmap(fs->block_map, blk)) {
group_free++;
total_free++;
}
count++;
if ((count == fs->super->s_blocks_per_group) ||
- (blk == fs->super->s_blocks_count-1)) {
+ (blk == EXT2_BLOCKS_COUNT(fs->super)-1)) {
fs->group_desc[group++].bg_free_blocks_count =
group_free;
count = 0;
group_free = 0;
}
}
- fs->super->s_free_blocks_count = total_free;
+ EXT2_FREE_BLOCKS_COUNT_SET(fs->super, total_free);

/*
* Next, calculate the inode statistics
Index: e2fsprogs-1.39-tyt3-v6/lib/ext2fs/extent.c
===================================================================
--- e2fsprogs-1.39-tyt3-v6.orig/lib/ext2fs/extent.c 2007-06-11 12:48:35.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v6/lib/ext2fs/extent.c 2007-06-11 12:48:52.000000000 +0200
@@ -106,7 +106,7 @@ errcode_t ext2fs_extent_verify(ext2_fils
{
ext_show_extent(ex);
/* FIXME: 48-bit support */
- if (ex->ee_start > fs->super->s_blocks_count)
+ if (ex->ee_start > EXT2_BLOCKS_COUNT(fs->super))
return EXT2_ET_EXTENT_LEAF_BAD;

if (ex->ee_len == 0)
@@ -149,7 +149,7 @@ errcode_t ext2fs_extent_index_verify(ext
{
ext_show_index(ix);
/* FIXME: 48-bit support */
- if (ix->ei_leaf > fs->super->s_blocks_count)
+ if (ix->ei_leaf > EXT2_BLOCKS_COUNT(fs->super))
return EXT2_ET_EXTENT_INDEX_BAD;

if (ix_prev == NULL)