static int process_block(ext2_filsys fs, blk64_t *block_nr,
e2_blkcnt_t blockcnt, blk64_t ref_block,
int ref_offset, void *priv_data)
{
struct process_block_struct *pb;
errcode_t retval;
int ret;
blk64_t block, orig;
pb = (struct process_block_struct *) priv_data;
block = orig = *block_nr;
ret = 0;
/*
* Let's see if this is one which we need to relocate
*/
if (ext2fs_test_block_bitmap2(pb->reserve, block)) {
do {
if (++block >= ext2fs_blocks_count(fs->super))
block = fs->super->s_first_data_block;
if (block == orig) {
pb->error = EXT2_ET_BLOCK_ALLOC_FAIL;
return BLOCK_ABORT;
}
} while (ext2fs_test_block_bitmap2(pb->reserve, block) ||
ext2fs_test_block_bitmap2(pb->alloc_map, block));
retval = io_channel_read_blk64(fs->io, orig, 1, pb->buf);
if (retval) {
pb->error = retval;
return BLOCK_ABORT;
}
retval = io_channel_write_blk64(fs->io, block, 1, pb->buf);
if (retval) {
pb->error = retval;
return BLOCK_ABORT;
}
*block_nr = block;
ext2fs_mark_block_bitmap2(pb->alloc_map, block);
ret = BLOCK_CHANGED;
if (pb->flags & EXT2_BMOVE_DEBUG)
printf("ino=%u, blockcnt=%lld, %llu->%llu\n",
(unsigned) pb->ino, blockcnt,
(unsigned long long) orig,
(unsigned long long) block);
}
if (pb->add_dir) {
retval = ext2fs_add_dir_block2(fs->dblist, pb->ino,
block, blockcnt);
if (retval) {
pb->error = retval;
ret |= BLOCK_ABORT;
}
}
return ret;
}
/*
* Helper function used by fix_directory.
*
* XXX need to finish this. General approach is to use bmap to
* iterate over all of the logical blocks using the bmap function, and
* copy the block reference as necessary. Big question --- what do
* about error recovery?
*
* Also question --- how to free the indirect blocks.
*/
int empty_pass1(ext2_filsys fs, blk64_t *block_nr, e2_blkcnt_t blockcnt,
blk64_t ref_block, int ref_offset, void *priv_data)
{
empty_dir_info edi = (empty_dir_info) priv_data;
blk64_t block, new_block;
errcode_t retval;
if (blockcnt < 0)
return 0;
block = *block_nr;
do {
retval = ext2fs_bmap2(fs, edi->ino, &edi->inode,
edi->block_buf, 0, edi->logblk, 0,
&new_block);
if (retval)
return DIRENT_ABORT; /* XXX what to do? */
if (new_block == 0)
break;
edi->logblk++;
} while (ext2fs_test_block_bitmap2(edi->empty_dir_blocks, new_block));
if (new_block == block)
return 0;
if (new_block == 0)
edi->freed_blocks++;
*block_nr = new_block;
return BLOCK_CHANGED;
}
void do_dump_unused(int argc EXT2FS_ATTR((unused)), char **argv)
{
blk64_t blk;
unsigned char buf[EXT2_MAX_BLOCK_SIZE];
unsigned int i;
errcode_t retval;
if (common_args_process(argc, argv, 1, 1,
"dump_unused", "", 0))
return;
for (blk=current_fs->super->s_first_data_block;
blk < ext2fs_blocks_count(current_fs->super); blk++) {
if (ext2fs_test_block_bitmap2(current_fs->block_map,blk))
continue;
retval = io_channel_read_blk64(current_fs->io, blk, 1, buf);
if (retval) {
com_err(argv[0], retval, "While reading block\n");
return;
}
for (i=0; i < current_fs->blocksize; i++)
if (buf[i])
break;
if (i >= current_fs->blocksize)
continue;
printf("\nUnused block %llu contains non-zero data:\n\n",
blk);
for (i=0; i < current_fs->blocksize; i++)
fputc(buf[i], stdout);
}
}
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");
}
static int set_bad_block_proc(ext2_filsys fs, blk_t *block_nr,
e2_blkcnt_t blockcnt,
blk_t ref_block EXT2FS_ATTR((unused)),
int ref_offset EXT2FS_ATTR((unused)),
void *priv_data)
{
struct set_badblock_record *rec = (struct set_badblock_record *)
priv_data;
errcode_t retval;
blk_t blk;
if (blockcnt >= 0) {
/*
* Get the next bad block.
*/
if (!ext2fs_badblocks_list_iterate(rec->bb_iter, &blk))
return BLOCK_ABORT;
rec->bad_block_count++;
} else {
/*
* An indirect block; fetch a block from the
* previously used indirect block list. The block
* most be not marked as used; if so, get another one.
* If we run out of reserved indirect blocks, allocate
* a new one.
*/
retry:
if (rec->ind_blocks_ptr < rec->ind_blocks_size) {
blk = rec->ind_blocks[rec->ind_blocks_ptr++];
if (ext2fs_test_block_bitmap2(fs->block_map, blk))
goto retry;
} else {
retval = ext2fs_new_block(fs, 0, 0, &blk);
if (retval) {
rec->err = retval;
return BLOCK_ABORT;
}
}
retval = io_channel_write_blk(fs->io, blk, 1, rec->block_buf);
if (retval) {
rec->err = retval;
return BLOCK_ABORT;
}
}
/*
* Update block counts
*/
ext2fs_block_alloc_stats(fs, blk, +1);
*block_nr = blk;
return BLOCK_CHANGED;
}
/*
* Verify the touched map
*/
static void check_map(void)
{
int i, j, first=1;
blk64_t blk;
for (i=0; test_vec[i]; i++) {
if (ext2fs_test_block_bitmap2(touched_map, test_vec[i])) {
printf("Bad block was touched --- %llu\n", test_vec[i]);
failed++;
first_no_comma = 1;
}
ext2fs_mark_block_bitmap2(touched_map, test_vec[i]);
}
for (i = 0; i < test_fs->group_desc_count; i++) {
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) &&
!ext2fs_test_block_bitmap2(bad_block_map, blk)) {
printf("Missing block --- %llu\n", blk);
failed++;
}
}
}
printf("Bad inodes: ");
for (i=1; i <= test_fs->super->s_inodes_count; i++) {
if (ext2fs_test_inode_bitmap2(bad_inode_map, i)) {
if (first)
first = 0;
else
printf(", ");
printf("%u", i);
}
}
printf("\n");
}
static void check_block_end(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
blk64_t end, save_blocks_count, i;
struct problem_context pctx;
clear_problem_context(&pctx);
end = ext2fs_get_block_bitmap_start2(fs->block_map) +
((blk64_t)EXT2_CLUSTERS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map, end,
&save_blocks_count);
if (pctx.errcode) {
pctx.num = 3;
fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
return;
}
if (save_blocks_count == end)
return;
/* Protect loop from wrap-around if end is maxed */
for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) {
if (!ext2fs_test_block_bitmap2(fs->block_map,
EXT2FS_C2B(fs, i))) {
if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
for (; i <= end; i++)
ext2fs_mark_block_bitmap2(fs->block_map,
EXT2FS_C2B(fs, i));
ext2fs_mark_bb_dirty(fs);
} else
ext2fs_unmark_valid(fs);
break;
}
}
pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map,
save_blocks_count, 0);
if (pctx.errcode) {
pctx.num = 4;
fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT; /* fatal */
return;
}
}
errcode_t ext2fs_convert_subcluster_bitmap(ext2_filsys fs,
ext2fs_block_bitmap *bitmap)
{
ext2fs_block_bitmap cmap, bmap;
errcode_t retval;
blk64_t i, b_end, c_end;
int n, ratio;
bmap = *bitmap;
if (fs->cluster_ratio_bits == ext2fs_get_bitmap_granularity(bmap))
return 0; /* Nothing to do */
retval = ext2fs_allocate_block_bitmap(fs, "converted cluster bitmap",
&cmap);
if (retval)
return retval;
i = bmap->start;
b_end = bmap->end;
bmap->end = bmap->real_end;
c_end = cmap->end;
cmap->end = cmap->real_end;
n = 0;
ratio = 1 << fs->cluster_ratio_bits;
while (i < bmap->real_end) {
if (ext2fs_test_block_bitmap2(bmap, i)) {
ext2fs_mark_block_bitmap2(cmap, i);
i += ratio - n;
n = 0;
continue;
}
i++; n++;
if (n >= ratio)
n = 0;
}
bmap->end = b_end;
cmap->end = c_end;
ext2fs_free_block_bitmap(bmap);
*bitmap = cmap;
return 0;
}
static void iscan_test_read_blk64(unsigned long long block, int count, errcode_t err)
{
int i;
if (first_no_comma)
first_no_comma = 0;
else
printf(", ");
if (count > 1)
printf("%llu-%llu", block, block+count-1);
else
printf("%llu", block);
for (i=0; i < count; i++, block++) {
if (ext2fs_test_block_bitmap2(touched_map, block)) {
printf("\nDuplicate block?!? --- %llu\n", block);
failed++;
first_no_comma = 1;
}
ext2fs_mark_block_bitmap2(touched_map, block);
}
}
void do_clearb(int argc, char *argv[])
{
unsigned int block, num;
int err;
int test_result, op_result;
if (check_fs_open(argv[0]))
return;
if (argc != 2 && argc != 3) {
com_err(argv[0], 0, "Usage: clearb <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;
ext2fs_unmark_block_bitmap_range2(test_fs->block_map,
block, num);
printf("Clearing blocks %u to %u\n", block, block + num - 1);
return;
}
test_result = ext2fs_test_block_bitmap2(test_fs->block_map, block);
op_result = ext2fs_unmark_block_bitmap2(test_fs->block_map, block);
printf("Clearing block %u, was %s before\n", block, op_result ?
"set" : "clear");
if (!test_result != !op_result)
com_err(argv[0], 0, "*ERROR* test_result different! (%d, %d)",
test_result, op_result);
}
static errcode_t undo_write_tdb(io_channel channel,
unsigned long long block, int count)
{
int size, sz;
unsigned long long block_num, backing_blk_num;
errcode_t retval = 0;
ext2_loff_t offset;
struct undo_private_data *data;
unsigned char *read_ptr;
unsigned long long end_block;
unsigned long long data_size;
void *data_ptr;
struct undo_key *key;
__u32 blk_crc;
data = (struct undo_private_data *) channel->private_data;
if (data->undo_file == NULL) {
/*
* Transaction database not initialized
*/
return 0;
}
if (count == 1)
size = channel->block_size;
else {
if (count < 0)
size = -count;
else
size = count * channel->block_size;
}
retval = undo_setup_tdb(data);
if (retval)
return retval;
/*
* Data is stored in tdb database as blocks of tdb_data_size size
* This helps in efficient lookup further.
*
* We divide the disk to blocks of tdb_data_size.
*/
offset = (block * channel->block_size) + data->offset ;
block_num = offset / data->tdb_data_size;
end_block = (offset + size - 1) / data->tdb_data_size;
while (block_num <= end_block) {
__u32 keysz;
/*
* Check if we have the record already
*/
if (ext2fs_test_block_bitmap2(data->written_block_map,
block_num)) {
/* Try the next block */
block_num++;
continue;
}
ext2fs_mark_block_bitmap2(data->written_block_map, block_num);
/*
* Read one block using the backing I/O manager
* The backing I/O manager block size may be
* different from the tdb_data_size.
* Also we need to recalcuate the block number with respect
* to the backing I/O manager.
*/
offset = block_num * data->tdb_data_size;
backing_blk_num = (offset - data->offset) / channel->block_size;
count = data->tdb_data_size +
((offset - data->offset) % channel->block_size);
retval = ext2fs_get_mem(count, &read_ptr);
if (retval) {
return retval;
}
memset(read_ptr, 0, count);
actual_size = 0;
if ((count % channel->block_size) == 0)
sz = count / channel->block_size;
else
sz = -count;
retval = io_channel_read_blk64(data->real, backing_blk_num,
sz, read_ptr);
if (retval) {
if (retval != EXT2_ET_SHORT_READ) {
free(read_ptr);
return retval;
}
/*
* short read so update the record size
* accordingly
*/
data_size = actual_size;
} else {
data_size = data->tdb_data_size;
}
if (data_size == 0) {
free(read_ptr);
block_num++;
continue;
}
dbg_printf("Read %llu bytes from FS block %llu (blk=%llu cnt=%u)\n",
data_size, backing_blk_num, block, count);
if ((data_size % data->undo_file->block_size) == 0)
sz = data_size / data->undo_file->block_size;
else
sz = -actual_size;
data_ptr = read_ptr + ((offset - data->offset) %
data->undo_file->block_size);
/* extend this key? */
if (data->keys_in_block) {
key = data->keyb->keys + data->keys_in_block - 1;
keysz = ext2fs_le32_to_cpu(key->size);
} else {
key = NULL;
keysz = 0;
}
if (key != NULL &&
ext2fs_le64_to_cpu(key->fsblk) +
((keysz + data->tdb_data_size - 1) /
data->tdb_data_size) == backing_blk_num &&
E2UNDO_MAX_EXTENT_BLOCKS * data->tdb_data_size >
keysz + sz) {
blk_crc = ext2fs_le32_to_cpu(key->blk_crc);
blk_crc = ext2fs_crc32c_le(blk_crc,
(unsigned char *)data_ptr,
data_size);
key->blk_crc = ext2fs_cpu_to_le32(blk_crc);
key->size = ext2fs_cpu_to_le32(keysz + data_size);
} else {
data->num_keys++;
key = data->keyb->keys + data->keys_in_block;
data->keys_in_block++;
key->fsblk = ext2fs_cpu_to_le64(backing_blk_num);
blk_crc = ext2fs_crc32c_le(~0,
(unsigned char *)data_ptr,
data_size);
key->blk_crc = ext2fs_cpu_to_le32(blk_crc);
key->size = ext2fs_cpu_to_le32(data_size);
}
dbg_printf("Writing block %llu to offset %llu size %d key %zu\n",
block_num,
data->undo_blk_num,
sz, data->num_keys - 1);
retval = io_channel_write_blk64(data->undo_file,
data->undo_blk_num, sz, data_ptr);
if (retval) {
free(read_ptr);
return retval;
}
data->undo_blk_num++;
free(read_ptr);
/* Write out the key block */
retval = write_undo_indexes(data, 0);
if (retval)
return retval;
/* Next block */
block_num++;
}
return retval;
}
/*
* This routine sanity checks the group descriptors
*/
errcode_t ext2fs_check_desc(ext2_filsys fs)
{
ext2fs_block_bitmap bmap;
errcode_t retval;
dgrp_t i;
blk_t first_block = fs->super->s_first_data_block;
blk_t last_block = fs->super->s_blocks_count-1;
blk_t blk, b;
int j;
EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
retval = ext2fs_allocate_block_bitmap(fs, "check_desc map", &bmap);
if (retval)
return retval;
for (i = 0; i < fs->group_desc_count; i++)
ext2fs_reserve_super_and_bgd(fs, i, bmap);
for (i = 0; i < fs->group_desc_count; i++) {
if (!EXT2_HAS_INCOMPAT_FEATURE(fs->super,
EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
first_block = ext2fs_group_first_block(fs, i);
last_block = ext2fs_group_last_block(fs, i);
if (i == (fs->group_desc_count - 1))
last_block = fs->super->s_blocks_count-1;
}
/*
* Check to make sure the block bitmap for group is sane
*/
blk = fs->group_desc[i].bg_block_bitmap;
if (blk < first_block || blk > last_block ||
ext2fs_test_block_bitmap2(bmap, blk)) {
retval = EXT2_ET_GDESC_BAD_BLOCK_MAP;
goto errout;
}
ext2fs_mark_block_bitmap2(bmap, blk);
/*
* Check to make sure the inode bitmap for group is sane
*/
blk = fs->group_desc[i].bg_inode_bitmap;
if (blk < first_block || blk > last_block ||
ext2fs_test_block_bitmap2(bmap, blk)) {
retval = EXT2_ET_GDESC_BAD_INODE_MAP;
goto errout;
}
ext2fs_mark_block_bitmap2(bmap, blk);
/*
* Check to make sure the inode table for group is sane
*/
blk = fs->group_desc[i].bg_inode_table;
if (blk < first_block ||
((blk + fs->inode_blocks_per_group - 1) > last_block)) {
retval = EXT2_ET_GDESC_BAD_INODE_TABLE;
goto errout;
}
for (j = 0, b = blk; j < fs->inode_blocks_per_group;
j++, b++) {
if (ext2fs_test_block_bitmap2(bmap, b)) {
retval = EXT2_ET_GDESC_BAD_INODE_TABLE;
goto errout;
}
ext2fs_mark_block_bitmap2(bmap, b);
}
}
errout:
ext2fs_free_block_bitmap(bmap);
return retval;
}
