2 * pass5.c --- check block and inode bitmaps against on-disk bitmaps
4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o.
7 * This file may be redistributed under the terms of the GNU Public
16 static void check_block_bitmaps(e2fsck_t ctx);
17 static void check_inode_bitmaps(e2fsck_t ctx);
18 static void check_inode_end(e2fsck_t ctx);
19 static void check_block_end(e2fsck_t ctx);
21 void e2fsck_pass5(e2fsck_t ctx)
24 struct resource_track rtrack;
26 struct problem_context pctx;
29 mtrace_print("Pass 5");
33 init_resource_track(&rtrack, ctx->fs->io);
36 clear_problem_context(&pctx);
38 if (!(ctx->options & E2F_OPT_PREEN))
39 fix_problem(ctx, PR_5_PASS_HEADER, &pctx);
42 if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2))
45 e2fsck_read_bitmaps(ctx);
47 check_block_bitmaps(ctx);
48 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
50 check_inode_bitmaps(ctx);
51 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
54 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
57 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
60 ext2fs_free_inode_bitmap(ctx->inode_used_map);
61 ctx->inode_used_map = 0;
62 ext2fs_free_inode_bitmap(ctx->inode_dir_map);
63 ctx->inode_dir_map = 0;
64 ext2fs_free_block_bitmap(ctx->block_found_map);
65 ctx->block_found_map = 0;
68 if (ctx->options & E2F_OPT_TIME2) {
69 e2fsck_clear_progbar(ctx);
70 print_resource_track(_("Pass 5"), &rtrack, ctx->fs->io);
75 #define NO_BLK ((blk_t) -1)
77 static void print_bitmap_problem(e2fsck_t ctx, int problem,
78 struct problem_context *pctx)
81 case PR_5_BLOCK_UNUSED:
82 if (pctx->blk == pctx->blk2)
85 problem = PR_5_BLOCK_RANGE_UNUSED;
88 if (pctx->blk == pctx->blk2)
91 problem = PR_5_BLOCK_RANGE_USED;
93 case PR_5_INODE_UNUSED:
94 if (pctx->ino == pctx->ino2)
97 problem = PR_5_INODE_RANGE_UNUSED;
100 if (pctx->ino == pctx->ino2)
103 problem = PR_5_INODE_RANGE_USED;
106 fix_problem(ctx, problem, pctx);
107 pctx->blk = pctx->blk2 = NO_BLK;
108 pctx->ino = pctx->ino2 = 0;
111 static void check_block_bitmaps(e2fsck_t ctx)
113 ext2_filsys fs = ctx->fs;
118 blk_t free_blocks = 0;
121 struct problem_context pctx;
122 int problem, save_problem, fixit, had_problem;
127 clear_problem_context(&pctx);
128 free_array = (int *) e2fsck_allocate_memory(ctx,
129 fs->group_desc_count * sizeof(int), "free block count array");
131 if ((fs->super->s_first_data_block <
132 ext2fs_get_block_bitmap_start(ctx->block_found_map)) ||
133 (fs->super->s_blocks_count-1 >
134 ext2fs_get_block_bitmap_end(ctx->block_found_map))) {
136 pctx.blk = fs->super->s_first_data_block;
137 pctx.blk2 = fs->super->s_blocks_count -1;
138 pctx.ino = ext2fs_get_block_bitmap_start(ctx->block_found_map);
139 pctx.ino2 = ext2fs_get_block_bitmap_end(ctx->block_found_map);
140 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
142 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
146 if ((fs->super->s_first_data_block <
147 ext2fs_get_block_bitmap_start(fs->block_map)) ||
148 (fs->super->s_blocks_count-1 >
149 ext2fs_get_block_bitmap_end(fs->block_map))) {
151 pctx.blk = fs->super->s_first_data_block;
152 pctx.blk2 = fs->super->s_blocks_count -1;
153 pctx.ino = ext2fs_get_block_bitmap_start(fs->block_map);
154 pctx.ino2 = ext2fs_get_block_bitmap_end(fs->block_map);
155 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
157 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
161 csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
162 EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
166 pctx.blk = pctx.blk2 = NO_BLK;
168 (fs->group_desc[group].bg_flags & EXT2_BG_BLOCK_UNINIT))
170 super = fs->super->s_first_data_block;
171 for (i = fs->super->s_first_data_block;
172 i < fs->super->s_blocks_count;
174 actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i);
177 blk_t super_blk, old_desc_blk, new_desc_blk;
180 ext2fs_super_and_bgd_loc(fs, group, &super_blk,
181 &old_desc_blk, &new_desc_blk, 0);
183 if (fs->super->s_feature_incompat &
184 EXT2_FEATURE_INCOMPAT_META_BG)
185 old_desc_blocks = fs->super->s_first_meta_bg;
187 old_desc_blocks = fs->desc_blocks +
188 fs->super->s_reserved_gdt_blocks;
193 if (old_desc_blk && old_desc_blocks &&
194 (i >= old_desc_blk) &&
195 (i < old_desc_blk + old_desc_blocks))
200 if (i == fs->group_desc[group].bg_block_bitmap)
202 else if (i == fs->group_desc[group].bg_inode_bitmap)
204 else if (i >= fs->group_desc[group].bg_inode_table &&
205 (i < fs->group_desc[group].bg_inode_table
206 + fs->inode_blocks_per_group))
208 actual = (actual != 0);
210 bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i);
212 if (actual == bitmap)
215 if (!actual && bitmap) {
217 * Block not used, but marked in use in the bitmap.
219 problem = PR_5_BLOCK_UNUSED;
222 * Block used, but not marked in use in the bitmap.
224 problem = PR_5_BLOCK_USED;
227 struct problem_context pctx2;
230 if (fix_problem(ctx, PR_5_BLOCK_UNINIT,&pctx2)){
231 fs->group_desc[group].bg_flags &=
232 ~EXT2_BG_BLOCK_UNINIT;
237 if (pctx.blk == NO_BLK) {
238 pctx.blk = pctx.blk2 = i;
239 save_problem = problem;
241 if ((problem == save_problem) &&
245 print_bitmap_problem(ctx, save_problem, &pctx);
246 pctx.blk = pctx.blk2 = i;
247 save_problem = problem;
250 ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
254 if (!bitmap && (!skip_group || csum_flag)) {
259 if ((blocks == fs->super->s_blocks_per_group) ||
260 (i == fs->super->s_blocks_count-1)) {
261 free_array[group] = group_free;
266 super += fs->super->s_blocks_per_group;
268 if ((ctx->progress)(ctx, 5, group,
269 fs->group_desc_count*2))
272 (i != fs->super->s_blocks_count-1) &&
273 (fs->group_desc[group].bg_flags &
274 EXT2_BG_BLOCK_UNINIT))
278 if (pctx.blk != NO_BLK)
279 print_bitmap_problem(ctx, save_problem, &pctx);
281 fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
284 ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
287 ext2fs_free_block_bitmap(fs->block_map);
288 retval = ext2fs_copy_bitmap(ctx->block_found_map,
291 clear_problem_context(&pctx);
292 fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
293 ctx->flags |= E2F_FLAG_ABORT;
296 ext2fs_set_bitmap_padding(fs->block_map);
297 ext2fs_mark_bb_dirty(fs);
299 /* Redo the counts */
300 blocks = 0; free_blocks = 0; group_free = 0; group = 0;
301 memset(free_array, 0, fs->group_desc_count * sizeof(int));
303 } else if (fixit == 0)
304 ext2fs_unmark_valid(fs);
306 for (i = 0; i < fs->group_desc_count; i++) {
307 if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) {
309 pctx.blk = fs->group_desc[i].bg_free_blocks_count;
310 pctx.blk2 = free_array[i];
312 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
314 fs->group_desc[i].bg_free_blocks_count =
316 ext2fs_mark_super_dirty(fs);
318 ext2fs_unmark_valid(fs);
321 if (free_blocks != fs->super->s_free_blocks_count) {
323 pctx.blk = fs->super->s_free_blocks_count;
324 pctx.blk2 = free_blocks;
326 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
327 fs->super->s_free_blocks_count = free_blocks;
328 ext2fs_mark_super_dirty(fs);
330 ext2fs_unmark_valid(fs);
333 ext2fs_free_mem(&free_array);
336 static void check_inode_bitmaps(e2fsck_t ctx)
338 ext2_filsys fs = ctx->fs;
340 unsigned int free_inodes = 0;
344 unsigned int inodes = 0;
349 struct problem_context pctx;
350 int problem, save_problem, fixit, had_problem;
354 clear_problem_context(&pctx);
355 free_array = (int *) e2fsck_allocate_memory(ctx,
356 fs->group_desc_count * sizeof(int), "free inode count array");
358 dir_array = (int *) e2fsck_allocate_memory(ctx,
359 fs->group_desc_count * sizeof(int), "directory count array");
361 if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) ||
362 (fs->super->s_inodes_count >
363 ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) {
366 pctx.blk2 = fs->super->s_inodes_count;
367 pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map);
368 pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map);
369 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
371 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
374 if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) ||
375 (fs->super->s_inodes_count >
376 ext2fs_get_inode_bitmap_end(fs->inode_map))) {
379 pctx.blk2 = fs->super->s_inodes_count;
380 pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map);
381 pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map);
382 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
384 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
388 csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
389 EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
393 pctx.ino = pctx.ino2 = 0;
395 (fs->group_desc[group].bg_flags & EXT2_BG_INODE_UNINIT))
398 /* Protect loop from wrap-around if inodes_count is maxed */
399 for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) {
400 actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i);
404 bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i);
405 if (actual == bitmap)
408 if (!actual && bitmap) {
410 * Inode wasn't used, but marked in bitmap
412 problem = PR_5_INODE_UNUSED;
413 } else /* if (actual && !bitmap) */ {
415 * Inode used, but not in bitmap
417 problem = PR_5_INODE_USED;
419 /* We should never hit this, because it means that
420 * inodes were marked in use that weren't noticed
421 * in pass1 or pass 2. It is easier to fix the problem
422 * than to kill e2fsck and leave the user stuck. */
424 struct problem_context pctx2;
427 if (fix_problem(ctx, PR_5_INODE_UNINIT,&pctx2)){
428 fs->group_desc[group].bg_flags &=
429 ~EXT2_BG_INODE_UNINIT;
435 pctx.ino = pctx.ino2 = i;
436 save_problem = problem;
438 if ((problem == save_problem) &&
442 print_bitmap_problem(ctx, save_problem, &pctx);
443 pctx.ino = pctx.ino2 = i;
444 save_problem = problem;
447 ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
452 if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i))
454 } else if (!skip_group || csum_flag) {
459 if ((inodes == fs->super->s_inodes_per_group) ||
460 (i == fs->super->s_inodes_count)) {
461 free_array[group] = group_free;
462 dir_array[group] = dirs_count;
469 if ((ctx->progress)(ctx, 5,
470 group + fs->group_desc_count,
471 fs->group_desc_count*2))
474 (i != fs->super->s_inodes_count) &&
475 (fs->group_desc[group].bg_flags &
476 EXT2_BG_INODE_UNINIT))
481 print_bitmap_problem(ctx, save_problem, &pctx);
484 fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP);
487 ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
490 ext2fs_free_inode_bitmap(fs->inode_map);
491 retval = ext2fs_copy_bitmap(ctx->inode_used_map,
494 clear_problem_context(&pctx);
495 fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx);
496 ctx->flags |= E2F_FLAG_ABORT;
499 ext2fs_set_bitmap_padding(fs->inode_map);
500 ext2fs_mark_ib_dirty(fs);
503 inodes = 0; free_inodes = 0; group_free = 0;
504 dirs_count = 0; group = 0;
505 memset(free_array, 0, fs->group_desc_count * sizeof(int));
506 memset(dir_array, 0, fs->group_desc_count * sizeof(int));
508 } else if (fixit == 0)
509 ext2fs_unmark_valid(fs);
511 for (i = 0; i < fs->group_desc_count; i++) {
512 if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) {
514 pctx.ino = fs->group_desc[i].bg_free_inodes_count;
515 pctx.ino2 = free_array[i];
516 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP,
518 fs->group_desc[i].bg_free_inodes_count =
520 ext2fs_mark_super_dirty(fs);
522 ext2fs_unmark_valid(fs);
524 if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) {
526 pctx.ino = fs->group_desc[i].bg_used_dirs_count;
527 pctx.ino2 = dir_array[i];
529 if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP,
531 fs->group_desc[i].bg_used_dirs_count =
533 ext2fs_mark_super_dirty(fs);
535 ext2fs_unmark_valid(fs);
538 if (free_inodes != fs->super->s_free_inodes_count) {
540 pctx.ino = fs->super->s_free_inodes_count;
541 pctx.ino2 = free_inodes;
543 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) {
544 fs->super->s_free_inodes_count = free_inodes;
545 ext2fs_mark_super_dirty(fs);
547 ext2fs_unmark_valid(fs);
550 ext2fs_free_mem(&free_array);
551 ext2fs_free_mem(&dir_array);
554 static void check_inode_end(e2fsck_t ctx)
556 ext2_filsys fs = ctx->fs;
557 ext2_ino_t end, save_inodes_count, i;
558 struct problem_context pctx;
560 clear_problem_context(&pctx);
562 end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
563 pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end,
567 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
568 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
571 if (save_inodes_count == end)
574 /* protect loop from wrap-around if end is maxed */
575 for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) {
576 if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) {
577 if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) {
578 for (i = save_inodes_count + 1; i <= end; i++)
579 ext2fs_mark_inode_bitmap(fs->inode_map,
581 ext2fs_mark_ib_dirty(fs);
583 ext2fs_unmark_valid(fs);
588 pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map,
589 save_inodes_count, 0);
592 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
593 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
598 static void check_block_end(e2fsck_t ctx)
600 ext2_filsys fs = ctx->fs;
601 blk_t end, save_blocks_count, i;
602 struct problem_context pctx;
604 clear_problem_context(&pctx);
606 end = ext2fs_get_block_bitmap_start(fs->block_map) +
607 (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
608 pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end,
612 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
613 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
616 if (save_blocks_count == end)
619 /* Protect loop from wrap-around if end is maxed */
620 for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) {
621 if (!ext2fs_test_block_bitmap(fs->block_map, i)) {
622 if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
623 for (i = save_blocks_count + 1; i <= end; i++)
624 ext2fs_mark_block_bitmap(fs->block_map,
626 ext2fs_mark_bb_dirty(fs);
628 ext2fs_unmark_valid(fs);
633 pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map,
634 save_blocks_count, 0);
637 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
638 ctx->flags |= E2F_FLAG_ABORT; /* fatal */