X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Fpass1.c;h=799158ea059f13d8b1e6d47e21ee5751151abedc;hb=d37026ea07a6abcb0bbff8d97e58b47e8089df8e;hp=7554f4ee8703abdc23c4874913d814d80e04468b;hpb=bc82f39437922f50d5f2846656458e50d65d2dc4;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index 7554f4e..799158e 100644 --- a/e2fsck/pass1.c +++ b/e2fsck/pass1.c @@ -56,6 +56,8 @@ #define _INLINE_ inline #endif +#undef DEBUG + static int process_block(ext2_filsys fs, blk64_t *blocknr, e2_blkcnt_t blockcnt, blk64_t ref_blk, int ref_offset, void *priv_data); @@ -68,6 +70,7 @@ static void mark_table_blocks(e2fsck_t ctx); static void alloc_bb_map(e2fsck_t ctx); static void alloc_imagic_map(e2fsck_t ctx); static void mark_inode_bad(e2fsck_t ctx, ino_t ino); +static void add_encrypted_dir(e2fsck_t ctx, ino_t ino); static void handle_fs_bad_blocks(e2fsck_t ctx); static void process_inodes(e2fsck_t ctx, char *block_buf); static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b); @@ -80,7 +83,8 @@ static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, struct process_block_struct { ext2_ino_t ino; unsigned is_dir:1, is_reg:1, clear:1, suppress:1, - fragmented:1, compressed:1, bbcheck:1; + fragmented:1, compressed:1, bbcheck:1, + inode_modified:1; blk64_t num_blocks; blk64_t max_blocks; e2_blkcnt_t last_block; @@ -92,11 +96,13 @@ struct process_block_struct { struct problem_context *pctx; ext2fs_block_bitmap fs_meta_blocks; e2fsck_t ctx; + region_t region; + struct extent_tree_info eti; }; struct process_inode_block { ext2_ino_t ino; - struct ext2_inode inode; + struct ext2_inode_large inode; }; struct scan_callback_struct { @@ -181,6 +187,8 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, return 0; if (inode->i_flags & EXT4_EXTENTS_FL) { + if (inode->i_flags & EXT4_INLINE_DATA_FL) + return 0; if (inode->i_size > fs->blocksize) return 0; if (ext2fs_extent_open2(fs, ino, inode, &handle)) @@ -202,8 +210,21 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, return i; } + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + size_t inline_size; + + if (ext2fs_inline_data_size(fs, ino, &inline_size)) + return 0; + if (inode->i_size != inline_size) + return 0; + + return 1; + } + blocks = ext2fs_inode_data_blocks2(fs, inode); if (blocks) { + if (inode->i_flags & EXT4_INLINE_DATA_FL) + return 0; if ((inode->i_size >= fs->blocksize) || (blocks != fs->blocksize >> 9) || (inode->i_block[0] < fs->super->s_first_data_block) || @@ -217,9 +238,34 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, if (io_channel_read_blk64(fs->io, inode->i_block[0], 1, buf)) return 0; - len = strnlen(buf, fs->blocksize); + if (inode->i_flags & EXT4_ENCRYPT_FL) { + len = ext2fs_le32_to_cpu(*((__u32 *)buf)) + 4; + } else { + len = strnlen(buf, fs->blocksize); + } if (len == fs->blocksize) return 0; + } else if (inode->i_flags & EXT4_INLINE_DATA_FL) { + char *inline_buf = NULL; + size_t inline_sz = 0; + + if (ext2fs_inline_data_size(fs, ino, &inline_sz)) + return 0; + if (inode->i_size != inline_sz) + return 0; + if (ext2fs_get_mem(inline_sz + 1, &inline_buf)) + return 0; + i = 0; + if (ext2fs_inline_data_get(fs, ino, inode, inline_buf, NULL)) + goto exit_inline; + inline_buf[inline_sz] = 0; + len = strnlen(inline_buf, inline_sz); + if (len != inline_sz) + goto exit_inline; + i = 1; +exit_inline: + ext2fs_free_mem(&inline_buf); + return i; } else { if (inode->i_size >= sizeof(inode->i_block)) return 0; @@ -229,11 +275,30 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, return 0; } if (len != inode->i_size) - return 0; + if ((inode->i_flags & EXT4_ENCRYPT_FL) == 0) + return 0; return 1; } /* + * If the extents or inlinedata flags are set on the inode, offer to clear 'em. + */ +#define BAD_SPECIAL_FLAGS (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL) +static void check_extents_inlinedata(e2fsck_t ctx, + struct problem_context *pctx) +{ + if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) + return; + + if (!fix_problem(ctx, PR_1_SPECIAL_EXTENTS_IDATA, pctx)) + return; + + pctx->inode->i_flags &= ~BAD_SPECIAL_FLAGS; + e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); +} +#undef BAD_SPECIAL_FLAGS + +/* * If the immutable (or append-only) flag is set on the inode, offer * to clear it. */ @@ -264,8 +329,7 @@ static void check_size(e2fsck_t ctx, struct problem_context *pctx) if (!fix_problem(ctx, PR_1_SET_NONZSIZE, pctx)) return; - inode->i_size = 0; - inode->i_size_high = 0; + ext2fs_inode_size_set(ctx->fs, inode, 0); e2fsck_write_inode(ctx, pctx->ino, pctx->inode, "pass1"); } @@ -274,15 +338,17 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) struct ext2_super_block *sb = ctx->fs->super; struct ext2_inode_large *inode; struct ext2_ext_attr_entry *entry; - char *start; + char *start, *header; unsigned int storage_size, remain; problem_t problem = 0; + region_t region = 0; inode = (struct ext2_inode_large *) pctx->inode; storage_size = EXT2_INODE_SIZE(ctx->fs->super) - EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize; - start = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + - inode->i_extra_isize + sizeof(__u32); + header = ((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + + inode->i_extra_isize; + start = header + sizeof(__u32); entry = (struct ext2_ext_attr_entry *) start; /* scan all entry's headers first */ @@ -290,9 +356,28 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) /* take finish entry 0UL into account */ remain = storage_size - sizeof(__u32); - while (!EXT2_EXT_IS_LAST_ENTRY(entry)) { + region = region_create(0, storage_size); + if (!region) { + fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); + problem = 0; + ctx->flags |= E2F_FLAG_ABORT; + return; + } + if (region_allocate(region, 0, sizeof(__u32))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } + + while (remain >= sizeof(struct ext2_ext_attr_entry) && + !EXT2_EXT_IS_LAST_ENTRY(entry)) { __u32 hash; + if (region_allocate(region, (char *)entry - (char *)header, + EXT2_EXT_ATTR_LEN(entry->e_name_len))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } + /* header eats this space */ remain -= sizeof(struct ext2_ext_attr_entry); @@ -320,6 +405,13 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) goto fix; } + if (entry->e_value_size && + region_allocate(region, sizeof(__u32) + entry->e_value_offs, + EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } + hash = ext2fs_ext_attr_hash_entry(entry, start + entry->e_value_offs); @@ -334,7 +426,15 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) entry = EXT2_EXT_ATTR_NEXT(entry); } + + if (region_allocate(region, (char *)entry - (char *)header, + sizeof(__u32))) { + problem = PR_1_INODE_EA_ALLOC_COLLISION; + goto fix; + } fix: + if (region) + region_free(region); /* * it seems like a corruption. it's very unlikely we could repair * EA(s) in automatic fashion -bzzz @@ -343,11 +443,26 @@ fix: return; /* simply remove all possible EA(s) */ - *((__u32 *)start) = 0UL; + *((__u32 *)header) = 0UL; e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, EXT2_INODE_SIZE(sb), "pass1"); } +static int check_inode_extra_negative_epoch(__u32 xtime, __u32 extra) { + return (xtime & (1 << 31)) != 0 && + (extra & EXT4_EPOCH_MASK) == EXT4_EPOCH_MASK; +} + +#define CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, xtime) \ + check_inode_extra_negative_epoch(inode->i_##xtime, \ + inode->i_##xtime##_extra) + +/* When today's date is earlier than 2242, we assume that atimes, + * ctimes, crtimes, and mtimes with years in the range 2310..2378 are + * actually pre-1970 dates mis-encoded. + */ +#define EXT4_EXTRA_NEGATIVE_DATE_CUTOFF 2 * (1LL << 32) + static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) { struct ext2_super_block *sb = ctx->fs->super; @@ -382,12 +497,42 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) return; } + /* check if there is no place for an EA header */ + if (inode->i_extra_isize >= max - sizeof(__u32)) + return; + eamagic = (__u32 *) (((char *) inode) + EXT2_GOOD_OLD_INODE_SIZE + inode->i_extra_isize); if (*eamagic == EXT2_EXT_ATTR_MAGIC) { /* it seems inode has an extended attribute(s) in body */ check_ea_in_inode(ctx, pctx); } + + /* + * If the inode's extended atime (ctime, crtime, mtime) is stored in + * the old, invalid format, repair it. + */ + if (sizeof(time_t) > 4 && ctx->now < EXT4_EXTRA_NEGATIVE_DATE_CUTOFF && + (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, ctime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime) || + CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime))) { + + if (!fix_problem(ctx, PR_1_EA_TIME_OUT_OF_RANGE, pctx)) + return; + + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, atime)) + inode->i_atime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, ctime)) + inode->i_ctime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, crtime)) + inode->i_crtime_extra &= ~EXT4_EPOCH_MASK; + if (CHECK_INODE_EXTRA_NEGATIVE_EPOCH(inode, mtime)) + inode->i_mtime_extra &= ~EXT4_EPOCH_MASK; + e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, + EXT2_INODE_SIZE(sb), "pass1"); + } + } /* @@ -407,6 +552,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, blk64_t blk; unsigned int i, rec_len, not_device = 0; int extent_fs; + int inlinedata_fs; /* * If the mode looks OK, we believe it. If the first block in @@ -434,11 +580,50 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, * For extent mapped files, we don't do any sanity checking: * just try to get the phys block of logical block 0 and run * with it. + * + * For inline data files, we just try to get the size of inline + * data. If it's true, we will treat it as a directory. */ - extent_fs = (ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_EXTENTS); - if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { + extent_fs = ext2fs_has_feature_extents(ctx->fs->super); + inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); + if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) { + size_t size; + __u32 dotdot; + unsigned int rec_len2; + struct ext2_dir_entry de; + + if (ext2fs_inline_data_size(ctx->fs, pctx->ino, &size)) + return; + /* + * If the size isn't a multiple of 4, it's probably not a + * directory?? + */ + if (size & 3) + return; + /* + * If the first 10 bytes don't look like a directory entry, + * it's probably not a directory. + */ + memcpy(&dotdot, inode->i_block, sizeof(dotdot)); + memcpy(&de, ((char *)inode->i_block) + EXT4_INLINE_DATA_DOTDOT_SIZE, + EXT2_DIR_REC_LEN(0)); + dotdot = ext2fs_le32_to_cpu(dotdot); + de.inode = ext2fs_le32_to_cpu(de.inode); + de.rec_len = ext2fs_le16_to_cpu(de.rec_len); + ext2fs_get_rec_len(ctx->fs, &de, &rec_len2); + if (dotdot >= ctx->fs->super->s_inodes_count || + (dotdot < EXT2_FIRST_INO(ctx->fs->super) && + dotdot != EXT2_ROOT_INO) || + de.inode >= ctx->fs->super->s_inodes_count || + (de.inode < EXT2_FIRST_INO(ctx->fs->super) && + de.inode != 0) || + rec_len2 > EXT4_MIN_INLINE_DATA_SIZE - + EXT4_INLINE_DATA_DOTDOT_SIZE) + return; + /* device files never have a "system.data" entry */ + goto isdir; + } else if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { /* extent mapped */ if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0, &blk)) @@ -501,6 +686,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, (rec_len % 4)) return; +isdir: if (fix_problem(ctx, PR_1_TREAT_AS_DIRECTORY, pctx)) { inode->i_mode = (inode->i_mode & 07777) | LINUX_S_IFDIR; e2fsck_write_inode_full(ctx, pctx->ino, inode, @@ -551,6 +737,7 @@ static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, * Reread inode. If we don't see checksum error, then this inode * has been fixed elsewhere. */ + ctx->stashed_ino = 0; retval = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode, sizeof(inode)); if (retval && retval != EXT2_ET_INODE_CSUM_INVALID) @@ -568,9 +755,278 @@ static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode, sizeof(inode)); + return retval; +} + +static void reserve_block_for_root_repair(e2fsck_t ctx) +{ + blk64_t blk = 0; + errcode_t err; + ext2_filsys fs = ctx->fs; + + ctx->root_repair_block = 0; + if (ext2fs_test_inode_bitmap2(ctx->inode_used_map, EXT2_ROOT_INO)) + return; + + err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); + if (err) + return; + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + ctx->root_repair_block = blk; +} + +static void reserve_block_for_lnf_repair(e2fsck_t ctx) +{ + blk64_t blk = 0; + errcode_t err; + ext2_filsys fs = ctx->fs; + static const char name[] = "lost+found"; + ext2_ino_t ino; + + ctx->lnf_repair_block = 0; + if (!ext2fs_lookup(fs, EXT2_ROOT_INO, name, sizeof(name)-1, 0, &ino)) + return; + + err = ext2fs_new_block2(fs, 0, ctx->block_found_map, &blk); + if (err) + return; + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + ctx->lnf_repair_block = blk; +} + +static errcode_t get_inline_data_ea_size(ext2_filsys fs, ext2_ino_t ino, + size_t *sz) +{ + void *p; + struct ext2_xattr_handle *handle; + errcode_t retval; + + retval = ext2fs_xattrs_open(fs, ino, &handle); if (retval) return retval; + retval = ext2fs_xattrs_read(handle); + if (retval) + goto err; + + retval = ext2fs_xattr_get(handle, "system.data", &p, sz); + if (retval) + goto err; + ext2fs_free_mem(&p); +err: + (void) ext2fs_xattrs_close(&handle); + return retval; +} + +static void finish_processing_inode(e2fsck_t ctx, ext2_ino_t ino, + struct problem_context *pctx, + int failed_csum) +{ + if (!failed_csum) + return; + + /* + * If the inode failed the checksum and the user didn't + * clear the inode, test the checksum again -- if it still + * fails, ask the user if the checksum should be corrected. + */ + pctx->errcode = recheck_bad_inode_checksum(ctx->fs, ino, ctx, pctx); + if (pctx->errcode) + ctx->flags |= E2F_FLAG_ABORT; +} +#define FINISH_INODE_LOOP(ctx, ino, pctx, failed_csum) \ + do { \ + finish_processing_inode((ctx), (ino), (pctx), (failed_csum)); \ + if ((ctx)->flags & E2F_FLAG_ABORT) \ + return; \ + } while (0) + +static int could_be_block_map(ext2_filsys fs, struct ext2_inode *inode) +{ + __u32 x; + int i; + + for (i = 0; i < EXT2_N_BLOCKS; i++) { + x = inode->i_block[i]; +#ifdef WORDS_BIGENDIAN + x = ext2fs_swab32(x); +#endif + if (x >= ext2fs_blocks_count(fs->super)) + return 0; + } + + return 1; +} + +/* + * Figure out what to do with an inode that has both extents and inline data + * inode flags set. Returns -1 if we decide to erase the inode, 0 otherwise. + */ +static int fix_inline_data_extents_file(e2fsck_t ctx, + ext2_ino_t ino, + struct ext2_inode *inode, + int inode_size, + struct problem_context *pctx) +{ + size_t max_inline_ea_size; + ext2_filsys fs = ctx->fs; + int dirty = 0; + + /* Both feature flags not set? Just run the regular checks */ + if (!ext2fs_has_feature_extents(fs->super) && + !ext2fs_has_feature_inline_data(fs->super)) + return 0; + + /* Clear both flags if it's a special file */ + if (LINUX_S_ISCHR(inode->i_mode) || + LINUX_S_ISBLK(inode->i_mode) || + LINUX_S_ISFIFO(inode->i_mode) || + LINUX_S_ISSOCK(inode->i_mode)) { + check_extents_inlinedata(ctx, pctx); + return 0; + } + + /* If it looks like an extent tree, try to clear inlinedata */ + if (ext2fs_extent_header_verify(inode->i_block, + sizeof(inode->i_block)) == 0 && + fix_problem(ctx, PR_1_CLEAR_INLINE_DATA_FOR_EXTENT, pctx)) { + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + dirty = 1; + goto out; + } + + /* If it looks short enough to be inline data, try to clear extents */ + if (inode_size > EXT2_GOOD_OLD_INODE_SIZE) + max_inline_ea_size = inode_size - + (EXT2_GOOD_OLD_INODE_SIZE + + ((struct ext2_inode_large *)inode)->i_extra_isize); + else + max_inline_ea_size = 0; + if (EXT2_I_SIZE(inode) < + EXT4_MIN_INLINE_DATA_SIZE + max_inline_ea_size && + fix_problem(ctx, PR_1_CLEAR_EXTENT_FOR_INLINE_DATA, pctx)) { + inode->i_flags &= ~EXT4_EXTENTS_FL; + dirty = 1; + goto out; + } + + /* + * Too big for inline data, but no evidence of extent tree - + * maybe it's a block map file? If the mappings all look valid? + */ + if (could_be_block_map(fs, inode) && + fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_FLAGS, pctx)) { +#ifdef WORDS_BIGENDIAN + int i; + + for (i = 0; i < EXT2_N_BLOCKS; i++) + inode->i_block[i] = ext2fs_swab32(inode->i_block[i]); +#endif + + inode->i_flags &= ~(EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL); + dirty = 1; + goto out; + } + + /* Oh well, just clear the busted inode. */ + if (fix_problem(ctx, PR_1_CLEAR_EXTENT_INLINE_DATA_INODE, pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + return -1; + } + +out: + if (dirty) + e2fsck_write_inode(ctx, ino, inode, "pass1"); + + return 0; +} + +static void pass1_readahead(e2fsck_t ctx, dgrp_t *group, ext2_ino_t *next_ino) +{ + ext2_ino_t inodes_in_group = 0, inodes_per_block, inodes_per_buffer; + dgrp_t start = *group, grp; + blk64_t blocks_to_read = 0; + errcode_t err = EXT2_ET_INVALID_ARGUMENT; + + if (ctx->readahead_kb == 0) + goto out; + + /* Keep iterating groups until we have enough to readahead */ + inodes_per_block = EXT2_INODES_PER_BLOCK(ctx->fs->super); + for (grp = start; grp < ctx->fs->group_desc_count; grp++) { + if (ext2fs_bg_flags_test(ctx->fs, grp, EXT2_BG_INODE_UNINIT)) + continue; + inodes_in_group = ctx->fs->super->s_inodes_per_group - + ext2fs_bg_itable_unused(ctx->fs, grp); + blocks_to_read += (inodes_in_group + inodes_per_block - 1) / + inodes_per_block; + if (blocks_to_read * ctx->fs->blocksize > + ctx->readahead_kb * 1024) + break; + } + + err = e2fsck_readahead(ctx->fs, E2FSCK_READA_ITABLE, start, + grp - start + 1); + if (err == EAGAIN) { + ctx->readahead_kb /= 2; + err = 0; + } + +out: + if (err) { + /* Error; disable itable readahead */ + *group = ctx->fs->group_desc_count; + *next_ino = ctx->fs->super->s_inodes_count; + } else { + /* + * Don't do more readahead until we've reached the first inode + * of the last inode scan buffer block for the last group. + */ + *group = grp + 1; + inodes_per_buffer = (ctx->inode_buffer_blocks ? + ctx->inode_buffer_blocks : + EXT2_INODE_SCAN_DEFAULT_BUFFER_BLOCKS) * + ctx->fs->blocksize / + EXT2_INODE_SIZE(ctx->fs->super); + inodes_in_group--; + *next_ino = inodes_in_group - + (inodes_in_group % inodes_per_buffer) + 1 + + (grp * ctx->fs->super->s_inodes_per_group); + } +} + +/* + * Check if the passed ino is one of the used superblock quota inodes. + * + * Before the quota inodes were journaled, older superblock quota inodes + * were just regular files in the filesystem and not reserved inodes. This + * checks if the passed ino is one of the s_*_quota_inum superblock fields, + * which may not always be the same as the EXT4_*_QUOTA_INO fields. + */ +static int quota_inum_is_super(struct ext2_super_block *sb, ext2_ino_t ino) +{ + enum quota_type qtype; + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) + if (*quota_sb_inump(sb, qtype) == ino) + return 1; + + return 0; +} + +/* + * Check if the passed ino is one of the reserved quota inodes. + * This checks if the inode number is one of the reserved EXT4_*_QUOTA_INO + * inodes. These inodes may or may not be in use by the quota feature. + */ +static int quota_inum_is_reserved(ext2_filsys fs, ext2_ino_t ino) +{ + enum quota_type qtype; + + for (qtype = 0; qtype < MAXQUOTAS; qtype++) + if (quota_type2inum(qtype, fs->super) == ino) + return 1; + return 0; } @@ -592,18 +1048,27 @@ void e2fsck_pass1(e2fsck_t ctx) struct ext2_super_block *sb = ctx->fs->super; const char *old_op; unsigned int save_type; - int imagic_fs, extent_fs; - int busted_fs_time = 0; - int inode_size; + int imagic_fs, extent_fs, inlinedata_fs; + int low_dtime_check = 1; + int inode_size = EXT2_INODE_SIZE(fs->super); int failed_csum = 0; + ext2_ino_t ino_threshold = 0; + dgrp_t ra_group = 0; init_resource_track(&rtrack, ctx->fs->io); clear_problem_context(&pctx); + /* If we can do readahead, figure out how many groups to pull in. */ + if (!e2fsck_can_readahead(ctx->fs)) + ctx->readahead_kb = 0; + else if (ctx->readahead_kb == ~0ULL) + ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs); + pass1_readahead(ctx, &ra_group, &ino_threshold); + if (!(ctx->options & E2F_OPT_PREEN)) fix_problem(ctx, PR_1_PASS_HEADER, &pctx); - if ((fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && + if (ext2fs_has_feature_dir_index(fs->super) && !(ctx->options & E2F_OPT_NO)) { if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50)) ctx->dirs_to_hash = 0; @@ -624,8 +1089,9 @@ void e2fsck_pass1(e2fsck_t ctx) } #undef EXT2_BPP - imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); - extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS); + imagic_fs = ext2fs_has_feature_imagic_inodes(sb); + extent_fs = ext2fs_has_feature_extents(sb); + inlinedata_fs = ext2fs_has_feature_inline_data(sb); /* * Allocate bitmaps structures @@ -668,6 +1134,15 @@ void e2fsck_pass1(e2fsck_t ctx) ctx->flags |= E2F_FLAG_ABORT; return; } + pctx.errcode = e2fsck_allocate_block_bitmap(fs, + _("metadata block map"), EXT2FS_BMAP64_RBTREE, + "block_metadata_map", &ctx->block_metadata_map); + if (pctx.errcode) { + pctx.num = 1; + fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; + } e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info); if (!ctx->inode_link_info) { e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, @@ -682,7 +1157,6 @@ void e2fsck_pass1(e2fsck_t ctx) ctx->flags |= E2F_FLAG_ABORT; return; } - inode_size = EXT2_INODE_SIZE(fs->super); inode = (struct ext2_inode *) e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); @@ -726,6 +1200,7 @@ void e2fsck_pass1(e2fsck_t ctx) "block interate buffer"); if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE) e2fsck_use_inode_shortcuts(ctx, 1); + e2fsck_intercept_block_allocations(ctx); old_op = ehandler_operation(_("opening inode scan")); pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks, &scan); @@ -735,7 +1210,8 @@ void e2fsck_pass1(e2fsck_t ctx) ctx->flags |= E2F_FLAG_ABORT; goto endit; } - ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); + ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE | + EXT2_SF_WARN_GARBAGE_INODES, 0); ctx->stashed_inode = inode; scan_struct.ctx = ctx; scan_struct.block_buf = block_buf; @@ -744,10 +1220,12 @@ void e2fsck_pass1(e2fsck_t ctx) ctx->fs->group_desc_count))) goto endit; if ((fs->super->s_wtime < fs->super->s_inodes_count) || - (fs->super->s_mtime < fs->super->s_inodes_count)) - busted_fs_time = 1; + (fs->super->s_mtime < fs->super->s_inodes_count) || + (fs->super->s_mkfs_time && + fs->super->s_mkfs_time < fs->super->s_inodes_count)) + low_dtime_check = 0; - if ((fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_MMP) && + if (ext2fs_has_feature_mmp(fs->super) && fs->super->s_mmp_block > fs->super->s_first_data_block && fs->super->s_mmp_block < ext2fs_blocks_count(fs->super)) ext2fs_mark_block_bitmap2(ctx->block_found_map, @@ -764,10 +1242,43 @@ void e2fsck_pass1(e2fsck_t ctx) old_op = ehandler_operation(_("getting next inode from scan")); pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, inode, inode_size); + if (ino > ino_threshold) + pass1_readahead(ctx, &ra_group, &ino_threshold); ehandler_operation(old_op); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; + goto endit; if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { + /* + * If badblocks says badblocks is bad, offer to clear + * the list, update the in-core bb list, and restart + * the inode scan. + */ + if (ino == EXT2_BAD_INO && + fix_problem(ctx, PR_1_BADBLOCKS_IN_BADBLOCKS, + &pctx)) { + errcode_t err; + + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + ext2fs_badblocks_list_free(ctx->fs->badblocks); + ctx->fs->badblocks = NULL; + err = ext2fs_read_bb_inode(ctx->fs, + &ctx->fs->badblocks); + if (err) { + fix_problem(ctx, PR_1_ISCAN_ERROR, + &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + err = ext2fs_inode_scan_goto_blockgroup(scan, + 0); + if (err) { + fix_problem(ctx, PR_1_ISCAN_ERROR, + &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + continue; + } if (!ctx->inode_bb_map) alloc_bb_map(ctx); ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); @@ -775,7 +1286,8 @@ void e2fsck_pass1(e2fsck_t ctx) continue; } if (pctx.errcode && - pctx.errcode != EXT2_ET_INODE_CSUM_INVALID) { + pctx.errcode != EXT2_ET_INODE_CSUM_INVALID && + pctx.errcode != EXT2_ET_INODE_IS_GARBAGE) { fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; goto endit; @@ -786,12 +1298,14 @@ void e2fsck_pass1(e2fsck_t ctx) pctx.inode = inode; ctx->stashed_ino = ino; - /* Clear corrupt inode? */ - if (pctx.errcode == EXT2_ET_INODE_CSUM_INVALID) { - if (fix_problem(ctx, PR_1_INODE_CSUM_INVALID, &pctx)) - goto clear_inode; - failed_csum = 1; + /* Clear trashed inode? */ + if (pctx.errcode == EXT2_ET_INODE_IS_GARBAGE && + inode->i_links_count > 0 && + fix_problem(ctx, PR_1_INODE_IS_GARBAGE, &pctx)) { + pctx.errcode = 0; + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); } + failed_csum = pctx.errcode != 0; if (inode->i_links_count) { pctx.errcode = ext2fs_icount_store(ctx->inode_link_info, @@ -804,6 +1318,94 @@ void e2fsck_pass1(e2fsck_t ctx) } } + /* Conflicting inlinedata/extents inode flags? */ + if ((inode->i_flags & EXT4_INLINE_DATA_FL) && + (inode->i_flags & EXT4_EXTENTS_FL)) { + int res = fix_inline_data_extents_file(ctx, ino, inode, + inode_size, + &pctx); + if (res < 0) { + /* skip FINISH_INODE_LOOP */ + continue; + } + } + + /* Test for incorrect inline_data flags settings. */ + if ((inode->i_flags & EXT4_INLINE_DATA_FL) && !inlinedata_fs && + (ino >= EXT2_FIRST_INODE(fs->super))) { + size_t size = 0; + + pctx.errcode = ext2fs_inline_data_size(fs, ino, &size); + if (!pctx.errcode && size && + fix_problem(ctx, PR_1_INLINE_DATA_FEATURE, &pctx)) { + ext2fs_set_feature_inline_data(sb); + ext2fs_mark_super_dirty(fs); + inlinedata_fs = 1; + } else if (fix_problem(ctx, PR_1_INLINE_DATA_SET, &pctx)) { + e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); + /* skip FINISH_INODE_LOOP */ + continue; + } + } + + /* Test for inline data flag but no attr */ + if ((inode->i_flags & EXT4_INLINE_DATA_FL) && inlinedata_fs && + EXT2_I_SIZE(inode) > EXT4_MIN_INLINE_DATA_SIZE && + (ino >= EXT2_FIRST_INODE(fs->super))) { + size_t size = 0; + errcode_t err; + int flags; + + flags = fs->flags; + if (failed_csum) + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + err = get_inline_data_ea_size(fs, ino, &size); + fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + + switch (err) { + case 0: + /* Everything is awesome... */ + break; + case EXT2_ET_BAD_EA_BLOCK_NUM: + case EXT2_ET_BAD_EA_HASH: + case EXT2_ET_BAD_EA_HEADER: + case EXT2_ET_EA_BAD_NAME_LEN: + case EXT2_ET_EA_BAD_VALUE_SIZE: + case EXT2_ET_EA_KEY_NOT_FOUND: + case EXT2_ET_EA_NO_SPACE: + case EXT2_ET_MISSING_EA_FEATURE: + case EXT2_ET_INLINE_DATA_CANT_ITERATE: + case EXT2_ET_INLINE_DATA_NO_BLOCK: + case EXT2_ET_INLINE_DATA_NO_SPACE: + case EXT2_ET_NO_INLINE_DATA: + case EXT2_ET_EXT_ATTR_CSUM_INVALID: + case EXT2_ET_EA_BAD_VALUE_OFFSET: + /* broken EA or no system.data EA; truncate */ + if (fix_problem(ctx, PR_1_INLINE_DATA_NO_ATTR, + &pctx)) { + err = ext2fs_inode_size_set(fs, inode, + sizeof(inode->i_block)); + if (err) { + pctx.errcode = err; + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + if (LINUX_S_ISLNK(inode->i_mode)) + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + failed_csum = 0; + } + break; + default: + /* Some other kind of non-xattr error? */ + pctx.errcode = err; + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + } + /* * Test for incorrect extent flag settings. * @@ -825,7 +1427,7 @@ void e2fsck_pass1(e2fsck_t ctx) if ((ext2fs_extent_header_verify(inode->i_block, sizeof(inode->i_block)) == 0) && fix_problem(ctx, PR_1_EXTENT_FEATURE, &pctx)) { - sb->s_feature_incompat |= EXT3_FEATURE_INCOMPAT_EXTENTS; + ext2fs_set_feature_extents(sb); ext2fs_mark_super_dirty(fs); extent_fs = 1; } else if (fix_problem(ctx, PR_1_EXTENTS_SET, &pctx)) { @@ -834,6 +1436,7 @@ void e2fsck_pass1(e2fsck_t ctx) if (ino == EXT2_BAD_INO) ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); + /* skip FINISH_INODE_LOOP */ continue; } } @@ -870,18 +1473,22 @@ void e2fsck_pass1(e2fsck_t ctx) sizeof(inode->i_block)); #endif e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } if (ino == EXT2_BAD_INO) { struct process_block_struct pb; - if ((inode->i_mode || inode->i_uid || inode->i_gid || - inode->i_links_count || inode->i_file_acl) && + if ((failed_csum || inode->i_mode || inode->i_uid || + inode->i_gid || inode->i_links_count || + (inode->i_flags & EXT4_INLINE_DATA_FL) || + inode->i_file_acl) && fix_problem(ctx, PR_1_INVALID_BAD_INODE, &pctx)) { memset(inode, 0, sizeof(struct ext2_inode)); e2fsck_write_inode(ctx, ino, inode, "clear bad inode"); + failed_csum = 0; } pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, @@ -916,6 +1523,7 @@ void e2fsck_pass1(e2fsck_t ctx) } ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); clear_problem_context(&pctx); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); continue; } else if (ino == EXT2_ROOT_INO) { /* @@ -941,6 +1549,7 @@ void e2fsck_pass1(e2fsck_t ctx) inode->i_dtime = 0; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } } else if (ino == EXT2_JOURNAL_INO) { @@ -952,8 +1561,10 @@ void e2fsck_pass1(e2fsck_t ctx) inode->i_mode = LINUX_S_IFREG; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } check_blocks(ctx, &pctx, block_buf); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); continue; } if ((inode->i_links_count || @@ -965,22 +1576,22 @@ void e2fsck_pass1(e2fsck_t ctx) ino, 0); e2fsck_write_inode_full(ctx, ino, inode, inode_size, "pass1"); + failed_csum = 0; } - } else if ((ino == EXT4_USR_QUOTA_INO) || - (ino == EXT4_GRP_QUOTA_INO)) { + } else if (quota_inum_is_reserved(fs, ino)) { ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); - if ((fs->super->s_feature_ro_compat & - EXT4_FEATURE_RO_COMPAT_QUOTA) && - ((fs->super->s_usr_quota_inum == ino) || - (fs->super->s_grp_quota_inum == ino))) { + if (ext2fs_has_feature_quota(fs->super) && + quota_inum_is_super(fs->super, ino)) { if (!LINUX_S_ISREG(inode->i_mode) && fix_problem(ctx, PR_1_QUOTA_BAD_MODE, &pctx)) { inode->i_mode = LINUX_S_IFREG; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } check_blocks(ctx, &pctx, block_buf); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); continue; } if ((inode->i_links_count || @@ -992,6 +1603,7 @@ void e2fsck_pass1(e2fsck_t ctx) ino, 0); e2fsck_write_inode_full(ctx, ino, inode, inode_size, "pass1"); + failed_csum = 0; } } else if (ino < EXT2_FIRST_INODE(fs->super)) { problem_t problem = 0; @@ -1013,9 +1625,11 @@ void e2fsck_pass1(e2fsck_t ctx) inode->i_mode = 0; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } check_blocks(ctx, &pctx, block_buf); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); continue; } @@ -1036,13 +1650,14 @@ void e2fsck_pass1(e2fsck_t ctx) * than nothing. The right answer is that there * shouldn't be any bugs in the orphan list handling. :-) */ - if (inode->i_dtime && !busted_fs_time && + if (inode->i_dtime && low_dtime_check && inode->i_dtime < ctx->fs->super->s_inodes_count) { if (fix_problem(ctx, PR_1_LOW_DTIME, &pctx)) { inode->i_dtime = inode->i_links_count ? 0 : ctx->now; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } @@ -1057,8 +1672,10 @@ void e2fsck_pass1(e2fsck_t ctx) inode->i_dtime = ctx->now; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); continue; } /* @@ -1075,6 +1692,7 @@ void e2fsck_pass1(e2fsck_t ctx) if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { inode->i_dtime = 0; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } @@ -1091,13 +1709,12 @@ void e2fsck_pass1(e2fsck_t ctx) if (inode->i_faddr || frag || fsize || (LINUX_S_ISDIR(inode->i_mode) && inode->i_dir_acl)) mark_inode_bad(ctx, ino); - if (!(fs->super->s_feature_incompat & - EXT4_FEATURE_INCOMPAT_64BIT) && + if ((fs->super->s_creator_os == EXT2_OS_LINUX) && + !ext2fs_has_feature_64bit(fs->super) && inode->osd2.linux2.l_i_file_acl_high != 0) mark_inode_bad(ctx, ino); if ((fs->super->s_creator_os == EXT2_OS_LINUX) && - !(fs->super->s_feature_ro_compat & - EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && + !ext2fs_has_feature_huge_file(fs->super) && (inode->osd2.linux2.l_i_blocks_hi != 0)) mark_inode_bad(ctx, ino); if (inode->i_flags & EXT2_IMAGIC_FL) { @@ -1111,6 +1728,7 @@ void e2fsck_pass1(e2fsck_t ctx) inode->i_flags &= ~EXT2_IMAGIC_FL; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } } @@ -1128,22 +1746,27 @@ void e2fsck_pass1(e2fsck_t ctx) fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) { inode->i_flags &= ~EXT4_EXTENTS_FL; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } if (LINUX_S_ISDIR(inode->i_mode)) { ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); e2fsck_add_dir_info(ctx, ino, 0); ctx->fs_directory_count++; + if (inode->i_flags & EXT4_ENCRYPT_FL) + add_encrypted_dir(ctx, ino); } else if (LINUX_S_ISREG (inode->i_mode)) { ext2fs_mark_inode_bitmap2(ctx->inode_reg_map, ino); ctx->fs_regular_count++; } else if (LINUX_S_ISCHR (inode->i_mode) && e2fsck_pass1_check_device_inode(fs, inode)) { + check_extents_inlinedata(ctx, &pctx); check_immutable(ctx, &pctx); check_size(ctx, &pctx); ctx->fs_chardev_count++; } else if (LINUX_S_ISBLK (inode->i_mode) && e2fsck_pass1_check_device_inode(fs, inode)) { + check_extents_inlinedata(ctx, &pctx); check_immutable(ctx, &pctx); check_size(ctx, &pctx); ctx->fs_blockdev_count++; @@ -1152,25 +1775,32 @@ void e2fsck_pass1(e2fsck_t ctx) block_buf)) { check_immutable(ctx, &pctx); ctx->fs_symlinks_count++; - if (ext2fs_inode_data_blocks(fs, inode) == 0) { + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + continue; + } else if (ext2fs_inode_data_blocks(fs, inode) == 0) { ctx->fs_fast_symlinks_count++; check_blocks(ctx, &pctx, block_buf); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); continue; } } else if (LINUX_S_ISFIFO (inode->i_mode) && e2fsck_pass1_check_device_inode(fs, inode)) { + check_extents_inlinedata(ctx, &pctx); check_immutable(ctx, &pctx); check_size(ctx, &pctx); ctx->fs_fifo_count++; } else if ((LINUX_S_ISSOCK (inode->i_mode)) && e2fsck_pass1_check_device_inode(fs, inode)) { + check_extents_inlinedata(ctx, &pctx); check_immutable(ctx, &pctx); check_size(ctx, &pctx); ctx->fs_sockets_count++; } else mark_inode_bad(ctx, ino); - if (!(inode->i_flags & EXT4_EXTENTS_FL)) { + if (!(inode->i_flags & EXT4_EXTENTS_FL) && + !(inode->i_flags & EXT4_INLINE_DATA_FL)) { if (inode->i_block[EXT2_IND_BLOCK]) ctx->fs_ind_count++; if (inode->i_block[EXT2_DIND_BLOCK]) @@ -1179,29 +1809,19 @@ void e2fsck_pass1(e2fsck_t ctx) ctx->fs_tind_count++; } if (!(inode->i_flags & EXT4_EXTENTS_FL) && + !(inode->i_flags & EXT4_INLINE_DATA_FL) && (inode->i_block[EXT2_IND_BLOCK] || inode->i_block[EXT2_DIND_BLOCK] || inode->i_block[EXT2_TIND_BLOCK] || ext2fs_file_acl_block(fs, inode))) { inodes_to_process[process_inode_count].ino = ino; - inodes_to_process[process_inode_count].inode = *inode; + inodes_to_process[process_inode_count].inode = + *(struct ext2_inode_large *)inode; process_inode_count++; } else check_blocks(ctx, &pctx, block_buf); - /* - * If the inode failed the checksum and the user didn't - * clear the inode, test the checksum again -- if it still - * fails, ask the user if the checksum should be corrected. - */ - if (failed_csum) { - pctx.errcode = recheck_bad_inode_checksum(fs, ino, ctx, - &pctx); - if (pctx.errcode) { - ctx->flags |= E2F_FLAG_ABORT; - return; - } - } + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) goto endit; @@ -1217,6 +1837,9 @@ void e2fsck_pass1(e2fsck_t ctx) ext2fs_close_inode_scan(scan); scan = NULL; + reserve_block_for_root_repair(ctx); + reserve_block_for_lnf_repair(ctx); + /* * If any extended attribute blocks' reference counts need to * be adjusted, either up (ctx->refcount_extra), or down @@ -1244,10 +1867,6 @@ void e2fsck_pass1(e2fsck_t ctx) } if (ctx->flags & E2F_FLAG_RESIZE_INODE) { - ext2fs_block_bitmap save_bmap; - - save_bmap = fs->block_map; - fs->block_map = ctx->block_found_map; clear_problem_context(&pctx); pctx.errcode = ext2fs_create_resize_inode(fs); if (pctx.errcode) { @@ -1265,7 +1884,6 @@ void e2fsck_pass1(e2fsck_t ctx) e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, "recreate inode"); } - fs->block_map = save_bmap; ctx->flags &= ~E2F_FLAG_RESIZE_INODE; } @@ -1288,6 +1906,7 @@ void e2fsck_pass1(e2fsck_t ctx) } e2fsck_pass1_dupblocks(ctx, block_buf); } + ctx->flags |= E2F_FLAG_ALLOC_OK; ext2fs_free_mem(&inodes_to_process); endit: e2fsck_use_inode_shortcuts(ctx, 0); @@ -1307,7 +1926,10 @@ endit: if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); + else + ctx->invalid_bitmaps++; } +#undef FINISH_INODE_LOOP /* * When the inode_scan routines call this callback at the end of the @@ -1357,7 +1979,8 @@ static void process_inodes(e2fsck_t ctx, char *block_buf) sizeof(struct process_inode_block), process_inode_cmp); clear_problem_context(&pctx); for (i=0; i < process_inode_count; i++) { - pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; + pctx.inode = ctx->stashed_inode = + (struct ext2_inode *) &inodes_to_process[i].inode; pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; #if 0 @@ -1395,8 +2018,8 @@ static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) * inodes, so it's OK to pass NULL to * ext2fs_file_acl_block() here. */ - ret = ext2fs_file_acl_block(0, &(ib_a->inode)) - - ext2fs_file_acl_block(0, &(ib_b->inode)); + ret = ext2fs_file_acl_block(0, ext2fs_const_inode(&ib_a->inode)) - + ext2fs_file_acl_block(0, ext2fs_const_inode(&ib_b->inode)); if (ret == 0) ret = ib_a->ino - ib_b->ino; return ret; @@ -1426,6 +2049,23 @@ static void mark_inode_bad(e2fsck_t ctx, ino_t ino) ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino); } +static void add_encrypted_dir(e2fsck_t ctx, ino_t ino) +{ + struct problem_context pctx; + + if (!ctx->encrypted_dirs) { + pctx.errcode = ext2fs_u32_list_create(&ctx->encrypted_dirs, 0); + if (pctx.errcode) + goto error; + } + pctx.errcode = ext2fs_u32_list_add(ctx->encrypted_dirs, ino); + if (pctx.errcode == 0) + return; +error: + fix_problem(ctx, PR_1_ALLOCATE_ENCRYPTED_DIRLIST, &pctx); + /* Should never get here */ + ctx->flags |= E2F_FLAG_ABORT; +} /* * This procedure will allocate the inode "bb" (badblock) map table @@ -1587,7 +2227,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, * Or if the extended attribute block is an invalid block, * then the inode is also corrupted. */ - if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || + if (!ext2fs_has_feature_xattr(fs->super) || (blk < fs->super->s_first_data_block) || (blk >= ext2fs_blocks_count(fs->super))) { mark_inode_bad(ctx, ino); @@ -1650,12 +2290,16 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, pctx->blk = blk; pctx->errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, pctx->ino); if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) { - if (fix_problem(ctx, PR_1_EA_BLOCK_CSUM_INVALID, pctx)) - goto clear_extattr; + pctx->errcode = 0; failed_csum = 1; - } - if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) + } else if (pctx->errcode == EXT2_ET_BAD_EA_HEADER) + pctx->errcode = 0; + + if (pctx->errcode && + fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) { + pctx->errcode = 0; goto clear_extattr; + } header = (struct ext2_ext_attr_header *) block_buf; pctx->blk = ext2fs_file_acl_block(fs, inode); if (((ctx->ext_attr_ver == 1) && @@ -1671,6 +2315,9 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, goto clear_extattr; } + if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) + goto clear_extattr; + region = region_create(0, fs->blocksize); if (!region) { fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); @@ -1774,7 +2421,7 @@ static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, if ((!LINUX_S_ISDIR(inode->i_mode) && fix_problem(ctx, PR_1_HTREE_NODIR, pctx)) || - (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX) && + (!ext2fs_has_feature_dir_index(fs->super) && fix_problem(ctx, PR_1_HTREE_SET, pctx))) return 1; @@ -1829,6 +2476,16 @@ void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, ext2fs_icount_store(ctx->inode_link_info, ino, 0); inode->i_dtime = ctx->now; + /* + * If a special inode has such rotten block mappings that we + * want to clear the whole inode, be sure to actually zap + * the block maps because i_links_count isn't checked for + * special inodes, and we'll end up right back here the next + * time we run fsck. + */ + if (ino < EXT2_FIRST_INODE(ctx->fs->super)) + memset(inode->i_block, 0, sizeof(inode->i_block)); + ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); if (ctx->inode_reg_map) @@ -1848,11 +2505,46 @@ void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, e2fsck_write_inode(ctx, ino, inode, source); } +/* + * Use the multiple-blocks reclamation code to fix alignment problems in + * a bigalloc filesystem. We want a logical cluster to map to *only* one + * physical cluster, and we want the block offsets within that cluster to + * line up. + */ +static int has_unaligned_cluster_map(e2fsck_t ctx, + blk64_t last_pblk, e2_blkcnt_t last_lblk, + blk64_t pblk, blk64_t lblk) +{ + blk64_t cluster_mask; + + if (!ctx->fs->cluster_ratio_bits) + return 0; + cluster_mask = EXT2FS_CLUSTER_MASK(ctx->fs); + + /* + * If the block in the logical cluster doesn't align with the block in + * the physical cluster... + */ + if ((lblk & cluster_mask) != (pblk & cluster_mask)) + return 1; + + /* + * If we cross a physical cluster boundary within a logical cluster... + */ + if (last_pblk && (lblk & cluster_mask) != 0 && + EXT2FS_B2C(ctx->fs, lblk) == EXT2FS_B2C(ctx->fs, last_lblk) && + EXT2FS_B2C(ctx->fs, pblk) != EXT2FS_B2C(ctx->fs, last_pblk)) + return 1; + + return 0; +} + static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, struct process_block_struct *pb, blk64_t start_block, blk64_t end_block, blk64_t eof_block, - ext2_extent_handle_t ehandle) + ext2_extent_handle_t ehandle, + int try_repairs) { struct ext2fs_extent extent; blk64_t blk, last_lblk; @@ -1861,33 +2553,46 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, int is_dir, is_leaf; problem_t problem; struct ext2_extent_info info; - int failed_csum; + int failed_csum = 0; + + if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) + failed_csum = 1; pctx->errcode = ext2fs_extent_get_info(ehandle, &info); if (pctx->errcode) return; + if (!(ctx->options & E2F_OPT_FIXES_ONLY) && + !pb->eti.force_rebuild) { + struct extent_tree_level *etl; + + etl = pb->eti.ext_info + info.curr_level; + etl->num_extents += info.num_entries; + etl->max_extents += info.max_entries; + /* + * Implementation wart: Splitting extent blocks when appending + * will leave the old block with one free entry. Therefore + * unless the node is totally full, pretend that a non-root + * extent block can hold one fewer entry than it actually does, + * so that we don't repeatedly rebuild the extent tree. + */ + if (info.curr_level && info.num_entries < info.max_entries) + etl->max_extents--; + } pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB, &extent); while ((pctx->errcode == 0 || pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) && info.num_entries-- > 0) { - failed_csum = 0; is_leaf = extent.e_flags & EXT2_EXTENT_FLAGS_LEAF; is_dir = LINUX_S_ISDIR(pctx->inode->i_mode); last_lblk = extent.e_lblk + extent.e_len - 1; problem = 0; - /* Ask to clear a corrupt extent block */ - if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) { - pctx->blk = extent.e_pblk; - pctx->blk2 = extent.e_lblk; - pctx->num = extent.e_len; - problem = PR_1_EXTENT_CSUM_INVALID; - if (fix_problem(ctx, problem, pctx)) - goto fix_problem_now; - failed_csum = 1; - } + pctx->blk = extent.e_pblk; + pctx->blk2 = extent.e_lblk; + pctx->num = extent.e_len; + pctx->blkcount = extent.e_lblk + extent.e_len; if (extent.e_pblk == 0 || extent.e_pblk < ctx->fs->super->s_first_data_block || @@ -1910,33 +2615,63 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, (1 << (21 - ctx->fs->super->s_log_block_size)))) problem = PR_1_TOOBIG_DIR; - /* Corrupt but passes checks? Ask to fix checksum. */ - if (failed_csum) { - pctx->blk = extent.e_pblk; - pctx->blk2 = extent.e_lblk; - pctx->num = extent.e_len; - problem = 0; - if (fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, - pctx)) - ext2fs_extent_replace(ehandle, 0, &extent); + if (is_leaf && problem == 0 && extent.e_len > 0 && + region_allocate(pb->region, extent.e_lblk, extent.e_len)) + problem = PR_1_EXTENT_COLLISION; + + /* + * Uninitialized blocks in a directory? Clear the flag and + * we'll interpret the blocks later. + */ + if (try_repairs && is_dir && problem == 0 && + (extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT) && + fix_problem(ctx, PR_1_UNINIT_DBLOCK, pctx)) { + extent.e_flags &= ~EXT2_EXTENT_FLAGS_UNINIT; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, + &extent); + if (pctx->errcode) + return; + failed_csum = 0; } - if (problem) { + if (try_repairs && problem) { report_problem: - pctx->blk = extent.e_pblk; - pctx->blk2 = extent.e_lblk; - pctx->num = extent.e_len; - pctx->blkcount = extent.e_lblk + extent.e_len; if (fix_problem(ctx, problem, pctx)) { -fix_problem_now: + if (ctx->invalid_bitmaps) { + /* + * If fsck knows the bitmaps are bad, + * skip to the next extent and + * try to clear this extent again + * after fixing the bitmaps, by + * restarting fsck. + */ + pctx->errcode = ext2fs_extent_get( + ehandle, + EXT2_EXTENT_NEXT_SIB, + &extent); + ctx->flags |= E2F_FLAG_RESTART_LATER; + if (pctx->errcode == + EXT2_ET_NO_CURRENT_NODE) { + pctx->errcode = 0; + break; + } + continue; + } e2fsck_read_bitmaps(ctx); + pb->inode_modified = 1; pctx->errcode = ext2fs_extent_delete(ehandle, 0); if (pctx->errcode) { pctx->str = "ext2fs_extent_delete"; return; } - ext2fs_extent_fix_parents(ehandle); + pctx->errcode = ext2fs_extent_fix_parents(ehandle); + if (pctx->errcode && + pctx->errcode != EXT2_ET_NO_CURRENT_NODE) { + pctx->str = "ext2fs_extent_fix_parents"; + return; + } pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_CURRENT, &extent); @@ -1944,6 +2679,7 @@ fix_problem_now: pctx->errcode = 0; break; } + failed_csum = 0; continue; } goto next; @@ -1951,17 +2687,34 @@ fix_problem_now: if (!is_leaf) { blk64_t lblk = extent.e_lblk; + int next_try_repairs = 1; blk = extent.e_pblk; + + /* + * If this lower extent block collides with critical + * metadata, don't try to repair the damage. Pass 1b + * will reallocate the block; then we can try again. + */ + if (pb->ino != EXT2_RESIZE_INO && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, + extent.e_pblk)) { + next_try_repairs = 0; + pctx->blk = blk; + fix_problem(ctx, + PR_1_CRITICAL_METADATA_COLLISION, + pctx); + ctx->flags |= E2F_FLAG_RESTART_LATER; + } pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_DOWN, &extent); - if (pctx->errcode) { + if (pctx->errcode && + pctx->errcode != EXT2_ET_EXTENT_CSUM_INVALID) { pctx->str = "EXT2_EXTENT_DOWN"; problem = PR_1_EXTENT_HEADER_INVALID; - if (pctx->errcode == - EXT2_ET_EXTENT_HEADER_BAD || - pctx->errcode == - EXT2_ET_EXTENT_CSUM_INVALID) + if (!next_try_repairs) + return; + if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD) goto report_problem; return; } @@ -1974,11 +2727,19 @@ fix_problem_now: pctx->blk2 = extent.e_lblk; pctx->num = e_info.curr_level - 1; problem = PR_1_EXTENT_INDEX_START_INVALID; - if (fix_problem(ctx, problem, pctx)) - ext2fs_extent_fix_parents(ehandle); + if (fix_problem(ctx, problem, pctx)) { + pb->inode_modified = 1; + pctx->errcode = + ext2fs_extent_fix_parents(ehandle); + if (pctx->errcode) { + pctx->str = "ext2fs_extent_fix_parents"; + return; + } + } } scan_extent_node(ctx, pctx, pb, extent.e_lblk, - last_lblk, eof_block, ehandle); + last_lblk, eof_block, ehandle, + next_try_repairs); if (pctx->errcode) return; pctx->errcode = ext2fs_extent_get(ehandle, @@ -2013,6 +2774,46 @@ fix_problem_now: } pb->fragmented = 1; } + /* + * If we notice a gap in the logical block mappings of an + * extent-mapped directory, offer to close the hole by + * moving the logical block down, otherwise we'll go mad in + * pass 3 allocating empty directory blocks to fill the hole. + */ + if (try_repairs && is_dir && + pb->last_block + 1 < (e2_blkcnt_t)extent.e_lblk) { + blk64_t new_lblk; + + new_lblk = pb->last_block + 1; + if (EXT2FS_CLUSTER_RATIO(ctx->fs) > 1) + new_lblk = ((new_lblk + + EXT2FS_CLUSTER_RATIO(ctx->fs) - 1) & + ~EXT2FS_CLUSTER_MASK(ctx->fs)) | + (extent.e_pblk & + EXT2FS_CLUSTER_MASK(ctx->fs)); + pctx->blk = extent.e_lblk; + pctx->blk2 = new_lblk; + if (fix_problem(ctx, PR_1_COLLAPSE_DBLOCK, pctx)) { + extent.e_lblk = new_lblk; + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, + 0, &extent); + if (pctx->errcode) { + pctx->errcode = 0; + goto alloc_later; + } + pctx->errcode = ext2fs_extent_fix_parents(ehandle); + if (pctx->errcode) + goto failed_add_dir_block; + pctx->errcode = ext2fs_extent_goto(ehandle, + extent.e_lblk); + if (pctx->errcode) + goto failed_add_dir_block; + last_lblk = extent.e_lblk + extent.e_len - 1; + failed_csum = 0; + } + } +alloc_later: while (is_dir && (++pb->last_db_block < (e2_blkcnt_t) extent.e_lblk)) { pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, @@ -2040,7 +2841,16 @@ fix_problem_now: mark_block_used(ctx, blk); pb->num_blocks++; } - + if (has_unaligned_cluster_map(ctx, pb->previous_block, + pb->last_block, blk, + blockcnt)) { + pctx->blk = blockcnt; + pctx->blk2 = blk; + fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx); + mark_block_used(ctx, blk); + mark_block_used(ctx, blk); + } + pb->last_block = blockcnt; pb->previous_block = blk; if (is_dir) { @@ -2068,6 +2878,16 @@ fix_problem_now: EXT2_EXTENT_NEXT_SIB, &extent); } + + /* Failed csum but passes checks? Ask to fix checksum. */ + if (failed_csum && + fix_problem(ctx, PR_1_EXTENT_ONLY_CSUM_INVALID, pctx)) { + pb->inode_modified = 1; + pctx->errcode = ext2fs_extent_replace(ehandle, 0, &extent); + if (pctx->errcode) + return; + } + if (pctx->errcode == EXT2_ET_EXTENT_NO_NEXT) pctx->errcode = 0; } @@ -2082,7 +2902,20 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, ext2_ino_t ino = pctx->ino; errcode_t retval; blk64_t eof_lblk; + struct ext3_extent_header *eh; + + /* Check for a proper extent header... */ + eh = (struct ext3_extent_header *) &inode->i_block[0]; + retval = ext2fs_extent_header_verify(eh, sizeof(inode->i_block)); + if (retval) { + if (fix_problem(ctx, PR_1_MISSING_EXTENT_HEADER, pctx)) + e2fsck_clear_inode(ctx, ino, inode, 0, + "check_blocks_extents"); + pctx->errcode = 0; + return; + } + /* ...since this function doesn't fail if i_block is zeroed. */ pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle); if (pctx->errcode) { if (fix_problem(ctx, PR_1_READ_EXTENT, pctx)) @@ -2094,14 +2927,38 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, retval = ext2fs_extent_get_info(ehandle, &info); if (retval == 0) { - if (info.max_depth >= MAX_EXTENT_DEPTH_COUNT) - info.max_depth = MAX_EXTENT_DEPTH_COUNT-1; - ctx->extent_depth_count[info.max_depth]++; + int max_depth = info.max_depth; + + if (max_depth >= MAX_EXTENT_DEPTH_COUNT) + max_depth = MAX_EXTENT_DEPTH_COUNT-1; + ctx->extent_depth_count[max_depth]++; + } + + /* Check maximum extent depth */ + pctx->blk = info.max_depth; + pctx->blk2 = ext2fs_max_extent_depth(ehandle); + if (pctx->blk2 < pctx->blk && + fix_problem(ctx, PR_1_EXTENT_BAD_MAX_DEPTH, pctx)) + pb->eti.force_rebuild = 1; + + /* Can we collect extent tree level stats? */ + pctx->blk = MAX_EXTENT_DEPTH_COUNT; + if (pctx->blk2 > pctx->blk) + fix_problem(ctx, PR_1E_MAX_EXTENT_TREE_DEPTH, pctx); + memset(pb->eti.ext_info, 0, sizeof(pb->eti.ext_info)); + pb->eti.ino = pb->ino; + + pb->region = region_create(0, info.max_lblk); + if (!pb->region) { + ext2fs_extent_free(ehandle); + fix_problem(ctx, PR_1_EXTENT_ALLOC_REGION_ABORT, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return; } eof_lblk = ((EXT2_I_SIZE(inode) + fs->blocksize - 1) >> EXT2_BLOCK_SIZE_BITS(fs->super)) - 1; - scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle); + scan_extent_node(ctx, pctx, pb, 0, 0, eof_lblk, ehandle, 1); if (pctx->errcode && fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) { pb->num_blocks = 0; @@ -2110,7 +2967,67 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, "check_blocks_extents"); pctx->errcode = 0; } + region_free(pb->region); + pb->region = NULL; ext2fs_extent_free(ehandle); + + /* Rebuild unless it's a dir and we're rehashing it */ + if (LINUX_S_ISDIR(inode->i_mode) && + e2fsck_dir_will_be_rehashed(ctx, ino)) + return; + + if (ctx->options & E2F_OPT_CONVERT_BMAP) + e2fsck_rebuild_extents_later(ctx, ino); + else + e2fsck_should_rebuild_extents(ctx, pctx, &pb->eti, &info); +} + +/* + * In fact we don't need to check blocks for an inode with inline data + * because this inode doesn't have any blocks. In this function all + * we need to do is add this inode into dblist when it is a directory. + */ +static void check_blocks_inline_data(e2fsck_t ctx, struct problem_context *pctx, + struct process_block_struct *pb) +{ + int flags; + size_t inline_data_size = 0; + + if (!pb->is_dir) { + pctx->errcode = 0; + return; + } + + /* Process the dirents in i_block[] as the "first" block. */ + pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 0); + if (pctx->errcode) + goto err; + + /* Process the dirents in the EA as a "second" block. */ + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + pctx->errcode = ext2fs_inline_data_size(ctx->fs, pb->ino, + &inline_data_size); + ctx->fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (pctx->errcode) { + pctx->errcode = 0; + return; + } + + if (inline_data_size <= EXT4_MIN_INLINE_DATA_SIZE) + return; + + pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pb->ino, 0, 1); + if (pctx->errcode) + goto err; + + return; +err: + pctx->blk = 0; + pctx->num = 0; + fix_problem(ctx, PR_1_ADD_DBLOCK, pctx); + ctx->flags |= E2F_FLAG_ABORT; } /* @@ -2127,6 +3044,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, unsigned bad_size = 0; int dirty_inode = 0; int extent_fs; + int inlinedata_fs; __u64 size; pb.ino = ino; @@ -2145,35 +3063,38 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, pb.inode = inode; pb.pctx = pctx; pb.ctx = ctx; + pb.inode_modified = 0; + pb.eti.force_rebuild = 0; pctx->ino = ino; pctx->errcode = 0; - extent_fs = (ctx->fs->super->s_feature_incompat & - EXT3_FEATURE_INCOMPAT_EXTENTS); + extent_fs = ext2fs_has_feature_extents(ctx->fs->super); + inlinedata_fs = ext2fs_has_feature_inline_data(ctx->fs->super); - if (inode->i_flags & EXT2_COMPRBLK_FL) { - if (fs->super->s_feature_incompat & - EXT2_FEATURE_INCOMPAT_COMPRESSION) - pb.compressed = 1; - else { - if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { - inode->i_flags &= ~EXT2_COMPRBLK_FL; - dirty_inode++; - } - } - } - - if (ext2fs_file_acl_block(fs, inode) && - check_ext_attr(ctx, pctx, block_buf)) { + if (check_ext_attr(ctx, pctx, block_buf)) { if (ctx->flags & E2F_FLAG_SIGNAL_MASK) goto out; pb.num_blocks++; } - if (ext2fs_inode_has_valid_blocks2(fs, inode)) { + if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) + check_blocks_inline_data(ctx, pctx, &pb); + else if (ext2fs_inode_has_valid_blocks2(fs, inode)) { if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) check_blocks_extents(ctx, pctx, &pb); else { + int flags; + /* + * If we've modified the inode, write it out before + * iterate() tries to use it. + */ + if (dirty_inode) { + e2fsck_write_inode(ctx, ino, inode, + "check_blocks"); + dirty_inode = 0; + } + flags = fs->flags; + fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; pctx->errcode = ext2fs_block_iterate3(fs, ino, pb.is_dir ? BLOCK_FLAG_HOLE : 0, block_buf, process_block, &pb); @@ -2182,6 +3103,26 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, * files. */ pb.last_init_lblock = pb.last_block; + /* + * If iterate() changed a block mapping, we have to + * re-read the inode. If we decide to clear the + * inode after clearing some stuff, we'll re-write the + * bad mappings into the inode! + */ + if (pb.inode_modified) + e2fsck_read_inode(ctx, ino, inode, + "check_blocks"); + fs->flags = (flags & EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (fs->flags & ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + + if (ctx->options & E2F_OPT_CONVERT_BMAP) { +#ifdef DEBUG + printf("bmap rebuild ino=%d\n", ino); +#endif + if (!LINUX_S_ISDIR(inode->i_mode) || + !e2fsck_dir_will_be_rehashed(ctx, ino)) + e2fsck_rebuild_extents_later(ctx, ino); + } } } end_problem_latch(ctx, PR_LATCH_BLOCK); @@ -2209,13 +3150,12 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, inode->i_flags &= ~EXT2_INDEX_FL; dirty_inode++; } else { -#ifdef ENABLE_HTREE e2fsck_add_dx_dir(ctx, ino, pb.last_block+1); -#endif } } - if (!pb.num_blocks && pb.is_dir) { + if (!pb.num_blocks && pb.is_dir && + !(inode->i_flags & EXT4_INLINE_DATA_FL)) { if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); ctx->fs_directory_count--; @@ -2223,14 +3163,15 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } } - if (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super)) { - quota_data_add(ctx->qctx, inode, ino, - pb.num_blocks * fs->blocksize); - quota_data_inodes(ctx->qctx, inode, ino, +1); + if (ino != quota_type2inum(PRJQUOTA, fs->super) && + (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INODE(ctx->fs->super))) { + quota_data_add(ctx->qctx, (struct ext2_inode_large *) inode, + ino, pb.num_blocks * fs->blocksize); + quota_data_inodes(ctx->qctx, (struct ext2_inode_large *) inode, + ino, +1); } - if (!(fs->super->s_feature_ro_compat & - EXT4_FEATURE_RO_COMPAT_HUGE_FILE) || + if (!ext2fs_has_feature_huge_file(fs->super) || !(inode->i_flags & EXT4_HUGE_FILE_FL)) pb.num_blocks *= (fs->blocksize / 512); pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs); @@ -2241,7 +3182,25 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, #endif if (pb.is_dir) { int nblock = inode->i_size >> EXT2_BLOCK_SIZE_BITS(fs->super); - if (inode->i_size & (fs->blocksize - 1)) + if (inode->i_flags & EXT4_INLINE_DATA_FL) { + int flags; + size_t size; + errcode_t err; + + size = 0; + flags = ctx->fs->flags; + ctx->fs->flags |= EXT2_FLAG_IGNORE_CSUM_ERRORS; + err = ext2fs_inline_data_size(ctx->fs, pctx->ino, + &size); + ctx->fs->flags = (flags & + EXT2_FLAG_IGNORE_CSUM_ERRORS) | + (ctx->fs->flags & + ~EXT2_FLAG_IGNORE_CSUM_ERRORS); + if (err || size != inode->i_size) { + bad_size = 7; + pctx->num = size; + } + } else if (inode->i_size & (fs->blocksize - 1)) bad_size = 5; else if (nblock > (pb.last_block + 1)) bad_size = 1; @@ -2273,12 +3232,20 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } /* i_size for symlinks is checked elsewhere */ if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { - pctx->num = (pb.last_block+1) * fs->blocksize; + /* Did inline_data set pctx->num earlier? */ + if (bad_size != 7) + pctx->num = (pb.last_block + 1) * fs->blocksize; pctx->group = bad_size; if (fix_problem(ctx, PR_1_BAD_I_SIZE, pctx)) { - inode->i_size = pctx->num; - if (!LINUX_S_ISDIR(inode->i_mode)) - inode->i_size_high = pctx->num >> 32; + if (LINUX_S_ISDIR(inode->i_mode)) + pctx->num &= 0xFFFFFFFFULL; + ext2fs_inode_size_set(fs, inode, pctx->num); + if (EXT2_I_SIZE(inode) == 0 && + (inode->i_flags & EXT4_INLINE_DATA_FL)) { + memset(inode->i_block, 0, + sizeof(inode->i_block)); + inode->i_flags &= ~EXT4_INLINE_DATA_FL; + } dirty_inode++; } pctx->num = 0; @@ -2286,11 +3253,11 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, if (LINUX_S_ISREG(inode->i_mode) && ext2fs_needs_large_file_feature(EXT2_I_SIZE(inode))) ctx->large_files++; - if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) || - ((fs->super->s_feature_ro_compat & - EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && - (inode->i_flags & EXT4_HUGE_FILE_FL) && - (inode->osd2.linux2.l_i_blocks_hi != 0))) { + if ((fs->super->s_creator_os == EXT2_OS_LINUX) && + ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) || + (ext2fs_has_feature_huge_file(fs->super) && + (inode->i_flags & EXT4_HUGE_FILE_FL) && + (inode->osd2.linux2.l_i_blocks_hi != 0)))) { pctx->num = pb.num_blocks; if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { inode->i_blocks = pb.num_blocks; @@ -2300,6 +3267,22 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, pctx->num = 0; } + /* + * The kernel gets mad if we ask it to allocate bigalloc clusters to + * a block mapped file, so rebuild it as an extent file. We can skip + * symlinks because they're never rewritten. + */ + if (ext2fs_has_feature_bigalloc(fs->super) && + (LINUX_S_ISREG(inode->i_mode) || LINUX_S_ISDIR(inode->i_mode)) && + ext2fs_inode_data_blocks2(fs, inode) > 0 && + (ino == EXT2_ROOT_INO || ino >= EXT2_FIRST_INO(fs->super)) && + !(inode->i_flags & (EXT4_EXTENTS_FL | EXT4_INLINE_DATA_FL)) && + fix_problem(ctx, PR_1_NO_BIGALLOC_BLOCKMAP_FILES, pctx)) { + pctx->errcode = e2fsck_rebuild_extents_later(ctx, ino); + if (pctx->errcode) + goto out; + } + if (ctx->dirs_to_hash && pb.is_dir && !(ctx->lost_and_found && ctx->lost_and_found == ino) && !(inode->i_flags & EXT2_INDEX_FL) && @@ -2384,26 +3367,19 @@ static int process_block(ext2_filsys fs, pctx = p->pctx; ctx = p->ctx; - if (p->compressed && (blk == EXT2FS_COMPRESSED_BLKADDR)) { - /* todo: Check that the comprblk_fl is high, that the - blkaddr pattern looks right (all non-holes up to - first EXT2FS_COMPRESSED_BLKADDR, then all - EXT2FS_COMPRESSED_BLKADDR up to end of cluster), - that the feature_incompat bit is high, and that the - inode is a regular file. If we're doing a "full - check" (a concept introduced to e2fsck by e2compr, - meaning that we look at data blocks as well as - metadata) then call some library routine that - checks the compressed data. I'll have to think - about this, because one particularly important - problem to be able to fix is to recalculate the - cluster size if necessary. I think that perhaps - we'd better do most/all e2compr-specific checks - separately, after the non-e2compr checks. If not - doing a full check, it may be useful to test that - the personality is linux; e.g. if it isn't then - perhaps this really is just an illegal block. */ - return 0; + /* + * For a directory, add logical block zero for processing even if it's + * not mapped or we'll be perennially stuck with broken "." and ".." + * entries. + */ + if (p->is_dir && blockcnt == 0 && blk == 0) { + pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, 0, 0); + if (pctx->errcode) { + pctx->blk = blk; + pctx->num = blockcnt; + goto failed_add_dir_block; + } + p->last_db_block++; } if (blk == 0) @@ -2419,7 +3395,7 @@ static int process_block(ext2_filsys fs, * file be contiguous. (Which can never be true for really * big files that are greater than a block group.) */ - if (!HOLE_BLKADDR(p->previous_block) && p->ino != EXT2_RESIZE_INO) { + if (p->previous_block && p->ino != EXT2_RESIZE_INO) { if (p->previous_block+1 != blk) { if (ctx->options & E2F_OPT_FRAGCHECK) { char type = '?'; @@ -2451,8 +3427,44 @@ static int process_block(ext2_filsys fs, blk >= ext2fs_blocks_count(fs->super)) problem = PR_1_ILLEGAL_BLOCK_NUM; + /* + * If this IND/DIND/TIND block is squatting atop some critical metadata + * (group descriptors, superblock, bitmap, inode table), any write to + * "fix" mapping problems will destroy the metadata. We'll let pass 1b + * fix that and restart fsck. + */ + if (blockcnt < 0 && + p->ino != EXT2_RESIZE_INO && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) { + pctx->blk = blk; + fix_problem(ctx, PR_1_CRITICAL_METADATA_COLLISION, pctx); + ctx->flags |= E2F_FLAG_RESTART_LATER; + } + if (problem) { p->num_illegal_blocks++; + /* + * A bit of subterfuge here -- we're trying to fix a block + * mapping, but the IND/DIND/TIND block could have collided + * with some critical metadata. So, fix the in-core mapping so + * iterate won't go insane, but return 0 instead of + * BLOCK_CHANGED so that it won't write the remapping out to + * our multiply linked block. + * + * Even if we previously determined that an *IND block + * conflicts with critical metadata, we must still try to + * iterate the *IND block as if it is an *IND block to find and + * mark the blocks it points to. Better to be overly cautious + * with the used_blocks map so that we don't move the *IND + * block to a block that's really in use! + */ + if (p->ino != EXT2_RESIZE_INO && + ref_block != 0 && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, + ref_block)) { + *block_nr = 0; + return 0; + } if (!p->suppress && (p->num_illegal_blocks % 12) == 0) { if (fix_problem(ctx, PR_1_TOO_MANY_BAD_BLOCKS, pctx)) { p->clear = 1; @@ -2469,6 +3481,18 @@ static int process_block(ext2_filsys fs, if (fix_problem(ctx, problem, pctx)) { blk = *block_nr = 0; ret_code = BLOCK_CHANGED; + p->inode_modified = 1; + /* + * If the directory block is too big and is beyond the + * end of the FS, don't bother trying to add it for + * processing -- the kernel would never have created a + * directory this large, and we risk an ENOMEM abort. + * In any case, the toobig handler for extent-based + * directories also doesn't feed toobig blocks to + * pass 2. + */ + if (problem == PR_1_TOOBIG_DIR) + return ret_code; goto mark_dir; } else return 0; @@ -2493,6 +3517,13 @@ static int process_block(ext2_filsys fs, ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { mark_block_used(ctx, blk); p->num_blocks++; + } else if (has_unaligned_cluster_map(ctx, p->previous_block, + p->last_block, blk, blockcnt)) { + pctx->blk = blockcnt; + pctx->blk2 = blk; + fix_problem(ctx, PR_1_MISALIGNED_CLUSTER, pctx); + mark_block_used(ctx, blk); + mark_block_used(ctx, blk); } if (blockcnt >= 0) p->last_block = blockcnt; @@ -2538,11 +3569,6 @@ static int process_bad_block(ext2_filsys fs, struct problem_context *pctx; e2fsck_t ctx; - /* - * Note: This function processes blocks for the bad blocks - * inode, which is never compressed. So we don't use HOLE_BLKADDR(). - */ - if (!blk) return 0; @@ -2712,16 +3738,15 @@ static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group, * within the flex_bg, and if that fails then try finding the * space anywhere in the filesystem. */ - is_flexbg = EXT2_HAS_INCOMPAT_FEATURE(fs->super, - EXT4_FEATURE_INCOMPAT_FLEX_BG); + is_flexbg = ext2fs_has_feature_flex_bg(fs->super); if (is_flexbg) { flexbg_size = 1 << fs->super->s_log_groups_per_flex; flexbg = group / flexbg_size; first_block = ext2fs_group_first_block2(fs, flexbg_size * flexbg); last_grp = group | (flexbg_size - 1); - if (last_grp > fs->group_desc_count) - last_grp = fs->group_desc_count; + if (last_grp >= fs->group_desc_count) + last_grp = fs->group_desc_count - 1; last_block = ext2fs_group_last_block2(fs, last_grp); } else last_block = ext2fs_group_last_block2(fs, group); @@ -2761,12 +3786,15 @@ static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group, old_block + i, 1, buf); if (pctx.errcode) fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); - } else - memset(buf, 0, fs->blocksize); + pctx.blk = (*new_block) + i; + pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, + 1, buf); + } else { + pctx.blk = (*new_block) + i; + pctx.errcode = ext2fs_zero_blocks2(fs, pctx.blk, 1, + NULL, NULL); + } - pctx.blk = (*new_block) + i; - pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, - 1, buf); if (pctx.errcode) fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); } @@ -2832,6 +3860,7 @@ static void mark_table_blocks(e2fsck_t ctx) pctx.group = i; ext2fs_reserve_super_and_bgd(fs, i, ctx->block_found_map); + ext2fs_reserve_super_and_bgd(fs, i, ctx->block_metadata_map); /* * Mark the blocks used for the inode table @@ -2850,8 +3879,10 @@ static void mark_table_blocks(e2fsck_t ctx) ctx->invalid_bitmaps++; } } else { - ext2fs_mark_block_bitmap2(ctx->block_found_map, - b); + ext2fs_mark_block_bitmap2( + ctx->block_found_map, b); + ext2fs_mark_block_bitmap2( + ctx->block_metadata_map, b); } } } @@ -2870,8 +3901,9 @@ static void mark_table_blocks(e2fsck_t ctx) } else { ext2fs_mark_block_bitmap2(ctx->block_found_map, ext2fs_block_bitmap_loc(fs, i)); - } - + ext2fs_mark_block_bitmap2(ctx->block_metadata_map, + ext2fs_block_bitmap_loc(fs, i)); + } } /* * Mark block used for the inode bitmap @@ -2885,6 +3917,8 @@ static void mark_table_blocks(e2fsck_t ctx) ctx->invalid_bitmaps++; } } else { + ext2fs_mark_block_bitmap2(ctx->block_metadata_map, + ext2fs_inode_bitmap_loc(fs, i)); ext2fs_mark_block_bitmap2(ctx->block_found_map, ext2fs_inode_bitmap_loc(fs, i)); } @@ -2969,7 +4003,7 @@ static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, return retval; } - retval = ext2fs_new_block2(fs, goal, 0, &new_block); + retval = ext2fs_new_block2(fs, goal, fs->block_map, &new_block); if (retval) return retval; } @@ -2978,10 +4012,37 @@ static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, return (0); } +static errcode_t e2fsck_new_range(ext2_filsys fs, int flags, blk64_t goal, + blk64_t len, blk64_t *pblk, blk64_t *plen) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + errcode_t retval; + + if (ctx->block_found_map) + return ext2fs_new_range(fs, flags, goal, len, + ctx->block_found_map, pblk, plen); + + if (!fs->block_map) { + retval = ext2fs_read_block_bitmap(fs); + if (retval) + return retval; + } + + return ext2fs_new_range(fs, flags, goal, len, fs->block_map, + pblk, plen); +} + static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) { e2fsck_t ctx = (e2fsck_t) fs->priv_data; + /* Never free a critical metadata block */ + if (ctx->block_found_map && + ctx->block_metadata_map && + inuse < 0 && + ext2fs_test_block_bitmap2(ctx->block_metadata_map, blk)) + return; + if (ctx->block_found_map) { if (inuse > 0) ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); @@ -2990,6 +4051,28 @@ static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) } } +static void e2fsck_block_alloc_stats_range(ext2_filsys fs, blk64_t blk, + blk_t num, int inuse) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + /* Never free a critical metadata block */ + if (ctx->block_found_map && + ctx->block_metadata_map && + inuse < 0 && + ext2fs_test_block_bitmap_range2(ctx->block_metadata_map, blk, num)) + return; + + if (ctx->block_found_map) { + if (inuse > 0) + ext2fs_mark_block_bitmap_range2(ctx->block_found_map, + blk, num); + else + ext2fs_unmark_block_bitmap_range2(ctx->block_found_map, + blk, num); + } +} + void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) { ext2_filsys fs = ctx->fs; @@ -3000,11 +4083,6 @@ void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) fs->read_inode = pass1_read_inode; fs->write_inode = pass1_write_inode; ctx->stashed_ino = 0; - ext2fs_set_alloc_block_callback(fs, e2fsck_get_alloc_block, - 0); - ext2fs_set_block_alloc_stats_callback(fs, - e2fsck_block_alloc_stats, - 0); } else { fs->get_blocks = 0; fs->check_directory = 0; @@ -3012,3 +4090,13 @@ void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) fs->write_inode = 0; } } + +void e2fsck_intercept_block_allocations(e2fsck_t ctx) +{ + ext2fs_set_alloc_block_callback(ctx->fs, e2fsck_get_alloc_block, 0); + ext2fs_set_block_alloc_stats_callback(ctx->fs, + e2fsck_block_alloc_stats, 0); + ext2fs_set_new_range_callback(ctx->fs, e2fsck_new_range, NULL); + ext2fs_set_block_alloc_stats_range_callback(ctx->fs, + e2fsck_block_alloc_stats_range, NULL); +}