This patch contains the changes to handle 64-bit block numbers stored in group
descriptor structure.
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/check_desc.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/check_desc.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/check_desc.c 2007-06-21 16:44:41.000000000 +0200
@@ -45,22 +45,22 @@ errcode_t ext2fs_check_desc(ext2_filsys
* Check to make sure block bitmap for group is
* located within the group.
*/
- if (fs->group_desc[i].bg_block_bitmap < first_block ||
- fs->group_desc[i].bg_block_bitmap > last_block)
+ if (ext2_block_bitmap(fs, i) < first_block ||
+ ext2_block_bitmap(fs, i) > last_block)
return EXT2_ET_GDESC_BAD_BLOCK_MAP;
/*
* Check to make sure inode bitmap for group is
* located within the group
*/
- if (fs->group_desc[i].bg_inode_bitmap < first_block ||
- fs->group_desc[i].bg_inode_bitmap > last_block)
+ if (ext2_inode_bitmap(fs, i) < first_block ||
+ ext2_inode_bitmap(fs, i) > last_block)
return EXT2_ET_GDESC_BAD_INODE_MAP;
/*
* Check to make sure inode table for group is located
* within the group
*/
- if (fs->group_desc[i].bg_inode_table < first_block ||
- ((fs->group_desc[i].bg_inode_table +
+ if (ext2_inode_table(fs, i) < first_block ||
+ ((ext2_inode_table(fs, i) +
fs->inode_blocks_per_group) > last_block))
return EXT2_ET_GDESC_BAD_INODE_TABLE;
}
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/alloc_tables.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/alloc_tables.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/alloc_tables.c 2007-06-21 16:44:41.000000000 +0200
@@ -56,7 +56,7 @@ errcode_t ext2fs_allocate_group_table(ex
} else
start_blk = group_blk;
- if (!fs->group_desc[group].bg_block_bitmap) {
+ if (!ext2_block_bitmap(fs, group)) {
retval = ext2fs_get_free_blocks(fs, start_blk, last_blk,
1, bmap, &new_blk);
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL)
@@ -65,10 +65,10 @@ errcode_t ext2fs_allocate_group_table(ex
if (retval)
return retval;
ext2fs_mark_block_bitmap(bmap, new_blk);
- fs->group_desc[group].bg_block_bitmap = new_blk;
+ ext2_block_bitmap_set(fs, group, new_blk);
}
- if (!fs->group_desc[group].bg_inode_bitmap) {
+ if (!ext2_inode_bitmap(fs, group)) {
retval = ext2fs_get_free_blocks(fs, start_blk, last_blk,
1, bmap, &new_blk);
if (retval == EXT2_ET_BLOCK_ALLOC_FAIL)
@@ -77,13 +77,13 @@ errcode_t ext2fs_allocate_group_table(ex
if (retval)
return retval;
ext2fs_mark_block_bitmap(bmap, new_blk);
- fs->group_desc[group].bg_inode_bitmap = new_blk;
+ ext2_inode_bitmap_set(fs, group, new_blk);
}
/*
* Allocate the inode table
*/
- if (!fs->group_desc[group].bg_inode_table) {
+ if (!ext2_inode_table(fs, group)) {
retval = ext2fs_get_free_blocks(fs, group_blk, last_blk,
fs->inode_blocks_per_group,
bmap, &new_blk);
@@ -93,7 +93,7 @@ errcode_t ext2fs_allocate_group_table(ex
j < fs->inode_blocks_per_group;
j++, blk++)
ext2fs_mark_block_bitmap(bmap, blk);
- fs->group_desc[group].bg_inode_table = new_blk;
+ ext2_inode_table_set(fs, group, new_blk);
}
Index: e2fsprogs-1.39-tyt3-v7/e2fsck/pass5.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/e2fsck/pass5.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/e2fsck/pass5.c 2007-06-21 16:44:41.000000000 +0200
@@ -123,6 +123,7 @@ static void check_block_bitmaps(e2fsck_t
errcode_t retval;
int lazy_bg = 0;
int skip_group = 0;
+ struct ext4_group_desc *gdp;
clear_problem_context(&pctx);
free_array = (int *) e2fsck_allocate_memory(ctx,
@@ -165,8 +166,8 @@ redo_counts:
had_problem = 0;
save_problem = 0;
pctx.blk = pctx.blk2 = NO_BLK;
- if (lazy_bg && (fs->group_desc[group].bg_flags &
- EXT2_BG_BLOCK_UNINIT))
+ gdp = ext2_get_group_desc(fs, group);
+ if (lazy_bg && (gdp->bg_flags & EXT2_BG_BLOCK_UNINIT))
skip_group++;
super = fs->super->s_first_data_block;
for (i = fs->super->s_first_data_block;
@@ -179,12 +180,12 @@ redo_counts:
(i <= super + fs->desc_blocks) &&
ext2fs_bg_has_super(fs, group))
bitmap = 1;
- else if (i == fs->group_desc[group].bg_block_bitmap)
+ else if (i == ext2_block_bitmap(fs, group))
bitmap = 1;
- else if (i == fs->group_desc[group].bg_inode_bitmap)
+ else if (i == ext2_inode_bitmap(fs, group))
bitmap = 1;
- else if (i >= fs->group_desc[group].bg_inode_table &&
- (i < fs->group_desc[group].bg_inode_table
+ else if (i >= ext2_inode_table(fs, group) &&
+ (i < ext2_inode_table(fs, group)
+ fs->inode_blocks_per_group))
bitmap = 1;
else
@@ -241,10 +242,10 @@ redo_counts:
if ((ctx->progress)(ctx, 5, group,
fs->group_desc_count*2))
goto errout;
+ gdp = ext2_get_group_desc(fs, group);
if (lazy_bg &&
(i != EXT2_BLOCKS_COUNT(fs->super)-1) &&
- (fs->group_desc[group].bg_flags &
- EXT2_BG_BLOCK_UNINIT))
+ (gdp->bg_flags & EXT2_BG_BLOCK_UNINIT))
skip_group++;
}
}
@@ -277,15 +278,15 @@ redo_counts:
ext2fs_unmark_valid(fs);
for (i = 0; i < fs->group_desc_count; i++) {
- if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) {
+ gdp = ext2_get_group_desc(fs, i);
+ if (free_array[i] != gdp->bg_free_blocks_count) {
pctx.group = i;
- pctx.blk = fs->group_desc[i].bg_free_blocks_count;
+ pctx.blk = gdp->bg_free_blocks_count;
pctx.blk2 = free_array[i];
if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
&pctx)) {
- fs->group_desc[i].bg_free_blocks_count =
- free_array[i];
+ gdp->bg_free_blocks_count = free_array[i];
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
@@ -323,6 +324,7 @@ static void check_inode_bitmaps(e2fsck_t
int problem, save_problem, fixit, had_problem;
int lazy_bg = 0;
int skip_group = 0;
+ struct ext4_group_desc *gdp;
clear_problem_context(&pctx);
free_array = (int *) e2fsck_allocate_memory(ctx,
@@ -366,8 +368,8 @@ redo_counts:
had_problem = 0;
save_problem = 0;
pctx.ino = pctx.ino2 = 0;
- if (lazy_bg && (fs->group_desc[group].bg_flags &
- EXT2_BG_INODE_UNINIT))
+ gdp = ext2_get_group_desc(fs, group);
+ if (lazy_bg && (gdp->bg_flags & EXT2_BG_INODE_UNINIT))
skip_group++;
/* Protect loop from wrap-around if inodes_count is maxed */
@@ -430,10 +432,10 @@ do_counts:
group + fs->group_desc_count,
fs->group_desc_count*2))
goto errout;
+ gdp = ext2_get_group_desc(fs, group);
if (lazy_bg &&
(i != fs->super->s_inodes_count) &&
- (fs->group_desc[group].bg_flags &
- EXT2_BG_INODE_UNINIT))
+ (gdp->bg_flags & EXT2_BG_INODE_UNINIT))
skip_group++;
}
}
@@ -469,27 +471,26 @@ do_counts:
ext2fs_unmark_valid(fs);
for (i = 0; i < fs->group_desc_count; i++) {
- if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) {
+ gdp = ext2_get_group_desc(fs, i);
+ if (free_array[i] != gdp->bg_free_inodes_count) {
pctx.group = i;
- pctx.ino = fs->group_desc[i].bg_free_inodes_count;
+ pctx.ino = gdp->bg_free_inodes_count;
pctx.ino2 = free_array[i];
if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP,
&pctx)) {
- fs->group_desc[i].bg_free_inodes_count =
- free_array[i];
+ gdp->bg_free_inodes_count = free_array[i];
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
}
- if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) {
+ if (dir_array[i] != gdp->bg_used_dirs_count) {
pctx.group = i;
- pctx.ino = fs->group_desc[i].bg_used_dirs_count;
+ pctx.ino = gdp->bg_used_dirs_count;
pctx.ino2 = dir_array[i];
if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP,
&pctx)) {
- fs->group_desc[i].bg_used_dirs_count =
- dir_array[i];
+ gdp->bg_used_dirs_count = dir_array[i];
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/swapfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/swapfs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/swapfs.c 2007-06-21 16:44:41.000000000 +0200
@@ -80,7 +80,8 @@ void ext2fs_swap_super(struct ext2_super
}
-void ext2fs_swap_group_desc(struct ext2_group_desc *gdp)
+void ext2fs_swap_group_desc(struct ext2_super_block *sb,
+ struct ext4_group_desc *gdp)
{
gdp->bg_block_bitmap = ext2fs_swab32(gdp->bg_block_bitmap);
gdp->bg_inode_bitmap = ext2fs_swab32(gdp->bg_inode_bitmap);
@@ -91,6 +92,12 @@ void ext2fs_swap_group_desc(struct ext2_
gdp->bg_flags = ext2fs_swab16(gdp->bg_flags);
gdp->bg_itable_unused = ext2fs_swab16(gdp->bg_itable_unused);
gdp->bg_checksum = ext2fs_swab16(gdp->bg_checksum);
+ if (EXT2_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT) &&
+ sb->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp->bg_block_bitmap_hi = ext2fs_swab32(gdp->bg_block_bitmap_hi);
+ gdp->bg_inode_bitmap_hi = ext2fs_swab32(gdp->bg_inode_bitmap_hi);
+ gdp->bg_inode_table_hi = ext2fs_swab32(gdp->bg_inode_table_hi);
+ }
}
void ext2fs_swap_ext_attr(char *to, char *from, int bufsize, int has_header)
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/rw_bitmaps.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/rw_bitmaps.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/rw_bitmaps.c 2007-06-21 16:44:41.000000000 +0200
@@ -62,6 +62,7 @@ static errcode_t write_bitmaps(ext2_fils
char *block_buf, *inode_buf;
int lazy_flag = 0;
blk_t blk;
+ struct ext4_group_desc *gdp;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
@@ -94,8 +95,8 @@ static errcode_t write_bitmaps(ext2_fils
if (!block_bitmap || !do_block)
goto skip_block_bitmap;
- if (lazy_flag && fs->group_desc[i].bg_flags &
- EXT2_BG_BLOCK_UNINIT)
+ gdp = ext2_get_group_desc(fs, i);
+ if (lazy_flag && gdp->bg_flags & EXT2_BG_BLOCK_UNINIT)
goto skip_this_block_bitmap;
memcpy(block_buf, block_bitmap, block_nbytes);
@@ -108,7 +109,7 @@ static errcode_t write_bitmaps(ext2_fils
for (j = nbits; j < fs->blocksize * 8; j++)
ext2fs_set_bit(j, block_buf);
}
- blk = fs->group_desc[i].bg_block_bitmap;
+ blk = ext2_block_bitmap(fs, i);
if (blk) {
#ifdef EXT2_BIG_ENDIAN_BITMAPS
if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
@@ -128,12 +129,11 @@ static errcode_t write_bitmaps(ext2_fils
if (!inode_bitmap || !do_inode)
continue;
- if (lazy_flag && fs->group_desc[i].bg_flags &
- EXT2_BG_INODE_UNINIT)
+ if (lazy_flag && gdp->bg_flags & EXT2_BG_INODE_UNINIT)
goto skip_this_inode_bitmap;
memcpy(inode_buf, inode_bitmap, inode_nbytes);
- blk = fs->group_desc[i].bg_inode_bitmap;
+ blk = ext2_inode_bitmap(fs, i);
if (blk) {
#ifdef EXT2_BIG_ENDIAN_BITMAPS
if (!((fs->flags & EXT2_FLAG_SWAP_BYTES) ||
@@ -171,6 +171,7 @@ static errcode_t read_bitmaps(ext2_filsy
int inode_nbytes = (int) EXT2_INODES_PER_GROUP(fs->super) / 8;
int lazy_flag = 0;
blk_t blk;
+ struct ext4_group_desc *gdp;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
@@ -227,9 +228,9 @@ static errcode_t read_bitmaps(ext2_filsy
for (i = 0; i < fs->group_desc_count; i++) {
if (block_bitmap) {
- blk = fs->group_desc[i].bg_block_bitmap;
- if (lazy_flag && fs->group_desc[i].bg_flags &
- EXT2_BG_BLOCK_UNINIT)
+ blk = ext2_block_bitmap(fs, i);
+ gdp = ext2_get_group_desc(fs, i);
+ if (lazy_flag && gdp->bg_flags & EXT2_BG_BLOCK_UNINIT)
blk = 0;
if (blk) {
retval = io_channel_read_blk(fs->io, blk,
@@ -248,8 +249,8 @@ static errcode_t read_bitmaps(ext2_filsy
block_bitmap += block_nbytes;
}
if (inode_bitmap) {
- blk = fs->group_desc[i].bg_inode_bitmap;
- if (lazy_flag && fs->group_desc[i].bg_flags &
+ blk = ext2_inode_bitmap(fs, i);
+ if (lazy_flag && gdp->bg_flags &
EXT2_BG_INODE_UNINIT)
blk = 0;
if (blk) {
Index: e2fsprogs-1.39-tyt3-v7/resize/online.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/resize/online.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/resize/online.c 2007-06-21 16:44:41.000000000 +0200
@@ -117,9 +117,9 @@ errcode_t online_resize_fs(ext2_filsys f
new_fs->super->s_reserved_gdt_blocks;
input.group = i;
- input.block_bitmap = new_fs->group_desc[i].bg_block_bitmap;
- input.inode_bitmap = new_fs->group_desc[i].bg_inode_bitmap;
- input.inode_table = new_fs->group_desc[i].bg_inode_table;
+ input.block_bitmap = ext2_block_bitmap(new_fs, i);
+ input.inode_bitmap = ext2_inode_bitmap(new_fs, i);
+ input.inode_table = ext2_inode_table(new_fs, i);
input.blocks_count = sb->s_blocks_per_group;
if (i == new_fs->group_desc_count-1) {
input.blocks_count = EXT2_BLOCKS_COUNT(new_fs->super) -
Index: e2fsprogs-1.39-tyt3-v7/debugfs/logdump.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/debugfs/logdump.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/debugfs/logdump.c 2007-06-21 16:44:41.000000000 +0200
@@ -156,7 +156,7 @@ void do_logdump(int argc, char **argv)
/ sizeof(struct ext2_inode));
inode_block_to_dump =
- current_fs->group_desc[inode_group].bg_inode_table +
+ ext2_inode_table(current_fs, inode_group) +
(group_offset / inodes_per_block);
inode_offset_to_dump = ((group_offset % inodes_per_block)
* sizeof(struct ext2_inode));
@@ -181,7 +181,7 @@ void do_logdump(int argc, char **argv)
group_to_dump = ((block_to_dump -
es->s_first_data_block)
/ es->s_blocks_per_group);
- bitmap_to_dump = current_fs->group_desc[group_to_dump].bg_block_bitmap;
+ bitmap_to_dump = ext2_block_bitmap(current_fs, group_to_dump);
}
if (!journal_fn && check_fs_open(argv[0]))
Index: e2fsprogs-1.39-tyt3-v7/debugfs/debugfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/debugfs/debugfs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/debugfs/debugfs.c 2007-06-21 16:44:41.000000000 +0200
@@ -266,7 +266,7 @@ static void print_features(struct ext2_s
fputs("\n", f);
}
-static void print_bg_opts(struct ext2_group_desc *gdp, int mask,
+static void print_bg_opts(struct ext4_group_desc *gdp, int mask,
const char *str, int *first, FILE *f)
{
if (gdp->bg_flags & mask) {
@@ -283,7 +283,7 @@ void do_show_super_stats(int argc, char
{
dgrp_t i;
FILE *out;
- struct ext2_group_desc *gdp;
+ struct ext4_group_desc *gdp;
int c, header_only = 0;
int numdirs = 0, first;
@@ -305,8 +305,10 @@ void do_show_super_stats(int argc, char
out = open_pager();
list_super2(current_fs->super, out);
- for (i=0; i < current_fs->group_desc_count; i++)
- numdirs += current_fs->group_desc[i].bg_used_dirs_count;
+ for (i=0; i < current_fs->group_desc_count; i++) {
+ gdp = ext2_get_group_desc(current_fs, i);
+ numdirs += gdp->bg_used_dirs_count;
+ }
fprintf(out, "Directories: %d\n", numdirs);
if (header_only) {
@@ -314,16 +316,17 @@ void do_show_super_stats(int argc, char
return;
}
- gdp = ¤t_fs->group_desc[0];
- for (i = 0; i < current_fs->group_desc_count; i++, gdp++) {
+ for (i = 0; i < current_fs->group_desc_count; i++) {
+ gdp = ext2_get_group_desc(current_fs, i);
fprintf(out, " Group %2d: block bitmap at %u, "
"inode bitmap at %u, "
"inode table at %u\n"
" %d free %s, "
"%d free %s, "
"%d used %s\n",
- i, gdp->bg_block_bitmap,
- gdp->bg_inode_bitmap, gdp->bg_inode_table,
+ i, ext2_block_bitmap(current_fs, i),
+ ext2_inode_bitmap(current_fs, i),
+ ext2_inode_table(current_fs, i),
gdp->bg_free_blocks_count,
gdp->bg_free_blocks_count != 1 ? "blocks" : "block",
gdp->bg_free_inodes_count,
@@ -1798,12 +1801,12 @@ void do_imap(int argc, char *argv[])
offset = ((ino - 1) % EXT2_INODES_PER_GROUP(current_fs->super)) *
EXT2_INODE_SIZE(current_fs->super);
block = offset >> EXT2_BLOCK_SIZE_BITS(current_fs->super);
- if (!current_fs->group_desc[(unsigned)group].bg_inode_table) {
+ if (!ext2_inode_table(current_fs, group)) {
com_err(argv[0], 0, "Inode table for group %lu is missing\n",
group);
return;
}
- block_nr = current_fs->group_desc[(unsigned)group].bg_inode_table +
+ block_nr = ext2_inode_table(current_fs, group) +
block;
offset &= (EXT2_BLOCK_SIZE(current_fs->super) - 1);
Index: e2fsprogs-1.39-tyt3-v7/resize/resize2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/resize/resize2fs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/resize/resize2fs.c 2007-06-21 16:44:41.000000000 +0200
@@ -53,9 +53,9 @@ static errcode_t ext2fs_calculate_summar
/*
* Some helper CPP macros
*/
-#define FS_BLOCK_BM(fs, i) ((fs)->group_desc[(i)].bg_block_bitmap)
-#define FS_INODE_BM(fs, i) ((fs)->group_desc[(i)].bg_inode_bitmap)
-#define FS_INODE_TB(fs, i) ((fs)->group_desc[(i)].bg_inode_table)
+#define FS_BLOCK_BM(fs, i) (ext2_block_bitmap((fs), (i)))
+#define FS_INODE_BM(fs, i) (ext2_inode_bitmap((fs), (i)))
+#define FS_INODE_TB(fs, i) (ext2_inode_table((fs), (i)))
#define IS_BLOCK_BM(fs, i, blk) ((blk) == FS_BLOCK_BM((fs),(i)))
#define IS_INODE_BM(fs, i, blk) ((blk) == FS_INODE_BM((fs),(i)))
@@ -188,6 +188,7 @@ errcode_t adjust_fs_info(ext2_filsys fs,
unsigned int meta_bg, meta_bg_size;
int has_super;
__u64 new_inodes; /* u64 to check for overflow */
+ struct ext4_group_desc *gdp;
EXT2_BLOCKS_COUNT_SET(fs->super, new_size);
@@ -340,7 +341,8 @@ retry:
} else
numblocks = fs->super->s_blocks_per_group;
i = old_fs->group_desc_count - 1;
- fs->group_desc[i].bg_free_blocks_count += (numblocks-old_numblocks);
+ gdp = ext2_get_group_desc(fs, i);
+ gdp->bg_free_blocks_count += (numblocks-old_numblocks);
/*
* If the number of block groups is staying the same, we're
@@ -367,8 +369,13 @@ retry:
fs->super->s_reserved_gdt_blocks;
for (i = old_fs->group_desc_count;
i < fs->group_desc_count; i++) {
- memset(&fs->group_desc[i], 0,
- sizeof(struct ext2_group_desc));
+ gdp = ext2_get_group_desc(fs, i);
+ if (EXT2_HAS_INCOMPAT_FEATURE(old_fs->super,
+ EXT4_FEATURE_INCOMPAT_64BIT) &&
+ old_fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT)
+ memset(gdp, 0, sizeof(struct ext4_group_desc));
+ else
+ memset(gdp, 0, sizeof(struct ext2_group_desc));
adjblocks = 0;
if (i == fs->group_desc_count-1) {
@@ -412,10 +419,10 @@ retry:
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;
- fs->group_desc[i].bg_free_inodes_count =
+ gdp->bg_free_blocks_count = numblocks;
+ gdp->bg_free_inodes_count =
fs->super->s_inodes_per_group;
- fs->group_desc[i].bg_used_dirs_count = 0;
+ gdp->bg_used_dirs_count = 0;
retval = ext2fs_allocate_group_table(fs, i, 0);
if (retval) goto errout;
@@ -505,7 +512,7 @@ static errcode_t adjust_superblock(ext2_
* Write out the new inode table
*/
retval = io_channel_write_blk(fs->io,
- fs->group_desc[i].bg_inode_table,
+ ext2_inode_table(fs, i),
fs->inode_blocks_per_group,
rfs->itable_buf);
if (retval) goto errout;
@@ -563,7 +570,7 @@ static errcode_t mark_table_blocks(ext2_
/*
* Mark the blocks used for the inode table
*/
- for (j = 0, b = fs->group_desc[i].bg_inode_table;
+ for (j = 0, b = ext2_inode_table(fs, i);
j < (unsigned int) fs->inode_blocks_per_group;
j++, b++)
ext2fs_mark_block_bitmap(bmap, b);
@@ -572,13 +579,13 @@ static errcode_t mark_table_blocks(ext2_
* Mark block used for the block bitmap
*/
ext2fs_mark_block_bitmap(bmap,
- fs->group_desc[i].bg_block_bitmap);
+ ext2_block_bitmap(fs, i));
/*
* Mark block used for the inode bitmap
*/
ext2fs_mark_block_bitmap(bmap,
- fs->group_desc[i].bg_inode_bitmap);
+ ext2_inode_bitmap(fs, i));
}
return 0;
}
@@ -603,13 +610,13 @@ static void mark_fs_metablock(ext2_resiz
* mark it as a block to be moved.
*/
if (IS_BLOCK_BM(fs, group, blk)) {
- FS_BLOCK_BM(fs, group) = 0;
+ ext2_block_bitmap_set(fs, group, 0UL);
rfs->needed_blocks++;
} else if (IS_INODE_BM(fs, group, blk)) {
- FS_INODE_BM(fs, group) = 0;
+ ext2_inode_bitmap_set(fs, group, 0UL);
rfs->needed_blocks++;
} else if (IS_INODE_TB(fs, group, blk)) {
- FS_INODE_TB(fs, group) = 0;
+ ext2_inode_table_set(fs, group, 0UL);
rfs->needed_blocks++;
} else if (ext2fs_test_block_bitmap(rfs->old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) {
@@ -744,23 +751,23 @@ static errcode_t blocks_to_move(ext2_res
group_blk + has_super);
}
- if (fs->group_desc[i].bg_inode_table &&
- fs->group_desc[i].bg_inode_bitmap &&
- fs->group_desc[i].bg_block_bitmap)
+ if (ext2_inode_table(fs, i) &&
+ ext2_inode_bitmap(fs, i) &&
+ ext2_block_bitmap(fs, i))
goto next_group;
/*
* Reserve the existing meta blocks that we know
* aren't to be moved.
*/
- if (fs->group_desc[i].bg_block_bitmap)
+ if (ext2_block_bitmap(fs, i))
ext2fs_mark_block_bitmap(rfs->reserve_blocks,
- fs->group_desc[i].bg_block_bitmap);
- if (fs->group_desc[i].bg_inode_bitmap)
+ ext2_block_bitmap(fs, i));
+ if (ext2_inode_bitmap(fs, i))
ext2fs_mark_block_bitmap(rfs->reserve_blocks,
- fs->group_desc[i].bg_inode_bitmap);
- if (fs->group_desc[i].bg_inode_table)
- for (blk = fs->group_desc[i].bg_inode_table, j=0;
+ ext2_inode_bitmap(fs, i));
+ if (ext2_inode_table(fs, i))
+ for (blk = ext2_inode_table(fs, i), j=0;
j < fs->inode_blocks_per_group ; j++, blk++)
ext2fs_mark_block_bitmap(rfs->reserve_blocks,
blk);
@@ -811,7 +818,7 @@ static errcode_t blocks_to_move(ext2_res
* allocation bitmap, and move any blocks that might
* be necessary.
*/
- for (blk = fs->group_desc[i].bg_inode_table, j=0;
+ for (blk = ext2_inode_table(fs, i), j=0;
j < fs->inode_blocks_per_group ; j++, blk++) {
ext2fs_mark_block_bitmap(fs->block_map, blk);
if (ext2fs_test_block_bitmap(old_fs->block_map, blk) &&
@@ -824,7 +831,7 @@ static errcode_t blocks_to_move(ext2_res
* Make sure the old inode table is reserved in the
* block reservation bitmap.
*/
- for (blk = rfs->old_fs->group_desc[i].bg_inode_table, j=0;
+ for (blk = ext2_inode_table(rfs->old_fs, i), j=0;
j < fs->inode_blocks_per_group ; j++, blk++)
ext2fs_mark_block_bitmap(rfs->reserve_blocks, blk);
@@ -1118,6 +1125,7 @@ static errcode_t inode_scan_and_fix(ext2
char *block_buf = 0;
ext2_ino_t start_to_move;
blk_t orig_size, new_block;
+ struct ext4_group_desc *gdp;
if ((rfs->old_fs->group_desc_count <=
rfs->new_fs->group_desc_count) &&
@@ -1225,8 +1233,10 @@ static errcode_t inode_scan_and_fix(ext2
if (retval) goto errout;
group = (new_inode-1) / EXT2_INODES_PER_GROUP(rfs->new_fs->super);
- if (LINUX_S_ISDIR(inode.i_mode))
- rfs->new_fs->group_desc[group].bg_used_dirs_count++;
+ if (LINUX_S_ISDIR(inode.i_mode)) {
+ gdp = ext2_get_group_desc(rfs->new_fs, group);
+ gdp->bg_used_dirs_count++;
+ }
#ifdef RESIZE2FS_DEBUG
if (rfs->flags & RESIZE_DEBUG_INODEMAP)
@@ -1404,8 +1414,8 @@ static errcode_t move_itables(ext2_resiz
*/
to_move = moved = 0;
for (i=0; i < max_groups; i++)
- if (rfs->old_fs->group_desc[i].bg_inode_table !=
- fs->group_desc[i].bg_inode_table)
+ if (ext2_inode_table(rfs->old_fs, i) !=
+ ext2_inode_table(rfs->old_fs, i))
to_move++;
if (to_move == 0)
@@ -1421,8 +1431,8 @@ static errcode_t move_itables(ext2_resiz
rfs->old_fs->flags |= EXT2_FLAG_MASTER_SB_ONLY;
for (i=0; i < max_groups; i++) {
- old_blk = rfs->old_fs->group_desc[i].bg_inode_table;
- new_blk = fs->group_desc[i].bg_inode_table;
+ old_blk = ext2_inode_table(rfs->old_fs, i);
+ new_blk = ext2_inode_table(fs, i);
diff = new_blk - old_blk;
#ifdef RESIZE2FS_DEBUG
@@ -1475,11 +1485,11 @@ static errcode_t move_itables(ext2_resiz
goto errout;
}
- for (blk = rfs->old_fs->group_desc[i].bg_inode_table, j=0;
+ for (blk = ext2_inode_table(rfs->old_fs, i), j=0;
j < fs->inode_blocks_per_group ; j++, blk++)
ext2fs_unmark_block_bitmap(fs->block_map, blk);
- rfs->old_fs->group_desc[i].bg_inode_table = new_blk;
+ ext2_inode_table_set(rfs->old_fs, i, new_blk);
ext2fs_mark_super_dirty(rfs->old_fs);
ext2fs_flush(rfs->old_fs);
@@ -1564,6 +1574,7 @@ static errcode_t ext2fs_calculate_summar
blk_t count = 0;
blk_t total_free = 0;
int group_free = 0;
+ struct ext4_group_desc *gdp;
/*
* First calculate the block statistics
@@ -1577,8 +1588,9 @@ static errcode_t ext2fs_calculate_summar
count++;
if ((count == fs->super->s_blocks_per_group) ||
(blk == EXT2_BLOCKS_COUNT(fs->super)-1)) {
- fs->group_desc[group++].bg_free_blocks_count =
- group_free;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_blocks_count = group_free;
+ group++;
count = 0;
group_free = 0;
}
@@ -1602,8 +1614,9 @@ static errcode_t ext2fs_calculate_summar
count++;
if ((count == fs->super->s_inodes_per_group) ||
(ino == fs->super->s_inodes_count)) {
- fs->group_desc[group++].bg_free_inodes_count =
- group_free;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_inodes_count = group_free;
+ group++;
count = 0;
group_free = 0;
}
Index: e2fsprogs-1.39-tyt3-v7/misc/dumpe2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/misc/dumpe2fs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/misc/dumpe2fs.c 2007-06-21 16:44:41.000000000 +0200
@@ -111,10 +111,12 @@ static void print_bg_opt(int bg_flags, i
static void print_bg_opts(ext2_filsys fs, dgrp_t i)
{
int first = 1, bg_flags;
+ struct ext4_group_desc *gdp;
- if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_LAZY_BG)
- bg_flags = fs->group_desc[i].bg_flags;
- else
+ if (fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_LAZY_BG) {
+ gdp = ext2_get_group_desc(fs, i);
+ bg_flags = gdp->bg_flags;
+ } else
bg_flags = 0;
print_bg_opt(bg_flags, EXT2_BG_INODE_UNINIT, "Inode not init",
@@ -135,6 +137,7 @@ static void list_desc (ext2_filsys fs)
char *block_bitmap=NULL, *inode_bitmap=NULL;
int inode_blocks_per_group, old_desc_blocks, reserved_gdt;
int has_super;
+ struct ext4_group_desc *gdp;
if (fs->block_map)
block_bitmap = fs->block_map->bitmap;
@@ -188,27 +191,28 @@ static void list_desc (ext2_filsys fs)
if (has_super)
fputc('\n', stdout);
fputs(_(" Block bitmap at "), stdout);
- print_number(fs->group_desc[i].bg_block_bitmap);
- diff = fs->group_desc[i].bg_block_bitmap - first_block;
+ print_number(ext2_block_bitmap(fs, i));
+ diff = ext2_block_bitmap(fs, i) - first_block;
if (diff >= 0)
printf(" (+%ld)", diff);
fputs(_(", Inode bitmap at "), stdout);
- print_number(fs->group_desc[i].bg_inode_bitmap);
- diff = fs->group_desc[i].bg_inode_bitmap - first_block;
+ print_number(ext2_inode_bitmap(fs, i));
+ diff = ext2_inode_bitmap(fs, i) - first_block;
if (diff >= 0)
printf(" (+%ld)", diff);
fputs(_("\n Inode table at "), stdout);
- print_range(fs->group_desc[i].bg_inode_table,
- fs->group_desc[i].bg_inode_table +
+ print_range(ext2_inode_table(fs, i),
+ ext2_inode_table(fs, i) +
inode_blocks_per_group - 1);
- diff = fs->group_desc[i].bg_inode_table - first_block;
+ diff = ext2_inode_table(fs, i) - first_block;
if (diff > 0)
printf(" (+%ld)", diff);
+ gdp = ext2_get_group_desc(fs, i);
printf (_("\n %d free blocks, %d free inodes, "
"%d directories\n"),
- fs->group_desc[i].bg_free_blocks_count,
- fs->group_desc[i].bg_free_inodes_count,
- fs->group_desc[i].bg_used_dirs_count);
+ gdp->bg_free_blocks_count,
+ gdp->bg_free_inodes_count,
+ gdp->bg_used_dirs_count);
if (block_bitmap) {
fputs(_(" Free blocks: "), stdout);
print_free (i, block_bitmap,
Index: e2fsprogs-1.39-tyt3-v7/e2fsck/swapfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/e2fsck/swapfs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/e2fsck/swapfs.c 2007-06-21 16:44:41.000000000 +0200
@@ -131,7 +131,7 @@ static void swap_inodes(e2fsck_t ctx)
"block interate buffer");
for (group = 0; group < fs->group_desc_count; group++) {
retval = io_channel_read_blk(fs->io,
- fs->group_desc[group].bg_inode_table,
+ ext2_inode_table(fs, group),
fs->inode_blocks_per_group, buf);
if (retval) {
com_err("swap_inodes", retval,
@@ -169,7 +169,7 @@ static void swap_inodes(e2fsck_t ctx)
ext2fs_swap_inode(fs, inode, inode, 1);
}
retval = io_channel_write_blk(fs->io,
- fs->group_desc[group].bg_inode_table,
+ ext2_inode_table(fs, group),
fs->inode_blocks_per_group, buf);
if (retval) {
com_err("swap_inodes", retval,
Index: e2fsprogs-1.39-tyt3-v7/resize/main.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/resize/main.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/resize/main.c 2007-06-21 16:44:41.000000000 +0200
@@ -106,11 +106,11 @@ static void determine_fs_stride(ext2_fil
has_sb = ext2fs_bg_has_super(fs, group);
if (group == 0 || has_sb != prev_has_sb)
goto next;
- b_stride = fs->group_desc[group].bg_block_bitmap -
- fs->group_desc[group-1].bg_block_bitmap -
+ b_stride = ext2_block_bitmap(fs, group) -
+ ext2_block_bitmap(fs, group-1) -
fs->super->s_blocks_per_group;
- i_stride = fs->group_desc[group].bg_inode_bitmap -
- fs->group_desc[group-1].bg_inode_bitmap -
+ i_stride = ext2_inode_bitmap(fs, group) -
+ ext2_inode_bitmap(fs, group-1) -
fs->super->s_blocks_per_group;
if (b_stride != i_stride ||
b_stride < 0)
Index: e2fsprogs-1.39-tyt3-v7/misc/mke2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/misc/mke2fs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/misc/mke2fs.c 2007-06-21 16:44:41.000000000 +0200
@@ -221,6 +221,7 @@ static void handle_bad_blocks(ext2_filsy
blk_t group_block;
int group;
int group_bad;
+ struct ext4_group_desc *gdp;
if (!bb_list)
return;
@@ -262,7 +263,8 @@ _("Warning: the backup superblock/group
group_block);
group_bad++;
group = ext2fs_group_of_blk(fs, group_block+j);
- fs->group_desc[group].bg_free_blocks_count++;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_blocks_count++;
EXT2_FREE_BLOCKS_COUNT_SET(fs->super, EXT2_FREE_BLOCKS_COUNT(fs->super) + 1);
}
}
@@ -406,6 +408,7 @@ static void write_inode_tables(ext2_fils
int num;
struct progress_struct progress;
int lazy_flag = 0;
+ struct ext4_group_desc *gdp;
if (quiet)
memset(&progress, 0, sizeof(progress));
@@ -420,11 +423,12 @@ static void write_inode_tables(ext2_fils
for (i = 0; i < fs->group_desc_count; i++) {
progress_update(&progress, i);
- blk = fs->group_desc[i].bg_inode_table;
+ blk = ext2_inode_table(fs, i);
num = fs->inode_blocks_per_group;
+ gdp = ext2_get_group_desc(fs, i);
if (!(lazy_flag &&
- (fs->group_desc[i].bg_flags & EXT2_BG_INODE_UNINIT))) {
+ (gdp->bg_flags & EXT2_BG_INODE_UNINIT))) {
retval = zero_blocks(fs, blk, num, 0, &blk, &num);
if (retval) {
fprintf(stderr, _("\nCould not write %d "
@@ -449,14 +453,15 @@ static void setup_lazy_bg(ext2_filsys fs
dgrp_t i;
int blks;
struct ext2_super_block *sb = fs->super;
- struct ext2_group_desc *bg = fs->group_desc;
+ struct ext4_group_desc *bg;
if (EXT2_HAS_COMPAT_FEATURE(fs->super,
EXT2_FEATURE_COMPAT_LAZY_BG)) {
- for (i = 0; i < fs->group_desc_count; i++, bg++) {
+ for (i = 0; i < fs->group_desc_count; i++) {
if ((i == 0) ||
(i == fs->group_desc_count-1))
continue;
+ bg = ext2_get_group_desc(fs, i);
if (bg->bg_free_inodes_count ==
sb->s_inodes_per_group) {
bg->bg_free_inodes_count = 0;
@@ -560,11 +565,13 @@ static void reserve_inodes(ext2_filsys f
{
ext2_ino_t i;
int group;
+ struct ext4_group_desc *gdp;
for (i = EXT2_ROOT_INO + 1; i < EXT2_FIRST_INODE(fs->super); i++) {
ext2fs_mark_inode_bitmap(fs->inode_map, i);
group = ext2fs_group_of_ino(fs, i);
- fs->group_desc[group].bg_free_inodes_count--;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_inodes_count--;
fs->super->s_free_inodes_count--;
}
ext2fs_mark_ib_dirty(fs);
@@ -687,7 +694,7 @@ static void show_stats(ext2_filsys fs)
printf(_("First data block=%u\n"), s->s_first_data_block);
if (s->s_reserved_gdt_blocks)
printf(_("Maximum filesystem blocks=%lu\n"),
- (s->s_reserved_gdt_blocks + fs->desc_blocks) *
+ (blk_t)(s->s_reserved_gdt_blocks + fs->desc_blocks) *
EXT2_DESC_PER_BLOCK(s) * s->s_blocks_per_group);
if (fs->group_desc_count > 1)
printf(_("%u block groups\n"), fs->group_desc_count);
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/inode.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/inode.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/inode.c 2007-06-21 16:44:41.000000000 +0200
@@ -142,8 +142,8 @@ errcode_t ext2fs_open_inode_scan(ext2_fi
scan->current_group = 0;
scan->groups_left = fs->group_desc_count - 1;
scan->inode_buffer_blocks = buffer_blocks ? buffer_blocks : 8;
- scan->current_block = scan->fs->
- group_desc[scan->current_group].bg_inode_table;
+ scan->current_block =
+ ext2_inode_table(scan->fs, scan->current_group);
scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super);
scan->blocks_left = scan->fs->inode_blocks_per_group;
retval = ext2fs_get_mem((size_t) (scan->inode_buffer_blocks *
@@ -221,8 +221,8 @@ static errcode_t get_next_blockgroup(ext
scan->current_group++;
scan->groups_left--;
- scan->current_block = scan->fs->
- group_desc[scan->current_group].bg_inode_table;
+ scan->current_block =
+ ext2_inode_table(scan->fs, scan->current_group);
scan->current_inode = scan->current_group *
EXT2_INODES_PER_GROUP(scan->fs->super);
@@ -386,6 +386,7 @@ errcode_t ext2fs_get_next_inode_full(ext
{
errcode_t retval;
int extra_bytes = 0;
+ struct ext4_group_desc *gdp;
EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN);
@@ -413,9 +414,9 @@ errcode_t ext2fs_get_next_inode_full(ext
* These checks are done outside the above if statement so
* they can be done for block group #0.
*/
+ gdp = ext2_get_group_desc(scan->fs, scan->current_group);
if ((scan->scan_flags & EXT2_SF_DO_LAZY) &&
- (scan->fs->group_desc[scan->current_group].bg_flags &
- EXT2_BG_INODE_UNINIT))
+ (gdp->bg_flags & EXT2_BG_INODE_UNINIT))
goto force_new_group;
if (scan->current_block == 0) {
if (scan->scan_flags & EXT2_SF_SKIP_MISSING_ITABLE) {
@@ -546,9 +547,9 @@ errcode_t ext2fs_read_inode_full(ext2_fi
offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) *
EXT2_INODE_SIZE(fs->super);
block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super);
- if (!fs->group_desc[(unsigned)group].bg_inode_table)
+ if (!ext2_inode_table(fs, group))
return EXT2_ET_MISSING_INODE_TABLE;
- block_nr = fs->group_desc[(unsigned)group].bg_inode_table +
+ block_nr = ext2_inode_table(fs, group) +
block;
io = fs->io;
}
@@ -669,11 +670,11 @@ errcode_t ext2fs_write_inode_full(ext2_f
offset = ((ino - 1) % EXT2_INODES_PER_GROUP(fs->super)) *
EXT2_INODE_SIZE(fs->super);
block = offset >> EXT2_BLOCK_SIZE_BITS(fs->super);
- if (!fs->group_desc[(unsigned) group].bg_inode_table) {
+ if (!ext2_inode_table(fs, group)) {
retval = EXT2_ET_MISSING_INODE_TABLE;
goto errout;
}
- block_nr = fs->group_desc[(unsigned) group].bg_inode_table + block;
+ block_nr = ext2_inode_table(fs, group) + block;
offset &= (EXT2_BLOCK_SIZE(fs->super) - 1);
Index: e2fsprogs-1.39-tyt3-v7/e2fsck/pass1b.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/e2fsck/pass1b.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/e2fsck/pass1b.c 2007-06-21 16:44:41.000000000 +0200
@@ -816,15 +816,15 @@ static int check_if_fs_block(e2fsck_t ct
}
/* Check the inode table */
- if ((fs->group_desc[i].bg_inode_table) &&
- (test_block >= fs->group_desc[i].bg_inode_table) &&
- (test_block < (fs->group_desc[i].bg_inode_table +
+ if (ext2_inode_table(fs, i) &&
+ (test_block >= ext2_inode_table(fs, i)) &&
+ (test_block < (ext2_inode_table(fs, i) +
fs->inode_blocks_per_group)))
return 1;
/* Check the bitmap blocks */
- if ((test_block == fs->group_desc[i].bg_block_bitmap) ||
- (test_block == fs->group_desc[i].bg_inode_bitmap))
+ if ((test_block == ext2_block_bitmap(fs, i)) ||
+ (test_block == ext2_inode_bitmap(fs, i)))
return 1;
first_block += fs->super->s_blocks_per_group;
Index: e2fsprogs-1.39-tyt3-v7/e2fsck/pass1.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/e2fsck/pass1.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/e2fsck/pass1.c 2007-06-21 16:44:41.000000000 +0200
@@ -1882,16 +1882,16 @@ static char *describe_illegal_block(ext2
"of group %d", i);
break;
}
- if (block == fs->group_desc[i].bg_block_bitmap) {
+ if (block == ext2_block_bitmap(fs, i)) {
sprintf(problem, "is the block bitmap of group %d", i);
break;
}
- if (block == fs->group_desc[i].bg_inode_bitmap) {
+ if (block == ext2_inode_bitmap(fs, i)) {
sprintf(problem, "is the inode bitmap of group %d", i);
break;
}
- if (block >= fs->group_desc[i].bg_inode_table &&
- (block < fs->group_desc[i].bg_inode_table
+ if (block >= ext2_inode_table(fs, i) &&
+ (block < ext2_inode_table(fs, i)
+ fs->inode_blocks_per_group)) {
sprintf(problem, "is in the inode table of group %d",
i);
@@ -2197,22 +2197,22 @@ static int process_bad_block(ext2_filsys
return 0;
}
skip_super:
- if (blk == fs->group_desc[i].bg_block_bitmap) {
+ if (blk == ext2_block_bitmap(fs, i)) {
if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) {
ctx->invalid_block_bitmap_flag[i]++;
ctx->invalid_bitmaps++;
}
return 0;
}
- if (blk == fs->group_desc[i].bg_inode_bitmap) {
+ if (blk == ext2_inode_bitmap(fs, i)) {
if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) {
ctx->invalid_inode_bitmap_flag[i]++;
ctx->invalid_bitmaps++;
}
return 0;
}
- if ((blk >= fs->group_desc[i].bg_inode_table) &&
- (blk < (fs->group_desc[i].bg_inode_table +
+ if ((blk >= ext2_inode_table(fs, i)) &&
+ (blk < (ext2_inode_table(fs, i) +
fs->inode_blocks_per_group))) {
/*
* If there are bad blocks in the inode table,
@@ -2318,22 +2318,28 @@ static void handle_fs_bad_blocks(e2fsck_
ext2_filsys fs = ctx->fs;
dgrp_t i;
blk_t first_block;
+ blk_t blk;
for (i = 0; i < fs->group_desc_count; i++) {
first_block = ext2fs_group_first_block(fs, i);
if (ctx->invalid_block_bitmap_flag[i]) {
+ blk = ext2_block_bitmap(fs, i);
new_table_block(ctx, first_block, i, _("block bitmap"),
- 1, &fs->group_desc[i].bg_block_bitmap);
+ 1, &blk);
+ ext2_block_bitmap_set(fs, i, blk);
}
if (ctx->invalid_inode_bitmap_flag[i]) {
+ blk = ext2_inode_bitmap(fs, i);
new_table_block(ctx, first_block, i, _("inode bitmap"),
- 1, &fs->group_desc[i].bg_inode_bitmap);
+ 1, &blk);
+ ext2_inode_bitmap_set(fs, i, blk);
}
if (ctx->invalid_inode_table_flag[i]) {
+ blk = ext2_inode_table(fs, i);
new_table_block(ctx, first_block, i, _("inode table"),
- fs->inode_blocks_per_group,
- &fs->group_desc[i].bg_inode_table);
+ fs->inode_blocks_per_group, &blk);
+ ext2_inode_table_set(fs, i, blk);
ctx->flags |= E2F_FLAG_RESTART;
}
}
@@ -2362,8 +2368,8 @@ static void mark_table_blocks(e2fsck_t c
/*
* Mark the blocks used for the inode table
*/
- if (fs->group_desc[i].bg_inode_table) {
- for (j = 0, b = fs->group_desc[i].bg_inode_table;
+ if (ext2_inode_table(fs, i)) {
+ for (j = 0, b = ext2_inode_table(fs, i);
j < fs->inode_blocks_per_group;
j++, b++) {
if (ext2fs_test_block_bitmap(ctx->block_found_map,
@@ -2384,34 +2390,34 @@ static void mark_table_blocks(e2fsck_t c
/*
* Mark block used for the block bitmap
*/
- if (fs->group_desc[i].bg_block_bitmap) {
+ if (ext2_block_bitmap(fs, i)) {
if (ext2fs_test_block_bitmap(ctx->block_found_map,
- fs->group_desc[i].bg_block_bitmap)) {
- pctx.blk = fs->group_desc[i].bg_block_bitmap;
+ ext2_block_bitmap(fs, i))) {
+ pctx.blk = ext2_block_bitmap(fs, i);
if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) {
ctx->invalid_block_bitmap_flag[i]++;
ctx->invalid_bitmaps++;
}
} else {
ext2fs_mark_block_bitmap(ctx->block_found_map,
- fs->group_desc[i].bg_block_bitmap);
+ ext2_block_bitmap(fs, i));
}
}
/*
* Mark block used for the inode bitmap
*/
- if (fs->group_desc[i].bg_inode_bitmap) {
+ if (ext2_inode_bitmap(fs, i)) {
if (ext2fs_test_block_bitmap(ctx->block_found_map,
- fs->group_desc[i].bg_inode_bitmap)) {
- pctx.blk = fs->group_desc[i].bg_inode_bitmap;
+ ext2_inode_bitmap(fs, i))) {
+ pctx.blk = ext2_inode_bitmap(fs, i);
if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) {
ctx->invalid_inode_bitmap_flag[i]++;
ctx->invalid_bitmaps++;
}
} else {
ext2fs_mark_block_bitmap(ctx->block_found_map,
- fs->group_desc[i].bg_inode_bitmap);
+ ext2_inode_bitmap(fs, i));
}
}
}
Index: e2fsprogs-1.39-tyt3-v7/e2fsck/super.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/e2fsck/super.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/e2fsck/super.c 2007-06-21 16:44:41.000000000 +0200
@@ -471,7 +471,7 @@ void check_super_block(e2fsck_t ctx)
ext2_filsys fs = ctx->fs;
blk_t first_block, last_block;
struct ext2_super_block *sb = fs->super;
- struct ext2_group_desc *gd;
+ struct ext4_group_desc *gd;
blk_t blocks_per_group = fs->super->s_blocks_per_group;
blk_t bpg_max;
int inodes_per_block;
@@ -598,40 +598,41 @@ void check_super_block(e2fsck_t ctx)
*/
first_block = sb->s_first_data_block;
- for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) {
+ for (i = 0; i < fs->group_desc_count; i++) {
pctx.group = i;
+ gd = ext2_get_group_desc(fs, i);
first_block = ext2fs_group_first_block(fs, i);
last_block = ext2fs_group_last_block(fs, i);
- if ((gd->bg_block_bitmap < first_block) ||
- (gd->bg_block_bitmap > last_block)) {
- pctx.blk = gd->bg_block_bitmap;
+ if ((ext2_block_bitmap(fs, i) < first_block) ||
+ (ext2_block_bitmap(fs, i) > last_block)) {
+ pctx.blk = ext2_block_bitmap(fs, i);
if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx))
- gd->bg_block_bitmap = 0;
+ ext2_block_bitmap_set(fs, i, 0UL);
}
- if (gd->bg_block_bitmap == 0) {
+ if (!ext2_block_bitmap(fs, i)) {
ctx->invalid_block_bitmap_flag[i]++;
ctx->invalid_bitmaps++;
}
- if ((gd->bg_inode_bitmap < first_block) ||
- (gd->bg_inode_bitmap > last_block)) {
- pctx.blk = gd->bg_inode_bitmap;
+ if ((ext2_inode_bitmap(fs, i) < first_block) ||
+ (ext2_inode_bitmap(fs, i) > last_block)) {
+ pctx.blk = ext2_inode_bitmap(fs, i);
if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx))
- gd->bg_inode_bitmap = 0;
+ ext2_inode_bitmap_set(fs, i, 0UL);
}
- if (gd->bg_inode_bitmap == 0) {
+ if (!ext2_inode_bitmap(fs, i)) {
ctx->invalid_inode_bitmap_flag[i]++;
ctx->invalid_bitmaps++;
}
- if ((gd->bg_inode_table < first_block) ||
- ((gd->bg_inode_table +
+ if ((ext2_inode_table(fs, i) < first_block) ||
+ ((ext2_inode_table(fs, i) +
fs->inode_blocks_per_group - 1) > last_block)) {
- pctx.blk = gd->bg_inode_table;
+ pctx.blk = ext2_inode_table(fs, i);
if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx))
- gd->bg_inode_table = 0;
+ ext2_inode_table_set(fs, i, 0UL);
}
- if (gd->bg_inode_table == 0) {
+ if (!ext2_inode_table(fs, i)) {
ctx->invalid_inode_table_flag[i]++;
ctx->invalid_bitmaps++;
}
Index: e2fsprogs-1.39-tyt3-v7/misc/e2image.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/misc/e2image.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/misc/e2image.c 2007-06-21 16:44:41.000000000 +0200
@@ -265,8 +265,8 @@ static void mark_table_blocks(ext2_filsy
/*
* Mark the blocks used for the inode table
*/
- if (fs->group_desc[i].bg_inode_table) {
- for (j = 0, b = fs->group_desc[i].bg_inode_table;
+ if (ext2_inode_table(fs, i)) {
+ for (j = 0, b = ext2_inode_table(fs, i);
j < (unsigned) fs->inode_blocks_per_group;
j++, b++)
ext2fs_mark_block_bitmap(meta_block_map, b);
@@ -275,17 +275,17 @@ static void mark_table_blocks(ext2_filsy
/*
* Mark block used for the block bitmap
*/
- if (fs->group_desc[i].bg_block_bitmap) {
+ if (ext2_block_bitmap(fs, i)) {
ext2fs_mark_block_bitmap(meta_block_map,
- fs->group_desc[i].bg_block_bitmap);
+ ext2_block_bitmap(fs, i));
}
/*
* Mark block used for the inode bitmap
*/
- if (fs->group_desc[i].bg_inode_bitmap) {
+ if (ext2_inode_bitmap(fs, i)) {
ext2fs_mark_block_bitmap(meta_block_map,
- fs->group_desc[i].bg_inode_bitmap);
+ ext2_inode_bitmap(fs, i));
}
}
}
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/tst_iscan.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/tst_iscan.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/tst_iscan.c 2007-06-21 16:44:41.000000000 +0200
@@ -182,7 +182,7 @@ static void check_map(void)
ext2fs_mark_block_bitmap(touched_map, test_vec[i]);
}
for (i = 0; i < test_fs->group_desc_count; i++) {
- for (j=0, blk = test_fs->group_desc[i].bg_inode_table;
+ for (j=0, blk = ext2_inode_table(test_fs, i);
j < test_fs->inode_blocks_per_group;
j++, blk++) {
if (!ext2fs_test_block_bitmap(touched_map, blk) &&
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/imager.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/imager.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/imager.c 2007-06-21 16:44:41.000000000 +0200
@@ -71,7 +71,7 @@ errcode_t ext2fs_image_inode_write(ext2_
return ENOMEM;
for (group = 0; group < fs->group_desc_count; group++) {
- blk = fs->group_desc[(unsigned)group].bg_inode_table;
+ blk = ext2_inode_table(fs, group);
if (!blk) {
retval = EXT2_ET_MISSING_INODE_TABLE;
goto errout;
@@ -145,7 +145,7 @@ errcode_t ext2fs_image_inode_read(ext2_f
return ENOMEM;
for (group = 0; group < fs->group_desc_count; group++) {
- blk = fs->group_desc[(unsigned)group].bg_inode_table;
+ blk = ext2_inode_table(fs, group);
if (!blk) {
retval = EXT2_ET_MISSING_INODE_TABLE;
goto errout;
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/ext2fs.h
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/ext2fs.h 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/ext2fs.h 2007-06-21 16:44:41.000000000 +0200
@@ -1038,7 +1038,8 @@ extern errcode_t ext2fs_copy_bitmap(ext2
extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize,
int has_header);
extern void ext2fs_swap_super(struct ext2_super_block * super);
-extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp);
+extern void ext2fs_swap_group_desc(struct ext2_super_block *super,
+ struct ext4_group_desc *gdp);
extern void ext2fs_swap_extent_header(struct ext3_extent_header *eh);
extern void ext2fs_swap_extent_index(struct ext3_extent_idx *ix);
extern void ext2fs_swap_extent(struct ext3_extent *ex);
@@ -1084,6 +1085,14 @@ extern blk_t ext2fs_group_last_block(ext
extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
struct ext2_inode *inode);
extern unsigned long ext2fs_div_ceil(unsigned long a, unsigned long b);
+extern blk_t ext2_block_bitmap(ext2_filsys fs, dgrp_t group);
+extern blk_t ext2_inode_bitmap(ext2_filsys fs, dgrp_t group);
+extern blk_t ext2_inode_table(ext2_filsys fs, dgrp_t group);
+extern void ext2_block_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk);
+extern void ext2_inode_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk);
+extern void ext2_inode_table_set(ext2_filsys fs, dgrp_t group, blk_t blk);
+extern struct ext4_group_desc *ext2_get_group_desc(ext2_filsys fs,
+ dgrp_t group);
/*
* The actual inlined functions definitions themselves...
@@ -1284,6 +1293,127 @@ _INLINE_ unsigned long ext2fs_div_ceil(u
return 0;
return ((a - 1) / b) + 1;
}
+
+/*
+ * Return the block bitmap block of a group
+ */
+_INLINE_ blk_t ext2_block_bitmap(ext2_filsys fs, dgrp_t group)
+{
+ struct ext4_group_desc *gdp;
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
+ return ((blk64_t) gdp->bg_block_bitmap_hi << 32) +
+ gdp->bg_block_bitmap;
+ } else {
+ gdp = (struct ext4_group_desc *) (fs->group_desc + group);
+ return (blk_t) (gdp->bg_block_bitmap);
+ }
+}
+
+/*
+ * Return the inode bitmap block of a group
+ */
+_INLINE_ blk_t ext2_inode_bitmap(ext2_filsys fs, dgrp_t group)
+{
+ struct ext4_group_desc *gdp;
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
+ return ((blk64_t) gdp->bg_inode_bitmap_hi << 32) +
+ gdp->bg_inode_bitmap;
+ } else {
+ gdp = (struct ext4_group_desc *) (fs->group_desc + group);
+ return (blk_t) (gdp->bg_inode_bitmap);
+ }
+}
+
+/*
+ * Return the inode table block of a group
+ */
+_INLINE_ blk_t ext2_inode_table(ext2_filsys fs, dgrp_t group)
+{
+ struct ext4_group_desc *gdp;
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
+ return ((blk64_t) gdp->bg_inode_table_hi << 32) +
+ gdp->bg_inode_table;
+ } else {
+ gdp = (struct ext4_group_desc *) (fs->group_desc + group);
+ return (blk_t) (gdp->bg_inode_table);
+ }
+}
+
+/*
+ * Set the block bitmap block of a group
+ */
+_INLINE_ void ext2_block_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk)
+{
+ struct ext4_group_desc *gdp;
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
+ gdp->bg_block_bitmap = (__u32)(blk);
+ gdp->bg_block_bitmap_hi = (__u64)(blk) >> 32;
+ } else {
+ gdp = (struct ext4_group_desc *) (fs->group_desc + group);
+ gdp->bg_block_bitmap = (__u32)(blk);
+ }
+}
+
+/*
+ * Set the inode bitmap block of a group
+ */
+_INLINE_ void ext2_inode_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk)
+{
+ struct ext4_group_desc *gdp;
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
+ gdp->bg_inode_bitmap = (__u32)(blk);
+ gdp->bg_inode_bitmap_hi = (__u64)(blk) >> 32;
+ } else {
+ gdp = (struct ext4_group_desc *) (fs->group_desc + group);
+ gdp->bg_inode_bitmap = (__u32)(blk);
+ }
+}
+
+/*
+ * Set the inode table block of a group
+ */
+_INLINE_ void ext2_inode_table_set(ext2_filsys fs, dgrp_t group, blk_t blk)
+{
+ struct ext4_group_desc *gdp;
+
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
+ gdp->bg_inode_table = (__u32)(blk);
+ gdp->bg_inode_table_hi = (__u64)(blk) >> 32;
+ } else {
+ gdp = (struct ext4_group_desc *) (fs->group_desc + group);
+ gdp->bg_inode_table = (__u32)(blk);
+ }
+}
+
+/*
+ * Return the group descriptor of a group
+ */
+_INLINE_ struct ext4_group_desc *ext2_get_group_desc(ext2_filsys fs, dgrp_t group)
+{
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT)
+ return (struct ext4_group_desc *) (fs->group_desc) + group;
+ else
+ return (struct ext4_group_desc *) (fs->group_desc + group);
+}
+
#undef _INLINE_
#endif
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/openfs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/openfs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/openfs.c 2007-06-21 16:44:41.000000000 +0200
@@ -90,6 +90,7 @@ errcode_t ext2fs_open2(const char *name,
blk_t group_block, blk;
char *dest, *cp;
struct ext2_group_desc *gdp;
+ struct ext4_group_desc *gdpe;
EXT2_CHECK_MAGIC(manager, EXT2_ET_MAGIC_IO_MANAGER);
@@ -288,9 +289,18 @@ errcode_t ext2fs_open2(const char *name,
goto cleanup;
#ifdef EXT2FS_ENABLE_SWAPFS
if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
- gdp = (struct ext2_group_desc *) dest;
- for (j=0; j < groups_per_block; j++)
- ext2fs_swap_group_desc(gdp++);
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
+ EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ gdpe = (struct ext4_group_desc *) dest;
+ for (j=0; j < groups_per_block; j++, gdpe++)
+ ext2fs_swap_group_desc(fs->super, gdpe);
+ } else {
+ gdp = (struct ext2_group_desc *) dest;
+ for (j=0; j < groups_per_block; j++, gdp++)
+ ext2fs_swap_group_desc(fs->super,
+ (struct ext4_group_desc *) gdp);
+ }
}
#endif
dest += fs->blocksize;
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/closefs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/closefs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/closefs.c 2007-06-21 16:44:41.000000000 +0200
@@ -209,7 +209,7 @@ errcode_t ext2fs_flush(ext2_filsys fs)
unsigned long fs_state;
struct ext2_super_block *super_shadow = 0;
struct ext2_group_desc *group_shadow = 0;
- struct ext2_group_desc *s, *t;
+ struct ext4_group_desc *s, *t;
char *group_ptr;
int old_desc_blocks;
@@ -234,10 +234,18 @@ errcode_t ext2fs_flush(ext2_filsys fs)
fs->desc_blocks);
/* swap the group descriptors */
- for (j=0, s=fs->group_desc, t=group_shadow;
- j < fs->group_desc_count; j++, t++, s++) {
- *t = *s;
- ext2fs_swap_group_desc(t);
+ for (j=0; j < fs->group_desc_count; j++) {
+ if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
+ EXT4_FEATURE_INCOMPAT_64BIT)
+ && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
+ s = (struct ext4_group_desc *) (fs->group_desc) + j;
+ t = (struct ext4_group_desc *) (group_shadow) + j;
+ *t = *s;
+ } else {
+ *(group_shadow +j) = *(fs->group_desc + j);
+ t = (struct ext4_group_desc *) (group_shadow +j);
+ }
+ ext2fs_swap_group_desc(fs->super, t);
}
} else {
super_shadow = fs->super;
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/alloc_stats.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/alloc_stats.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/alloc_stats.c 2007-06-21 16:44:41.000000000 +0200
@@ -18,15 +18,17 @@
void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino,
int inuse, int isdir)
{
+ struct ext4_group_desc *gdp;
int group = ext2fs_group_of_ino(fs, ino);
if (inuse > 0)
ext2fs_mark_inode_bitmap(fs->inode_map, ino);
else
ext2fs_unmark_inode_bitmap(fs->inode_map, ino);
- fs->group_desc[group].bg_free_inodes_count -= inuse;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_inodes_count -= inuse;
if (isdir)
- fs->group_desc[group].bg_used_dirs_count += inuse;
+ gdp->bg_used_dirs_count += inuse;
fs->super->s_free_inodes_count -= inuse;
ext2fs_mark_super_dirty(fs);
ext2fs_mark_ib_dirty(fs);
@@ -39,13 +41,15 @@ void ext2fs_inode_alloc_stats(ext2_filsy
void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse)
{
+ struct ext4_group_desc *gdp;
int group = ext2fs_group_of_blk(fs, blk);
if (inuse > 0)
ext2fs_mark_block_bitmap(fs->block_map, blk);
else
ext2fs_unmark_block_bitmap(fs->block_map, blk);
- fs->group_desc[group].bg_free_blocks_count -= inuse;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_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-v7/e2fsck/journal.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/e2fsck/journal.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/e2fsck/journal.c 2007-06-21 16:44:41.000000000 +0200
@@ -855,6 +855,7 @@ void e2fsck_move_ext3_journal(e2fsck_t c
errcode_t retval;
const char * const * cpp;
int group, mount_flags;
+ struct ext4_group_desc *gdp;
clear_problem_context(&pctx);
@@ -951,7 +952,8 @@ void e2fsck_move_ext3_journal(e2fsck_t c
group = ext2fs_group_of_ino(fs, ino);
ext2fs_unmark_inode_bitmap(fs->inode_map, ino);
ext2fs_mark_ib_dirty(fs);
- fs->group_desc[group].bg_free_inodes_count++;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_inodes_count++;
fs->super->s_free_inodes_count++;
return;
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/dblist.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/dblist.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/dblist.c 2007-06-21 16:44:41.000000000 +0200
@@ -31,16 +31,18 @@ errcode_t ext2fs_get_num_dirs(ext2_filsy
{
dgrp_t i;
ext2_ino_t num_dirs, max_dirs;
+ struct ext4_group_desc *gdp;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
num_dirs = 0;
max_dirs = fs->super->s_inodes_per_group;
for (i = 0; i < fs->group_desc_count; i++) {
- if (fs->group_desc[i].bg_used_dirs_count > max_dirs)
+ gdp = ext2_get_group_desc(fs, i);
+ if (gdp->bg_used_dirs_count > max_dirs)
num_dirs += max_dirs / 8;
else
- num_dirs += fs->group_desc[i].bg_used_dirs_count;
+ num_dirs += gdp->bg_used_dirs_count;
}
if (num_dirs > fs->super->s_inodes_count)
num_dirs = fs->super->s_inodes_count;
Index: e2fsprogs-1.39-tyt3-v7/lib/ext2fs/initialize.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/lib/ext2fs/initialize.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/lib/ext2fs/initialize.c 2007-06-21 16:44:41.000000000 +0200
@@ -106,6 +106,7 @@ errcode_t ext2fs_initialize(const char *
int io_flags;
char *buf;
char c;
+ struct ext4_group_desc *gdp;
if (!param || !EXT2_BLOCKS_COUNT(param))
return EXT2_ET_INVALID_ARGUMENT;
@@ -369,10 +370,11 @@ ipg_retry:
numblocks = ext2fs_reserve_super_and_bgd(fs, i, fs->block_map);
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 =
+ gdp = ext2_get_group_desc(fs, i);
+ gdp->bg_free_blocks_count = numblocks;
+ gdp->bg_free_inodes_count =
fs->super->s_inodes_per_group;
- fs->group_desc[i].bg_used_dirs_count = 0;
+ gdp->bg_used_dirs_count = 0;
}
c = (char) 255;
Index: e2fsprogs-1.39-tyt3-v7/misc/tune2fs.c
===================================================================
--- e2fsprogs-1.39-tyt3-v7.orig/misc/tune2fs.c 2007-06-21 16:39:32.000000000 +0200
+++ e2fsprogs-1.39-tyt3-v7/misc/tune2fs.c 2007-06-21 16:44:41.000000000 +0200
@@ -208,11 +208,13 @@ static int release_blocks_proc(ext2_fils
{
blk_t block;
int group;
+ struct ext4_group_desc *gdp;
block = *blocknr;
ext2fs_unmark_block_bitmap(fs->block_map,block);
group = ext2fs_group_of_blk(fs, block);
- fs->group_desc[group].bg_free_blocks_count++;
+ gdp = ext2_get_group_desc(fs, group);
+ gdp->bg_free_blocks_count++;
EXT2_FREE_BLOCKS_COUNT_SET(fs->super, EXT2_FREE_BLOCKS_COUNT(fs->super) + 1);
return 0;
}
On Jun 21, 2007 17:29 +0200, Valerie Clement wrote:
> @@ -91,6 +92,12 @@ void ext2fs_swap_group_desc(struct ext2_
> gdp->bg_flags = ext2fs_swab16(gdp->bg_flags);
> gdp->bg_itable_unused = ext2fs_swab16(gdp->bg_itable_unused);
> gdp->bg_checksum = ext2fs_swab16(gdp->bg_checksum);
> + if (EXT2_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT) &&
> + sb->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
> + gdp->bg_block_bitmap_hi = ext2fs_swab32(gdp->bg_block_bitmap_hi);
> + gdp->bg_inode_bitmap_hi = ext2fs_swab32(gdp->bg_inode_bitmap_hi);
> + gdp->bg_inode_table_hi = ext2fs_swab32(gdp->bg_inode_table_hi);
> + }
You could also use "if (EXT2_DESC_SIZE(sb) > EXT2_MIN_DESC_SIZE)" to be
cleaner.
> @@ -367,8 +369,13 @@ retry:
> + if (EXT2_HAS_INCOMPAT_FEATURE(old_fs->super,
> + EXT4_FEATURE_INCOMPAT_64BIT) &&
> + old_fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT)
> + memset(gdp, 0, sizeof(struct ext4_group_desc));
> + else
> + memset(gdp, 0, sizeof(struct ext2_group_desc));
Use "memset(gdp, 0, EXT2_DESC_SIZE(sb))"
> +extern blk_t ext2_block_bitmap(ext2_filsys fs, dgrp_t group);
> +extern blk_t ext2_inode_bitmap(ext2_filsys fs, dgrp_t group);
> +extern blk_t ext2_inode_table(ext2_filsys fs, dgrp_t group);
> +extern void ext2_block_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk);
> +extern void ext2_inode_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk);
> +extern void ext2_inode_table_set(ext2_filsys fs, dgrp_t group, blk_t blk);
> +extern struct ext4_group_desc *ext2_get_group_desc(ext2_filsys fs,
> + dgrp_t group);
Since you are adding these functions newly, why use blk_t instead of __u64
or blk64_t?
> +_INLINE_ blk_t ext2_block_bitmap(ext2_filsys fs, dgrp_t group)
> +{
> + if (EXT2_HAS_INCOMPAT_FEATURE(fs->super, EXT4_FEATURE_INCOMPAT_64BIT)
> + && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
if (EXT2_DESC_SIZE(sb) > EXT2_MIN_DESC_SIZE) {
> + gdp = (struct ext4_group_desc *) (fs->group_desc) + group;
> + return ((blk64_t) gdp->bg_block_bitmap_hi << 32) +
> + gdp->bg_block_bitmap;
This can't return a blk64_t value through the blk_t return type.
Also, this cannot work for s_desc_size != sizeof(struct ext4_group_desc).
You need to have a helper macro here which depends only on s_desc_size:
gdp = (struct ext4_group_desc *)((char *)fs->group_desc +
group * EXT2_DESC_SIZE(sb));
> +_INLINE_ blk_t ext2_inode_bitmap(ext2_filsys fs, dgrp_t group)
> +_INLINE_ blk_t ext2_inode_table(ext2_filsys fs, dgrp_t group)
> +_INLINE_ void ext2_block_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk)
> +_INLINE_ void ext2_inode_bitmap_set(ext2_filsys fs, dgrp_t group, blk_t blk)
> +_INLINE_ void ext2_inode_table_set(ext2_filsys fs, dgrp_t group, blk_t blk)
> +_INLINE_ struct ext4_group_desc *ext2_get_group_desc(ext2_filsys fs, dgrp_t group)
Same as above.
These do not need to be typecast.
> @@ -288,9 +289,18 @@ errcode_t ext2fs_open2(const char *name,
> if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
> + if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
> + EXT4_FEATURE_INCOMPAT_64BIT)
> + && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
if (EXT2_DESC_SIZE(sb) > EXT2_MIN_DESC_SIZE)
> + gdpe = (struct ext4_group_desc *) dest;
> + for (j=0; j < groups_per_block; j++, gdpe++)
> + ext2fs_swap_group_desc(fs->super, gdpe);
> + } else {
> + gdp = (struct ext2_group_desc *) dest;
> + for (j=0; j < groups_per_block; j++, gdp++)
> + ext2fs_swap_group_desc(fs->super,
> + (struct ext4_group_desc *) gdp);
> + }
In fact, anywhere that uses "sizeof(struct ext4_group_desc)" (including
array indexing or incrementing a pointer to this struct) to walk the
group descriptor table is broken if s_desc_size != 64. All such places
should be changed to use only EXT2_DESC_SIZE(sb) like:
for (i=0 ; i < fs->desc_blocks; i++) {
blk = ext2fs_descriptor_block_loc(fs, group_block, i);
retval = io_channel_read_blk(fs->io, blk, 1, dest);
if (retval)
goto cleanup;
#ifdef EXT2FS_ENABLE_SWAPFS
if (fs->flags & EXT2_FLAG_SWAP_BYTES) {
for (j = 0; j < EXT2_DESC_PER_BLOCK(sb);
j++, dest += EXT2_DESC_SIZE(sb)) {
gdp = (struct ext2_group_desc *)dest;
ext2fs_swap_group_desc(fs->super, gdp);
}
} else
#endif
dest += fs->blocksize;
}
or some equivalent that adds EXT2_DESC_SIZE(sb) to dest each loop
This will work regardless of the descriptor size. I think this can be
limited to a few places because of your changes to use accessor macros
everywhere.
> @@ -234,10 +234,18 @@ errcode_t ext2fs_flush(ext2_filsys fs)
> + for (j=0; j < fs->group_desc_count; j++) {
> + if (EXT2_HAS_INCOMPAT_FEATURE(fs->super,
> + EXT4_FEATURE_INCOMPAT_64BIT)
> + && fs->super->s_desc_size >= EXT2_MIN_DESC_SIZE_64BIT) {
> + s = (struct ext4_group_desc *) (fs->group_desc) + j;
> + t = (struct ext4_group_desc *) (group_shadow) + j;
> + *t = *s;
> + } else {
> + *(group_shadow +j) = *(fs->group_desc + j);
> + t = (struct ext4_group_desc *) (group_shadow +j);
> + }
> + ext2fs_swap_group_desc(fs->super, t);
Same as above.
Cheers, Andreas
--
Andreas Dilger
Principal Software Engineer
Cluster File Systems, Inc.