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 59 #undef DEBUG 60 61 static int process_block(ext2_filsys fs, blk64_t *blocknr, 62 e2_blkcnt_t blockcnt, blk64_t ref_blk, 63 int ref_offset, void *priv_data); 64 static int process_bad_block(ext2_filsys fs, blk64_t *block_nr, 65 e2_blkcnt_t blockcnt, blk64_t ref_blk, 66 int ref_offset, void *priv_data); 67 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 68 char *block_buf); 69 static void mark_table_blocks(e2fsck_t ctx); 70 static void alloc_bb_map(e2fsck_t ctx); 71 static void alloc_imagic_map(e2fsck_t ctx); 72 static void mark_inode_bad(e2fsck_t ctx, ino_t ino); 73 static void add_encrypted_dir(e2fsck_t ctx, ino_t ino); 74 static void handle_fs_bad_blocks(e2fsck_t ctx); 75 static void process_inodes(e2fsck_t ctx, char *block_buf); 76 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); 77 static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, 78 dgrp_t group, void * priv_data); 79 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 80 char *block_buf, int adjust_sign); 81 /* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */ 82 83 struct process_block_struct { 84 ext2_ino_t ino; 85 unsigned is_dir:1, is_reg:1, clear:1, suppress:1, 86 fragmented:1, compressed:1, bbcheck:1, 87 inode_modified:1; 88 blk64_t num_blocks; 89 blk64_t max_blocks; 90 blk64_t last_block; 91 e2_blkcnt_t last_init_lblock; 92 e2_blkcnt_t last_db_block; 93 int num_illegal_blocks; 94 blk64_t previous_block; 95 struct ext2_inode *inode; 96 struct problem_context *pctx; 97 ext2fs_block_bitmap fs_meta_blocks; 98 e2fsck_t ctx; 99 region_t region; 100 struct extent_tree_info eti; 101 }; 102 103 struct process_inode_block { 104 ext2_ino_t ino; 105 struct ext2_inode_large inode; 106 }; 107 108 struct scan_callback_struct { 109 e2fsck_t ctx; 110 char *block_buf; 111 }; 112 113 /* 114 * For the inodes to process list. 115 */ 116 static struct process_inode_block *inodes_to_process; 117 static int process_inode_count; 118 119 static __u64 ext2_max_sizes[EXT2_MAX_BLOCK_LOG_SIZE - 120 EXT2_MIN_BLOCK_LOG_SIZE + 1]; 121 122 /* 123 * Free all memory allocated by pass1 in preparation for restarting 124 * things. 125 */ 126 static void unwind_pass1(ext2_filsys fs EXT2FS_ATTR((unused))) 127 { 128 ext2fs_free_mem(&inodes_to_process); 129 inodes_to_process = 0; 130 } 131 132 /* 133 * Check to make sure a device inode is real. Returns 1 if the device 134 * checks out, 0 if not. 135 * 136 * Note: this routine is now also used to check FIFO's and Sockets, 137 * since they have the same requirement; the i_block fields should be 138 * zero. 139 */ 140 int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)), 141 struct ext2_inode *inode) 142 { 143 int i; 144 145 /* 146 * If the index flag is set, then this is a bogus 147 * device/fifo/socket 148 */ 149 if (inode->i_flags & EXT2_INDEX_FL) 150 return 0; 151 152 /* 153 * We should be able to do the test below all the time, but 154 * because the kernel doesn't forcibly clear the device 155 * inode's additional i_block fields, there are some rare 156 * occasions when a legitimate device inode will have non-zero 157 * additional i_block fields. So for now, we only complain 158 * when the immutable flag is set, which should never happen 159 * for devices. (And that's when the problem is caused, since 160 * you can't set or clear immutable flags for devices.) Once 161 * the kernel has been fixed we can change this... 162 */ 163 if (inode->i_flags & (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL)) { 164 for (i=4; i < EXT2_N_BLOCKS; i++) 165 if (inode->i_block[i]) 166 return 0; 167 } 168 return 1; 169 } 170 171 /* 172 * Check to make sure a symlink inode is real. Returns 1 if the symlink 173 * checks out, 0 if not. 174 */ 175 int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, 176 struct ext2_inode *inode, char *buf) 177 { 178 unsigned int len; 179 int i; 180 blk64_t blocks; 181 ext2_extent_handle_t handle; 182 struct ext2_extent_info info; 183 struct ext2fs_extent extent; 184 185 if ((inode->i_size_high || inode->i_size == 0) || 186 (inode->i_flags & EXT2_INDEX_FL)) 187 return 0; 188 189 if (inode->i_flags & EXT4_EXTENTS_FL) { 190 if (inode->i_flags & EXT4_INLINE_DATA_FL) 191 return 0; 192 if (inode->i_size > fs->blocksize) 193 return 0; 194 if (ext2fs_extent_open2(fs, ino, inode, &handle)) 195 return 0; 196 i = 0; 197 if (ext2fs_extent_get_info(handle, &info) || 198 (info.num_entries != 1) || 199 (info.max_depth != 0)) 200 goto exit_extent; 201 if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) || 202 (extent.e_lblk != 0) || 203 (extent.e_len != 1) || 204 (extent.e_pblk < fs->super->s_first_data_block) || 205 (extent.e_pblk >= ext2fs_blocks_count(fs->super))) 206 goto exit_extent; 207 i = 1; 208 exit_extent: 209 ext2fs_extent_free(handle); 210 return i; 211 } 212 213 if (inode->i_flags & EXT4_INLINE_DATA_FL) { 214 size_t inline_size; 215 216 if (ext2fs_inline_data_size(fs, ino, &inline_size)) 217 return 0; 218 if (inode->i_size != inline_size) 219 return 0; 220 221 return 1; 222 } 223 224 blocks = ext2fs_inode_data_blocks2(fs, inode); 225 if (blocks) { 226 if (inode->i_flags & EXT4_INLINE_DATA_FL) 227 return 0; 228 if ((inode->i_size >= fs->blocksize) || 229 (blocks != fs->blocksize >> 9) || 230 (inode->i_block[0] < fs->super->s_first_data_block) || 231 (inode->i_block[0] >= ext2fs_blocks_count(fs->super))) 232 return 0; 233 234 for (i = 1; i < EXT2_N_BLOCKS; i++) 235 if (inode->i_block[i]) 236 return 0; 237 238 if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf)) 239 return 0; 240 241 if (inode->i_flags & EXT4_ENCRYPT_FL) { 242 len = ext2fs_le32_to_cpu(*((__u32 *)buf)) + 4; 243 } else { 244 len = strnlen(buf, fs->blocksize); 245 } 246 if (len == fs->blocksize) 247 return 0; 248 } else if (inode->i_flags & EXT4_INLINE_DATA_FL) { 249 char *inline_buf = NULL; 250 size_t inline_sz = 0; 251 252 if (ext2fs_inline_data_size(fs, ino, &inline_sz)) 253 return 0; 254 if (inode->i_size != inline_sz) 255 return 0; 256 if (ext2fs_get_mem(inline_sz + 1, &inline_buf)) 257 return 0; 258 i = 0; 259 if (ext2fs_inline_data_get(fs, ino, inode, inline_buf, NULL)) 260 goto exit_inline; 261 inline_buf[inline_sz] = 0; 262 len = strnlen(inline_buf, inline_sz); 263 if (len != inline_sz) 264 goto exit_inline; 265 i = 1; 266 exit_inline: 267 ext2fs_free_mem(&inline_buf); 268 return i; 269 } else { 270 if (inode->i_size >= sizeof(inode->i_block)) 271 return 0; 272 273 len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); 274 if (len == sizeof(inode->i_block)) 275 return 0; 276 } 277 if (len != inode->i_size) 278 if ((inode->i_flags & EXT4_ENCRYPT_FL) == 0) 279 return 0; 280 return 1; 281 } 282 283 /* 284 * If the extents or inlinedata flags are set on the inode, offer to clear 'em. 285 */ 286 #define BAD_SPECIAL_FLAGS (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL) 287 static void check_extents_inlinedata(e2fsck_t ctx, 288 struct problem_context *pctx) 289 { 290 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) 291 return; 292 293 if (!fix_problem(ctx, PR_1_SPECIAL_EXTENTS_IDATA, pctx)) 294 return; 295 296 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; 297 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 298 } 299 #undef BAD_SPECIAL_FLAGS 300 301 /* 302 * If the immutable (or append-only) flag is set on the inode, offer 303 * to clear it. 304 */ 305 #define BAD_SPECIAL_FLAGS (EXT2_IMMUTABLE_FL | EXT2_APPEND_FL) 306 static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) 307 { 308 if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) 309 return; 310 311 if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) 312 return; 313 314 pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; 315 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 316 } 317 318 /* 319 * If device, fifo or socket, check size is zero -- if not offer to 320 * clear it 321 */ 322 static void check_size(e2fsck_t ctx, struct problem_context *pctx) 323 { 324 struct ext2_inode *inode = pctx->inode; 325 326 if (EXT2_I_SIZE(inode) == 0) 327 return; 328 329 if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) 330 return; 331 332 ext2fs_inode_size_set(ctx->fs, inode, 0); 333 e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); 334 } 335 336 static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) 337 { 338 struct ext2_super_block *sb = ctx->fs->super; 339 struct ext2_inode_large *inode; 340 struct ext2_ext_attr_entry *entry; 341 char *start, *header; 342 unsigned int storage_size, remain; 343 problem_t problem = 0; 344 region_t region = 0; 345 346 inode = (struct ext2_inode_large *) pctx->inode; 347 storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - 348 inode->i_extra_isize; 349 header = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 350 inode->i_extra_isize; 351 start = header + sizeof(__u32); 352 entry = (struct ext2_ext_attr_entry *) start; 353 354 /* scan all entry's headers first */ 355 356 /* take finish entry 0UL into account */ 357 remain = storage_size - sizeof(__u32); 358 359 region = region_create(0, storage_size); 360 if (!region) { 361 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); 362 problem = 0; 363 ctx->flags |= E2F_FLAG_ABORT; 364 return; 365 } 366 if (region_allocate(region, 0, sizeof(__u32))) { 367 problem = PR_1_INODE_EA_ALLOC_COLLISION; 368 goto fix; 369 } 370 371 while (remain >= sizeof(struct ext2_ext_attr_entry) && 372 !EXT2_EXT_IS_LAST_ENTRY(entry)) { 373 __u32 hash; 374 375 if (region_allocate(region, (char *)entry - (char *)header, 376 EXT2_EXT_ATTR_LEN(entry->e_name_len))) { 377 problem = PR_1_INODE_EA_ALLOC_COLLISION; 378 goto fix; 379 } 380 381 /* header eats this space */ 382 remain -= sizeof(struct ext2_ext_attr_entry); 383 384 /* is attribute name valid? */ 385 if (EXT2_EXT_ATTR_SIZE(entry->e_name_len) > remain) { 386 pctx->num = entry->e_name_len; 387 problem = PR_1_ATTR_NAME_LEN; 388 goto fix; 389 } 390 391 /* attribute len eats this space */ 392 remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); 393 394 /* check value size */ 395 if (entry->e_value_size > remain) { 396 pctx->num = entry->e_value_size; 397 problem = PR_1_ATTR_VALUE_SIZE; 398 goto fix; 399 } 400 401 /* e_value_block must be 0 in inode's ea */ 402 if (entry->e_value_block != 0) { 403 pctx->num = entry->e_value_block; 404 problem = PR_1_ATTR_VALUE_BLOCK; 405 goto fix; 406 } 407 408 if (entry->e_value_size && 409 region_allocate(region, sizeof(__u32) + entry->e_value_offs, 410 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { 411 problem = PR_1_INODE_EA_ALLOC_COLLISION; 412 goto fix; 413 } 414 415 hash = ext2fs_ext_attr_hash_entry(entry, 416 start + entry->e_value_offs); 417 418 /* e_hash may be 0 in older inode's ea */ 419 if (entry->e_hash != 0 && entry->e_hash != hash) { 420 pctx->num = entry->e_hash; 421 problem = PR_1_ATTR_HASH; 422 goto fix; 423 } 424 425 remain -= entry->e_value_size; 426 427 entry = EXT2_EXT_ATTR_NEXT(entry); 428 } 429 430 if (region_allocate(region, (char *)entry - (char *)header, 431 sizeof(__u32))) { 432 problem = PR_1_INODE_EA_ALLOC_COLLISION; 433 goto fix; 434 } 435 fix: 436 if (region) 437 region_free(region); 438 /* 439 * it seems like a corruption. it's very unlikely we could repair 440 * EA(s) in automatic fashion -bzzz 441 */ 442 if (problem == 0 || !fix_problem(ctx, problem, pctx)) 443 return; 444 445 /* simply remove all possible EA(s) */ 446 *((__u32 *)header) = 0UL; 447 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 448 EXT2_INODE_SIZE(sb), "pass1"); 449 } 450 451 static int check_inode_extra_negative_epoch(__u32 xtime, __u32 extra) { 452 return (xtime & (1 << 31)) != 0 && 453 (extra & EXT4_EPOCH_MASK) == EXT4_EPOCH_MASK; 454 } 455 456 #define CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, xtime) \ 457 check_inode_extra_negative_epoch(inode->i_##xtime, \ 458 inode->i_##xtime##_extra) 459 460 /* When today's date is earlier than 2242, we assume that atimes, 461 * ctimes, crtimes, and mtimes with years in the range 2310..2378 are 462 * actually pre-1970 dates mis-encoded. 463 */ 464 #define EXT4_EXTRA_NEGATIVE_DATE_CUTOFF 2 * (1LL << 32) 465 466 static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) 467 { 468 struct ext2_super_block *sb = ctx->fs->super; 469 struct ext2_inode_large *inode; 470 __u32 *eamagic; 471 int min, max; 472 473 inode = (struct ext2_inode_large *) pctx->inode; 474 if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { 475 /* this isn't large inode. so, nothing to check */ 476 return; 477 } 478 479 #if 0 480 printf("inode #%u, i_extra_size %d\n", pctx->ino, 481 inode->i_extra_isize); 482 #endif 483 /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */ 484 min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi); 485 max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; 486 /* 487 * For now we will allow i_extra_isize to be 0, but really 488 * implementations should never allow i_extra_isize to be 0 489 */ 490 if (inode->i_extra_isize && 491 (inode->i_extra_isize < min || inode->i_extra_isize > max || 492 inode->i_extra_isize & 3)) { 493 if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) 494 return; 495 if (inode->i_extra_isize < min || inode->i_extra_isize > max) 496 inode->i_extra_isize = sb->s_want_extra_isize; 497 else 498 inode->i_extra_isize = (inode->i_extra_isize + 3) & ~3; 499 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 500 EXT2_INODE_SIZE(sb), "pass1"); 501 return; 502 } 503 504 /* check if there is no place for an EA header */ 505 if (inode->i_extra_isize >= max - sizeof(__u32)) 506 return; 507 508 eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + 509 inode->i_extra_isize); 510 if (*eamagic == EXT2_EXT_ATTR_MAGIC) { 511 /* it seems inode has an extended attribute(s) in body */ 512 check_ea_in_inode(ctx, pctx); 513 } 514 515 /* 516 * If the inode's extended atime (ctime, crtime, mtime) is stored in 517 * the old, invalid format, repair it. 518 */ 519 if (((sizeof(time_t) <= 4) || 520 (((sizeof(time_t) > 4) && 521 ctx->now < EXT4_EXTRA_NEGATIVE_DATE_CUTOFF))) && 522 (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime) || 523 CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, ctime) || 524 CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime) || 525 CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime))) { 526 527 if (!fix_problem(ctx, PR_1_EA_TIME_OUT_OF_RANGE, pctx)) 528 return; 529 530 if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime)) 531 inode->i_atime_extra &= ~EXT4_EPOCH_MASK; 532 if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, ctime)) 533 inode->i_ctime_extra &= ~EXT4_EPOCH_MASK; 534 if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime)) 535 inode->i_crtime_extra &= ~EXT4_EPOCH_MASK; 536 if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime)) 537 inode->i_mtime_extra &= ~EXT4_EPOCH_MASK; 538 e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, 539 EXT2_INODE_SIZE(sb), "pass1"); 540 } 541 542 } 543 544 /* 545 * Check to see if the inode might really be a directory, despite i_mode 546 * 547 * This is a lot of complexity for something for which I'm not really 548 * convinced happens frequently in the wild. If for any reason this 549 * causes any problems, take this code out. 550 * [tytso:20070331.0827EDT] 551 */ 552 static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, 553 char *buf) 554 { 555 struct ext2_inode *inode = pctx->inode; 556 struct ext2_dir_entry *dirent; 557 errcode_t retval; 558 blk64_t blk; 559 unsigned int i, rec_len, not_device = 0; 560 int extent_fs; 561 int inlinedata_fs; 562 563 /* 564 * If the mode looks OK, we believe it. If the first block in 565 * the i_block array is 0, this cannot be a directory. If the 566 * inode is extent-mapped, it is still the case that the latter 567 * cannot be 0 - the magic number in the extent header would make 568 * it nonzero. 569 */ 570 if (LINUX_S_ISDIR(inode->i_mode) || LINUX_S_ISREG(inode->i_mode) || 571 LINUX_S_ISLNK(inode->i_mode) || inode->i_block[0] == 0) 572 return; 573 574 /* 575 * Check the block numbers in the i_block array for validity: 576 * zero blocks are skipped (but the first one cannot be zero - 577 * see above), other blocks are checked against the first and 578 * max data blocks (from the the superblock) and against the 579 * block bitmap. Any invalid block found means this cannot be 580 * a directory. 581 * 582 * If there are non-zero blocks past the fourth entry, then 583 * this cannot be a device file: we remember that for the next 584 * check. 585 * 586 * For extent mapped files, we don't do any sanity checking: 587 * just try to get the phys block of logical block 0 and run 588 * with it. 589 * 590 * For inline data files, we just try to get the size of inline 591 * data. If it's true, we will treat it as a directory. 592 */ 593 594 extent_fs = ext2fs_has_feature_extents(ctx->fs->super); 595 inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); 596 if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) { 597 size_t size; 598 __u32 dotdot; 599 unsigned int rec_len2; 600 struct ext2_dir_entry de; 601 602 if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size)) 603 return; 604 /* 605 * If the size isn't a multiple of 4, it's probably not a 606 * directory?? 607 */ 608 if (size & 3) 609 return; 610 /* 611 * If the first 10 bytes don't look like a directory entry, 612 * it's probably not a directory. 613 */ 614 memcpy(&dotdot, inode->i_block, sizeof(dotdot)); 615 memcpy(&de, ((char *)inode->i_block) + EXT4_INLINE_DATA_DOTDOT_SIZE, 616 EXT2_DIR_REC_LEN(0)); 617 dotdot = ext2fs_le32_to_cpu(dotdot); 618 de.inode = ext2fs_le32_to_cpu(de.inode); 619 de.rec_len = ext2fs_le16_to_cpu(de.rec_len); 620 ext2fs_get_rec_len(ctx->fs, &de, &rec_len2); 621 if (dotdot >= ctx->fs->super->s_inodes_count || 622 (dotdot < EXT2_FIRST_INO(ctx->fs->super) && 623 dotdot != EXT2_ROOT_INO) || 624 de.inode >= ctx->fs->super->s_inodes_count || 625 (de.inode < EXT2_FIRST_INO(ctx->fs->super) && 626 de.inode != 0) || 627 rec_len2 > EXT4_MIN_INLINE_DATA_SIZE - 628 EXT4_INLINE_DATA_DOTDOT_SIZE) 629 return; 630 /* device files never have a "system.data" entry */ 631 goto isdir; 632 } else if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { 633 /* extent mapped */ 634 if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0, 635 &blk)) 636 return; 637 /* device files are never extent mapped */ 638 not_device++; 639 } else { 640 for (i=0; i < EXT2_N_BLOCKS; i++) { 641 blk = inode->i_block[i]; 642 if (!blk) 643 continue; 644 if (i >= 4) 645 not_device++; 646 647 if (blk < ctx->fs->super->s_first_data_block || 648 blk >= ext2fs_blocks_count(ctx->fs->super) || 649 ext2fs_fast_test_block_bitmap2(ctx->block_found_map, 650 blk)) 651 return; /* Invalid block, can't be dir */ 652 } 653 blk = inode->i_block[0]; 654 } 655 656 /* 657 * If the mode says this is a device file and the i_links_count field 658 * is sane and we have not ruled it out as a device file previously, 659 * we declare it a device file, not a directory. 660 */ 661 if ((LINUX_S_ISCHR(inode->i_mode) || LINUX_S_ISBLK(inode->i_mode)) && 662 (inode->i_links_count == 1) && !not_device) 663 return; 664 665 /* read the first block */ 666 ehandler_operation(_("reading directory block")); 667 retval = ext2fs_read_dir_block4(ctx->fs, blk, buf, 0, pctx->ino); 668 ehandler_operation(0); 669 if (retval) 670 return; 671 672 dirent = (struct ext2_dir_entry *) buf; 673 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); 674 if (retval) 675 return; 676 if ((ext2fs_dirent_name_len(dirent) != 1) || 677 (dirent->name[0] != '.') || 678 (dirent->inode != pctx->ino) || 679 (rec_len < 12) || 680 (rec_len % 4) || 681 (rec_len >= ctx->fs->blocksize - 12)) 682 return; 683 684 dirent = (struct ext2_dir_entry *) (buf + rec_len); 685 retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); 686 if (retval) 687 return; 688 if ((ext2fs_dirent_name_len(dirent) != 2) || 689 (dirent->name[0] != '.') || 690 (dirent->name[1] != '.') || 691 (rec_len < 12) || 692 (rec_len % 4)) 693 return; 694 695 isdir: 696 if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) { 697 inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR; 698 e2fsck_write_inode_full(ctx, pctx->ino, inode, 699 EXT2_INODE_SIZE(ctx->fs->super), 700 "check_is_really_dir"); 701 } 702 } 703 704 extern errcode_t e2fsck_setup_icount(e2fsck_t ctx, const char *icount_name, 705 int flags, ext2_icount_t hint, 706 ext2_icount_t *ret) 707 { 708 unsigned int threshold; 709 unsigned int save_type; 710 ext2_ino_t num_dirs; 711 errcode_t retval; 712 char *tdb_dir; 713 int enable; 714 715 *ret = 0; 716 717 profile_get_string(ctx->profile, "scratch_files", "directory", 0, 0, 718 &tdb_dir); 719 profile_get_uint(ctx->profile, "scratch_files", 720 "numdirs_threshold", 0, 0, &threshold); 721 profile_get_boolean(ctx->profile, "scratch_files", 722 "icount", 0, 1, &enable); 723 724 retval = ext2fs_get_num_dirs(ctx->fs, &num_dirs); 725 if (retval) 726 num_dirs = 1024; /* Guess */ 727 728 if (enable && tdb_dir && !access(tdb_dir, W_OK) && 729 (!threshold || num_dirs > threshold)) { 730 retval = ext2fs_create_icount_tdb(ctx->fs, tdb_dir, 731 flags, ret); 732 if (retval == 0) 733 return 0; 734 } 735 e2fsck_set_bitmap_type(ctx->fs, EXT2FS_BMAP64_RBTREE, icount_name, 736 &save_type); 737 retval = ext2fs_create_icount2(ctx->fs, flags, 0, hint, ret); 738 ctx->fs->default_bitmap_type = save_type; 739 return retval; 740 } 741 742 static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, 743 e2fsck_t ctx, 744 struct problem_context *pctx) 745 { 746 errcode_t retval; 747 struct ext2_inode_large inode; 748 749 /* 750 * Reread inode. If we don't see checksum error, then this inode 751 * has been fixed elsewhere. 752 */ 753 ctx->stashed_ino = 0; 754 retval = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode, 755 sizeof(inode)); 756 if (retval && retval != EXT2_ET_INODE_CSUM_INVALID) 757 return retval; 758 if (!retval) 759 return 0; 760 761 /* 762 * Checksum still doesn't match. That implies that the inode passes 763 * all the sanity checks, so maybe the checksum is simply corrupt. 764 * See if the user will go for fixing that. 765 */ 766 if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx)) 767 return 0; 768 769 retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode, 770 sizeof(inode)); 771 return retval; 772 } 773 774 static void reserve_block_for_root_repair(e2fsck_t ctx) 775 { 776 blk64_t blk = 0; 777 errcode_t err; 778 ext2_filsys fs = ctx->fs; 779 780 ctx->root_repair_block = 0; 781 if (ext2fs_test_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO)) 782 return; 783 784 err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); 785 if (err) 786 return; 787 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 788 ctx->root_repair_block = blk; 789 } 790 791 static void reserve_block_for_lnf_repair(e2fsck_t ctx) 792 { 793 blk64_t blk = 0; 794 errcode_t err; 795 ext2_filsys fs = ctx->fs; 796 static const char name[] = "lost+found"; 797 ext2_ino_t ino; 798 799 ctx->lnf_repair_block = 0; 800 if (!ext2fs_lookup(fs, EXT2_ROOT_INO, name, sizeof(name)-1, 0, &ino)) 801 return; 802 803 err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); 804 if (err) 805 return; 806 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 807 ctx->lnf_repair_block = blk; 808 } 809 810 static errcode_t get_inline_data_ea_size(ext2_filsys fs, ext2_ino_t ino, 811 size_t *sz) 812 { 813 void *p; 814 struct ext2_xattr_handle *handle; 815 errcode_t retval; 816 817 retval = ext2fs_xattrs_open(fs, ino, &handle); 818 if (retval) 819 return retval; 820 821 retval = ext2fs_xattrs_read(handle); 822 if (retval) 823 goto err; 824 825 retval = ext2fs_xattr_get(handle, "system.data", &p, sz); 826 if (retval) 827 goto err; 828 ext2fs_free_mem(&p); 829 err: 830 (void) ext2fs_xattrs_close(&handle); 831 return retval; 832 } 833 834 static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino, 835 struct problem_context *pctx, 836 int failed_csum) 837 { 838 if (!failed_csum) 839 return; 840 841 /* 842 * If the inode failed the checksum and the user didn't 843 * clear the inode, test the checksum again -- if it still 844 * fails, ask the user if the checksum should be corrected. 845 */ 846 pctx->errcode = recheck_bad_inode_checksum(ctx->fs, ino, ctx, pctx); 847 if (pctx->errcode) 848 ctx->flags |= E2F_FLAG_ABORT; 849 } 850 #define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \ 851 do { \ 852 finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \ 853 if ((ctx)->flags & E2F_FLAG_ABORT) \ 854 return; \ 855 } while (0) 856 857 static int could_be_block_map(ext2_filsys fs, struct ext2_inode *inode) 858 { 859 __u32 x; 860 int i; 861 862 for (i = 0; i < EXT2_N_BLOCKS; i++) { 863 x = inode->i_block[i]; 864 #ifdef WORDS_BIGENDIAN 865 x = ext2fs_swab32(x); 866 #endif 867 if (x >= ext2fs_blocks_count(fs->super)) 868 return 0; 869 } 870 871 return 1; 872 } 873 874 /* 875 * Figure out what to do with an inode that has both extents and inline data 876 * inode flags set. Returns -1 if we decide to erase the inode, 0 otherwise. 877 */ 878 static int fix_inline_data_extents_file(e2fsck_t ctx, 879 ext2_ino_t ino, 880 struct ext2_inode *inode, 881 int inode_size, 882 struct problem_context *pctx) 883 { 884 size_t max_inline_ea_size; 885 ext2_filsys fs = ctx->fs; 886 int dirty = 0; 887 888 /* Both feature flags not set? Just run the regular checks */ 889 if (!ext2fs_has_feature_extents(fs->super) && 890 !ext2fs_has_feature_inline_data(fs->super)) 891 return 0; 892 893 /* Clear both flags if it's a special file */ 894 if (LINUX_S_ISCHR(inode->i_mode) || 895 LINUX_S_ISBLK(inode->i_mode) || 896 LINUX_S_ISFIFO(inode->i_mode) || 897 LINUX_S_ISSOCK(inode->i_mode)) { 898 check_extents_inlinedata(ctx, pctx); 899 return 0; 900 } 901 902 /* If it looks like an extent tree, try to clear inlinedata */ 903 if (ext2fs_extent_header_verify(inode->i_block, 904 sizeof(inode->i_block)) == 0 && 905 fix_problem(ctx, PR_1_CLEAR_INLINE_DATA_FOR_EXTENT, pctx)) { 906 inode->i_flags &= ~EXT4_INLINE_DATA_FL; 907 dirty = 1; 908 goto out; 909 } 910 911 /* If it looks short enough to be inline data, try to clear extents */ 912 if (inode_size > EXT2_GOOD_OLD_INODE_SIZE) 913 max_inline_ea_size = inode_size - 914 (EXT2_GOOD_OLD_INODE_SIZE + 915 ((struct ext2_inode_large *)inode)->i_extra_isize); 916 else 917 max_inline_ea_size = 0; 918 if (EXT2_I_SIZE(inode) < 919 EXT4_MIN_INLINE_DATA_SIZE + max_inline_ea_size && 920 fix_problem(ctx, PR_1_CLEAR_EXTENT_FOR_INLINE_DATA, pctx)) { 921 inode->i_flags &= ~EXT4_EXTENTS_FL; 922 dirty = 1; 923 goto out; 924 } 925 926 /* 927 * Too big for inline data, but no evidence of extent tree - 928 * maybe it's a block map file? If the mappings all look valid? 929 */ 930 if (could_be_block_map(fs, inode) && 931 fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS, pctx)) { 932 #ifdef WORDS_BIGENDIAN 933 int i; 934 935 for (i = 0; i < EXT2_N_BLOCKS; i++) 936 inode->i_block[i] = ext2fs_swab32(inode->i_block[i]); 937 #endif 938 939 inode->i_flags &= ~(EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL); 940 dirty = 1; 941 goto out; 942 } 943 944 /* Oh well, just clear the busted inode. */ 945 if (fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_INODE, pctx)) { 946 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 947 return -1; 948 } 949 950 out: 951 if (dirty) 952 e2fsck_write_inode(ctx, ino, inode, "pass1"); 953 954 return 0; 955 } 956 957 static void pass1_readahead(e2fsck_t ctx, dgrp_t *group, ext2_ino_t *next_ino) 958 { 959 ext2_ino_t inodes_in_group = 0, inodes_per_block, inodes_per_buffer; 960 dgrp_t start = *group, grp; 961 blk64_t blocks_to_read = 0; 962 errcode_t err = EXT2_ET_INVALID_ARGUMENT; 963 964 if (ctx->readahead_kb == 0) 965 goto out; 966 967 /* Keep iterating groups until we have enough to readahead */ 968 inodes_per_block = EXT2_INODES_PER_BLOCK(ctx->fs->super); 969 for (grp = start; grp < ctx->fs->group_desc_count; grp++) { 970 if (ext2fs_bg_flags_test(ctx->fs, grp, EXT2_BG_INODE_UNINIT)) 971 continue; 972 inodes_in_group = ctx->fs->super->s_inodes_per_group - 973 ext2fs_bg_itable_unused(ctx->fs, grp); 974 blocks_to_read += (inodes_in_group + inodes_per_block - 1) / 975 inodes_per_block; 976 if (blocks_to_read * ctx->fs->blocksize > 977 ctx->readahead_kb * 1024) 978 break; 979 } 980 981 err = e2fsck_readahead(ctx->fs, E2FSCK_READA_ITABLE, start, 982 grp - start + 1); 983 if (err == EAGAIN) { 984 ctx->readahead_kb /= 2; 985 err = 0; 986 } 987 988 out: 989 if (err) { 990 /* Error; disable itable readahead */ 991 *group = ctx->fs->group_desc_count; 992 *next_ino = ctx->fs->super->s_inodes_count; 993 } else { 994 /* 995 * Don't do more readahead until we've reached the first inode 996 * of the last inode scan buffer block for the last group. 997 */ 998 *group = grp + 1; 999 inodes_per_buffer = (ctx->inode_buffer_blocks ? 1000 ctx->inode_buffer_blocks : 1001 EXT2_INODE_SCAN_DEFAULT_BUFFER_BLOCKS) * 1002 ctx->fs->blocksize / 1003 EXT2_INODE_SIZE(ctx->fs->super); 1004 inodes_in_group--; 1005 *next_ino = inodes_in_group - 1006 (inodes_in_group % inodes_per_buffer) + 1 + 1007 (grp * ctx->fs->super->s_inodes_per_group); 1008 } 1009 } 1010 1011 /* 1012 * Check if the passed ino is one of the used superblock quota inodes. 1013 * 1014 * Before the quota inodes were journaled, older superblock quota inodes 1015 * were just regular files in the filesystem and not reserved inodes. This 1016 * checks if the passed ino is one of the s_*_quota_inum superblock fields, 1017 * which may not always be the same as the EXT4_*_QUOTA_INO fields. 1018 */ 1019 static int quota_inum_is_super(struct ext2_super_block *sb, ext2_ino_t ino) 1020 { 1021 enum quota_type qtype; 1022 1023 for (qtype = 0; qtype < MAXQUOTAS; qtype++) 1024 if (*quota_sb_inump(sb, qtype) == ino) 1025 return 1; 1026 1027 return 0; 1028 } 1029 1030 /* 1031 * Check if the passed ino is one of the reserved quota inodes. 1032 * This checks if the inode number is one of the reserved EXT4_*_QUOTA_INO 1033 * inodes. These inodes may or may not be in use by the quota feature. 1034 */ 1035 static int quota_inum_is_reserved(ext2_filsys fs, ext2_ino_t ino) 1036 { 1037 enum quota_type qtype; 1038 1039 for (qtype = 0; qtype < MAXQUOTAS; qtype++) 1040 if (quota_type2inum(qtype, fs->super) == ino) 1041 return 1; 1042 1043 return 0; 1044 } 1045 1046 void e2fsck_pass1(e2fsck_t ctx) 1047 { 1048 int i; 1049 __u64 max_sizes; 1050 ext2_filsys fs = ctx->fs; 1051 ext2_ino_t ino = 0; 1052 struct ext2_inode *inode = NULL; 1053 ext2_inode_scan scan = NULL; 1054 char *block_buf = NULL; 1055 #ifdef RESOURCE_TRACK 1056 struct resource_track rtrack; 1057 #endif 1058 unsigned char frag, fsize; 1059 struct problem_context pctx; 1060 struct scan_callback_struct scan_struct; 1061 struct ext2_super_block *sb = ctx->fs->super; 1062 const char *old_op; 1063 int imagic_fs, extent_fs, inlinedata_fs; 1064 int low_dtime_check = 1; 1065 int inode_size = EXT2_INODE_SIZE(fs->super); 1066 int failed_csum = 0; 1067 ext2_ino_t ino_threshold = 0; 1068 dgrp_t ra_group = 0; 1069 1070 init_resource_track(&rtrack, ctx->fs->io); 1071 clear_problem_context(&pctx); 1072 1073 /* If we can do readahead, figure out how many groups to pull in. */ 1074 if (!e2fsck_can_readahead(ctx->fs)) 1075 ctx->readahead_kb = 0; 1076 else if (ctx->readahead_kb == ~0ULL) 1077 ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs); 1078 pass1_readahead(ctx, &ra_group, &ino_threshold); 1079 1080 if (!(ctx->options & E2F_OPT_PREEN)) 1081 fix_problem(ctx, PR_1_PASS_HEADER, &pctx); 1082 1083 if (ext2fs_has_feature_dir_index(fs->super) && 1084 !(ctx->options & E2F_OPT_NO)) { 1085 if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) 1086 ctx->dirs_to_hash = 0; 1087 } 1088 1089 #ifdef MTRACE 1090 mtrace_print("Pass 1"); 1091 #endif 1092 1093 #define EXT2_BPP(bits) (1ULL << ((bits) - 2)) 1094 1095 for (i = EXT2_MIN_BLOCK_LOG_SIZE; i <= EXT2_MAX_BLOCK_LOG_SIZE; i++) { 1096 max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); 1097 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); 1098 max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); 1099 max_sizes = (max_sizes * (1UL << i)); 1100 ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; 1101 } 1102 #undef EXT2_BPP 1103 1104 imagic_fs = ext2fs_has_feature_imagic_inodes(sb); 1105 extent_fs = ext2fs_has_feature_extents(sb); 1106 inlinedata_fs = ext2fs_has_feature_inline_data(sb); 1107 1108 /* 1109 * Allocate bitmaps structures 1110 */ 1111 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"), 1112 EXT2FS_BMAP64_RBTREE, 1113 "inode_used_map", 1114 &ctx->inode_used_map); 1115 if (pctx.errcode) { 1116 pctx.num = 1; 1117 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1118 ctx->flags |= E2F_FLAG_ABORT; 1119 return; 1120 } 1121 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, 1122 _("directory inode map"), 1123 EXT2FS_BMAP64_AUTODIR, 1124 "inode_dir_map", &ctx->inode_dir_map); 1125 if (pctx.errcode) { 1126 pctx.num = 2; 1127 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1128 ctx->flags |= E2F_FLAG_ABORT; 1129 return; 1130 } 1131 pctx.errcode = e2fsck_allocate_inode_bitmap(fs, 1132 _("regular file inode map"), EXT2FS_BMAP64_RBTREE, 1133 "inode_reg_map", &ctx->inode_reg_map); 1134 if (pctx.errcode) { 1135 pctx.num = 6; 1136 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 1137 ctx->flags |= E2F_FLAG_ABORT; 1138 return; 1139 } 1140 pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs, 1141 _("in-use block map"), EXT2FS_BMAP64_RBTREE, 1142 "block_found_map", &ctx->block_found_map); 1143 if (pctx.errcode) { 1144 pctx.num = 1; 1145 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 1146 ctx->flags |= E2F_FLAG_ABORT; 1147 return; 1148 } 1149 pctx.errcode = e2fsck_allocate_block_bitmap(fs, 1150 _("metadata block map"), EXT2FS_BMAP64_RBTREE, 1151 "block_metadata_map", &ctx->block_metadata_map); 1152 if (pctx.errcode) { 1153 pctx.num = 1; 1154 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 1155 ctx->flags |= E2F_FLAG_ABORT; 1156 return; 1157 } 1158 pctx.errcode = e2fsck_setup_icount(ctx, "inode_link_info", 0, NULL, 1159 &ctx->inode_link_info); 1160 if (pctx.errcode) { 1161 fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); 1162 ctx->flags |= E2F_FLAG_ABORT; 1163 return; 1164 } 1165 inode = (struct ext2_inode *) 1166 e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); 1167 1168 inodes_to_process = (struct process_inode_block *) 1169 e2fsck_allocate_memory(ctx, 1170 (ctx->process_inode_size * 1171 sizeof(struct process_inode_block)), 1172 "array of inodes to process"); 1173 process_inode_count = 0; 1174 1175 pctx.errcode = ext2fs_init_dblist(fs, 0); 1176 if (pctx.errcode) { 1177 fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); 1178 ctx->flags |= E2F_FLAG_ABORT; 1179 goto endit; 1180 } 1181 1182 /* 1183 * If the last orphan field is set, clear it, since the pass1 1184 * processing will automatically find and clear the orphans. 1185 * In the future, we may want to try using the last_orphan 1186 * linked list ourselves, but for now, we clear it so that the 1187 * ext3 mount code won't get confused. 1188 */ 1189 if (!(ctx->options & E2F_OPT_READONLY)) { 1190 if (fs->super->s_last_orphan) { 1191 fs->super->s_last_orphan = 0; 1192 ext2fs_mark_super_dirty(fs); 1193 } 1194 } 1195 1196 mark_table_blocks(ctx); 1197 pctx.errcode = ext2fs_convert_subcluster_bitmap(fs, 1198 &ctx->block_found_map); 1199 if (pctx.errcode) { 1200 fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); 1201 ctx->flags |= E2F_FLAG_ABORT; 1202 goto endit; 1203 } 1204 block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, 1205 "block interate buffer"); 1206 if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE) 1207 e2fsck_use_inode_shortcuts(ctx, 1); 1208 e2fsck_intercept_block_allocations(ctx); 1209 old_op = ehandler_operation(_("opening inode scan")); 1210 pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, 1211 &scan); 1212 ehandler_operation(old_op); 1213 if (pctx.errcode) { 1214 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); 1215 ctx->flags |= E2F_FLAG_ABORT; 1216 goto endit; 1217 } 1218 ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE | 1219 EXT2_SF_WARN_GARBAGE_INODES, 0); 1220 ctx->stashed_inode = inode; 1221 scan_struct.ctx = ctx; 1222 scan_struct.block_buf = block_buf; 1223 ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); 1224 if (ctx->progress && ((ctx->progress)(ctx, 1, 0, 1225 ctx->fs->group_desc_count))) 1226 goto endit; 1227 if ((fs->super->s_wtime < fs->super->s_inodes_count) || 1228 (fs->super->s_mtime < fs->super->s_inodes_count) || 1229 (fs->super->s_mkfs_time && 1230 fs->super->s_mkfs_time < fs->super->s_inodes_count)) 1231 low_dtime_check = 0; 1232 1233 if (ext2fs_has_feature_mmp(fs->super) && 1234 fs->super->s_mmp_block > fs->super->s_first_data_block && 1235 fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) 1236 ext2fs_mark_block_bitmap2(ctx->block_found_map, 1237 fs->super->s_mmp_block); 1238 1239 /* Set up ctx->lost_and_found if possible */ 1240 (void) e2fsck_get_lost_and_found(ctx, 0); 1241 1242 while (1) { 1243 if (ino % (fs->super->s_inodes_per_group * 4) == 1) { 1244 if (e2fsck_mmp_update(fs)) 1245 fatal_error(ctx, 0); 1246 } 1247 old_op = ehandler_operation(_("getting next inode from scan")); 1248 pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, 1249 inode, inode_size); 1250 if (ino > ino_threshold) 1251 pass1_readahead(ctx, &ra_group, &ino_threshold); 1252 ehandler_operation(old_op); 1253 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1254 goto endit; 1255 if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { 1256 /* 1257 * If badblocks says badblocks is bad, offer to clear 1258 * the list, update the in-core bb list, and restart 1259 * the inode scan. 1260 */ 1261 if (ino == EXT2_BAD_INO && 1262 fix_problem(ctx, PR_1_BADBLOCKS_IN_BADBLOCKS, 1263 &pctx)) { 1264 errcode_t err; 1265 1266 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 1267 ext2fs_badblocks_list_free(ctx->fs->badblocks); 1268 ctx->fs->badblocks = NULL; 1269 err = ext2fs_read_bb_inode(ctx->fs, 1270 &ctx->fs->badblocks); 1271 if (err) { 1272 fix_problem(ctx, PR_1_ISCAN_ERROR, 1273 &pctx); 1274 ctx->flags |= E2F_FLAG_ABORT; 1275 goto endit; 1276 } 1277 err = ext2fs_inode_scan_goto_blockgroup(scan, 1278 0); 1279 if (err) { 1280 fix_problem(ctx, PR_1_ISCAN_ERROR, 1281 &pctx); 1282 ctx->flags |= E2F_FLAG_ABORT; 1283 goto endit; 1284 } 1285 continue; 1286 } 1287 if (!ctx->inode_bb_map) 1288 alloc_bb_map(ctx); 1289 ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); 1290 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1291 continue; 1292 } 1293 if (pctx.errcode && 1294 pctx.errcode != EXT2_ET_INODE_CSUM_INVALID && 1295 pctx.errcode != EXT2_ET_INODE_IS_GARBAGE) { 1296 fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); 1297 ctx->flags |= E2F_FLAG_ABORT; 1298 goto endit; 1299 } 1300 if (!ino) 1301 break; 1302 pctx.ino = ino; 1303 pctx.inode = inode; 1304 ctx->stashed_ino = ino; 1305 1306 /* Clear trashed inode? */ 1307 if (pctx.errcode == EXT2_ET_INODE_IS_GARBAGE && 1308 inode->i_links_count > 0 && 1309 fix_problem(ctx, PR_1_INODE_IS_GARBAGE, &pctx)) { 1310 pctx.errcode = 0; 1311 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 1312 } 1313 failed_csum = pctx.errcode != 0; 1314 1315 if (inode->i_links_count) { 1316 pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, 1317 ino, inode->i_links_count); 1318 if (pctx.errcode) { 1319 pctx.num = inode->i_links_count; 1320 fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); 1321 ctx->flags |= E2F_FLAG_ABORT; 1322 goto endit; 1323 } 1324 } 1325 1326 /* Conflicting inlinedata/extents inode flags? */ 1327 if ((inode->i_flags & EXT4_INLINE_DATA_FL) && 1328 (inode->i_flags & EXT4_EXTENTS_FL)) { 1329 int res = fix_inline_data_extents_file(ctx, ino, inode, 1330 inode_size, 1331 &pctx); 1332 if (res < 0) { 1333 /* skip FINISH_INODE_LOOP */ 1334 continue; 1335 } 1336 } 1337 1338 /* Test for incorrect inline_data flags settings. */ 1339 if ((inode->i_flags & EXT4_INLINE_DATA_FL) && !inlinedata_fs && 1340 (ino >= EXT2_FIRST_INODE(fs->super))) { 1341 size_t size = 0; 1342 1343 pctx.errcode = ext2fs_inline_data_size(fs, ino, &size); 1344 if (!pctx.errcode && size && 1345 fix_problem(ctx, PR_1_INLINE_DATA_FEATURE, &pctx)) { 1346 ext2fs_set_feature_inline_data(sb); 1347 ext2fs_mark_super_dirty(fs); 1348 inlinedata_fs = 1; 1349 } else if (fix_problem(ctx, PR_1_INLINE_DATA_SET, &pctx)) { 1350 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 1351 /* skip FINISH_INODE_LOOP */ 1352 continue; 1353 } 1354 } 1355 1356 /* Test for inline data flag but no attr */ 1357 if ((inode->i_flags & EXT4_INLINE_DATA_FL) && inlinedata_fs && 1358 EXT2_I_SIZE(inode) > EXT4_MIN_INLINE_DATA_SIZE && 1359 (ino >= EXT2_FIRST_INODE(fs->super))) { 1360 size_t size = 0; 1361 errcode_t err; 1362 int flags; 1363 1364 flags = fs->flags; 1365 if (failed_csum) 1366 fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; 1367 err = get_inline_data_ea_size(fs, ino, &size); 1368 fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | 1369 (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); 1370 1371 switch (err) { 1372 case 0: 1373 /* Everything is awesome... */ 1374 break; 1375 case EXT2_ET_BAD_EA_BLOCK_NUM: 1376 case EXT2_ET_BAD_EA_HASH: 1377 case EXT2_ET_BAD_EA_HEADER: 1378 case EXT2_ET_EA_BAD_NAME_LEN: 1379 case EXT2_ET_EA_BAD_VALUE_SIZE: 1380 case EXT2_ET_EA_KEY_NOT_FOUND: 1381 case EXT2_ET_EA_NO_SPACE: 1382 case EXT2_ET_MISSING_EA_FEATURE: 1383 case EXT2_ET_INLINE_DATA_CANT_ITERATE: 1384 case EXT2_ET_INLINE_DATA_NO_BLOCK: 1385 case EXT2_ET_INLINE_DATA_NO_SPACE: 1386 case EXT2_ET_NO_INLINE_DATA: 1387 case EXT2_ET_EXT_ATTR_CSUM_INVALID: 1388 case EXT2_ET_EA_BAD_VALUE_OFFSET: 1389 /* broken EA or no system.data EA; truncate */ 1390 if (fix_problem(ctx, PR_1_INLINE_DATA_NO_ATTR, 1391 &pctx)) { 1392 err = ext2fs_inode_size_set(fs, inode, 1393 sizeof(inode->i_block)); 1394 if (err) { 1395 pctx.errcode = err; 1396 ctx->flags |= E2F_FLAG_ABORT; 1397 goto endit; 1398 } 1399 if (LINUX_S_ISLNK(inode->i_mode)) 1400 inode->i_flags &= ~EXT4_INLINE_DATA_FL; 1401 e2fsck_write_inode(ctx, ino, inode, 1402 "pass1"); 1403 failed_csum = 0; 1404 } 1405 break; 1406 default: 1407 /* Some other kind of non-xattr error? */ 1408 pctx.errcode = err; 1409 ctx->flags |= E2F_FLAG_ABORT; 1410 goto endit; 1411 } 1412 } 1413 1414 /* 1415 * Test for incorrect extent flag settings. 1416 * 1417 * On big-endian machines we must be careful: 1418 * When the inode is read, the i_block array is not swapped 1419 * if the extent flag is set. Therefore if we are testing 1420 * for or fixing a wrongly-set flag, we must potentially 1421 * (un)swap before testing, or after fixing. 1422 */ 1423 1424 /* 1425 * In this case the extents flag was set when read, so 1426 * extent_header_verify is ok. If the inode is cleared, 1427 * no need to swap... so no extra swapping here. 1428 */ 1429 if ((inode->i_flags & EXT4_EXTENTS_FL) && !extent_fs && 1430 (inode->i_links_count || (ino == EXT2_BAD_INO) || 1431 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO))) { 1432 if ((ext2fs_extent_header_verify(inode->i_block, 1433 sizeof(inode->i_block)) == 0) && 1434 fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) { 1435 ext2fs_set_feature_extents(sb); 1436 ext2fs_mark_super_dirty(fs); 1437 extent_fs = 1; 1438 } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) { 1439 clear_inode: 1440 e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); 1441 if (ino == EXT2_BAD_INO) 1442 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, 1443 ino); 1444 /* skip FINISH_INODE_LOOP */ 1445 continue; 1446 } 1447 } 1448 1449 /* 1450 * For big-endian machines: 1451 * If the inode didn't have the extents flag set when it 1452 * was read, then the i_blocks array was swapped. To test 1453 * as an extents header, we must swap it back first. 1454 * IF we then set the extents flag, the entire i_block 1455 * array must be un/re-swapped to make it proper extents data. 1456 */ 1457 if (extent_fs && !(inode->i_flags & EXT4_EXTENTS_FL) && 1458 (inode->i_links_count || (ino == EXT2_BAD_INO) || 1459 (ino == EXT2_ROOT_INO) || (ino == EXT2_JOURNAL_INO)) && 1460 (LINUX_S_ISREG(inode->i_mode) || 1461 LINUX_S_ISDIR(inode->i_mode))) { 1462 void *ehp; 1463 #ifdef WORDS_BIGENDIAN 1464 __u32 tmp_block[EXT2_N_BLOCKS]; 1465 1466 for (i = 0; i < EXT2_N_BLOCKS; i++) 1467 tmp_block[i] = ext2fs_swab32(inode->i_block[i]); 1468 ehp = tmp_block; 1469 #else 1470 ehp = inode->i_block; 1471 #endif 1472 if ((ext2fs_extent_header_verify(ehp, 1473 sizeof(inode->i_block)) == 0) && 1474 (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) { 1475 inode->i_flags |= EXT4_EXTENTS_FL; 1476 #ifdef WORDS_BIGENDIAN 1477 memcpy(inode->i_block, tmp_block, 1478 sizeof(inode->i_block)); 1479 #endif 1480 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1481 failed_csum = 0; 1482 } 1483 } 1484 1485 if (ino == EXT2_BAD_INO) { 1486 struct process_block_struct pb; 1487 1488 if ((failed_csum || inode->i_mode || inode->i_uid || 1489 inode->i_gid || inode->i_links_count || 1490 (inode->i_flags & EXT4_INLINE_DATA_FL) || 1491 inode->i_file_acl) && 1492 fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) { 1493 memset(inode, 0, sizeof(struct ext2_inode)); 1494 e2fsck_write_inode(ctx, ino, inode, 1495 "clear bad inode"); 1496 failed_csum = 0; 1497 } 1498 1499 pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, 1500 &pb.fs_meta_blocks); 1501 if (pctx.errcode) { 1502 pctx.num = 4; 1503 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); 1504 ctx->flags |= E2F_FLAG_ABORT; 1505 goto endit; 1506 } 1507 pb.ino = EXT2_BAD_INO; 1508 pb.num_blocks = pb.last_block = 0; 1509 pb.last_db_block = -1; 1510 pb.num_illegal_blocks = 0; 1511 pb.suppress = 0; pb.clear = 0; pb.is_dir = 0; 1512 pb.is_reg = 0; pb.fragmented = 0; pb.bbcheck = 0; 1513 pb.inode = inode; 1514 pb.pctx = &pctx; 1515 pb.ctx = ctx; 1516 pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, 1517 block_buf, process_bad_block, &pb); 1518 ext2fs_free_block_bitmap(pb.fs_meta_blocks); 1519 if (pctx.errcode) { 1520 fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); 1521 ctx->flags |= E2F_FLAG_ABORT; 1522 goto endit; 1523 } 1524 if (pb.bbcheck) 1525 if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { 1526 ctx->flags |= E2F_FLAG_ABORT; 1527 goto endit; 1528 } 1529 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1530 clear_problem_context(&pctx); 1531 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1532 continue; 1533 } else if (ino == EXT2_ROOT_INO) { 1534 /* 1535 * Make sure the root inode is a directory; if 1536 * not, offer to clear it. It will be 1537 * regnerated in pass #3. 1538 */ 1539 if (!LINUX_S_ISDIR(inode->i_mode)) { 1540 if (fix_problem(ctx, PR_1_ROOT_NO_DIR, &pctx)) 1541 goto clear_inode; 1542 } 1543 /* 1544 * If dtime is set, offer to clear it. mke2fs 1545 * version 0.2b created filesystems with the 1546 * dtime field set for the root and lost+found 1547 * directories. We won't worry about 1548 * /lost+found, since that can be regenerated 1549 * easily. But we will fix the root directory 1550 * as a special case. 1551 */ 1552 if (inode->i_dtime && inode->i_links_count) { 1553 if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { 1554 inode->i_dtime = 0; 1555 e2fsck_write_inode(ctx, ino, inode, 1556 "pass1"); 1557 failed_csum = 0; 1558 } 1559 } 1560 } else if (ino == EXT2_JOURNAL_INO) { 1561 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1562 if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { 1563 if (!LINUX_S_ISREG(inode->i_mode) && 1564 fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, 1565 &pctx)) { 1566 inode->i_mode = LINUX_S_IFREG; 1567 e2fsck_write_inode(ctx, ino, inode, 1568 "pass1"); 1569 failed_csum = 0; 1570 } 1571 check_blocks(ctx, &pctx, block_buf); 1572 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1573 continue; 1574 } 1575 if ((inode->i_links_count || 1576 inode->i_blocks || inode->i_block[0]) && 1577 fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, 1578 &pctx)) { 1579 memset(inode, 0, inode_size); 1580 ext2fs_icount_store(ctx->inode_link_info, 1581 ino, 0); 1582 e2fsck_write_inode_full(ctx, ino, inode, 1583 inode_size, "pass1"); 1584 failed_csum = 0; 1585 } 1586 } else if (quota_inum_is_reserved(fs, ino)) { 1587 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1588 if (ext2fs_has_feature_quota(fs->super) && 1589 quota_inum_is_super(fs->super, ino)) { 1590 if (!LINUX_S_ISREG(inode->i_mode) && 1591 fix_problem(ctx, PR_1_QUOTA_BAD_MODE, 1592 &pctx)) { 1593 inode->i_mode = LINUX_S_IFREG; 1594 e2fsck_write_inode(ctx, ino, inode, 1595 "pass1"); 1596 failed_csum = 0; 1597 } 1598 check_blocks(ctx, &pctx, block_buf); 1599 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1600 continue; 1601 } 1602 if ((inode->i_links_count || 1603 inode->i_blocks || inode->i_block[0]) && 1604 fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR, 1605 &pctx)) { 1606 memset(inode, 0, inode_size); 1607 ext2fs_icount_store(ctx->inode_link_info, 1608 ino, 0); 1609 e2fsck_write_inode_full(ctx, ino, inode, 1610 inode_size, "pass1"); 1611 failed_csum = 0; 1612 } 1613 } else if (ino < EXT2_FIRST_INODE(fs->super)) { 1614 problem_t problem = 0; 1615 1616 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1617 if (ino == EXT2_BOOT_LOADER_INO) { 1618 if (LINUX_S_ISDIR(inode->i_mode)) 1619 problem = PR_1_RESERVED_BAD_MODE; 1620 } else if (ino == EXT2_RESIZE_INO) { 1621 if (inode->i_mode && 1622 !LINUX_S_ISREG(inode->i_mode)) 1623 problem = PR_1_RESERVED_BAD_MODE; 1624 } else { 1625 if (inode->i_mode != 0) 1626 problem = PR_1_RESERVED_BAD_MODE; 1627 } 1628 if (problem) { 1629 if (fix_problem(ctx, problem, &pctx)) { 1630 inode->i_mode = 0; 1631 e2fsck_write_inode(ctx, ino, inode, 1632 "pass1"); 1633 failed_csum = 0; 1634 } 1635 } 1636 check_blocks(ctx, &pctx, block_buf); 1637 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1638 continue; 1639 } 1640 1641 /* 1642 * Check for inodes who might have been part of the 1643 * orphaned list linked list. They should have gotten 1644 * dealt with by now, unless the list had somehow been 1645 * corrupted. 1646 * 1647 * FIXME: In the future, inodes which are still in use 1648 * (and which are therefore) pending truncation should 1649 * be handled specially. Right now we just clear the 1650 * dtime field, and the normal e2fsck handling of 1651 * inodes where i_size and the inode blocks are 1652 * inconsistent is to fix i_size, instead of releasing 1653 * the extra blocks. This won't catch the inodes that 1654 * was at the end of the orphan list, but it's better 1655 * than nothing. The right answer is that there 1656 * shouldn't be any bugs in the orphan list handling. :-) 1657 */ 1658 if (inode->i_dtime && low_dtime_check && 1659 inode->i_dtime < ctx->fs->super->s_inodes_count) { 1660 if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { 1661 inode->i_dtime = inode->i_links_count ? 1662 0 : ctx->now; 1663 e2fsck_write_inode(ctx, ino, inode, 1664 "pass1"); 1665 failed_csum = 0; 1666 } 1667 } 1668 1669 /* 1670 * This code assumes that deleted inodes have 1671 * i_links_count set to 0. 1672 */ 1673 if (!inode->i_links_count) { 1674 if (!inode->i_dtime && inode->i_mode) { 1675 if (fix_problem(ctx, 1676 PR_1_ZERO_DTIME, &pctx)) { 1677 inode->i_dtime = ctx->now; 1678 e2fsck_write_inode(ctx, ino, inode, 1679 "pass1"); 1680 failed_csum = 0; 1681 } 1682 } 1683 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1684 continue; 1685 } 1686 /* 1687 * n.b. 0.3c ext2fs code didn't clear i_links_count for 1688 * deleted files. Oops. 1689 * 1690 * Since all new ext2 implementations get this right, 1691 * we now assume that the case of non-zero 1692 * i_links_count and non-zero dtime means that we 1693 * should keep the file, not delete it. 1694 * 1695 */ 1696 if (inode->i_dtime) { 1697 if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { 1698 inode->i_dtime = 0; 1699 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1700 failed_csum = 0; 1701 } 1702 } 1703 1704 ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); 1705 switch (fs->super->s_creator_os) { 1706 case EXT2_OS_HURD: 1707 frag = inode->osd2.hurd2.h_i_frag; 1708 fsize = inode->osd2.hurd2.h_i_fsize; 1709 break; 1710 default: 1711 frag = fsize = 0; 1712 } 1713 1714 if (inode->i_faddr || frag || fsize || 1715 (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) 1716 mark_inode_bad(ctx, ino); 1717 if ((fs->super->s_creator_os != EXT2_OS_HURD) && 1718 !ext2fs_has_feature_64bit(fs->super) && 1719 inode->osd2.linux2.l_i_file_acl_high != 0) 1720 mark_inode_bad(ctx, ino); 1721 if ((fs->super->s_creator_os != EXT2_OS_HURD) && 1722 !ext2fs_has_feature_huge_file(fs->super) && 1723 (inode->osd2.linux2.l_i_blocks_hi != 0)) 1724 mark_inode_bad(ctx, ino); 1725 if (inode->i_flags & EXT2_IMAGIC_FL) { 1726 if (imagic_fs) { 1727 if (!ctx->inode_imagic_map) 1728 alloc_imagic_map(ctx); 1729 ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map, 1730 ino); 1731 } else { 1732 if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { 1733 inode->i_flags &= ~EXT2_IMAGIC_FL; 1734 e2fsck_write_inode(ctx, ino, 1735 inode, "pass1"); 1736 failed_csum = 0; 1737 } 1738 } 1739 } 1740 1741 check_inode_extra_space(ctx, &pctx); 1742 check_is_really_dir(ctx, &pctx, block_buf); 1743 1744 /* 1745 * ext2fs_inode_has_valid_blocks2 does not actually look 1746 * at i_block[] values, so not endian-sensitive here. 1747 */ 1748 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) && 1749 LINUX_S_ISLNK(inode->i_mode) && 1750 !ext2fs_inode_has_valid_blocks2(fs, inode) && 1751 fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) { 1752 inode->i_flags &= ~EXT4_EXTENTS_FL; 1753 e2fsck_write_inode(ctx, ino, inode, "pass1"); 1754 failed_csum = 0; 1755 } 1756 1757 if (LINUX_S_ISDIR(inode->i_mode)) { 1758 ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); 1759 e2fsck_add_dir_info(ctx, ino, 0); 1760 ctx->fs_directory_count++; 1761 if (inode->i_flags & EXT4_ENCRYPT_FL) 1762 add_encrypted_dir(ctx, ino); 1763 } else if (LINUX_S_ISREG (inode->i_mode)) { 1764 ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino); 1765 ctx->fs_regular_count++; 1766 } else if (LINUX_S_ISCHR (inode->i_mode) && 1767 e2fsck_pass1_check_device_inode(fs, inode)) { 1768 check_extents_inlinedata(ctx, &pctx); 1769 check_immutable(ctx, &pctx); 1770 check_size(ctx, &pctx); 1771 ctx->fs_chardev_count++; 1772 } else if (LINUX_S_ISBLK (inode->i_mode) && 1773 e2fsck_pass1_check_device_inode(fs, inode)) { 1774 check_extents_inlinedata(ctx, &pctx); 1775 check_immutable(ctx, &pctx); 1776 check_size(ctx, &pctx); 1777 ctx->fs_blockdev_count++; 1778 } else if (LINUX_S_ISLNK (inode->i_mode) && 1779 e2fsck_pass1_check_symlink(fs, ino, inode, 1780 block_buf)) { 1781 check_immutable(ctx, &pctx); 1782 ctx->fs_symlinks_count++; 1783 if (inode->i_flags & EXT4_INLINE_DATA_FL) { 1784 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1785 continue; 1786 } else if (ext2fs_inode_data_blocks(fs, inode) == 0) { 1787 ctx->fs_fast_symlinks_count++; 1788 check_blocks(ctx, &pctx, block_buf); 1789 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1790 continue; 1791 } 1792 } 1793 else if (LINUX_S_ISFIFO (inode->i_mode) && 1794 e2fsck_pass1_check_device_inode(fs, inode)) { 1795 check_extents_inlinedata(ctx, &pctx); 1796 check_immutable(ctx, &pctx); 1797 check_size(ctx, &pctx); 1798 ctx->fs_fifo_count++; 1799 } else if ((LINUX_S_ISSOCK (inode->i_mode)) && 1800 e2fsck_pass1_check_device_inode(fs, inode)) { 1801 check_extents_inlinedata(ctx, &pctx); 1802 check_immutable(ctx, &pctx); 1803 check_size(ctx, &pctx); 1804 ctx->fs_sockets_count++; 1805 } else 1806 mark_inode_bad(ctx, ino); 1807 if (!(inode->i_flags & EXT4_EXTENTS_FL) && 1808 !(inode->i_flags & EXT4_INLINE_DATA_FL)) { 1809 if (inode->i_block[EXT2_IND_BLOCK]) 1810 ctx->fs_ind_count++; 1811 if (inode->i_block[EXT2_DIND_BLOCK]) 1812 ctx->fs_dind_count++; 1813 if (inode->i_block[EXT2_TIND_BLOCK]) 1814 ctx->fs_tind_count++; 1815 } 1816 if (!(inode->i_flags & EXT4_EXTENTS_FL) && 1817 !(inode->i_flags & EXT4_INLINE_DATA_FL) && 1818 (inode->i_block[EXT2_IND_BLOCK] || 1819 inode->i_block[EXT2_DIND_BLOCK] || 1820 inode->i_block[EXT2_TIND_BLOCK] || 1821 ext2fs_file_acl_block(fs, inode))) { 1822 struct ext2_inode_large *ip; 1823 1824 inodes_to_process[process_inode_count].ino = ino; 1825 ip = &inodes_to_process[process_inode_count].inode; 1826 if (inode_size < sizeof(struct ext2_inode_large)) 1827 memcpy(ip, inode, inode_size); 1828 else 1829 memcpy(ip, inode, sizeof(*ip)); 1830 process_inode_count++; 1831 } else 1832 check_blocks(ctx, &pctx, block_buf); 1833 1834 FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); 1835 1836 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1837 goto endit; 1838 1839 if (process_inode_count >= ctx->process_inode_size) { 1840 process_inodes(ctx, block_buf); 1841 1842 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 1843 goto endit; 1844 } 1845 } 1846 process_inodes(ctx, block_buf); 1847 ext2fs_close_inode_scan(scan); 1848 scan = NULL; 1849 1850 reserve_block_for_root_repair(ctx); 1851 reserve_block_for_lnf_repair(ctx); 1852 1853 /* 1854 * If any extended attribute blocks' reference counts need to 1855 * be adjusted, either up (ctx->refcount_extra), or down 1856 * (ctx->refcount), then fix them. 1857 */ 1858 if (ctx->refcount) { 1859 adjust_extattr_refcount(ctx, ctx->refcount, block_buf, -1); 1860 ea_refcount_free(ctx->refcount); 1861 ctx->refcount = 0; 1862 } 1863 if (ctx->refcount_extra) { 1864 adjust_extattr_refcount(ctx, ctx->refcount_extra, 1865 block_buf, +1); 1866 ea_refcount_free(ctx->refcount_extra); 1867 ctx->refcount_extra = 0; 1868 } 1869 1870 if (ctx->invalid_bitmaps) 1871 handle_fs_bad_blocks(ctx); 1872 1873 /* We don't need the block_ea_map any more */ 1874 if (ctx->block_ea_map) { 1875 ext2fs_free_block_bitmap(ctx->block_ea_map); 1876 ctx->block_ea_map = 0; 1877 } 1878 1879 if (ctx->flags & E2F_FLAG_RESIZE_INODE) { 1880 clear_problem_context(&pctx); 1881 pctx.errcode = ext2fs_create_resize_inode(fs); 1882 if (pctx.errcode) { 1883 if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, 1884 &pctx)) { 1885 ctx->flags |= E2F_FLAG_ABORT; 1886 goto endit; 1887 } 1888 pctx.errcode = 0; 1889 } 1890 if (!pctx.errcode) { 1891 e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, 1892 "recreate inode"); 1893 inode->i_mtime = ctx->now; 1894 e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, 1895 "recreate inode"); 1896 } 1897 ctx->flags &= ~E2F_FLAG_RESIZE_INODE; 1898 } 1899 1900 if (ctx->flags & E2F_FLAG_RESTART) { 1901 /* 1902 * Only the master copy of the superblock and block 1903 * group descriptors are going to be written during a 1904 * restart, so set the superblock to be used to be the 1905 * master superblock. 1906 */ 1907 ctx->use_superblock = 0; 1908 unwind_pass1(fs); 1909 goto endit; 1910 } 1911 1912 if (ctx->block_dup_map) { 1913 if (ctx->options & E2F_OPT_PREEN) { 1914 clear_problem_context(&pctx); 1915 fix_problem(ctx, PR_1_DUP_BLOCKS_PREENSTOP, &pctx); 1916 } 1917 e2fsck_pass1_dupblocks(ctx, block_buf); 1918 } 1919 ctx->flags |= E2F_FLAG_ALLOC_OK; 1920 ext2fs_free_mem(&inodes_to_process); 1921 endit: 1922 e2fsck_use_inode_shortcuts(ctx, 0); 1923 1924 if (scan) 1925 ext2fs_close_inode_scan(scan); 1926 if (block_buf) 1927 ext2fs_free_mem(&block_buf); 1928 if (inode) 1929 ext2fs_free_mem(&inode); 1930 1931 /* 1932 * The l+f inode may have been cleared, so zap it now and 1933 * later passes will recalculate it if necessary 1934 */ 1935 ctx->lost_and_found = 0; 1936 1937 if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) 1938 print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); 1939 else 1940 ctx->invalid_bitmaps++; 1941 } 1942 #undef FINISH_INODE_LOOP 1943 1944 /* 1945 * When the inode_scan routines call this callback at the end of the 1946 * glock group, call process_inodes. 1947 */ 1948 static errcode_t scan_callback(ext2_filsys fs, 1949 ext2_inode_scan scan EXT2FS_ATTR((unused)), 1950 dgrp_t group, void * priv_data) 1951 { 1952 struct scan_callback_struct *scan_struct; 1953 e2fsck_t ctx; 1954 1955 scan_struct = (struct scan_callback_struct *) priv_data; 1956 ctx = scan_struct->ctx; 1957 1958 process_inodes((e2fsck_t) fs->priv_data, scan_struct->block_buf); 1959 1960 if (ctx->progress) 1961 if ((ctx->progress)(ctx, 1, group+1, 1962 ctx->fs->group_desc_count)) 1963 return EXT2_ET_CANCEL_REQUESTED; 1964 1965 return 0; 1966 } 1967 1968 /* 1969 * Process the inodes in the "inodes to process" list. 1970 */ 1971 static void process_inodes(e2fsck_t ctx, char *block_buf) 1972 { 1973 int i; 1974 struct ext2_inode *old_stashed_inode; 1975 ext2_ino_t old_stashed_ino; 1976 const char *old_operation; 1977 char buf[80]; 1978 struct problem_context pctx; 1979 1980 #if 0 1981 printf("begin process_inodes: "); 1982 #endif 1983 if (process_inode_count == 0) 1984 return; 1985 old_operation = ehandler_operation(0); 1986 old_stashed_inode = ctx->stashed_inode; 1987 old_stashed_ino = ctx->stashed_ino; 1988 qsort(inodes_to_process, process_inode_count, 1989 sizeof(struct process_inode_block), process_inode_cmp); 1990 clear_problem_context(&pctx); 1991 for (i=0; i < process_inode_count; i++) { 1992 pctx.inode = ctx->stashed_inode = 1993 (struct ext2_inode *) &inodes_to_process[i].inode; 1994 pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; 1995 1996 #if 0 1997 printf("%u ", pctx.ino); 1998 #endif 1999 sprintf(buf, _("reading indirect blocks of inode %u"), 2000 pctx.ino); 2001 ehandler_operation(buf); 2002 check_blocks(ctx, &pctx, block_buf); 2003 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 2004 break; 2005 } 2006 ctx->stashed_inode = old_stashed_inode; 2007 ctx->stashed_ino = old_stashed_ino; 2008 process_inode_count = 0; 2009 #if 0 2010 printf("end process inodes\n"); 2011 #endif 2012 ehandler_operation(old_operation); 2013 } 2014 2015 static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) 2016 { 2017 const struct process_inode_block *ib_a = 2018 (const struct process_inode_block *) a; 2019 const struct process_inode_block *ib_b = 2020 (const struct process_inode_block *) b; 2021 int ret; 2022 2023 ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - 2024 ib_b->inode.i_block[EXT2_IND_BLOCK]); 2025 if (ret == 0) 2026 /* 2027 * We only call process_inodes() for non-extent 2028 * inodes, so it's OK to pass NULL to 2029 * ext2fs_file_acl_block() here. 2030 */ 2031 ret = ext2fs_file_acl_block(0, ext2fs_const_inode(&ib_a->inode)) - 2032 ext2fs_file_acl_block(0, ext2fs_const_inode(&ib_b->inode)); 2033 if (ret == 0) 2034 ret = ib_a->ino - ib_b->ino; 2035 return ret; 2036 } 2037 2038 /* 2039 * Mark an inode as being bad in some what 2040 */ 2041 static void mark_inode_bad(e2fsck_t ctx, ino_t ino) 2042 { 2043 struct problem_context pctx; 2044 2045 if (!ctx->inode_bad_map) { 2046 clear_problem_context(&pctx); 2047 2048 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 2049 _("bad inode map"), EXT2FS_BMAP64_RBTREE, 2050 "inode_bad_map", &ctx->inode_bad_map); 2051 if (pctx.errcode) { 2052 pctx.num = 3; 2053 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 2054 /* Should never get here */ 2055 ctx->flags |= E2F_FLAG_ABORT; 2056 return; 2057 } 2058 } 2059 ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino); 2060 } 2061 2062 static void add_encrypted_dir(e2fsck_t ctx, ino_t ino) 2063 { 2064 struct problem_context pctx; 2065 2066 if (!ctx->encrypted_dirs) { 2067 pctx.errcode = ext2fs_u32_list_create(&ctx->encrypted_dirs, 0); 2068 if (pctx.errcode) 2069 goto error; 2070 } 2071 pctx.errcode = ext2fs_u32_list_add(ctx->encrypted_dirs, ino); 2072 if (pctx.errcode == 0) 2073 return; 2074 error: 2075 fix_problem(ctx, PR_1_ALLOCATE_ENCRYPTED_DIRLIST, &pctx); 2076 /* Should never get here */ 2077 ctx->flags |= E2F_FLAG_ABORT; 2078 } 2079 2080 /* 2081 * This procedure will allocate the inode "bb" (badblock) map table 2082 */ 2083 static void alloc_bb_map(e2fsck_t ctx) 2084 { 2085 struct problem_context pctx; 2086 2087 clear_problem_context(&pctx); 2088 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 2089 _("inode in bad block map"), EXT2FS_BMAP64_RBTREE, 2090 "inode_bb_map", &ctx->inode_bb_map); 2091 if (pctx.errcode) { 2092 pctx.num = 4; 2093 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 2094 /* Should never get here */ 2095 ctx->flags |= E2F_FLAG_ABORT; 2096 return; 2097 } 2098 } 2099 2100 /* 2101 * This procedure will allocate the inode imagic table 2102 */ 2103 static void alloc_imagic_map(e2fsck_t ctx) 2104 { 2105 struct problem_context pctx; 2106 2107 clear_problem_context(&pctx); 2108 pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, 2109 _("imagic inode map"), EXT2FS_BMAP64_RBTREE, 2110 "inode_imagic_map", &ctx->inode_imagic_map); 2111 if (pctx.errcode) { 2112 pctx.num = 5; 2113 fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); 2114 /* Should never get here */ 2115 ctx->flags |= E2F_FLAG_ABORT; 2116 return; 2117 } 2118 } 2119 2120 /* 2121 * Marks a block as in use, setting the dup_map if it's been set 2122 * already. Called by process_block and process_bad_block. 2123 * 2124 * WARNING: Assumes checks have already been done to make sure block 2125 * is valid. This is true in both process_block and process_bad_block. 2126 */ 2127 static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block) 2128 { 2129 struct problem_context pctx; 2130 2131 clear_problem_context(&pctx); 2132 2133 if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) { 2134 if (!ctx->block_dup_map) { 2135 pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, 2136 _("multiply claimed block map"), 2137 EXT2FS_BMAP64_RBTREE, "block_dup_map", 2138 &ctx->block_dup_map); 2139 if (pctx.errcode) { 2140 pctx.num = 3; 2141 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, 2142 &pctx); 2143 /* Should never get here */ 2144 ctx->flags |= E2F_FLAG_ABORT; 2145 return; 2146 } 2147 } 2148 ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block); 2149 } else { 2150 ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, block); 2151 } 2152 } 2153 2154 static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, 2155 unsigned int num) 2156 { 2157 if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num)) 2158 ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num); 2159 else 2160 while (num--) 2161 mark_block_used(ctx, block++); 2162 } 2163 2164 /* 2165 * Adjust the extended attribute block's reference counts at the end 2166 * of pass 1, either by subtracting out references for EA blocks that 2167 * are still referenced in ctx->refcount, or by adding references for 2168 * EA blocks that had extra references as accounted for in 2169 * ctx->refcount_extra. 2170 */ 2171 static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, 2172 char *block_buf, int adjust_sign) 2173 { 2174 struct ext2_ext_attr_header *header; 2175 struct problem_context pctx; 2176 ext2_filsys fs = ctx->fs; 2177 blk64_t blk; 2178 __u32 should_be; 2179 int count; 2180 2181 clear_problem_context(&pctx); 2182 2183 ea_refcount_intr_begin(refcount); 2184 while (1) { 2185 if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) 2186 break; 2187 pctx.blk = blk; 2188 pctx.errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, 2189 pctx.ino); 2190 if (pctx.errcode) { 2191 fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); 2192 return; 2193 } 2194 header = (struct ext2_ext_attr_header *) block_buf; 2195 pctx.blkcount = header->h_refcount; 2196 should_be = header->h_refcount + adjust_sign * count; 2197 pctx.num = should_be; 2198 if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { 2199 header->h_refcount = should_be; 2200 pctx.errcode = ext2fs_write_ext_attr3(fs, blk, 2201 block_buf, 2202 pctx.ino); 2203 if (pctx.errcode) { 2204 fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT, 2205 &pctx); 2206 continue; 2207 } 2208 } 2209 } 2210 } 2211 2212 /* 2213 * Handle processing the extended attribute blocks 2214 */ 2215 static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, 2216 char *block_buf) 2217 { 2218 ext2_filsys fs = ctx->fs; 2219 ext2_ino_t ino = pctx->ino; 2220 struct ext2_inode *inode = pctx->inode; 2221 blk64_t blk; 2222 char * end; 2223 struct ext2_ext_attr_header *header; 2224 struct ext2_ext_attr_entry *entry; 2225 int count; 2226 region_t region = 0; 2227 int failed_csum = 0; 2228 2229 blk = ext2fs_file_acl_block(fs, inode); 2230 if (blk == 0) 2231 return 0; 2232 2233 /* 2234 * If the Extended attribute flag isn't set, then a non-zero 2235 * file acl means that the inode is corrupted. 2236 * 2237 * Or if the extended attribute block is an invalid block, 2238 * then the inode is also corrupted. 2239 */ 2240 if (!ext2fs_has_feature_xattr(fs->super) || 2241 (blk < fs->super->s_first_data_block) || 2242 (blk >= ext2fs_blocks_count(fs->super))) { 2243 mark_inode_bad(ctx, ino); 2244 return 0; 2245 } 2246 2247 /* If ea bitmap hasn't been allocated, create it */ 2248 if (!ctx->block_ea_map) { 2249 pctx->errcode = e2fsck_allocate_block_bitmap(fs, 2250 _("ext attr block map"), 2251 EXT2FS_BMAP64_RBTREE, "block_ea_map", 2252 &ctx->block_ea_map); 2253 if (pctx->errcode) { 2254 pctx->num = 2; 2255 fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); 2256 ctx->flags |= E2F_FLAG_ABORT; 2257 return 0; 2258 } 2259 } 2260 2261 /* Create the EA refcount structure if necessary */ 2262 if (!ctx->refcount) { 2263 pctx->errcode = ea_refcount_create(0, &ctx->refcount); 2264 if (pctx->errcode) { 2265 pctx->num = 1; 2266 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); 2267 ctx->flags |= E2F_FLAG_ABORT; 2268 return 0; 2269 } 2270 } 2271 2272 #if 0 2273 /* Debugging text */ 2274 printf("Inode %u has EA block %u\n", ino, blk); 2275 #endif 2276 2277 /* Have we seen this EA block before? */ 2278 if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) { 2279 if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) 2280 return 1; 2281 /* Ooops, this EA was referenced more than it stated */ 2282 if (!ctx->refcount_extra) { 2283 pctx->errcode = ea_refcount_create(0, 2284 &ctx->refcount_extra); 2285 if (pctx->errcode) { 2286 pctx->num = 2; 2287 fix_problem(ctx, PR_1_ALLOCATE_REFCOUNT, pctx); 2288 ctx->flags |= E2F_FLAG_ABORT; 2289 return 0; 2290 } 2291 } 2292 ea_refcount_increment(ctx->refcount_extra, blk, 0); 2293 return 1; 2294 } 2295 2296 /* 2297 * OK, we haven't seen this EA block yet. So we need to 2298 * validate it 2299 */ 2300 pctx->blk = blk; 2301 pctx->errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, pctx->ino); 2302 if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) { 2303 pctx->errcode = 0; 2304 failed_csum = 1; 2305 } else if (pctx->errcode == EXT2_ET_BAD_EA_HEADER) 2306 pctx->errcode = 0; 2307 2308 if (pctx->errcode && 2309 fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) { 2310 pctx->errcode = 0; 2311 goto clear_extattr; 2312 } 2313 header = (struct ext2_ext_attr_header *) block_buf; 2314 pctx->blk = ext2fs_file_acl_block(fs, inode); 2315 if (((ctx->ext_attr_ver == 1) && 2316 (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || 2317 ((ctx->ext_attr_ver == 2) && 2318 (header->h_magic != EXT2_EXT_ATTR_MAGIC))) { 2319 if (fix_problem(ctx, PR_1_BAD_EA_BLOCK, pctx)) 2320 goto clear_extattr; 2321 } 2322 2323 if (header->h_blocks != 1) { 2324 if (fix_problem(ctx, PR_1_EA_MULTI_BLOCK, pctx)) 2325 goto clear_extattr; 2326 } 2327 2328 if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) 2329 goto clear_extattr; 2330 2331 region = region_create(0, fs->blocksize); 2332 if (!region) { 2333 fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); 2334 ctx->flags |= E2F_FLAG_ABORT; 2335 return 0; 2336 } 2337 if (region_allocate(region, 0, sizeof(struct ext2_ext_attr_header))) { 2338 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 2339 goto clear_extattr; 2340 } 2341 2342 entry = (struct ext2_ext_attr_entry *)(header+1); 2343 end = block_buf + fs->blocksize; 2344 while ((char *)entry < end && *(__u32 *)entry) { 2345 __u32 hash; 2346 2347 if (region_allocate(region, (char *)entry - (char *)header, 2348 EXT2_EXT_ATTR_LEN(entry->e_name_len))) { 2349 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 2350 goto clear_extattr; 2351 break; 2352 } 2353 if ((ctx->ext_attr_ver == 1 && 2354 (entry->e_name_len == 0 || entry->e_name_index != 0)) || 2355 (ctx->ext_attr_ver == 2 && 2356 entry->e_name_index == 0)) { 2357 if (fix_problem(ctx, PR_1_EA_BAD_NAME, pctx)) 2358 goto clear_extattr; 2359 break; 2360 } 2361 if (entry->e_value_block != 0) { 2362 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) 2363 goto clear_extattr; 2364 } 2365 if (entry->e_value_offs + entry->e_value_size > fs->blocksize) { 2366 if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) 2367 goto clear_extattr; 2368 break; 2369 } 2370 if (entry->e_value_size && 2371 region_allocate(region, entry->e_value_offs, 2372 EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { 2373 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 2374 goto clear_extattr; 2375 } 2376 2377 hash = ext2fs_ext_attr_hash_entry(entry, block_buf + 2378 entry->e_value_offs); 2379 2380 if (entry->e_hash != hash) { 2381 pctx->num = entry->e_hash; 2382 if (fix_problem(ctx, PR_1_ATTR_HASH, pctx)) 2383 goto clear_extattr; 2384 entry->e_hash = hash; 2385 } 2386 2387 entry = EXT2_EXT_ATTR_NEXT(entry); 2388 } 2389 if (region_allocate(region, (char *)entry - (char *)header, 4)) { 2390 if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) 2391 goto clear_extattr; 2392 } 2393 region_free(region); 2394 2395 /* 2396 * We only get here if there was no other errors that were fixed. 2397 * If there was a checksum fail, ask to correct it. 2398 */ 2399 if (failed_csum && 2400 fix_problem(ctx, PR_1_EA_BLOCK_ONLY_CSUM_INVALID, pctx)) { 2401 pctx->errcode = ext2fs_write_ext_attr3(fs, blk, block_buf, 2402 pctx->ino); 2403 if (pctx->errcode) 2404 return 0; 2405 } 2406 2407 count = header->h_refcount - 1; 2408 if (count) 2409 ea_refcount_store(ctx->refcount, blk, count); 2410 mark_block_used(ctx, blk); 2411 ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk); 2412 return 1; 2413 2414 clear_extattr: 2415 if (region) 2416 region_free(region); 2417 ext2fs_file_acl_block_set(fs, inode, 0); 2418 e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); 2419 return 0; 2420 } 2421 2422 /* Returns 1 if bad htree, 0 if OK */ 2423 static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, 2424 ext2_ino_t ino, struct ext2_inode *inode, 2425 char *block_buf) 2426 { 2427 struct ext2_dx_root_info *root; 2428 ext2_filsys fs = ctx->fs; 2429 errcode_t retval; 2430 blk64_t blk; 2431 2432 if ((!LINUX_S_ISDIR(inode->i_mode) && 2433 fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || 2434 (!ext2fs_has_feature_dir_index(fs->super) && 2435 fix_problem(ctx, PR_1_HTREE_SET, pctx))) 2436 return 1; 2437 2438 pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk); 2439 2440 if ((pctx->errcode) || 2441 (blk == 0) || 2442 (blk < fs->super->s_first_data_block) || 2443 (blk >= ext2fs_blocks_count(fs->super))) { 2444 if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 2445 return 1; 2446 else 2447 return 0; 2448 } 2449 2450 retval = io_channel_read_blk64(fs->io, blk, 1, block_buf); 2451 if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 2452 return 1; 2453 2454 /* XXX should check that beginning matches a directory */ 2455 root = (struct ext2_dx_root_info *) (block_buf + 24); 2456 2457 if ((root->reserved_zero || root->info_length < 8) && 2458 fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) 2459 return 1; 2460 2461 pctx->num = root->hash_version; 2462 if ((root->hash_version != EXT2_HASH_LEGACY) && 2463 (root->hash_version != EXT2_HASH_HALF_MD4) && 2464 (root->hash_version != EXT2_HASH_TEA) && 2465 fix_problem(ctx, PR_1_HTREE_HASHV, pctx)) 2466 return 1; 2467 2468 if ((root->unused_flags & EXT2_HASH_FLAG_INCOMPAT) && 2469 fix_problem(ctx, PR_1_HTREE_INCOMPAT, pctx)) 2470 return 1; 2471 2472 pctx->num = root->indirect_levels; 2473 if ((root->indirect_levels > 1) && 2474 fix_problem(ctx, PR_1_HTREE_DEPTH, pctx)) 2475 return 1; 2476 2477 return 0; 2478 } 2479 2480 void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, 2481 struct ext2_inode *inode, int restart_flag, 2482 const char *source) 2483 { 2484 inode->i_flags = 0; 2485 inode->i_links_count = 0; 2486 ext2fs_icount_store(ctx->inode_link_info, ino, 0); 2487 inode->i_dtime = ctx->now; 2488 2489 /* 2490 * If a special inode has such rotten block mappings that we 2491 * want to clear the whole inode, be sure to actually zap 2492 * the block maps because i_links_count isn't checked for 2493 * special inodes, and we'll end up right back here the next 2494 * time we run fsck. 2495 */ 2496 if (ino < EXT2_FIRST_INODE(ctx->fs->super)) 2497 memset(inode->i_block, 0, sizeof(inode->i_block)); 2498 2499 ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); 2500 ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); 2501 if (ctx->inode_reg_map) 2502 ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); 2503 if (ctx->inode_bad_map) 2504 ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); 2505 2506 /* 2507 * If the inode was partially accounted for before processing 2508 * was aborted, we need to restart the pass 1 scan. 2509 */ 2510 ctx->flags |= restart_flag; 2511 2512 if (ino == EXT2_BAD_INO) 2513 memset(inode, 0, sizeof(struct ext2_inode)); 2514 2515 e2fsck_write_inode(ctx, ino, inode, source); 2516 } 2517 2518 /* 2519 * Use the multiple-blocks reclamation code to fix alignment problems in 2520 * a bigalloc filesystem. We want a logical cluster to map to *only* one 2521 * physical cluster, and we want the block offsets within that cluster to 2522 * line up. 2523 */ 2524 static int has_unaligned_cluster_map(e2fsck_t ctx, 2525 blk64_t last_pblk, blk64_t last_lblk, 2526 blk64_t pblk, blk64_t lblk) 2527 { 2528 blk64_t cluster_mask; 2529 2530 if (!ctx->fs->cluster_ratio_bits) 2531 return 0; 2532 cluster_mask = EXT2FS_CLUSTER_MASK(ctx->fs); 2533 2534 /* 2535 * If the block in the logical cluster doesn't align with the block in 2536 * the physical cluster... 2537 */ 2538 if ((lblk & cluster_mask) != (pblk & cluster_mask)) 2539 return 1; 2540 2541 /* 2542 * If we cross a physical cluster boundary within a logical cluster... 2543 */ 2544 if (last_pblk && (lblk & cluster_mask) != 0 && 2545 EXT2FS_B2C(ctx->fs, lblk) == EXT2FS_B2C(ctx->fs, last_lblk) && 2546 EXT2FS_B2C(ctx->fs, pblk) != EXT2FS_B2C(ctx->fs, last_pblk)) 2547 return 1; 2548 2549 return 0; 2550 } 2551 2552 static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, 2553 struct process_block_struct *pb, 2554 blk64_t start_block, blk64_t end_block, 2555 blk64_t eof_block, 2556 ext2_extent_handle_t ehandle, 2557 int try_repairs) 2558 { 2559 struct ext2fs_extent extent; 2560 blk64_t blk, last_lblk; 2561 e2_blkcnt_t blockcnt; 2562 unsigned int i; 2563 int is_dir, is_leaf; 2564 problem_t problem; 2565 struct ext2_extent_info info; 2566 int failed_csum = 0; 2567 2568 if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) 2569 failed_csum = 1; 2570 2571 pctx->errcode = ext2fs_extent_get_info(ehandle, &info); 2572 if (pctx->errcode) 2573 return; 2574 if (!(ctx->options & E2F_OPT_FIXES_ONLY) && 2575 !pb->eti.force_rebuild) { 2576 struct extent_tree_level *etl; 2577 2578 etl = pb->eti.ext_info + info.curr_level; 2579 etl->num_extents += info.num_entries; 2580 etl->max_extents += info.max_entries; 2581 /* 2582 * Implementation wart: Splitting extent blocks when appending 2583 * will leave the old block with one free entry. Therefore 2584 * unless the node is totally full, pretend that a non-root 2585 * extent block can hold one fewer entry than it actually does, 2586 * so that we don't repeatedly rebuild the extent tree. 2587 */ 2588 if (info.curr_level && info.num_entries < info.max_entries) 2589 etl->max_extents--; 2590 } 2591 2592 pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB, 2593 &extent); 2594 while ((pctx->errcode == 0 || 2595 pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) && 2596 info.num_entries-- > 0) { 2597 is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF; 2598 is_dir = LINUX_S_ISDIR(pctx->inode->i_mode); 2599 last_lblk = extent.e_lblk + extent.e_len - 1; 2600 2601 problem = 0; 2602 pctx->blk = extent.e_pblk; 2603 pctx->blk2 = extent.e_lblk; 2604 pctx->num = extent.e_len; 2605 pctx->blkcount = extent.e_lblk + extent.e_len; 2606 2607 if (extent.e_pblk == 0 || 2608 extent.e_pblk < ctx->fs->super->s_first_data_block || 2609 extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super)) 2610 problem = PR_1_EXTENT_BAD_START_BLK; 2611 else if (extent.e_lblk < start_block) 2612 problem = PR_1_OUT_OF_ORDER_EXTENTS; 2613 else if ((end_block && last_lblk > end_block) && 2614 (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT && 2615 last_lblk > eof_block))) 2616 problem = PR_1_EXTENT_END_OUT_OF_BOUNDS; 2617 else if (is_leaf && extent.e_len == 0) 2618 problem = PR_1_EXTENT_LENGTH_ZERO; 2619 else if (is_leaf && 2620 (extent.e_pblk + extent.e_len) > 2621 ext2fs_blocks_count(ctx->fs->super)) 2622 problem = PR_1_EXTENT_ENDS_BEYOND; 2623 else if (is_leaf && is_dir && 2624 ((extent.e_lblk + extent.e_len) > 2625 (1U << (21 - ctx->fs->super->s_log_block_size)))) 2626 problem = PR_1_TOOBIG_DIR; 2627 2628 if (is_leaf && problem == 0 && extent.e_len > 0 && 2629 region_allocate(pb->region, extent.e_lblk, extent.e_len)) 2630 problem = PR_1_EXTENT_COLLISION; 2631 2632 /* 2633 * Uninitialized blocks in a directory? Clear the flag and 2634 * we'll interpret the blocks later. 2635 */ 2636 if (try_repairs && is_dir && problem == 0 && 2637 (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) && 2638 fix_problem(ctx, PR_1_UNINIT_DBLOCK, pctx)) { 2639 extent.e_flags &= ~EXT2_EXTENT_FLAGS_UNINIT; 2640 pb->inode_modified = 1; 2641 pctx->errcode = ext2fs_extent_replace(ehandle, 0, 2642 &extent); 2643 if (pctx->errcode) 2644 return; 2645 failed_csum = 0; 2646 } 2647 2648 if (try_repairs && problem) { 2649 report_problem: 2650 if (fix_problem(ctx, problem, pctx)) { 2651 if (ctx->invalid_bitmaps) { 2652 /* 2653 * If fsck knows the bitmaps are bad, 2654 * skip to the next extent and 2655 * try to clear this extent again 2656 * after fixing the bitmaps, by 2657 * restarting fsck. 2658 */ 2659 pctx->errcode = ext2fs_extent_get( 2660 ehandle, 2661 EXT2_EXTENT_NEXT_SIB, 2662 &extent); 2663 ctx->flags |= E2F_FLAG_RESTART_LATER; 2664 if (pctx->errcode == 2665 EXT2_ET_NO_CURRENT_NODE) { 2666 pctx->errcode = 0; 2667 break; 2668 } 2669 continue; 2670 } 2671 e2fsck_read_bitmaps(ctx); 2672 pb->inode_modified = 1; 2673 pctx->errcode = 2674 ext2fs_extent_delete(ehandle, 0); 2675 if (pctx->errcode) { 2676 pctx->str = "ext2fs_extent_delete"; 2677 return; 2678 } 2679 pctx->errcode = ext2fs_extent_fix_parents(ehandle); 2680 if (pctx->errcode && 2681 pctx->errcode != EXT2_ET_NO_CURRENT_NODE) { 2682 pctx->str = "ext2fs_extent_fix_parents"; 2683 return; 2684 } 2685 pctx->errcode = ext2fs_extent_get(ehandle, 2686 EXT2_EXTENT_CURRENT, 2687 &extent); 2688 if (pctx->errcode == EXT2_ET_NO_CURRENT_NODE) { 2689 pctx->errcode = 0; 2690 break; 2691 } 2692 failed_csum = 0; 2693 continue; 2694 } 2695 goto next; 2696 } 2697 2698 if (!is_leaf) { 2699 blk64_t lblk = extent.e_lblk; 2700 int next_try_repairs = 1; 2701 2702 blk = extent.e_pblk; 2703 2704 /* 2705 * If this lower extent block collides with critical 2706 * metadata, don't try to repair the damage. Pass 1b 2707 * will reallocate the block; then we can try again. 2708 */ 2709 if (pb->ino != EXT2_RESIZE_INO && 2710 ext2fs_test_block_bitmap2(ctx->block_metadata_map, 2711 extent.e_pblk)) { 2712 next_try_repairs = 0; 2713 pctx->blk = blk; 2714 fix_problem(ctx, 2715 PR_1_CRITICAL_METADATA_COLLISION, 2716 pctx); 2717 ctx->flags |= E2F_FLAG_RESTART_LATER; 2718 } 2719 pctx->errcode = ext2fs_extent_get(ehandle, 2720 EXT2_EXTENT_DOWN, &extent); 2721 if (pctx->errcode && 2722 pctx->errcode != EXT2_ET_EXTENT_CSUM_INVALID) { 2723 pctx->str = "EXT2_EXTENT_DOWN"; 2724 problem = PR_1_EXTENT_HEADER_INVALID; 2725 if (!next_try_repairs) 2726 return; 2727 if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD) 2728 goto report_problem; 2729 return; 2730 } 2731 /* The next extent should match this index's logical start */ 2732 if (extent.e_lblk != lblk) { 2733 struct ext2_extent_info e_info; 2734 2735 ext2fs_extent_get_info(ehandle, &e_info); 2736 pctx->blk = lblk; 2737 pctx->blk2 = extent.e_lblk; 2738 pctx->num = e_info.curr_level - 1; 2739 problem = PR_1_EXTENT_INDEX_START_INVALID; 2740 if (fix_problem(ctx, problem, pctx)) { 2741 pb->inode_modified = 1; 2742 pctx->errcode = 2743 ext2fs_extent_fix_parents(ehandle); 2744 if (pctx->errcode) { 2745 pctx->str = "ext2fs_extent_fix_parents"; 2746 return; 2747 } 2748 } 2749 } 2750 scan_extent_node(ctx, pctx, pb, extent.e_lblk, 2751 last_lblk, eof_block, ehandle, 2752 next_try_repairs); 2753 if (pctx->errcode) 2754 return; 2755 pctx->errcode = ext2fs_extent_get(ehandle, 2756 EXT2_EXTENT_UP, &extent); 2757 if (pctx->errcode) { 2758 pctx->str = "EXT2_EXTENT_UP"; 2759 return; 2760 } 2761 mark_block_used(ctx, blk); 2762 pb->num_blocks++; 2763 goto next; 2764 } 2765 2766 if ((pb->previous_block != 0) && 2767 (pb->previous_block+1 != extent.e_pblk)) { 2768 if (ctx->options & E2F_OPT_FRAGCHECK) { 2769 char type = '?'; 2770 2771 if (pb->is_dir) 2772 type = 'd'; 2773 else if (pb->is_reg) 2774 type = 'f'; 2775 2776 printf(("%6lu(%c): expecting %6lu " 2777 "actual extent " 2778 "phys %6lu log %lu len %lu\n"), 2779 (unsigned long) pctx->ino, type, 2780 (unsigned long) pb->previous_block+1, 2781 (unsigned long) extent.e_pblk, 2782 (unsigned long) extent.e_lblk, 2783 (unsigned long) extent.e_len); 2784 } 2785 pb->fragmented = 1; 2786 } 2787 /* 2788 * If we notice a gap in the logical block mappings of an 2789 * extent-mapped directory, offer to close the hole by 2790 * moving the logical block down, otherwise we'll go mad in 2791 * pass 3 allocating empty directory blocks to fill the hole. 2792 */ 2793 if (try_repairs && is_dir && 2794 pb->last_block + 1 < extent.e_lblk) { 2795 blk64_t new_lblk; 2796 2797 new_lblk = pb->last_block + 1; 2798 if (EXT2FS_CLUSTER_RATIO(ctx->fs) > 1) 2799 new_lblk = ((new_lblk + 2800 EXT2FS_CLUSTER_RATIO(ctx->fs) - 1) & 2801 ~EXT2FS_CLUSTER_MASK(ctx->fs)) | 2802 (extent.e_pblk & 2803 EXT2FS_CLUSTER_MASK(ctx->fs)); 2804 pctx->blk = extent.e_lblk; 2805 pctx->blk2 = new_lblk; 2806 if (fix_problem(ctx, PR_1_COLLAPSE_DBLOCK, pctx)) { 2807 extent.e_lblk = new_lblk; 2808 pb->inode_modified = 1; 2809 pctx->errcode = ext2fs_extent_replace(ehandle, 2810 0, &extent); 2811 if (pctx->errcode) { 2812 pctx->errcode = 0; 2813 goto alloc_later; 2814 } 2815 pctx->errcode = ext2fs_extent_fix_parents(ehandle); 2816 if (pctx->errcode) 2817 goto failed_add_dir_block; 2818 pctx->errcode = ext2fs_extent_goto(ehandle, 2819 extent.e_lblk); 2820 if (pctx->errcode) 2821 goto failed_add_dir_block; 2822 last_lblk = extent.e_lblk + extent.e_len - 1; 2823 failed_csum = 0; 2824 } 2825 } 2826 alloc_later: 2827 while (is_dir && (++pb->last_db_block < 2828 (e2_blkcnt_t) extent.e_lblk)) { 2829 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, 2830 pb->ino, 0, 2831 pb->last_db_block); 2832 if (pctx->errcode) { 2833 pctx->blk = 0; 2834 pctx->num = pb->last_db_block; 2835 goto failed_add_dir_block; 2836 } 2837 } 2838 if (!ctx->fs->cluster_ratio_bits) { 2839 mark_blocks_used(ctx, extent.e_pblk, extent.e_len); 2840 pb->num_blocks += extent.e_len; 2841 } 2842 for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0; 2843 i < extent.e_len; 2844 blk++, blockcnt++, i++) { 2845 if (ctx->fs->cluster_ratio_bits && 2846 !(pb->previous_block && 2847 (EXT2FS_B2C(ctx->fs, blk) == 2848 EXT2FS_B2C(ctx->fs, pb->previous_block)) && 2849 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == 2850 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { 2851 mark_block_used(ctx, blk); 2852 pb->num_blocks++; 2853 } 2854 if (has_unaligned_cluster_map(ctx, pb->previous_block, 2855 pb->last_block, blk, 2856 blockcnt)) { 2857 pctx->blk = blockcnt; 2858 pctx->blk2 = blk; 2859 fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx); 2860 mark_block_used(ctx, blk); 2861 mark_block_used(ctx, blk); 2862 } 2863 pb->last_block = blockcnt; 2864 pb->previous_block = blk; 2865 2866 if (is_dir) { 2867 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt); 2868 if (pctx->errcode) { 2869 pctx->blk = blk; 2870 pctx->num = blockcnt; 2871 failed_add_dir_block: 2872 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 2873 /* Should never get here */ 2874 ctx->flags |= E2F_FLAG_ABORT; 2875 return; 2876 } 2877 } 2878 } 2879 if (is_dir && extent.e_len > 0) 2880 pb->last_db_block = blockcnt - 1; 2881 pb->previous_block = extent.e_pblk + extent.e_len - 1; 2882 start_block = pb->last_block = last_lblk; 2883 if (is_leaf && !is_dir && 2884 !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)) 2885 pb->last_init_lblock = last_lblk; 2886 next: 2887 pctx->errcode = ext2fs_extent_get(ehandle, 2888 EXT2_EXTENT_NEXT_SIB, 2889 &extent); 2890 } 2891 2892 /* Failed csum but passes checks? Ask to fix checksum. */ 2893 if (failed_csum && 2894 fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) { 2895 pb->inode_modified = 1; 2896 pctx->errcode = ext2fs_extent_replace(ehandle, 0, &extent); 2897 if (pctx->errcode) 2898 return; 2899 } 2900 2901 if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT) 2902 pctx->errcode = 0; 2903 } 2904 2905 static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, 2906 struct process_block_struct *pb) 2907 { 2908 struct ext2_extent_info info; 2909 struct ext2_inode *inode = pctx->inode; 2910 ext2_extent_handle_t ehandle; 2911 ext2_filsys fs = ctx->fs; 2912 ext2_ino_t ino = pctx->ino; 2913 errcode_t retval; 2914 blk64_t eof_lblk; 2915 struct ext3_extent_header *eh; 2916 2917 /* Check for a proper extent header... */ 2918 eh = (struct ext3_extent_header *) &inode->i_block[0]; 2919 retval = ext2fs_extent_header_verify(eh, sizeof(inode->i_block)); 2920 if (retval) { 2921 if (fix_problem(ctx, PR_1_MISSING_EXTENT_HEADER, pctx)) 2922 e2fsck_clear_inode(ctx, ino, inode, 0, 2923 "check_blocks_extents"); 2924 pctx->errcode = 0; 2925 return; 2926 } 2927 2928 /* ...since this function doesn't fail if i_block is zeroed. */ 2929 pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle); 2930 if (pctx->errcode) { 2931 if (fix_problem(ctx, PR_1_READ_EXTENT, pctx)) 2932 e2fsck_clear_inode(ctx, ino, inode, 0, 2933 "check_blocks_extents"); 2934 pctx->errcode = 0; 2935 return; 2936 } 2937 2938 retval = ext2fs_extent_get_info(ehandle, &info); 2939 if (retval == 0) { 2940 int max_depth = info.max_depth; 2941 2942 if (max_depth >= MAX_EXTENT_DEPTH_COUNT) 2943 max_depth = MAX_EXTENT_DEPTH_COUNT-1; 2944 ctx->extent_depth_count[max_depth]++; 2945 } 2946 2947 /* Check maximum extent depth */ 2948 pctx->blk = info.max_depth; 2949 pctx->blk2 = ext2fs_max_extent_depth(ehandle); 2950 if (pctx->blk2 < pctx->blk && 2951 fix_problem(ctx, PR_1_EXTENT_BAD_MAX_DEPTH, pctx)) 2952 pb->eti.force_rebuild = 1; 2953 2954 /* Can we collect extent tree level stats? */ 2955 pctx->blk = MAX_EXTENT_DEPTH_COUNT; 2956 if (pctx->blk2 > pctx->blk) 2957 fix_problem(ctx, PR_1E_MAX_EXTENT_TREE_DEPTH, pctx); 2958 memset(pb->eti.ext_info, 0, sizeof(pb->eti.ext_info)); 2959 pb->eti.ino = pb->ino; 2960 2961 pb->region = region_create(0, info.max_lblk); 2962 if (!pb->region) { 2963 ext2fs_extent_free(ehandle); 2964 fix_problem(ctx, PR_1_EXTENT_ALLOC_REGION_ABORT, pctx); 2965 ctx->flags |= E2F_FLAG_ABORT; 2966 return; 2967 } 2968 2969 eof_lblk = ((EXT2_I_SIZE(inode) + fs->blocksize - 1) >> 2970 EXT2_BLOCK_SIZE_BITS(fs->super)) - 1; 2971 scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle, 1); 2972 if (pctx->errcode && 2973 fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) { 2974 pb->num_blocks = 0; 2975 inode->i_blocks = 0; 2976 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, 2977 "check_blocks_extents"); 2978 pctx->errcode = 0; 2979 } 2980 region_free(pb->region); 2981 pb->region = NULL; 2982 ext2fs_extent_free(ehandle); 2983 2984 /* Rebuild unless it's a dir and we're rehashing it */ 2985 if (LINUX_S_ISDIR(inode->i_mode) && 2986 e2fsck_dir_will_be_rehashed(ctx, ino)) 2987 return; 2988 2989 if (ctx->options & E2F_OPT_CONVERT_BMAP) 2990 e2fsck_rebuild_extents_later(ctx, ino); 2991 else 2992 e2fsck_should_rebuild_extents(ctx, pctx, &pb->eti, &info); 2993 } 2994 2995 /* 2996 * In fact we don't need to check blocks for an inode with inline data 2997 * because this inode doesn't have any blocks. In this function all 2998 * we need to do is add this inode into dblist when it is a directory. 2999 */ 3000 static void check_blocks_inline_data(e2fsck_t ctx, struct problem_context *pctx, 3001 struct process_block_struct *pb) 3002 { 3003 int flags; 3004 size_t inline_data_size = 0; 3005 3006 if (!pb->is_dir) { 3007 pctx->errcode = 0; 3008 return; 3009 } 3010 3011 /* Process the dirents in i_block[] as the "first" block. */ 3012 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 0); 3013 if (pctx->errcode) 3014 goto err; 3015 3016 /* Process the dirents in the EA as a "second" block. */ 3017 flags = ctx->fs->flags; 3018 ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; 3019 pctx->errcode = ext2fs_inline_data_size(ctx->fs, pb->ino, 3020 &inline_data_size); 3021 ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | 3022 (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); 3023 if (pctx->errcode) { 3024 pctx->errcode = 0; 3025 return; 3026 } 3027 3028 if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE) 3029 return; 3030 3031 pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 1); 3032 if (pctx->errcode) 3033 goto err; 3034 3035 return; 3036 err: 3037 pctx->blk = 0; 3038 pctx->num = 0; 3039 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 3040 ctx->flags |= E2F_FLAG_ABORT; 3041 } 3042 3043 /* 3044 * This subroutine is called on each inode to account for all of the 3045 * blocks used by that inode. 3046 */ 3047 static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 3048 char *block_buf) 3049 { 3050 ext2_filsys fs = ctx->fs; 3051 struct process_block_struct pb; 3052 ext2_ino_t ino = pctx->ino; 3053 struct ext2_inode *inode = pctx->inode; 3054 unsigned bad_size = 0; 3055 int dirty_inode = 0; 3056 int extent_fs; 3057 int inlinedata_fs; 3058 __u64 size; 3059 3060 pb.ino = ino; 3061 pb.num_blocks = 0; 3062 pb.last_block = ~0; 3063 pb.last_init_lblock = -1; 3064 pb.last_db_block = -1; 3065 pb.num_illegal_blocks = 0; 3066 pb.suppress = 0; pb.clear = 0; 3067 pb.fragmented = 0; 3068 pb.compressed = 0; 3069 pb.previous_block = 0; 3070 pb.is_dir = LINUX_S_ISDIR(inode->i_mode); 3071 pb.is_reg = LINUX_S_ISREG(inode->i_mode); 3072 pb.max_blocks = 1 << (31 - fs->super->s_log_block_size); 3073 pb.inode = inode; 3074 pb.pctx = pctx; 3075 pb.ctx = ctx; 3076 pb.inode_modified = 0; 3077 pb.eti.force_rebuild = 0; 3078 pctx->ino = ino; 3079 pctx->errcode = 0; 3080 3081 extent_fs = ext2fs_has_feature_extents(ctx->fs->super); 3082 inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); 3083 3084 if (check_ext_attr(ctx, pctx, block_buf)) { 3085 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 3086 goto out; 3087 pb.num_blocks++; 3088 } 3089 3090 if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) 3091 check_blocks_inline_data(ctx, pctx, &pb); 3092 else if (ext2fs_inode_has_valid_blocks2(fs, inode)) { 3093 if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) 3094 check_blocks_extents(ctx, pctx, &pb); 3095 else { 3096 int flags; 3097 /* 3098 * If we've modified the inode, write it out before 3099 * iterate() tries to use it. 3100 */ 3101 if (dirty_inode) { 3102 e2fsck_write_inode(ctx, ino, inode, 3103 "check_blocks"); 3104 dirty_inode = 0; 3105 } 3106 flags = fs->flags; 3107 fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; 3108 pctx->errcode = ext2fs_block_iterate3(fs, ino, 3109 pb.is_dir ? BLOCK_FLAG_HOLE : 0, 3110 block_buf, process_block, &pb); 3111 /* 3112 * We do not have uninitialized extents in non extent 3113 * files. 3114 */ 3115 pb.last_init_lblock = pb.last_block; 3116 /* 3117 * If iterate() changed a block mapping, we have to 3118 * re-read the inode. If we decide to clear the 3119 * inode after clearing some stuff, we'll re-write the 3120 * bad mappings into the inode! 3121 */ 3122 if (pb.inode_modified) 3123 e2fsck_read_inode(ctx, ino, inode, 3124 "check_blocks"); 3125 fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | 3126 (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); 3127 3128 if (ctx->options & E2F_OPT_CONVERT_BMAP) { 3129 #ifdef DEBUG 3130 printf("bmap rebuild ino=%d\n", ino); 3131 #endif 3132 if (!LINUX_S_ISDIR(inode->i_mode) || 3133 !e2fsck_dir_will_be_rehashed(ctx, ino)) 3134 e2fsck_rebuild_extents_later(ctx, ino); 3135 } 3136 } 3137 } 3138 end_problem_latch(ctx, PR_LATCH_BLOCK); 3139 end_problem_latch(ctx, PR_LATCH_TOOBIG); 3140 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 3141 goto out; 3142 if (pctx->errcode) 3143 fix_problem(ctx, PR_1_BLOCK_ITERATE, pctx); 3144 3145 if (pb.fragmented && pb.num_blocks < fs->super->s_blocks_per_group) { 3146 if (LINUX_S_ISDIR(inode->i_mode)) 3147 ctx->fs_fragmented_dir++; 3148 else 3149 ctx->fs_fragmented++; 3150 } 3151 3152 if (pb.clear) { 3153 e2fsck_clear_inode(ctx, ino, inode, E2F_FLAG_RESTART, 3154 "check_blocks"); 3155 return; 3156 } 3157 3158 if (inode->i_flags & EXT2_INDEX_FL) { 3159 if (handle_htree(ctx, pctx, ino, inode, block_buf)) { 3160 inode->i_flags &= ~EXT2_INDEX_FL; 3161 dirty_inode++; 3162 } else { 3163 e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); 3164 } 3165 } 3166 3167 if (!pb.num_blocks && pb.is_dir && 3168 !(inode->i_flags & EXT4_INLINE_DATA_FL)) { 3169 if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { 3170 e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); 3171 ctx->fs_directory_count--; 3172 return; 3173 } 3174 } 3175 3176 if (ino != quota_type2inum(PRJQUOTA, fs->super) && 3177 (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super))) { 3178 quota_data_add(ctx->qctx, (struct ext2_inode_large *) inode, 3179 ino, pb.num_blocks * fs->blocksize); 3180 quota_data_inodes(ctx->qctx, (struct ext2_inode_large *) inode, 3181 ino, +1); 3182 } 3183 3184 if (!ext2fs_has_feature_huge_file(fs->super) || 3185 !(inode->i_flags & EXT4_HUGE_FILE_FL)) 3186 pb.num_blocks *= (fs->blocksize / 512); 3187 pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs); 3188 #if 0 3189 printf("inode %u, i_size = %u, last_block = %llu, i_blocks=%llu, num_blocks = %llu\n", 3190 ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode), 3191 pb.num_blocks); 3192 #endif 3193 if (pb.is_dir) { 3194 unsigned nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); 3195 if (inode->i_flags & EXT4_INLINE_DATA_FL) { 3196 int flags; 3197 size_t sz = 0; 3198 errcode_t err; 3199 3200 flags = ctx->fs->flags; 3201 ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; 3202 err = ext2fs_inline_data_size(ctx->fs, pctx->ino, 3203 &sz); 3204 ctx->fs->flags = (flags & 3205 EXT2_FLAG_IGNORE_CSUM_ERRORS) | 3206 (ctx->fs->flags & 3207 ~EXT2_FLAG_IGNORE_CSUM_ERRORS); 3208 if (err || sz != inode->i_size) { 3209 bad_size = 7; 3210 pctx->num = sz; 3211 } 3212 } else if (inode->i_size & (fs->blocksize - 1)) 3213 bad_size = 5; 3214 else if (nblock > (pb.last_block + 1)) 3215 bad_size = 1; 3216 else if (nblock < (pb.last_block + 1)) { 3217 if (((pb.last_block + 1) - nblock) > 3218 fs->super->s_prealloc_dir_blocks) 3219 bad_size = 2; 3220 } 3221 } else { 3222 e2_blkcnt_t blkpg = ctx->blocks_per_page; 3223 3224 size = EXT2_I_SIZE(inode); 3225 if ((pb.last_init_lblock >= 0) && 3226 /* allow allocated blocks to end of PAGE_SIZE */ 3227 (size < (__u64)pb.last_init_lblock * fs->blocksize) && 3228 (pb.last_init_lblock / blkpg * blkpg != pb.last_init_lblock || 3229 size < (__u64)(pb.last_init_lblock & ~(blkpg-1)) * 3230 fs->blocksize)) 3231 bad_size = 3; 3232 else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && 3233 size > ext2_max_sizes[fs->super->s_log_block_size]) 3234 /* too big for a direct/indirect-mapped file */ 3235 bad_size = 4; 3236 else if ((extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && 3237 size > 3238 ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1)) 3239 /* too big for an extent-based file - 32bit ee_block */ 3240 bad_size = 6; 3241 } 3242 /* i_size for symlinks is checked elsewhere */ 3243 if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { 3244 /* Did inline_data set pctx->num earlier? */ 3245 if (bad_size != 7) 3246 pctx->num = (pb.last_block + 1) * fs->blocksize; 3247 pctx->group = bad_size; 3248 if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { 3249 if (LINUX_S_ISDIR(inode->i_mode)) 3250 pctx->num &= 0xFFFFFFFFULL; 3251 ext2fs_inode_size_set(fs, inode, pctx->num); 3252 if (EXT2_I_SIZE(inode) == 0 && 3253 (inode->i_flags & EXT4_INLINE_DATA_FL)) { 3254 memset(inode->i_block, 0, 3255 sizeof(inode->i_block)); 3256 inode->i_flags &= ~EXT4_INLINE_DATA_FL; 3257 } 3258 dirty_inode++; 3259 } 3260 pctx->num = 0; 3261 } 3262 if (LINUX_S_ISREG(inode->i_mode) && 3263 ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode))) 3264 ctx->large_files++; 3265 if ((fs->super->s_creator_os != EXT2_OS_HURD) && 3266 ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) || 3267 (ext2fs_has_feature_huge_file(fs->super) && 3268 (inode->i_flags & EXT4_HUGE_FILE_FL) && 3269 (inode->osd2.linux2.l_i_blocks_hi != 0)))) { 3270 pctx->num = pb.num_blocks; 3271 if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { 3272 inode->i_blocks = pb.num_blocks; 3273 inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32; 3274 dirty_inode++; 3275 } 3276 pctx->num = 0; 3277 } 3278 3279 /* 3280 * The kernel gets mad if we ask it to allocate bigalloc clusters to 3281 * a block mapped file, so rebuild it as an extent file. We can skip 3282 * symlinks because they're never rewritten. 3283 */ 3284 if (ext2fs_has_feature_bigalloc(fs->super) && 3285 (LINUX_S_ISREG(inode->i_mode) || LINUX_S_ISDIR(inode->i_mode)) && 3286 ext2fs_inode_data_blocks2(fs, inode) > 0 && 3287 (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INO(fs->super)) && 3288 !(inode->i_flags & (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL)) && 3289 fix_problem(ctx, PR_1_NO_BIGALLOC_BLOCKMAP_FILES, pctx)) { 3290 pctx->errcode = e2fsck_rebuild_extents_later(ctx, ino); 3291 if (pctx->errcode) 3292 goto out; 3293 } 3294 3295 if (ctx->dirs_to_hash && pb.is_dir && 3296 !(ctx->lost_and_found && ctx->lost_and_found == ino) && 3297 !(inode->i_flags & EXT2_INDEX_FL) && 3298 ((inode->i_size / fs->blocksize) >= 3)) 3299 e2fsck_rehash_dir_later(ctx, ino); 3300 3301 out: 3302 if (dirty_inode) 3303 e2fsck_write_inode(ctx, ino, inode, "check_blocks"); 3304 } 3305 3306 #if 0 3307 /* 3308 * Helper function called by process block when an illegal block is 3309 * found. It returns a description about why the block is illegal 3310 */ 3311 static char *describe_illegal_block(ext2_filsys fs, blk64_t block) 3312 { 3313 blk64_t super; 3314 int i; 3315 static char problem[80]; 3316 3317 super = fs->super->s_first_data_block; 3318 strcpy(problem, "PROGRAMMING ERROR: Unknown reason for illegal block"); 3319 if (block < super) { 3320 sprintf(problem, "< FIRSTBLOCK (%u)", super); 3321 return(problem); 3322 } else if (block >= ext2fs_blocks_count(fs->super)) { 3323 sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super)); 3324 return(problem); 3325 } 3326 for (i = 0; i < fs->group_desc_count; i++) { 3327 if (block == super) { 3328 sprintf(problem, "is the superblock in group %d", i); 3329 break; 3330 } 3331 if (block > super && 3332 block <= (super + fs->desc_blocks)) { 3333 sprintf(problem, "is in the group descriptors " 3334 "of group %d", i); 3335 break; 3336 } 3337 if (block == ext2fs_block_bitmap_loc(fs, i)) { 3338 sprintf(problem, "is the block bitmap of group %d", i); 3339 break; 3340 } 3341 if (block == ext2fs_inode_bitmap_loc(fs, i)) { 3342 sprintf(problem, "is the inode bitmap of group %d", i); 3343 break; 3344 } 3345 if (block >= ext2fs_inode_table_loc(fs, i) && 3346 (block < ext2fs_inode_table_loc(fs, i) 3347 + fs->inode_blocks_per_group)) { 3348 sprintf(problem, "is in the inode table of group %d", 3349 i); 3350 break; 3351 } 3352 super += fs->super->s_blocks_per_group; 3353 } 3354 return(problem); 3355 } 3356 #endif 3357 3358 /* 3359 * This is a helper function for check_blocks(). 3360 */ 3361 static int process_block(ext2_filsys fs, 3362 blk64_t *block_nr, 3363 e2_blkcnt_t blockcnt, 3364 blk64_t ref_block EXT2FS_ATTR((unused)), 3365 int ref_offset EXT2FS_ATTR((unused)), 3366 void *priv_data) 3367 { 3368 struct process_block_struct *p; 3369 struct problem_context *pctx; 3370 blk64_t blk = *block_nr; 3371 int ret_code = 0; 3372 problem_t problem = 0; 3373 e2fsck_t ctx; 3374 3375 p = (struct process_block_struct *) priv_data; 3376 pctx = p->pctx; 3377 ctx = p->ctx; 3378 3379 /* 3380 * For a directory, add logical block zero for processing even if it's 3381 * not mapped or we'll be perennially stuck with broken "." and ".." 3382 * entries. 3383 */ 3384 if (p->is_dir && blockcnt == 0 && blk == 0) { 3385 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 0, 0); 3386 if (pctx->errcode) { 3387 pctx->blk = blk; 3388 pctx->num = blockcnt; 3389 goto failed_add_dir_block; 3390 } 3391 p->last_db_block++; 3392 } 3393 3394 if (blk == 0) 3395 return 0; 3396 3397 #if 0 3398 printf("Process_block, inode %lu, block %u, #%d\n", p->ino, blk, 3399 blockcnt); 3400 #endif 3401 3402 /* 3403 * Simplistic fragmentation check. We merely require that the 3404 * file be contiguous. (Which can never be true for really 3405 * big files that are greater than a block group.) 3406 */ 3407 if (p->previous_block && p->ino != EXT2_RESIZE_INO) { 3408 if (p->previous_block+1 != blk) { 3409 if (ctx->options & E2F_OPT_FRAGCHECK) { 3410 char type = '?'; 3411 3412 if (p->is_dir) 3413 type = 'd'; 3414 else if (p->is_reg) 3415 type = 'f'; 3416 3417 printf(_("%6lu(%c): expecting %6lu " 3418 "got phys %6lu (blkcnt %lld)\n"), 3419 (unsigned long) pctx->ino, type, 3420 (unsigned long) p->previous_block+1, 3421 (unsigned long) blk, 3422 blockcnt); 3423 } 3424 p->fragmented = 1; 3425 } 3426 } 3427 3428 if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) 3429 problem = PR_1_TOOBIG_DIR; 3430 if (p->is_reg && p->num_blocks+1 >= p->max_blocks) 3431 problem = PR_1_TOOBIG_REG; 3432 if (!p->is_dir && !p->is_reg && blockcnt > 0) 3433 problem = PR_1_TOOBIG_SYMLINK; 3434 3435 if (blk < fs->super->s_first_data_block || 3436 blk >= ext2fs_blocks_count(fs->super)) 3437 problem = PR_1_ILLEGAL_BLOCK_NUM; 3438 3439 /* 3440 * If this IND/DIND/TIND block is squatting atop some critical metadata 3441 * (group descriptors, superblock, bitmap, inode table), any write to 3442 * "fix" mapping problems will destroy the metadata. We'll let pass 1b 3443 * fix that and restart fsck. 3444 */ 3445 if (blockcnt < 0 && 3446 p->ino != EXT2_RESIZE_INO && 3447 ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) { 3448 pctx->blk = blk; 3449 fix_problem(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx); 3450 ctx->flags |= E2F_FLAG_RESTART_LATER; 3451 } 3452 3453 if (problem) { 3454 p->num_illegal_blocks++; 3455 /* 3456 * A bit of subterfuge here -- we're trying to fix a block 3457 * mapping, but the IND/DIND/TIND block could have collided 3458 * with some critical metadata. So, fix the in-core mapping so 3459 * iterate won't go insane, but return 0 instead of 3460 * BLOCK_CHANGED so that it won't write the remapping out to 3461 * our multiply linked block. 3462 * 3463 * Even if we previously determined that an *IND block 3464 * conflicts with critical metadata, we must still try to 3465 * iterate the *IND block as if it is an *IND block to find and 3466 * mark the blocks it points to. Better to be overly cautious 3467 * with the used_blocks map so that we don't move the *IND 3468 * block to a block that's really in use! 3469 */ 3470 if (p->ino != EXT2_RESIZE_INO && 3471 ref_block != 0 && 3472 ext2fs_test_block_bitmap2(ctx->block_metadata_map, 3473 ref_block)) { 3474 *block_nr = 0; 3475 return 0; 3476 } 3477 if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { 3478 if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { 3479 p->clear = 1; 3480 return BLOCK_ABORT; 3481 } 3482 if (fix_problem(ctx, PR_1_SUPPRESS_MESSAGES, pctx)) { 3483 p->suppress = 1; 3484 set_latch_flags(PR_LATCH_BLOCK, 3485 PRL_SUPPRESS, 0); 3486 } 3487 } 3488 pctx->blk = blk; 3489 pctx->blkcount = blockcnt; 3490 if (fix_problem(ctx, problem, pctx)) { 3491 blk = *block_nr = 0; 3492 ret_code = BLOCK_CHANGED; 3493 p->inode_modified = 1; 3494 /* 3495 * If the directory block is too big and is beyond the 3496 * end of the FS, don't bother trying to add it for 3497 * processing -- the kernel would never have created a 3498 * directory this large, and we risk an ENOMEM abort. 3499 * In any case, the toobig handler for extent-based 3500 * directories also doesn't feed toobig blocks to 3501 * pass 2. 3502 */ 3503 if (problem == PR_1_TOOBIG_DIR) 3504 return ret_code; 3505 goto mark_dir; 3506 } else 3507 return 0; 3508 } 3509 3510 if (p->ino == EXT2_RESIZE_INO) { 3511 /* 3512 * The resize inode has already be sanity checked 3513 * during pass #0 (the superblock checks). All we 3514 * have to do is mark the double indirect block as 3515 * being in use; all of the other blocks are handled 3516 * by mark_table_blocks()). 3517 */ 3518 if (blockcnt == BLOCK_COUNT_DIND) 3519 mark_block_used(ctx, blk); 3520 p->num_blocks++; 3521 } else if (!(ctx->fs->cluster_ratio_bits && 3522 p->previous_block && 3523 (EXT2FS_B2C(ctx->fs, blk) == 3524 EXT2FS_B2C(ctx->fs, p->previous_block)) && 3525 (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == 3526 ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { 3527 mark_block_used(ctx, blk); 3528 p->num_blocks++; 3529 } else if (has_unaligned_cluster_map(ctx, p->previous_block, 3530 p->last_block, blk, blockcnt)) { 3531 pctx->blk = blockcnt; 3532 pctx->blk2 = blk; 3533 fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx); 3534 mark_block_used(ctx, blk); 3535 mark_block_used(ctx, blk); 3536 } 3537 if (blockcnt >= 0) 3538 p->last_block = blockcnt; 3539 p->previous_block = blk; 3540 mark_dir: 3541 if (p->is_dir && (blockcnt >= 0)) { 3542 while (++p->last_db_block < blockcnt) { 3543 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, 3544 p->ino, 0, 3545 p->last_db_block); 3546 if (pctx->errcode) { 3547 pctx->blk = 0; 3548 pctx->num = p->last_db_block; 3549 goto failed_add_dir_block; 3550 } 3551 } 3552 pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 3553 blk, blockcnt); 3554 if (pctx->errcode) { 3555 pctx->blk = blk; 3556 pctx->num = blockcnt; 3557 failed_add_dir_block: 3558 fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); 3559 /* Should never get here */ 3560 ctx->flags |= E2F_FLAG_ABORT; 3561 return BLOCK_ABORT; 3562 } 3563 } 3564 return ret_code; 3565 } 3566 3567 static int process_bad_block(ext2_filsys fs, 3568 blk64_t *block_nr, 3569 e2_blkcnt_t blockcnt, 3570 blk64_t ref_block EXT2FS_ATTR((unused)), 3571 int ref_offset EXT2FS_ATTR((unused)), 3572 void *priv_data) 3573 { 3574 struct process_block_struct *p; 3575 blk64_t blk = *block_nr; 3576 blk64_t first_block; 3577 dgrp_t i; 3578 struct problem_context *pctx; 3579 e2fsck_t ctx; 3580 3581 if (!blk) 3582 return 0; 3583 3584 p = (struct process_block_struct *) priv_data; 3585 ctx = p->ctx; 3586 pctx = p->pctx; 3587 3588 pctx->ino = EXT2_BAD_INO; 3589 pctx->blk = blk; 3590 pctx->blkcount = blockcnt; 3591 3592 if ((blk < fs->super->s_first_data_block) || 3593 (blk >= ext2fs_blocks_count(fs->super))) { 3594 if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) { 3595 *block_nr = 0; 3596 return BLOCK_CHANGED; 3597 } else 3598 return 0; 3599 } 3600 3601 if (blockcnt < 0) { 3602 if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) { 3603 p->bbcheck = 1; 3604 if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) { 3605 *block_nr = 0; 3606 return BLOCK_CHANGED; 3607 } 3608 } else if (ext2fs_test_block_bitmap2(ctx->block_found_map, 3609 blk)) { 3610 p->bbcheck = 1; 3611 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, 3612 pctx)) { 3613 *block_nr = 0; 3614 return BLOCK_CHANGED; 3615 } 3616 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 3617 return BLOCK_ABORT; 3618 } else 3619 mark_block_used(ctx, blk); 3620 return 0; 3621 } 3622 #if 0 3623 printf ("DEBUG: Marking %u as bad.\n", blk); 3624 #endif 3625 ctx->fs_badblocks_count++; 3626 /* 3627 * If the block is not used, then mark it as used and return. 3628 * If it is already marked as found, this must mean that 3629 * there's an overlap between the filesystem table blocks 3630 * (bitmaps and inode table) and the bad block list. 3631 */ 3632 if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) { 3633 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 3634 return 0; 3635 } 3636 /* 3637 * Try to find the where the filesystem block was used... 3638 */ 3639 first_block = fs->super->s_first_data_block; 3640 3641 for (i = 0; i < fs->group_desc_count; i++ ) { 3642 pctx->group = i; 3643 pctx->blk = blk; 3644 if (!ext2fs_bg_has_super(fs, i)) 3645 goto skip_super; 3646 if (blk == first_block) { 3647 if (i == 0) { 3648 if (fix_problem(ctx, 3649 PR_1_BAD_PRIMARY_SUPERBLOCK, 3650 pctx)) { 3651 *block_nr = 0; 3652 return BLOCK_CHANGED; 3653 } 3654 return 0; 3655 } 3656 fix_problem(ctx, PR_1_BAD_SUPERBLOCK, pctx); 3657 return 0; 3658 } 3659 if ((blk > first_block) && 3660 (blk <= first_block + fs->desc_blocks)) { 3661 if (i == 0) { 3662 pctx->blk = *block_nr; 3663 if (fix_problem(ctx, 3664 PR_1_BAD_PRIMARY_GROUP_DESCRIPTOR, pctx)) { 3665 *block_nr = 0; 3666 return BLOCK_CHANGED; 3667 } 3668 return 0; 3669 } 3670 fix_problem(ctx, PR_1_BAD_GROUP_DESCRIPTORS, pctx); 3671 return 0; 3672 } 3673 skip_super: 3674 if (blk == ext2fs_block_bitmap_loc(fs, i)) { 3675 if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { 3676 ctx->invalid_block_bitmap_flag[i]++; 3677 ctx->invalid_bitmaps++; 3678 } 3679 return 0; 3680 } 3681 if (blk == ext2fs_inode_bitmap_loc(fs, i)) { 3682 if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { 3683 ctx->invalid_inode_bitmap_flag[i]++; 3684 ctx->invalid_bitmaps++; 3685 } 3686 return 0; 3687 } 3688 if ((blk >= ext2fs_inode_table_loc(fs, i)) && 3689 (blk < (ext2fs_inode_table_loc(fs, i) + 3690 fs->inode_blocks_per_group))) { 3691 /* 3692 * If there are bad blocks in the inode table, 3693 * the inode scan code will try to do 3694 * something reasonable automatically. 3695 */ 3696 return 0; 3697 } 3698 first_block += fs->super->s_blocks_per_group; 3699 } 3700 /* 3701 * If we've gotten to this point, then the only 3702 * possibility is that the bad block inode meta data 3703 * is using a bad block. 3704 */ 3705 if ((blk == p->inode->i_block[EXT2_IND_BLOCK]) || 3706 (blk == p->inode->i_block[EXT2_DIND_BLOCK]) || 3707 (blk == p->inode->i_block[EXT2_TIND_BLOCK])) { 3708 p->bbcheck = 1; 3709 if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, pctx)) { 3710 *block_nr = 0; 3711 return BLOCK_CHANGED; 3712 } 3713 if (ctx->flags & E2F_FLAG_SIGNAL_MASK) 3714 return BLOCK_ABORT; 3715 return 0; 3716 } 3717 3718 pctx->group = -1; 3719 3720 /* Warn user that the block wasn't claimed */ 3721 fix_problem(ctx, PR_1_PROGERR_CLAIMED_BLOCK, pctx); 3722 3723 return 0; 3724 } 3725 3726 static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group, 3727 const char *name, int num, blk64_t *new_block) 3728 { 3729 ext2_filsys fs = ctx->fs; 3730 dgrp_t last_grp; 3731 blk64_t old_block = *new_block; 3732 blk64_t last_block; 3733 dgrp_t flexbg; 3734 unsigned flexbg_size; 3735 int i, is_flexbg; 3736 char *buf; 3737 struct problem_context pctx; 3738 3739 clear_problem_context(&pctx); 3740 3741 pctx.group = group; 3742 pctx.blk = old_block; 3743 pctx.str = name; 3744 3745 /* 3746 * For flex_bg filesystems, first try to allocate the metadata 3747 * within the flex_bg, and if that fails then try finding the 3748 * space anywhere in the filesystem. 3749 */ 3750 is_flexbg = ext2fs_has_feature_flex_bg(fs->super); 3751 if (is_flexbg) { 3752 flexbg_size = 1 << fs->super->s_log_groups_per_flex; 3753 flexbg = group / flexbg_size; 3754 first_block = ext2fs_group_first_block2(fs, 3755 flexbg_size * flexbg); 3756 last_grp = group | (flexbg_size - 1); 3757 if (last_grp >= fs->group_desc_count) 3758 last_grp = fs->group_desc_count - 1; 3759 last_block = ext2fs_group_last_block2(fs, last_grp); 3760 } else 3761 last_block = ext2fs_group_last_block2(fs, group); 3762 pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block, 3763 num, ctx->block_found_map, 3764 new_block); 3765 if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL)) 3766 pctx.errcode = ext2fs_get_free_blocks2(fs, 3767 fs->super->s_first_data_block, 3768 ext2fs_blocks_count(fs->super), 3769 num, ctx->block_found_map, new_block); 3770 if (pctx.errcode) { 3771 pctx.num = num; 3772 fix_problem(ctx, PR_1_RELOC_BLOCK_ALLOCATE, &pctx); 3773 ext2fs_unmark_valid(fs); 3774 ctx->flags |= E2F_FLAG_ABORT; 3775 return; 3776 } 3777 pctx.errcode = ext2fs_get_mem(fs->blocksize, &buf); 3778 if (pctx.errcode) { 3779 fix_problem(ctx, PR_1_RELOC_MEMORY_ALLOCATE, &pctx); 3780 ext2fs_unmark_valid(fs); 3781 ctx->flags |= E2F_FLAG_ABORT; 3782 return; 3783 } 3784 ext2fs_mark_super_dirty(fs); 3785 fs->flags &= ~EXT2_FLAG_MASTER_SB_ONLY; 3786 pctx.blk2 = *new_block; 3787 fix_problem(ctx, (old_block ? PR_1_RELOC_FROM_TO : 3788 PR_1_RELOC_TO), &pctx); 3789 pctx.blk2 = 0; 3790 for (i = 0; i < num; i++) { 3791 pctx.blk = i; 3792 ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i); 3793 if (old_block) { 3794 pctx.errcode = io_channel_read_blk64(fs->io, 3795 old_block + i, 1, buf); 3796 if (pctx.errcode) 3797 fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); 3798 pctx.blk = (*new_block) + i; 3799 pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, 3800 1, buf); 3801 } else { 3802 pctx.blk = (*new_block) + i; 3803 pctx.errcode = ext2fs_zero_blocks2(fs, pctx.blk, 1, 3804 NULL, NULL); 3805 } 3806 3807 if (pctx.errcode) 3808 fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); 3809 } 3810 ext2fs_free_mem(&buf); 3811 } 3812 3813 /* 3814 * This routine gets called at the end of pass 1 if bad blocks are 3815 * detected in the superblock, group descriptors, inode_bitmaps, or 3816 * block bitmaps. At this point, all of the blocks have been mapped 3817 * out, so we can try to allocate new block(s) to replace the bad 3818 * blocks. 3819 */ 3820 static void handle_fs_bad_blocks(e2fsck_t ctx) 3821 { 3822 ext2_filsys fs = ctx->fs; 3823 dgrp_t i; 3824 blk64_t first_block; 3825 blk64_t new_blk; 3826 3827 for (i = 0; i < fs->group_desc_count; i++) { 3828 first_block = ext2fs_group_first_block2(fs, i); 3829 3830 if (ctx->invalid_block_bitmap_flag[i]) { 3831 new_blk = ext2fs_block_bitmap_loc(fs, i); 3832 new_table_block(ctx, first_block, i, _("block bitmap"), 3833 1, &new_blk); 3834 ext2fs_block_bitmap_loc_set(fs, i, new_blk); 3835 } 3836 if (ctx->invalid_inode_bitmap_flag[i]) { 3837 new_blk = ext2fs_inode_bitmap_loc(fs, i); 3838 new_table_block(ctx, first_block, i, _("inode bitmap"), 3839 1, &new_blk); 3840 ext2fs_inode_bitmap_loc_set(fs, i, new_blk); 3841 } 3842 if (ctx->invalid_inode_table_flag[i]) { 3843 new_blk = ext2fs_inode_table_loc(fs, i); 3844 new_table_block(ctx, first_block, i, _("inode table"), 3845 fs->inode_blocks_per_group, 3846 &new_blk); 3847 ext2fs_inode_table_loc_set(fs, i, new_blk); 3848 ctx->flags |= E2F_FLAG_RESTART; 3849 } 3850 } 3851 ctx->invalid_bitmaps = 0; 3852 } 3853 3854 /* 3855 * This routine marks all blocks which are used by the superblock, 3856 * group descriptors, inode bitmaps, and block bitmaps. 3857 */ 3858 static void mark_table_blocks(e2fsck_t ctx) 3859 { 3860 ext2_filsys fs = ctx->fs; 3861 blk64_t b; 3862 dgrp_t i; 3863 unsigned int j; 3864 struct problem_context pctx; 3865 3866 clear_problem_context(&pctx); 3867 3868 for (i = 0; i < fs->group_desc_count; i++) { 3869 pctx.group = i; 3870 3871 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); 3872 ext2fs_reserve_super_and_bgd(fs, i, ctx->block_metadata_map); 3873 3874 /* 3875 * Mark the blocks used for the inode table 3876 */ 3877 if (ext2fs_inode_table_loc(fs, i)) { 3878 for (j = 0, b = ext2fs_inode_table_loc(fs, i); 3879 j < fs->inode_blocks_per_group; 3880 j++, b++) { 3881 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 3882 b)) { 3883 pctx.blk = b; 3884 if (!ctx->invalid_inode_table_flag[i] && 3885 fix_problem(ctx, 3886 PR_1_ITABLE_CONFLICT, &pctx)) { 3887 ctx->invalid_inode_table_flag[i]++; 3888 ctx->invalid_bitmaps++; 3889 } 3890 } else { 3891 ext2fs_mark_block_bitmap2( 3892 ctx->block_found_map, b); 3893 ext2fs_mark_block_bitmap2( 3894 ctx->block_metadata_map, b); 3895 } 3896 } 3897 } 3898 3899 /* 3900 * Mark block used for the block bitmap 3901 */ 3902 if (ext2fs_block_bitmap_loc(fs, i)) { 3903 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 3904 ext2fs_block_bitmap_loc(fs, i))) { 3905 pctx.blk = ext2fs_block_bitmap_loc(fs, i); 3906 if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { 3907 ctx->invalid_block_bitmap_flag[i]++; 3908 ctx->invalid_bitmaps++; 3909 } 3910 } else { 3911 ext2fs_mark_block_bitmap2(ctx->block_found_map, 3912 ext2fs_block_bitmap_loc(fs, i)); 3913 ext2fs_mark_block_bitmap2(ctx->block_metadata_map, 3914 ext2fs_block_bitmap_loc(fs, i)); 3915 } 3916 } 3917 /* 3918 * Mark block used for the inode bitmap 3919 */ 3920 if (ext2fs_inode_bitmap_loc(fs, i)) { 3921 if (ext2fs_test_block_bitmap2(ctx->block_found_map, 3922 ext2fs_inode_bitmap_loc(fs, i))) { 3923 pctx.blk = ext2fs_inode_bitmap_loc(fs, i); 3924 if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { 3925 ctx->invalid_inode_bitmap_flag[i]++; 3926 ctx->invalid_bitmaps++; 3927 } 3928 } else { 3929 ext2fs_mark_block_bitmap2(ctx->block_metadata_map, 3930 ext2fs_inode_bitmap_loc(fs, i)); 3931 ext2fs_mark_block_bitmap2(ctx->block_found_map, 3932 ext2fs_inode_bitmap_loc(fs, i)); 3933 } 3934 } 3935 } 3936 } 3937 3938 /* 3939 * Thes subroutines short circuits ext2fs_get_blocks and 3940 * ext2fs_check_directory; we use them since we already have the inode 3941 * structure, so there's no point in letting the ext2fs library read 3942 * the inode again. 3943 */ 3944 static errcode_t pass1_get_blocks(ext2_filsys fs, ext2_ino_t ino, 3945 blk_t *blocks) 3946 { 3947 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 3948 int i; 3949 3950 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 3951 return EXT2_ET_CALLBACK_NOTHANDLED; 3952 3953 for (i=0; i < EXT2_N_BLOCKS; i++) 3954 blocks[i] = ctx->stashed_inode->i_block[i]; 3955 return 0; 3956 } 3957 3958 static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, 3959 struct ext2_inode *inode) 3960 { 3961 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 3962 3963 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 3964 return EXT2_ET_CALLBACK_NOTHANDLED; 3965 *inode = *ctx->stashed_inode; 3966 return 0; 3967 } 3968 3969 static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, 3970 struct ext2_inode *inode) 3971 { 3972 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 3973 3974 if ((ino == ctx->stashed_ino) && ctx->stashed_inode && 3975 (inode != ctx->stashed_inode)) 3976 *ctx->stashed_inode = *inode; 3977 return EXT2_ET_CALLBACK_NOTHANDLED; 3978 } 3979 3980 static errcode_t pass1_check_directory(ext2_filsys fs, ext2_ino_t ino) 3981 { 3982 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 3983 3984 if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) 3985 return EXT2_ET_CALLBACK_NOTHANDLED; 3986 3987 if (!LINUX_S_ISDIR(ctx->stashed_inode->i_mode)) 3988 return EXT2_ET_NO_DIRECTORY; 3989 return 0; 3990 } 3991 3992 static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, 3993 blk64_t *ret) 3994 { 3995 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 3996 errcode_t retval; 3997 blk64_t new_block; 3998 3999 if (ctx->block_found_map) { 4000 retval = ext2fs_new_block2(fs, goal, ctx->block_found_map, 4001 &new_block); 4002 if (retval) 4003 return retval; 4004 if (fs->block_map) { 4005 ext2fs_mark_block_bitmap2(fs->block_map, new_block); 4006 ext2fs_mark_bb_dirty(fs); 4007 } 4008 } else { 4009 if (!fs->block_map) { 4010 retval = ext2fs_read_block_bitmap(fs); 4011 if (retval) 4012 return retval; 4013 } 4014 4015 retval = ext2fs_new_block2(fs, goal, fs->block_map, &new_block); 4016 if (retval) 4017 return retval; 4018 } 4019 4020 *ret = new_block; 4021 return (0); 4022 } 4023 4024 static errcode_t e2fsck_new_range(ext2_filsys fs, int flags, blk64_t goal, 4025 blk64_t len, blk64_t *pblk, blk64_t *plen) 4026 { 4027 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 4028 errcode_t retval; 4029 4030 if (ctx->block_found_map) 4031 return ext2fs_new_range(fs, flags, goal, len, 4032 ctx->block_found_map, pblk, plen); 4033 4034 if (!fs->block_map) { 4035 retval = ext2fs_read_block_bitmap(fs); 4036 if (retval) 4037 return retval; 4038 } 4039 4040 return ext2fs_new_range(fs, flags, goal, len, fs->block_map, 4041 pblk, plen); 4042 } 4043 4044 static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) 4045 { 4046 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 4047 4048 /* Never free a critical metadata block */ 4049 if (ctx->block_found_map && 4050 ctx->block_metadata_map && 4051 inuse < 0 && 4052 ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) 4053 return; 4054 4055 if (ctx->block_found_map) { 4056 if (inuse > 0) 4057 ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); 4058 else 4059 ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk); 4060 } 4061 } 4062 4063 static void e2fsck_block_alloc_stats_range(ext2_filsys fs, blk64_t blk, 4064 blk_t num, int inuse) 4065 { 4066 e2fsck_t ctx = (e2fsck_t) fs->priv_data; 4067 4068 /* Never free a critical metadata block */ 4069 if (ctx->block_found_map && 4070 ctx->block_metadata_map && 4071 inuse < 0 && 4072 ext2fs_test_block_bitmap_range2(ctx->block_metadata_map, blk, num)) 4073 return; 4074 4075 if (ctx->block_found_map) { 4076 if (inuse > 0) 4077 ext2fs_mark_block_bitmap_range2(ctx->block_found_map, 4078 blk, num); 4079 else 4080 ext2fs_unmark_block_bitmap_range2(ctx->block_found_map, 4081 blk, num); 4082 } 4083 } 4084 4085 void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) 4086 { 4087 ext2_filsys fs = ctx->fs; 4088 4089 if (use_shortcuts) { 4090 fs->get_blocks = pass1_get_blocks; 4091 fs->check_directory = pass1_check_directory; 4092 fs->read_inode = pass1_read_inode; 4093 fs->write_inode = pass1_write_inode; 4094 ctx->stashed_ino = 0; 4095 } else { 4096 fs->get_blocks = 0; 4097 fs->check_directory = 0; 4098 fs->read_inode = 0; 4099 fs->write_inode = 0; 4100 } 4101 } 4102 4103 void e2fsck_intercept_block_allocations(e2fsck_t ctx) 4104 { 4105 ext2fs_set_alloc_block_callback(ctx->fs, e2fsck_get_alloc_block, 0); 4106 ext2fs_set_block_alloc_stats_callback(ctx->fs, 4107 e2fsck_block_alloc_stats, 0); 4108 ext2fs_set_new_range_callback(ctx->fs, e2fsck_new_range, NULL); 4109 ext2fs_set_block_alloc_stats_range_callback(ctx->fs, 4110 e2fsck_block_alloc_stats_range, NULL); 4111 } 4112
