pass1.c revision 2fe2d408a4e231eb5d2342b7f3dbd155563aa755
1/* 2 * pass1.c -- pass #1 of e2fsck: sequential scan of the inode table 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 * Pass 1 of e2fsck iterates over all the inodes in the filesystems, 12 * and applies the following tests to each inode: 13 * 14 * - The mode field of the inode must be legal. 15 * - The size and block count fields of the inode are correct. 16 * - A data block must not be used by another inode 17 * 18 * Pass 1 also gathers the collects the following information: 19 * 20 * - A bitmap of which inodes are in use. (inode_used_map) 21 * - A bitmap of which inodes are directories. (inode_dir_map) 22 * - A bitmap of which inodes are regular files. (inode_reg_map) 23 * - A bitmap of which inodes have bad fields. (inode_bad_map) 24 * - A bitmap of which inodes are in bad blocks. (inode_bb_map) 25 * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) 26 * - A bitmap of which blocks are in use. (block_found_map) 27 * - A bitmap of which blocks are in use by two inodes (block_dup_map) 28 * - The data blocks of the directory inodes. (dir_map) 29 * 30 * Pass 1 is designed to stash away enough information so that the 31 * other passes should not need to read in the inode information 32 * during the normal course of a filesystem check. (Althogh if an 33 * inconsistency is detected, other passes may need to read in an 34 * inode to fix it.) 35 * 36 * Note that pass 1B will be invoked if there are any duplicate blocks 37 * found. 38 */ 39 40#define _GNU_SOURCE 1 /* get strnlen() */ 41#include "config.h" 42#include <string.h> 43#include <time.h> 44#ifdef HAVE_ERRNO_H 45#include <errno.h> 46#endif 47 48#include "e2fsck.h" 49#include <ext2fs/ext2_ext_attr.h> 50 51#include "problem.h" 52 53#ifdef NO_INLINE_FUNCS 54#define _INLINE_ 55#else 56#define _INLINE_ inline 57#endif 58 59static int process_block(ext2_filsys fs, blk64_t *blocknr, 60 e2_blkcnt_t blockcnt, blk64_t ref_blk, 61 int ref_offset, void *priv_data); 62static int process_bad_block(ext2_filsys fs, blk64_t *block_nr, 63 e2_blkcnt_t blockcnt, blk64_t ref_blk, 64 int ref_offset, void *priv_data); 65static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 66 char *block_buf); 67static void mark_table_blocks(e2fsck_t ctx); 68static void alloc_bb_map(e2fsck_t ctx); 69static void alloc_imagic_map(e2fsck_t ctx); 70static void mark_inode_bad(e2fsck_t ctx, ino_t ino); 71static void handle_fs_bad_blocks(e2fsck_t ctx); 72static void process_inodes(e2fsck_t ctx, char *block_buf); 73static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); 74static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, 75 dgrp_t group, void * priv_data); 76static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 77 char *block_buf, int adjust_sign); 78/* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */ 79 80struct process_block_struct { 81 ext2_ino_t ino; 82 unsigned is_dir:1, is_reg:1, clear:1, suppress:1, 83 fragmented:1, compressed:1, bbcheck:1; 84 blk64_t num_blocks; 85 blk64_t max_blocks; 86 e2_blkcnt_t last_block; 87 e2_blkcnt_t last_init_lblock; 88 e2_blkcnt_t last_db_block; 89 int num_illegal_blocks; 90 blk64_t previous_block; 91 struct ext2_inode *inode; 92 struct problem_context *pctx; 93 ext2fs_block_bitmap fs_meta_blocks; 94 e2fsck_t ctx; 95}; 96 97struct process_inode_block { 98 ext2_ino_t ino; 99 struct ext2_inode inode; 100}; 101 102struct scan_callback_struct { 103 e2fsck_t ctx; 104 char *block_buf; 105}; 106 107/* 108 * For the inodes to process list. 109 */ 110static struct process_inode_block *inodes_to_process; 111static int process_inode_count; 112 113static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - 114 EXT2_MIN_BLOCK_LOG_SIZE + 1]; 115 116/* 117 * Free all memory allocated by pass1 in preparation for restarting 118 * things. 119 */ 120static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused))) 121{ 122 ext2fs_free_mem(&inodes_to_process); 123 inodes_to_process = 0; 124} 125 126/* 127 * Check to make sure a device inode is real. Returns 1 if the device 128 * checks out, 0 if not. 129 * 130 * Note: this routine is now also used to check FIFO's and Sockets, 131 * since they have the same requirement; the i_block fields should be 132 * zero. 133 */ 134int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)), 135 struct ext2_inode *inode) 136{ 137 int i; 138 139 /* 140 * If the index flag is set, then this is a bogus 141 * device/fifo/socket 142 */ 143 if (inode->i_flags & EXT2_INDEX_FL) 144 return 0; 145 146 /* 147 * We should be able to do the test below all the time, but 148 * because the kernel doesn't forcibly clear the device 149 * inode's additional i_block fields, there are some rare 150 * occasions when a legitimate device inode will have non-zero 151 * additional i_block fields. So for now, we only complain 152 * when the immutable flag is set, which should never happen 153 * for devices. (And that's when the problem is caused, since 154 * you can't set or clear immutable flags for devices.) Once 155 * the kernel has been fixed we can change this... 156 */ 157 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) { 158 for (i=4; i < EXT2_N_BLOCKS; i++) 159 if (inode->i_block[i]) 160 return 0; 161 } 162 return 1; 163} 164 165/* 166 * Check to make sure a symlink inode is real. Returns 1 if the symlink 167 * checks out, 0 if not. 168 */ 169int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, 170 struct ext2_inode *inode, char *buf) 171{ 172 unsigned int len; 173 int i; 174 blk64_t blocks; 175 ext2_extent_handle_t handle; 176 struct ext2_extent_info info; 177 struct ext2fs_extent extent; 178 179 if ((inode->i_size_high || inode->i_size == 0) || 180 (inode->i_flags & EXT2_INDEX_FL)) 181 return 0; 182 183 if (inode->i_flags & EXT4_EXTENTS_FL) { 184 if (inode->i_size > fs->blocksize) 185 return 0; 186 if (ext2fs_extent_open2(fs, ino, inode, &handle)) 187 return 0; 188 i = 0; 189 if (ext2fs_extent_get_info(handle, &info) || 190 (info.num_entries != 1) || 191 (info.max_depth != 0)) 192 goto exit_extent; 193 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) || 194 (extent.e_lblk != 0) || 195 (extent.e_len != 1) || 196 (extent.e_pblk < fs->super->s_first_data_block) || 197 (extent.e_pblk >= ext2fs_blocks_count(fs->super))) 198 goto exit_extent; 199 i = 1; 200 exit_extent: 201 ext2fs_extent_free(handle); 202 return i; 203 } 204 205 blocks = ext2fs_inode_data_blocks2(fs, inode); 206 if (blocks) { 207 if ((inode->i_size >= fs->blocksize) || 208 (blocks != fs->blocksize >> 9) || 209 (inode->i_block[0] < fs->super->s_first_data_block) || 210 (inode->i_block[0] >= ext2fs_blocks_count(fs->super))) 211 return 0; 212 213 for (i = 1; i < EXT2_N_BLOCKS; i++) 214 if (inode->i_block[i]) 215 return 0; 216 217 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf)) 218 return 0; 219 220 len = strnlen(buf, fs->blocksize); 221 if (len == fs->blocksize) 222 return 0; 223 } else { 224 if (inode->i_size >= sizeof(inode->i_block)) 225 return 0; 226 227 len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); 228 if (len == sizeof(inode->i_block)) 229 return 0; 230 } 231 if (len != inode->i_size) 232 return 0; 233 return 1; 234} 235 236/* 237 * If the immutable (or append-only) flag is set on the inode, offer 238 * to clear it. 239 */ 240#define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL) 241static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) 242{ 243 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) 244 return; 245 246 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) 247 return; 248 249 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; 250 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 251} 252 253/* 254 * If device, fifo or socket, check size is zero -- if not offer to 255 * clear it 256 */ 257static void check_size(e2fsck_t ctx, struct problem_context *pctx) 258{ 259 struct ext2_inode *inode = pctx->inode; 260 261 if (EXT2_I_SIZE(inode) == 0) 262 return; 263 264 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) 265 return; 266 267 inode->i_size = 0; 268 inode->i_size_high = 0; 269 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 270} 271 272static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) 273{ 274 struct ext2_super_block *sb = ctx->fs->super; 275 struct ext2_inode_large *inode; 276 struct ext2_ext_attr_entry *entry; 277 char *start; 278 unsigned int storage_size, remain; 279 problem_t problem = 0; 280 281 inode = (struct ext2_inode_large *) pctx->inode; 282 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - 283 inode->i_extra_isize; 284 start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 285 inode->i_extra_isize + sizeof(__u32); 286 entry = (struct ext2_ext_attr_entry *) start; 287 288 /* scan all entry's headers first */ 289 290 /* take finish entry 0UL into account */ 291 remain = storage_size - sizeof(__u32); 292 293 while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { 294 __u32 hash; 295 296 /* header eats this space */ 297 remain -= sizeof(struct ext2_ext_attr_entry); 298 299 /* is attribute name valid? */ 300 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) { 301 pctx->num = entry->e_name_len; 302 problem = PR_1_ATTR_NAME_LEN; 303 goto fix; 304 } 305 306 /* attribute len eats this space */ 307 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); 308 309 /* check value size */ 310 if (entry->e_value_size > remain) { 311 pctx->num = entry->e_value_size; 312 problem = PR_1_ATTR_VALUE_SIZE; 313 goto fix; 314 } 315 316 /* e_value_block must be 0 in inode's ea */ 317 if (entry->e_value_block != 0) { 318 pctx->num = entry->e_value_block; 319 problem = PR_1_ATTR_VALUE_BLOCK; 320 goto fix; 321 } 322 323 hash = ext2fs_ext_attr_hash_entry(entry, 324 start + entry->e_value_offs); 325 326 /* e_hash may be 0 in older inode's ea */ 327 if (entry->e_hash != 0 && entry->e_hash != hash) { 328 pctx->num = entry->e_hash; 329 problem = PR_1_ATTR_HASH; 330 goto fix; 331 } 332 333 remain -= entry->e_value_size; 334 335 entry = EXT2_EXT_ATTR_NEXT(entry); 336 } 337fix: 338 /* 339 * it seems like a corruption. it's very unlikely we could repair 340 * EA(s) in automatic fashion -bzzz 341 */ 342 if (problem == 0 || !fix_problem(ctx, problem, pctx)) 343 return; 344 345 /* simply remove all possible EA(s) */ 346 *((__u32 *)start) = 0UL; 347 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 348 EXT2_INODE_SIZE(sb), "pass1"); 349} 350 351static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) 352{ 353 struct ext2_super_block *sb = ctx->fs->super; 354 struct ext2_inode_large *inode; 355 __u32 *eamagic; 356 int min, max; 357 358 inode = (struct ext2_inode_large *) pctx->inode; 359 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { 360 /* this isn't large inode. so, nothing to check */ 361 return; 362 } 363 364#if 0 365 printf("inode #%u, i_extra_size %d\n", pctx->ino, 366 inode->i_extra_isize); 367#endif 368 /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */ 369 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi); 370 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; 371 /* 372 * For now we will allow i_extra_isize to be 0, but really 373 * implementations should never allow i_extra_isize to be 0 374 */ 375 if (inode->i_extra_isize && 376 (inode->i_extra_isize < min || inode->i_extra_isize > max)) { 377 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) 378 return; 379 inode->i_extra_isize = min; 380 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 381 EXT2_INODE_SIZE(sb), "pass1"); 382 return; 383 } 384 385 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 386 inode->i_extra_isize); 387 if (*eamagic == EXT2_EXT_ATTR_MAGIC) { 388 /* it seems inode has an extended attribute(s) in body */ 389 check_ea_in_inode(ctx, pctx); 390 } 391} 392 393/* 394 * Check to see if the inode might really be a directory, despite i_mode 395 * 396 * This is a lot of complexity for something for which I'm not really 397 * convinced happens frequently in the wild. If for any reason this 398 * causes any problems, take this code out. 399 * [tytso:20070331.0827EDT] 400 */ 401static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, 402 char *buf) 403{ 404 struct ext2_inode *inode = pctx->inode; 405 struct ext2_dir_entry *dirent; 406 errcode_t retval; 407 blk64_t blk; 408 unsigned int i, rec_len, not_device = 0; 409 int extent_fs; 410 411 /* 412 * If the mode looks OK, we believe it. If the first block in 413 * the i_block array is 0, this cannot be a directory. If the 414 * inode is extent-mapped, it is still the case that the latter 415 * cannot be 0 - the magic number in the extent header would make 416 * it nonzero. 417 */ 418 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) || 419 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0) 420 return; 421 422 /* 423 * Check the block numbers in the i_block array for validity: 424 * zero blocks are skipped (but the first one cannot be zero - 425 * see above), other blocks are checked against the first and 426 * max data blocks (from the the superblock) and against the 427 * block bitmap. Any invalid block found means this cannot be 428 * a directory. 429 * 430 * If there are non-zero blocks past the fourth entry, then 431 * this cannot be a device file: we remember that for the next 432 * check. 433 * 434 * For extent mapped files, we don't do any sanity checking: 435 * just try to get the phys block of logical block 0 and run 436 * with it. 437 */ 438 439 extent_fs = (ctx->fs->super->s_feature_incompat & 440 EXT3_FEATURE_INCOMPAT_EXTENTS); 441 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { 442 /* extent mapped */ 443 if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0, 444 &blk)) 445 return; 446 /* device files are never extent mapped */ 447 not_device++; 448 } else { 449 for (i=0; i < EXT2_N_BLOCKS; i++) { 450 blk = inode->i_block[i]; 451 if (!blk) 452 continue; 453 if (i >= 4) 454 not_device++; 455 456 if (blk < ctx->fs->super->s_first_data_block || 457 blk >= ext2fs_blocks_count(ctx->fs->super) || 458 ext2fs_fast_test_block_bitmap2(ctx->block_found_map, 459 blk)) 460 return; /* Invalid block, can't be dir */ 461 } 462 blk = inode->i_block[0]; 463 } 464 465 /* 466 * If the mode says this is a device file and the i_links_count field 467 * is sane and we have not ruled it out as a device file previously, 468 * we declare it a device file, not a directory. 469 */ 470 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) && 471 (inode->i_links_count == 1) && !not_device) 472 return; 473 474 /* read the first block */ 475 ehandler_operation(_("reading directory block")); 476 retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0); 477 ehandler_operation(0); 478 if (retval) 479 return; 480 481 dirent = (struct ext2_dir_entry *) buf; 482 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); 483 if (retval) 484 return; 485 if (((dirent->name_len & 0xFF) != 1) || 486 (dirent->name[0] != '.') || 487 (dirent->inode != pctx->ino) || 488 (rec_len < 12) || 489 (rec_len % 4) || 490 (rec_len >= ctx->fs->blocksize - 12)) 491 return; 492 493 dirent = (struct ext2_dir_entry *) (buf + rec_len); 494 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); 495 if (retval) 496 return; 497 if (((dirent->name_len & 0xFF) != 2) || 498 (dirent->name[0] != '.') || 499 (dirent->name[1] != '.') || 500 (rec_len < 12) || 501 (rec_len % 4)) 502 return; 503 504 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) { 505 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR; 506 e2fsck_write_inode_full(ctx, pctx->ino, inode, 507 EXT2_INODE_SIZE(ctx->fs->super), 508 "check_is_really_dir"); 509 } 510} 511 512extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags, 513 ext2_icount_t *ret) 514{ 515 unsigned int threshold; 516 ext2_ino_t num_dirs; 517 errcode_t retval; 518 char *tdb_dir; 519 int enable; 520 521 *ret = 0; 522 523 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0, 524 &tdb_dir); 525 profile_get_uint(ctx->profile, "scratch_files", 526 "numdirs_threshold", 0, 0, &threshold); 527 profile_get_boolean(ctx->profile, "scratch_files", 528 "icount", 0, 1, &enable); 529 530 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); 531 if (retval) 532 num_dirs = 1024; /* Guess */ 533 534 if (!enable || !tdb_dir || access(tdb_dir, W_OK) || 535 (threshold && num_dirs <= threshold)) 536 return; 537 538 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, flags, ret); 539 if (retval) 540 *ret = 0; 541} 542 543void e2fsck_pass1(e2fsck_t ctx) 544{ 545 int i; 546 __u64 max_sizes; 547 ext2_filsys fs = ctx->fs; 548 ext2_ino_t ino = 0; 549 struct ext2_inode *inode; 550 ext2_inode_scan scan; 551 char *block_buf; 552#ifdef RESOURCE_TRACK 553 struct resource_track rtrack; 554#endif 555 unsigned char frag, fsize; 556 struct problem_context pctx; 557 struct scan_callback_struct scan_struct; 558 struct ext2_super_block *sb = ctx->fs->super; 559 const char *old_op; 560 unsigned int save_type; 561 int imagic_fs, extent_fs; 562 int busted_fs_time = 0; 563 int inode_size; 564 565 init_resource_track(&rtrack, ctx->fs->io); 566 clear_problem_context(&pctx); 567 568 if (!(ctx->options & E2F_OPT_PREEN)) 569 fix_problem(ctx, PR_1_PASS_HEADER, &pctx); 570 571 if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && 572 !(ctx->options & E2F_OPT_NO)) { 573 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) 574 ctx->dirs_to_hash = 0; 575 } 576 577#ifdef MTRACE 578 mtrace_print("Pass 1"); 579#endif 580 581#define EXT2_BPP(bits) (1ULL << ((bits) - 2)) 582 583 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { 584 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); 585 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); 586 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); 587 max_sizes = (max_sizes * (1UL << i)); 588 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; 589 } 590#undef EXT2_BPP 591 592 imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); 593 extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS); 594 595 /* 596 * Allocate bitmaps structures 597 */ 598 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"), 599 EXT2FS_BMAP64_RBTREE, 600 "inode_used_map", 601 &ctx->inode_used_map); 602 if (pctx.errcode) { 603 pctx.num = 1; 604 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 605 ctx->flags |= E2F_FLAG_ABORT; 606 return; 607 } 608 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, 609 _("directory inode map"), 610 EXT2FS_BMAP64_AUTODIR, 611 "inode_dir_map", &ctx->inode_dir_map); 612 if (pctx.errcode) { 613 pctx.num = 2; 614 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 615 ctx->flags |= E2F_FLAG_ABORT; 616 return; 617 } 618 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, 619 _("regular file inode map"), EXT2FS_BMAP64_RBTREE, 620 "inode_reg_map", &ctx->inode_reg_map); 621 if (pctx.errcode) { 622 pctx.num = 6; 623 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 624 ctx->flags |= E2F_FLAG_ABORT; 625 return; 626 } 627 pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs, 628 _("in-use block map"), EXT2FS_BMAP64_RBTREE, 629 "block_found_map", &ctx->block_found_map); 630 if (pctx.errcode) { 631 pctx.num = 1; 632 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 633 ctx->flags |= E2F_FLAG_ABORT; 634 return; 635 } 636 e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info); 637 if (!ctx->inode_link_info) { 638 e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, 639 "inode_link_info", &save_type); 640 pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0, 641 &ctx->inode_link_info); 642 fs->default_bitmap_type = save_type; 643 } 644 645 if (pctx.errcode) { 646 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); 647 ctx->flags |= E2F_FLAG_ABORT; 648 return; 649 } 650 inode_size = EXT2_INODE_SIZE(fs->super); 651 inode = (struct ext2_inode *) 652 e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); 653 654 inodes_to_process = (struct process_inode_block *) 655 e2fsck_allocate_memory(ctx, 656 (ctx->process_inode_size * 657 sizeof(struct process_inode_block)), 658 "array of inodes to process"); 659 process_inode_count = 0; 660 661 pctx.errcode = ext2fs_init_dblist(fs, 0); 662 if (pctx.errcode) { 663 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); 664 ctx->flags |= E2F_FLAG_ABORT; 665 ext2fs_free_mem(&inode); 666 return; 667 } 668 669 /* 670 * If the last orphan field is set, clear it, since the pass1 671 * processing will automatically find and clear the orphans. 672 * In the future, we may want to try using the last_orphan 673 * linked list ourselves, but for now, we clear it so that the 674 * ext3 mount code won't get confused. 675 */ 676 if (!(ctx->options & E2F_OPT_READONLY)) { 677 if (fs->super->s_last_orphan) { 678 fs->super->s_last_orphan = 0; 679 ext2fs_mark_super_dirty(fs); 680 } 681 } 682 683 mark_table_blocks(ctx); 684 pctx.errcode = ext2fs_convert_subcluster_bitmap(fs, 685 &ctx->block_found_map); 686 if (pctx.errcode) { 687 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); 688 ctx->flags |= E2F_FLAG_ABORT; 689 ext2fs_free_mem(&inode); 690 return; 691 } 692 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, 693 "block interate buffer"); 694 e2fsck_use_inode_shortcuts(ctx, 1); 695 old_op = ehandler_operation(_("opening inode scan")); 696 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, 697 &scan); 698 ehandler_operation(old_op); 699 if (pctx.errcode) { 700 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); 701 ctx->flags |= E2F_FLAG_ABORT; 702 ext2fs_free_mem(&block_buf); 703 ext2fs_free_mem(&inode); 704 return; 705 } 706 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); 707 ctx->stashed_inode = inode; 708 scan_struct.ctx = ctx; 709 scan_struct.block_buf = block_buf; 710 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); 711 if (ctx->progress) 712 if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count)) 713 return; 714 if ((fs->super->s_wtime < fs->super->s_inodes_count) || 715 (fs->super->s_mtime < fs->super->s_inodes_count)) 716 busted_fs_time = 1; 717 718 if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) && 719 fs->super->s_mmp_block > fs->super->s_first_data_block && 720 fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) 721 ext2fs_mark_block_bitmap2(ctx->block_found_map, 722 fs->super->s_mmp_block); 723 724 while (1) { 725 if (ino % (fs->super->s_inodes_per_group * 4) == 1) { 726 if (e2fsck_mmp_update(fs)) 727 fatal_error(ctx, 0); 728 } 729 old_op = ehandler_operation(_("getting next inode from scan")); 730 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, 731 inode, inode_size); 732 ehandler_operation(old_op); 733 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 734 return; 735 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { 736 if (!ctx->inode_bb_map) 737 alloc_bb_map(ctx); 738 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); 739 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 740 continue; 741 } 742 if (pctx.errcode) { 743 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); 744 ctx->flags |= E2F_FLAG_ABORT; 745 return; 746 } 747 if (!ino) 748 break; 749 pctx.ino = ino; 750 pctx.inode = inode; 751 ctx->stashed_ino = ino; 752 if (inode->i_links_count) { 753 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, 754 ino, inode->i_links_count); 755 if (pctx.errcode) { 756 pctx.num = inode->i_links_count; 757 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); 758 ctx->flags |= E2F_FLAG_ABORT; 759 return; 760 } 761 } 762 763 /* 764 * Test for incorrect extent flag settings. 765 * 766 * On big-endian machines we must be careful: 767 * When the inode is read, the i_block array is not swapped 768 * if the extent flag is set. Therefore if we are testing 769 * for or fixing a wrongly-set flag, we must potentially 770 * (un)swap before testing, or after fixing. 771 */ 772 773 /* 774 * In this case the extents flag was set when read, so 775 * extent_header_verify is ok. If the inode is cleared, 776 * no need to swap... so no extra swapping here. 777 */ 778 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs && 779 (inode->i_links_count || (ino == EXT2_BAD_INO) || 780 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) { 781 if ((ext2fs_extent_header_verify(inode->i_block, 782 sizeof(inode->i_block)) == 0) && 783 fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) { 784 sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS; 785 ext2fs_mark_super_dirty(fs); 786 extent_fs = 1; 787 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) { 788 clear_inode: 789 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 790 if (ino == EXT2_BAD_INO) 791 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, 792 ino); 793 continue; 794 } 795 } 796 797 /* 798 * For big-endian machines: 799 * If the inode didn't have the extents flag set when it 800 * was read, then the i_blocks array was swapped. To test 801 * as an extents header, we must swap it back first. 802 * IF we then set the extents flag, the entire i_block 803 * array must be un/re-swapped to make it proper extents data. 804 */ 805 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) && 806 (inode->i_links_count || (ino == EXT2_BAD_INO) || 807 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) && 808 (LINUX_S_ISREG(inode->i_mode) || 809 LINUX_S_ISDIR(inode->i_mode))) { 810 void *ehp; 811#ifdef WORDS_BIGENDIAN 812 __u32 tmp_block[EXT2_N_BLOCKS]; 813 814 for (i = 0; i < EXT2_N_BLOCKS; i++) 815 tmp_block[i] = ext2fs_swab32(inode->i_block[i]); 816 ehp = tmp_block; 817#else 818 ehp = inode->i_block; 819#endif 820 if ((ext2fs_extent_header_verify(ehp, 821 sizeof(inode->i_block)) == 0) && 822 (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) { 823 inode->i_flags |= EXT4_EXTENTS_FL; 824#ifdef WORDS_BIGENDIAN 825 memcpy(inode->i_block, tmp_block, 826 sizeof(inode->i_block)); 827#endif 828 e2fsck_write_inode(ctx, ino, inode, "pass1"); 829 } 830 } 831 832 if (ino == EXT2_BAD_INO) { 833 struct process_block_struct pb; 834 835 if ((inode->i_mode || inode->i_uid || inode->i_gid || 836 inode->i_links_count || inode->i_file_acl) && 837 fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) { 838 memset(inode, 0, sizeof(struct ext2_inode)); 839 e2fsck_write_inode(ctx, ino, inode, 840 "clear bad inode"); 841 } 842 843 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, 844 &pb.fs_meta_blocks); 845 if (pctx.errcode) { 846 pctx.num = 4; 847 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 848 ctx->flags |= E2F_FLAG_ABORT; 849 return; 850 } 851 pb.ino = EXT2_BAD_INO; 852 pb.num_blocks = pb.last_block = 0; 853 pb.last_db_block = -1; 854 pb.num_illegal_blocks = 0; 855 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0; 856 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0; 857 pb.inode = inode; 858 pb.pctx = &pctx; 859 pb.ctx = ctx; 860 pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, 861 block_buf, process_bad_block, &pb); 862 ext2fs_free_block_bitmap(pb.fs_meta_blocks); 863 if (pctx.errcode) { 864 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); 865 ctx->flags |= E2F_FLAG_ABORT; 866 return; 867 } 868 if (pb.bbcheck) 869 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { 870 ctx->flags |= E2F_FLAG_ABORT; 871 return; 872 } 873 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 874 clear_problem_context(&pctx); 875 continue; 876 } else if (ino == EXT2_ROOT_INO) { 877 /* 878 * Make sure the root inode is a directory; if 879 * not, offer to clear it. It will be 880 * regnerated in pass #3. 881 */ 882 if (!LINUX_S_ISDIR(inode->i_mode)) { 883 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) 884 goto clear_inode; 885 } 886 /* 887 * If dtime is set, offer to clear it. mke2fs 888 * version 0.2b created filesystems with the 889 * dtime field set for the root and lost+found 890 * directories. We won't worry about 891 * /lost+found, since that can be regenerated 892 * easily. But we will fix the root directory 893 * as a special case. 894 */ 895 if (inode->i_dtime && inode->i_links_count) { 896 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { 897 inode->i_dtime = 0; 898 e2fsck_write_inode(ctx, ino, inode, 899 "pass1"); 900 } 901 } 902 } else if (ino == EXT2_JOURNAL_INO) { 903 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 904 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { 905 if (!LINUX_S_ISREG(inode->i_mode) && 906 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, 907 &pctx)) { 908 inode->i_mode = LINUX_S_IFREG; 909 e2fsck_write_inode(ctx, ino, inode, 910 "pass1"); 911 } 912 check_blocks(ctx, &pctx, block_buf); 913 continue; 914 } 915 if ((inode->i_links_count || 916 inode->i_blocks || inode->i_block[0]) && 917 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, 918 &pctx)) { 919 memset(inode, 0, inode_size); 920 ext2fs_icount_store(ctx->inode_link_info, 921 ino, 0); 922 e2fsck_write_inode_full(ctx, ino, inode, 923 inode_size, "pass1"); 924 } 925 } else if ((ino == EXT4_USR_QUOTA_INO) || 926 (ino == EXT4_GRP_QUOTA_INO)) { 927 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 928 if ((fs->super->s_feature_ro_compat & 929 EXT4_FEATURE_RO_COMPAT_QUOTA) && 930 ((fs->super->s_usr_quota_inum == ino) || 931 (fs->super->s_grp_quota_inum == ino))) { 932 if (!LINUX_S_ISREG(inode->i_mode) && 933 fix_problem(ctx, PR_1_QUOTA_BAD_MODE, 934 &pctx)) { 935 inode->i_mode = LINUX_S_IFREG; 936 e2fsck_write_inode(ctx, ino, inode, 937 "pass1"); 938 } 939 check_blocks(ctx, &pctx, block_buf); 940 continue; 941 } 942 if ((inode->i_links_count || 943 inode->i_blocks || inode->i_block[0]) && 944 fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR, 945 &pctx)) { 946 memset(inode, 0, inode_size); 947 ext2fs_icount_store(ctx->inode_link_info, 948 ino, 0); 949 e2fsck_write_inode_full(ctx, ino, inode, 950 inode_size, "pass1"); 951 } 952 } else if (ino < EXT2_FIRST_INODE(fs->super)) { 953 problem_t problem = 0; 954 955 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 956 if (ino == EXT2_BOOT_LOADER_INO) { 957 if (LINUX_S_ISDIR(inode->i_mode)) 958 problem = PR_1_RESERVED_BAD_MODE; 959 } else if (ino == EXT2_RESIZE_INO) { 960 if (inode->i_mode && 961 !LINUX_S_ISREG(inode->i_mode)) 962 problem = PR_1_RESERVED_BAD_MODE; 963 } else { 964 if (inode->i_mode != 0) 965 problem = PR_1_RESERVED_BAD_MODE; 966 } 967 if (problem) { 968 if (fix_problem(ctx, problem, &pctx)) { 969 inode->i_mode = 0; 970 e2fsck_write_inode(ctx, ino, inode, 971 "pass1"); 972 } 973 } 974 check_blocks(ctx, &pctx, block_buf); 975 continue; 976 } 977 978 /* 979 * Check for inodes who might have been part of the 980 * orphaned list linked list. They should have gotten 981 * dealt with by now, unless the list had somehow been 982 * corrupted. 983 * 984 * FIXME: In the future, inodes which are still in use 985 * (and which are therefore) pending truncation should 986 * be handled specially. Right now we just clear the 987 * dtime field, and the normal e2fsck handling of 988 * inodes where i_size and the inode blocks are 989 * inconsistent is to fix i_size, instead of releasing 990 * the extra blocks. This won't catch the inodes that 991 * was at the end of the orphan list, but it's better 992 * than nothing. The right answer is that there 993 * shouldn't be any bugs in the orphan list handling. :-) 994 */ 995 if (inode->i_dtime && !busted_fs_time && 996 inode->i_dtime < ctx->fs->super->s_inodes_count) { 997 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { 998 inode->i_dtime = inode->i_links_count ? 999 0 : ctx->now; 1000 e2fsck_write_inode(ctx, ino, inode, 1001 "pass1"); 1002 } 1003 } 1004 1005 /* 1006 * This code assumes that deleted inodes have 1007 * i_links_count set to 0. 1008 */ 1009 if (!inode->i_links_count) { 1010 if (!inode->i_dtime && inode->i_mode) { 1011 if (fix_problem(ctx, 1012 PR_1_ZERO_DTIME, &pctx)) { 1013 inode->i_dtime = ctx->now; 1014 e2fsck_write_inode(ctx, ino, inode, 1015 "pass1"); 1016 } 1017 } 1018 continue; 1019 } 1020 /* 1021 * n.b. 0.3c ext2fs code didn't clear i_links_count for 1022 * deleted files. Oops. 1023 * 1024 * Since all new ext2 implementations get this right, 1025 * we now assume that the case of non-zero 1026 * i_links_count and non-zero dtime means that we 1027 * should keep the file, not delete it. 1028 * 1029 */ 1030 if (inode->i_dtime) { 1031 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { 1032 inode->i_dtime = 0; 1033 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1034 } 1035 } 1036 1037 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1038 switch (fs->super->s_creator_os) { 1039 case EXT2_OS_HURD: 1040 frag = inode->osd2.hurd2.h_i_frag; 1041 fsize = inode->osd2.hurd2.h_i_fsize; 1042 break; 1043 default: 1044 frag = fsize = 0; 1045 } 1046 1047 if (inode->i_faddr || frag || fsize || 1048 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) 1049 mark_inode_bad(ctx, ino); 1050 if (!(fs->super->s_feature_incompat & 1051 EXT4_FEATURE_INCOMPAT_64BIT) && 1052 inode->osd2.linux2.l_i_file_acl_high != 0) 1053 mark_inode_bad(ctx, ino); 1054 if ((fs->super->s_creator_os == EXT2_OS_LINUX) && 1055 !(fs->super->s_feature_ro_compat & 1056 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && 1057 (inode->osd2.linux2.l_i_blocks_hi != 0)) 1058 mark_inode_bad(ctx, ino); 1059 if (inode->i_flags & EXT2_IMAGIC_FL) { 1060 if (imagic_fs) { 1061 if (!ctx->inode_imagic_map) 1062 alloc_imagic_map(ctx); 1063 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map, 1064 ino); 1065 } else { 1066 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { 1067 inode->i_flags &= ~EXT2_IMAGIC_FL; 1068 e2fsck_write_inode(ctx, ino, 1069 inode, "pass1"); 1070 } 1071 } 1072 } 1073 1074 check_inode_extra_space(ctx, &pctx); 1075 check_is_really_dir(ctx, &pctx, block_buf); 1076 1077 /* 1078 * ext2fs_inode_has_valid_blocks2 does not actually look 1079 * at i_block[] values, so not endian-sensitive here. 1080 */ 1081 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) && 1082 LINUX_S_ISLNK(inode->i_mode) && 1083 !ext2fs_inode_has_valid_blocks2(fs, inode) && 1084 fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) { 1085 inode->i_flags &= ~EXT4_EXTENTS_FL; 1086 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1087 } 1088 1089 if (LINUX_S_ISDIR(inode->i_mode)) { 1090 ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); 1091 e2fsck_add_dir_info(ctx, ino, 0); 1092 ctx->fs_directory_count++; 1093 } else if (LINUX_S_ISREG (inode->i_mode)) { 1094 ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino); 1095 ctx->fs_regular_count++; 1096 } else if (LINUX_S_ISCHR (inode->i_mode) && 1097 e2fsck_pass1_check_device_inode(fs, inode)) { 1098 check_immutable(ctx, &pctx); 1099 check_size(ctx, &pctx); 1100 ctx->fs_chardev_count++; 1101 } else if (LINUX_S_ISBLK (inode->i_mode) && 1102 e2fsck_pass1_check_device_inode(fs, inode)) { 1103 check_immutable(ctx, &pctx); 1104 check_size(ctx, &pctx); 1105 ctx->fs_blockdev_count++; 1106 } else if (LINUX_S_ISLNK (inode->i_mode) && 1107 e2fsck_pass1_check_symlink(fs, ino, inode, 1108 block_buf)) { 1109 check_immutable(ctx, &pctx); 1110 ctx->fs_symlinks_count++; 1111 if (ext2fs_inode_data_blocks(fs, inode) == 0) { 1112 ctx->fs_fast_symlinks_count++; 1113 check_blocks(ctx, &pctx, block_buf); 1114 continue; 1115 } 1116 } 1117 else if (LINUX_S_ISFIFO (inode->i_mode) && 1118 e2fsck_pass1_check_device_inode(fs, inode)) { 1119 check_immutable(ctx, &pctx); 1120 check_size(ctx, &pctx); 1121 ctx->fs_fifo_count++; 1122 } else if ((LINUX_S_ISSOCK (inode->i_mode)) && 1123 e2fsck_pass1_check_device_inode(fs, inode)) { 1124 check_immutable(ctx, &pctx); 1125 check_size(ctx, &pctx); 1126 ctx->fs_sockets_count++; 1127 } else 1128 mark_inode_bad(ctx, ino); 1129 if (!(inode->i_flags & EXT4_EXTENTS_FL)) { 1130 if (inode->i_block[EXT2_IND_BLOCK]) 1131 ctx->fs_ind_count++; 1132 if (inode->i_block[EXT2_DIND_BLOCK]) 1133 ctx->fs_dind_count++; 1134 if (inode->i_block[EXT2_TIND_BLOCK]) 1135 ctx->fs_tind_count++; 1136 } 1137 if (!(inode->i_flags & EXT4_EXTENTS_FL) && 1138 (inode->i_block[EXT2_IND_BLOCK] || 1139 inode->i_block[EXT2_DIND_BLOCK] || 1140 inode->i_block[EXT2_TIND_BLOCK] || 1141 ext2fs_file_acl_block(fs, inode))) { 1142 inodes_to_process[process_inode_count].ino = ino; 1143 inodes_to_process[process_inode_count].inode = *inode; 1144 process_inode_count++; 1145 } else 1146 check_blocks(ctx, &pctx, block_buf); 1147 1148 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1149 return; 1150 1151 if (process_inode_count >= ctx->process_inode_size) { 1152 process_inodes(ctx, block_buf); 1153 1154 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1155 return; 1156 } 1157 } 1158 process_inodes(ctx, block_buf); 1159 ext2fs_close_inode_scan(scan); 1160 1161 /* 1162 * If any extended attribute blocks' reference counts need to 1163 * be adjusted, either up (ctx->refcount_extra), or down 1164 * (ctx->refcount), then fix them. 1165 */ 1166 if (ctx->refcount) { 1167 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); 1168 ea_refcount_free(ctx->refcount); 1169 ctx->refcount = 0; 1170 } 1171 if (ctx->refcount_extra) { 1172 adjust_extattr_refcount(ctx, ctx->refcount_extra, 1173 block_buf, +1); 1174 ea_refcount_free(ctx->refcount_extra); 1175 ctx->refcount_extra = 0; 1176 } 1177 1178 if (ctx->invalid_bitmaps) 1179 handle_fs_bad_blocks(ctx); 1180 1181 /* We don't need the block_ea_map any more */ 1182 if (ctx->block_ea_map) { 1183 ext2fs_free_block_bitmap(ctx->block_ea_map); 1184 ctx->block_ea_map = 0; 1185 } 1186 1187 if (ctx->flags & E2F_FLAG_RESIZE_INODE) { 1188 ext2fs_block_bitmap save_bmap; 1189 1190 save_bmap = fs->block_map; 1191 fs->block_map = ctx->block_found_map; 1192 clear_problem_context(&pctx); 1193 pctx.errcode = ext2fs_create_resize_inode(fs); 1194 if (pctx.errcode) { 1195 if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, 1196 &pctx)) { 1197 ctx->flags |= E2F_FLAG_ABORT; 1198 return; 1199 } 1200 pctx.errcode = 0; 1201 } 1202 if (!pctx.errcode) { 1203 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, 1204 "recreate inode"); 1205 inode->i_mtime = ctx->now; 1206 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, 1207 "recreate inode"); 1208 } 1209 fs->block_map = save_bmap; 1210 ctx->flags &= ~E2F_FLAG_RESIZE_INODE; 1211 } 1212 1213 if (ctx->flags & E2F_FLAG_RESTART) { 1214 /* 1215 * Only the master copy of the superblock and block 1216 * group descriptors are going to be written during a 1217 * restart, so set the superblock to be used to be the 1218 * master superblock. 1219 */ 1220 ctx->use_superblock = 0; 1221 unwind_pass1(fs); 1222 goto endit; 1223 } 1224 1225 if (ctx->block_dup_map) { 1226 if (ctx->options & E2F_OPT_PREEN) { 1227 clear_problem_context(&pctx); 1228 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); 1229 } 1230 e2fsck_pass1_dupblocks(ctx, block_buf); 1231 } 1232 ext2fs_free_mem(&inodes_to_process); 1233endit: 1234 e2fsck_use_inode_shortcuts(ctx, 0); 1235 1236 ext2fs_free_mem(&block_buf); 1237 ext2fs_free_mem(&inode); 1238 1239 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); 1240} 1241 1242/* 1243 * When the inode_scan routines call this callback at the end of the 1244 * glock group, call process_inodes. 1245 */ 1246static errcode_t scan_callback(ext2_filsys fs, 1247 ext2_inode_scan scan EXT2FS_ATTR((unused)), 1248 dgrp_t group, void * priv_data) 1249{ 1250 struct scan_callback_struct *scan_struct; 1251 e2fsck_t ctx; 1252 1253 scan_struct = (struct scan_callback_struct *) priv_data; 1254 ctx = scan_struct->ctx; 1255 1256 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); 1257 1258 if (ctx->progress) 1259 if ((ctx->progress)(ctx, 1, group+1, 1260 ctx->fs->group_desc_count)) 1261 return EXT2_ET_CANCEL_REQUESTED; 1262 1263 return 0; 1264} 1265 1266/* 1267 * Process the inodes in the "inodes to process" list. 1268 */ 1269static void process_inodes(e2fsck_t ctx, char *block_buf) 1270{ 1271 int i; 1272 struct ext2_inode *old_stashed_inode; 1273 ext2_ino_t old_stashed_ino; 1274 const char *old_operation; 1275 char buf[80]; 1276 struct problem_context pctx; 1277 1278#if 0 1279 printf("begin process_inodes: "); 1280#endif 1281 if (process_inode_count == 0) 1282 return; 1283 old_operation = ehandler_operation(0); 1284 old_stashed_inode = ctx->stashed_inode; 1285 old_stashed_ino = ctx->stashed_ino; 1286 qsort(inodes_to_process, process_inode_count, 1287 sizeof(struct process_inode_block), process_inode_cmp); 1288 clear_problem_context(&pctx); 1289 for (i=0; i < process_inode_count; i++) { 1290 pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; 1291 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; 1292 1293#if 0 1294 printf("%u ", pctx.ino); 1295#endif 1296 sprintf(buf, _("reading indirect blocks of inode %u"), 1297 pctx.ino); 1298 ehandler_operation(buf); 1299 check_blocks(ctx, &pctx, block_buf); 1300 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1301 break; 1302 } 1303 ctx->stashed_inode = old_stashed_inode; 1304 ctx->stashed_ino = old_stashed_ino; 1305 process_inode_count = 0; 1306#if 0 1307 printf("end process inodes\n"); 1308#endif 1309 ehandler_operation(old_operation); 1310} 1311 1312static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) 1313{ 1314 const struct process_inode_block *ib_a = 1315 (const struct process_inode_block *) a; 1316 const struct process_inode_block *ib_b = 1317 (const struct process_inode_block *) b; 1318 int ret; 1319 1320 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - 1321 ib_b->inode.i_block[EXT2_IND_BLOCK]); 1322 if (ret == 0) 1323 /* 1324 * We only call process_inodes() for non-extent 1325 * inodes, so it's OK to pass NULL to 1326 * ext2fs_file_acl_block() here. 1327 */ 1328 ret = ext2fs_file_acl_block(0, &(ib_a->inode)) - 1329 ext2fs_file_acl_block(0, &(ib_b->inode)); 1330 if (ret == 0) 1331 ret = ib_a->ino - ib_b->ino; 1332 return ret; 1333} 1334 1335/* 1336 * Mark an inode as being bad in some what 1337 */ 1338static void mark_inode_bad(e2fsck_t ctx, ino_t ino) 1339{ 1340 struct problem_context pctx; 1341 1342 if (!ctx->inode_bad_map) { 1343 clear_problem_context(&pctx); 1344 1345 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 1346 _("bad inode map"), EXT2FS_BMAP64_RBTREE, 1347 "inode_bad_map", &ctx->inode_bad_map); 1348 if (pctx.errcode) { 1349 pctx.num = 3; 1350 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1351 /* Should never get here */ 1352 ctx->flags |= E2F_FLAG_ABORT; 1353 return; 1354 } 1355 } 1356 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino); 1357} 1358 1359 1360/* 1361 * This procedure will allocate the inode "bb" (badblock) map table 1362 */ 1363static void alloc_bb_map(e2fsck_t ctx) 1364{ 1365 struct problem_context pctx; 1366 1367 clear_problem_context(&pctx); 1368 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 1369 _("inode in bad block map"), EXT2FS_BMAP64_RBTREE, 1370 "inode_bb_map", &ctx->inode_bb_map); 1371 if (pctx.errcode) { 1372 pctx.num = 4; 1373 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1374 /* Should never get here */ 1375 ctx->flags |= E2F_FLAG_ABORT; 1376 return; 1377 } 1378} 1379 1380/* 1381 * This procedure will allocate the inode imagic table 1382 */ 1383static void alloc_imagic_map(e2fsck_t ctx) 1384{ 1385 struct problem_context pctx; 1386 1387 clear_problem_context(&pctx); 1388 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 1389 _("imagic inode map"), EXT2FS_BMAP64_RBTREE, 1390 "inode_imagic_map", &ctx->inode_imagic_map); 1391 if (pctx.errcode) { 1392 pctx.num = 5; 1393 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1394 /* Should never get here */ 1395 ctx->flags |= E2F_FLAG_ABORT; 1396 return; 1397 } 1398} 1399 1400/* 1401 * Marks a block as in use, setting the dup_map if it's been set 1402 * already. Called by process_block and process_bad_block. 1403 * 1404 * WARNING: Assumes checks have already been done to make sure block 1405 * is valid. This is true in both process_block and process_bad_block. 1406 */ 1407static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block) 1408{ 1409 struct problem_context pctx; 1410 1411 clear_problem_context(&pctx); 1412 1413 if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) { 1414 if (!ctx->block_dup_map) { 1415 pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, 1416 _("multiply claimed block map"), 1417 EXT2FS_BMAP64_RBTREE, "block_dup_map", 1418 &ctx->block_dup_map); 1419 if (pctx.errcode) { 1420 pctx.num = 3; 1421 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, 1422 &pctx); 1423 /* Should never get here */ 1424 ctx->flags |= E2F_FLAG_ABORT; 1425 return; 1426 } 1427 } 1428 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block); 1429 } else { 1430 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block); 1431 } 1432} 1433 1434static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, 1435 unsigned int num) 1436{ 1437 if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num)) 1438 ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num); 1439 else 1440 while (num--) 1441 mark_block_used(ctx, block++); 1442} 1443 1444/* 1445 * Adjust the extended attribute block's reference counts at the end 1446 * of pass 1, either by subtracting out references for EA blocks that 1447 * are still referenced in ctx->refcount, or by adding references for 1448 * EA blocks that had extra references as accounted for in 1449 * ctx->refcount_extra. 1450 */ 1451static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 1452 char *block_buf, int adjust_sign) 1453{ 1454 struct ext2_ext_attr_header *header; 1455 struct problem_context pctx; 1456 ext2_filsys fs = ctx->fs; 1457 blk64_t blk; 1458 __u32 should_be; 1459 int count; 1460 1461 clear_problem_context(&pctx); 1462 1463 ea_refcount_intr_begin(refcount); 1464 while (1) { 1465 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) 1466 break; 1467 pctx.blk = blk; 1468 pctx.errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); 1469 if (pctx.errcode) { 1470 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); 1471 return; 1472 } 1473 header = (struct ext2_ext_attr_header *) block_buf; 1474 pctx.blkcount = header->h_refcount; 1475 should_be = header->h_refcount + adjust_sign * count; 1476 pctx.num = should_be; 1477 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { 1478 header->h_refcount = should_be; 1479 pctx.errcode = ext2fs_write_ext_attr2(fs, blk, 1480 block_buf); 1481 if (pctx.errcode) { 1482 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT, 1483 &pctx); 1484 continue; 1485 } 1486 } 1487 } 1488} 1489 1490/* 1491 * Handle processing the extended attribute blocks 1492 */ 1493static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, 1494 char *block_buf) 1495{ 1496 ext2_filsys fs = ctx->fs; 1497 ext2_ino_t ino = pctx->ino; 1498 struct ext2_inode *inode = pctx->inode; 1499 blk64_t blk; 1500 char * end; 1501 struct ext2_ext_attr_header *header; 1502 struct ext2_ext_attr_entry *entry; 1503 int count; 1504 region_t region = 0; 1505 1506 blk = ext2fs_file_acl_block(fs, inode); 1507 if (blk == 0) 1508 return 0; 1509 1510 /* 1511 * If the Extended attribute flag isn't set, then a non-zero 1512 * file acl means that the inode is corrupted. 1513 * 1514 * Or if the extended attribute block is an invalid block, 1515 * then the inode is also corrupted. 1516 */ 1517 if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || 1518 (blk < fs->super->s_first_data_block) || 1519 (blk >= ext2fs_blocks_count(fs->super))) { 1520 mark_inode_bad(ctx, ino); 1521 return 0; 1522 } 1523 1524 /* If ea bitmap hasn't been allocated, create it */ 1525 if (!ctx->block_ea_map) { 1526 pctx->errcode = e2fsck_allocate_block_bitmap(fs, 1527 _("ext attr block map"), 1528 EXT2FS_BMAP64_RBTREE, "block_ea_map", 1529 &ctx->block_ea_map); 1530 if (pctx->errcode) { 1531 pctx->num = 2; 1532 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); 1533 ctx->flags |= E2F_FLAG_ABORT; 1534 return 0; 1535 } 1536 } 1537 1538 /* Create the EA refcount structure if necessary */ 1539 if (!ctx->refcount) { 1540 pctx->errcode = ea_refcount_create(0, &ctx->refcount); 1541 if (pctx->errcode) { 1542 pctx->num = 1; 1543 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); 1544 ctx->flags |= E2F_FLAG_ABORT; 1545 return 0; 1546 } 1547 } 1548 1549#if 0 1550 /* Debugging text */ 1551 printf("Inode %u has EA block %u\n", ino, blk); 1552#endif 1553 1554 /* Have we seen this EA block before? */ 1555 if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) { 1556 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) 1557 return 1; 1558 /* Ooops, this EA was referenced more than it stated */ 1559 if (!ctx->refcount_extra) { 1560 pctx->errcode = ea_refcount_create(0, 1561 &ctx->refcount_extra); 1562 if (pctx->errcode) { 1563 pctx->num = 2; 1564 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); 1565 ctx->flags |= E2F_FLAG_ABORT; 1566 return 0; 1567 } 1568 } 1569 ea_refcount_increment(ctx->refcount_extra, blk, 0); 1570 return 1; 1571 } 1572 1573 /* 1574 * OK, we haven't seen this EA block yet. So we need to 1575 * validate it 1576 */ 1577 pctx->blk = blk; 1578 pctx->errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); 1579 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) 1580 goto clear_extattr; 1581 header = (struct ext2_ext_attr_header *) block_buf; 1582 pctx->blk = ext2fs_file_acl_block(fs, inode); 1583 if (((ctx->ext_attr_ver == 1) && 1584 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || 1585 ((ctx->ext_attr_ver == 2) && 1586 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) { 1587 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx)) 1588 goto clear_extattr; 1589 } 1590 1591 if (header->h_blocks != 1) { 1592 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx)) 1593 goto clear_extattr; 1594 } 1595 1596 region = region_create(0, fs->blocksize); 1597 if (!region) { 1598 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); 1599 ctx->flags |= E2F_FLAG_ABORT; 1600 return 0; 1601 } 1602 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) { 1603 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1604 goto clear_extattr; 1605 } 1606 1607 entry = (struct ext2_ext_attr_entry *)(header+1); 1608 end = block_buf + fs->blocksize; 1609 while ((char *)entry < end && *(__u32 *)entry) { 1610 __u32 hash; 1611 1612 if (region_allocate(region, (char *)entry - (char *)header, 1613 EXT2_EXT_ATTR_LEN(entry->e_name_len))) { 1614 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1615 goto clear_extattr; 1616 break; 1617 } 1618 if ((ctx->ext_attr_ver == 1 && 1619 (entry->e_name_len == 0 || entry->e_name_index != 0)) || 1620 (ctx->ext_attr_ver == 2 && 1621 entry->e_name_index == 0)) { 1622 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx)) 1623 goto clear_extattr; 1624 break; 1625 } 1626 if (entry->e_value_block != 0) { 1627 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) 1628 goto clear_extattr; 1629 } 1630 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) { 1631 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) 1632 goto clear_extattr; 1633 break; 1634 } 1635 if (entry->e_value_size && 1636 region_allocate(region, entry->e_value_offs, 1637 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { 1638 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1639 goto clear_extattr; 1640 } 1641 1642 hash = ext2fs_ext_attr_hash_entry(entry, block_buf + 1643 entry->e_value_offs); 1644 1645 if (entry->e_hash != hash) { 1646 pctx->num = entry->e_hash; 1647 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx)) 1648 goto clear_extattr; 1649 entry->e_hash = hash; 1650 } 1651 1652 entry = EXT2_EXT_ATTR_NEXT(entry); 1653 } 1654 if (region_allocate(region, (char *)entry - (char *)header, 4)) { 1655 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 1656 goto clear_extattr; 1657 } 1658 region_free(region); 1659 1660 count = header->h_refcount - 1; 1661 if (count) 1662 ea_refcount_store(ctx->refcount, blk, count); 1663 mark_block_used(ctx, blk); 1664 ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk); 1665 return 1; 1666 1667clear_extattr: 1668 if (region) 1669 region_free(region); 1670 ext2fs_file_acl_block_set(fs, inode, 0); 1671 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); 1672 return 0; 1673} 1674 1675/* Returns 1 if bad htree, 0 if OK */ 1676static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, 1677 ext2_ino_t ino, struct ext2_inode *inode, 1678 char *block_buf) 1679{ 1680 struct ext2_dx_root_info *root; 1681 ext2_filsys fs = ctx->fs; 1682 errcode_t retval; 1683 blk64_t blk; 1684 1685 if ((!LINUX_S_ISDIR(inode->i_mode) && 1686 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || 1687 (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && 1688 fix_problem(ctx, PR_1_HTREE_SET, pctx))) 1689 return 1; 1690 1691 pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk); 1692 1693 if ((pctx->errcode) || 1694 (blk == 0) || 1695 (blk < fs->super->s_first_data_block) || 1696 (blk >= ext2fs_blocks_count(fs->super))) { 1697 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 1698 return 1; 1699 else 1700 return 0; 1701 } 1702 1703 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf); 1704 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 1705 return 1; 1706 1707 /* XXX should check that beginning matches a directory */ 1708 root = (struct ext2_dx_root_info *) (block_buf + 24); 1709 1710 if ((root->reserved_zero || root->info_length < 8) && 1711 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 1712 return 1; 1713 1714 pctx->num = root->hash_version; 1715 if ((root->hash_version != EXT2_HASH_LEGACY) && 1716 (root->hash_version != EXT2_HASH_HALF_MD4) && 1717 (root->hash_version != EXT2_HASH_TEA) && 1718 fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) 1719 return 1; 1720 1721 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) && 1722 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx)) 1723 return 1; 1724 1725 pctx->num = root->indirect_levels; 1726 if ((root->indirect_levels > 1) && 1727 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) 1728 return 1; 1729 1730 return 0; 1731} 1732 1733void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, 1734 struct ext2_inode *inode, int restart_flag, 1735 const char *source) 1736{ 1737 inode->i_flags = 0; 1738 inode->i_links_count = 0; 1739 ext2fs_icount_store(ctx->inode_link_info, ino, 0); 1740 inode->i_dtime = ctx->now; 1741 1742 ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); 1743 ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); 1744 if (ctx->inode_reg_map) 1745 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); 1746 if (ctx->inode_bad_map) 1747 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); 1748 1749 /* 1750 * If the inode was partially accounted for before processing 1751 * was aborted, we need to restart the pass 1 scan. 1752 */ 1753 ctx->flags |= restart_flag; 1754 1755 if (ino == EXT2_BAD_INO) 1756 memset(inode, 0, sizeof(struct ext2_inode)); 1757 1758 e2fsck_write_inode(ctx, ino, inode, source); 1759} 1760 1761static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, 1762 struct process_block_struct *pb, 1763 blk64_t start_block, blk64_t end_block, 1764 blk64_t eof_block, 1765 ext2_extent_handle_t ehandle) 1766{ 1767 struct ext2fs_extent extent; 1768 blk64_t blk, last_lblk; 1769 e2_blkcnt_t blockcnt; 1770 unsigned int i; 1771 int is_dir, is_leaf; 1772 problem_t problem; 1773 struct ext2_extent_info info; 1774 1775 pctx->errcode = ext2fs_extent_get_info(ehandle, &info); 1776 if (pctx->errcode) 1777 return; 1778 1779 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB, 1780 &extent); 1781 while (!pctx->errcode && info.num_entries-- > 0) { 1782 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF; 1783 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode); 1784 last_lblk = extent.e_lblk + extent.e_len - 1; 1785 1786 problem = 0; 1787 if (extent.e_pblk == 0 || 1788 extent.e_pblk < ctx->fs->super->s_first_data_block || 1789 extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super)) 1790 problem = PR_1_EXTENT_BAD_START_BLK; 1791 else if (extent.e_lblk < start_block) 1792 problem = PR_1_OUT_OF_ORDER_EXTENTS; 1793 else if ((end_block && last_lblk > end_block) && 1794 (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT && 1795 last_lblk > eof_block))) 1796 problem = PR_1_EXTENT_END_OUT_OF_BOUNDS; 1797 else if (is_leaf && extent.e_len == 0) 1798 problem = PR_1_EXTENT_LENGTH_ZERO; 1799 else if (is_leaf && 1800 (extent.e_pblk + extent.e_len) > 1801 ext2fs_blocks_count(ctx->fs->super)) 1802 problem = PR_1_EXTENT_ENDS_BEYOND; 1803 else if (is_leaf && is_dir && 1804 ((extent.e_lblk + extent.e_len) > 1805 (1 << (21 - ctx->fs->super->s_log_block_size)))) 1806 problem = PR_1_TOOBIG_DIR; 1807 1808 if (problem) { 1809report_problem: 1810 pctx->blk = extent.e_pblk; 1811 pctx->blk2 = extent.e_lblk; 1812 pctx->num = extent.e_len; 1813 pctx->blkcount = extent.e_lblk + extent.e_len; 1814 if (fix_problem(ctx, problem, pctx)) { 1815 e2fsck_read_bitmaps(ctx); 1816 pctx->errcode = 1817 ext2fs_extent_delete(ehandle, 0); 1818 if (pctx->errcode) { 1819 pctx->str = "ext2fs_extent_delete"; 1820 return; 1821 } 1822 ext2fs_extent_fix_parents(ehandle); 1823 pctx->errcode = ext2fs_extent_get(ehandle, 1824 EXT2_EXTENT_CURRENT, 1825 &extent); 1826 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) { 1827 pctx->errcode = 0; 1828 break; 1829 } 1830 continue; 1831 } 1832 goto next; 1833 } 1834 1835 if (!is_leaf) { 1836 blk64_t lblk = extent.e_lblk; 1837 1838 blk = extent.e_pblk; 1839 pctx->errcode = ext2fs_extent_get(ehandle, 1840 EXT2_EXTENT_DOWN, &extent); 1841 if (pctx->errcode) { 1842 pctx->str = "EXT2_EXTENT_DOWN"; 1843 problem = PR_1_EXTENT_HEADER_INVALID; 1844 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD) 1845 goto report_problem; 1846 return; 1847 } 1848 /* The next extent should match this index's logical start */ 1849 if (extent.e_lblk != lblk) { 1850 struct ext2_extent_info e_info; 1851 1852 ext2fs_extent_get_info(ehandle, &e_info); 1853 pctx->blk = lblk; 1854 pctx->blk2 = extent.e_lblk; 1855 pctx->num = e_info.curr_level - 1; 1856 problem = PR_1_EXTENT_INDEX_START_INVALID; 1857 if (fix_problem(ctx, problem, pctx)) 1858 ext2fs_extent_fix_parents(ehandle); 1859 } 1860 scan_extent_node(ctx, pctx, pb, extent.e_lblk, 1861 last_lblk, eof_block, ehandle); 1862 if (pctx->errcode) 1863 return; 1864 pctx->errcode = ext2fs_extent_get(ehandle, 1865 EXT2_EXTENT_UP, &extent); 1866 if (pctx->errcode) { 1867 pctx->str = "EXT2_EXTENT_UP"; 1868 return; 1869 } 1870 mark_block_used(ctx, blk); 1871 pb->num_blocks++; 1872 goto next; 1873 } 1874 1875 if ((pb->previous_block != 0) && 1876 (pb->previous_block+1 != extent.e_pblk)) { 1877 if (ctx->options & E2F_OPT_FRAGCHECK) { 1878 char type = '?'; 1879 1880 if (pb->is_dir) 1881 type = 'd'; 1882 else if (pb->is_reg) 1883 type = 'f'; 1884 1885 printf(("%6lu(%c): expecting %6lu " 1886 "actual extent " 1887 "phys %6lu log %lu len %lu\n"), 1888 (unsigned long) pctx->ino, type, 1889 (unsigned long) pb->previous_block+1, 1890 (unsigned long) extent.e_pblk, 1891 (unsigned long) extent.e_lblk, 1892 (unsigned long) extent.e_len); 1893 } 1894 pb->fragmented = 1; 1895 } 1896 while (is_dir && (++pb->last_db_block < 1897 (e2_blkcnt_t) extent.e_lblk)) { 1898 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, 1899 pb->ino, 0, 1900 pb->last_db_block); 1901 if (pctx->errcode) { 1902 pctx->blk = 0; 1903 pctx->num = pb->last_db_block; 1904 goto failed_add_dir_block; 1905 } 1906 } 1907 if (!ctx->fs->cluster_ratio_bits) { 1908 mark_blocks_used(ctx, extent.e_pblk, extent.e_len); 1909 pb->num_blocks += extent.e_len; 1910 } 1911 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0; 1912 i < extent.e_len; 1913 blk++, blockcnt++, i++) { 1914 if (ctx->fs->cluster_ratio_bits && 1915 !(pb->previous_block && 1916 (EXT2FS_B2C(ctx->fs, blk) == 1917 EXT2FS_B2C(ctx->fs, pb->previous_block)) && 1918 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == 1919 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { 1920 mark_block_used(ctx, blk); 1921 pb->num_blocks++; 1922 } 1923 1924 pb->previous_block = blk; 1925 1926 if (is_dir) { 1927 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt); 1928 if (pctx->errcode) { 1929 pctx->blk = blk; 1930 pctx->num = blockcnt; 1931 failed_add_dir_block: 1932 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 1933 /* Should never get here */ 1934 ctx->flags |= E2F_FLAG_ABORT; 1935 return; 1936 } 1937 } 1938 } 1939 if (is_dir && extent.e_len > 0) 1940 pb->last_db_block = blockcnt - 1; 1941 pb->previous_block = extent.e_pblk + extent.e_len - 1; 1942 start_block = pb->last_block = last_lblk; 1943 if (is_leaf && !is_dir && 1944 !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)) 1945 pb->last_init_lblock = last_lblk; 1946 next: 1947 pctx->errcode = ext2fs_extent_get(ehandle, 1948 EXT2_EXTENT_NEXT_SIB, 1949 &extent); 1950 } 1951 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT) 1952 pctx->errcode = 0; 1953} 1954 1955static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, 1956 struct process_block_struct *pb) 1957{ 1958 struct ext2_extent_info info; 1959 struct ext2_inode *inode = pctx->inode; 1960 ext2_extent_handle_t ehandle; 1961 ext2_filsys fs = ctx->fs; 1962 ext2_ino_t ino = pctx->ino; 1963 errcode_t retval; 1964 blk64_t eof_lblk; 1965 1966 pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle); 1967 if (pctx->errcode) { 1968 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx)) 1969 e2fsck_clear_inode(ctx, ino, inode, 0, 1970 "check_blocks_extents"); 1971 pctx->errcode = 0; 1972 return; 1973 } 1974 1975 retval = ext2fs_extent_get_info(ehandle, &info); 1976 if (retval == 0) { 1977 if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT) 1978 info.max_depth = MAX_EXTENT_DEPTH_COUNT-1; 1979 ctx->extent_depth_count[info.max_depth]++; 1980 } 1981 1982 eof_lblk = ((EXT2_I_SIZE(inode) + fs->blocksize - 1) >> 1983 EXT2_BLOCK_SIZE_BITS(fs->super)) - 1; 1984 scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle); 1985 if (pctx->errcode && 1986 fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) { 1987 pb->num_blocks = 0; 1988 inode->i_blocks = 0; 1989 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, 1990 "check_blocks_extents"); 1991 pctx->errcode = 0; 1992 } 1993 ext2fs_extent_free(ehandle); 1994} 1995 1996/* 1997 * This subroutine is called on each inode to account for all of the 1998 * blocks used by that inode. 1999 */ 2000static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 2001 char *block_buf) 2002{ 2003 ext2_filsys fs = ctx->fs; 2004 struct process_block_struct pb; 2005 ext2_ino_t ino = pctx->ino; 2006 struct ext2_inode *inode = pctx->inode; 2007 unsigned bad_size = 0; 2008 int dirty_inode = 0; 2009 int extent_fs; 2010 __u64 size; 2011 2012 pb.ino = ino; 2013 pb.num_blocks = 0; 2014 pb.last_block = -1; 2015 pb.last_init_lblock = -1; 2016 pb.last_db_block = -1; 2017 pb.num_illegal_blocks = 0; 2018 pb.suppress = 0; pb.clear = 0; 2019 pb.fragmented = 0; 2020 pb.compressed = 0; 2021 pb.previous_block = 0; 2022 pb.is_dir = LINUX_S_ISDIR(inode->i_mode); 2023 pb.is_reg = LINUX_S_ISREG(inode->i_mode); 2024 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size); 2025 pb.inode = inode; 2026 pb.pctx = pctx; 2027 pb.ctx = ctx; 2028 pctx->ino = ino; 2029 pctx->errcode = 0; 2030 2031 extent_fs = (ctx->fs->super->s_feature_incompat & 2032 EXT3_FEATURE_INCOMPAT_EXTENTS); 2033 2034 if (inode->i_flags & EXT2_COMPRBLK_FL) { 2035 if (fs->super->s_feature_incompat & 2036 EXT2_FEATURE_INCOMPAT_COMPRESSION) 2037 pb.compressed = 1; 2038 else { 2039 if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { 2040 inode->i_flags &= ~EXT2_COMPRBLK_FL; 2041 dirty_inode++; 2042 } 2043 } 2044 } 2045 2046 if (ext2fs_file_acl_block(fs, inode) && 2047 check_ext_attr(ctx, pctx, block_buf)) { 2048 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2049 goto out; 2050 pb.num_blocks++; 2051 } 2052 2053 if (ext2fs_inode_has_valid_blocks2(fs, inode)) { 2054 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) 2055 check_blocks_extents(ctx, pctx, &pb); 2056 else { 2057 pctx->errcode = ext2fs_block_iterate3(fs, ino, 2058 pb.is_dir ? BLOCK_FLAG_HOLE : 0, 2059 block_buf, process_block, &pb); 2060 /* 2061 * We do not have uninitialized extents in non extent 2062 * files. 2063 */ 2064 pb.last_init_lblock = pb.last_block; 2065 } 2066 } 2067 end_problem_latch(ctx, PR_LATCH_BLOCK); 2068 end_problem_latch(ctx, PR_LATCH_TOOBIG); 2069 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2070 goto out; 2071 if (pctx->errcode) 2072 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); 2073 2074 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) { 2075 if (LINUX_S_ISDIR(inode->i_mode)) 2076 ctx->fs_fragmented_dir++; 2077 else 2078 ctx->fs_fragmented++; 2079 } 2080 2081 if (pb.clear) { 2082 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, 2083 "check_blocks"); 2084 return; 2085 } 2086 2087 if (inode->i_flags & EXT2_INDEX_FL) { 2088 if (handle_htree(ctx, pctx, ino, inode, block_buf)) { 2089 inode->i_flags &= ~EXT2_INDEX_FL; 2090 dirty_inode++; 2091 } else { 2092#ifdef ENABLE_HTREE 2093 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); 2094#endif 2095 } 2096 } 2097 2098 if (!pb.num_blocks && pb.is_dir) { 2099 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { 2100 e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); 2101 ctx->fs_directory_count--; 2102 return; 2103 } 2104 } 2105 2106 if (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super)) { 2107 quota_data_add(ctx->qctx, inode, ino, 2108 pb.num_blocks * fs->blocksize); 2109 quota_data_inodes(ctx->qctx, inode, ino, +1); 2110 } 2111 2112 if (!(fs->super->s_feature_ro_compat & 2113 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) || 2114 !(inode->i_flags & EXT4_HUGE_FILE_FL)) 2115 pb.num_blocks *= (fs->blocksize / 512); 2116 pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs); 2117#if 0 2118 printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n", 2119 ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode), 2120 pb.num_blocks); 2121#endif 2122 if (pb.is_dir) { 2123 int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); 2124 if (inode->i_size & (fs->blocksize - 1)) 2125 bad_size = 5; 2126 else if (nblock > (pb.last_block + 1)) 2127 bad_size = 1; 2128 else if (nblock < (pb.last_block + 1)) { 2129 if (((pb.last_block + 1) - nblock) > 2130 fs->super->s_prealloc_dir_blocks) 2131 bad_size = 2; 2132 } 2133 } else { 2134 e2_blkcnt_t blkpg = ctx->blocks_per_page; 2135 2136 size = EXT2_I_SIZE(inode); 2137 if ((pb.last_init_lblock >= 0) && 2138 /* allow allocated blocks to end of PAGE_SIZE */ 2139 (size < (__u64)pb.last_init_lblock * fs->blocksize) && 2140 (pb.last_init_lblock / blkpg * blkpg != pb.last_init_lblock || 2141 size < (__u64)(pb.last_init_lblock & ~(blkpg-1)) * 2142 fs->blocksize)) 2143 bad_size = 3; 2144 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && 2145 size > ext2_max_sizes[fs->super->s_log_block_size]) 2146 /* too big for a direct/indirect-mapped file */ 2147 bad_size = 4; 2148 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && 2149 size > 2150 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1)) 2151 /* too big for an extent-based file - 32bit ee_block */ 2152 bad_size = 6; 2153 } 2154 /* i_size for symlinks is checked elsewhere */ 2155 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { 2156 pctx->num = (pb.last_block+1) * fs->blocksize; 2157 pctx->group = bad_size; 2158 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { 2159 inode->i_size = pctx->num; 2160 if (!LINUX_S_ISDIR(inode->i_mode)) 2161 inode->i_size_high = pctx->num >> 32; 2162 dirty_inode++; 2163 } 2164 pctx->num = 0; 2165 } 2166 if (LINUX_S_ISREG(inode->i_mode) && EXT2_I_SIZE(inode) >= 0x80000000UL) 2167 ctx->large_files++; 2168 if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) || 2169 ((fs->super->s_feature_ro_compat & 2170 EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && 2171 (inode->i_flags & EXT4_HUGE_FILE_FL) && 2172 (inode->osd2.linux2.l_i_blocks_hi != 0))) { 2173 pctx->num = pb.num_blocks; 2174 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { 2175 inode->i_blocks = pb.num_blocks; 2176 inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32; 2177 dirty_inode++; 2178 } 2179 pctx->num = 0; 2180 } 2181 2182 if (ctx->dirs_to_hash && pb.is_dir && 2183 !(inode->i_flags & EXT2_INDEX_FL) && 2184 ((inode->i_size / fs->blocksize) >= 3)) 2185 ext2fs_u32_list_add(ctx->dirs_to_hash, ino); 2186 2187out: 2188 if (dirty_inode) 2189 e2fsck_write_inode(ctx, ino, inode, "check_blocks"); 2190} 2191 2192#if 0 2193/* 2194 * Helper function called by process block when an illegal block is 2195 * found. It returns a description about why the block is illegal 2196 */ 2197static char *describe_illegal_block(ext2_filsys fs, blk64_t block) 2198{ 2199 blk64_t super; 2200 int i; 2201 static char problem[80]; 2202 2203 super = fs->super->s_first_data_block; 2204 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block"); 2205 if (block < super) { 2206 sprintf(problem, "< FIRSTBLOCK (%u)", super); 2207 return(problem); 2208 } else if (block >= ext2fs_blocks_count(fs->super)) { 2209 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super)); 2210 return(problem); 2211 } 2212 for (i = 0; i < fs->group_desc_count; i++) { 2213 if (block == super) { 2214 sprintf(problem, "is the superblock in group %d", i); 2215 break; 2216 } 2217 if (block > super && 2218 block <= (super + fs->desc_blocks)) { 2219 sprintf(problem, "is in the group descriptors " 2220 "of group %d", i); 2221 break; 2222 } 2223 if (block == ext2fs_block_bitmap_loc(fs, i)) { 2224 sprintf(problem, "is the block bitmap of group %d", i); 2225 break; 2226 } 2227 if (block == ext2fs_inode_bitmap_loc(fs, i)) { 2228 sprintf(problem, "is the inode bitmap of group %d", i); 2229 break; 2230 } 2231 if (block >= ext2fs_inode_table_loc(fs, i) && 2232 (block < ext2fs_inode_table_loc(fs, i) 2233 + fs->inode_blocks_per_group)) { 2234 sprintf(problem, "is in the inode table of group %d", 2235 i); 2236 break; 2237 } 2238 super += fs->super->s_blocks_per_group; 2239 } 2240 return(problem); 2241} 2242#endif 2243 2244/* 2245 * This is a helper function for check_blocks(). 2246 */ 2247static int process_block(ext2_filsys fs, 2248 blk64_t *block_nr, 2249 e2_blkcnt_t blockcnt, 2250 blk64_t ref_block EXT2FS_ATTR((unused)), 2251 int ref_offset EXT2FS_ATTR((unused)), 2252 void *priv_data) 2253{ 2254 struct process_block_struct *p; 2255 struct problem_context *pctx; 2256 blk64_t blk = *block_nr; 2257 int ret_code = 0; 2258 problem_t problem = 0; 2259 e2fsck_t ctx; 2260 2261 p = (struct process_block_struct *) priv_data; 2262 pctx = p->pctx; 2263 ctx = p->ctx; 2264 2265 if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) { 2266 /* todo: Check that the comprblk_fl is high, that the 2267 blkaddr pattern looks right (all non-holes up to 2268 first EXT2FS_COMPRESSED_BLKADDR, then all 2269 EXT2FS_COMPRESSED_BLKADDR up to end of cluster), 2270 that the feature_incompat bit is high, and that the 2271 inode is a regular file. If we're doing a "full 2272 check" (a concept introduced to e2fsck by e2compr, 2273 meaning that we look at data blocks as well as 2274 metadata) then call some library routine that 2275 checks the compressed data. I'll have to think 2276 about this, because one particularly important 2277 problem to be able to fix is to recalculate the 2278 cluster size if necessary. I think that perhaps 2279 we'd better do most/all e2compr-specific checks 2280 separately, after the non-e2compr checks. If not 2281 doing a full check, it may be useful to test that 2282 the personality is linux; e.g. if it isn't then 2283 perhaps this really is just an illegal block. */ 2284 return 0; 2285 } 2286 2287 if (blk == 0) 2288 return 0; 2289 2290#if 0 2291 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk, 2292 blockcnt); 2293#endif 2294 2295 /* 2296 * Simplistic fragmentation check. We merely require that the 2297 * file be contiguous. (Which can never be true for really 2298 * big files that are greater than a block group.) 2299 */ 2300 if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) { 2301 if (p->previous_block+1 != blk) { 2302 if (ctx->options & E2F_OPT_FRAGCHECK) { 2303 char type = '?'; 2304 2305 if (p->is_dir) 2306 type = 'd'; 2307 else if (p->is_reg) 2308 type = 'f'; 2309 2310 printf(_("%6lu(%c): expecting %6lu " 2311 "got phys %6lu (blkcnt %lld)\n"), 2312 (unsigned long) pctx->ino, type, 2313 (unsigned long) p->previous_block+1, 2314 (unsigned long) blk, 2315 blockcnt); 2316 } 2317 p->fragmented = 1; 2318 } 2319 } 2320 2321 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) 2322 problem = PR_1_TOOBIG_DIR; 2323 if (p->is_reg && p->num_blocks+1 >= p->max_blocks) 2324 problem = PR_1_TOOBIG_REG; 2325 if (!p->is_dir && !p->is_reg && blockcnt > 0) 2326 problem = PR_1_TOOBIG_SYMLINK; 2327 2328 if (blk < fs->super->s_first_data_block || 2329 blk >= ext2fs_blocks_count(fs->super)) 2330 problem = PR_1_ILLEGAL_BLOCK_NUM; 2331 2332 if (problem) { 2333 p->num_illegal_blocks++; 2334 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { 2335 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { 2336 p->clear = 1; 2337 return BLOCK_ABORT; 2338 } 2339 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) { 2340 p->suppress = 1; 2341 set_latch_flags(PR_LATCH_BLOCK, 2342 PRL_SUPPRESS, 0); 2343 } 2344 } 2345 pctx->blk = blk; 2346 pctx->blkcount = blockcnt; 2347 if (fix_problem(ctx, problem, pctx)) { 2348 blk = *block_nr = 0; 2349 ret_code = BLOCK_CHANGED; 2350 goto mark_dir; 2351 } else 2352 return 0; 2353 } 2354 2355 if (p->ino == EXT2_RESIZE_INO) { 2356 /* 2357 * The resize inode has already be sanity checked 2358 * during pass #0 (the superblock checks). All we 2359 * have to do is mark the double indirect block as 2360 * being in use; all of the other blocks are handled 2361 * by mark_table_blocks()). 2362 */ 2363 if (blockcnt == BLOCK_COUNT_DIND) 2364 mark_block_used(ctx, blk); 2365 p->num_blocks++; 2366 } else if (!(ctx->fs->cluster_ratio_bits && 2367 p->previous_block && 2368 (EXT2FS_B2C(ctx->fs, blk) == 2369 EXT2FS_B2C(ctx->fs, p->previous_block)) && 2370 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == 2371 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { 2372 mark_block_used(ctx, blk); 2373 p->num_blocks++; 2374 } 2375 if (blockcnt >= 0) 2376 p->last_block = blockcnt; 2377 p->previous_block = blk; 2378mark_dir: 2379 if (p->is_dir && (blockcnt >= 0)) { 2380 while (++p->last_db_block < blockcnt) { 2381 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, 2382 p->ino, 0, 2383 p->last_db_block); 2384 if (pctx->errcode) { 2385 pctx->blk = 0; 2386 pctx->num = p->last_db_block; 2387 goto failed_add_dir_block; 2388 } 2389 } 2390 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 2391 blk, blockcnt); 2392 if (pctx->errcode) { 2393 pctx->blk = blk; 2394 pctx->num = blockcnt; 2395 failed_add_dir_block: 2396 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 2397 /* Should never get here */ 2398 ctx->flags |= E2F_FLAG_ABORT; 2399 return BLOCK_ABORT; 2400 } 2401 } 2402 return ret_code; 2403} 2404 2405static int process_bad_block(ext2_filsys fs, 2406 blk64_t *block_nr, 2407 e2_blkcnt_t blockcnt, 2408 blk64_t ref_block EXT2FS_ATTR((unused)), 2409 int ref_offset EXT2FS_ATTR((unused)), 2410 void *priv_data) 2411{ 2412 struct process_block_struct *p; 2413 blk64_t blk = *block_nr; 2414 blk64_t first_block; 2415 dgrp_t i; 2416 struct problem_context *pctx; 2417 e2fsck_t ctx; 2418 2419 /* 2420 * Note: This function processes blocks for the bad blocks 2421 * inode, which is never compressed. So we don't use HOLE_BLKADDR(). 2422 */ 2423 2424 if (!blk) 2425 return 0; 2426 2427 p = (struct process_block_struct *) priv_data; 2428 ctx = p->ctx; 2429 pctx = p->pctx; 2430 2431 pctx->ino = EXT2_BAD_INO; 2432 pctx->blk = blk; 2433 pctx->blkcount = blockcnt; 2434 2435 if ((blk < fs->super->s_first_data_block) || 2436 (blk >= ext2fs_blocks_count(fs->super))) { 2437 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) { 2438 *block_nr = 0; 2439 return BLOCK_CHANGED; 2440 } else 2441 return 0; 2442 } 2443 2444 if (blockcnt < 0) { 2445 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) { 2446 p->bbcheck = 1; 2447 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) { 2448 *block_nr = 0; 2449 return BLOCK_CHANGED; 2450 } 2451 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2452 blk)) { 2453 p->bbcheck = 1; 2454 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, 2455 pctx)) { 2456 *block_nr = 0; 2457 return BLOCK_CHANGED; 2458 } 2459 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2460 return BLOCK_ABORT; 2461 } else 2462 mark_block_used(ctx, blk); 2463 return 0; 2464 } 2465#if 0 2466 printf ("DEBUG: Marking %u as bad.\n", blk); 2467#endif 2468 ctx->fs_badblocks_count++; 2469 /* 2470 * If the block is not used, then mark it as used and return. 2471 * If it is already marked as found, this must mean that 2472 * there's an overlap between the filesystem table blocks 2473 * (bitmaps and inode table) and the bad block list. 2474 */ 2475 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) { 2476 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 2477 return 0; 2478 } 2479 /* 2480 * Try to find the where the filesystem block was used... 2481 */ 2482 first_block = fs->super->s_first_data_block; 2483 2484 for (i = 0; i < fs->group_desc_count; i++ ) { 2485 pctx->group = i; 2486 pctx->blk = blk; 2487 if (!ext2fs_bg_has_super(fs, i)) 2488 goto skip_super; 2489 if (blk == first_block) { 2490 if (i == 0) { 2491 if (fix_problem(ctx, 2492 PR_1_BAD_PRIMARY_SUPERBLOCK, 2493 pctx)) { 2494 *block_nr = 0; 2495 return BLOCK_CHANGED; 2496 } 2497 return 0; 2498 } 2499 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx); 2500 return 0; 2501 } 2502 if ((blk > first_block) && 2503 (blk <= first_block + fs->desc_blocks)) { 2504 if (i == 0) { 2505 pctx->blk = *block_nr; 2506 if (fix_problem(ctx, 2507 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) { 2508 *block_nr = 0; 2509 return BLOCK_CHANGED; 2510 } 2511 return 0; 2512 } 2513 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx); 2514 return 0; 2515 } 2516 skip_super: 2517 if (blk == ext2fs_block_bitmap_loc(fs, i)) { 2518 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { 2519 ctx->invalid_block_bitmap_flag[i]++; 2520 ctx->invalid_bitmaps++; 2521 } 2522 return 0; 2523 } 2524 if (blk == ext2fs_inode_bitmap_loc(fs, i)) { 2525 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { 2526 ctx->invalid_inode_bitmap_flag[i]++; 2527 ctx->invalid_bitmaps++; 2528 } 2529 return 0; 2530 } 2531 if ((blk >= ext2fs_inode_table_loc(fs, i)) && 2532 (blk < (ext2fs_inode_table_loc(fs, i) + 2533 fs->inode_blocks_per_group))) { 2534 /* 2535 * If there are bad blocks in the inode table, 2536 * the inode scan code will try to do 2537 * something reasonable automatically. 2538 */ 2539 return 0; 2540 } 2541 first_block += fs->super->s_blocks_per_group; 2542 } 2543 /* 2544 * If we've gotten to this point, then the only 2545 * possibility is that the bad block inode meta data 2546 * is using a bad block. 2547 */ 2548 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) || 2549 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) || 2550 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) { 2551 p->bbcheck = 1; 2552 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) { 2553 *block_nr = 0; 2554 return BLOCK_CHANGED; 2555 } 2556 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2557 return BLOCK_ABORT; 2558 return 0; 2559 } 2560 2561 pctx->group = -1; 2562 2563 /* Warn user that the block wasn't claimed */ 2564 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx); 2565 2566 return 0; 2567} 2568 2569static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group, 2570 const char *name, int num, blk64_t *new_block) 2571{ 2572 ext2_filsys fs = ctx->fs; 2573 dgrp_t last_grp; 2574 blk64_t old_block = *new_block; 2575 blk64_t last_block; 2576 dgrp_t flexbg; 2577 unsigned flexbg_size; 2578 int i, is_flexbg; 2579 char *buf; 2580 struct problem_context pctx; 2581 2582 clear_problem_context(&pctx); 2583 2584 pctx.group = group; 2585 pctx.blk = old_block; 2586 pctx.str = name; 2587 2588 /* 2589 * For flex_bg filesystems, first try to allocate the metadata 2590 * within the flex_bg, and if that fails then try finding the 2591 * space anywhere in the filesystem. 2592 */ 2593 is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super, 2594 EXT4_FEATURE_INCOMPAT_FLEX_BG); 2595 if (is_flexbg) { 2596 flexbg_size = 1 << fs->super->s_log_groups_per_flex; 2597 flexbg = group / flexbg_size; 2598 first_block = ext2fs_group_first_block2(fs, 2599 flexbg_size * flexbg); 2600 last_grp = group | (flexbg_size - 1); 2601 if (last_grp > fs->group_desc_count) 2602 last_grp = fs->group_desc_count; 2603 last_block = ext2fs_group_last_block2(fs, last_grp); 2604 } else 2605 last_block = ext2fs_group_last_block2(fs, group); 2606 pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block, 2607 num, ctx->block_found_map, 2608 new_block); 2609 if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL)) 2610 pctx.errcode = ext2fs_get_free_blocks2(fs, 2611 fs->super->s_first_data_block, 2612 ext2fs_blocks_count(fs->super), 2613 num, ctx->block_found_map, new_block); 2614 if (pctx.errcode) { 2615 pctx.num = num; 2616 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx); 2617 ext2fs_unmark_valid(fs); 2618 ctx->flags |= E2F_FLAG_ABORT; 2619 return; 2620 } 2621 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf); 2622 if (pctx.errcode) { 2623 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx); 2624 ext2fs_unmark_valid(fs); 2625 ctx->flags |= E2F_FLAG_ABORT; 2626 return; 2627 } 2628 ext2fs_mark_super_dirty(fs); 2629 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 2630 pctx.blk2 = *new_block; 2631 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO : 2632 PR_1_RELOC_TO), &pctx); 2633 pctx.blk2 = 0; 2634 for (i = 0; i < num; i++) { 2635 pctx.blk = i; 2636 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i); 2637 if (old_block) { 2638 pctx.errcode = io_channel_read_blk64(fs->io, 2639 old_block + i, 1, buf); 2640 if (pctx.errcode) 2641 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); 2642 } else 2643 memset(buf, 0, fs->blocksize); 2644 2645 pctx.blk = (*new_block) + i; 2646 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, 2647 1, buf); 2648 if (pctx.errcode) 2649 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); 2650 } 2651 ext2fs_free_mem(&buf); 2652} 2653 2654/* 2655 * This routine gets called at the end of pass 1 if bad blocks are 2656 * detected in the superblock, group descriptors, inode_bitmaps, or 2657 * block bitmaps. At this point, all of the blocks have been mapped 2658 * out, so we can try to allocate new block(s) to replace the bad 2659 * blocks. 2660 */ 2661static void handle_fs_bad_blocks(e2fsck_t ctx) 2662{ 2663 ext2_filsys fs = ctx->fs; 2664 dgrp_t i; 2665 blk64_t first_block; 2666 blk64_t new_blk; 2667 2668 for (i = 0; i < fs->group_desc_count; i++) { 2669 first_block = ext2fs_group_first_block2(fs, i); 2670 2671 if (ctx->invalid_block_bitmap_flag[i]) { 2672 new_blk = ext2fs_block_bitmap_loc(fs, i); 2673 new_table_block(ctx, first_block, i, _("block bitmap"), 2674 1, &new_blk); 2675 ext2fs_block_bitmap_loc_set(fs, i, new_blk); 2676 } 2677 if (ctx->invalid_inode_bitmap_flag[i]) { 2678 new_blk = ext2fs_inode_bitmap_loc(fs, i); 2679 new_table_block(ctx, first_block, i, _("inode bitmap"), 2680 1, &new_blk); 2681 ext2fs_inode_bitmap_loc_set(fs, i, new_blk); 2682 } 2683 if (ctx->invalid_inode_table_flag[i]) { 2684 new_blk = ext2fs_inode_table_loc(fs, i); 2685 new_table_block(ctx, first_block, i, _("inode table"), 2686 fs->inode_blocks_per_group, 2687 &new_blk); 2688 ext2fs_inode_table_loc_set(fs, i, new_blk); 2689 ctx->flags |= E2F_FLAG_RESTART; 2690 } 2691 } 2692 ctx->invalid_bitmaps = 0; 2693} 2694 2695/* 2696 * This routine marks all blocks which are used by the superblock, 2697 * group descriptors, inode bitmaps, and block bitmaps. 2698 */ 2699static void mark_table_blocks(e2fsck_t ctx) 2700{ 2701 ext2_filsys fs = ctx->fs; 2702 blk64_t b; 2703 dgrp_t i; 2704 unsigned int j; 2705 struct problem_context pctx; 2706 2707 clear_problem_context(&pctx); 2708 2709 for (i = 0; i < fs->group_desc_count; i++) { 2710 pctx.group = i; 2711 2712 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); 2713 2714 /* 2715 * Mark the blocks used for the inode table 2716 */ 2717 if (ext2fs_inode_table_loc(fs, i)) { 2718 for (j = 0, b = ext2fs_inode_table_loc(fs, i); 2719 j < fs->inode_blocks_per_group; 2720 j++, b++) { 2721 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2722 b)) { 2723 pctx.blk = b; 2724 if (!ctx->invalid_inode_table_flag[i] && 2725 fix_problem(ctx, 2726 PR_1_ITABLE_CONFLICT, &pctx)) { 2727 ctx->invalid_inode_table_flag[i]++; 2728 ctx->invalid_bitmaps++; 2729 } 2730 } else { 2731 ext2fs_mark_block_bitmap2(ctx->block_found_map, 2732 b); 2733 } 2734 } 2735 } 2736 2737 /* 2738 * Mark block used for the block bitmap 2739 */ 2740 if (ext2fs_block_bitmap_loc(fs, i)) { 2741 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2742 ext2fs_block_bitmap_loc(fs, i))) { 2743 pctx.blk = ext2fs_block_bitmap_loc(fs, i); 2744 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { 2745 ctx->invalid_block_bitmap_flag[i]++; 2746 ctx->invalid_bitmaps++; 2747 } 2748 } else { 2749 ext2fs_mark_block_bitmap2(ctx->block_found_map, 2750 ext2fs_block_bitmap_loc(fs, i)); 2751 } 2752 2753 } 2754 /* 2755 * Mark block used for the inode bitmap 2756 */ 2757 if (ext2fs_inode_bitmap_loc(fs, i)) { 2758 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 2759 ext2fs_inode_bitmap_loc(fs, i))) { 2760 pctx.blk = ext2fs_inode_bitmap_loc(fs, i); 2761 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { 2762 ctx->invalid_inode_bitmap_flag[i]++; 2763 ctx->invalid_bitmaps++; 2764 } 2765 } else { 2766 ext2fs_mark_block_bitmap2(ctx->block_found_map, 2767 ext2fs_inode_bitmap_loc(fs, i)); 2768 } 2769 } 2770 } 2771} 2772 2773/* 2774 * Thes subroutines short circuits ext2fs_get_blocks and 2775 * ext2fs_check_directory; we use them since we already have the inode 2776 * structure, so there's no point in letting the ext2fs library read 2777 * the inode again. 2778 */ 2779static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino, 2780 blk_t *blocks) 2781{ 2782 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2783 int i; 2784 2785 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 2786 return EXT2_ET_CALLBACK_NOTHANDLED; 2787 2788 for (i=0; i < EXT2_N_BLOCKS; i++) 2789 blocks[i] = ctx->stashed_inode->i_block[i]; 2790 return 0; 2791} 2792 2793static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, 2794 struct ext2_inode *inode) 2795{ 2796 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2797 2798 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 2799 return EXT2_ET_CALLBACK_NOTHANDLED; 2800 *inode = *ctx->stashed_inode; 2801 return 0; 2802} 2803 2804static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, 2805 struct ext2_inode *inode) 2806{ 2807 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2808 2809 if ((ino == ctx->stashed_ino) && ctx->stashed_inode && 2810 (inode != ctx->stashed_inode)) 2811 *ctx->stashed_inode = *inode; 2812 return EXT2_ET_CALLBACK_NOTHANDLED; 2813} 2814 2815static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino) 2816{ 2817 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2818 2819 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 2820 return EXT2_ET_CALLBACK_NOTHANDLED; 2821 2822 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode)) 2823 return EXT2_ET_NO_DIRECTORY; 2824 return 0; 2825} 2826 2827static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, 2828 blk64_t *ret) 2829{ 2830 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2831 errcode_t retval; 2832 blk64_t new_block; 2833 2834 if (ctx->block_found_map) { 2835 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map, 2836 &new_block); 2837 if (retval) 2838 return retval; 2839 if (fs->block_map) { 2840 ext2fs_mark_block_bitmap2(fs->block_map, new_block); 2841 ext2fs_mark_bb_dirty(fs); 2842 } 2843 } else { 2844 if (!fs->block_map) { 2845 retval = ext2fs_read_block_bitmap(fs); 2846 if (retval) 2847 return retval; 2848 } 2849 2850 retval = ext2fs_new_block2(fs, goal, 0, &new_block); 2851 if (retval) 2852 return retval; 2853 } 2854 2855 *ret = new_block; 2856 return (0); 2857} 2858 2859static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) 2860{ 2861 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 2862 2863 if (ctx->block_found_map) { 2864 if (inuse > 0) 2865 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 2866 else 2867 ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk); 2868 } 2869} 2870 2871void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) 2872{ 2873 ext2_filsys fs = ctx->fs; 2874 2875 if (use_shortcuts) { 2876 fs->get_blocks = pass1_get_blocks; 2877 fs->check_directory = pass1_check_directory; 2878 fs->read_inode = pass1_read_inode; 2879 fs->write_inode = pass1_write_inode; 2880 ctx->stashed_ino = 0; 2881 ext2fs_set_alloc_block_callback(fs, e2fsck_get_alloc_block, 2882 0); 2883 ext2fs_set_block_alloc_stats_callback(fs, 2884 e2fsck_block_alloc_stats, 2885 0); 2886 } else { 2887 fs->get_blocks = 0; 2888 fs->check_directory = 0; 2889 fs->read_inode = 0; 2890 fs->write_inode = 0; 2891 } 2892} 2893