void do_testb(int argc, char *argv[])
{
unsigned int block, num;
int err;
int test_result;
if (check_fs_open(argv[0]))
return;
if (argc != 2 && argc != 3) {
com_err(argv[0], 0, "Usage: testb <block> [num]");
return;
}
block = parse_ulong(argv[1], argv[0], "block", &err);
if (err)
return;
if (argc == 3) {
num = parse_ulong(argv[2], argv[0], "num", &err);
if (err)
return;
test_result =
ext2fs_test_block_bitmap_range2(test_fs->block_map,
block, num);
printf("Blocks %u to %u are %sall clear.\n",
block, block + num - 1, test_result ? "" : "NOT ");
return;
}
test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
printf("Block %u is %s\n", block, test_result ? "set" : "clear");
}
/*
* This routine searches for free blocks that can allocate a full
* group of bitmaps or inode tables for a flexbg group. Returns the
* block number with a correct offset were the bitmaps and inode
* tables can be allocated continously and in order.
*/
static blk64_t flexbg_offset(ext2_filsys fs, dgrp_t group, blk64_t start_blk,
ext2fs_block_bitmap bmap, int rem_grp,
int elem_size)
{
int flexbg, flexbg_size, size;
blk64_t last_blk, first_free = 0;
dgrp_t last_grp;
flexbg_size = 1 << fs->super->s_log_groups_per_flex;
flexbg = group / flexbg_size;
size = rem_grp * elem_size;
if (size > (int) (fs->super->s_blocks_per_group / 8))
size = (int) fs->super->s_blocks_per_group / 8;
/*
* Don't do a long search if the previous block
* search is still valid.
*/
if (start_blk && ext2fs_test_block_bitmap_range2(bmap, start_blk,
elem_size))
return start_blk;
start_blk = ext2fs_group_first_block2(fs, flexbg_size * flexbg);
last_grp = group | (flexbg_size - 1);
if (last_grp > fs->group_desc_count-1)
last_grp = fs->group_desc_count-1;
last_blk = ext2fs_group_last_block2(fs, last_grp);
/* Find the first available block */
if (ext2fs_get_free_blocks2(fs, start_blk, last_blk, size,
bmap, &first_free) == 0)
return first_free;
if (ext2fs_get_free_blocks2(fs, start_blk, last_blk, elem_size,
bmap, &first_free) == 0)
return first_free;
if (ext2fs_get_free_blocks2(fs, 0, last_blk, elem_size, bmap,
&first_free) == 0)
return first_free;
return first_free;
}
static void check_block_bitmaps(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
blk64_t i;
unsigned int *free_array;
int group = 0;
unsigned int blocks = 0;
blk64_t free_blocks = 0;
blk64_t first_free = ext2fs_blocks_count(fs->super);
unsigned int group_free = 0;
int actual, bitmap;
struct problem_context pctx;
int problem, save_problem, fixit, had_problem;
errcode_t retval;
int csum_flag;
int skip_group = 0;
int old_desc_blocks = 0;
int count = 0;
int cmp_block = 0;
int redo_flag = 0;
blk64_t super_blk, old_desc_blk, new_desc_blk;
clear_problem_context(&pctx);
free_array = (unsigned int *) e2fsck_allocate_memory(ctx,
fs->group_desc_count * sizeof(unsigned int), "free block count array");
if ((B2C(fs->super->s_first_data_block) <
ext2fs_get_block_bitmap_start2(ctx->block_found_map)) ||
(B2C(ext2fs_blocks_count(fs->super)-1) >
ext2fs_get_block_bitmap_end2(ctx->block_found_map))) {
pctx.num = 1;
pctx.blk = B2C(fs->super->s_first_data_block);
pctx.blk2 = B2C(ext2fs_blocks_count(fs->super) - 1);
pctx.ino = ext2fs_get_block_bitmap_start2(ctx->block_found_map);
pctx.ino2 = ext2fs_get_block_bitmap_end2(ctx->block_found_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
goto errout;
}
if ((B2C(fs->super->s_first_data_block) <
ext2fs_get_block_bitmap_start2(fs->block_map)) ||
(B2C(ext2fs_blocks_count(fs->super)-1) >
ext2fs_get_block_bitmap_end2(fs->block_map))) {
pctx.num = 2;
pctx.blk = B2C(fs->super->s_first_data_block);
pctx.blk2 = B2C(ext2fs_blocks_count(fs->super) - 1);
pctx.ino = ext2fs_get_block_bitmap_start2(fs->block_map);
pctx.ino2 = ext2fs_get_block_bitmap_end2(fs->block_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
goto errout;
}
csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
redo_counts:
had_problem = 0;
save_problem = 0;
pctx.blk = pctx.blk2 = NO_BLK;
if (csum_flag &&
(ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
skip_group++;
for (i = B2C(fs->super->s_first_data_block);
i < ext2fs_blocks_count(fs->super);
i += EXT2FS_CLUSTER_RATIO(fs)) {
actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i);
if (skip_group) {
if ((B2C(i) - B2C(fs->super->s_first_data_block)) %
fs->super->s_clusters_per_group == 0) {
super_blk = 0;
old_desc_blk = 0;
new_desc_blk = 0;
ext2fs_super_and_bgd_loc2(fs, group, &super_blk,
&old_desc_blk, &new_desc_blk, 0);
if (fs->super->s_feature_incompat &
EXT2_FEATURE_INCOMPAT_META_BG)
old_desc_blocks =
fs->super->s_first_meta_bg;
else
old_desc_blocks = fs->desc_blocks +
fs->super->s_reserved_gdt_blocks;
count = 0;
cmp_block = fs->super->s_clusters_per_group;
if (group == (int)fs->group_desc_count - 1)
cmp_block = EXT2FS_NUM_B2C(fs,
ext2fs_group_blocks_count(fs, group));
}
bitmap = 0;
if (EQ_CLSTR(i, super_blk) ||
(old_desc_blk && old_desc_blocks &&
GE_CLSTR(i, old_desc_blk) &&
LE_CLSTR(i, old_desc_blk + old_desc_blocks-1)) ||
(new_desc_blk && EQ_CLSTR(i, new_desc_blk)) ||
EQ_CLSTR(i, ext2fs_block_bitmap_loc(fs, group)) ||
EQ_CLSTR(i, ext2fs_inode_bitmap_loc(fs, group)) ||
(GE_CLSTR(i, ext2fs_inode_table_loc(fs, group)) &&
LE_CLSTR(i, (ext2fs_inode_table_loc(fs, group) +
fs->inode_blocks_per_group - 1)))) {
bitmap = 1;
actual = (actual != 0);
count++;
cmp_block--;
} else if ((EXT2FS_B2C(fs, i) - count -
EXT2FS_B2C(fs, fs->super->s_first_data_block)) %
fs->super->s_clusters_per_group == 0) {
/*
* When the compare data blocks in block bitmap
* are 0, count the free block,
* skip the current block group.
*/
if (ext2fs_test_block_bitmap_range2(
ctx->block_found_map,
EXT2FS_B2C(fs, i),
cmp_block)) {
/*
* -1 means to skip the current block
* group.
*/
blocks = fs->super->s_clusters_per_group - 1;
group_free = cmp_block;
free_blocks += cmp_block;
/*
* The current block group's last block
* is set to i.
*/
i += EXT2FS_C2B(fs, cmp_block - 1);
bitmap = 1;
goto do_counts;
}
}
} else if (redo_flag)
bitmap = actual;
else
bitmap = ext2fs_fast_test_block_bitmap2(fs->block_map, i);
if (!actual == !bitmap)
goto do_counts;
if (!actual && bitmap) {
/*
* Block not used, but marked in use in the bitmap.
*/
problem = PR_5_BLOCK_UNUSED;
} else {
/*
* Block used, but not marked in use in the bitmap.
*/
problem = PR_5_BLOCK_USED;
if (skip_group) {
struct problem_context pctx2;
pctx2.blk = i;
pctx2.group = group;
if (fix_problem(ctx, PR_5_BLOCK_UNINIT,&pctx2)){
ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
skip_group = 0;
}
}
}
if (pctx.blk == NO_BLK) {
pctx.blk = pctx.blk2 = i;
save_problem = problem;
} else {
if ((problem == save_problem) &&
(pctx.blk2 == i-1))
pctx.blk2++;
else {
print_bitmap_problem(ctx, save_problem, &pctx);
pctx.blk = pctx.blk2 = i;
save_problem = problem;
}
}
ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
had_problem++;
/*
* If there a problem we should turn off the discard so we
* do not compromise the filesystem.
*/
ctx->options &= ~E2F_OPT_DISCARD;
do_counts:
if (!bitmap) {
group_free++;
free_blocks++;
if (first_free > i)
first_free = i;
} else if (i > first_free) {
e2fsck_discard_blocks(ctx, first_free,
(i - first_free));
first_free = ext2fs_blocks_count(fs->super);
}
blocks ++;
if ((blocks == fs->super->s_clusters_per_group) ||
(EXT2FS_B2C(fs, i) ==
EXT2FS_B2C(fs, ext2fs_blocks_count(fs->super)-1))) {
/*
* If the last block of this group is free, then we can
* discard it as well.
*/
if (!bitmap && i >= first_free)
e2fsck_discard_blocks(ctx, first_free,
(i - first_free) + 1);
first_free = ext2fs_blocks_count(fs->super);
free_array[group] = group_free;
group ++;
blocks = 0;
group_free = 0;
skip_group = 0;
if (ctx->progress)
if ((ctx->progress)(ctx, 5, group,
fs->group_desc_count*2))
goto errout;
if (csum_flag &&
(i != ext2fs_blocks_count(fs->super)-1) &&
ext2fs_bg_flags_test(fs, group,
EXT2_BG_BLOCK_UNINIT))
skip_group++;
}
}
if (pctx.blk != NO_BLK)
print_bitmap_problem(ctx, save_problem, &pctx);
if (had_problem)
fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
else
fixit = -1;
ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
if (fixit == 1) {
ext2fs_free_block_bitmap(fs->block_map);
retval = ext2fs_copy_bitmap(ctx->block_found_map,
&fs->block_map);
if (retval) {
clear_problem_context(&pctx);
fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
goto errout;
}
ext2fs_set_bitmap_padding(fs->block_map);
ext2fs_mark_bb_dirty(fs);
/* Redo the counts */
blocks = 0; free_blocks = 0; group_free = 0; group = 0;
memset(free_array, 0, fs->group_desc_count * sizeof(int));
redo_flag++;
goto redo_counts;
} else if (fixit == 0)
ext2fs_unmark_valid(fs);
for (i = 0; i < fs->group_desc_count; i++) {
if (free_array[i] != ext2fs_bg_free_blocks_count(fs, i)) {
pctx.group = i;
pctx.blk = ext2fs_bg_free_blocks_count(fs, i);
pctx.blk2 = free_array[i];
if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
&pctx)) {
ext2fs_bg_free_blocks_count_set(fs, i, free_array[i]);
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
}
}
free_blocks = EXT2FS_C2B(fs, free_blocks);
if (free_blocks != ext2fs_free_blocks_count(fs->super)) {
pctx.group = 0;
pctx.blk = ext2fs_free_blocks_count(fs->super);
pctx.blk2 = free_blocks;
if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
ext2fs_free_blocks_count_set(fs->super, free_blocks);
ext2fs_mark_super_dirty(fs);
}
}
errout:
ext2fs_free_mem(&free_array);
}
static void check_block_bitmaps(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
blk64_t i;
int *free_array;
int group = 0;
blk_t blocks = 0;
blk_t free_blocks = 0;
int group_free = 0;
int actual, bitmap;
struct problem_context pctx;
int problem, save_problem, fixit, had_problem;
errcode_t retval;
int csum_flag;
int skip_group = 0;
int old_desc_blocks = 0;
int count = 0;
int cmp_block = 0;
int redo_flag = 0;
blk64_t super_blk, old_desc_blk, new_desc_blk;
clear_problem_context(&pctx);
free_array = (int *) e2fsck_allocate_memory(ctx,
fs->group_desc_count * sizeof(int), "free block count array");
if ((fs->super->s_first_data_block <
ext2fs_get_block_bitmap_start2(ctx->block_found_map)) ||
(fs->super->s_blocks_count-1 >
ext2fs_get_block_bitmap_end2(ctx->block_found_map))) {
pctx.num = 1;
pctx.blk = fs->super->s_first_data_block;
pctx.blk2 = fs->super->s_blocks_count -1;
pctx.ino = ext2fs_get_block_bitmap_start2(ctx->block_found_map);
pctx.ino2 = ext2fs_get_block_bitmap_end2(ctx->block_found_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
goto errout;
}
if ((fs->super->s_first_data_block <
ext2fs_get_block_bitmap_start2(fs->block_map)) ||
(fs->super->s_blocks_count-1 >
ext2fs_get_block_bitmap_end2(fs->block_map))) {
pctx.num = 2;
pctx.blk = fs->super->s_first_data_block;
pctx.blk2 = fs->super->s_blocks_count -1;
pctx.ino = ext2fs_get_block_bitmap_start2(fs->block_map);
pctx.ino2 = ext2fs_get_block_bitmap_end2(fs->block_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
goto errout;
}
csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
redo_counts:
had_problem = 0;
save_problem = 0;
pctx.blk = pctx.blk2 = NO_BLK;
if (csum_flag &&
(fs->group_desc[group].bg_flags & EXT2_BG_BLOCK_UNINIT))
skip_group++;
for (i = fs->super->s_first_data_block;
i < fs->super->s_blocks_count;
i++) {
actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i);
if (skip_group) {
if ((i - fs->super->s_first_data_block) %
fs->super->s_blocks_per_group == 0) {
super_blk = 0;
old_desc_blk = 0;
new_desc_blk = 0;
ext2fs_super_and_bgd_loc2(fs, group, &super_blk,
&old_desc_blk, &new_desc_blk, 0);
if (fs->super->s_feature_incompat &
EXT2_FEATURE_INCOMPAT_META_BG)
old_desc_blocks =
fs->super->s_first_meta_bg;
else
old_desc_blocks = fs->desc_blocks +
fs->super->s_reserved_gdt_blocks;
count = 0;
cmp_block = fs->super->s_blocks_per_group;
if (group == (int)fs->group_desc_count - 1)
cmp_block =
fs->super->s_blocks_count %
fs->super->s_blocks_per_group;
}
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))) {
bitmap = 1;
actual = (actual != 0);
count++;
cmp_block--;
} else if ((i - count - fs->super->s_first_data_block) %
fs->super->s_blocks_per_group == 0) {
/*
* When the compare data blocks in block bitmap
* are 0, count the free block,
* skip the current block group.
*/
if (ext2fs_test_block_bitmap_range2(
ctx->block_found_map, i,
cmp_block)) {
/*
* -1 means to skip the current block
* group.
*/
blocks = fs->super->s_blocks_per_group
- 1;
group_free = cmp_block;
free_blocks += cmp_block;
/*
* The current block group's last block
* is set to i.
*/
i += cmp_block - 1;
bitmap = 1;
goto do_counts;
}
}
} else if (redo_flag)
bitmap = actual;
else
bitmap = ext2fs_fast_test_block_bitmap2(fs->block_map, i);
if (actual == bitmap)
goto do_counts;
if (!actual && bitmap) {
/*
* Block not used, but marked in use in the bitmap.
*/
problem = PR_5_BLOCK_UNUSED;
} else {
/*
* Block used, but not marked in use in the bitmap.
*/
problem = PR_5_BLOCK_USED;
if (skip_group) {
struct problem_context pctx2;
pctx2.blk = i;
pctx2.group = group;
if (fix_problem(ctx, PR_5_BLOCK_UNINIT,&pctx2)){
fs->group_desc[group].bg_flags &=
~EXT2_BG_BLOCK_UNINIT;
skip_group = 0;
}
}
}
if (pctx.blk == NO_BLK) {
pctx.blk = pctx.blk2 = i;
save_problem = problem;
} else {
if ((problem == save_problem) &&
(pctx.blk2 == i-1))
pctx.blk2++;
else {
print_bitmap_problem(ctx, save_problem, &pctx);
pctx.blk = pctx.blk2 = i;
save_problem = problem;
}
}
ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
had_problem++;
do_counts:
if (!bitmap && (!skip_group || csum_flag)) {
group_free++;
free_blocks++;
}
blocks ++;
if ((blocks == fs->super->s_blocks_per_group) ||
(i == fs->super->s_blocks_count-1)) {
free_array[group] = group_free;
group ++;
blocks = 0;
group_free = 0;
skip_group = 0;
if (ctx->progress)
if ((ctx->progress)(ctx, 5, group,
fs->group_desc_count*2))
goto errout;
if (csum_flag &&
(i != fs->super->s_blocks_count-1) &&
(fs->group_desc[group].bg_flags &
EXT2_BG_BLOCK_UNINIT))
skip_group++;
}
}
if (pctx.blk != NO_BLK)
print_bitmap_problem(ctx, save_problem, &pctx);
if (had_problem)
fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
else
fixit = -1;
ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
if (fixit == 1) {
ext2fs_free_block_bitmap(fs->block_map);
retval = ext2fs_copy_bitmap(ctx->block_found_map,
&fs->block_map);
if (retval) {
clear_problem_context(&pctx);
fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
goto errout;
}
ext2fs_set_bitmap_padding(fs->block_map);
ext2fs_mark_bb_dirty(fs);
/* Redo the counts */
blocks = 0; free_blocks = 0; group_free = 0; group = 0;
memset(free_array, 0, fs->group_desc_count * sizeof(int));
redo_flag++;
goto redo_counts;
} else if (fixit == 0)
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) {
pctx.group = i;
pctx.blk = fs->group_desc[i].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];
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
}
}
if (free_blocks != fs->super->s_free_blocks_count) {
pctx.group = 0;
pctx.blk = fs->super->s_free_blocks_count;
pctx.blk2 = free_blocks;
if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
fs->super->s_free_blocks_count = free_blocks;
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
}
errout:
ext2fs_free_mem(&free_array);
}
