static void check_block_bitmap_checksum(e2fsck_t ctx)
{
struct problem_context pctx;
char *buf;
dgrp_t i;
int nbytes;
blk64_t blk_itr;
errcode_t retval;
if (!EXT2_HAS_RO_COMPAT_FEATURE(ctx->fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
return;
/* If bitmap is dirty from being fixed, checksum will be corrected */
if (ext2fs_test_bb_dirty(ctx->fs))
return;
nbytes = (size_t)(EXT2_CLUSTERS_PER_GROUP(ctx->fs->super) / 8);
retval = ext2fs_get_memalign(ctx->fs->blocksize, ctx->fs->blocksize,
&buf);
if (retval) {
com_err(ctx->program_name, 0,
_("check_block_bitmap_checksum: Memory allocation error"));
fatal_error(ctx, 0);
}
clear_problem_context(&pctx);
for (i = 0; i < ctx->fs->group_desc_count; i++) {
if (ext2fs_bg_flags_test(ctx->fs, i, EXT2_BG_BLOCK_UNINIT))
continue;
blk_itr = EXT2FS_B2C(ctx->fs,
ctx->fs->super->s_first_data_block) +
(i * (nbytes << 3));
retval = ext2fs_get_block_bitmap_range2(ctx->fs->block_map,
blk_itr, nbytes << 3,
buf);
if (retval)
break;
if (ext2fs_block_bitmap_csum_verify(ctx->fs, i, buf, nbytes))
continue;
pctx.group = i;
if (!fix_problem(ctx, PR_5_BLOCK_BITMAP_CSUM_INVALID, &pctx))
continue;
/*
* Fixing one checksum will rewrite all of them. The bitmap
* will be checked against the one we made during pass1 for
* discrepancies, and fixed if need be.
*/
ext2fs_mark_bb_dirty(ctx->fs);
break;
}
ext2fs_free_mem(&buf);
}
/*
* Clear the uninit block bitmap flag if necessary
*/
static void clear_block_uninit(ext2_filsys fs, dgrp_t group)
{
if (!ext2fs_has_group_desc_csum(fs) ||
!(ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
return;
/* uninit block bitmaps are now initialized in read_bitmaps() */
ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
ext2fs_group_desc_csum_set(fs, group);
ext2fs_mark_super_dirty(fs);
ext2fs_mark_bb_dirty(fs);
}
/*
* Check for uninit block bitmaps and deal with them appropriately
*/
static void check_block_uninit(ext2_filsys fs, ext2fs_block_bitmap map,
dgrp_t group)
{
blk_t i;
blk64_t blk, super_blk, old_desc_blk, new_desc_blk;
int old_desc_blocks;
if (!(EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM)) ||
!(ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
return;
blk = (group * fs->super->s_blocks_per_group) +
fs->super->s_first_data_block;
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;
for (i=0; i < fs->super->s_blocks_per_group; i++, blk++)
ext2fs_fast_unmark_block_bitmap2(map, blk);
blk = (group * fs->super->s_blocks_per_group) +
fs->super->s_first_data_block;
for (i=0; i < fs->super->s_blocks_per_group; i++, blk++) {
if ((blk == super_blk) ||
(old_desc_blk && old_desc_blocks &&
(blk >= old_desc_blk) &&
(blk < old_desc_blk + old_desc_blocks)) ||
(new_desc_blk && (blk == new_desc_blk)) ||
(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);
}
ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
ext2fs_group_desc_csum_set(fs, group);
ext2fs_mark_super_dirty(fs);
ext2fs_mark_bb_dirty(fs);
}
/*
* Check for uninit inode bitmaps and deal with them appropriately
*/
static void check_inode_uninit(ext2_filsys fs, ext2fs_inode_bitmap map,
dgrp_t group)
{
ext2_ino_t i, ino;
if (!ext2fs_has_group_desc_csum(fs) ||
!(ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)))
return;
ino = (group * fs->super->s_inodes_per_group) + 1;
for (i=0; i < fs->super->s_inodes_per_group; i++, ino++)
ext2fs_fast_unmark_inode_bitmap2(map, ino);
ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT);
ext2fs_group_desc_csum_set(fs, group);
ext2fs_mark_ib_dirty(fs);
ext2fs_mark_super_dirty(fs);
check_block_uninit(fs, fs->block_map, group);
}
static errcode_t mark_uninit_bg_group_blocks(ext2_filsys fs)
{
dgrp_t i;
blk64_t blk;
ext2fs_block_bitmap bmap = fs->block_map;
for (i = 0; i < fs->group_desc_count; i++) {
if (!ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT))
continue;
ext2fs_reserve_super_and_bgd(fs, i, bmap);
/*
* Mark the blocks used for the inode table
*/
blk = ext2fs_inode_table_loc(fs, i);
if (blk)
ext2fs_mark_block_bitmap_range2(bmap, blk,
fs->inode_blocks_per_group);
/*
* Mark block used for the block bitmap
*/
blk = ext2fs_block_bitmap_loc(fs, i);
if (blk)
ext2fs_mark_block_bitmap2(bmap, blk);
/*
* Mark block used for the inode bitmap
*/
blk = ext2fs_inode_bitmap_loc(fs, i);
if (blk)
ext2fs_mark_block_bitmap2(bmap, blk);
}
return 0;
}
static errcode_t write_bitmaps(ext2_filsys fs, int do_inode, int do_block)
{
dgrp_t i;
unsigned int j;
int block_nbytes, inode_nbytes;
unsigned int nbits;
errcode_t retval;
char *block_buf = NULL, *inode_buf = NULL;
int csum_flag = 0;
blk64_t blk;
blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block);
ext2_ino_t ino_itr = 1;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if (!(fs->flags & EXT2_FLAG_RW))
return EXT2_ET_RO_FILSYS;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
csum_flag = 1;
inode_nbytes = block_nbytes = 0;
if (do_block) {
block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8;
retval = io_channel_alloc_buf(fs->io, 0, &block_buf);
if (retval)
goto errout;
memset(block_buf, 0xff, fs->blocksize);
}
if (do_inode) {
inode_nbytes = (size_t)
((EXT2_INODES_PER_GROUP(fs->super)+7) / 8);
retval = io_channel_alloc_buf(fs->io, 0, &inode_buf);
if (retval)
goto errout;
memset(inode_buf, 0xff, fs->blocksize);
}
for (i = 0; i < fs->group_desc_count; i++) {
if (!do_block)
goto skip_block_bitmap;
if (csum_flag && ext2fs_bg_flags_test(fs, i, EXT2_BG_BLOCK_UNINIT)
)
goto skip_this_block_bitmap;
retval = ext2fs_get_block_bitmap_range2(fs->block_map,
blk_itr, block_nbytes << 3, block_buf);
if (retval)
goto errout;
if (i == fs->group_desc_count - 1) {
/* Force bitmap padding for the last group */
nbits = EXT2FS_NUM_B2C(fs,
((ext2fs_blocks_count(fs->super)
- (__u64) fs->super->s_first_data_block)
% (__u64) EXT2_BLOCKS_PER_GROUP(fs->super)));
if (nbits)
for (j = nbits; j < fs->blocksize * 8; j++)
ext2fs_set_bit(j, block_buf);
}
blk = ext2fs_block_bitmap_loc(fs, i);
if (blk) {
retval = io_channel_write_blk64(fs->io, blk, 1,
block_buf);
if (retval) {
retval = EXT2_ET_BLOCK_BITMAP_WRITE;
goto errout;
}
}
skip_this_block_bitmap:
blk_itr += block_nbytes << 3;
skip_block_bitmap:
if (!do_inode)
continue;
if (csum_flag && ext2fs_bg_flags_test(fs, i, EXT2_BG_INODE_UNINIT)
)
goto skip_this_inode_bitmap;
retval = ext2fs_get_inode_bitmap_range2(fs->inode_map,
ino_itr, inode_nbytes << 3, inode_buf);
if (retval)
goto errout;
blk = ext2fs_inode_bitmap_loc(fs, i);
if (blk) {
retval = io_channel_write_blk64(fs->io, blk, 1,
inode_buf);
if (retval) {
retval = EXT2_ET_INODE_BITMAP_WRITE;
goto errout;
}
}
skip_this_inode_bitmap:
ino_itr += inode_nbytes << 3;
}
if (do_block) {
fs->flags &= ~EXT2_FLAG_BB_DIRTY;
ext2fs_free_mem(&block_buf);
}
if (do_inode) {
fs->flags &= ~EXT2_FLAG_IB_DIRTY;
ext2fs_free_mem(&inode_buf);
}
return 0;
errout:
if (inode_buf)
ext2fs_free_mem(&inode_buf);
if (block_buf)
ext2fs_free_mem(&block_buf);
return retval;
}
static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
{
dgrp_t i;
char *block_bitmap = 0, *inode_bitmap = 0;
char *buf;
errcode_t retval;
int block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8;
int inode_nbytes = EXT2_INODES_PER_GROUP(fs->super) / 8;
int csum_flag = 0;
unsigned int cnt;
blk64_t blk;
blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block);
blk64_t blk_cnt;
ext2_ino_t ino_itr = 1;
ext2_ino_t ino_cnt;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if ((block_nbytes > fs->blocksize) || (inode_nbytes > fs->blocksize))
return EXT2_ET_CORRUPT_SUPERBLOCK;
fs->write_bitmaps = ext2fs_write_bitmaps;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_GDT_CSUM))
csum_flag = 1;
retval = ext2fs_get_mem(strlen(fs->device_name) + 80, &buf);
if (retval)
return retval;
if (do_block) {
if (fs->block_map)
ext2fs_free_block_bitmap(fs->block_map);
strcpy(buf, "block bitmap for ");
strcat(buf, fs->device_name);
retval = ext2fs_allocate_block_bitmap(fs, buf, &fs->block_map);
if (retval)
goto cleanup;
retval = io_channel_alloc_buf(fs->io, 0, &block_bitmap);
if (retval)
goto cleanup;
} else
block_nbytes = 0;
if (do_inode) {
if (fs->inode_map)
ext2fs_free_inode_bitmap(fs->inode_map);
strcpy(buf, "inode bitmap for ");
strcat(buf, fs->device_name);
retval = ext2fs_allocate_inode_bitmap(fs, buf, &fs->inode_map);
if (retval)
goto cleanup;
retval = io_channel_alloc_buf(fs->io, 0, &inode_bitmap);
if (retval)
goto cleanup;
} else
inode_nbytes = 0;
ext2fs_free_mem(&buf);
if (fs->flags & EXT2_FLAG_IMAGE_FILE) {
blk = (fs->image_header->offset_inodemap / fs->blocksize);
ino_cnt = fs->super->s_inodes_count;
while (inode_nbytes > 0) {
retval = io_channel_read_blk64(fs->image_io, blk++,
1, inode_bitmap);
if (retval)
goto cleanup;
cnt = fs->blocksize << 3;
if (cnt > ino_cnt)
cnt = ino_cnt;
retval = ext2fs_set_inode_bitmap_range2(fs->inode_map,
ino_itr, cnt, inode_bitmap);
if (retval)
goto cleanup;
ino_itr += fs->blocksize << 3;
ino_cnt -= fs->blocksize << 3;
inode_nbytes -= fs->blocksize;
}
blk = (fs->image_header->offset_blockmap /
fs->blocksize);
blk_cnt = (blk64_t)EXT2_CLUSTERS_PER_GROUP(fs->super) *
fs->group_desc_count;
while (block_nbytes > 0) {
retval = io_channel_read_blk64(fs->image_io, blk++,
1, block_bitmap);
if (retval)
goto cleanup;
cnt = fs->blocksize << 3;
if (cnt > blk_cnt)
cnt = blk_cnt;
retval = ext2fs_set_block_bitmap_range2(fs->block_map,
blk_itr, cnt, block_bitmap);
if (retval)
goto cleanup;
blk_itr += fs->blocksize << 3;
blk_cnt -= fs->blocksize << 3;
block_nbytes -= fs->blocksize;
}
goto success_cleanup;
}
for (i = 0; i < fs->group_desc_count; i++) {
if (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))
blk = 0;
if (blk) {
retval = io_channel_read_blk64(fs->io, blk,
1, block_bitmap);
if (retval) {
retval = EXT2_ET_BLOCK_BITMAP_READ;
goto cleanup;
}
} else
memset(block_bitmap, 0, block_nbytes);
cnt = block_nbytes << 3;
retval = ext2fs_set_block_bitmap_range2(fs->block_map,
blk_itr, cnt, block_bitmap);
if (retval)
goto cleanup;
blk_itr += block_nbytes << 3;
}
if (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))
blk = 0;
if (blk) {
retval = io_channel_read_blk64(fs->io, blk,
1, inode_bitmap);
if (retval) {
retval = EXT2_ET_INODE_BITMAP_READ;
goto cleanup;
}
} else
memset(inode_bitmap, 0, inode_nbytes);
cnt = inode_nbytes << 3;
retval = ext2fs_set_inode_bitmap_range2(fs->inode_map,
ino_itr, cnt, inode_bitmap);
if (retval)
goto cleanup;
ino_itr += inode_nbytes << 3;
}
}
success_cleanup:
if (inode_bitmap)
ext2fs_free_mem(&inode_bitmap);
if (block_bitmap)
ext2fs_free_mem(&block_bitmap);
return 0;
cleanup:
if (do_block) {
ext2fs_free_mem(&fs->block_map);
fs->block_map = 0;
}
if (do_inode) {
ext2fs_free_mem(&fs->inode_map);
fs->inode_map = 0;
}
if (inode_bitmap)
ext2fs_free_mem(&inode_bitmap);
if (block_bitmap)
ext2fs_free_mem(&block_bitmap);
if (buf)
ext2fs_free_mem(&buf);
return retval;
}
errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
struct ext2_inode *inode, int bufsize)
{
errcode_t retval;
int extra_bytes = 0;
int length;
struct ext2_inode_large *iptr = (struct ext2_inode_large *)inode;
char *iblock_status;
unsigned int iblk;
EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN);
length = EXT2_INODE_SIZE(scan->fs->super);
iblock_status = SCAN_BLOCK_STATUS(scan);
/*
* Do we need to start reading a new block group?
*/
if (scan->inodes_left <= 0) {
force_new_group:
if (scan->done_group) {
retval = (scan->done_group)
(scan->fs, scan, scan->current_group,
scan->done_group_data);
if (retval)
return retval;
}
if (scan->groups_left <= 0) {
*ino = 0;
return 0;
}
retval = get_next_blockgroup(scan);
if (retval)
return retval;
}
/*
* These checks are done outside the above if statement so
* they can be done for block group #0.
*/
if ((scan->scan_flags & EXT2_SF_DO_LAZY) &&
(ext2fs_bg_flags_test(scan->fs, scan->current_group, EXT2_BG_INODE_UNINIT)
))
goto force_new_group;
if (scan->inodes_left == 0)
goto force_new_group;
if (scan->current_block == 0) {
if (scan->scan_flags & EXT2_SF_SKIP_MISSING_ITABLE) {
goto force_new_group;
} else
return EXT2_ET_MISSING_INODE_TABLE;
}
/*
* Have we run out of space in the inode buffer? If so, we
* need to read in more blocks.
*/
if (scan->bytes_left < scan->inode_size) {
memcpy(scan->temp_buffer, scan->ptr, scan->bytes_left);
extra_bytes = scan->bytes_left;
retval = get_next_blocks(scan);
if (retval)
return retval;
#if 0
/*
* XXX test Need check for used inode somehow.
* (Note: this is hard.)
*/
if (is_empty_scan(scan))
goto force_new_group;
#endif
}
if (bufsize < length) {
retval = ext2fs_get_mem(length, &iptr);
if (retval)
return retval;
}
retval = 0;
iblk = scan->current_inode % EXT2_INODES_PER_GROUP(scan->fs->super) /
EXT2_INODES_PER_BLOCK(scan->fs->super) %
scan->inode_buffer_blocks;
if (extra_bytes) {
memcpy(scan->temp_buffer+extra_bytes, scan->ptr,
scan->inode_size - extra_bytes);
scan->ptr += scan->inode_size - extra_bytes;
scan->bytes_left -= scan->inode_size - extra_bytes;
/* Verify the inode checksum. */
if (!(iblock_status[iblk] & IBLOCK_STATUS_CSUMS_OK) &&
!(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
!ext2fs_inode_csum_verify(scan->fs, scan->current_inode + 1,
(struct ext2_inode_large *)scan->temp_buffer))
retval = EXT2_ET_INODE_CSUM_INVALID;
#ifdef WORDS_BIGENDIAN
memset(iptr, 0, length);
ext2fs_swap_inode_full(scan->fs,
(struct ext2_inode_large *) iptr,
(struct ext2_inode_large *) scan->temp_buffer,
0, length);
#else
memcpy(iptr, scan->temp_buffer, length);
#endif
if (scan->scan_flags & EXT2_SF_BAD_EXTRA_BYTES)
retval = EXT2_ET_BAD_BLOCK_IN_INODE_TABLE;
scan->scan_flags &= ~EXT2_SF_BAD_EXTRA_BYTES;
} else {
/* Verify the inode checksum. */
if (!(iblock_status[iblk] & IBLOCK_STATUS_CSUMS_OK) &&
!(scan->fs->flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
!ext2fs_inode_csum_verify(scan->fs, scan->current_inode + 1,
(struct ext2_inode_large *)scan->ptr))
retval = EXT2_ET_INODE_CSUM_INVALID;
#ifdef WORDS_BIGENDIAN
memset(iptr, 0, length);
ext2fs_swap_inode_full(scan->fs,
(struct ext2_inode_large *) iptr,
(struct ext2_inode_large *) scan->ptr,
0, length);
#else
memcpy(iptr, scan->ptr, length);
#endif
scan->ptr += scan->inode_size;
scan->bytes_left -= scan->inode_size;
if (scan->scan_flags & EXT2_SF_BAD_INODE_BLK)
retval = EXT2_ET_BAD_BLOCK_IN_INODE_TABLE;
}
if ((iblock_status[iblk] & IBLOCK_STATUS_INSANE) &&
(retval == 0 || retval == EXT2_ET_INODE_CSUM_INVALID))
retval = EXT2_ET_INODE_IS_GARBAGE;
scan->inodes_left--;
scan->current_inode++;
*ino = scan->current_inode;
if (iptr != (struct ext2_inode_large *)inode) {
memcpy(inode, iptr, bufsize);
ext2fs_free_mem(&iptr);
}
return retval;
}
static errcode_t read_bitmaps(ext2_filsys fs, int do_inode, int do_block)
{
dgrp_t i;
char *block_bitmap = 0, *inode_bitmap = 0;
char *buf;
errcode_t retval;
int block_nbytes = EXT2_CLUSTERS_PER_GROUP(fs->super) / 8;
int inode_nbytes = EXT2_INODES_PER_GROUP(fs->super) / 8;
int csum_flag;
unsigned int cnt;
blk64_t blk;
blk64_t blk_itr = EXT2FS_B2C(fs, fs->super->s_first_data_block);
blk64_t blk_cnt;
ext2_ino_t ino_itr = 1;
ext2_ino_t ino_cnt;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
if ((block_nbytes > (int) fs->blocksize) ||
(inode_nbytes > (int) fs->blocksize))
return EXT2_ET_CORRUPT_SUPERBLOCK;
fs->write_bitmaps = ext2fs_write_bitmaps;
csum_flag = ext2fs_has_group_desc_csum(fs);
retval = ext2fs_get_mem(strlen(fs->device_name) + 80, &buf);
if (retval)
return retval;
if (do_block) {
if (fs->block_map)
ext2fs_free_block_bitmap(fs->block_map);
strcpy(buf, "block bitmap for ");
strcat(buf, fs->device_name);
retval = ext2fs_allocate_block_bitmap(fs, buf, &fs->block_map);
if (retval)
goto cleanup;
retval = io_channel_alloc_buf(fs->io, 0, &block_bitmap);
if (retval)
goto cleanup;
} else
block_nbytes = 0;
if (do_inode) {
if (fs->inode_map)
ext2fs_free_inode_bitmap(fs->inode_map);
strcpy(buf, "inode bitmap for ");
strcat(buf, fs->device_name);
retval = ext2fs_allocate_inode_bitmap(fs, buf, &fs->inode_map);
if (retval)
goto cleanup;
retval = io_channel_alloc_buf(fs->io, 0, &inode_bitmap);
if (retval)
goto cleanup;
} else
inode_nbytes = 0;
ext2fs_free_mem(&buf);
if (fs->flags & EXT2_FLAG_IMAGE_FILE) {
blk = (ext2fs_le32_to_cpu(fs->image_header->offset_inodemap) / fs->blocksize);
ino_cnt = fs->super->s_inodes_count;
while (inode_bitmap && ino_cnt > 0) {
retval = io_channel_read_blk64(fs->image_io, blk++,
1, inode_bitmap);
if (retval)
goto cleanup;
cnt = fs->blocksize << 3;
if (cnt > ino_cnt)
cnt = ino_cnt;
retval = ext2fs_set_inode_bitmap_range2(fs->inode_map,
ino_itr, cnt, inode_bitmap);
if (retval)
goto cleanup;
ino_itr += cnt;
ino_cnt -= cnt;
}
blk = (ext2fs_le32_to_cpu(fs->image_header->offset_blockmap) /
fs->blocksize);
blk_cnt = EXT2_GROUPS_TO_CLUSTERS(fs->super,
fs->group_desc_count);
while (block_bitmap && blk_cnt > 0) {
retval = io_channel_read_blk64(fs->image_io, blk++,
1, block_bitmap);
if (retval)
goto cleanup;
cnt = fs->blocksize << 3;
if (cnt > blk_cnt)
cnt = blk_cnt;
retval = ext2fs_set_block_bitmap_range2(fs->block_map,
blk_itr, cnt, block_bitmap);
if (retval)
goto cleanup;
blk_itr += cnt;
blk_cnt -= cnt;
}
goto success_cleanup;
}
for (i = 0; i < fs->group_desc_count; i++) {
if (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))
blk = 0;
if (blk) {
retval = io_channel_read_blk64(fs->io, blk,
1, block_bitmap);
if (retval) {
retval = EXT2_ET_BLOCK_BITMAP_READ;
goto cleanup;
}
/* verify block bitmap checksum */
if (!(fs->flags &
EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
!ext2fs_block_bitmap_csum_verify(fs, i,
block_bitmap, block_nbytes)) {
retval =
EXT2_ET_BLOCK_BITMAP_CSUM_INVALID;
goto cleanup;
}
} else
memset(block_bitmap, 0, block_nbytes);
cnt = block_nbytes << 3;
retval = ext2fs_set_block_bitmap_range2(fs->block_map,
blk_itr, cnt, block_bitmap);
if (retval)
goto cleanup;
blk_itr += block_nbytes << 3;
}
if (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))
blk = 0;
if (blk) {
retval = io_channel_read_blk64(fs->io, blk,
1, inode_bitmap);
if (retval) {
retval = EXT2_ET_INODE_BITMAP_READ;
goto cleanup;
}
/* verify inode bitmap checksum */
if (!(fs->flags &
EXT2_FLAG_IGNORE_CSUM_ERRORS) &&
!ext2fs_inode_bitmap_csum_verify(fs, i,
inode_bitmap, inode_nbytes)) {
retval =
EXT2_ET_INODE_BITMAP_CSUM_INVALID;
goto cleanup;
}
} else
memset(inode_bitmap, 0, inode_nbytes);
cnt = inode_nbytes << 3;
retval = ext2fs_set_inode_bitmap_range2(fs->inode_map,
ino_itr, cnt, inode_bitmap);
if (retval)
goto cleanup;
ino_itr += inode_nbytes << 3;
}
}
/* Mark group blocks for any BLOCK_UNINIT groups */
if (do_block) {
retval = mark_uninit_bg_group_blocks(fs);
if (retval)
goto cleanup;
}
success_cleanup:
if (inode_bitmap)
ext2fs_free_mem(&inode_bitmap);
if (block_bitmap)
ext2fs_free_mem(&block_bitmap);
return 0;
cleanup:
if (do_block) {
ext2fs_free_mem(&fs->block_map);
fs->block_map = 0;
}
if (do_inode) {
ext2fs_free_mem(&fs->inode_map);
fs->inode_map = 0;
}
if (inode_bitmap)
ext2fs_free_mem(&inode_bitmap);
if (block_bitmap)
ext2fs_free_mem(&block_bitmap);
if (buf)
ext2fs_free_mem(&buf);
return retval;
}
static int check_dir_block(ext2_filsys fs,
struct ext2_db_entry2 *db,
void *priv_data)
{
struct dx_dir_info *dx_dir;
#ifdef ENABLE_HTREE
struct dx_dirblock_info *dx_db = 0;
#endif /* ENABLE_HTREE */
struct ext2_dir_entry *dirent, *prev;
ext2_dirhash_t hash;
unsigned int offset = 0;
int dir_modified = 0;
int dot_state;
unsigned int rec_len;
blk64_t block_nr = db->blk;
ext2_ino_t ino = db->ino;
ext2_ino_t subdir_parent;
__u16 links;
struct check_dir_struct *cd;
char *buf;
e2fsck_t ctx;
int problem;
struct ext2_dx_root_info *root;
struct ext2_dx_countlimit *limit;
static dict_t de_dict;
struct problem_context pctx;
int dups_found = 0;
int ret;
int dx_csum_size = 0, de_csum_size = 0;
int failed_csum = 0;
int is_leaf = 1;
cd = (struct check_dir_struct *) priv_data;
buf = cd->buf;
ctx = cd->ctx;
if (ctx->flags & E2F_FLAG_SIGNAL_MASK || ctx->flags & E2F_FLAG_RESTART)
return DIRENT_ABORT;
if (ctx->progress && (ctx->progress)(ctx, 2, cd->count++, cd->max))
return DIRENT_ABORT;
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
dx_csum_size = sizeof(struct ext2_dx_tail);
de_csum_size = sizeof(struct ext2_dir_entry_tail);
}
/*
* Make sure the inode is still in use (could have been
* deleted in the duplicate/bad blocks pass.
*/
if (!(ext2fs_test_inode_bitmap2(ctx->inode_used_map, ino)))
return 0;
cd->pctx.ino = ino;
cd->pctx.blk = block_nr;
cd->pctx.blkcount = db->blockcnt;
cd->pctx.ino2 = 0;
cd->pctx.dirent = 0;
cd->pctx.num = 0;
if (db->blk == 0) {
if (allocate_dir_block(ctx, db, buf, &cd->pctx))
return 0;
block_nr = db->blk;
}
if (db->blockcnt)
dot_state = 2;
else
dot_state = 0;
if (ctx->dirs_to_hash &&
ext2fs_u32_list_test(ctx->dirs_to_hash, ino))
dups_found++;
#if 0
printf("In process_dir_block block %lu, #%d, inode %lu\n", block_nr,
db->blockcnt, ino);
#endif
ehandler_operation(_("reading directory block"));
cd->pctx.errcode = ext2fs_read_dir_block4(fs, block_nr, buf, 0, ino);
ehandler_operation(0);
if (cd->pctx.errcode == EXT2_ET_DIR_CORRUPTED)
cd->pctx.errcode = 0; /* We'll handle this ourselves */
else if (cd->pctx.errcode == EXT2_ET_DIR_CSUM_INVALID) {
cd->pctx.errcode = 0; /* We'll handle this ourselves */
failed_csum = 1;
}
if (cd->pctx.errcode) {
char *buf2;
if (!fix_problem(ctx, PR_2_READ_DIRBLOCK, &cd->pctx)) {
ctx->flags |= E2F_FLAG_ABORT;
return DIRENT_ABORT;
}
ext2fs_new_dir_block(fs, db->blockcnt == 0 ? ino : 0,
EXT2_ROOT_INO, &buf2);
memcpy(buf, buf2, fs->blocksize);
ext2fs_free_mem(&buf2);
}
#ifdef ENABLE_HTREE
dx_dir = e2fsck_get_dx_dir_info(ctx, ino);
if (dx_dir && dx_dir->numblocks) {
if (db->blockcnt >= dx_dir->numblocks) {
if (fix_problem(ctx, PR_2_UNEXPECTED_HTREE_BLOCK,
&pctx)) {
clear_htree(ctx, ino);
dx_dir->numblocks = 0;
dx_db = 0;
goto out_htree;
}
fatal_error(ctx, _("Can not continue."));
}
dx_db = &dx_dir->dx_block[db->blockcnt];
dx_db->type = DX_DIRBLOCK_LEAF;
dx_db->phys = block_nr;
dx_db->min_hash = ~0;
dx_db->max_hash = 0;
dirent = (struct ext2_dir_entry *) buf;
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
limit = (struct ext2_dx_countlimit *) (buf+8);
if (db->blockcnt == 0) {
root = (struct ext2_dx_root_info *) (buf + 24);
dx_db->type = DX_DIRBLOCK_ROOT;
dx_db->flags |= DX_FLAG_FIRST | DX_FLAG_LAST;
if ((root->reserved_zero ||
root->info_length < 8 ||
root->indirect_levels > 1) &&
fix_problem(ctx, PR_2_HTREE_BAD_ROOT, &cd->pctx)) {
clear_htree(ctx, ino);
dx_dir->numblocks = 0;
dx_db = 0;
}
dx_dir->hashversion = root->hash_version;
if ((dx_dir->hashversion <= EXT2_HASH_TEA) &&
(fs->super->s_flags & EXT2_FLAGS_UNSIGNED_HASH))
dx_dir->hashversion += 3;
dx_dir->depth = root->indirect_levels + 1;
} else if ((dirent->inode == 0) &&
(rec_len == fs->blocksize) &&
(dirent->name_len == 0) &&
(ext2fs_le16_to_cpu(limit->limit) ==
((fs->blocksize - (8 + dx_csum_size)) /
sizeof(struct ext2_dx_entry))))
dx_db->type = DX_DIRBLOCK_NODE;
is_leaf = 0;
}
out_htree:
#endif /* ENABLE_HTREE */
/* Verify checksum. */
if (is_leaf && de_csum_size) {
/* No space for csum? Rebuild dirs in pass 3A. */
if (!ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf)) {
de_csum_size = 0;
if (e2fsck_dir_will_be_rehashed(ctx, ino))
goto skip_checksum;
if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_MISSING_CSUM,
&cd->pctx))
goto skip_checksum;
e2fsck_rehash_dir_later(ctx, ino);
goto skip_checksum;
}
if (failed_csum) {
char *buf2;
if (!fix_problem(cd->ctx, PR_2_LEAF_NODE_CSUM_INVALID,
&cd->pctx))
goto skip_checksum;
ext2fs_new_dir_block(fs,
db->blockcnt == 0 ? ino : 0,
EXT2_ROOT_INO, &buf2);
memcpy(buf, buf2, fs->blocksize);
ext2fs_free_mem(&buf2);
dir_modified++;
failed_csum = 0;
}
}
/* htree nodes don't use fake dirents to store checksums */
if (!is_leaf)
de_csum_size = 0;
skip_checksum:
dict_init(&de_dict, DICTCOUNT_T_MAX, dict_de_cmp);
prev = 0;
do {
int group;
ext2_ino_t first_unused_inode;
problem = 0;
dirent = (struct ext2_dir_entry *) (buf + offset);
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
cd->pctx.dirent = dirent;
cd->pctx.num = offset;
if (((offset + rec_len) > fs->blocksize) ||
(rec_len < 12) ||
((rec_len % 4) != 0) ||
(((dirent->name_len & (unsigned) 0xFF)+8) > rec_len)) {
if (fix_problem(ctx, PR_2_DIR_CORRUPTED, &cd->pctx)) {
salvage_directory(fs, dirent, prev, &offset);
dir_modified++;
continue;
} else
goto abort_free_dict;
}
if (dot_state == 0) {
if (check_dot(ctx, dirent, ino, &cd->pctx))
dir_modified++;
} else if (dot_state == 1) {
ret = check_dotdot(ctx, dirent, ino, &cd->pctx);
if (ret < 0)
goto abort_free_dict;
if (ret)
dir_modified++;
} else if (dirent->inode == ino) {
problem = PR_2_LINK_DOT;
if (fix_problem(ctx, PR_2_LINK_DOT, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
}
if (!dirent->inode)
goto next;
/*
* Make sure the inode listed is a legal one.
*/
if (((dirent->inode != EXT2_ROOT_INO) &&
(dirent->inode < EXT2_FIRST_INODE(fs->super))) ||
(dirent->inode > fs->super->s_inodes_count)) {
problem = PR_2_BAD_INO;
} else if (ctx->inode_bb_map &&
(ext2fs_test_inode_bitmap2(ctx->inode_bb_map,
dirent->inode))) {
/*
* If the inode is in a bad block, offer to
* clear it.
*/
problem = PR_2_BB_INODE;
} else if ((dot_state > 1) &&
((dirent->name_len & 0xFF) == 1) &&
(dirent->name[0] == '.')) {
/*
* If there's a '.' entry in anything other
* than the first directory entry, it's a
* duplicate entry that should be removed.
*/
problem = PR_2_DUP_DOT;
} else if ((dot_state > 1) &&
((dirent->name_len & 0xFF) == 2) &&
(dirent->name[0] == '.') &&
(dirent->name[1] == '.')) {
/*
* If there's a '..' entry in anything other
* than the second directory entry, it's a
* duplicate entry that should be removed.
*/
problem = PR_2_DUP_DOT_DOT;
} else if ((dot_state > 1) &&
(dirent->inode == EXT2_ROOT_INO)) {
/*
* Don't allow links to the root directory.
* We check this specially to make sure we
* catch this error case even if the root
* directory hasn't been created yet.
*/
problem = PR_2_LINK_ROOT;
} else if ((dot_state > 1) &&
(dirent->name_len & 0xFF) == 0) {
/*
* Don't allow zero-length directory names.
*/
problem = PR_2_NULL_NAME;
}
if (problem) {
if (fix_problem(ctx, problem, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
/*
* If the inode was marked as having bad fields in
* pass1, process it and offer to fix/clear it.
* (We wait until now so that we can display the
* pathname to the user.)
*/
if (ctx->inode_bad_map &&
ext2fs_test_inode_bitmap2(ctx->inode_bad_map,
dirent->inode)) {
if (e2fsck_process_bad_inode(ctx, ino,
dirent->inode,
buf + fs->blocksize)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return DIRENT_ABORT;
}
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 -
ext2fs_bg_itable_unused(fs, group);
cd->pctx.group = group;
/*
* Check if the inode was missed out because
* _INODE_UNINIT flag was set or bg_itable_unused was
* incorrect. If so, clear the _INODE_UNINIT flag and
* restart e2fsck. In the future it would be nice if
* we could call a function in pass1.c that checks the
* newly visible inodes.
*/
if (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)) {
pctx.num = dirent->inode;
if (fix_problem(ctx, PR_2_INOREF_BG_INO_UNINIT,
&cd->pctx)){
ext2fs_bg_flags_clear(fs, group,
EXT2_BG_INODE_UNINIT);
ext2fs_mark_super_dirty(fs);
ctx->flags |= E2F_FLAG_RESTART_LATER;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
} else if (dirent->inode >= first_unused_inode) {
pctx.num = dirent->inode;
if (fix_problem(ctx, PR_2_INOREF_IN_UNUSED, &cd->pctx)){
ext2fs_bg_itable_unused_set(fs, group, 0);
ext2fs_mark_super_dirty(fs);
ctx->flags |= E2F_FLAG_RESTART_LATER;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
/*
* Offer to clear unused inodes; if we are going to be
* restarting the scan due to bg_itable_unused being
* wrong, then don't clear any inodes to avoid zapping
* inodes that were skipped during pass1 due to an
* incorrect bg_itable_unused; we'll get any real
* problems after we restart.
*/
if (!(ctx->flags & E2F_FLAG_RESTART_LATER) &&
!(ext2fs_test_inode_bitmap2(ctx->inode_used_map,
dirent->inode)))
problem = PR_2_UNUSED_INODE;
if (problem) {
if (fix_problem(ctx, problem, &cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
} else {
ext2fs_unmark_valid(fs);
if (problem == PR_2_BAD_INO)
goto next;
}
}
if (check_name(ctx, dirent, ino, &cd->pctx))
dir_modified++;
if (check_filetype(ctx, dirent, ino, &cd->pctx))
dir_modified++;
#ifdef ENABLE_HTREE
if (dx_db) {
ext2fs_dirhash(dx_dir->hashversion, dirent->name,
(dirent->name_len & 0xFF),
fs->super->s_hash_seed, &hash, 0);
if (hash < dx_db->min_hash)
dx_db->min_hash = hash;
if (hash > dx_db->max_hash)
dx_db->max_hash = hash;
}
#endif
/*
* If this is a directory, then mark its parent in its
* dir_info structure. If the parent field is already
* filled in, then this directory has more than one
* hard link. We assume the first link is correct,
* and ask the user if he/she wants to clear this one.
*/
if ((dot_state > 1) &&
(ext2fs_test_inode_bitmap2(ctx->inode_dir_map,
dirent->inode))) {
if (e2fsck_dir_info_get_parent(ctx, dirent->inode,
&subdir_parent)) {
cd->pctx.ino = dirent->inode;
fix_problem(ctx, PR_2_NO_DIRINFO, &cd->pctx);
goto abort_free_dict;
}
if (subdir_parent) {
cd->pctx.ino2 = subdir_parent;
if (fix_problem(ctx, PR_2_LINK_DIR,
&cd->pctx)) {
dirent->inode = 0;
dir_modified++;
goto next;
}
cd->pctx.ino2 = 0;
} else {
(void) e2fsck_dir_info_set_parent(ctx,
dirent->inode, ino);
}
}
if (dups_found) {
;
} else if (dict_lookup(&de_dict, dirent)) {
clear_problem_context(&pctx);
pctx.ino = ino;
pctx.dirent = dirent;
fix_problem(ctx, PR_2_REPORT_DUP_DIRENT, &pctx);
e2fsck_rehash_dir_later(ctx, ino);
dups_found++;
} else
dict_alloc_insert(&de_dict, dirent, dirent);
ext2fs_icount_increment(ctx->inode_count, dirent->inode,
&links);
if (links > 1)
ctx->fs_links_count++;
ctx->fs_total_count++;
next:
prev = dirent;
if (dir_modified)
(void) ext2fs_get_rec_len(fs, dirent, &rec_len);
offset += rec_len;
dot_state++;
} while (offset < fs->blocksize - de_csum_size);
#if 0
printf("\n");
#endif
#ifdef ENABLE_HTREE
if (dx_db) {
#ifdef DX_DEBUG
printf("db_block %d, type %d, min_hash 0x%0x, max_hash 0x%0x\n",
db->blockcnt, dx_db->type,
dx_db->min_hash, dx_db->max_hash);
#endif
cd->pctx.dir = cd->pctx.ino;
if ((dx_db->type == DX_DIRBLOCK_ROOT) ||
(dx_db->type == DX_DIRBLOCK_NODE))
parse_int_node(fs, db, cd, dx_dir, buf, failed_csum);
}
#endif /* ENABLE_HTREE */
if (offset != fs->blocksize - de_csum_size) {
cd->pctx.num = rec_len - (fs->blocksize - de_csum_size) +
offset;
if (fix_problem(ctx, PR_2_FINAL_RECLEN, &cd->pctx)) {
dirent->rec_len = cd->pctx.num;
dir_modified++;
}
}
if (dir_modified) {
/* leaf block with no tail? Rehash dirs later. */
if (EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
EXT4_FEATURE_RO_COMPAT_METADATA_CSUM) &&
is_leaf &&
!ext2fs_dirent_has_tail(fs, (struct ext2_dir_entry *)buf))
e2fsck_rehash_dir_later(ctx, ino);
write_and_fix:
if (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS;
cd->pctx.errcode = ext2fs_write_dir_block4(fs, block_nr, buf,
0, ino);
if (e2fsck_dir_will_be_rehashed(ctx, ino))
ctx->fs->flags &= ~EXT2_FLAG_IGNORE_CSUM_ERRORS;
if (cd->pctx.errcode) {
if (!fix_problem(ctx, PR_2_WRITE_DIRBLOCK,
&cd->pctx))
goto abort_free_dict;
}
ext2fs_mark_changed(fs);
} else if (is_leaf && failed_csum && !dir_modified) {
/*
* If a leaf node that fails csum makes it this far without
* alteration, ask the user if the checksum should be fixed.
*/
if (fix_problem(ctx, PR_2_LEAF_NODE_ONLY_CSUM_INVALID,
&cd->pctx))
goto write_and_fix;
}
dict_free_nodes(&de_dict);
return 0;
abort_free_dict:
ctx->flags |= E2F_FLAG_ABORT;
dict_free_nodes(&de_dict);
return DIRENT_ABORT;
}
errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan, ext2_ino_t *ino,
struct ext2_inode *inode, int bufsize)
{
errcode_t retval;
int extra_bytes = 0;
EXT2_CHECK_MAGIC(scan, EXT2_ET_MAGIC_INODE_SCAN);
/*
* Do we need to start reading a new block group?
*/
if (scan->inodes_left <= 0) {
force_new_group:
if (scan->done_group) {
retval = (scan->done_group)
(scan->fs, scan, scan->current_group,
scan->done_group_data);
if (retval)
return retval;
}
if (scan->groups_left <= 0) {
*ino = 0;
return 0;
}
retval = get_next_blockgroup(scan);
if (retval)
return retval;
}
/*
* These checks are done outside the above if statement so
* they can be done for block group #0.
*/
if ((scan->scan_flags & EXT2_SF_DO_LAZY) &&
(ext2fs_bg_flags_test(scan->fs, scan->current_group, EXT2_BG_INODE_UNINIT)
))
goto force_new_group;
if (scan->inodes_left == 0)
goto force_new_group;
if (scan->current_block == 0) {
if (scan->scan_flags & EXT2_SF_SKIP_MISSING_ITABLE) {
goto force_new_group;
} else
return EXT2_ET_MISSING_INODE_TABLE;
}
/*
* Have we run out of space in the inode buffer? If so, we
* need to read in more blocks.
*/
if (scan->bytes_left < scan->inode_size) {
memcpy(scan->temp_buffer, scan->ptr, scan->bytes_left);
extra_bytes = scan->bytes_left;
retval = get_next_blocks(scan);
if (retval)
return retval;
#if 0
/*
* XXX test Need check for used inode somehow.
* (Note: this is hard.)
*/
if (is_empty_scan(scan))
goto force_new_group;
#endif
}
retval = 0;
if (extra_bytes) {
memcpy(scan->temp_buffer+extra_bytes, scan->ptr,
scan->inode_size - extra_bytes);
scan->ptr += scan->inode_size - extra_bytes;
scan->bytes_left -= scan->inode_size - extra_bytes;
#ifdef WORDS_BIGENDIAN
memset(inode, 0, bufsize);
ext2fs_swap_inode_full(scan->fs,
(struct ext2_inode_large *) inode,
(struct ext2_inode_large *) scan->temp_buffer,
0, bufsize);
#else
*inode = *((struct ext2_inode *) scan->temp_buffer);
#endif
if (scan->scan_flags & EXT2_SF_BAD_EXTRA_BYTES)
retval = EXT2_ET_BAD_BLOCK_IN_INODE_TABLE;
scan->scan_flags &= ~EXT2_SF_BAD_EXTRA_BYTES;
} else {
#ifdef WORDS_BIGENDIAN
memset(inode, 0, bufsize);
ext2fs_swap_inode_full(scan->fs,
(struct ext2_inode_large *) inode,
(struct ext2_inode_large *) scan->ptr,
0, bufsize);
#else
memcpy(inode, scan->ptr, bufsize);
#endif
scan->ptr += scan->inode_size;
scan->bytes_left -= scan->inode_size;
if (scan->scan_flags & EXT2_SF_BAD_INODE_BLK)
retval = EXT2_ET_BAD_BLOCK_IN_INODE_TABLE;
}
scan->inodes_left--;
scan->current_inode++;
*ino = scan->current_inode;
return retval;
}
static void check_inode_bitmaps(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
ext2_ino_t i;
unsigned int free_inodes = 0;
int group_free = 0;
int dirs_count = 0;
int group = 0;
unsigned int inodes = 0;
ext2_ino_t *free_array;
ext2_ino_t *dir_array;
int actual, bitmap;
errcode_t retval;
struct problem_context pctx;
int problem, save_problem, fixit, had_problem;
int csum_flag;
int skip_group = 0;
int redo_flag = 0;
ext2_ino_t first_free = fs->super->s_inodes_per_group + 1;
clear_problem_context(&pctx);
free_array = (ext2_ino_t *) e2fsck_allocate_memory(ctx,
fs->group_desc_count * sizeof(ext2_ino_t), "free inode count array");
dir_array = (ext2_ino_t *) e2fsck_allocate_memory(ctx,
fs->group_desc_count * sizeof(ext2_ino_t), "directory count array");
if ((1 < ext2fs_get_inode_bitmap_start2(ctx->inode_used_map)) ||
(fs->super->s_inodes_count >
ext2fs_get_inode_bitmap_end2(ctx->inode_used_map))) {
pctx.num = 3;
pctx.blk = 1;
pctx.blk2 = fs->super->s_inodes_count;
pctx.ino = ext2fs_get_inode_bitmap_start2(ctx->inode_used_map);
pctx.ino2 = ext2fs_get_inode_bitmap_end2(ctx->inode_used_map);
fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
goto errout;
}
if ((1 < ext2fs_get_inode_bitmap_start2(fs->inode_map)) ||
(fs->super->s_inodes_count >
ext2fs_get_inode_bitmap_end2(fs->inode_map))) {
pctx.num = 4;
pctx.blk = 1;
pctx.blk2 = fs->super->s_inodes_count;
pctx.ino = ext2fs_get_inode_bitmap_start2(fs->inode_map);
pctx.ino2 = ext2fs_get_inode_bitmap_end2(fs->inode_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.ino = pctx.ino2 = 0;
if (csum_flag &&
(ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)))
skip_group++;
/* Protect loop from wrap-around if inodes_count is maxed */
for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) {
bitmap = 0;
if (skip_group &&
i % fs->super->s_inodes_per_group == 1) {
/*
* Current inode is the first inode
* in the current block group.
*/
if (ext2fs_test_inode_bitmap_range(
ctx->inode_used_map, i,
fs->super->s_inodes_per_group)) {
/*
* When the compared inodes in inodes bitmap
* are 0, count the free inode,
* skip the current block group.
*/
first_free = 1;
inodes = fs->super->s_inodes_per_group - 1;
group_free = inodes;
free_inodes += inodes;
i += inodes;
skip_group = 0;
goto do_counts;
}
}
actual = ext2fs_fast_test_inode_bitmap2(ctx->inode_used_map, i);
if (redo_flag)
bitmap = actual;
else if (!skip_group)
bitmap = ext2fs_fast_test_inode_bitmap2(fs->inode_map, i);
if (!actual == !bitmap)
goto do_counts;
if (!actual && bitmap) {
/*
* Inode wasn't used, but marked in bitmap
*/
problem = PR_5_INODE_UNUSED;
} else /* if (actual && !bitmap) */ {
/*
* Inode used, but not in bitmap
*/
problem = PR_5_INODE_USED;
/* We should never hit this, because it means that
* inodes were marked in use that weren't noticed
* in pass1 or pass 2. It is easier to fix the problem
* than to kill e2fsck and leave the user stuck. */
if (skip_group) {
struct problem_context pctx2;
pctx2.blk = i;
pctx2.group = group;
if (fix_problem(ctx, PR_5_INODE_UNINIT,&pctx2)){
ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT);
skip_group = 0;
}
}
}
if (pctx.ino == 0) {
pctx.ino = pctx.ino2 = i;
save_problem = problem;
} else {
if ((problem == save_problem) &&
(pctx.ino2 == i-1))
pctx.ino2++;
else {
print_bitmap_problem(ctx, save_problem, &pctx);
pctx.ino = pctx.ino2 = 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:
inodes++;
if (bitmap) {
if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i))
dirs_count++;
if (inodes > first_free) {
e2fsck_discard_inodes(ctx, group, first_free,
inodes - first_free);
first_free = fs->super->s_inodes_per_group + 1;
}
} else {
group_free++;
free_inodes++;
if (first_free > inodes)
first_free = inodes;
}
if ((inodes == fs->super->s_inodes_per_group) ||
(i == fs->super->s_inodes_count)) {
/*
* If the last inode is free, we can discard it as well.
*/
if (!bitmap && inodes >= first_free)
e2fsck_discard_inodes(ctx, group, first_free,
inodes - first_free + 1);
/*
* If discard zeroes data and the group inode table
* was not zeroed yet, set itable as zeroed
*/
if ((ctx->options & E2F_OPT_DISCARD) &&
io_channel_discard_zeroes_data(fs->io) &&
!(ext2fs_bg_flags_test(fs, group,
EXT2_BG_INODE_ZEROED))) {
ext2fs_bg_flags_set(fs, group,
EXT2_BG_INODE_ZEROED);
ext2fs_group_desc_csum_set(fs, group);
}
first_free = fs->super->s_inodes_per_group + 1;
free_array[group] = group_free;
dir_array[group] = dirs_count;
group ++;
inodes = 0;
skip_group = 0;
group_free = 0;
dirs_count = 0;
if (ctx->progress)
if ((ctx->progress)(ctx, 5,
group + fs->group_desc_count,
fs->group_desc_count*2))
goto errout;
if (csum_flag &&
(i != fs->super->s_inodes_count) &&
(ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)
))
skip_group++;
}
}
if (pctx.ino)
print_bitmap_problem(ctx, save_problem, &pctx);
if (had_problem)
fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP);
else
fixit = -1;
ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
if (fixit == 1) {
ext2fs_free_inode_bitmap(fs->inode_map);
retval = ext2fs_copy_bitmap(ctx->inode_used_map,
&fs->inode_map);
if (retval) {
clear_problem_context(&pctx);
fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
goto errout;
}
ext2fs_set_bitmap_padding(fs->inode_map);
ext2fs_mark_ib_dirty(fs);
/* redo counts */
inodes = 0; free_inodes = 0; group_free = 0;
dirs_count = 0; group = 0;
memset(free_array, 0, fs->group_desc_count * sizeof(int));
memset(dir_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_inodes_count(fs, i)) {
pctx.group = i;
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)) {
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] != ext2fs_bg_used_dirs_count(fs, i)) {
pctx.group = i;
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)) {
ext2fs_bg_used_dirs_count_set(fs, i, dir_array[i]);
ext2fs_mark_super_dirty(fs);
} else
ext2fs_unmark_valid(fs);
}
}
if (free_inodes != fs->super->s_free_inodes_count) {
pctx.group = -1;
pctx.ino = fs->super->s_free_inodes_count;
pctx.ino2 = free_inodes;
if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) {
fs->super->s_free_inodes_count = free_inodes;
ext2fs_mark_super_dirty(fs);
}
}
errout:
ext2fs_free_mem(&free_array);
ext2fs_free_mem(&dir_array);
}
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;
unsigned int *free_array;
dgrp_t g, 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;
problem_t problem, save_problem;
int fixit, had_problem;
errcode_t retval;
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;
char *actual_buf, *bitmap_buf;
actual_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize,
"actual bitmap buffer");
bitmap_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize,
"bitmap block buffer");
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;
}
redo_counts:
had_problem = 0;
save_problem = 0;
pctx.blk = pctx.blk2 = NO_BLK;
for (i = B2C(fs->super->s_first_data_block);
i < ext2fs_blocks_count(fs->super);
i += EXT2FS_CLUSTER_RATIO(fs)) {
int first_block_in_bg = (B2C(i) -
B2C(fs->super->s_first_data_block)) %
fs->super->s_clusters_per_group == 0;
int n, nbytes = fs->super->s_clusters_per_group / 8;
actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i);
/*
* Try to optimize pass5 by extracting a bitmap block
* as expected from what we have on disk, and then
* comparing the two. If they are identical, then
* update the free block counts and go on to the next
* block group. This is much faster than doing the
* individual bit-by-bit comparison. The one downside
* is that this doesn't work if we are asking e2fsck
* to do a discard operation.
*/
if (!first_block_in_bg ||
(group == (int)fs->group_desc_count - 1) ||
(ctx->options & E2F_OPT_DISCARD))
goto no_optimize;
retval = ext2fs_get_block_bitmap_range2(ctx->block_found_map,
B2C(i), fs->super->s_clusters_per_group,
actual_buf);
if (retval)
goto no_optimize;
retval = ext2fs_get_block_bitmap_range2(fs->block_map,
B2C(i), fs->super->s_clusters_per_group,
bitmap_buf);
if (retval)
goto no_optimize;
if (memcmp(actual_buf, bitmap_buf, nbytes) != 0)
goto no_optimize;
n = ext2fs_bitcount(actual_buf, nbytes);
group_free = fs->super->s_clusters_per_group - n;
free_blocks += group_free;
i += EXT2FS_C2B(fs, fs->super->s_clusters_per_group - 1);
goto next_group;
no_optimize:
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 (ext2fs_bg_flags_test(fs, group,
EXT2_BG_BLOCK_UNINIT)) {
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);
}
}
if (pctx.blk == NO_BLK) {
pctx.blk = pctx.blk2 = i;
save_problem = problem;
} else {
if ((problem == save_problem) &&
(pctx.blk2 == i - EXT2FS_CLUSTER_RATIO(fs)))
pctx.blk2 += EXT2FS_CLUSTER_RATIO(fs);
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);
next_group:
first_free = ext2fs_blocks_count(fs->super);
free_array[group] = group_free;
group ++;
blocks = 0;
group_free = 0;
if (ctx->progress)
if ((ctx->progress)(ctx, 5, group,
fs->group_desc_count*2))
goto errout;
}
}
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 (g = 0; g < fs->group_desc_count; g++) {
if (free_array[g] != ext2fs_bg_free_blocks_count(fs, g)) {
pctx.group = g;
pctx.blk = ext2fs_bg_free_blocks_count(fs, g);
pctx.blk2 = free_array[g];
if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
&pctx)) {
ext2fs_bg_free_blocks_count_set(fs, g, free_array[g]);
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);
ext2fs_free_mem(&actual_buf);
ext2fs_free_mem(&bitmap_buf);
}
