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