1 /* 2 * pass5.c --- check block and inode bitmaps against on-disk bitmaps 3 * 4 * Copyright (C) 1993, 1994, 1995, 1996, 1997 Theodore Ts'o. 5 * 6 * %Begin-Header% 7 * This file may be redistributed under the terms of the GNU Public 8 * License. 9 * %End-Header% 10 * 11 */ 12 13 #include "e2fsck.h" 14 #include "problem.h" 15 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); 20 21 void e2fsck_pass5(e2fsck_t ctx) 22 { 23 #ifdef RESOURCE_TRACK 24 struct resource_track rtrack; 25 #endif 26 struct problem_context pctx; 27 28 #ifdef MTRACE 29 mtrace_print("Pass 5"); 30 #endif 31 32 #ifdef RESOURCE_TRACK 33 init_resource_track(&rtrack); 34 #endif 35 36 clear_problem_context(&pctx); 37 38 if (!(ctx->options & E2F_OPT_PREEN)) 39 fix_problem(ctx, PR_5_PASS_HEADER, &pctx); 40 41 if (ctx->progress) 42 if ((ctx->progress)(ctx, 5, 0, ctx->fs->group_desc_count*2)) 43 return; 44 45 e2fsck_read_bitmaps(ctx); 46 47 check_block_bitmaps(ctx); 48 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 49 return; 50 check_inode_bitmaps(ctx); 51 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 52 return; 53 check_inode_end(ctx); 54 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 55 return; 56 check_block_end(ctx); 57 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 58 return; 59 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; 66 67 #ifdef RESOURCE_TRACK 68 if (ctx->options & E2F_OPT_TIME2) { 69 e2fsck_clear_progbar(ctx); 70 print_resource_track(_("Pass 5"), &rtrack); 71 } 72 #endif 73 } 74 75 #define NO_BLK ((blk_t) -1) 76 77 static void print_bitmap_problem(e2fsck_t ctx, int problem, 78 struct problem_context *pctx) 79 { 80 switch (problem) { 81 case PR_5_BLOCK_UNUSED: 82 if (pctx->blk == pctx->blk2) 83 pctx->blk2 = 0; 84 else 85 problem = PR_5_BLOCK_RANGE_UNUSED; 86 break; 87 case PR_5_BLOCK_USED: 88 if (pctx->blk == pctx->blk2) 89 pctx->blk2 = 0; 90 else 91 problem = PR_5_BLOCK_RANGE_USED; 92 break; 93 case PR_5_INODE_UNUSED: 94 if (pctx->ino == pctx->ino2) 95 pctx->ino2 = 0; 96 else 97 problem = PR_5_INODE_RANGE_UNUSED; 98 break; 99 case PR_5_INODE_USED: 100 if (pctx->ino == pctx->ino2) 101 pctx->ino2 = 0; 102 else 103 problem = PR_5_INODE_RANGE_USED; 104 break; 105 } 106 fix_problem(ctx, problem, pctx); 107 pctx->blk = pctx->blk2 = NO_BLK; 108 pctx->ino = pctx->ino2 = 0; 109 } 110 111 static void check_block_bitmaps(e2fsck_t ctx) 112 { 113 ext2_filsys fs = ctx->fs; 114 blk_t i, super; 115 int *free_array; 116 int group = 0; 117 unsigned int blocks = 0; 118 unsigned int free_blocks = 0; 119 int group_free = 0; 120 int actual, bitmap; 121 struct problem_context pctx; 122 int problem, save_problem, fixit, had_problem; 123 errcode_t retval; 124 int lazy_bg = 0; 125 int skip_group = 0; 126 127 clear_problem_context(&pctx); 128 free_array = (int *) e2fsck_allocate_memory(ctx, 129 fs->group_desc_count * sizeof(int), "free block count array"); 130 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))) { 135 pctx.num = 1; 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); 141 142 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 143 goto errout; 144 } 145 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))) { 150 pctx.num = 2; 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); 156 157 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 158 goto errout; 159 } 160 161 if (EXT2_HAS_COMPAT_FEATURE(fs->super, EXT2_FEATURE_COMPAT_LAZY_BG)) 162 lazy_bg++; 163 164 redo_counts: 165 had_problem = 0; 166 save_problem = 0; 167 pctx.blk = pctx.blk2 = NO_BLK; 168 if (lazy_bg && (fs->group_desc[group].bg_flags & 169 EXT2_BG_BLOCK_UNINIT)) 170 skip_group++; 171 super = fs->super->s_first_data_block; 172 for (i = fs->super->s_first_data_block; 173 i < fs->super->s_blocks_count; 174 i++) { 175 actual = ext2fs_fast_test_block_bitmap(ctx->block_found_map, i); 176 177 if (skip_group) { 178 if ((i >= super) && 179 (i <= super + fs->desc_blocks) && 180 ext2fs_bg_has_super(fs, group)) 181 bitmap = 1; 182 else if (i == fs->group_desc[group].bg_block_bitmap) 183 bitmap = 1; 184 else if (i == fs->group_desc[group].bg_inode_bitmap) 185 bitmap = 1; 186 else if (i >= fs->group_desc[group].bg_inode_table && 187 (i < fs->group_desc[group].bg_inode_table 188 + fs->inode_blocks_per_group)) 189 bitmap = 1; 190 else 191 bitmap = 0; 192 actual = (actual != 0); 193 } else 194 bitmap = ext2fs_fast_test_block_bitmap(fs->block_map, i); 195 196 if (actual == bitmap) 197 goto do_counts; 198 199 if (!actual && bitmap) { 200 /* 201 * Block not used, but marked in use in the bitmap. 202 */ 203 problem = PR_5_BLOCK_UNUSED; 204 } else { 205 /* 206 * Block used, but not marked in use in the bitmap. 207 */ 208 problem = PR_5_BLOCK_USED; 209 } 210 if (pctx.blk == NO_BLK) { 211 pctx.blk = pctx.blk2 = i; 212 save_problem = problem; 213 } else { 214 if ((problem == save_problem) && 215 (pctx.blk2 == i-1)) 216 pctx.blk2++; 217 else { 218 print_bitmap_problem(ctx, save_problem, &pctx); 219 pctx.blk = pctx.blk2 = i; 220 save_problem = problem; 221 } 222 } 223 ctx->flags |= E2F_FLAG_PROG_SUPPRESS; 224 had_problem++; 225 226 do_counts: 227 if (!bitmap && !skip_group) { 228 group_free++; 229 free_blocks++; 230 } 231 blocks ++; 232 if ((blocks == fs->super->s_blocks_per_group) || 233 (i == fs->super->s_blocks_count-1)) { 234 free_array[group] = group_free; 235 group ++; 236 blocks = 0; 237 group_free = 0; 238 skip_group = 0; 239 super += fs->super->s_blocks_per_group; 240 if (ctx->progress) 241 if ((ctx->progress)(ctx, 5, group, 242 fs->group_desc_count*2)) 243 goto errout; 244 if (lazy_bg && 245 (i != fs->super->s_blocks_count-1) && 246 (fs->group_desc[group].bg_flags & 247 EXT2_BG_BLOCK_UNINIT)) 248 skip_group++; 249 } 250 } 251 if (pctx.blk != NO_BLK) 252 print_bitmap_problem(ctx, save_problem, &pctx); 253 if (had_problem) 254 fixit = end_problem_latch(ctx, PR_LATCH_BBITMAP); 255 else 256 fixit = -1; 257 ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; 258 259 if (fixit == 1) { 260 ext2fs_free_block_bitmap(fs->block_map); 261 retval = ext2fs_copy_bitmap(ctx->block_found_map, 262 &fs->block_map); 263 if (retval) { 264 clear_problem_context(&pctx); 265 fix_problem(ctx, PR_5_COPY_BBITMAP_ERROR, &pctx); 266 ctx->flags |= E2F_FLAG_ABORT; 267 goto errout; 268 } 269 ext2fs_set_bitmap_padding(fs->block_map); 270 ext2fs_mark_bb_dirty(fs); 271 272 /* Redo the counts */ 273 blocks = 0; free_blocks = 0; group_free = 0; group = 0; 274 memset(free_array, 0, fs->group_desc_count * sizeof(int)); 275 goto redo_counts; 276 } else if (fixit == 0) 277 ext2fs_unmark_valid(fs); 278 279 for (i = 0; i < fs->group_desc_count; i++) { 280 if (free_array[i] != fs->group_desc[i].bg_free_blocks_count) { 281 pctx.group = i; 282 pctx.blk = fs->group_desc[i].bg_free_blocks_count; 283 pctx.blk2 = free_array[i]; 284 285 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT_GROUP, 286 &pctx)) { 287 fs->group_desc[i].bg_free_blocks_count = 288 free_array[i]; 289 ext2fs_mark_super_dirty(fs); 290 } else 291 ext2fs_unmark_valid(fs); 292 } 293 } 294 if (free_blocks != fs->super->s_free_blocks_count) { 295 pctx.group = 0; 296 pctx.blk = fs->super->s_free_blocks_count; 297 pctx.blk2 = free_blocks; 298 299 if (fix_problem(ctx, PR_5_FREE_BLOCK_COUNT, &pctx)) { 300 fs->super->s_free_blocks_count = free_blocks; 301 ext2fs_mark_super_dirty(fs); 302 } else 303 ext2fs_unmark_valid(fs); 304 } 305 errout: 306 ext2fs_free_mem(&free_array); 307 } 308 309 static void check_inode_bitmaps(e2fsck_t ctx) 310 { 311 ext2_filsys fs = ctx->fs; 312 ext2_ino_t i; 313 unsigned int free_inodes = 0; 314 int group_free = 0; 315 int dirs_count = 0; 316 int group = 0; 317 unsigned int inodes = 0; 318 int *free_array; 319 int *dir_array; 320 int actual, bitmap; 321 errcode_t retval; 322 struct problem_context pctx; 323 int problem, save_problem, fixit, had_problem; 324 int lazy_bg = 0; 325 int skip_group = 0; 326 327 clear_problem_context(&pctx); 328 free_array = (int *) e2fsck_allocate_memory(ctx, 329 fs->group_desc_count * sizeof(int), "free inode count array"); 330 331 dir_array = (int *) e2fsck_allocate_memory(ctx, 332 fs->group_desc_count * sizeof(int), "directory count array"); 333 334 if ((1 < ext2fs_get_inode_bitmap_start(ctx->inode_used_map)) || 335 (fs->super->s_inodes_count > 336 ext2fs_get_inode_bitmap_end(ctx->inode_used_map))) { 337 pctx.num = 3; 338 pctx.blk = 1; 339 pctx.blk2 = fs->super->s_inodes_count; 340 pctx.ino = ext2fs_get_inode_bitmap_start(ctx->inode_used_map); 341 pctx.ino2 = ext2fs_get_inode_bitmap_end(ctx->inode_used_map); 342 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); 343 344 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 345 goto errout; 346 } 347 if ((1 < ext2fs_get_inode_bitmap_start(fs->inode_map)) || 348 (fs->super->s_inodes_count > 349 ext2fs_get_inode_bitmap_end(fs->inode_map))) { 350 pctx.num = 4; 351 pctx.blk = 1; 352 pctx.blk2 = fs->super->s_inodes_count; 353 pctx.ino = ext2fs_get_inode_bitmap_start(fs->inode_map); 354 pctx.ino2 = ext2fs_get_inode_bitmap_end(fs->inode_map); 355 fix_problem(ctx, PR_5_BMAP_ENDPOINTS, &pctx); 356 357 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 358 goto errout; 359 } 360 361 if (EXT2_HAS_COMPAT_FEATURE(fs->super, 362 EXT2_FEATURE_COMPAT_LAZY_BG)) 363 lazy_bg++; 364 365 redo_counts: 366 had_problem = 0; 367 save_problem = 0; 368 pctx.ino = pctx.ino2 = 0; 369 if (lazy_bg && (fs->group_desc[group].bg_flags & 370 EXT2_BG_INODE_UNINIT)) 371 skip_group++; 372 373 /* Protect loop from wrap-around if inodes_count is maxed */ 374 for (i = 1; i <= fs->super->s_inodes_count && i > 0; i++) { 375 actual = ext2fs_fast_test_inode_bitmap(ctx->inode_used_map, i); 376 if (skip_group) 377 bitmap = 0; 378 else 379 bitmap = ext2fs_fast_test_inode_bitmap(fs->inode_map, i); 380 if (actual == bitmap) 381 goto do_counts; 382 383 if (!actual && bitmap) { 384 /* 385 * Inode wasn't used, but marked in bitmap 386 */ 387 problem = PR_5_INODE_UNUSED; 388 } else /* if (actual && !bitmap) */ { 389 /* 390 * Inode used, but not in bitmap 391 */ 392 problem = PR_5_INODE_USED; 393 } 394 if (pctx.ino == 0) { 395 pctx.ino = pctx.ino2 = i; 396 save_problem = problem; 397 } else { 398 if ((problem == save_problem) && 399 (pctx.ino2 == i-1)) 400 pctx.ino2++; 401 else { 402 print_bitmap_problem(ctx, save_problem, &pctx); 403 pctx.ino = pctx.ino2 = i; 404 save_problem = problem; 405 } 406 } 407 ctx->flags |= E2F_FLAG_PROG_SUPPRESS; 408 had_problem++; 409 410 do_counts: 411 if (bitmap) { 412 if (ext2fs_test_inode_bitmap(ctx->inode_dir_map, i)) 413 dirs_count++; 414 } else if (!skip_group) { 415 group_free++; 416 free_inodes++; 417 } 418 inodes++; 419 if ((inodes == fs->super->s_inodes_per_group) || 420 (i == fs->super->s_inodes_count)) { 421 free_array[group] = group_free; 422 dir_array[group] = dirs_count; 423 group ++; 424 inodes = 0; 425 skip_group = 0; 426 group_free = 0; 427 dirs_count = 0; 428 if (ctx->progress) 429 if ((ctx->progress)(ctx, 5, 430 group + fs->group_desc_count, 431 fs->group_desc_count*2)) 432 goto errout; 433 if (lazy_bg && 434 (i != fs->super->s_inodes_count) && 435 (fs->group_desc[group].bg_flags & 436 EXT2_BG_INODE_UNINIT)) 437 skip_group++; 438 } 439 } 440 if (pctx.ino) 441 print_bitmap_problem(ctx, save_problem, &pctx); 442 443 if (had_problem) 444 fixit = end_problem_latch(ctx, PR_LATCH_IBITMAP); 445 else 446 fixit = -1; 447 ctx->flags &= ~E2F_FLAG_PROG_SUPPRESS; 448 449 if (fixit == 1) { 450 ext2fs_free_inode_bitmap(fs->inode_map); 451 retval = ext2fs_copy_bitmap(ctx->inode_used_map, 452 &fs->inode_map); 453 if (retval) { 454 clear_problem_context(&pctx); 455 fix_problem(ctx, PR_5_COPY_IBITMAP_ERROR, &pctx); 456 ctx->flags |= E2F_FLAG_ABORT; 457 goto errout; 458 } 459 ext2fs_set_bitmap_padding(fs->inode_map); 460 ext2fs_mark_ib_dirty(fs); 461 462 /* redo counts */ 463 inodes = 0; free_inodes = 0; group_free = 0; 464 dirs_count = 0; group = 0; 465 memset(free_array, 0, fs->group_desc_count * sizeof(int)); 466 memset(dir_array, 0, fs->group_desc_count * sizeof(int)); 467 goto redo_counts; 468 } else if (fixit == 0) 469 ext2fs_unmark_valid(fs); 470 471 for (i = 0; i < fs->group_desc_count; i++) { 472 if (free_array[i] != fs->group_desc[i].bg_free_inodes_count) { 473 pctx.group = i; 474 pctx.ino = fs->group_desc[i].bg_free_inodes_count; 475 pctx.ino2 = free_array[i]; 476 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT_GROUP, 477 &pctx)) { 478 fs->group_desc[i].bg_free_inodes_count = 479 free_array[i]; 480 ext2fs_mark_super_dirty(fs); 481 } else 482 ext2fs_unmark_valid(fs); 483 } 484 if (dir_array[i] != fs->group_desc[i].bg_used_dirs_count) { 485 pctx.group = i; 486 pctx.ino = fs->group_desc[i].bg_used_dirs_count; 487 pctx.ino2 = dir_array[i]; 488 489 if (fix_problem(ctx, PR_5_FREE_DIR_COUNT_GROUP, 490 &pctx)) { 491 fs->group_desc[i].bg_used_dirs_count = 492 dir_array[i]; 493 ext2fs_mark_super_dirty(fs); 494 } else 495 ext2fs_unmark_valid(fs); 496 } 497 } 498 if (free_inodes != fs->super->s_free_inodes_count) { 499 pctx.group = -1; 500 pctx.ino = fs->super->s_free_inodes_count; 501 pctx.ino2 = free_inodes; 502 503 if (fix_problem(ctx, PR_5_FREE_INODE_COUNT, &pctx)) { 504 fs->super->s_free_inodes_count = free_inodes; 505 ext2fs_mark_super_dirty(fs); 506 } else 507 ext2fs_unmark_valid(fs); 508 } 509 errout: 510 ext2fs_free_mem(&free_array); 511 ext2fs_free_mem(&dir_array); 512 } 513 514 static void check_inode_end(e2fsck_t ctx) 515 { 516 ext2_filsys fs = ctx->fs; 517 ext2_ino_t end, save_inodes_count, i; 518 struct problem_context pctx; 519 520 clear_problem_context(&pctx); 521 522 end = EXT2_INODES_PER_GROUP(fs->super) * fs->group_desc_count; 523 pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, end, 524 &save_inodes_count); 525 if (pctx.errcode) { 526 pctx.num = 1; 527 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); 528 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 529 return; 530 } 531 if (save_inodes_count == end) 532 return; 533 534 /* protect loop from wrap-around if end is maxed */ 535 for (i = save_inodes_count + 1; i <= end && i > save_inodes_count; i++) { 536 if (!ext2fs_test_inode_bitmap(fs->inode_map, i)) { 537 if (fix_problem(ctx, PR_5_INODE_BMAP_PADDING, &pctx)) { 538 for (i = save_inodes_count + 1; i <= end; i++) 539 ext2fs_mark_inode_bitmap(fs->inode_map, 540 i); 541 ext2fs_mark_ib_dirty(fs); 542 } else 543 ext2fs_unmark_valid(fs); 544 break; 545 } 546 } 547 548 pctx.errcode = ext2fs_fudge_inode_bitmap_end(fs->inode_map, 549 save_inodes_count, 0); 550 if (pctx.errcode) { 551 pctx.num = 2; 552 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); 553 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 554 return; 555 } 556 } 557 558 static void check_block_end(e2fsck_t ctx) 559 { 560 ext2_filsys fs = ctx->fs; 561 blk_t end, save_blocks_count, i; 562 struct problem_context pctx; 563 564 clear_problem_context(&pctx); 565 566 end = fs->block_map->start + 567 (EXT2_BLOCKS_PER_GROUP(fs->super) * fs->group_desc_count) - 1; 568 pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, end, 569 &save_blocks_count); 570 if (pctx.errcode) { 571 pctx.num = 3; 572 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); 573 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 574 return; 575 } 576 if (save_blocks_count == end) 577 return; 578 579 /* Protect loop from wrap-around if end is maxed */ 580 for (i = save_blocks_count + 1; i <= end && i > save_blocks_count; i++) { 581 if (!ext2fs_test_block_bitmap(fs->block_map, i)) { 582 if (fix_problem(ctx, PR_5_BLOCK_BMAP_PADDING, &pctx)) { 583 for (i = save_blocks_count + 1; i <= end; i++) 584 ext2fs_mark_block_bitmap(fs->block_map, 585 i); 586 ext2fs_mark_bb_dirty(fs); 587 } else 588 ext2fs_unmark_valid(fs); 589 break; 590 } 591 } 592 593 pctx.errcode = ext2fs_fudge_block_bitmap_end(fs->block_map, 594 save_blocks_count, 0); 595 if (pctx.errcode) { 596 pctx.num = 4; 597 fix_problem(ctx, PR_5_FUDGE_BITMAP_ERROR, &pctx); 598 ctx->flags |= E2F_FLAG_ABORT; /* fatal */ 599 return; 600 } 601 } 602 603 604 605
