super.c revision 88b34b1f87c2d7c3dfc9be7ff6e5d916f06d960a
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 25static 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 */ 44struct 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 56static 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 */ 153static 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 */ 225static 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; 297return_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 */ 308static 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 421cleanup: 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 */ 430static 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 455void 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 blk_t free_blocks = 0; 471 ino_t free_inodes = 0; 472 473 inodes_per_block = EXT2_INODES_PER_BLOCK(fs->super); 474 ipg_max = inodes_per_block * (blocks_per_group - 4); 475 if (ipg_max > EXT2_MAX_INODES_PER_GROUP(sb)) 476 ipg_max = EXT2_MAX_INODES_PER_GROUP(sb); 477 bpg_max = 8 * EXT2_BLOCK_SIZE(sb); 478 if (bpg_max > EXT2_MAX_BLOCKS_PER_GROUP(sb)) 479 bpg_max = EXT2_MAX_BLOCKS_PER_GROUP(sb); 480 481 ctx->invalid_inode_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, 482 sizeof(int) * fs->group_desc_count, "invalid_inode_bitmap"); 483 ctx->invalid_block_bitmap_flag = (int *) e2fsck_allocate_memory(ctx, 484 sizeof(int) * fs->group_desc_count, "invalid_block_bitmap"); 485 ctx->invalid_inode_table_flag = (int *) e2fsck_allocate_memory(ctx, 486 sizeof(int) * fs->group_desc_count, "invalid_inode_table"); 487 488 clear_problem_context(&pctx); 489 490 /* 491 * Verify the super block constants... 492 */ 493 check_super_value(ctx, "inodes_count", sb->s_inodes_count, 494 MIN_CHECK, 1, 0); 495 check_super_value(ctx, "blocks_count", sb->s_blocks_count, 496 MIN_CHECK, 1, 0); 497 check_super_value(ctx, "first_data_block", sb->s_first_data_block, 498 MAX_CHECK, 0, sb->s_blocks_count); 499 check_super_value(ctx, "log_block_size", sb->s_log_block_size, 500 MIN_CHECK | MAX_CHECK, 0, 501 EXT2_MAX_BLOCK_LOG_SIZE - EXT2_MIN_BLOCK_LOG_SIZE); 502 check_super_value(ctx, "log_frag_size", sb->s_log_frag_size, 503 MIN_CHECK | MAX_CHECK, 0, sb->s_log_block_size); 504 check_super_value(ctx, "frags_per_group", sb->s_frags_per_group, 505 MIN_CHECK | MAX_CHECK, sb->s_blocks_per_group, 506 bpg_max); 507 check_super_value(ctx, "blocks_per_group", sb->s_blocks_per_group, 508 MIN_CHECK | MAX_CHECK, 8, bpg_max); 509 check_super_value(ctx, "inodes_per_group", sb->s_inodes_per_group, 510 MIN_CHECK | MAX_CHECK, inodes_per_block, ipg_max); 511 check_super_value(ctx, "r_blocks_count", sb->s_r_blocks_count, 512 MAX_CHECK, 0, sb->s_blocks_count / 2); 513 check_super_value(ctx, "reserved_gdt_blocks", 514 sb->s_reserved_gdt_blocks, MAX_CHECK, 0, 515 fs->blocksize/4); 516 inode_size = EXT2_INODE_SIZE(sb); 517 check_super_value(ctx, "inode_size", 518 inode_size, MIN_CHECK | MAX_CHECK, 519 EXT2_GOOD_OLD_INODE_SIZE, fs->blocksize); 520 if (inode_size & (inode_size - 1)) { 521 pctx.num = inode_size; 522 pctx.str = "inode_size"; 523 fix_problem(ctx, PR_0_MISC_CORRUPT_SUPER, &pctx); 524 ctx->flags |= E2F_FLAG_ABORT; /* never get here! */ 525 return; 526 } 527 528 if ((ctx->flags & E2F_FLAG_GOT_DEVSIZE) && 529 (ctx->num_blocks < sb->s_blocks_count)) { 530 pctx.blk = sb->s_blocks_count; 531 pctx.blk2 = ctx->num_blocks; 532 if (fix_problem(ctx, PR_0_FS_SIZE_WRONG, &pctx)) { 533 ctx->flags |= E2F_FLAG_ABORT; 534 return; 535 } 536 } 537 538 if (sb->s_log_block_size != (__u32) sb->s_log_frag_size) { 539 pctx.blk = EXT2_BLOCK_SIZE(sb); 540 pctx.blk2 = EXT2_FRAG_SIZE(sb); 541 fix_problem(ctx, PR_0_NO_FRAGMENTS, &pctx); 542 ctx->flags |= E2F_FLAG_ABORT; 543 return; 544 } 545 546 should_be = sb->s_frags_per_group >> 547 (sb->s_log_block_size - sb->s_log_frag_size); 548 if (sb->s_blocks_per_group != should_be) { 549 pctx.blk = sb->s_blocks_per_group; 550 pctx.blk2 = should_be; 551 fix_problem(ctx, PR_0_BLOCKS_PER_GROUP, &pctx); 552 ctx->flags |= E2F_FLAG_ABORT; 553 return; 554 } 555 556 should_be = (sb->s_log_block_size == 0) ? 1 : 0; 557 if (sb->s_first_data_block != should_be) { 558 pctx.blk = sb->s_first_data_block; 559 pctx.blk2 = should_be; 560 fix_problem(ctx, PR_0_FIRST_DATA_BLOCK, &pctx); 561 ctx->flags |= E2F_FLAG_ABORT; 562 return; 563 } 564 565 should_be = sb->s_inodes_per_group * fs->group_desc_count; 566 if (sb->s_inodes_count != should_be) { 567 pctx.ino = sb->s_inodes_count; 568 pctx.ino2 = should_be; 569 if (fix_problem(ctx, PR_0_INODE_COUNT_WRONG, &pctx)) { 570 sb->s_inodes_count = should_be; 571 ext2fs_mark_super_dirty(fs); 572 } 573 } 574 575 /* 576 * Verify the group descriptors.... 577 */ 578 first_block = sb->s_first_data_block; 579 last_block = sb->s_blocks_count-1; 580 581 for (i = 0, gd=fs->group_desc; i < fs->group_desc_count; i++, gd++) { 582 pctx.group = i; 583 584 if (!EXT2_HAS_INCOMPAT_FEATURE(fs->super, 585 EXT4_FEATURE_INCOMPAT_FLEX_BG)) { 586 first_block = ext2fs_group_first_block(fs, i); 587 last_block = ext2fs_group_last_block(fs, i); 588 } 589 590 if ((gd->bg_block_bitmap < first_block) || 591 (gd->bg_block_bitmap > last_block)) { 592 pctx.blk = gd->bg_block_bitmap; 593 if (fix_problem(ctx, PR_0_BB_NOT_GROUP, &pctx)) 594 gd->bg_block_bitmap = 0; 595 } 596 if (gd->bg_block_bitmap == 0) { 597 ctx->invalid_block_bitmap_flag[i]++; 598 ctx->invalid_bitmaps++; 599 } 600 if ((gd->bg_inode_bitmap < first_block) || 601 (gd->bg_inode_bitmap > last_block)) { 602 pctx.blk = gd->bg_inode_bitmap; 603 if (fix_problem(ctx, PR_0_IB_NOT_GROUP, &pctx)) 604 gd->bg_inode_bitmap = 0; 605 } 606 if (gd->bg_inode_bitmap == 0) { 607 ctx->invalid_inode_bitmap_flag[i]++; 608 ctx->invalid_bitmaps++; 609 } 610 if ((gd->bg_inode_table < first_block) || 611 ((gd->bg_inode_table + 612 fs->inode_blocks_per_group - 1) > last_block)) { 613 pctx.blk = gd->bg_inode_table; 614 if (fix_problem(ctx, PR_0_ITABLE_NOT_GROUP, &pctx)) 615 gd->bg_inode_table = 0; 616 } 617 if (gd->bg_inode_table == 0) { 618 ctx->invalid_inode_table_flag[i]++; 619 ctx->invalid_bitmaps++; 620 } 621 free_blocks += gd->bg_free_blocks_count; 622 free_inodes += gd->bg_free_inodes_count; 623 624 if ((gd->bg_free_blocks_count > sb->s_blocks_per_group) || 625 (gd->bg_free_inodes_count > sb->s_inodes_per_group) || 626 (gd->bg_used_dirs_count > sb->s_inodes_per_group)) 627 ext2fs_unmark_valid(fs); 628 629 } 630 631 /* 632 * Update the global counts from the block group counts. This 633 * is needed for an experimental patch which eliminates 634 * locking the entire filesystem when allocating blocks or 635 * inodes; if the filesystem is not unmounted cleanly, the 636 * global counts may not be accurate. 637 */ 638 if ((free_blocks != sb->s_free_blocks_count) || 639 (free_inodes != sb->s_free_inodes_count)) { 640 if (ctx->options & E2F_OPT_READONLY) 641 ext2fs_unmark_valid(fs); 642 else { 643 sb->s_free_blocks_count = free_blocks; 644 sb->s_free_inodes_count = free_inodes; 645 ext2fs_mark_super_dirty(fs); 646 } 647 } 648 649 if ((sb->s_free_blocks_count > sb->s_blocks_count) || 650 (sb->s_free_inodes_count > sb->s_inodes_count)) 651 ext2fs_unmark_valid(fs); 652 653 654 /* 655 * If we have invalid bitmaps, set the error state of the 656 * filesystem. 657 */ 658 if (ctx->invalid_bitmaps && !(ctx->options & E2F_OPT_READONLY)) { 659 sb->s_state &= ~EXT2_VALID_FS; 660 ext2fs_mark_super_dirty(fs); 661 } 662 663 clear_problem_context(&pctx); 664 665#ifndef EXT2_SKIP_UUID 666 /* 667 * If the UUID field isn't assigned, assign it. 668 */ 669 if (!(ctx->options & E2F_OPT_READONLY) && uuid_is_null(sb->s_uuid)) { 670 if (fix_problem(ctx, PR_0_ADD_UUID, &pctx)) { 671 uuid_generate(sb->s_uuid); 672 ext2fs_mark_super_dirty(fs); 673 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 674 } 675 } 676#endif 677 678 /* 679 * For the Hurd, check to see if the filetype option is set, 680 * since it doesn't support it. 681 */ 682 if (!(ctx->options & E2F_OPT_READONLY) && 683 fs->super->s_creator_os == EXT2_OS_HURD && 684 (fs->super->s_feature_incompat & 685 EXT2_FEATURE_INCOMPAT_FILETYPE)) { 686 if (fix_problem(ctx, PR_0_HURD_CLEAR_FILETYPE, &pctx)) { 687 fs->super->s_feature_incompat &= 688 ~EXT2_FEATURE_INCOMPAT_FILETYPE; 689 ext2fs_mark_super_dirty(fs); 690 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 691 } 692 } 693 694 /* 695 * If we have any of the compatibility flags set, we need to have a 696 * revision 1 filesystem. Most kernels will not check the flags on 697 * a rev 0 filesystem and we may have corruption issues because of 698 * the incompatible changes to the filesystem. 699 */ 700 if (!(ctx->options & E2F_OPT_READONLY) && 701 fs->super->s_rev_level == EXT2_GOOD_OLD_REV && 702 (fs->super->s_feature_compat || 703 fs->super->s_feature_ro_compat || 704 fs->super->s_feature_incompat) && 705 fix_problem(ctx, PR_0_FS_REV_LEVEL, &pctx)) { 706 ext2fs_update_dynamic_rev(fs); 707 ext2fs_mark_super_dirty(fs); 708 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 709 } 710 711 check_resize_inode(ctx); 712 713 /* 714 * Clean up any orphan inodes, if present. 715 */ 716 if (!(ctx->options & E2F_OPT_READONLY) && release_orphan_inodes(ctx)) { 717 fs->super->s_state &= ~EXT2_VALID_FS; 718 ext2fs_mark_super_dirty(fs); 719 } 720 721 /* 722 * Some buggy distributions (such as Ubuntu) have init scripts 723 * and/or installers which fail to correctly set the system 724 * clock before running e2fsck and/or formatting the 725 * filesystem initially. Normally this happens because the 726 * hardware clock is ticking localtime, instead of the more 727 * proper and less error-prone UTC time. So while the kernel 728 * is booting, the system time (which in Linux systems always 729 * ticks in UTC time) is set from the hardware clock, but 730 * since the hardware clock is ticking localtime, the system 731 * time is incorrect. Unfortunately, some buggy distributions 732 * do not correct this before running e2fsck. If this option 733 * is set to a boolean value of true, we attempt to work 734 * around this situation by allowing the superblock last write 735 * time, last mount time, and last check time to be in the 736 * future by up to 24 hours. 737 */ 738 profile_get_boolean(ctx->profile, "options", "buggy_init_scripts", 739 0, 0, &buggy_init_scripts); 740 ctx->time_fudge = buggy_init_scripts ? 86400 : 0; 741 742 /* 743 * Check to see if the superblock last mount time or last 744 * write time is in the future. 745 */ 746 if (fs->super->s_mtime > (__u32) ctx->now + ctx->time_fudge) { 747 pctx.num = fs->super->s_mtime; 748 if (fix_problem(ctx, PR_0_FUTURE_SB_LAST_MOUNT, &pctx)) { 749 fs->super->s_mtime = ctx->now; 750 ext2fs_mark_super_dirty(fs); 751 } 752 } 753 if (fs->super->s_wtime > (__u32) ctx->now + ctx->time_fudge) { 754 pctx.num = fs->super->s_wtime; 755 if (fix_problem(ctx, PR_0_FUTURE_SB_LAST_WRITE, &pctx)) { 756 fs->super->s_wtime = ctx->now; 757 ext2fs_mark_super_dirty(fs); 758 } 759 } 760 761 /* 762 * Move the ext3 journal file, if necessary. 763 */ 764 e2fsck_move_ext3_journal(ctx); 765 766 /* 767 * Fix journal hint, if necessary 768 */ 769 e2fsck_fix_ext3_journal_hint(ctx); 770 771 /* 772 * Add dirhash hint if necessary 773 */ 774 e2fsck_fix_dirhash_hint(ctx); 775 776 return; 777} 778 779/* 780 * Check to see if we should backup the master sb to the backup super 781 * blocks. 782 */ 783int check_backup_super_block(e2fsck_t ctx) 784{ 785 ext2_filsys fs = ctx->fs; 786 ext2_filsys tfs = 0; 787 io_manager io_ptr; 788 errcode_t retval; 789 dgrp_t g; 790 blk_t sb; 791 int ret = 0; 792 793 /* 794 * If we are already writing out the backup blocks, then we 795 * don't need to test. Also, if the filesystem is invalid, or 796 * the check was aborted or cancelled, we also don't want to 797 * do the backup. If the filesystem was opened read-only then 798 * we can't do the backup. 799 */ 800 if (((fs->flags & EXT2_FLAG_MASTER_SB_ONLY) == 0) || 801 !ext2fs_test_valid(fs) || 802 (fs->super->s_state & EXT2_ERROR_FS) || 803 (ctx->flags & (E2F_FLAG_ABORT | E2F_FLAG_CANCEL)) || 804 (ctx->options & E2F_OPT_READONLY)) 805 return 0; 806 807 for (g = 1; g < fs->group_desc_count; g++) { 808 if (!ext2fs_bg_has_super(fs, g)) 809 continue; 810 811 sb = fs->super->s_first_data_block + 812 (g * fs->super->s_blocks_per_group); 813 814 retval = ext2fs_open(ctx->filesystem_name, 0, 815 sb, fs->blocksize, 816 fs->io->manager, &tfs); 817 if (retval) { 818 tfs = 0; 819 continue; 820 } 821 822#define SUPER_DIFFERENT(x) (fs->super->x != tfs->super->x) 823 if (SUPER_DIFFERENT(s_feature_compat) || 824 SUPER_DIFFERENT(s_feature_incompat) || 825 SUPER_DIFFERENT(s_feature_ro_compat) || 826 SUPER_DIFFERENT(s_blocks_count) || 827 SUPER_DIFFERENT(s_inodes_count) || 828 memcmp(fs->super->s_uuid, tfs->super->s_uuid, 829 sizeof(fs->super->s_uuid))) 830 ret = 1; 831 ext2fs_close(tfs); 832 break; 833 } 834 return ret; 835} 836