1 /* 2 * e2fsck.c - superblock checks 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 #ifdef HAVE_ERRNO_H 13 #include <errno.h> 14 #endif 15 16 #ifndef EXT2_SKIP_UUID 17 #include "uuid/uuid.h" 18 #endif 19 #include "e2fsck.h" 20 #include "problem.h" 21 22 #define MIN_CHECK 1 23 #define MAX_CHECK 2 24 25 static void check_super_value(e2fsck_t ctx, const char *descr, 26 unsigned long value, int flags, 27 unsigned long min_val, unsigned long max_val) 28 { 29 struct problem_context pctx; 30 31 if (((flags & MIN_CHECK) && (value < min_val)) || 32 ((flags & MAX_CHECK) && (value > max_val))) { 33 clear_problem_context(&pctx); 34 pctx.num = value; 35 pctx.str = descr; 36 fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); 37 ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ 38 } 39 } 40 41 /* 42 * helper function to release an inode 43 */ 44 struct process_block_struct { 45 e2fsck_t ctx; 46 char *buf; 47 struct problem_context *pctx; 48 int truncating; 49 int truncate_offset; 50 e2_blkcnt_t truncate_block; 51 int truncated_blocks; 52 int abort; 53 errcode_t errcode; 54 }; 55 56 static int release_inode_block(ext2_filsys fs, 57 blk_t *block_nr, 58 e2_blkcnt_t blockcnt, 59 blk_t ref_blk EXT2FS_ATTR((unused)), 60 int ref_offset EXT2FS_ATTR((unused)), 61 void *priv_data) 62 { 63 struct process_block_struct *pb; 64 e2fsck_t ctx; 65 struct problem_context *pctx; 66 blk_t blk = *block_nr; 67 int retval = 0; 68 69 pb = (struct process_block_struct *) priv_data; 70 ctx = pb->ctx; 71 pctx = pb->pctx; 72 73 pctx->blk = blk; 74 pctx->blkcount = blockcnt; 75 76 if (HOLE_BLKADDR(blk)) 77 return 0; 78 79 if ((blk < fs->super->s_first_data_block) || 80 (blk >= fs->super->s_blocks_count)) { 81 fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_BLOCK_NUM, pctx); 82 return_abort: 83 pb->abort = 1; 84 return BLOCK_ABORT; 85 } 86 87 if (!ext2fs_test_block_bitmap(fs->block_map, blk)) { 88 fix_problem(ctx, PR_0_ORPHAN_ALREADY_CLEARED_BLOCK, pctx); 89 goto return_abort; 90 } 91 92 /* 93 * If we are deleting an orphan, then we leave the fields alone. 94 * If we are truncating an orphan, then update the inode fields 95 * and clean up any partial block data. 96 */ 97 if (pb->truncating) { 98 /* 99 * We only remove indirect blocks if they are 100 * completely empty. 101 */ 102 if (blockcnt < 0) { 103 int i, limit; 104 blk_t *bp; 105 106 pb->errcode = io_channel_read_blk(fs->io, blk, 1, 107 pb->buf); 108 if (pb->errcode) 109 goto return_abort; 110 111 limit = fs->blocksize >> 2; 112 for (i = 0, bp = (blk_t *) pb->buf; 113 i < limit; i++, bp++) 114 if (*bp) 115 return 0; 116 } 117 /* 118 * We don't remove direct blocks until we've reached 119 * the truncation block. 120 */ 121 if (blockcnt >= 0 && blockcnt < pb->truncate_block) 122 return 0; 123 /* 124 * If part of the last block needs truncating, we do 125 * it here. 126 */ 127 if ((blockcnt == pb->truncate_block) && pb->truncate_offset) { 128 pb->errcode = io_channel_read_blk(fs->io, blk, 1, 129 pb->buf); 130 if (pb->errcode) 131 goto return_abort; 132 memset(pb->buf + pb->truncate_offset, 0, 133 fs->blocksize - pb->truncate_offset); 134 pb->errcode = io_channel_write_blk(fs->io, blk, 1, 135 pb->buf); 136 if (pb->errcode) 137 goto return_abort; 138 } 139 pb->truncated_blocks++; 140 *block_nr = 0; 141 retval |= BLOCK_CHANGED; 142 } 143 144 ext2fs_block_alloc_stats(fs, blk, -1); 145 return retval; 146 } 147 148 /* 149 * This function releases an inode. Returns 1 if an inconsistency was 150 * found. If the inode has a link count, then it is being truncated and 151 * not deleted. 152 */ 153 static int release_inode_blocks(e2fsck_t ctx, ext2_ino_t ino, 154 struct ext2_inode *inode, char *block_buf, 155 struct problem_context *pctx) 156 { 157 struct process_block_struct pb; 158 ext2_filsys fs = ctx->fs; 159 errcode_t retval; 160 __u32 count; 161 162 if (!ext2fs_inode_has_valid_blocks(inode)) 163 return 0; 164 165 pb.buf = block_buf + 3 * ctx->fs->blocksize; 166 pb.ctx = ctx; 167 pb.abort = 0; 168 pb.errcode = 0; 169 pb.pctx = pctx; 170 if (inode->i_links_count) { 171 pb.truncating = 1; 172 pb.truncate_block = (e2_blkcnt_t) 173 ((((long long)inode->i_size_high << 32) + 174 inode->i_size + fs->blocksize - 1) / 175 fs->blocksize); 176 pb.truncate_offset = inode->i_size % fs->blocksize; 177 } else { 178 pb.truncating = 0; 179 pb.truncate_block = 0; 180 pb.truncate_offset = 0; 181 } 182 pb.truncated_blocks = 0; 183 retval = ext2fs_block_iterate2(fs, ino, BLOCK_FLAG_DEPTH_TRAVERSE, 184 block_buf, release_inode_block, &pb); 185 if (retval) { 186 com_err("release_inode_blocks", retval, 187 _("while calling ext2fs_block_iterate for inode %d"), 188 ino); 189 return 1; 190 } 191 if (pb.abort) 192 return 1; 193 194 /* Refresh the inode since ext2fs_block_iterate may have changed it */ 195 e2fsck_read_inode(ctx, ino, inode, "release_inode_blocks"); 196 197 if (pb.truncated_blocks) 198 inode->i_blocks -= pb.truncated_blocks * 199 (fs->blocksize / 512); 200 201 if (inode->i_file_acl) { 202 retval = ext2fs_adjust_ea_refcount(fs, inode->i_file_acl, 203 block_buf, -1, &count); 204 if (retval == EXT2_ET_BAD_EA_BLOCK_NUM) { 205 retval = 0; 206 count = 1; 207 } 208 if (retval) { 209 com_err("release_inode_blocks", retval, 210 _("while calling ext2fs_adjust_ea_refcount for inode %d"), 211 ino); 212 return 1; 213 } 214 if (count == 0) 215 ext2fs_block_alloc_stats(fs, inode->i_file_acl, -1); 216 inode->i_file_acl = 0; 217 } 218 return 0; 219 } 220 221 /* 222 * This function releases all of the orphan inodes. It returns 1 if 223 * it hit some error, and 0 on success. 224 */ 225 static int release_orphan_inodes(e2fsck_t ctx) 226 { 227 ext2_filsys fs = ctx->fs; 228 ext2_ino_t ino, next_ino; 229 struct ext2_inode inode; 230 struct problem_context pctx; 231 char *block_buf; 232 233 if ((ino = fs->super->s_last_orphan) == 0) 234 return 0; 235 236 /* 237 * Win or lose, we won't be using the head of the orphan inode 238 * list again. 239 */ 240 fs->super->s_last_orphan = 0; 241 ext2fs_mark_super_dirty(fs); 242 243 /* 244 * If the filesystem contains errors, don't run the orphan 245 * list, since the orphan list can't be trusted; and we're 246 * going to be running a full e2fsck run anyway... 247 */ 248 if (fs->super->s_state & EXT2_ERROR_FS) 249 return 0; 250 251 if ((ino < EXT2_FIRST_INODE(fs->super)) || 252 (ino > fs->super->s_inodes_count)) { 253 clear_problem_context(&pctx); 254 pctx.ino = ino; 255 fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_HEAD_INODE, &pctx); 256 return 1; 257 } 258 259 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 4, 260 "block iterate buffer"); 261 e2fsck_read_bitmaps(ctx); 262 263 while (ino) { 264 e2fsck_read_inode(ctx, ino, &inode, "release_orphan_inodes"); 265 clear_problem_context(&pctx); 266 pctx.ino = ino; 267 pctx.inode = &inode; 268 pctx.str = inode.i_links_count ? _("Truncating") : 269 _("Clearing"); 270 271 fix_problem(ctx, PR_0_ORPHAN_CLEAR_INODE, &pctx); 272 273 next_ino = inode.i_dtime; 274 if (next_ino && 275 ((next_ino < EXT2_FIRST_INODE(fs->super)) || 276 (next_ino > fs->super->s_inodes_count))) { 277 pctx.ino = next_ino; 278 fix_problem(ctx, PR_0_ORPHAN_ILLEGAL_INODE, &pctx); 279 goto return_abort; 280 } 281 282 if (release_inode_blocks(ctx, ino, &inode, block_buf, &pctx)) 283 goto return_abort; 284 285 if (!inode.i_links_count) { 286 ext2fs_inode_alloc_stats2(fs, ino, -1, 287 LINUX_S_ISDIR(inode.i_mode)); 288 inode.i_dtime = ctx->now; 289 } else { 290 inode.i_dtime = 0; 291 } 292 e2fsck_write_inode(ctx, ino, &inode, "delete_file"); 293 ino = next_ino; 294 } 295 ext2fs_free_mem(&block_buf); 296 return 0; 297 return_abort: 298 ext2fs_free_mem(&block_buf); 299 return 1; 300 } 301 302 /* 303 * Check the resize inode to make sure it is sane. We check both for 304 * the case where on-line resizing is not enabled (in which case the 305 * resize inode should be cleared) as well as the case where on-line 306 * resizing is enabled. 307 */ 308 static void check_resize_inode(e2fsck_t ctx) 309 { 310 ext2_filsys fs = ctx->fs; 311 struct ext2_inode inode; 312 struct problem_context pctx; 313 int i, gdt_off, ind_off; 314 dgrp_t j; 315 blk_t blk, pblk, expect; 316 __u32 *dind_buf = 0, *ind_buf; 317 errcode_t retval; 318 319 clear_problem_context(&pctx); 320 321 /* 322 * If the resize inode feature isn't set, then 323 * s_reserved_gdt_blocks must be zero. 324 */ 325 if (!(fs->super->s_feature_compat & 326 EXT2_FEATURE_COMPAT_RESIZE_INODE)) { 327 if (fs->super->s_reserved_gdt_blocks) { 328 pctx.num = fs->super->s_reserved_gdt_blocks; 329 if (fix_problem(ctx, PR_0_NONZERO_RESERVED_GDT_BLOCKS, 330 &pctx)) { 331 fs->super->s_reserved_gdt_blocks = 0; 332 ext2fs_mark_super_dirty(fs); 333 } 334 } 335 } 336 337 /* Read the resize inode */ 338 pctx.ino = EXT2_RESIZE_INO; 339 retval = ext2fs_read_inode(fs, EXT2_RESIZE_INO, &inode); 340 if (retval) { 341 if (fs->super->s_feature_compat & 342 EXT2_FEATURE_COMPAT_RESIZE_INODE) 343 ctx->flags |= E2F_FLAG_RESIZE_INODE; 344 return; 345 } 346 347 /* 348 * If the resize inode feature isn't set, check to make sure 349 * the resize inode is cleared; then we're done. 350 */ 351 if (!(fs->super->s_feature_compat & 352 EXT2_FEATURE_COMPAT_RESIZE_INODE)) { 353 for (i=0; i < EXT2_N_BLOCKS; i++) { 354 if (inode.i_block[i]) 355 break; 356 } 357 if ((i < EXT2_N_BLOCKS) && 358 fix_problem(ctx, PR_0_CLEAR_RESIZE_INODE, &pctx)) { 359 memset(&inode, 0, sizeof(inode)); 360 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, 361 "clear_resize"); 362 } 363 return; 364 } 365 366 /* 367 * The resize inode feature is enabled; check to make sure the 368 * only block in use is the double indirect block 369 */ 370 blk = inode.i_block[EXT2_DIND_BLOCK]; 371 for (i=0; i < EXT2_N_BLOCKS; i++) { 372 if (i != EXT2_DIND_BLOCK && inode.i_block[i]) 373 break; 374 } 375 if ((i < EXT2_N_BLOCKS) || !blk || !inode.i_links_count || 376 !(inode.i_mode & LINUX_S_IFREG) || 377 (blk < fs->super->s_first_data_block || 378 blk >= fs->super->s_blocks_count)) { 379 resize_inode_invalid: 380 if (fix_problem(ctx, PR_0_RESIZE_INODE_INVALID, &pctx)) { 381 memset(&inode, 0, sizeof(inode)); 382 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, &inode, 383 "clear_resize"); 384 ctx->flags |= E2F_FLAG_RESIZE_INODE; 385 } 386 if (!(ctx->options & E2F_OPT_READONLY)) { 387 fs->super->s_state &= ~EXT2_VALID_FS; 388 ext2fs_mark_super_dirty(fs); 389 } 390 goto cleanup; 391 } 392 dind_buf = (__u32 *) e2fsck_allocate_memory(ctx, fs->blocksize * 2, 393 "resize dind buffer"); 394 ind_buf = (__u32 *) ((char *) dind_buf + fs->blocksize); 395 396 retval = ext2fs_read_ind_block(fs, blk, dind_buf); 397 if (retval) 398 goto resize_inode_invalid; 399 400 gdt_off = fs->desc_blocks; 401 pblk = fs->super->s_first_data_block + 1 + fs->desc_blocks; 402 for (i = 0; i < fs->super->s_reserved_gdt_blocks / 4; 403 i++, gdt_off++, pblk++) { 404 gdt_off %= fs->blocksize/4; 405 if (dind_buf[gdt_off] != pblk) 406 goto resize_inode_invalid; 407 retval = ext2fs_read_ind_block(fs, pblk, ind_buf); 408 if (retval) 409 goto resize_inode_invalid; 410 ind_off = 0; 411 for (j = 1; j < fs->group_desc_count; j++) { 412 if (!ext2fs_bg_has_super(fs, j)) 413 continue; 414 expect = pblk + (j * fs->super->s_blocks_per_group); 415 if (ind_buf[ind_off] != expect) 416 goto resize_inode_invalid; 417 ind_off++; 418 } 419 } 420 421 cleanup: 422 if (dind_buf) 423 ext2fs_free_mem(&dind_buf); 424 425 } 426 427 /* 428 * This function checks the dirhash signed/unsigned hint if necessary. 429 */ 430 static void e2fsck_fix_dirhash_hint(e2fsck_t ctx) 431 { 432 struct ext2_super_block *sb = ctx->fs->super; 433 struct problem_context pctx; 434 char c; 435 436 if ((ctx->options & E2F_OPT_READONLY) || 437 !(sb->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) || 438 (sb->s_flags & (EXT2_FLAGS_SIGNED_HASH|EXT2_FLAGS_UNSIGNED_HASH))) 439 return; 440 441 c = (char) 255; 442 443 clear_problem_context(&pctx); 444 if (fix_problem(ctx, PR_0_DIRHASH_HINT, &pctx)) { 445 if (((int) c) == -1) { 446 sb->s_flags |= EXT2_FLAGS_SIGNED_HASH; 447 } else { 448 sb->s_flags |= EXT2_FLAGS_UNSIGNED_HASH; 449 } 450 ext2fs_mark_super_dirty(ctx->fs); 451 } 452 } 453 454 455 void check_super_block(e2fsck_t ctx) 456 { 457 ext2_filsys fs = ctx->fs; 458 blk_t first_block, last_block; 459 struct ext2_super_block *sb = fs->super; 460 struct ext2_group_desc *gd; 461 blk_t blocks_per_group = fs->super->s_blocks_per_group; 462 blk_t bpg_max; 463 int inodes_per_block; 464 int ipg_max; 465 int inode_size; 466 int buggy_init_scripts; 467 dgrp_t i; 468 blk_t should_be; 469 struct problem_context pctx; 470 __u32 free_blocks = 0, free_inodes = 0; 471 472 inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super); 473 ipg_max = inodes_per_block * (blocks_per_group - 4); 474 if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb)) 475 ipg_max = EXT2_MAX_INODES_PER_GROUP(sb); 476 bpg_max = 8 * EXT2_BLOCK_SIZE(sb); 477 if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb)) 478 bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb); 479 480 ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, 481 sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap"); 482 ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, 483 sizeof(int) * fs->group_desc_count, "invalid_block_bitmap"); 484 ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx, 485 sizeof(int) * fs->group_desc_count, "invalid_inode_table"); 486 487 clear_problem_context(&pctx); 488 489 /* 490 * Verify the super block constants... 491 */ 492 check_super_value(ctx, "inodes_count", sb->s_inodes_count, 493 MIN_CHECK, 1, 0); 494 check_super_value(ctx, "blocks_count", sb->s_blocks_count, 495 MIN_CHECK, 1, 0); 496 check_super_value(ctx, "first_data_block", sb->s_first_data_block, 497 MAX_CHECK, 0, sb->s_blocks_count); 498 check_super_value(ctx, "log_block_size", sb->s_log_block_size, 499 MIN_CHECK | MAX_CHECK, 0, 500 EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE); 501 check_super_value(ctx, "log_frag_size", sb->s_log_frag_size, 502 MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size); 503 check_super_value(ctx, "frags_per_group", sb->s_frags_per_group, 504 MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group, 505 bpg_max); 506 check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group, 507 MIN_CHECK | MAX_CHECK, 8, bpg_max); 508 check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group, 509 MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max); 510 check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count, 511 MAX_CHECK, 0, sb->s_blocks_count / 2); 512 check_super_value(ctx, "reserved_gdt_blocks", 513 sb->s_reserved_gdt_blocks, MAX_CHECK, 0, 514 fs->blocksize/4); 515 inode_size = EXT2_INODE_SIZE(sb); 516 check_super_value(ctx, "inode_size", 517 inode_size, MIN_CHECK | MAX_CHECK, 518 EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize); 519 if (inode_size & (inode_size - 1)) { 520 pctx.num = inode_size; 521 pctx.str = "inode_size"; 522 fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); 523 ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ 524 return; 525 } 526 527 if ((ctx->flags & E2F_FLAG_GOT_DEVSIZE) && 528 (ctx->num_blocks < sb->s_blocks_count)) { 529 pctx.blk = sb->s_blocks_count; 530 pctx.blk2 = ctx->num_blocks; 531 if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) { 532 ctx->flags |= E2F_FLAG_ABORT; 533 return; 534 } 535 } 536 537 if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) { 538 pctx.blk = EXT2_BLOCK_SIZE(sb); 539 pctx.blk2 = EXT2_FRAG_SIZE(sb); 540 fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx); 541 ctx->flags |= E2F_FLAG_ABORT; 542 return; 543 } 544 545 should_be = sb->s_frags_per_group >> 546 (sb->s_log_block_size - sb->s_log_frag_size); 547 if (sb->s_blocks_per_group != should_be) { 548 pctx.blk = sb->s_blocks_per_group; 549 pctx.blk2 = should_be; 550 fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx); 551 ctx->flags |= E2F_FLAG_ABORT; 552 return; 553 } 554 555 should_be = (sb->s_log_block_size == 0) ? 1 : 0; 556 if (sb->s_first_data_block != should_be) { 557 pctx.blk = sb->s_first_data_block; 558 pctx.blk2 = should_be; 559 fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx); 560 ctx->flags |= E2F_FLAG_ABORT; 561 return; 562 } 563 564 should_be = sb->s_inodes_per_group * fs->group_desc_count; 565 if (sb->s_inodes_count != should_be) { 566 pctx.ino = sb->s_inodes_count; 567 pctx.ino2 = should_be; 568 if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) { 569 sb->s_inodes_count = should_be; 570 ext2fs_mark_super_dirty(fs); 571 } 572 } 573 574 /* 575 * Verify the group descriptors.... 576 */ 577 first_block = sb->s_first_data_block; 578 579 for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) { 580 pctx.group = i; 581 582 first_block = ext2fs_group_first_block(fs, i); 583 last_block = ext2fs_group_last_block(fs, i); 584 585 if ((gd->bg_block_bitmap < first_block) || 586 (gd->bg_block_bitmap > last_block)) { 587 pctx.blk = gd->bg_block_bitmap; 588 if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) 589 gd->bg_block_bitmap = 0; 590 } 591 if (gd->bg_block_bitmap == 0) { 592 ctx->invalid_block_bitmap_flag[i]++; 593 ctx->invalid_bitmaps++; 594 } 595 if ((gd->bg_inode_bitmap < first_block) || 596 (gd->bg_inode_bitmap > last_block)) { 597 pctx.blk = gd->bg_inode_bitmap; 598 if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) 599 gd->bg_inode_bitmap = 0; 600 } 601 if (gd->bg_inode_bitmap == 0) { 602 ctx->invalid_inode_bitmap_flag[i]++; 603 ctx->invalid_bitmaps++; 604 } 605 if ((gd->bg_inode_table < first_block) || 606 ((gd->bg_inode_table + 607 fs->inode_blocks_per_group - 1) > last_block)) { 608 pctx.blk = gd->bg_inode_table; 609 if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) 610 gd->bg_inode_table = 0; 611 } 612 if (gd->bg_inode_table == 0) { 613 ctx->invalid_inode_table_flag[i]++; 614 ctx->invalid_bitmaps++; 615 } 616 free_blocks += gd->bg_free_blocks_count; 617 free_inodes += gd->bg_free_inodes_count; 618 619 if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) || 620 (gd->bg_free_inodes_count > sb->s_inodes_per_group) || 621 (gd->bg_used_dirs_count > sb->s_inodes_per_group)) 622 ext2fs_unmark_valid(fs); 623 624 } 625 626 /* 627 * Update the global counts from the block group counts. This 628 * is needed for an experimental patch which eliminates 629 * locking the entire filesystem when allocating blocks or 630 * inodes; if the filesystem is not unmounted cleanly, the 631 * global counts may not be accurate. 632 */ 633 if ((free_blocks != sb->s_free_blocks_count) || 634 (free_inodes != sb->s_free_inodes_count)) { 635 if (ctx->options & E2F_OPT_READONLY) 636 ext2fs_unmark_valid(fs); 637 else { 638 sb->s_free_blocks_count = free_blocks; 639 sb->s_free_inodes_count = free_inodes; 640 ext2fs_mark_super_dirty(fs); 641 } 642 } 643 644 if ((sb->s_free_blocks_count > sb->s_blocks_count) || 645 (sb->s_free_inodes_count > sb->s_inodes_count)) 646 ext2fs_unmark_valid(fs); 647 648 649 /* 650 * If we have invalid bitmaps, set the error state of the 651 * filesystem. 652 */ 653 if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) { 654 sb->s_state &= ~EXT2_VALID_FS; 655 ext2fs_mark_super_dirty(fs); 656 } 657 658 clear_problem_context(&pctx); 659 660 #ifndef EXT2_SKIP_UUID 661 /* 662 * If the UUID field isn't assigned, assign it. 663 */ 664 if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) { 665 if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) { 666 uuid_generate(sb->s_uuid); 667 ext2fs_mark_super_dirty(fs); 668 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 669 } 670 } 671 #endif 672 673 /* 674 * For the Hurd, check to see if the filetype option is set, 675 * since it doesn't support it. 676 */ 677 if (!(ctx->options & E2F_OPT_READONLY) && 678 fs->super->s_creator_os == EXT2_OS_HURD && 679 (fs->super->s_feature_incompat & 680 EXT2_FEATURE_INCOMPAT_FILETYPE)) { 681 if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) { 682 fs->super->s_feature_incompat &= 683 ~EXT2_FEATURE_INCOMPAT_FILETYPE; 684 ext2fs_mark_super_dirty(fs); 685 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 686 } 687 } 688 689 /* 690 * If we have any of the compatibility flags set, we need to have a 691 * revision 1 filesystem. Most kernels will not check the flags on 692 * a rev 0 filesystem and we may have corruption issues because of 693 * the incompatible changes to the filesystem. 694 */ 695 if (!(ctx->options & E2F_OPT_READONLY) && 696 fs->super->s_rev_level == EXT2_GOOD_OLD_REV && 697 (fs->super->s_feature_compat || 698 fs->super->s_feature_ro_compat || 699 fs->super->s_feature_incompat) && 700 fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) { 701 ext2fs_update_dynamic_rev(fs); 702 ext2fs_mark_super_dirty(fs); 703 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 704 } 705 706 check_resize_inode(ctx); 707 708 /* 709 * Clean up any orphan inodes, if present. 710 */ 711 if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) { 712 fs->super->s_state &= ~EXT2_VALID_FS; 713 ext2fs_mark_super_dirty(fs); 714 } 715 716 /* 717 * Some buggy distributions (such as Ubuntu) have init scripts 718 * and/or installers which fail to correctly set the system 719 * clock before running e2fsck and/or formatting the 720 * filesystem initially. Normally this happens because the 721 * hardware clock is ticking localtime, instead of the more 722 * proper and less error-prone UTC time. So while the kernel 723 * is booting, the system time (which in Linux systems always 724 * ticks in UTC time) is set from the hardware clock, but 725 * since the hardware clock is ticking localtime, the system 726 * time is incorrect. Unfortunately, some buggy distributions 727 * do not correct this before running e2fsck. If this option 728 * is set to a boolean value of true, we attempt to work 729 * around this situation by allowing the superblock last write 730 * time, last mount time, and last check time to be in the 731 * future by up to 24 hours. 732 */ 733 profile_get_boolean(ctx->profile, "options", "buggy_init_scripts", 734 0, 0, &buggy_init_scripts); 735 ctx->time_fudge = buggy_init_scripts ? 86400 : 0; 736 737 /* 738 * Check to see if the superblock last mount time or last 739 * write time is in the future. 740 */ 741 if (fs->super->s_mtime > (__u32) ctx->now + ctx->time_fudge) { 742 pctx.num = fs->super->s_mtime; 743 if (fix_problem(ctx, PR_0_FUTURE_SB_LAST_MOUNT, &pctx)) { 744 fs->super->s_mtime = ctx->now; 745 ext2fs_mark_super_dirty(fs); 746 } 747 } 748 if (fs->super->s_wtime > (__u32) ctx->now + ctx->time_fudge) { 749 pctx.num = fs->super->s_wtime; 750 if (fix_problem(ctx, PR_0_FUTURE_SB_LAST_WRITE, &pctx)) { 751 fs->super->s_wtime = ctx->now; 752 ext2fs_mark_super_dirty(fs); 753 } 754 } 755 756 /* 757 * Move the ext3 journal file, if necessary. 758 */ 759 e2fsck_move_ext3_journal(ctx); 760 761 /* 762 * Fix journal hint, if necessary 763 */ 764 e2fsck_fix_ext3_journal_hint(ctx); 765 766 /* 767 * Add dirhash hint if necessary 768 */ 769 e2fsck_fix_dirhash_hint(ctx); 770 771 return; 772 } 773 774 /* 775 * Check to see if we should backup the master sb to the backup super 776 * blocks. Returns non-zero if the sb should be backed up. 777 */ 778 779 /* 780 * A few flags are set on the fly by the kernel, but only in the 781 * primary superblock. This is actually a bad thing, and we should 782 * try to discourage it in the future. In particular, for the newer 783 * ext4 files, especially EXT4_FEATURE_RO_COMPAT_DIR_NLINK and 784 * EXT3_FEATURE_INCOMPAT_EXTENTS. So some of these may go away in the 785 * future. 786 * 787 * The kernel will set EXT2_FEATURE_COMPAT_EXT_ATTR, but 788 * unfortunately, we shouldn't ignore it since if it's not set in the 789 * backup, the extended attributes in the filesystem will be stripped 790 * away. 791 */ 792 #define FEATURE_RO_COMPAT_IGNORE (EXT2_FEATURE_RO_COMPAT_LARGE_FILE| \ 793 EXT4_FEATURE_RO_COMPAT_DIR_NLINK) 794 #define FEATURE_INCOMPAT_IGNORE (EXT3_FEATURE_INCOMPAT_EXTENTS) 795 796 int check_backup_super_block(e2fsck_t ctx) 797 { 798 ext2_filsys fs = ctx->fs; 799 ext2_filsys tfs = 0; 800 io_manager io_ptr; 801 errcode_t retval; 802 dgrp_t g; 803 blk_t sb; 804 int ret = 0; 805 806 /* 807 * If we are already writing out the backup blocks, then we 808 * don't need to test. Also, if the filesystem is invalid, or 809 * the check was aborted or cancelled, we also don't want to 810 * do the backup. If the filesystem was opened read-only then 811 * we can't do the backup. 812 */ 813 if (((fs->flags & EXT2_FLAG_MASTER_SB_ONLY) == 0) || 814 !ext2fs_test_valid(fs) || 815 (fs->super->s_state & EXT2_ERROR_FS) || 816 (ctx->flags & (E2F_FLAG_ABORT | E2F_FLAG_CANCEL)) || 817 (ctx->options & E2F_OPT_READONLY)) 818 return 0; 819 820 for (g = 1; g < fs->group_desc_count; g++) { 821 if (!ext2fs_bg_has_super(fs, g)) 822 continue; 823 824 sb = fs->super->s_first_data_block + 825 (g * fs->super->s_blocks_per_group); 826 827 retval = ext2fs_open(ctx->filesystem_name, 0, 828 sb, fs->blocksize, 829 fs->io->manager, &tfs); 830 if (retval) { 831 tfs = 0; 832 continue; 833 } 834 835 #define SUPER_INCOMPAT_DIFFERENT(x) \ 836 (( fs->super->x & ~FEATURE_INCOMPAT_IGNORE) != \ 837 (tfs->super->x & ~FEATURE_INCOMPAT_IGNORE)) 838 #define SUPER_RO_COMPAT_DIFFERENT(x) \ 839 (( fs->super->x & ~FEATURE_RO_COMPAT_IGNORE) != \ 840 (tfs->super->x & ~FEATURE_RO_COMPAT_IGNORE)) 841 #define SUPER_DIFFERENT(x) \ 842 (fs->super->x != tfs->super->x) 843 844 if (SUPER_DIFFERENT(s_feature_compat) || 845 SUPER_INCOMPAT_DIFFERENT(s_feature_incompat) || 846 SUPER_RO_COMPAT_DIFFERENT(s_feature_ro_compat) || 847 SUPER_DIFFERENT(s_blocks_count) || 848 SUPER_DIFFERENT(s_inodes_count) || 849 memcmp(fs->super->s_uuid, tfs->super->s_uuid, 850 sizeof(fs->super->s_uuid))) 851 ret = 1; 852 ext2fs_close(tfs); 853 break; 854 } 855 return ret; 856 } 857
