X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Fpass5.c;h=eb3ebf02960db497d8117dca50c28b6bae94c7a2;hb=f5fa20078bfc05b554294fe9c5505375d7913e8c;hp=744aee20cd72f54433494cbddb2defa20566674b;hpb=50e1e10fa0ac12a3e2a9d20a75ee9041873cda96;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/pass5.c b/e2fsck/pass5.c index 744aee2..eb3ebf0 100644 --- a/e2fsck/pass5.c +++ b/e2fsck/pass5.c @@ -1,136 +1,231 @@ /* * pass5.c --- check block and inode bitmaps against on-disk bitmaps * - * Copyright (C) 1993, 1994 Theodore Ts'o. This file may be - * redistributed under the terms of the GNU Public License. + * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. + * + * %Begin-Header% + * This file may be redistributed under the terms of the GNU Public + * License. + * %End-Header% * */ -#include "et/com_err.h" - #include "e2fsck.h" +#include "problem.h" -static void check_block_bitmaps(ext2_filsys fs); -static void check_inode_bitmaps(ext2_filsys fs); -static void check_inode_end(ext2_filsys fs); -static void check_block_end(ext2_filsys fs); - -static int do_fix = -1; -static const char *fix_question = "Fix summary information"; +static void check_block_bitmaps(e2fsck_t ctx); +static void check_inode_bitmaps(e2fsck_t ctx); +static void check_inode_end(e2fsck_t ctx); +static void check_block_end(e2fsck_t ctx); -void pass5(ext2_filsys fs) +void e2fsck_pass5(e2fsck_t ctx) { +#ifdef RESOURCE_TRACK struct resource_track rtrack; +#endif + struct problem_context pctx; #ifdef MTRACE mtrace_print("Pass 5"); #endif +#ifdef RESOURCE_TRACK init_resource_track(&rtrack); +#endif - if (!preen) - printf("Pass 5: Checking group summary information\n"); + clear_problem_context(&pctx); + + if (!(ctx->options & E2F_OPT_PREEN)) + fix_problem(ctx, PR_5_PASS_HEADER, &pctx); - read_bitmaps(fs); + if (ctx->progress) + if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2)) + return; - check_block_bitmaps(fs); - check_inode_bitmaps(fs); - check_inode_end(fs); - check_block_end(fs); + e2fsck_read_bitmaps(ctx); + + check_block_bitmaps(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + check_inode_bitmaps(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + check_inode_end(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; + check_block_end(ctx); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) + return; - ext2fs_free_inode_bitmap(inode_used_map); - ext2fs_free_inode_bitmap(inode_dir_map); - ext2fs_free_block_bitmap(block_found_map); + ext2fs_free_inode_bitmap(ctx->inode_used_map); + ctx->inode_used_map = 0; + ext2fs_free_inode_bitmap(ctx->inode_dir_map); + ctx->inode_dir_map = 0; + ext2fs_free_block_bitmap(ctx->block_found_map); + ctx->block_found_map = 0; - if (tflag > 1) { - printf("Pass 5: "); - print_resource_track(&rtrack); +#ifdef RESOURCE_TRACK + if (ctx->options & E2F_OPT_TIME2) { + e2fsck_clear_progbar(ctx); + print_resource_track(_("Pass 5"), &rtrack); } +#endif } -static void check_block_bitmaps(ext2_filsys fs) +#define NO_BLK ((blk_t) -1) + +static void print_bitmap_problem(e2fsck_t ctx, int problem, + struct problem_context *pctx) +{ + switch (problem) { + case PR_5_BLOCK_UNUSED: + if (pctx->blk == pctx->blk2) + pctx->blk2 = 0; + else + problem = PR_5_BLOCK_RANGE_UNUSED; + break; + case PR_5_BLOCK_USED: + if (pctx->blk == pctx->blk2) + pctx->blk2 = 0; + else + problem = PR_5_BLOCK_RANGE_USED; + break; + case PR_5_INODE_UNUSED: + if (pctx->ino == pctx->ino2) + pctx->ino2 = 0; + else + problem = PR_5_INODE_RANGE_UNUSED; + break; + case PR_5_INODE_USED: + if (pctx->ino == pctx->ino2) + pctx->ino2 = 0; + else + problem = PR_5_INODE_RANGE_USED; + break; + } + fix_problem(ctx, problem, pctx); + pctx->blk = pctx->blk2 = NO_BLK; + pctx->ino = pctx->ino2 = 0; +} + +static void check_block_bitmaps(e2fsck_t ctx) { - blk_t i; + ext2_filsys fs = ctx->fs; + blk_t i, super; int *free_array; int group = 0; - int blocks = 0; - int free_blocks = 0; + unsigned int blocks = 0; + unsigned int free_blocks = 0; int group_free = 0; int actual, bitmap; - const char *print_header = "Block bitmap differences:"; + struct problem_context pctx; + int problem, save_problem, fixit, had_problem; + errcode_t retval; + int lazy_bg = 0; + int skip_group = 0; - free_array = allocate_memory(fs->group_desc_count * sizeof(int), - "free block count array"); + 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_start(block_found_map)) || + ext2fs_get_block_bitmap_start(ctx->block_found_map)) || (fs->super->s_blocks_count-1 > - ext2fs_get_block_bitmap_end(block_found_map))) { - printf("PROGRAMMING ERROR: filesystem endpoints (%d, %d)\n\t" - "don't match block_found_map endpoints (%d, %d).\n", - fs->super->s_first_data_block, - fs->super->s_blocks_count -1, - ext2fs_get_block_bitmap_start(block_found_map), - ext2fs_get_block_bitmap_end(block_found_map)); - fatal_error(0); + ext2fs_get_block_bitmap_end(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_start(ctx->block_found_map); + pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; } if ((fs->super->s_first_data_block < ext2fs_get_block_bitmap_start(fs->block_map)) || (fs->super->s_blocks_count-1 > ext2fs_get_block_bitmap_end(fs->block_map))) { - printf("PROGRAMMING ERROR: filesystem endpoints (%d, %d)\n\t" - "don't match fs->block_map endpoints (%d, %d).\n", - fs->super->s_first_data_block, - fs->super->s_blocks_count -1, - ext2fs_get_block_bitmap_start(fs->block_map), - ext2fs_get_block_bitmap_end(fs->block_map)); - fatal_error(0); + 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_start(fs->block_map); + pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; } - + if (EXT2_HAS_COMPAT_FEATURE(fs->super, + EXT2_FEATURE_COMPAT_LAZY_BG)) + lazy_bg++; + +redo_counts: + had_problem = 0; + save_problem = 0; + pctx.blk = pctx.blk2 = NO_BLK; + if (lazy_bg && (fs->group_desc[group].bg_flags & + EXT2_BG_BLOCK_UNINIT)) + skip_group++; + super = fs->super->s_first_data_block; for (i = fs->super->s_first_data_block; i < fs->super->s_blocks_count; i++) { - actual = ext2fs_fast_test_block_bitmap(block_found_map, i); - bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i); + actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i); + + if (skip_group) { + if ((i >= super) && + (i <= super + fs->desc_blocks) && + ext2fs_bg_has_super(fs, group)) + bitmap = 1; + else if (i == fs->group_desc[group].bg_block_bitmap) + bitmap = 1; + else if (i == fs->group_desc[group].bg_inode_bitmap) + bitmap = 1; + else if (i >= fs->group_desc[group].bg_inode_table && + (i < fs->group_desc[group].bg_inode_table + + fs->inode_blocks_per_group)) + bitmap = 1; + else + bitmap = 0; + actual = (actual != 0); + } else + bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i); if (actual == bitmap) goto do_counts; - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen && print_header) { - printf(print_header); - print_header = 0; - } if (!actual && bitmap) { /* * Block not used, but marked in use in the bitmap. */ - if (!preen) - printf(" -%u", i); - if (do_fix) - ext2fs_unmark_block_bitmap(fs->block_map, - i); + problem = PR_5_BLOCK_UNUSED; } else { /* * Block used, but not marked in use in the bitmap. */ - if (!preen) - printf(" +%u", i); - if (do_fix) - ext2fs_mark_block_bitmap(fs->block_map, - i); + problem = PR_5_BLOCK_USED; } - if (do_fix) { - ext2fs_mark_bb_dirty(fs); - bitmap = actual; - } else - ext2fs_unmark_valid(fs); - + 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) { + if (!bitmap && !skip_group) { group_free++; free_blocks++; } @@ -141,20 +236,55 @@ static void check_block_bitmaps(ext2_filsys fs) group ++; blocks = 0; group_free = 0; + skip_group = 0; + super += fs->super->s_blocks_per_group; + if (ctx->progress) + if ((ctx->progress)(ctx, 5, group, + fs->group_desc_count*2)) + return; + if (lazy_bg && + (i != fs->super->s_blocks_count-1) && + (fs->group_desc[group].bg_flags & + EXT2_BG_BLOCK_UNINIT)) + skip_group++; } } - if (!print_header) - printf(". %s\n", fix_msg[do_fix]); + 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; + return; + } + 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)); + 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) { - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen) - printf("Free blocks count wrong for " - "group %u (%u, counted=%d). %s\n", i, - fs->group_desc[i].bg_free_blocks_count, - free_array[i], fix_msg[do_fix]); - if (do_fix) { + 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); @@ -163,105 +293,126 @@ static void check_block_bitmaps(ext2_filsys fs) } } if (free_blocks != fs->super->s_free_blocks_count) { - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen) - printf("Free blocks count wrong " - "(%u, counted=%d). %s\n", - fs->super->s_free_blocks_count, free_blocks, - fix_msg[do_fix]); - if (do_fix) { + 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); } - free(free_array); + ext2fs_free_mem(&free_array); } -static void check_inode_bitmaps(ext2_filsys fs) +static void check_inode_bitmaps(e2fsck_t ctx) { - ino_t i; - int free_inodes = 0; - int group_free = 0; - int dirs_count = 0; - int group = 0; - int inodes = 0; - int *free_array; - int *dir_array; - int actual, bitmap; - const char *print_header = "Inode bitmap differences:"; + 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; + int *free_array; + int *dir_array; + int actual, bitmap; + errcode_t retval; + struct problem_context pctx; + int problem, save_problem, fixit, had_problem; + int lazy_bg = 0; + int skip_group = 0; - free_array = allocate_memory(fs->group_desc_count * sizeof(int), - "free inode count array"); + clear_problem_context(&pctx); + free_array = (int *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(int), "free inode count array"); - dir_array = allocate_memory(fs->group_desc_count * sizeof(int), - "directory count array"); + dir_array = (int *) e2fsck_allocate_memory(ctx, + fs->group_desc_count * sizeof(int), "directory count array"); - if ((1 < ext2fs_get_inode_bitmap_start(inode_used_map)) || + if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) || (fs->super->s_inodes_count > - ext2fs_get_inode_bitmap_end(inode_used_map))) { - printf("PROGRAMMING ERROR: filesystem inode endpoints (%d, %d)\n\t" - "don't match inode_used_map endpoints (%d, %d).\n", - 1, fs->super->s_inodes_count, - ext2fs_get_inode_bitmap_start(inode_used_map), - ext2fs_get_inode_bitmap_end(inode_used_map)); - fatal_error(0); + ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) { + pctx.num = 3; + pctx.blk = 1; + pctx.blk2 = fs->super->s_inodes_count; + pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map); + pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; } if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) || (fs->super->s_inodes_count > ext2fs_get_inode_bitmap_end(fs->inode_map))) { - printf("PROGRAMMING ERROR: filesystem inode endpoints (%d, %d)\n\t" - "don't match fs->inode_map endpoints (%d, %d).\n", - 1, fs->super->s_inodes_count, - ext2fs_get_inode_bitmap_start(fs->inode_map), - ext2fs_get_inode_bitmap_end(fs->inode_map)); - fatal_error(0); + pctx.num = 4; + pctx.blk = 1; + pctx.blk2 = fs->super->s_inodes_count; + pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map); + pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map); + fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); + + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; } + if (EXT2_HAS_COMPAT_FEATURE(fs->super, + EXT2_FEATURE_COMPAT_LAZY_BG)) + lazy_bg++; + +redo_counts: + had_problem = 0; + save_problem = 0; + pctx.ino = pctx.ino2 = 0; + if (lazy_bg && (fs->group_desc[group].bg_flags & + EXT2_BG_INODE_UNINIT)) + skip_group++; + for (i = 1; i <= fs->super->s_inodes_count; i++) { - actual = ext2fs_fast_test_inode_bitmap(inode_used_map, i); - bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i); - + actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i); + if (skip_group) + bitmap = 0; + else + bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i); if (actual == bitmap) goto do_counts; - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen && print_header) { - printf(print_header); - print_header = 0; - } if (!actual && bitmap) { /* * Inode wasn't used, but marked in bitmap */ - if (!preen) - printf(" -%lu", i); - if (do_fix) - ext2fs_unmark_inode_bitmap(fs->inode_map, i); - } else if (actual && !bitmap) { + problem = PR_5_INODE_UNUSED; + } else /* if (actual && !bitmap) */ { /* * Inode used, but not in bitmap */ - if (!preen) - printf (" +%lu", i); - if (do_fix) - ext2fs_mark_inode_bitmap(fs->inode_map, i); + problem = PR_5_INODE_USED; } - if (do_fix) { - ext2fs_mark_ib_dirty(fs); - bitmap = actual; - } else - ext2fs_unmark_valid(fs); - + 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++; + do_counts: - if (!bitmap) { + if (bitmap) { + if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i)) + dirs_count++; + } else if (!skip_group) { group_free++; free_inodes++; - } else { - if (ext2fs_test_inode_bitmap(inode_dir_map, i)) - dirs_count++; } inodes++; if ((inodes == fs->super->s_inodes_per_group) || @@ -270,23 +421,59 @@ do_counts: 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)) + return; + if (lazy_bg && + (i != fs->super->s_inodes_count) && + (fs->group_desc[group].bg_flags & + EXT2_BG_INODE_UNINIT)) + skip_group++; } } - if (!print_header) - printf(". %s\n", fix_msg[do_fix]); + 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; + return; + } + 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)); + 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_inodes_count) { - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen) - printf ("Free inodes count wrong for " - "group #%lu (%u, counted=%d). %s\n", i, - fs->group_desc[i].bg_free_inodes_count, - free_array[i], fix_msg[do_fix]); - if (do_fix) { + pctx.group = i; + pctx.ino = fs->group_desc[i].bg_free_inodes_count; + pctx.ino2 = free_array[i]; + if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP, + &pctx)) { fs->group_desc[i].bg_free_inodes_count = free_array[i]; ext2fs_mark_super_dirty(fs); @@ -294,14 +481,12 @@ do_counts: ext2fs_unmark_valid(fs); } if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) { - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen) - printf ("Directories count wrong for " - "group #%lu (%u, counted=%d). %s\n", i, - fs->group_desc[i].bg_used_dirs_count, - dir_array[i], fix_msg[do_fix]); - if (do_fix) { + pctx.group = i; + pctx.ino = fs->group_desc[i].bg_used_dirs_count; + pctx.ino2 = dir_array[i]; + + if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP, + &pctx)) { fs->group_desc[i].bg_used_dirs_count = dir_array[i]; ext2fs_mark_super_dirty(fs); @@ -310,43 +495,43 @@ do_counts: } } if (free_inodes != fs->super->s_free_inodes_count) { - if (do_fix < 0) - do_fix = ask(fix_question, 1); - if (!preen) - printf("Free inodes count wrong " - "(%u, counted=%d). %s\n", - fs->super->s_free_inodes_count, free_inodes, - fix_msg[do_fix]); - if (do_fix) { + 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); } else ext2fs_unmark_valid(fs); } - free(free_array); - free(dir_array); + ext2fs_free_mem(&free_array); + ext2fs_free_mem(&dir_array); } -static void check_inode_end(ext2_filsys fs) +static void check_inode_end(e2fsck_t ctx) { - ino_t end, save_inodes_count, i; - errcode_t retval; + ext2_filsys fs = ctx->fs; + ext2_ino_t end, save_inodes_count, i; + struct problem_context pctx; + + clear_problem_context(&pctx); end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count; - retval = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end, - &save_inodes_count); - if (retval) { - com_err("check_inode_end", retval, - "while trying to fudge end of inode bitmap"); - fatal_error(0); + pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end, + &save_inodes_count); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; } if (save_inodes_count == end) return; for (i = save_inodes_count + 1; i <= end; i++) { if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { - printf("Padding at end of inode bitmap is not set. "); - if (ask("Fix", 1)) { + if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { for (i = save_inodes_count + 1; i <= end; i++) ext2fs_mark_inode_bitmap(fs->inode_map, i); @@ -357,38 +542,41 @@ static void check_inode_end(ext2_filsys fs) } } - retval = ext2fs_fudge_inode_bitmap_end(fs->inode_map, - save_inodes_count, 0); - if (retval) { - com_err("check_inode_end", retval, - "while trying to fudge end of inode bitmap back"); - fatal_error(0); + pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, + save_inodes_count, 0); + if (pctx.errcode) { + pctx.num = 2; + fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; /* fatal */ + return; } } -static void check_block_end(ext2_filsys fs) +static void check_block_end(e2fsck_t ctx) { + ext2_filsys fs = ctx->fs; blk_t end, save_blocks_count, i; - errcode_t retval; + struct problem_context pctx; + + clear_problem_context(&pctx); end = fs->block_map->start + (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1; - retval = ext2fs_fudge_block_bitmap_end(fs->block_map, end, - &save_blocks_count); - if (retval) { - com_err("check_block_end", retval, - "while trying to fudge end of block bitmap"); - fatal_error(0); + pctx.errcode = ext2fs_fudge_block_bitmap_end(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; for (i = save_blocks_count + 1; i <= end; i++) { if (!ext2fs_test_block_bitmap(fs->block_map, i)) { - printf("Padding at end of block bitmap is not set. "); - - if (ask("Fix", 1)) { - for (i = save_blocks_count + 1; i < end; i++) + if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) { + for (i = save_blocks_count + 1; i <= end; i++) ext2fs_mark_block_bitmap(fs->block_map, i); ext2fs_mark_bb_dirty(fs); @@ -398,12 +586,15 @@ static void check_block_end(ext2_filsys fs) } } - retval = ext2fs_fudge_block_bitmap_end(fs->block_map, - save_blocks_count, 0); - if (retval) { - com_err("check_block_end", retval, - "while trying to fudge end of block bitmap back"); - fatal_error(0); + pctx.errcode = ext2fs_fudge_block_bitmap_end(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; } } + +