vitalif
/
e2fsprogs
mirror of https://github.com/vitalif/e2fsprogs
1
0
Fork 0
Code Issues Releases Wiki Activity

resize2fs: Move everything to new bitmap interface 

Signed-off-by: Valerie Aurora Henson <vaurora@redhat.com>
Signed-off-by: "Theodore Ts'o" <tytso@mit.edu>
bitmap-optimize
Valerie Aurora Henson 2009-08-22 21:13:37 -04:00 committed by Theodore Ts'o
parent 3c041a514c
commit 3346084bea
1 changed files with 41 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
resize/resize2fs.c
View File

@ -73,7 +73,7 @@ static errcode_t fix_sb_journal_backup(ext2_filsys fs);
* This is the top-level routine which does the dirty deed.... * This is the top-level routine which does the dirty deed....
*/ */
errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags, errcode_t resize_fs(ext2_filsys fs, blk_t *new_size, int flags,
errcode_t (*progress)(ext2_resize_t rfs, int pass, errcode_t (*progress)(ext2_resize_t rfs, int pass,
unsigned long cur, unsigned long cur,
unsigned long max_val)) unsigned long max_val))
{ {
@ -227,9 +227,9 @@ static void fix_uninit_block_bitmaps(ext2_filsys fs)
(blk >= fs->group_desc[g].bg_inode_table && (blk >= fs->group_desc[g].bg_inode_table &&
(blk < fs->group_desc[g].bg_inode_table (blk < fs->group_desc[g].bg_inode_table
+ fs->inode_blocks_per_group))) + fs->inode_blocks_per_group)))
ext2fs_fast_mark_block_bitmap(fs->block_map, blk); ext2fs_fast_mark_block_bitmap2(fs->block_map, blk);
else else
ext2fs_fast_unmark_block_bitmap(fs->block_map, blk); ext2fs_fast_unmark_block_bitmap2(fs->block_map, blk);
} }
} }
} }
@ -260,14 +260,14 @@ static void free_gdp_blocks(ext2_filsys fs,
if (gdp->bg_block_bitmap && if (gdp->bg_block_bitmap &&
(gdp->bg_block_bitmap < fs->super->s_blocks_count)) { (gdp->bg_block_bitmap < fs->super->s_blocks_count)) {
ext2fs_block_alloc_stats(fs, gdp->bg_block_bitmap, -1); ext2fs_block_alloc_stats(fs, gdp->bg_block_bitmap, -1);
ext2fs_mark_block_bitmap(reserve_blocks, ext2fs_mark_block_bitmap2(reserve_blocks,
gdp->bg_block_bitmap); gdp->bg_block_bitmap);
} }
if (gdp->bg_inode_bitmap && if (gdp->bg_inode_bitmap &&
(gdp->bg_inode_bitmap < fs->super->s_blocks_count)) { (gdp->bg_inode_bitmap < fs->super->s_blocks_count)) {
ext2fs_block_alloc_stats(fs, gdp->bg_inode_bitmap, -1); ext2fs_block_alloc_stats(fs, gdp->bg_inode_bitmap, -1);
ext2fs_mark_block_bitmap(reserve_blocks, ext2fs_mark_block_bitmap2(reserve_blocks,
gdp->bg_inode_bitmap); gdp->bg_inode_bitmap);
} }
@ -280,7 +280,7 @@ static void free_gdp_blocks(ext2_filsys fs,
if (blk >= fs->super->s_blocks_count) if (blk >= fs->super->s_blocks_count)
break; break;
ext2fs_block_alloc_stats(fs, blk, -1); ext2fs_block_alloc_stats(fs, blk, -1);
ext2fs_mark_block_bitmap(reserve_blocks, blk); ext2fs_mark_block_bitmap2(reserve_blocks, blk);
} }
} }
@ -376,7 +376,7 @@ retry:
/* /*
* Adjust the bitmaps for size * Adjust the bitmaps for size
*/ */
retval = ext2fs_resize_inode_bitmap(fs->super->s_inodes_count, retval = ext2fs_resize_inode_bitmap2(fs->super->s_inodes_count,
fs->super->s_inodes_count, fs->super->s_inodes_count,
fs->inode_map); fs->inode_map);
if (retval) goto errout; if (retval) goto errout;
@ -384,7 +384,7 @@ retry:
real_end = ((EXT2_BLOCKS_PER_GROUP(fs->super) real_end = ((EXT2_BLOCKS_PER_GROUP(fs->super)
* fs->group_desc_count)) - 1 + * fs->group_desc_count)) - 1 +
fs->super->s_first_data_block; fs->super->s_first_data_block;
retval = ext2fs_resize_block_bitmap(fs->super->s_blocks_count-1, retval = ext2fs_resize_block_bitmap2(fs->super->s_blocks_count-1,
real_end, fs->block_map); real_end, fs->block_map);
if (retval) goto errout; if (retval) goto errout;
@ -704,18 +704,18 @@ static errcode_t mark_table_blocks(ext2_filsys fs,
for (j = 0, b = fs->group_desc[i].bg_inode_table; for (j = 0, b = fs->group_desc[i].bg_inode_table;
j < (unsigned int) fs->inode_blocks_per_group; j < (unsigned int) fs->inode_blocks_per_group;
j++, b++) j++, b++)
ext2fs_mark_block_bitmap(bmap, b); ext2fs_mark_block_bitmap2(bmap, b);
/* /*
* Mark block used for the block bitmap * Mark block used for the block bitmap
*/ */
ext2fs_mark_block_bitmap(bmap, ext2fs_mark_block_bitmap2(bmap,
fs->group_desc[i].bg_block_bitmap); fs->group_desc[i].bg_block_bitmap);
/* /*
* Mark block used for the inode bitmap * Mark block used for the inode bitmap
*/ */
ext2fs_mark_block_bitmap(bmap, ext2fs_mark_block_bitmap2(bmap,
fs->group_desc[i].bg_inode_bitmap); fs->group_desc[i].bg_inode_bitmap);
} }
return 0; return 0;
@ -732,7 +732,7 @@ static void mark_fs_metablock(ext2_resize_t rfs,
{ {
ext2_filsys fs = rfs->new_fs; ext2_filsys fs = rfs->new_fs;
ext2fs_mark_block_bitmap(rfs->reserve_blocks, blk); ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk);
ext2fs_block_alloc_stats(fs, blk, +1); ext2fs_block_alloc_stats(fs, blk, +1);
/* /*
@ -757,9 +757,9 @@ static void mark_fs_metablock(ext2_resize_t rfs,
* nothing other than standard metadata in use. * nothing other than standard metadata in use.
*/ */
return; return;
} else if (ext2fs_test_block_bitmap(rfs->old_fs->block_map, blk) && } else if (ext2fs_test_block_bitmap2(rfs->old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) { !ext2fs_test_block_bitmap2(meta_bmap, blk)) {
ext2fs_mark_block_bitmap(rfs->move_blocks, blk); ext2fs_mark_block_bitmap2(rfs->move_blocks, blk);
rfs->needed_blocks++; rfs->needed_blocks++;
} }
} }
@ -821,12 +821,12 @@ static errcode_t blocks_to_move(ext2_resize_t rfs)
fs->super->s_first_data_block - 1; fs->super->s_first_data_block - 1;
continue; continue;
} }
if (ext2fs_test_block_bitmap(old_fs->block_map, blk) && if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) { !ext2fs_test_block_bitmap2(meta_bmap, blk)) {
ext2fs_mark_block_bitmap(rfs->move_blocks, blk); ext2fs_mark_block_bitmap2(rfs->move_blocks, blk);
rfs->needed_blocks++; rfs->needed_blocks++;
} }
ext2fs_mark_block_bitmap(rfs->reserve_blocks, blk); ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk);
} }
if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) { if (fs->super->s_feature_incompat & EXT2_FEATURE_INCOMPAT_META_BG) {
@ -907,15 +907,15 @@ static errcode_t blocks_to_move(ext2_resize_t rfs)
* aren't to be moved. * aren't to be moved.
*/ */
if (fs->group_desc[i].bg_block_bitmap) if (fs->group_desc[i].bg_block_bitmap)
ext2fs_mark_block_bitmap(rfs->reserve_blocks, ext2fs_mark_block_bitmap2(rfs->reserve_blocks,
fs->group_desc[i].bg_block_bitmap); fs->group_desc[i].bg_block_bitmap);
if (fs->group_desc[i].bg_inode_bitmap) if (fs->group_desc[i].bg_inode_bitmap)
ext2fs_mark_block_bitmap(rfs->reserve_blocks, ext2fs_mark_block_bitmap2(rfs->reserve_blocks,
fs->group_desc[i].bg_inode_bitmap); fs->group_desc[i].bg_inode_bitmap);
if (fs->group_desc[i].bg_inode_table) if (fs->group_desc[i].bg_inode_table)
for (blk = fs->group_desc[i].bg_inode_table, j=0; for (blk = fs->group_desc[i].bg_inode_table, j=0;
j < fs->inode_blocks_per_group ; j++, blk++) j < fs->inode_blocks_per_group ; j++, blk++)
ext2fs_mark_block_bitmap(rfs->reserve_blocks, ext2fs_mark_block_bitmap2(rfs->reserve_blocks,
blk); blk);
/* /*
@ -953,17 +953,17 @@ static errcode_t blocks_to_move(ext2_resize_t rfs)
if (FS_BLOCK_BM(old_fs, i) != if (FS_BLOCK_BM(old_fs, i) !=
(blk = FS_BLOCK_BM(fs, i))) { (blk = FS_BLOCK_BM(fs, i))) {
ext2fs_block_alloc_stats(fs, blk, +1); ext2fs_block_alloc_stats(fs, blk, +1);
if (ext2fs_test_block_bitmap(old_fs->block_map, blk) && if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) !ext2fs_test_block_bitmap2(meta_bmap, blk))
ext2fs_mark_block_bitmap(rfs->move_blocks, ext2fs_mark_block_bitmap2(rfs->move_blocks,
blk); blk);
} }
if (FS_INODE_BM(old_fs, i) != if (FS_INODE_BM(old_fs, i) !=
(blk = FS_INODE_BM(fs, i))) { (blk = FS_INODE_BM(fs, i))) {
ext2fs_block_alloc_stats(fs, blk, +1); ext2fs_block_alloc_stats(fs, blk, +1);
if (ext2fs_test_block_bitmap(old_fs->block_map, blk) && if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) !ext2fs_test_block_bitmap2(meta_bmap, blk))
ext2fs_mark_block_bitmap(rfs->move_blocks, ext2fs_mark_block_bitmap2(rfs->move_blocks,
blk); blk);
} }
@ -987,9 +987,9 @@ static errcode_t blocks_to_move(ext2_resize_t rfs)
for (blk = fs->group_desc[i].bg_inode_table, j=0; for (blk = fs->group_desc[i].bg_inode_table, j=0;
j < fs->inode_blocks_per_group ; j++, blk++) { j < fs->inode_blocks_per_group ; j++, blk++) {
ext2fs_block_alloc_stats(fs, blk, +1); ext2fs_block_alloc_stats(fs, blk, +1);
if (ext2fs_test_block_bitmap(old_fs->block_map, blk) && if (ext2fs_test_block_bitmap2(old_fs->block_map, blk) &&
!ext2fs_test_block_bitmap(meta_bmap, blk)) !ext2fs_test_block_bitmap2(meta_bmap, blk))
ext2fs_mark_block_bitmap(rfs->move_blocks, ext2fs_mark_block_bitmap2(rfs->move_blocks,
blk); blk);
} }
@ -999,7 +999,7 @@ static errcode_t blocks_to_move(ext2_resize_t rfs)
*/ */
for (blk = rfs->old_fs->group_desc[i].bg_inode_table, j=0; for (blk = rfs->old_fs->group_desc[i].bg_inode_table, j=0;
j < fs->inode_blocks_per_group ; j++, blk++) j < fs->inode_blocks_per_group ; j++, blk++)
ext2fs_mark_block_bitmap(rfs->reserve_blocks, blk); ext2fs_mark_block_bitmap2(rfs->reserve_blocks, blk);
next_group: next_group:
group_blk += rfs->new_fs->super->s_blocks_per_group; group_blk += rfs->new_fs->super->s_blocks_per_group;
@ -1060,12 +1060,12 @@ static blk_t get_new_block(ext2_resize_t rfs)
rfs->new_blk = fs->super->s_first_data_block; rfs->new_blk = fs->super->s_first_data_block;
continue; continue;
} }
if (ext2fs_test_block_bitmap(fs->block_map, rfs->new_blk) || if (ext2fs_test_block_bitmap2(fs->block_map, rfs->new_blk) ||
ext2fs_test_block_bitmap(rfs->reserve_blocks, ext2fs_test_block_bitmap2(rfs->reserve_blocks,
rfs->new_blk) || rfs->new_blk) ||
((rfs->alloc_state == AVOID_OLD) && ((rfs->alloc_state == AVOID_OLD) &&
(rfs->new_blk < rfs->old_fs->super->s_blocks_count) && (rfs->new_blk < rfs->old_fs->super->s_blocks_count) &&
ext2fs_test_block_bitmap(rfs->old_fs->block_map, ext2fs_test_block_bitmap2(rfs->old_fs->block_map,
rfs->new_blk))) { rfs->new_blk))) {
rfs->new_blk++; rfs->new_blk++;
continue; continue;
@ -1089,8 +1089,8 @@ static errcode_t resize2fs_get_alloc_block(ext2_filsys fs, blk64_t goal,
printf("get_alloc_block allocating %u\n", blk); printf("get_alloc_block allocating %u\n", blk);
#endif #endif
ext2fs_mark_block_bitmap(rfs->old_fs->block_map, blk); ext2fs_mark_block_bitmap2(rfs->old_fs->block_map, blk);
ext2fs_mark_block_bitmap(rfs->new_fs->block_map, blk); ext2fs_mark_block_bitmap2(rfs->new_fs->block_map, blk);
*ret = (blk64_t) blk; *ret = (blk64_t) blk;
return 0; return 0;
} }
@ -1133,9 +1133,9 @@ static errcode_t block_mover(ext2_resize_t rfs)
init_block_alloc(rfs); init_block_alloc(rfs);
for (blk = old_fs->super->s_first_data_block; for (blk = old_fs->super->s_first_data_block;
blk < old_fs->super->s_blocks_count; blk++) { blk < old_fs->super->s_blocks_count; blk++) {
if (!ext2fs_test_block_bitmap(old_fs->block_map, blk)) if (!ext2fs_test_block_bitmap2(old_fs->block_map, blk))
continue; continue;
if (!ext2fs_test_block_bitmap(rfs->move_blocks, blk)) if (!ext2fs_test_block_bitmap2(rfs->move_blocks, blk))
continue; continue;
if (ext2fs_badblocks_list_test(badblock_list, blk)) { if (ext2fs_badblocks_list_test(badblock_list, blk)) {
ext2fs_badblocks_list_del(badblock_list, blk); ext2fs_badblocks_list_del(badblock_list, blk);
@ -1808,7 +1808,7 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs)
((blk >= fs->group_desc[group].bg_inode_table && ((blk >= fs->group_desc[group].bg_inode_table &&
(blk < fs->group_desc[group].bg_inode_table (blk < fs->group_desc[group].bg_inode_table
+ fs->inode_blocks_per_group))))) || + fs->inode_blocks_per_group))))) ||
(!ext2fs_fast_test_block_bitmap(fs->block_map, blk))) { (!ext2fs_fast_test_block_bitmap2(fs->block_map, blk))) {
group_free++; group_free++;
total_free++; total_free++;
} }
@ -1848,7 +1848,7 @@ static errcode_t ext2fs_calculate_summary_stats(ext2_filsys fs)
uninit = fs->group_desc[group].bg_flags & EXT2_BG_INODE_UNINIT; uninit = fs->group_desc[group].bg_flags & EXT2_BG_INODE_UNINIT;
for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) { for (ino = 1; ino <= fs->super->s_inodes_count && ino > 0; ino++) {
if (uninit || if (uninit ||
!ext2fs_fast_test_inode_bitmap(fs->inode_map, ino)) { !ext2fs_fast_test_inode_bitmap2(fs->inode_map, ino)) {
group_free++; group_free++;
total_free++; total_free++;
} }