From d7cca6b06f366f998ed43346f9b6fca9e163692f Mon Sep 17 00:00:00 2001 From: Valerie Aurora Henson Date: Sun, 25 Oct 2009 21:43:47 -0400 Subject: Convert to use block group accessor functions Convert direct accesses to use the following block group accessor functions: ext2fs_block_bitmap_loc(), ext2fs_inode_bitmap_loc(), ext2fs_inode_table_loc(), ext2fs_bg_itable_unused(), ext2fs_block_bitmap_loc_set(), ext2fs_inode_bitmap_loc_set(), ext2fs_inode_table_loc_set(), ext2fs_bg_free_inodes_count(), ext2fs_ext2fs_bg_used_dirs_count(), ext2fs_bg_free_inodes_count_set(), ext2fs_bg_free_blocks_count_set(), ext2fs_bg_used_dirs_count_set() Signed-off-by: Valerie Aurora Henson Signed-off-by: Nick Dokos Signed-off-by: "Theodore Ts'o" --- debugfs/set_fields.c | 13 ++++-- e2fsck/journal.c | 2 +- e2fsck/pass1.c | 36 ++++++++-------- e2fsck/pass1b.c | 10 ++--- e2fsck/pass2.c | 4 +- e2fsck/pass5.c | 36 ++++++++-------- e2fsck/super.c | 57 ++++++++++++------------ lib/ext2fs/alloc.c | 8 ++-- lib/ext2fs/alloc_stats.c | 12 +++--- lib/ext2fs/alloc_tables.c | 34 +++++++-------- lib/ext2fs/check_desc.c | 8 ++-- lib/ext2fs/closefs.c | 2 +- lib/ext2fs/csum.c | 66 +++++++++++++++------------- lib/ext2fs/dblist.c | 4 +- lib/ext2fs/imager.c | 4 +- lib/ext2fs/initialize.c | 9 ++-- lib/ext2fs/inode.c | 22 +++++----- lib/ext2fs/mkjournal.c | 6 +-- lib/ext2fs/openfs.c | 2 +- lib/ext2fs/rw_bitmaps.c | 14 +++--- lib/ext2fs/tst_iscan.c | 2 +- misc/dumpe2fs.c | 32 +++++++------- misc/e2image.c | 12 +++--- misc/mke2fs.c | 6 +-- misc/tune2fs.c | 28 ++++++------ resize/main.c | 8 ++-- resize/online.c | 10 ++--- resize/resize2fs.c | 107 ++++++++++++++++++++++------------------------ 28 files changed, 278 insertions(+), 276 deletions(-) diff --git a/debugfs/set_fields.c b/debugfs/set_fields.c index 7ba77825..88cf411a 100644 --- a/debugfs/set_fields.c +++ b/debugfs/set_fields.c @@ -415,7 +415,10 @@ static errcode_t parse_gd_csum(struct field_set_info *info, char *arg) if (strcmp(arg, "calc") == 0) { ext2fs_group_desc_csum_set(current_fs, set_bg); - set_gd = current_fs->group_desc[set_bg]; + memcpy(&set_gd, ext2fs_group_desc(current_fs, + current_fs->group_desc, + set_bg), + sizeof(set_gd)); printf("Checksum set to 0x%04x\n", ext2fs_bg_checksum(current_fs, set_bg)); return 0; @@ -570,10 +573,14 @@ void do_set_block_group_descriptor(int argc, char *argv[]) return; } - set_gd = current_fs->group_desc[set_bg]; + memcpy(&set_gd, ext2fs_group_desc(current_fs, + current_fs->group_desc, set_bg), + sizeof(set_gd)); if (ss->func(ss, argv[3]) == 0) { - current_fs->group_desc[set_bg] = set_gd; + memcpy(ext2fs_group_desc(current_fs, + current_fs->group_desc, set_bg), + &set_gd, sizeof(set_gd)); ext2fs_mark_super_dirty(current_fs); } } diff --git a/e2fsck/journal.c b/e2fsck/journal.c index ffb1723e..57783ebb 100644 --- a/e2fsck/journal.c +++ b/e2fsck/journal.c @@ -1011,7 +1011,7 @@ void e2fsck_move_ext3_journal(e2fsck_t ctx) group = ext2fs_group_of_ino(fs, ino); ext2fs_unmark_inode_bitmap2(fs->inode_map, ino); ext2fs_mark_ib_dirty(fs); - fs->group_desc[group].bg_free_inodes_count++; + ext2fs_bg_free_inodes_count_set(fs, group, ext2fs_bg_free_inodes_count(fs, group) + 1); ext2fs_group_desc_csum_set(fs, group); fs->super->s_free_inodes_count++; return; diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index 46b155c5..567d4074 100644 --- a/e2fsck/pass1.c +++ b/e2fsck/pass1.c @@ -2023,16 +2023,16 @@ static char *describe_illegal_block(ext2_filsys fs, blk_t block) "of group %d", i); break; } - if (block == fs->group_desc[i].bg_block_bitmap) { + if (block == ext2fs_block_bitmap_loc(fs, i)) { sprintf(problem, "is the block bitmap of group %d", i); break; } - if (block == fs->group_desc[i].bg_inode_bitmap) { + if (block == ext2fs_inode_bitmap_loc(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 >= ext2fs_inode_table_loc(fs, i) && + (block < ext2fs_inode_table_loc(fs, i) + fs->inode_blocks_per_group)) { sprintf(problem, "is in the inode table of group %d", i); @@ -2322,22 +2322,22 @@ static int process_bad_block(ext2_filsys fs, return 0; } skip_super: - if (blk == fs->group_desc[i].bg_block_bitmap) { + if (blk == ext2fs_block_bitmap_loc(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 == ext2fs_inode_bitmap_loc(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 >= ext2fs_inode_table_loc(fs, i)) && + (blk < (ext2fs_inode_table_loc(fs, i) + fs->inode_blocks_per_group))) { /* * If there are bad blocks in the inode table, @@ -2520,8 +2520,8 @@ static void mark_table_blocks(e2fsck_t ctx) /* * 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 (ext2fs_inode_table_loc(fs, i)) { + for (j = 0, b = ext2fs_inode_table_loc(fs, i); j < fs->inode_blocks_per_group; j++, b++) { if (ext2fs_test_block_bitmap2(ctx->block_found_map, @@ -2543,34 +2543,34 @@ static void mark_table_blocks(e2fsck_t ctx) /* * Mark block used for the block bitmap */ - if (fs->group_desc[i].bg_block_bitmap) { + if (ext2fs_block_bitmap_loc(fs, i)) { if (ext2fs_test_block_bitmap2(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap)) { - pctx.blk = fs->group_desc[i].bg_block_bitmap; + ext2fs_block_bitmap_loc(fs, i))) { + pctx.blk = ext2fs_block_bitmap_loc(fs, i); if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { ctx->invalid_block_bitmap_flag[i]++; ctx->invalid_bitmaps++; } } else { ext2fs_mark_block_bitmap2(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap); + ext2fs_block_bitmap_loc(fs, i)); } } /* * Mark block used for the inode bitmap */ - if (fs->group_desc[i].bg_inode_bitmap) { + if (ext2fs_inode_bitmap_loc(fs, i)) { if (ext2fs_test_block_bitmap2(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap)) { - pctx.blk = fs->group_desc[i].bg_inode_bitmap; + ext2fs_inode_bitmap_loc(fs, i))) { + pctx.blk = ext2fs_inode_bitmap_loc(fs, i); if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { ctx->invalid_inode_bitmap_flag[i]++; ctx->invalid_bitmaps++; } } else { ext2fs_mark_block_bitmap2(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap); + ext2fs_inode_bitmap_loc(fs, i)); } } } diff --git a/e2fsck/pass1b.c b/e2fsck/pass1b.c index 003827da..5142367f 100644 --- a/e2fsck/pass1b.c +++ b/e2fsck/pass1b.c @@ -837,15 +837,15 @@ static int check_if_fs_block(e2fsck_t ctx, blk_t test_block) } /* 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 ((ext2fs_inode_table_loc(fs, i)) && + (test_block >= ext2fs_inode_table_loc(fs, i)) && + (test_block < (ext2fs_inode_table_loc(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 == ext2fs_block_bitmap_loc(fs, i)) || + (test_block == ext2fs_inode_bitmap_loc(fs, i))) return 1; first_block += fs->super->s_blocks_per_group; diff --git a/e2fsck/pass2.c b/e2fsck/pass2.c index cbf1457a..df969caa 100644 --- a/e2fsck/pass2.c +++ b/e2fsck/pass2.c @@ -976,7 +976,7 @@ out_htree: group = ext2fs_group_of_ino(fs, dirent->inode); first_unused_inode = group * fs->super->s_inodes_per_group + 1 + fs->super->s_inodes_per_group - - fs->group_desc[group].bg_itable_unused; + ext2fs_bg_itable_unused(fs, group); cd->pctx.group = group; /* @@ -1003,7 +1003,7 @@ out_htree: } else if (dirent->inode >= first_unused_inode) { pctx.num = dirent->inode; if (fix_problem(ctx, PR_2_INOREF_IN_UNUSED, &cd->pctx)){ - fs->group_desc[group].bg_itable_unused = 0; + ext2fs_bg_itable_unused_set(fs, group, 0); ext2fs_mark_super_dirty(fs); ctx->flags |= E2F_FLAG_RESTART_LATER; } else { diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c index ef8e1412..b22a838d 100644 --- a/e2fsck/pass5.c +++ b/e2fsck/pass5.c @@ -196,15 +196,15 @@ redo_counts: bitmap = 0; if ((i == super_blk) || - (old_desc_blk && old_desc_blocks && - (i >= old_desc_blk) && - (i < old_desc_blk + old_desc_blocks)) || - (new_desc_blk && (i == new_desc_blk)) || - (i == fs->group_desc[group].bg_block_bitmap) || - (i == fs->group_desc[group].bg_inode_bitmap) || - (i >= fs->group_desc[group].bg_inode_table && - (i < fs->group_desc[group].bg_inode_table + - fs->inode_blocks_per_group))) { + (old_desc_blk && old_desc_blocks && + (i >= old_desc_blk) && + (i < old_desc_blk + old_desc_blocks)) || + (new_desc_blk && (i == new_desc_blk)) || + (i == ext2fs_block_bitmap_loc(fs, group)) || + (i == ext2fs_inode_bitmap_loc(fs, group)) || + (i >= ext2fs_inode_table_loc(fs, group) && + (i < ext2fs_inode_table_loc(fs, group) + + fs->inode_blocks_per_group))) { bitmap = 1; actual = (actual != 0); count++; @@ -335,9 +335,9 @@ 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) { + if (free_array[i] != ext2fs_bg_free_blocks_count(fs, i)) { pctx.group = i; - pctx.blk = fs->group_desc[i].bg_free_blocks_count; + pctx.blk = ext2fs_bg_free_blocks_count(fs, i); pctx.blk2 = free_array[i]; if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP, @@ -564,27 +564,25 @@ 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) { + if (free_array[i] != ext2fs_bg_free_inodes_count(fs, i)) { pctx.group = i; - pctx.ino = fs->group_desc[i].bg_free_inodes_count; + pctx.ino = ext2fs_bg_free_inodes_count(fs, i); 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]; + ext2fs_bg_free_inodes_count_set(fs, i, 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] != ext2fs_bg_used_dirs_count(fs, i)) { pctx.group = i; - pctx.ino = fs->group_desc[i].bg_used_dirs_count; + pctx.ino = ext2fs_bg_used_dirs_count(fs, i); 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]; + ext2fs_bg_used_dirs_count_set(fs, i, dir_array[i]); ext2fs_mark_super_dirty(fs); } else ext2fs_unmark_valid(fs); diff --git a/e2fsck/super.c b/e2fsck/super.c index fbc8b8a2..4c989cc9 100644 --- a/e2fsck/super.c +++ b/e2fsck/super.c @@ -458,7 +458,6 @@ 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; problem_t problem; blk_t blocks_per_group = fs->super->s_blocks_per_group; blk_t bpg_max; @@ -587,7 +586,7 @@ void check_super_block(e2fsck_t ctx) csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super, EXT4_FEATURE_RO_COMPAT_GDT_CSUM); - 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; if (!EXT2_HAS_INCOMPAT_FEATURE(fs->super, @@ -596,43 +595,43 @@ void check_super_block(e2fsck_t ctx) 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 ((ext2fs_block_bitmap_loc(fs, i) < first_block) || + (ext2fs_block_bitmap_loc(fs, i) > last_block)) { + pctx.blk = ext2fs_block_bitmap_loc(fs, i); if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) - gd->bg_block_bitmap = 0; + ext2fs_block_bitmap_loc_set(fs, i, 0); } - if (gd->bg_block_bitmap == 0) { + if (ext2fs_block_bitmap_loc(fs, i) == 0) { 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 ((ext2fs_inode_bitmap_loc(fs, i) < first_block) || + (ext2fs_inode_bitmap_loc(fs, i) > last_block)) { + pctx.blk = ext2fs_inode_bitmap_loc(fs, i); if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) - gd->bg_inode_bitmap = 0; + ext2fs_inode_bitmap_loc_set(fs, i, 0); } - if (gd->bg_inode_bitmap == 0) { + if (ext2fs_inode_bitmap_loc(fs, i) == 0) { ctx->invalid_inode_bitmap_flag[i]++; ctx->invalid_bitmaps++; } - if ((gd->bg_inode_table < first_block) || - ((gd->bg_inode_table + + if ((ext2fs_inode_table_loc(fs, i) < first_block) || + ((ext2fs_inode_table_loc(fs, i) + fs->inode_blocks_per_group - 1) > last_block)) { - pctx.blk = gd->bg_inode_table; + pctx.blk = ext2fs_inode_table_loc(fs, i); if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) - gd->bg_inode_table = 0; + ext2fs_inode_table_loc_set(fs, i, 0); } - if (gd->bg_inode_table == 0) { + if (ext2fs_inode_table_loc(fs, i) == 0) { ctx->invalid_inode_table_flag[i]++; ctx->invalid_bitmaps++; } - free_blocks += gd->bg_free_blocks_count; - free_inodes += gd->bg_free_inodes_count; + free_blocks += ext2fs_bg_free_blocks_count(fs, i); + free_inodes += ext2fs_bg_free_inodes_count(fs, i); - if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) || - (gd->bg_free_inodes_count > sb->s_inodes_per_group) || - (gd->bg_used_dirs_count > sb->s_inodes_per_group)) + if ((ext2fs_bg_free_blocks_count(fs, i) > sb->s_blocks_per_group) || + (ext2fs_bg_free_inodes_count(fs, i) > sb->s_inodes_per_group) || + (ext2fs_bg_used_dirs_count(fs, i) > sb->s_inodes_per_group)) ext2fs_unmark_valid(fs); should_be = 0; @@ -640,7 +639,7 @@ void check_super_block(e2fsck_t ctx) if (fix_problem(ctx, PR_0_GDT_CSUM, &pctx)) { ext2fs_bg_flags_clear(fs, i, EXT2_BG_BLOCK_UNINIT); ext2fs_bg_flags_clear(fs, i, EXT2_BG_INODE_UNINIT); - gd->bg_itable_unused = 0; + ext2fs_bg_itable_unused_set(fs, i, 0); should_be = 1; } ext2fs_unmark_valid(fs); @@ -649,11 +648,11 @@ void check_super_block(e2fsck_t ctx) if (!csum_flag && (ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT) || ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT) || - gd->bg_itable_unused != 0)){ + ext2fs_bg_itable_unused(fs, i) != 0)) { if (fix_problem(ctx, PR_0_GDT_UNINIT, &pctx)) { ext2fs_bg_flags_clear(fs, i, EXT2_BG_BLOCK_UNINIT); ext2fs_bg_flags_clear(fs, i, EXT2_BG_INODE_UNINIT); - gd->bg_itable_unused = 0; + ext2fs_bg_itable_unused_set(fs, i, 0); should_be = 1; } ext2fs_unmark_valid(fs); @@ -678,11 +677,11 @@ void check_super_block(e2fsck_t ctx) } if (csum_flag && - (gd->bg_itable_unused > gd->bg_free_inodes_count || - gd->bg_itable_unused > sb->s_inodes_per_group)) { - pctx.blk = gd->bg_itable_unused; + (ext2fs_bg_itable_unused(fs, i) > ext2fs_bg_free_inodes_count(fs, i) || + ext2fs_bg_itable_unused(fs, i) > sb->s_inodes_per_group)) { + pctx.blk = ext2fs_bg_itable_unused(fs, i); if (fix_problem(ctx, PR_0_GDT_ITABLE_UNUSED, &pctx)) { - gd->bg_itable_unused = 0; + ext2fs_bg_itable_unused_set(fs, i, 0); should_be = 1; } ext2fs_unmark_valid(fs); diff --git a/lib/ext2fs/alloc.c b/lib/ext2fs/alloc.c index 932103d2..b9eefb3b 100644 --- a/lib/ext2fs/alloc.c +++ b/lib/ext2fs/alloc.c @@ -59,10 +59,10 @@ static void check_block_uninit(ext2_filsys fs, ext2fs_block_bitmap map, (blk >= old_desc_blk) && (blk < old_desc_blk + old_desc_blocks)) || (new_desc_blk && (blk == new_desc_blk)) || - (blk == fs->group_desc[group].bg_block_bitmap) || - (blk == fs->group_desc[group].bg_inode_bitmap) || - (blk >= fs->group_desc[group].bg_inode_table && - (blk < fs->group_desc[group].bg_inode_table + (blk == ext2fs_block_bitmap_loc(fs, group)) || + (blk == ext2fs_inode_bitmap_loc(fs, group)) || + (blk >= ext2fs_inode_table_loc(fs, group) && + (blk < ext2fs_inode_table_loc(fs, group) + fs->inode_blocks_per_group))) ext2fs_fast_mark_block_bitmap2(map, blk); else diff --git a/lib/ext2fs/alloc_stats.c b/lib/ext2fs/alloc_stats.c index 72293853..254da718 100644 --- a/lib/ext2fs/alloc_stats.c +++ b/lib/ext2fs/alloc_stats.c @@ -31,9 +31,9 @@ void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino, ext2fs_mark_inode_bitmap2(fs->inode_map, ino); else ext2fs_unmark_inode_bitmap2(fs->inode_map, ino); - fs->group_desc[group].bg_free_inodes_count -= inuse; + ext2fs_bg_free_inodes_count_set(fs, group, ext2fs_bg_free_inodes_count(fs, group) - inuse); if (isdir) - fs->group_desc[group].bg_used_dirs_count += inuse; + ext2fs_bg_used_dirs_count_set(fs, group, ext2fs_bg_used_dirs_count(fs, group) + inuse); /* We don't strictly need to be clearing the uninit flag if inuse < 0 * (i.e. freeing inodes) but it also means something is bad. */ @@ -41,13 +41,11 @@ void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino, if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { ext2_ino_t first_unused_inode = fs->super->s_inodes_per_group - - fs->group_desc[group].bg_itable_unused + + ext2fs_bg_itable_unused(fs, group) + group * fs->super->s_inodes_per_group + 1; if (ino >= first_unused_inode) - fs->group_desc[group].bg_itable_unused = - group * fs->super->s_inodes_per_group + - fs->super->s_inodes_per_group - ino; + ext2fs_bg_itable_unused_set(fs, group, group * fs->super->s_inodes_per_group + fs->super->s_inodes_per_group - ino); ext2fs_group_desc_csum_set(fs, group); } @@ -76,7 +74,7 @@ void ext2fs_block_alloc_stats2(ext2_filsys fs, blk64_t blk, int inuse) ext2fs_mark_block_bitmap2(fs->block_map, blk); else ext2fs_unmark_block_bitmap2(fs->block_map, blk); - fs->group_desc[group].bg_free_blocks_count -= inuse; + ext2fs_bg_free_blocks_count_set(fs, group, ext2fs_bg_free_blocks_count(fs, group) - inuse); ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT); ext2fs_group_desc_csum_set(fs, group); diff --git a/lib/ext2fs/alloc_tables.c b/lib/ext2fs/alloc_tables.c index 8141ec34..696829f0 100644 --- a/lib/ext2fs/alloc_tables.c +++ b/lib/ext2fs/alloc_tables.c @@ -122,14 +122,14 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, if (flexbg_size) { blk64_t prev_block = 0; - if (group && fs->group_desc[group-1].bg_block_bitmap) - prev_block = fs->group_desc[group-1].bg_block_bitmap; + if (group && ext2fs_block_bitmap_loc(fs, group - 1)) + prev_block = ext2fs_block_bitmap_loc(fs, group - 1); start_blk = flexbg_offset(fs, group, prev_block, bmap, 0, rem_grps, 1); last_blk = ext2fs_group_last_block(fs, last_grp); } - if (!fs->group_desc[group].bg_block_bitmap) { + if (!ext2fs_block_bitmap_loc(fs, group)) { retval = ext2fs_get_free_blocks(fs, start_blk, last_blk, 1, bmap, &new_blk); if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) @@ -138,10 +138,10 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, if (retval) return retval; ext2fs_mark_block_bitmap2(bmap, new_blk); - fs->group_desc[group].bg_block_bitmap = new_blk; + ext2fs_block_bitmap_loc_set(fs, group, new_blk); if (flexbg_size) { dgrp_t gr = ext2fs_group_of_blk(fs, new_blk); - fs->group_desc[gr].bg_free_blocks_count--; + ext2fs_bg_free_blocks_count_set(fs, gr, ext2fs_bg_free_blocks_count(fs, gr) - 1); ext2fs_free_blocks_count_add(fs->super, -1); ext2fs_bg_flags_clear(fs, gr, EXT2_BG_BLOCK_UNINIT); ext2fs_group_desc_csum_set(fs, gr); @@ -149,15 +149,15 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, } if (flexbg_size) { - blk_t prev_block = 0; - if (group && fs->group_desc[group-1].bg_inode_bitmap) - prev_block = fs->group_desc[group-1].bg_inode_bitmap; + blk64_t prev_block = 0; + if (group && ext2fs_inode_bitmap_loc(fs, group - 1)) + prev_block = ext2fs_inode_bitmap_loc(fs, group - 1); start_blk = flexbg_offset(fs, group, prev_block, bmap, flexbg_size, rem_grps, 1); last_blk = ext2fs_group_last_block(fs, last_grp); } - if (!fs->group_desc[group].bg_inode_bitmap) { + if (!ext2fs_inode_bitmap_loc(fs, group)) { retval = ext2fs_get_free_blocks(fs, start_blk, last_blk, 1, bmap, &new_blk); if (retval == EXT2_ET_BLOCK_ALLOC_FAIL) @@ -166,10 +166,10 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, if (retval) return retval; ext2fs_mark_block_bitmap2(bmap, new_blk); - fs->group_desc[group].bg_inode_bitmap = new_blk; + ext2fs_inode_bitmap_loc_set(fs, group, new_blk); if (flexbg_size) { dgrp_t gr = ext2fs_group_of_blk(fs, new_blk); - fs->group_desc[gr].bg_free_blocks_count--; + ext2fs_bg_free_blocks_count_set(fs, gr, ext2fs_bg_free_blocks_count(fs, gr) - 1); ext2fs_free_blocks_count_add(fs->super, -1); ext2fs_bg_flags_clear(fs, gr, EXT2_BG_BLOCK_UNINIT); ext2fs_group_desc_csum_set(fs, gr); @@ -180,9 +180,9 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, * Allocate the inode table */ if (flexbg_size) { - blk_t prev_block = 0; - if (group && fs->group_desc[group-1].bg_inode_table) - prev_block = fs->group_desc[group-1].bg_inode_table; + blk64_t prev_block = 0; + if (group && ext2fs_inode_table_loc(fs, group - 1)) + prev_block = ext2fs_inode_table_loc(fs, group - 1); group_blk = flexbg_offset(fs, group, prev_block, bmap, flexbg_size * 2, fs->inode_blocks_per_group * @@ -191,7 +191,7 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, last_blk = ext2fs_group_last_block(fs, last_grp); } - if (!fs->group_desc[group].bg_inode_table) { + if (!ext2fs_inode_table_loc(fs, group)) { retval = ext2fs_get_free_blocks(fs, group_blk, last_blk, fs->inode_blocks_per_group, bmap, &new_blk); @@ -203,14 +203,14 @@ errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group, ext2fs_mark_block_bitmap2(bmap, blk); if (flexbg_size) { dgrp_t gr = ext2fs_group_of_blk(fs, blk); - fs->group_desc[gr].bg_free_blocks_count--; + ext2fs_bg_free_blocks_count_set(fs, gr, ext2fs_bg_free_blocks_count(fs, gr) - 1); ext2fs_free_blocks_count_add(fs->super, -1); ext2fs_bg_flags_clear(fs, gr, EXT2_BG_BLOCK_UNINIT); ext2fs_group_desc_csum_set(fs, gr); } } - fs->group_desc[group].bg_inode_table = new_blk; + ext2fs_inode_table_loc_set(fs, group, new_blk); } ext2fs_group_desc_csum_set(fs, group); return 0; diff --git a/lib/ext2fs/check_desc.c b/lib/ext2fs/check_desc.c index 3ce38e68..321bf747 100644 --- a/lib/ext2fs/check_desc.c +++ b/lib/ext2fs/check_desc.c @@ -36,7 +36,7 @@ errcode_t ext2fs_check_desc(ext2_filsys fs) dgrp_t i; blk_t first_block = fs->super->s_first_data_block; blk_t last_block = ext2fs_blocks_count(fs->super)-1; - blk_t blk, b; + blk64_t blk, b; int j; EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS); @@ -60,7 +60,7 @@ errcode_t ext2fs_check_desc(ext2_filsys fs) /* * Check to make sure the block bitmap for group is sane */ - blk = fs->group_desc[i].bg_block_bitmap; + blk = ext2fs_block_bitmap_loc(fs, i); if (blk < first_block || blk > last_block || ext2fs_test_block_bitmap2(bmap, blk)) { retval = EXT2_ET_GDESC_BAD_BLOCK_MAP; @@ -71,7 +71,7 @@ errcode_t ext2fs_check_desc(ext2_filsys fs) /* * Check to make sure the inode bitmap for group is sane */ - blk = fs->group_desc[i].bg_inode_bitmap; + blk = ext2fs_inode_bitmap_loc(fs, i); if (blk < first_block || blk > last_block || ext2fs_test_block_bitmap2(bmap, blk)) { retval = EXT2_ET_GDESC_BAD_INODE_MAP; @@ -82,7 +82,7 @@ errcode_t ext2fs_check_desc(ext2_filsys fs) /* * Check to make sure the inode table for group is sane */ - blk = fs->group_desc[i].bg_inode_table; + blk = ext2fs_inode_table_loc(fs, i); if (blk < first_block || ((blk + fs->inode_blocks_per_group - 1) > last_block)) { retval = EXT2_ET_GDESC_BAD_INODE_TABLE; diff --git a/lib/ext2fs/closefs.c b/lib/ext2fs/closefs.c index c505f006..8b2e0966 100644 --- a/lib/ext2fs/closefs.c +++ b/lib/ext2fs/closefs.c @@ -304,7 +304,7 @@ errcode_t ext2fs_flush(ext2_filsys fs) } #else super_shadow = fs->super; - group_shadow = fs->group_desc; + group_shadow = ext2fs_group_desc(fs, fs->group_desc, 0); #endif /* diff --git a/lib/ext2fs/csum.c b/lib/ext2fs/csum.c index c2a177db..f02d676c 100644 --- a/lib/ext2fs/csum.c +++ b/lib/ext2fs/csum.c @@ -34,7 +34,7 @@ STATIC __u16 ext2fs_group_desc_csum(ext2_filsys fs, dgrp_t group) __u16 crc = 0; struct ext2_group_desc *desc; - desc = &fs->group_desc[group]; + desc = ext2fs_group_desc(fs, fs->group_desc, group); if (fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) { int offset = offsetof(struct ext2_group_desc, bg_checksum); @@ -53,7 +53,6 @@ STATIC __u16 ext2fs_group_desc_csum(ext2_filsys fs, dgrp_t group) crc = ext2fs_crc16(crc, &group, sizeof(group)); crc = ext2fs_crc16(crc, desc, offset); offset += sizeof(desc->bg_checksum); /* skip checksum */ - assert(offset == sizeof(*desc)); /* for checksum of struct ext4_group_desc do the rest...*/ if (offset < fs->super->s_desc_size) { crc = ext2fs_crc16(crc, (char *)desc + offset, @@ -68,7 +67,7 @@ int ext2fs_group_desc_csum_verify(ext2_filsys fs, dgrp_t group) { if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, EXT4_FEATURE_RO_COMPAT_GDT_CSUM) && - (fs->group_desc[group].bg_checksum != + (ext2fs_bg_checksum(fs, group) != ext2fs_group_desc_csum(fs, group))) return 0; @@ -77,10 +76,13 @@ int ext2fs_group_desc_csum_verify(ext2_filsys fs, dgrp_t group) void ext2fs_group_desc_csum_set(ext2_filsys fs, dgrp_t group) { - if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, - EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) - fs->group_desc[group].bg_checksum = - ext2fs_group_desc_csum(fs, group); + if (!EXT2_HAS_RO_COMPAT_FEATURE(fs->super, + EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) + return; + + /* ext2fs_bg_checksum_set() sets the actual checksum field but + * does not calculate the checksum itself. */ + ext2fs_bg_checksum_set(fs, group, ext2fs_group_desc_csum(fs, group)); } static __u32 find_last_inode_ingrp(ext2fs_inode_bitmap bitmap, @@ -103,7 +105,6 @@ static __u32 find_last_inode_ingrp(ext2fs_inode_bitmap bitmap, errcode_t ext2fs_set_gdt_csum(ext2_filsys fs) { struct ext2_super_block *sb = fs->super; - struct ext2_group_desc *bg = fs->group_desc; int dirty = 0; dgrp_t i; @@ -114,27 +115,31 @@ errcode_t ext2fs_set_gdt_csum(ext2_filsys fs) EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) return 0; - for (i = 0; i < fs->group_desc_count; i++, bg++) { - int old_csum = bg->bg_checksum; - int old_unused = bg->bg_itable_unused; - int old_flags = bg->bg_flags; + for (i = 0; i < fs->group_desc_count; i++) { + unsigned int old_csum = ext2fs_bg_checksum(fs, i); + int old_unused = ext2fs_bg_itable_unused(fs, i); + unsigned int old_flags = ext2fs_bg_flags(fs, i); + int old_free_inodes_count = ext2fs_bg_free_inodes_count(fs, i); - if (bg->bg_free_inodes_count == sb->s_inodes_per_group) { - bg->bg_flags |= EXT2_BG_INODE_UNINIT; - bg->bg_itable_unused = sb->s_inodes_per_group; + if (old_free_inodes_count == sb->s_inodes_per_group) { + ext2fs_bg_flags_set(fs, i, EXT2_BG_INODE_UNINIT); + ext2fs_bg_itable_unused_set(fs, i, sb->s_inodes_per_group); } else { - bg->bg_flags &= ~EXT2_BG_INODE_UNINIT; - bg->bg_itable_unused = sb->s_inodes_per_group - + int unused = + sb->s_inodes_per_group - find_last_inode_ingrp(fs->inode_map, - sb->s_inodes_per_group,i); + sb->s_inodes_per_group, i); + + ext2fs_bg_flags_clear(fs, i, EXT2_BG_INODE_UNINIT); + ext2fs_bg_itable_unused_set(fs, i, unused); } ext2fs_group_desc_csum_set(fs, i); - if (old_flags != bg->bg_flags) + if (old_flags != ext2fs_bg_flags(fs, i)) dirty = 1; - if (old_unused != bg->bg_itable_unused) + if (old_unused != ext2fs_bg_itable_unused(fs, i)) dirty = 1; - if (old_csum != bg->bg_checksum) + if (old_csum != ext2fs_bg_checksum(fs, i)) dirty = 1; } if (dirty) @@ -196,12 +201,12 @@ int main(int argc, char **argv) fs->super->s_feature_ro_compat = EXT4_FEATURE_RO_COMPAT_GDT_CSUM; for (i=0; i < fs->group_desc_count; i++) { - fs->group_desc[i].bg_block_bitmap = 124; - fs->group_desc[i].bg_inode_bitmap = 125; - fs->group_desc[i].bg_inode_table = 126; - fs->group_desc[i].bg_free_blocks_count = 31119; - fs->group_desc[i].bg_free_inodes_count = 15701; - fs->group_desc[i].bg_used_dirs_count = 2; + ext2fs_block_bitmap_loc_set(fs, i, 124); + ext2fs_inode_bitmap_loc_set(fs, i, 125); + ext2fs_inode_table_loc_set(fs, i, 126); + ext2fs_bg_free_blocks_count_set(fs, i, 31119); + ext2fs_bg_free_inodes_count_set(fs, i, 15701); + ext2fs_bg_used_dirs_count_set(fs, i, 2); ext2fs_bg_flags_zap(fs, i); }; @@ -224,7 +229,7 @@ int main(int argc, char **argv) printf("checksums for different groups shouldn't match\n"); exit(1); } - fs->group_desc[0].bg_checksum = csum1; + ext2fs_bg_checksum_set(fs, 0, csum1); csum2 = ext2fs_group_desc_csum(fs, 0); print_csum("csum_set", fs, 0); if (csum1 != csum2) { @@ -241,9 +246,10 @@ int main(int argc, char **argv) printf("checksums for different filesystems shouldn't match\n"); exit(1); } - csum1 = fs->group_desc[0].bg_checksum = ext2fs_group_desc_csum(fs, 0); + csum1 = ext2fs_group_desc_csum(fs, 0); + ext2fs_bg_checksum_set(fs, 0, csum1); print_csum("csum_new", fs, 0); - fs->group_desc[0].bg_free_blocks_count = 1; + ext2fs_bg_free_blocks_count_set(fs, 0, 1); csum2 = ext2fs_group_desc_csum(fs, 0); print_csum("csum_blk", fs, 0); if (csum1 == csum2) { diff --git a/lib/ext2fs/dblist.c b/lib/ext2fs/dblist.c index 4a80367c..300ad351 100644 --- a/lib/ext2fs/dblist.c +++ b/lib/ext2fs/dblist.c @@ -37,10 +37,10 @@ errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs) 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) + if (ext2fs_bg_used_dirs_count(fs, i) > max_dirs) num_dirs += max_dirs / 8; else - num_dirs += fs->group_desc[i].bg_used_dirs_count; + num_dirs += ext2fs_bg_used_dirs_count(fs, i); } if (num_dirs > fs->super->s_inodes_count) num_dirs = fs->super->s_inodes_count; diff --git a/lib/ext2fs/imager.c b/lib/ext2fs/imager.c index 948b1ac2..9559ebb5 100644 --- a/lib/ext2fs/imager.c +++ b/lib/ext2fs/imager.c @@ -71,7 +71,7 @@ errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags) return ENOMEM; for (group = 0; group < fs->group_desc_count; group++) { - blk = fs->group_desc[(unsigned)group].bg_inode_table; + blk = ext2fs_inode_table_loc(fs, (unsigned)group); if (!blk) { retval = EXT2_ET_MISSING_INODE_TABLE; goto errout; @@ -145,7 +145,7 @@ errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, return ENOMEM; for (group = 0; group < fs->group_desc_count; group++) { - blk = fs->group_desc[(unsigned)group].bg_inode_table; + blk = ext2fs_inode_table_loc(fs, (unsigned)group); if (!blk) { retval = EXT2_ET_MISSING_INODE_TABLE; goto errout; diff --git a/lib/ext2fs/initialize.c b/lib/ext2fs/initialize.c index 986dd285..36a35a01 100644 --- a/lib/ext2fs/initialize.c +++ b/lib/ext2fs/initialize.c @@ -410,7 +410,7 @@ ipg_retry: numblocks = super->s_inodes_per_group; if (i == 0) numblocks -= super->s_first_ino; - fs->group_desc[i].bg_itable_unused = numblocks; + ext2fs_bg_itable_unused_set(fs, i, numblocks); } numblocks = ext2fs_reserve_super_and_bgd(fs, i, fs->block_map); if (fs->super->s_log_groups_per_flex) @@ -419,10 +419,9 @@ ipg_retry: ext2fs_free_blocks_count_set(super, ext2fs_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; - fs->group_desc[i].bg_used_dirs_count = 0; + ext2fs_bg_free_blocks_count_set(fs, i, numblocks); + ext2fs_bg_free_inodes_count_set(fs, i, fs->super->s_inodes_per_group); + ext2fs_bg_used_dirs_count_set(fs, i, 0); ext2fs_group_desc_csum_set(fs, i); } diff --git a/lib/ext2fs/inode.c b/lib/ext2fs/inode.c index 6e3adbc3..1e18195a 100644 --- a/lib/ext2fs/inode.c +++ b/lib/ext2fs/inode.c @@ -33,7 +33,7 @@ struct ext2_struct_inode_scan { errcode_t magic; ext2_filsys fs; ext2_ino_t current_inode; - blk_t current_block; + blk64_t current_block; dgrp_t current_group; ext2_ino_t inodes_left; blk_t blocks_left; @@ -143,14 +143,14 @@ errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks, 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 = ext2fs_inode_table_loc(scan->fs, + scan->current_group); scan->inodes_left = EXT2_INODES_PER_GROUP(scan->fs->super); scan->blocks_left = scan->fs->inode_blocks_per_group; if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { scan->inodes_left -= - fs->group_desc[scan->current_group].bg_itable_unused; + ext2fs_bg_itable_unused(fs, scan->current_group); scan->blocks_left = (scan->inodes_left + (fs->blocksize / scan->inode_size - 1)) * @@ -233,8 +233,8 @@ static errcode_t get_next_blockgroup(ext2_inode_scan scan) scan->current_group++; scan->groups_left--; - scan->current_block =fs->group_desc[scan->current_group].bg_inode_table; - + scan->current_block = ext2fs_inode_table_loc(scan->fs, + scan->current_group); scan->current_inode = scan->current_group * EXT2_INODES_PER_GROUP(fs->super); @@ -244,7 +244,7 @@ static errcode_t get_next_blockgroup(ext2_inode_scan scan) if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) { scan->inodes_left -= - fs->group_desc[scan->current_group].bg_itable_unused; + ext2fs_bg_itable_unused(fs, scan->current_group); scan->blocks_left = (scan->inodes_left + (fs->blocksize / scan->inode_size - 1)) * @@ -569,9 +569,9 @@ errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino, 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 (!ext2fs_inode_table_loc(fs, (unsigned) group)) return EXT2_ET_MISSING_INODE_TABLE; - block_nr = fs->group_desc[(unsigned)group].bg_inode_table + + block_nr = ext2fs_inode_table_loc(fs, group) + block; io = fs->io; } @@ -688,11 +688,11 @@ errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino, 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 (!ext2fs_inode_table_loc(fs, (unsigned) group)) { retval = EXT2_ET_MISSING_INODE_TABLE; goto errout; } - block_nr = fs->group_desc[(unsigned) group].bg_inode_table + block; + block_nr = ext2fs_inode_table_loc(fs, (unsigned) group) + block; offset &= (EXT2_BLOCK_SIZE(fs->super) - 1); diff --git a/lib/ext2fs/mkjournal.c b/lib/ext2fs/mkjournal.c index 6ba11747..eff177fc 100644 --- a/lib/ext2fs/mkjournal.c +++ b/lib/ext2fs/mkjournal.c @@ -327,7 +327,7 @@ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino, if (fs->super->s_log_groups_per_flex && (group > log_flex)) { group = group & ~(log_flex - 1); while ((group < fs->group_desc_count) && - fs->group_desc[group].bg_free_blocks_count == 0) + ext2fs_bg_free_blocks_count(fs, group) == 0) group++; if (group == fs->group_desc_count) group = 0; @@ -337,8 +337,8 @@ static errcode_t write_journal_inode(ext2_filsys fs, ext2_ino_t journal_ino, end = ((group+1) < fs->group_desc_count) ? group+1 : group; group = start; for (i=start+1; i <= end; i++) - if (fs->group_desc[i].bg_free_blocks_count > - fs->group_desc[group].bg_free_blocks_count) + if (ext2fs_bg_free_blocks_count(fs, i) > + ext2fs_bg_free_blocks_count(fs, group)) group = i; es.goal = (fs->super->s_blocks_per_group * group) + diff --git a/lib/ext2fs/openfs.c b/lib/ext2fs/openfs.c index 8b246197..52f56c05 100644 --- a/lib/ext2fs/openfs.c +++ b/lib/ext2fs/openfs.c @@ -353,7 +353,7 @@ errcode_t ext2fs_open2(const char *name, const char *io_options, for (group = 0; group < fs->group_desc_count; group++) { ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT); ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT); - fs->group_desc[group].bg_itable_unused = 0; + ext2fs_bg_itable_unused_set(fs, group, 0); } ext2fs_mark_super_dirty(fs); } diff --git a/lib/ext2fs/rw_bitmaps.c b/lib/ext2fs/rw_bitmaps.c index f85473af..962678cb 100644 --- a/lib/ext2fs/rw_bitmaps.c +++ b/lib/ext2fs/rw_bitmaps.c @@ -36,7 +36,7 @@ static errcode_t write_bitmaps(ext2_filsys fs, int do_inode, int do_block) errcode_t retval; char *block_buf, *inode_buf; int csum_flag = 0; - blk_t blk; + blk64_t blk; blk64_t blk_itr = fs->super->s_first_data_block; ext2_ino_t ino_itr = 1; @@ -88,7 +88,7 @@ static errcode_t write_bitmaps(ext2_filsys fs, int do_inode, int do_block) for (j = nbits; j < fs->blocksize * 8; j++) ext2fs_set_bit(j, block_buf); } - blk = fs->group_desc[i].bg_block_bitmap; + blk = ext2fs_block_bitmap_loc(fs, i); if (blk) { retval = io_channel_write_blk64(fs->io, blk, 1, block_buf); @@ -111,7 +111,7 @@ static errcode_t write_bitmaps(ext2_filsys fs, int do_inode, int do_block) if (retval) return retval; - blk = fs->group_desc[i].bg_inode_bitmap; + blk = ext2fs_inode_bitmap_loc(fs, i); if (blk) { retval = io_channel_write_blk64(fs->io, blk, 1, inode_buf); @@ -144,9 +144,9 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block) int csum_flag = 0; int do_image = fs->flags & EXT2_FLAG_IMAGE_FILE; unsigned int cnt; - blk_t blk; + blk64_t blk; blk64_t blk_itr = fs->super->s_first_data_block; - blk_t blk_cnt; + blk64_t blk_cnt; ext2_ino_t ino_itr = 1; ext2_ino_t ino_cnt; @@ -235,7 +235,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block) for (i = 0; i < fs->group_desc_count; i++) { if (block_bitmap) { - blk = fs->group_desc[i].bg_block_bitmap; + blk = ext2fs_block_bitmap_loc(fs, i); if (csum_flag && ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT) && ext2fs_group_desc_csum_verify(fs, i)) @@ -257,7 +257,7 @@ static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block) blk_itr += block_nbytes << 3; } if (inode_bitmap) { - blk = fs->group_desc[i].bg_inode_bitmap; + blk = ext2fs_inode_bitmap_loc(fs, i); if (csum_flag && ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT) && ext2fs_group_desc_csum_verify(fs, i)) diff --git a/lib/ext2fs/tst_iscan.c b/lib/ext2fs/tst_iscan.c index 6c3abb3d..26d8da5b 100644 --- a/lib/ext2fs/tst_iscan.c +++ b/lib/ext2fs/tst_iscan.c @@ -188,7 +188,7 @@ static void check_map(void) ext2fs_mark_block_bitmap2(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 = ext2fs_inode_table_loc(test_fs, i); j < test_fs->inode_blocks_per_group; j++, blk++) { if (!ext2fs_test_block_bitmap2(touched_map, blk) && diff --git a/misc/dumpe2fs.c b/misc/dumpe2fs.c index cb9c1ab0..298dbb24 100644 --- a/misc/dumpe2fs.c +++ b/misc/dumpe2fs.c @@ -170,9 +170,9 @@ static void list_desc (ext2_filsys fs) fputs(")", stdout); print_bg_opts(fs, i); if (fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_GDT_CSUM) - printf(_(" Checksum 0x%04x, unused inodes %d\n"), - fs->group_desc[i].bg_checksum, - fs->group_desc[i].bg_itable_unused); + printf(_(" Checksum 0x%04x, unused inodes %u\n"), + ext2fs_bg_checksum(fs, i), + ext2fs_bg_itable_unused(fs, i)); has_super = ((i==0) || super_blk); if (has_super) { printf (_(" %s superblock at "), @@ -198,31 +198,31 @@ 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(ext2fs_block_bitmap_loc(fs, i)); + diff = ext2fs_block_bitmap_loc(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(ext2fs_inode_bitmap_loc(fs, i)); + diff = ext2fs_inode_bitmap_loc(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(ext2fs_inode_table_loc(fs, i), + ext2fs_inode_table_loc(fs, i) + inode_blocks_per_group - 1); - diff = fs->group_desc[i].bg_inode_table - first_block; + diff = ext2fs_inode_table_loc(fs, i) - first_block; if (diff > 0) printf(" (+%ld)", diff); printf (_("\n %u free blocks, %u free inodes, " "%u directories%s"), - fs->group_desc[i].bg_free_blocks_count, - fs->group_desc[i].bg_free_inodes_count, - fs->group_desc[i].bg_used_dirs_count, - fs->group_desc[i].bg_itable_unused ? "" : "\n"); - if (fs->group_desc[i].bg_itable_unused) + ext2fs_bg_free_blocks_count(fs, i), + ext2fs_bg_free_inodes_count(fs, i), + ext2fs_bg_used_dirs_count(fs, i), + ext2fs_bg_itable_unused(fs, i) ? "" : "\n"); + if (ext2fs_bg_itable_unused(fs, i)) printf (_(", %u unused inodes\n"), - fs->group_desc[i].bg_itable_unused); + ext2fs_bg_itable_unused(fs, i)); if (block_bitmap) { fputs(_(" Free blocks: "), stdout); ext2fs_get_block_bitmap_range2(fs->block_map, diff --git a/misc/e2image.c b/misc/e2image.c index 3802c993..0ee2b1e8 100644 --- a/misc/e2image.c +++ b/misc/e2image.c @@ -267,8 +267,8 @@ static void mark_table_blocks(ext2_filsys fs) /* * 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 (ext2fs_inode_table_loc(fs, i)) { + for (j = 0, b = ext2fs_inode_table_loc(fs, i); j < (unsigned) fs->inode_blocks_per_group; j++, b++) ext2fs_mark_block_bitmap2(meta_block_map, b); @@ -277,17 +277,17 @@ static void mark_table_blocks(ext2_filsys fs) /* * Mark block used for the block bitmap */ - if (fs->group_desc[i].bg_block_bitmap) { + if (ext2fs_block_bitmap_loc(fs, i)) { ext2fs_mark_block_bitmap2(meta_block_map, - fs->group_desc[i].bg_block_bitmap); + ext2fs_block_bitmap_loc(fs, i)); } /* * Mark block used for the inode bitmap */ - if (fs->group_desc[i].bg_inode_bitmap) { + if (ext2fs_inode_bitmap_loc(fs, i)) { ext2fs_mark_block_bitmap2(meta_block_map, - fs->group_desc[i].bg_inode_bitmap); + ext2fs_inode_bitmap_loc(fs, i)); } } } diff --git a/misc/mke2fs.c b/misc/mke2fs.c index a2e23192..4fb6dfe4 100644 --- a/misc/mke2fs.c +++ b/misc/mke2fs.c @@ -274,7 +274,7 @@ _("Warning: the backup superblock/group descriptors at block %u contain\n" group_block); group_bad++; group = ext2fs_group_of_blk(fs, group_block+j); - fs->group_desc[group].bg_free_blocks_count++; + ext2fs_bg_free_blocks_count_set(fs, group, ext2fs_bg_free_blocks_count(fs, group) + 1); ext2fs_group_desc_csum_set(fs, group); ext2fs_free_blocks_count_add(fs->super, 1); } @@ -311,13 +311,13 @@ static void write_inode_tables(ext2_filsys fs, int lazy_flag) for (i = 0; i < fs->group_desc_count; i++) { ext2fs_numeric_progress_update(fs, &progress, i); - blk = fs->group_desc[i].bg_inode_table; + blk = ext2fs_inode_table_loc(fs, i); num = fs->inode_blocks_per_group; if (lazy_flag) { ipb = fs->blocksize / EXT2_INODE_SIZE(fs->super); num = ((((fs->super->s_inodes_per_group - - fs->group_desc[i].bg_itable_unused) * + ext2fs_bg_itable_unused(fs, i)) * EXT2_INODE_SIZE(fs->super)) + EXT2_BLOCK_SIZE(fs->super) - 1) / EXT2_BLOCK_SIZE(fs->super)); diff --git a/misc/tune2fs.c b/misc/tune2fs.c index 8daf6324..df3c0cbc 100644 --- a/misc/tune2fs.c +++ b/misc/tune2fs.c @@ -261,7 +261,7 @@ static int release_blocks_proc(ext2_filsys fs, blk_t *blocknr, block = *blocknr; ext2fs_unmark_block_bitmap2(fs->block_map, block); group = ext2fs_group_of_blk(fs, block); - fs->group_desc[group].bg_free_blocks_count++; + ext2fs_bg_free_blocks_count_set(fs, group, ext2fs_bg_free_blocks_count(fs, group) + 1); ext2fs_group_desc_csum_set(fs, group); ext2fs_free_blocks_count_add(fs->super, 1); return 0; @@ -980,10 +980,10 @@ static int get_move_bitmaps(ext2_filsys fs, int new_ino_blks_per_grp, return retval; for (i = 0; i < fs->group_desc_count; i++) { - start_blk = fs->group_desc[i].bg_inode_table + + start_blk = ext2fs_inode_table_loc(fs, i) + fs->inode_blocks_per_group; - end_blk = fs->group_desc[i].bg_inode_table + + end_blk = ext2fs_inode_table_loc(fs, i) + new_ino_blks_per_grp; for (j = start_blk; j < end_blk; j++) { @@ -1019,9 +1019,9 @@ static int ext2fs_is_meta_block(ext2_filsys fs, blk_t blk) { dgrp_t group; group = ext2fs_group_of_blk(fs, blk); - if (fs->group_desc[group].bg_block_bitmap == blk) + if (ext2fs_block_bitmap_loc(fs, group) == blk) return 1; - if (fs->group_desc[group].bg_inode_bitmap == blk) + if (ext2fs_inode_bitmap_loc(fs, group) == blk) return 1; return 0; } @@ -1231,20 +1231,20 @@ static int group_desc_scan_and_fix(ext2_filsys fs, ext2fs_block_bitmap bmap) blk_t blk, new_blk; for (i = 0; i < fs->group_desc_count; i++) { - blk = fs->group_desc[i].bg_block_bitmap; + blk = ext2fs_block_bitmap_loc(fs, i); if (ext2fs_test_block_bitmap2(bmap, blk)) { new_blk = translate_block(blk); if (!new_blk) continue; - fs->group_desc[i].bg_block_bitmap = new_blk; + ext2fs_block_bitmap_loc_set(fs, i, new_blk); } - blk = fs->group_desc[i].bg_inode_bitmap; + blk = ext2fs_inode_bitmap_loc(fs, i); if (ext2fs_test_block_bitmap2(bmap, blk)) { new_blk = translate_block(blk); if (!new_blk) continue; - fs->group_desc[i].bg_inode_bitmap = new_blk; + ext2fs_inode_bitmap_loc_set(fs, i, new_blk); } } return 0; @@ -1284,7 +1284,7 @@ static int expand_inode_table(ext2_filsys fs, unsigned long new_ino_size) tmp_new_itable = new_itable; for (i = 0; i < fs->group_desc_count; i++) { - blk = fs->group_desc[i].bg_inode_table; + blk = ext2fs_inode_table_loc(fs, i); retval = io_channel_read_blk64(fs->io, blk, fs->inode_blocks_per_group, old_itable); if (retval) @@ -1345,8 +1345,8 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) count++; if ((count == fs->super->s_blocks_per_group) || (blk == ext2fs_blocks_count(fs->super)-1)) { - fs->group_desc[group++].bg_free_blocks_count = - group_free; + ext2fs_bg_free_blocks_count_set(fs, group++, + group_free); count = 0; group_free = 0; } @@ -1370,8 +1370,8 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) 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; + ext2fs_bg_free_inodes_count_set(fs, group++, + group_free); count = 0; group_free = 0; } diff --git a/resize/main.c b/resize/main.c index 1bb6ed7b..fd85d903 100644 --- a/resize/main.c +++ b/resize/main.c @@ -111,11 +111,11 @@ static void determine_fs_stride(ext2_filsys fs) 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 = ext2fs_block_bitmap_loc(fs, group) - + ext2fs_block_bitmap_loc(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 = ext2fs_inode_bitmap_loc(fs, group) - + ext2fs_inode_bitmap_loc(fs, group - 1) - fs->super->s_blocks_per_group; if (b_stride != i_stride || b_stride < 0) diff --git a/resize/online.c b/resize/online.c index 6f828a8a..d73b9f6a 100644 --- a/resize/online.c +++ b/resize/online.c @@ -133,9 +133,9 @@ errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt, 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 = ext2fs_block_bitmap_loc(new_fs, i); + input.inode_bitmap = ext2fs_inode_bitmap_loc(new_fs, i); + input.inode_table = ext2fs_inode_table_loc(new_fs, i); input.blocks_count = sb->s_blocks_per_group; if (i == new_fs->group_desc_count-1) { input.blocks_count = ext2fs_blocks_count(new_fs->super) - @@ -155,9 +155,9 @@ errcode_t online_resize_fs(ext2_filsys fs, const char *mtpt, printf("new group will reserve %d blocks\n", input.reserved_blocks); printf("new group has %d free blocks\n", - new_fs->group_desc[i].bg_free_blocks_count); + ext2fs_bg_free_blocks_count(new_fs, i), printf("new group has %d free inodes (%d blocks)\n", - new_fs->group_desc[i].bg_free_inodes_count, + ext2fs_bg_free_inodes_count(new_fs, i), new_fs->inode_blocks_per_group); printf("Adding group #%d\n", input.group); #endif diff --git a/resize/resize2fs.c b/resize/resize2fs.c index 538c7b77..abab8f34 100644 --- a/resize/resize2fs.c +++ b/resize/resize2fs.c @@ -54,15 +54,11 @@ static errcode_t fix_sb_journal_backup(ext2_filsys fs); /* * 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 IS_BLOCK_BM(fs, i, blk) ((blk) == ext2fs_block_bitmap_loc((fs),(i))) +#define IS_INODE_BM(fs, i, blk) ((blk) == ext2fs_inode_bitmap_loc((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))) - -#define IS_INODE_TB(fs, i, blk) (((blk) >= FS_INODE_TB((fs), (i))) && \ - ((blk) < (FS_INODE_TB((fs), (i)) + \ +#define IS_INODE_TB(fs, i, blk) (((blk) >= ext2fs_inode_table_loc((fs), (i))) && \ + ((blk) < (ext2fs_inode_table_loc((fs), (i)) + \ (fs)->inode_blocks_per_group))) #define META_OVERHEAD(fs) (2 + (fs)->inode_blocks_per_group) @@ -222,10 +218,10 @@ static void fix_uninit_block_bitmaps(ext2_filsys fs) (blk >= old_desc_blk) && (blk < old_desc_blk + old_desc_blocks)) || (new_desc_blk && (blk == new_desc_blk)) || - (blk == fs->group_desc[g].bg_block_bitmap) || - (blk == fs->group_desc[g].bg_inode_bitmap) || - (blk >= fs->group_desc[g].bg_inode_table && - (blk < fs->group_desc[g].bg_inode_table + (blk == ext2fs_block_bitmap_loc(fs, g)) || + (blk == ext2fs_inode_bitmap_loc(fs, g)) || + (blk >= ext2fs_inode_table_loc(fs, g) && + (blk < ext2fs_inode_table_loc(fs, g) + fs->inode_blocks_per_group))) ext2fs_fast_mark_block_bitmap2(fs->block_map, blk); else @@ -442,7 +438,8 @@ retry: for (i = fs->group_desc_count; i < old_fs->group_desc_count; i++) { free_gdp_blocks(fs, reserve_blocks, - &old_fs->group_desc[i]); + ext2fs_group_desc(old_fs, + old_fs->group_desc, i)); } retval = 0; goto errout; @@ -465,7 +462,7 @@ 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); + ext2fs_bg_free_blocks_count_set(fs, i, ext2fs_bg_free_blocks_count(fs, i) + (numblocks - old_numblocks)); ext2fs_group_desc_csum_set(fs, i); /* @@ -495,7 +492,7 @@ 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, + memset(ext2fs_group_desc(fs, fs->group_desc, i), 0, sizeof(struct ext2_group_desc)); adjblocks = 0; @@ -548,10 +545,10 @@ retry: ext2fs_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 = - fs->super->s_inodes_per_group; - fs->group_desc[i].bg_used_dirs_count = 0; + ext2fs_bg_free_blocks_count_set(fs, i, numblocks); + ext2fs_bg_free_inodes_count_set(fs, i, + fs->super->s_inodes_per_group); + ext2fs_bg_used_dirs_count_set(fs, i, 0); ext2fs_group_desc_csum_set(fs, i); retval = ext2fs_allocate_group_table(fs, i, 0); @@ -647,7 +644,7 @@ static errcode_t adjust_superblock(ext2_resize_t rfs, blk_t new_size) * Write out the new inode table */ retval = io_channel_write_blk64(fs->io, - fs->group_desc[i].bg_inode_table, + ext2fs_inode_table_loc(fs, i), fs->inode_blocks_per_group, rfs->itable_buf); if (retval) goto errout; @@ -705,7 +702,7 @@ static errcode_t mark_table_blocks(ext2_filsys fs, /* * Mark the blocks used for the inode table */ - for (j = 0, b = fs->group_desc[i].bg_inode_table; + for (j = 0, b = ext2fs_inode_table_loc(fs, i); j < (unsigned int) fs->inode_blocks_per_group; j++, b++) ext2fs_mark_block_bitmap2(bmap, b); @@ -714,13 +711,13 @@ static errcode_t mark_table_blocks(ext2_filsys fs, * Mark block used for the block bitmap */ ext2fs_mark_block_bitmap2(bmap, - fs->group_desc[i].bg_block_bitmap); + ext2fs_block_bitmap_loc(fs, i)); /* * Mark block used for the inode bitmap */ ext2fs_mark_block_bitmap2(bmap, - fs->group_desc[i].bg_inode_bitmap); + ext2fs_inode_bitmap_loc(fs, i)); } return 0; } @@ -745,13 +742,13 @@ static void mark_fs_metablock(ext2_resize_t rfs, * mark it as a block to be moved. */ if (IS_BLOCK_BM(fs, group, blk)) { - FS_BLOCK_BM(fs, group) = 0; + ext2fs_block_bitmap_loc_set(fs, group, 0); rfs->needed_blocks++; } else if (IS_INODE_BM(fs, group, blk)) { - FS_INODE_BM(fs, group) = 0; + ext2fs_inode_bitmap_loc_set(fs, group, 0); rfs->needed_blocks++; } else if (IS_INODE_TB(fs, group, blk)) { - FS_INODE_TB(fs, group) = 0; + ext2fs_inode_table_loc_set(fs, group, 0); rfs->needed_blocks++; } else if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super, EXT4_FEATURE_RO_COMPAT_GDT_CSUM) && @@ -901,23 +898,23 @@ static errcode_t blocks_to_move(ext2_resize_t rfs) 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 (ext2fs_inode_table_loc(fs, i) && + ext2fs_inode_bitmap_loc(fs, i) && + ext2fs_block_bitmap_loc(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 (ext2fs_block_bitmap_loc(fs, i)) ext2fs_mark_block_bitmap2(rfs->reserve_blocks, - fs->group_desc[i].bg_block_bitmap); - if (fs->group_desc[i].bg_inode_bitmap) + ext2fs_block_bitmap_loc(fs, i)); + if (ext2fs_inode_bitmap_loc(fs, i)) ext2fs_mark_block_bitmap2(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; + ext2fs_inode_bitmap_loc(fs, i)); + if (ext2fs_inode_table_loc(fs, i)) + for (blk = ext2fs_inode_table_loc(fs, i), j=0; j < fs->inode_blocks_per_group ; j++, blk++) ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); @@ -954,16 +951,16 @@ static errcode_t blocks_to_move(ext2_resize_t rfs) * For those structures that have changed, we need to * do bookkeepping. */ - if (FS_BLOCK_BM(old_fs, i) != - (blk = FS_BLOCK_BM(fs, i))) { + if (ext2fs_block_bitmap_loc(old_fs, i) != + (blk = ext2fs_block_bitmap_loc(fs, i))) { ext2fs_block_alloc_stats(fs, blk, +1); if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && !ext2fs_test_block_bitmap2(meta_bmap, blk)) ext2fs_mark_block_bitmap2(rfs->move_blocks, blk); } - if (FS_INODE_BM(old_fs, i) != - (blk = FS_INODE_BM(fs, i))) { + if (ext2fs_inode_bitmap_loc(old_fs, i) != + (blk = ext2fs_inode_bitmap_loc(fs, i))) { ext2fs_block_alloc_stats(fs, blk, +1); if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && !ext2fs_test_block_bitmap2(meta_bmap, blk)) @@ -978,7 +975,7 @@ static errcode_t blocks_to_move(ext2_resize_t rfs) * can't have the inode table be destroyed during the * block relocation phase. */ - if (FS_INODE_TB(fs, i) == FS_INODE_TB(old_fs, i)) + if (ext2fs_inode_table_loc(fs, i) == ext2fs_inode_table_loc(old_fs, i)) goto next_group; /* inode table not moved */ rfs->needed_blocks += fs->inode_blocks_per_group; @@ -988,7 +985,7 @@ static errcode_t blocks_to_move(ext2_resize_t rfs) * allocation bitmap, and move any blocks that might * be necessary. */ - for (blk = fs->group_desc[i].bg_inode_table, j=0; + for (blk = ext2fs_inode_table_loc(fs, i), j=0; j < fs->inode_blocks_per_group ; j++, blk++) { ext2fs_block_alloc_stats(fs, blk, +1); if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) && @@ -1001,7 +998,7 @@ static errcode_t blocks_to_move(ext2_resize_t rfs) * 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 = ext2fs_inode_table_loc(rfs->old_fs, i), j=0; j < fs->inode_blocks_per_group ; j++, blk++) ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk); @@ -1608,8 +1605,8 @@ static errcode_t move_itables(ext2_resize_t rfs) */ 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 (ext2fs_inode_table_loc(rfs->old_fs, i) != + ext2fs_inode_table_loc(fs, i)) to_move++; if (to_move == 0) @@ -1625,8 +1622,8 @@ static errcode_t move_itables(ext2_resize_t rfs) 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 = ext2fs_inode_table_loc(rfs->old_fs, i); + new_blk = ext2fs_inode_table_loc(fs, i); diff = new_blk - old_blk; #ifdef RESIZE2FS_DEBUG @@ -1679,11 +1676,11 @@ static errcode_t move_itables(ext2_resize_t rfs) goto errout; } - for (blk = rfs->old_fs->group_desc[i].bg_inode_table, j=0; + for (blk = ext2fs_inode_table_loc(rfs->old_fs, i), j=0; j < fs->inode_blocks_per_group ; j++, blk++) ext2fs_block_alloc_stats(fs, blk, -1); - rfs->old_fs->group_desc[i].bg_inode_table = new_blk; + ext2fs_inode_table_loc_set(rfs->old_fs, i, new_blk); ext2fs_group_desc_csum_set(rfs->old_fs, i); ext2fs_mark_super_dirty(rfs->old_fs); ext2fs_flush(rfs->old_fs); @@ -1807,10 +1804,10 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) (blk >= old_desc_blk) && (blk < old_desc_blk + old_desc_blocks))) || ((new_desc_blk && (blk == new_desc_blk))) || - (blk == fs->group_desc[group].bg_block_bitmap) || - (blk == fs->group_desc[group].bg_inode_bitmap) || - ((blk >= fs->group_desc[group].bg_inode_table && - (blk < fs->group_desc[group].bg_inode_table + (blk == ext2fs_block_bitmap_loc(fs, group)) || + (blk == ext2fs_inode_bitmap_loc(fs, group)) || + ((blk >= ext2fs_inode_table_loc(fs, group) && + (blk < ext2fs_inode_table_loc(fs, group) + fs->inode_blocks_per_group))))) || (!ext2fs_fast_test_block_bitmap2(fs->block_map, blk))) { group_free++; @@ -1819,8 +1816,7 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) count++; if ((count == fs->super->s_blocks_per_group) || (blk == ext2fs_blocks_count(fs->super)-1)) { - fs->group_desc[group].bg_free_blocks_count = - group_free; + ext2fs_bg_free_blocks_count_set(fs, group, group_free); ext2fs_group_desc_csum_set(fs, group); group++; count = 0; @@ -1859,8 +1855,7 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs) 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; + ext2fs_bg_free_inodes_count_set(fs, group, group_free); ext2fs_group_desc_csum_set(fs, group); group++; count = 0; -- cgit v1.2.3