void do_dump(int argc, char **argv)
{
errcode_t retval;
ext2_ino_t i;
__u16 count;
if (check_icount(argv[0]))
return;
for (i=1; i <= test_fs->super->s_inodes_count; i++) {
retval = ext2fs_icount_fetch(test_icount, i, &count);
if (retval) {
com_err(argv[0], retval,
"while fetching icount for %lu", (unsigned long)i);
return;
}
if (count)
printf("%lu: %u\n", (unsigned long)i, count);
}
}
void do_fetch(int argc, char **argv)
{
const char *usage = "usage: %s inode\n";
errcode_t retval;
ext2_ino_t ino;
__u16 count;
if (argc < 2) {
printf(usage, argv[0]);
return;
}
if (check_icount(argv[0]))
return;
if (parse_inode(argv[0], "inode", argv[1], &ino))
return;
retval = ext2fs_icount_fetch(test_icount, ino, &count);
if (retval) {
com_err(argv[0], retval, "while calling ext2fs_icount_fetch");
return;
}
printf("Count is %u\n", count);
}
void e2fsck_pass4(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
ext2_ino_t i;
struct ext2_inode *inode;
#ifdef RESOURCE_TRACK
struct resource_track rtrack;
#endif
struct problem_context pctx;
__u16 link_count, link_counted;
char *buf = 0;
dgrp_t group, maxgroup;
init_resource_track(&rtrack, ctx->fs->io);
#ifdef MTRACE
mtrace_print("Pass 4");
#endif
clear_problem_context(&pctx);
if (!(ctx->options & E2F_OPT_PREEN))
fix_problem(ctx, PR_4_PASS_HEADER, &pctx);
group = 0;
maxgroup = fs->group_desc_count;
if (ctx->progress)
if ((ctx->progress)(ctx, 4, 0, maxgroup))
return;
inode = e2fsck_allocate_memory(ctx, EXT2_INODE_SIZE(fs->super),
"scratch inode");
/* Protect loop from wrap-around if s_inodes_count maxed */
for (i=1; i <= fs->super->s_inodes_count && i > 0; i++) {
int isdir;
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
goto errout;
if ((i % fs->super->s_inodes_per_group) == 0) {
group++;
if (ctx->progress)
if ((ctx->progress)(ctx, 4, group, maxgroup))
goto errout;
}
if (i == EXT2_BAD_INO ||
(i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super)))
continue;
if (!(ext2fs_test_inode_bitmap2(ctx->inode_used_map, i)) ||
(ctx->inode_imagic_map &&
ext2fs_test_inode_bitmap2(ctx->inode_imagic_map, i)) ||
(ctx->inode_bb_map &&
ext2fs_test_inode_bitmap2(ctx->inode_bb_map, i)))
continue;
ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count);
ext2fs_icount_fetch(ctx->inode_count, i, &link_counted);
if (link_counted == 0) {
if (!buf)
buf = e2fsck_allocate_memory(ctx,
fs->blocksize, "bad_inode buffer");
if (e2fsck_process_bad_inode(ctx, 0, i, buf))
continue;
if (disconnect_inode(ctx, i, inode))
continue;
ext2fs_icount_fetch(ctx->inode_link_info, i,
&link_count);
ext2fs_icount_fetch(ctx->inode_count, i,
&link_counted);
}
isdir = ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i);
if (isdir && (link_counted > EXT2_LINK_MAX))
link_counted = 1;
if (link_counted != link_count) {
e2fsck_read_inode(ctx, i, inode, "pass4");
pctx.ino = i;
pctx.inode = inode;
if ((link_count != inode->i_links_count) && !isdir &&
(inode->i_links_count <= EXT2_LINK_MAX)) {
pctx.num = link_count;
fix_problem(ctx,
PR_4_INCONSISTENT_COUNT, &pctx);
}
pctx.num = link_counted;
/* i_link_count was previously exceeded, but no longer
* is, fix this but don't consider it an error */
if ((isdir && link_counted > 1 &&
(inode->i_flags & EXT2_INDEX_FL) &&
link_count == 1 && !(ctx->options & E2F_OPT_NO)) ||
fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) {
inode->i_links_count = link_counted;
e2fsck_write_inode(ctx, i, inode, "pass4");
}
}
}
ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0;
ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0;
ext2fs_free_inode_bitmap(ctx->inode_bb_map);
ctx->inode_bb_map = 0;
ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
ctx->inode_imagic_map = 0;
errout:
if (buf)
ext2fs_free_mem(&buf);
ext2fs_free_mem(&inode);
print_resource_track(ctx, _("Pass 4"), &rtrack, ctx->fs->io);
}
int run_test(int flags, int size, char *dir, struct test_program *prog)
{
errcode_t retval;
ext2_icount_t icount;
struct test_program *pc;
__u16 result;
int problem = 0;
if (dir) {
retval = ext2fs_create_icount_tdb(test_fs, dir,
flags, &icount);
if (retval) {
com_err("run_test", retval,
"while creating icount using tdb");
exit(1);
}
} else {
retval = ext2fs_create_icount2(test_fs, flags, size, 0,
&icount);
if (retval) {
com_err("run_test", retval, "while creating icount");
exit(1);
}
}
for (pc = prog; pc->cmd != EXIT; pc++) {
switch (pc->cmd) {
case FETCH:
printf("icount_fetch(%u) = ", pc->ino);
break;
case STORE:
retval = ext2fs_icount_store(icount, pc->ino, pc->arg);
if (retval) {
com_err("run_test", retval,
"while calling icount_store");
exit(1);
}
printf("icount_store(%u, %u) = ", pc->ino, pc->arg);
break;
case INCREMENT:
retval = ext2fs_icount_increment(icount, pc->ino, 0);
if (retval) {
com_err("run_test", retval,
"while calling icount_increment");
exit(1);
}
printf("icount_increment(%u) = ", pc->ino);
break;
case DECREMENT:
retval = ext2fs_icount_decrement(icount, pc->ino, 0);
if (retval) {
com_err("run_test", retval,
"while calling icount_decrement");
exit(1);
}
printf("icount_decrement(%u) = ", pc->ino);
break;
}
retval = ext2fs_icount_fetch(icount, pc->ino, &result);
if (retval) {
com_err("run_test", retval,
"while calling icount_fetch");
exit(1);
}
printf("%u (%s)\n", result, (result == pc->expected) ?
"OK" : "NOT OK");
if (result != pc->expected)
problem++;
}
printf("icount size is %u\n", ext2fs_get_icount_size(icount));
retval = ext2fs_icount_validate(icount, stdout);
if (retval) {
com_err("run_test", retval, "while calling icount_validate");
exit(1);
}
ext2fs_free_icount(icount);
return problem;
}
void e2fsck_pass4(e2fsck_t ctx)
{
ext2_filsys fs = ctx->fs;
ext2_ino_t i;
struct ext2_inode inode;
#ifdef RESOURCE_TRACK
struct resource_track rtrack;
#endif
struct problem_context pctx;
__u16 link_count, link_counted;
char *buf = 0;
int group, maxgroup;
#ifdef RESOURCE_TRACK
init_resource_track(&rtrack);
#endif
#ifdef MTRACE
mtrace_print("Pass 4");
#endif
clear_problem_context(&pctx);
if (!(ctx->options & E2F_OPT_PREEN))
fix_problem(ctx, PR_4_PASS_HEADER, &pctx);
group = 0;
maxgroup = fs->group_desc_count;
if (ctx->progress)
if ((ctx->progress)(ctx, 4, 0, maxgroup))
return;
/* Protect loop from wrap-around if s_inodes_count maxed */
for (i=1; i <= fs->super->s_inodes_count && i > 0; i++) {
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
goto errout;
if ((i % fs->super->s_inodes_per_group) == 0) {
group++;
if (ctx->progress)
if ((ctx->progress)(ctx, 4, group, maxgroup))
goto errout;
}
if (i == EXT2_BAD_INO ||
(i > EXT2_ROOT_INO && i < EXT2_FIRST_INODE(fs->super)))
continue;
if (!(ext2fs_test_inode_bitmap(ctx->inode_used_map, i)) ||
(ctx->inode_imagic_map &&
ext2fs_test_inode_bitmap(ctx->inode_imagic_map, i)) ||
(ctx->inode_bb_map &&
ext2fs_test_inode_bitmap(ctx->inode_bb_map, i)))
continue;
ext2fs_icount_fetch(ctx->inode_link_info, i, &link_count);
ext2fs_icount_fetch(ctx->inode_count, i, &link_counted);
if (link_counted == 0) {
if (!buf)
buf = e2fsck_allocate_memory(ctx,
fs->blocksize, "bad_inode buffer");
if (e2fsck_process_bad_inode(ctx, 0, i, buf))
continue;
if (disconnect_inode(ctx, i))
continue;
ext2fs_icount_fetch(ctx->inode_link_info, i,
&link_count);
ext2fs_icount_fetch(ctx->inode_count, i,
&link_counted);
}
if (link_counted != link_count) {
e2fsck_read_inode(ctx, i, &inode, "pass4");
pctx.ino = i;
pctx.inode = &inode;
if (link_count != inode.i_links_count) {
pctx.num = link_count;
fix_problem(ctx,
PR_4_INCONSISTENT_COUNT, &pctx);
}
pctx.num = link_counted;
if (fix_problem(ctx, PR_4_BAD_REF_COUNT, &pctx)) {
inode.i_links_count = link_counted;
e2fsck_write_inode(ctx, i, &inode, "pass4");
}
}
}
ext2fs_free_icount(ctx->inode_link_info); ctx->inode_link_info = 0;
ext2fs_free_icount(ctx->inode_count); ctx->inode_count = 0;
ext2fs_free_inode_bitmap(ctx->inode_bb_map);
ctx->inode_bb_map = 0;
ext2fs_free_inode_bitmap(ctx->inode_imagic_map);
ctx->inode_imagic_map = 0;
errout:
if (buf)
ext2fs_free_mem(&buf);
#ifdef RESOURCE_TRACK
if (ctx->options & E2F_OPT_TIME2) {
e2fsck_clear_progbar(ctx);
print_resource_track(_("Pass 4"), &rtrack);
}
#endif
}
