X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Fpass1.c;h=b13be545baa23fdb4e0ca53553b7ea4f568e0b5e;hb=a5abfe0382729fba2c5fea6aaae486cb8bc98f00;hp=7a887de14ba2362f03919beb2d753bc75ccaca61;hpb=b4a40883385d610c55c11de52002bd8f9c2d790e;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index 7a887de..b13be54 100644 --- a/e2fsck/pass1.c +++ b/e2fsck/pass1.c @@ -68,6 +68,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); @@ -93,6 +94,7 @@ struct process_block_struct { struct problem_context *pctx; ext2fs_block_bitmap fs_meta_blocks; e2fsck_t ctx; + region_t region; }; struct process_inode_block { @@ -176,12 +178,15 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, ext2_extent_handle_t handle; struct ext2_extent_info info; struct ext2fs_extent extent; + int encrypted = 0; if ((inode->i_size_high || inode->i_size == 0) || (inode->i_flags & EXT2_INDEX_FL)) 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)) @@ -203,8 +208,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) || @@ -218,9 +236,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; @@ -230,11 +273,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. */ @@ -265,8 +327,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"); } @@ -275,15 +336,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 */ @@ -291,9 +354,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); @@ -321,6 +403,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); @@ -335,7 +424,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 @@ -344,7 +441,7 @@ 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"); } @@ -408,6 +505,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 @@ -435,11 +533,52 @@ 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)) { + inlinedata_fs = (ctx->fs->super->s_feature_incompat & + EXT4_FEATURE_INCOMPAT_INLINE_DATA); + if (inlinedata_fs && (inode->i_flags & EXT4_INLINE_DATA_FL)) { + size_t size; + __u32 dotdot; + unsigned int rec_len; + 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_len); + 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_len > 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)) @@ -474,7 +613,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, /* read the first block */ ehandler_operation(_("reading directory block")); - retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0); + retval = ext2fs_read_dir_block4(ctx->fs, blk, buf, 0, pctx->ino); ehandler_operation(0); if (retval) return; @@ -483,7 +622,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); if (retval) return; - if (((dirent->name_len & 0xFF) != 1) || + if ((ext2fs_dirent_name_len(dirent) != 1) || (dirent->name[0] != '.') || (dirent->inode != pctx->ino) || (rec_len < 12) || @@ -495,13 +634,14 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, retval = ext2fs_get_rec_len(ctx->fs, dirent, &rec_len); if (retval) return; - if (((dirent->name_len & 0xFF) != 2) || + if ((ext2fs_dirent_name_len(dirent) != 2) || (dirent->name[0] != '.') || (dirent->name[1] != '.') || (rec_len < 12) || (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, @@ -541,6 +681,277 @@ void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags, *ret = 0; } +static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino, + e2fsck_t ctx, + struct problem_context *pctx) +{ + errcode_t retval; + struct ext2_inode_large inode; + + /* + * 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) + return retval; + if (!retval) + return 0; + + /* + * Checksum still doesn't match. That implies that the inode passes + * all the sanity checks, so maybe the checksum is simply corrupt. + * See if the user will go for fixing that. + */ + if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx)) + return 0; + + 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 (!EXT2_HAS_INCOMPAT_FEATURE(fs->super, + EXT3_FEATURE_INCOMPAT_EXTENTS) && + !EXT2_HAS_INCOMPAT_FEATURE(fs->super, + EXT4_FEATURE_INCOMPAT_INLINE_DATA)) + 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 (EXT2_INODE_SIZE(fs->super) > EXT2_GOOD_OLD_INODE_SIZE) + max_inline_ea_size = EXT2_INODE_SIZE(fs->super) - + (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); + } +} + void e2fsck_pass1(e2fsck_t ctx) { int i; @@ -559,13 +970,23 @@ 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 imagic_fs, extent_fs, inlinedata_fs; int low_dtime_check = 1; int inode_size; + 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); @@ -592,6 +1013,8 @@ void e2fsck_pass1(e2fsck_t ctx) imagic_fs = (sb->s_feature_compat & EXT2_FEATURE_COMPAT_IMAGIC_INODES); extent_fs = (sb->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS); + inlinedata_fs = (sb->s_feature_incompat & + EXT4_FEATURE_INCOMPAT_INLINE_DATA); /* * Allocate bitmaps structures @@ -634,6 +1057,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, @@ -690,7 +1122,8 @@ void e2fsck_pass1(e2fsck_t ctx) } block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, "block interate buffer"); - e2fsck_use_inode_shortcuts(ctx, 1); + 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, @@ -701,7 +1134,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; @@ -721,6 +1155,9 @@ void e2fsck_pass1(e2fsck_t ctx) ext2fs_mark_block_bitmap2(ctx->block_found_map, fs->super->s_mmp_block); + /* Set up ctx->lost_and_found if possible */ + (void) e2fsck_get_lost_and_found(ctx, 0); + while (1) { if (ino % (fs->super->s_inodes_per_group * 4) == 1) { if (e2fsck_mmp_update(fs)) @@ -729,17 +1166,52 @@ 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; 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); ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); continue; } - if (pctx.errcode) { + if (pctx.errcode && + 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; @@ -749,6 +1221,16 @@ void e2fsck_pass1(e2fsck_t ctx) pctx.ino = ino; pctx.inode = inode; ctx->stashed_ino = ino; + + /* 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, ino, inode->i_links_count); @@ -760,6 +1242,95 @@ 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)) { + sb->s_feature_incompat |= + EXT4_FEATURE_INCOMPAT_INLINE_DATA; + 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. * @@ -790,6 +1361,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; } } @@ -826,18 +1398,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, @@ -872,6 +1448,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) { /* @@ -897,6 +1474,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) { @@ -908,8 +1486,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 || @@ -921,6 +1501,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 == EXT4_USR_QUOTA_INO) || (ino == EXT4_GRP_QUOTA_INO)) { @@ -935,8 +1516,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 || @@ -948,6 +1531,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; @@ -969,9 +1553,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; } @@ -999,6 +1585,7 @@ void e2fsck_pass1(e2fsck_t ctx) 0 : ctx->now; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } @@ -1013,8 +1600,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; } /* @@ -1031,6 +1620,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; } } @@ -1047,7 +1637,8 @@ 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 & + if ((fs->super->s_creator_os == EXT2_OS_LINUX) && + !(fs->super->s_feature_incompat & EXT4_FEATURE_INCOMPAT_64BIT) && inode->osd2.linux2.l_i_file_acl_high != 0) mark_inode_bad(ctx, ino); @@ -1067,6 +1658,7 @@ void e2fsck_pass1(e2fsck_t ctx) inode->i_flags &= ~EXT2_IMAGIC_FL; e2fsck_write_inode(ctx, ino, inode, "pass1"); + failed_csum = 0; } } } @@ -1084,22 +1676,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++; @@ -1108,25 +1705,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]) @@ -1135,6 +1739,7 @@ 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] || @@ -1145,6 +1750,8 @@ void e2fsck_pass1(e2fsck_t ctx) } else check_blocks(ctx, &pctx, block_buf); + FINISH_INODE_LOOP(ctx, ino, &pctx, failed_csum); + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) goto endit; @@ -1159,6 +1766,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 @@ -1236,9 +1846,16 @@ endit: if (inode) ext2fs_free_mem(&inode); + /* + * The l+f inode may have been cleared, so zap it now and + * later passes will recalculate it if necessary + */ + ctx->lost_and_found = 0; + if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); } +#undef FINISH_INODE_LOOP /* * When the inode_scan routines call this callback at the end of the @@ -1357,6 +1974,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 @@ -1466,7 +2100,8 @@ static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, if ((blk = ea_refcount_intr_next(refcount, &count)) == 0) break; pctx.blk = blk; - pctx.errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); + pctx.errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, + pctx.ino); if (pctx.errcode) { fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); return; @@ -1477,8 +2112,9 @@ static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, pctx.num = should_be; if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { header->h_refcount = should_be; - pctx.errcode = ext2fs_write_ext_attr2(fs, blk, - block_buf); + pctx.errcode = ext2fs_write_ext_attr3(fs, blk, + block_buf, + pctx.ino); if (pctx.errcode) { fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT, &pctx); @@ -1503,6 +2139,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, struct ext2_ext_attr_entry *entry; int count; region_t region = 0; + int failed_csum = 0; blk = ext2fs_file_acl_block(fs, inode); if (blk == 0) @@ -1576,9 +2213,18 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, * validate it */ pctx->blk = blk; - pctx->errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); - if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) + pctx->errcode = ext2fs_read_ext_attr3(fs, blk, block_buf, pctx->ino); + if (pctx->errcode == EXT2_ET_EXT_ATTR_CSUM_INVALID) { + pctx->errcode = 0; + failed_csum = 1; + } 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) && @@ -1594,6 +2240,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); @@ -1658,6 +2307,18 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, } region_free(region); + /* + * We only get here if there was no other errors that were fixed. + * If there was a checksum fail, ask to correct it. + */ + if (failed_csum && + fix_problem(ctx, PR_1_EA_BLOCK_ONLY_CSUM_INVALID, pctx)) { + pctx->errcode = ext2fs_write_ext_attr3(fs, blk, block_buf, + pctx->ino); + if (pctx->errcode) + return 0; + } + count = header->h_refcount - 1; if (count) ea_refcount_store(ctx->refcount, blk, count); @@ -1740,6 +2401,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) @@ -1759,11 +2430,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; @@ -1772,6 +2478,10 @@ 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 = 0; + + if (pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) + failed_csum = 1; pctx->errcode = ext2fs_extent_get_info(ehandle, &info); if (pctx->errcode) @@ -1779,12 +2489,19 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_FIRST_SIB, &extent); - while (!pctx->errcode && info.num_entries-- > 0) { + while ((pctx->errcode == 0 || + pctx->errcode == EXT2_ET_EXTENT_CSUM_INVALID) && + info.num_entries-- > 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; + 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 || extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super)) @@ -1806,12 +2523,28 @@ 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; - if (problem) { + 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 (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)) { if (ctx->invalid_bitmaps) { /* @@ -1854,6 +2587,7 @@ report_problem: pctx->errcode = 0; break; } + failed_csum = 0; continue; } goto next; @@ -1861,13 +2595,33 @@ report_problem: 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 (!next_try_repairs) + return; if (pctx->errcode == EXT2_ET_EXTENT_HEADER_BAD) goto report_problem; return; @@ -1892,7 +2646,8 @@ report_problem: } } 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, @@ -1927,6 +2682,46 @@ report_problem: } 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, @@ -1954,7 +2749,16 @@ report_problem: 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) { @@ -1982,6 +2786,16 @@ report_problem: 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; } @@ -2013,9 +2827,17 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, ctx->extent_depth_count[info.max_depth]++; } + 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; @@ -2024,10 +2846,60 @@ 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); } /* + * 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; +} + +/* * This subroutine is called on each inode to account for all of the * blocks used by that inode. */ @@ -2041,6 +2913,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; @@ -2065,30 +2938,22 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, extent_fs = (ctx->fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS); + inlinedata_fs = (ctx->fs->super->s_feature_incompat & + EXT4_FEATURE_INCOMPAT_INLINE_DATA); - 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. @@ -2098,6 +2963,8 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, "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); @@ -2115,6 +2982,8 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, 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); } } end_problem_latch(ctx, PR_LATCH_BLOCK); @@ -2148,7 +3017,8 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } } - 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--; @@ -2174,7 +3044,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; @@ -2206,12 +3094,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; @@ -2219,11 +3115,12 @@ 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)) || + ((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)))) { pctx->num = pb.num_blocks; if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { inode->i_blocks = pb.num_blocks; @@ -2234,9 +3131,10 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } if (ctx->dirs_to_hash && pb.is_dir && + !(ctx->lost_and_found && ctx->lost_and_found == ino) && !(inode->i_flags & EXT2_INDEX_FL) && ((inode->i_size / fs->blocksize) >= 3)) - ext2fs_u32_list_add(ctx->dirs_to_hash, ino); + e2fsck_rehash_dir_later(ctx, ino); out: if (dirty_inode) @@ -2316,26 +3214,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) @@ -2351,7 +3242,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 = '?'; @@ -2383,8 +3274,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; @@ -2402,6 +3329,17 @@ static int process_block(ext2_filsys fs, 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; @@ -2426,6 +3364,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; @@ -2471,11 +3416,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; @@ -2653,8 +3593,8 @@ static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group, 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); @@ -2694,12 +3634,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); } @@ -2765,6 +3708,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 @@ -2783,8 +3727,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); } } } @@ -2803,8 +3749,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 @@ -2818,6 +3765,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)); } @@ -2902,7 +3851,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; } @@ -2915,6 +3864,13 @@ 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);