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");
32 init_resource_track(&rtrack, ctx->fs->io);
33 clear_problem_context(&pctx);
35 if (!(ctx->options & E2F_OPT_PREEN))
36 fix_problem(ctx, PR_5_PASS_HEADER, &pctx);
39 if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2))
42 e2fsck_read_bitmaps(ctx);
44 check_block_bitmaps(ctx);
45 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
47 check_inode_bitmaps(ctx);
48 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
51 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
54 if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
57 ext2fs_free_inode_bitmap(ctx->inode_used_map);
58 ctx->inode_used_map = 0;
59 ext2fs_free_inode_bitmap(ctx->inode_dir_map);
60 ctx->inode_dir_map = 0;
61 ext2fs_free_block_bitmap(ctx->block_found_map);
62 ctx->block_found_map = 0;
64 print_resource_track(ctx, _("Pass 5"), &rtrack, ctx->fs->io);
67 #define NO_BLK ((blk64_t) -1)
69 static void print_bitmap_problem(e2fsck_t ctx, int problem,
70 struct problem_context *pctx)
73 case PR_5_BLOCK_UNUSED:
74 if (pctx->blk == pctx->blk2)
77 problem = PR_5_BLOCK_RANGE_UNUSED;
80 if (pctx->blk == pctx->blk2)
83 problem = PR_5_BLOCK_RANGE_USED;
85 case PR_5_INODE_UNUSED:
86 if (pctx->ino == pctx->ino2)
89 problem = PR_5_INODE_RANGE_UNUSED;
92 if (pctx->ino == pctx->ino2)
95 problem = PR_5_INODE_RANGE_USED;
98 fix_problem(ctx, problem, pctx);
99 pctx->blk = pctx->blk2 = NO_BLK;
100 pctx->ino = pctx->ino2 = 0;
103 static void check_block_bitmaps(e2fsck_t ctx)
105 ext2_filsys fs = ctx->fs;
110 blk64_t free_blocks = 0;
113 struct problem_context pctx;
114 int problem, save_problem, fixit, had_problem;
118 int old_desc_blocks = 0;
122 blk64_t super_blk, old_desc_blk, new_desc_blk;
124 clear_problem_context(&pctx);
125 free_array = (int *) e2fsck_allocate_memory(ctx,
126 fs->group_desc_count * sizeof(int), "free block count array");
128 if ((fs->super->s_first_data_block <
129 ext2fs_get_block_bitmap_start2(ctx->block_found_map)) ||
130 (ext2fs_blocks_count(fs->super)-1 >
131 ext2fs_get_block_bitmap_end2(ctx->block_found_map))) {
133 pctx.blk = fs->super->s_first_data_block;
134 pctx.blk2 = ext2fs_blocks_count(fs->super) -1;
135 pctx.ino = ext2fs_get_block_bitmap_start2(ctx->block_found_map);
136 pctx.ino2 = ext2fs_get_block_bitmap_end2(ctx->block_found_map);
137 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
139 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
143 if ((fs->super->s_first_data_block <
144 ext2fs_get_block_bitmap_start2(fs->block_map)) ||
145 (ext2fs_blocks_count(fs->super)-1 >
146 ext2fs_get_block_bitmap_end2(fs->block_map))) {
148 pctx.blk = fs->super->s_first_data_block;
149 pctx.blk2 = ext2fs_blocks_count(fs->super) -1;
150 pctx.ino = ext2fs_get_block_bitmap_start2(fs->block_map);
151 pctx.ino2 = ext2fs_get_block_bitmap_end2(fs->block_map);
152 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
154 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
158 csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
159 EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
163 pctx.blk = pctx.blk2 = NO_BLK;
165 (ext2fs_bg_flags_test(fs, group, EXT2_BG_BLOCK_UNINIT)))
167 for (i = fs->super->s_first_data_block;
168 i < ext2fs_blocks_count(fs->super);
170 actual = ext2fs_fast_test_block_bitmap2(ctx->block_found_map, i);
173 if ((i - fs->super->s_first_data_block) %
174 fs->super->s_blocks_per_group == 0) {
178 ext2fs_super_and_bgd_loc2(fs, group, &super_blk,
179 &old_desc_blk, &new_desc_blk, 0);
181 if (fs->super->s_feature_incompat &
182 EXT2_FEATURE_INCOMPAT_META_BG)
184 fs->super->s_first_meta_bg;
186 old_desc_blocks = fs->desc_blocks +
187 fs->super->s_reserved_gdt_blocks;
190 cmp_block = fs->super->s_blocks_per_group;
191 if (group == (int)fs->group_desc_count - 1)
193 ext2fs_blocks_count(fs->super) %
194 fs->super->s_blocks_per_group;
198 if ((i == super_blk) ||
199 (old_desc_blk && old_desc_blocks &&
200 (i >= old_desc_blk) &&
201 (i < old_desc_blk + old_desc_blocks)) ||
202 (new_desc_blk && (i == new_desc_blk)) ||
203 (i == ext2fs_block_bitmap_loc(fs, group)) ||
204 (i == ext2fs_inode_bitmap_loc(fs, group)) ||
205 (i >= ext2fs_inode_table_loc(fs, group) &&
206 (i < ext2fs_inode_table_loc(fs, group) +
207 fs->inode_blocks_per_group))) {
209 actual = (actual != 0);
212 } else if ((i - count - fs->super->s_first_data_block) %
213 fs->super->s_blocks_per_group == 0) {
215 * When the compare data blocks in block bitmap
216 * are 0, count the free block,
217 * skip the current block group.
219 if (ext2fs_test_block_bitmap_range2(
220 ctx->block_found_map, i,
223 * -1 means to skip the current block
226 blocks = fs->super->s_blocks_per_group
228 group_free = cmp_block;
229 free_blocks += cmp_block;
231 * The current block group's last block
239 } else if (redo_flag)
242 bitmap = ext2fs_fast_test_block_bitmap2(fs->block_map, i);
244 if (actual == bitmap)
247 if (!actual && bitmap) {
249 * Block not used, but marked in use in the bitmap.
251 problem = PR_5_BLOCK_UNUSED;
254 * Block used, but not marked in use in the bitmap.
256 problem = PR_5_BLOCK_USED;
259 struct problem_context pctx2;
262 if (fix_problem(ctx, PR_5_BLOCK_UNINIT,&pctx2)){
263 ext2fs_bg_flags_clear(fs, group, EXT2_BG_BLOCK_UNINIT);
268 if (pctx.blk == NO_BLK) {
269 pctx.blk = pctx.blk2 = i;
270 save_problem = problem;
272 if ((problem == save_problem) &&
276 print_bitmap_problem(ctx, save_problem, &pctx);
277 pctx.blk = pctx.blk2 = i;
278 save_problem = problem;
281 ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
285 if (!bitmap && (!skip_group || csum_flag)) {
290 if ((blocks == fs->super->s_blocks_per_group) ||
291 (i == ext2fs_blocks_count(fs->super)-1)) {
292 free_array[group] = group_free;
298 if ((ctx->progress)(ctx, 5, group,
299 fs->group_desc_count*2))
302 (i != ext2fs_blocks_count(fs->super)-1) &&
303 ext2fs_bg_flags_test(fs, group,
304 EXT2_BG_BLOCK_UNINIT))
308 if (pctx.blk != NO_BLK)
309 print_bitmap_problem(ctx, save_problem, &pctx);
311 fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP);
314 ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
317 ext2fs_free_block_bitmap(fs->block_map);
318 retval = ext2fs_copy_bitmap(ctx->block_found_map,
321 clear_problem_context(&pctx);
322 fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx);
323 ctx->flags |= E2F_FLAG_ABORT;
326 ext2fs_set_bitmap_padding(fs->block_map);
327 ext2fs_mark_bb_dirty(fs);
329 /* Redo the counts */
330 blocks = 0; free_blocks = 0; group_free = 0; group = 0;
331 memset(free_array, 0, fs->group_desc_count * sizeof(int));
334 } else if (fixit == 0)
335 ext2fs_unmark_valid(fs);
337 for (i = 0; i < fs->group_desc_count; i++) {
338 if (free_array[i] != ext2fs_bg_free_blocks_count(fs, i)) {
340 pctx.blk = ext2fs_bg_free_blocks_count(fs, i);
341 pctx.blk2 = free_array[i];
343 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP,
345 ext2fs_bg_free_blocks_count_set(fs, i, free_array[i]);
346 ext2fs_mark_super_dirty(fs);
348 ext2fs_unmark_valid(fs);
351 if (free_blocks != ext2fs_free_blocks_count(fs->super)) {
353 pctx.blk = ext2fs_free_blocks_count(fs->super);
354 pctx.blk2 = free_blocks;
356 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) {
357 ext2fs_free_blocks_count_set(fs->super, free_blocks);
358 ext2fs_mark_super_dirty(fs);
360 ext2fs_unmark_valid(fs);
363 ext2fs_free_mem(&free_array);
366 static void check_inode_bitmaps(e2fsck_t ctx)
368 ext2_filsys fs = ctx->fs;
370 unsigned int free_inodes = 0;
374 unsigned int inodes = 0;
379 struct problem_context pctx;
380 int problem, save_problem, fixit, had_problem;
385 clear_problem_context(&pctx);
386 free_array = (int *) e2fsck_allocate_memory(ctx,
387 fs->group_desc_count * sizeof(int), "free inode count array");
389 dir_array = (int *) e2fsck_allocate_memory(ctx,
390 fs->group_desc_count * sizeof(int), "directory count array");
392 if ((1 < ext2fs_get_inode_bitmap_start2(ctx->inode_used_map)) ||
393 (fs->super->s_inodes_count >
394 ext2fs_get_inode_bitmap_end2(ctx->inode_used_map))) {
397 pctx.blk2 = fs->super->s_inodes_count;
398 pctx.ino = ext2fs_get_inode_bitmap_start2(ctx->inode_used_map);
399 pctx.ino2 = ext2fs_get_inode_bitmap_end2(ctx->inode_used_map);
400 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
402 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
405 if ((1 < ext2fs_get_inode_bitmap_start2(fs->inode_map)) ||
406 (fs->super->s_inodes_count >
407 ext2fs_get_inode_bitmap_end2(fs->inode_map))) {
410 pctx.blk2 = fs->super->s_inodes_count;
411 pctx.ino = ext2fs_get_inode_bitmap_start2(fs->inode_map);
412 pctx.ino2 = ext2fs_get_inode_bitmap_end2(fs->inode_map);
413 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx);
415 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
419 csum_flag = EXT2_HAS_RO_COMPAT_FEATURE(fs->super,
420 EXT4_FEATURE_RO_COMPAT_GDT_CSUM);
424 pctx.ino = pctx.ino2 = 0;
426 (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)))
429 /* Protect loop from wrap-around if inodes_count is maxed */
430 for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) {
433 i % fs->super->s_inodes_per_group == 1) {
435 * Current inode is the first inode
436 * in the current block group.
438 if (ext2fs_test_inode_bitmap_range(
439 ctx->inode_used_map, i,
440 fs->super->s_inodes_per_group)) {
442 * When the compared inodes in inodes bitmap
443 * are 0, count the free inode,
444 * skip the current block group.
446 inodes = fs->super->s_inodes_per_group - 1;
448 free_inodes += inodes;
455 actual = ext2fs_fast_test_inode_bitmap2(ctx->inode_used_map, i);
458 else if (!skip_group)
459 bitmap = ext2fs_fast_test_inode_bitmap2(fs->inode_map, i);
460 if (actual == bitmap)
463 if (!actual && bitmap) {
465 * Inode wasn't used, but marked in bitmap
467 problem = PR_5_INODE_UNUSED;
468 } else /* if (actual && !bitmap) */ {
470 * Inode used, but not in bitmap
472 problem = PR_5_INODE_USED;
474 /* We should never hit this, because it means that
475 * inodes were marked in use that weren't noticed
476 * in pass1 or pass 2. It is easier to fix the problem
477 * than to kill e2fsck and leave the user stuck. */
479 struct problem_context pctx2;
482 if (fix_problem(ctx, PR_5_INODE_UNINIT,&pctx2)){
483 ext2fs_bg_flags_clear(fs, group, EXT2_BG_INODE_UNINIT);
489 pctx.ino = pctx.ino2 = i;
490 save_problem = problem;
492 if ((problem == save_problem) &&
496 print_bitmap_problem(ctx, save_problem, &pctx);
497 pctx.ino = pctx.ino2 = i;
498 save_problem = problem;
501 ctx->flags |= E2F_FLAG_PROG_SUPPRESS;
506 if (ext2fs_test_inode_bitmap2(ctx->inode_dir_map, i))
508 } else if (!skip_group || csum_flag) {
513 if ((inodes == fs->super->s_inodes_per_group) ||
514 (i == fs->super->s_inodes_count)) {
515 free_array[group] = group_free;
516 dir_array[group] = dirs_count;
523 if ((ctx->progress)(ctx, 5,
524 group + fs->group_desc_count,
525 fs->group_desc_count*2))
528 (i != fs->super->s_inodes_count) &&
529 (ext2fs_bg_flags_test(fs, group, EXT2_BG_INODE_UNINIT)
535 print_bitmap_problem(ctx, save_problem, &pctx);
538 fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP);
541 ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS;
544 ext2fs_free_inode_bitmap(fs->inode_map);
545 retval = ext2fs_copy_bitmap(ctx->inode_used_map,
548 clear_problem_context(&pctx);
549 fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx);
550 ctx->flags |= E2F_FLAG_ABORT;
553 ext2fs_set_bitmap_padding(fs->inode_map);
554 ext2fs_mark_ib_dirty(fs);
557 inodes = 0; free_inodes = 0; group_free = 0;
558 dirs_count = 0; group = 0;
559 memset(free_array, 0, fs->group_desc_count * sizeof(int));
560 memset(dir_array, 0, fs->group_desc_count * sizeof(int));
563 } else if (fixit == 0)
564 ext2fs_unmark_valid(fs);
566 for (i = 0; i < fs->group_desc_count; i++) {
567 if (free_array[i] != ext2fs_bg_free_inodes_count(fs, i)) {
569 pctx.ino = ext2fs_bg_free_inodes_count(fs, i);
570 pctx.ino2 = free_array[i];
571 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP,
573 ext2fs_bg_free_inodes_count_set(fs, i, free_array[i]);
574 ext2fs_mark_super_dirty(fs);
576 ext2fs_unmark_valid(fs);
578 if (dir_array[i] != ext2fs_bg_used_dirs_count(fs, i)) {
580 pctx.ino = ext2fs_bg_used_dirs_count(fs, i);
581 pctx.ino2 = dir_array[i];
583 if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP,
585 ext2fs_bg_used_dirs_count_set(fs, i, dir_array[i]);
586 ext2fs_mark_super_dirty(fs);
588 ext2fs_unmark_valid(fs);
591 if (free_inodes != fs->super->s_free_inodes_count) {
593 pctx.ino = fs->super->s_free_inodes_count;
594 pctx.ino2 = free_inodes;
596 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) {
597 fs->super->s_free_inodes_count = free_inodes;
598 ext2fs_mark_super_dirty(fs);
600 ext2fs_unmark_valid(fs);
603 ext2fs_free_mem(&free_array);
604 ext2fs_free_mem(&dir_array);
607 static void check_inode_end(e2fsck_t ctx)
609 ext2_filsys fs = ctx->fs;
610 ext2_ino_t end, save_inodes_count, i;
611 struct problem_context pctx;
613 clear_problem_context(&pctx);
615 end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count;
616 pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end,
620 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
621 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
624 if (save_inodes_count == end)
627 /* protect loop from wrap-around if end is maxed */
628 for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) {
629 if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) {
630 if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) {
631 for (; i <= end; i++)
632 ext2fs_mark_inode_bitmap(fs->inode_map,
634 ext2fs_mark_ib_dirty(fs);
636 ext2fs_unmark_valid(fs);
641 pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map,
642 save_inodes_count, 0);
645 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
646 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
651 static void check_block_end(e2fsck_t ctx)
653 ext2_filsys fs = ctx->fs;
654 blk64_t end, save_blocks_count, i;
655 struct problem_context pctx;
657 clear_problem_context(&pctx);
659 end = ext2fs_get_block_bitmap_start2(fs->block_map) +
660 ((blk64_t)EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1;
661 pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map, end,
665 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
666 ctx->flags |= E2F_FLAG_ABORT; /* fatal */
669 if (save_blocks_count == end)
672 /* Protect loop from wrap-around if end is maxed */
673 for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) {
674 if (!ext2fs_test_block_bitmap2(fs->block_map, i)) {
675 if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) {
676 for (; i <= end; i++)
677 ext2fs_mark_block_bitmap2(fs->block_map,
679 ext2fs_mark_bb_dirty(fs);
681 ext2fs_unmark_valid(fs);
686 pctx.errcode = ext2fs_fudge_block_bitmap_end2(fs->block_map,
687 save_blocks_count, 0);
690 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx);
691 ctx->flags |= E2F_FLAG_ABORT; /* fatal */