X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Fpass1.c;h=e1d5c02218ea8afebf61e07f292cfe96fb18a392;hb=c29d5b3cce7e6d106fcf370b827beadf47ba56bb;hp=130b3f699967b9dd3e5ba45c1ee6c52f96f1e9f5;hpb=c5b23f6c0e17503630455fb16d1b2035f844acc9;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index 130b3f6..e1d5c02 100644 --- a/e2fsck/pass1.c +++ b/e2fsck/pass1.c @@ -20,12 +20,15 @@ * - A bitmap of which inodes are in use. (inode_used_map) * - A bitmap of which inodes are directories. (inode_dir_map) * - A bitmap of which inodes are regular files. (inode_reg_map) - * - A bitmap of which inodes have bad fields. (inode_bad_map) + * - An icount mechanism is used to keep track of + * inodes with bad fields and its badness (ctx->inode_badness) * - A bitmap of which inodes are in bad blocks. (inode_bb_map) * - A bitmap of which inodes are imagic inodes. (inode_imagic_map) + * - A bitmap of which inodes need to be expanded (expand_eisize_map) * - A bitmap of which blocks are in use. (block_found_map) * - A bitmap of which blocks are in use by two inodes (block_dup_map) * - The data blocks of the directory inodes. (dir_map) + * - A bitmap of EA inodes. (inode_ea_map) * * Pass 1 is designed to stash away enough information so that the * other passes should not need to read in the inode information @@ -38,6 +41,7 @@ */ #define _GNU_SOURCE 1 /* get strnlen() */ +#include "config.h" #include #include #ifdef HAVE_ERRNO_H @@ -55,18 +59,17 @@ #define _INLINE_ inline #endif -static int process_block(ext2_filsys fs, blk_t *blocknr, - e2_blkcnt_t blockcnt, blk_t ref_blk, +static int process_block(ext2_filsys fs, blk64_t *blocknr, + e2_blkcnt_t blockcnt, blk64_t ref_blk, int ref_offset, void *priv_data); -static int process_bad_block(ext2_filsys fs, blk_t *block_nr, - e2_blkcnt_t blockcnt, blk_t ref_blk, +static int process_bad_block(ext2_filsys fs, blk64_t *block_nr, + e2_blkcnt_t blockcnt, blk64_t ref_blk, int ref_offset, void *priv_data); static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, char *block_buf); 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 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); @@ -74,18 +77,20 @@ static errcode_t scan_callback(ext2_filsys fs, ext2_inode_scan scan, dgrp_t group, void * priv_data); static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, char *block_buf, int adjust_sign); -/* static char *describe_illegal_block(ext2_filsys fs, blk_t block); */ +/* static char *describe_illegal_block(ext2_filsys fs, blk64_t block); */ 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; - blk_t num_blocks; - blk_t max_blocks; + fragmented:1, compressed:1, bbcheck:1, + inode_modified:1; + blk64_t num_blocks; + blk64_t max_blocks; e2_blkcnt_t last_block; + e2_blkcnt_t last_init_lblock; e2_blkcnt_t last_db_block; int num_illegal_blocks; - blk_t previous_block; + blk64_t previous_block; struct ext2_inode *inode; struct problem_context *pctx; ext2fs_block_bitmap fs_meta_blocks; @@ -138,7 +143,7 @@ int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)), * If the index flag is set, then this is a bogus * device/fifo/socket */ - if (inode->i_flags & EXT2_INDEX_FL) + if (inode->i_flags & (EXT2_INDEX_FL | EXT4_EXTENTS_FL)) return 0; /* @@ -169,7 +174,7 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, { unsigned int len; int i; - blk_t blocks; + blk64_t blocks; ext2_extent_handle_t handle; struct ext2_extent_info info; struct ext2fs_extent extent; @@ -200,7 +205,7 @@ int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, return i; } - blocks = ext2fs_inode_data_blocks(fs, inode); + blocks = ext2fs_inode_data_blocks2(fs, inode); if (blocks) { if ((inode->i_size >= fs->blocksize) || (blocks != fs->blocksize >> 9) || @@ -241,6 +246,7 @@ static void check_immutable(e2fsck_t ctx, struct problem_context *pctx) if (!(pctx->inode->i_flags & BAD_SPECIAL_FLAGS)) return; + e2fsck_mark_inode_bad(ctx, pctx->ino, BADNESS_NORMAL); if (!fix_problem(ctx, PR_1_SET_IMMUTABLE, pctx)) return; @@ -256,33 +262,145 @@ static void check_size(e2fsck_t ctx, struct problem_context *pctx) { struct ext2_inode *inode = pctx->inode; - if ((inode->i_size == 0) && (inode->i_size_high == 0)) + if (EXT2_I_SIZE(inode) == 0) return; + e2fsck_mark_inode_bad(ctx, pctx->ino, BADNESS_NORMAL); 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"); } +static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) +{ + e2fsck_t ctx = (e2fsck_t) fs->priv_data; + + if (ctx->block_found_map) { + if (inuse > 0) + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); + else + ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk); + } +} + +static void mark_inode_ea_map(e2fsck_t ctx, struct problem_context *pctx, + ext2_ino_t ino) +{ + if (!ctx->inode_ea_map) { + pctx->errcode = ext2fs_allocate_inode_bitmap(ctx->fs, + _("EA inode map"), + &ctx->inode_ea_map); + if (pctx->errcode) { + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, + pctx); + exit(1); + } + } + + ext2fs_mark_inode_bitmap2(ctx->inode_ea_map, ino); +} + +/* + * Delete an EA entry. If this is the last entry to be deleted, then i_file_acl + * must have been freed, so we must update e2fsck block statistics and set + * i_file_acl_deleted. + * When we delete the entry successfully, this function returns 0, else + * non-zero value. + */ + +static int e2fsck_ea_entry_delete(e2fsck_t ctx, + struct ext2_ext_attr_entry *entry, + struct problem_context *pctx, + int *i_file_acl_deleted, problem_t prob) +{ + blk_t i_file_acl = pctx->inode->i_file_acl; + int err = 1; + + pctx->num = entry->e_value_inum; + + if (fix_problem(ctx, prob, pctx)) { + /* Delete corrupt EA entry */ + err = ext2fs_attr_set(ctx->fs, pctx->ino, pctx->inode, + entry->e_name_index, entry->e_name, + 0, 0, 0); + if (err == 0) { + if (i_file_acl && pctx->inode->i_file_acl == 0) { + e2fsck_block_alloc_stats(ctx->fs, i_file_acl, + -1); + *i_file_acl_deleted = 1; + } + return 0; + } + } + + return err; +} + +/* + * Check validity of EA inode. Return 0 if EA inode is valid, nonzero otherwise. + */ +static int check_large_ea_inode(e2fsck_t ctx, struct ext2_ext_attr_entry *entry, + struct problem_context *pctx, + int *i_file_acl_deleted) +{ + struct ext2_inode inode; + int ret = 0; + + /* Check if inode is within valid range */ + if ((entry->e_value_inum < EXT2_FIRST_INODE(ctx->fs->super)) || + (entry->e_value_inum > ctx->fs->super->s_inodes_count)) { + ret = e2fsck_ea_entry_delete(ctx, entry, pctx, + i_file_acl_deleted, + PR_1_ATTR_VALUE_EA_INODE); + /* If user refuses to delete this entry, caller may try to set + * the bit for this out-of-bound inode in inode_ea_map, so + * always return failure */ + return 1; + } + + e2fsck_read_inode(ctx, entry->e_value_inum, &inode, "pass1"); + if (!(inode.i_flags & EXT4_EA_INODE_FL)) { + /* If EXT4_EA_INODE_FL flag is not present but back-pointer + * matches then we should set this flag */ + if (inode.i_mtime == pctx->ino && + inode.i_generation == pctx->inode->i_generation && + fix_problem(ctx, PR_1_ATTR_SET_EA_INODE_FL, pctx)) { + inode.i_flags |= EXT4_EA_INODE_FL; + ext2fs_write_inode(ctx->fs, entry->e_value_inum,&inode); + } else { + ret = e2fsck_ea_entry_delete(ctx, entry, pctx, + i_file_acl_deleted, + PR_1_ATTR_NO_EA_INODE_FL); + goto out; + } + } else if (inode.i_mtime != pctx->ino || + inode.i_generation != pctx->inode->i_generation) { + ret = e2fsck_ea_entry_delete(ctx, entry, pctx, + i_file_acl_deleted, + PR_1_ATTR_INVAL_EA_INODE); + goto out; + } + +out: + return ret; +} + 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, *end; + char *start; unsigned int storage_size, remain; - int problem = 0; + problem_t problem = 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); - end = (char *) inode + EXT2_INODE_SIZE(ctx->fs->super); - entry = (struct ext2_ext_attr_entry *) start; + storage_size = EXT2_INODE_SIZE(ctx->fs->super) - + EXT2_GOOD_OLD_INODE_SIZE - inode->i_extra_isize; + entry = &IHDR(inode)->h_first_entry[0]; + start = (char *)entry; /* scan all entry's headers first */ @@ -306,16 +424,33 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); /* check value size */ - if (entry->e_value_size == 0 || entry->e_value_size > remain) { + if (entry->e_value_size > remain) { pctx->num = entry->e_value_size; problem = PR_1_ATTR_VALUE_SIZE; goto fix; } - /* e_value_block must be 0 in inode's ea */ - if (entry->e_value_block != 0) { - pctx->num = entry->e_value_block; - problem = PR_1_ATTR_VALUE_BLOCK; + if (entry->e_value_inum == 0) { + /* check value size */ + if (entry->e_value_size > remain) { + pctx->num = entry->e_value_size; + problem = PR_1_ATTR_VALUE_SIZE; + goto fix; + } + } else { + int ret, tmp; + + ret = check_large_ea_inode(ctx, entry, pctx, &tmp); + if (ret == 0) + mark_inode_ea_map(ctx, pctx, + entry->e_value_inum); + } + + /* Value size cannot be larger than EA space in inode */ + if (entry->e_value_offs > storage_size || + (entry->e_value_inum == 0 && + entry->e_value_offs + entry->e_value_size > storage_size)) { + problem = PR_1_INODE_EA_BAD_VALUE; goto fix; } @@ -329,7 +464,10 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) goto fix; } - remain -= entry->e_value_size; + /* If EA value is stored in external inode then it does not + * consume space here */ + if (entry->e_value_inum == 0) + remain -= entry->e_value_size; entry = EXT2_EXT_ATTR_NEXT(entry); } @@ -352,7 +490,7 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) struct ext2_super_block *sb = ctx->fs->super; struct ext2_inode_large *inode; __u32 *eamagic; - int min, max; + int min, max, dirty = 0; inode = (struct ext2_inode_large *) pctx->inode; if (EXT2_INODE_SIZE(sb) == EXT2_GOOD_OLD_INODE_SIZE) { @@ -364,8 +502,8 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) printf("inode #%u, i_extra_size %d\n", pctx->ino, inode->i_extra_isize); #endif - /* i_extra_isize must cover i_extra_isize + i_pad1 at least */ - min = sizeof(inode->i_extra_isize) + sizeof(inode->i_pad1); + /* i_extra_isize must cover i_extra_isize + i_checksum_hi at least */ + min = sizeof(inode->i_extra_isize) + sizeof(inode->i_checksum_hi); max = EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE; /* * For now we will allow i_extra_isize to be 0, but really @@ -373,20 +511,46 @@ static void check_inode_extra_space(e2fsck_t ctx, struct problem_context *pctx) */ if (inode->i_extra_isize && (inode->i_extra_isize < min || inode->i_extra_isize > max)) { + e2fsck_mark_inode_bad(ctx, pctx->ino, BADNESS_NORMAL); if (!fix_problem(ctx, PR_1_EXTRA_ISIZE, pctx)) return; - inode->i_extra_isize = min; - e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, - EXT2_INODE_SIZE(sb), "pass1"); - return; + inode->i_extra_isize = ctx->want_extra_isize; + dirty = 1; + + goto out; } - 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 (EXT4_FITS_IN_INODE(inode, inode, i_crtime) && + inode->i_crtime != 0 && + (EXT4_XTIME_FUTURE(ctx, sb, inode->i_crtime, 2*ctx->time_fudge) || + EXT4_XTIME_ANCIENT(ctx, sb, inode->i_crtime, 2*ctx->time_fudge))) { + pctx->num = inode->i_crtime; + if (fix_problem(ctx, PR_1_CRTIME_BAD, pctx)) { + inode->i_crtime = 0; + dirty = 1; + } + e2fsck_mark_inode_bad(ctx, pctx->ino, BADNESS_HIGH); + } + + eamagic = &IHDR(inode)->h_magic; + if (*eamagic != EXT2_EXT_ATTR_MAGIC && + (ctx->flags & E2F_FLAG_EXPAND_EISIZE) && + (inode->i_extra_isize < ctx->want_extra_isize)) { + fix_problem(ctx, PR_1_EXPAND_EISIZE, pctx); + memset((char *)inode + EXT2_GOOD_OLD_INODE_SIZE, 0, + EXT2_INODE_SIZE(sb) - EXT2_GOOD_OLD_INODE_SIZE); + inode->i_extra_isize = ctx->want_extra_isize; + dirty = 1; + if (inode->i_extra_isize < ctx->min_extra_isize) + ctx->min_extra_isize = inode->i_extra_isize; } + + if (*eamagic == EXT2_EXT_ATTR_MAGIC) + check_ea_in_inode(ctx, pctx); +out: + if (dirty) + e2fsck_write_inode_full(ctx, pctx->ino, pctx->inode, + EXT2_INODE_SIZE(sb), "pass1"); } /* @@ -402,10 +566,8 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, { struct ext2_inode *inode = pctx->inode; struct ext2_dir_entry *dirent; - const char *old_op; errcode_t retval; - blk_t blk; - blk64_t first_dir_blk; + blk64_t blk; unsigned int i, rec_len, not_device = 0; int extent_fs; @@ -437,10 +599,11 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, * with it. */ - extent_fs = (ctx->fs->super->s_feature_incompat & EXT3_FEATURE_INCOMPAT_EXTENTS); + extent_fs = (ctx->fs->super->s_feature_incompat & + EXT3_FEATURE_INCOMPAT_EXTENTS); if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) { /* extent mapped */ - if (ext2fs_bmap(ctx->fs, pctx->ino, inode, 0, 0, 0, + if (ext2fs_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0, &blk)) return; /* device files are never extent mapped */ @@ -472,8 +635,8 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, return; /* read the first block */ - old_op = ehandler_operation(_("reading directory block")); - retval = ext2fs_read_dir_block(ctx->fs, blk, buf); + ehandler_operation(_("reading directory block")); + retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0); ehandler_operation(0); if (retval) return; @@ -501,6 +664,7 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, (rec_len % 4)) return; + e2fsck_mark_inode_bad(ctx, pctx->ino, BADNESS_NORMAL); 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, @@ -509,8 +673,8 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, } } -extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags, - ext2_icount_t *ret) +void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags, + ext2_icount_t *ret) { unsigned int threshold; ext2_ino_t num_dirs; @@ -540,15 +704,195 @@ extern void e2fsck_setup_tdb_icount(e2fsck_t ctx, int flags, *ret = 0; } +int e2fsck_pass1_delete_attr(e2fsck_t ctx, struct ext2_inode_large *inode, + struct problem_context *pctx, int needed_size) +{ + struct ext2_ext_attr_header *header; + struct ext2_ext_attr_entry *entry_ino, *entry_blk = NULL, *entry; + char *start, name[4096], block_buf[4096]; + int len, index = EXT2_ATTR_INDEX_USER, entry_size, ea_size; + int in_inode = 1, error; + unsigned int freed_bytes = inode->i_extra_isize; + + entry_ino = &IHDR(inode)->h_first_entry[0]; + start = (char *)entry_ino; + + if (inode->i_file_acl) { + error = ext2fs_read_ext_attr(ctx->fs, inode->i_file_acl, + block_buf); + /* We have already checked this block, shouldn't happen */ + if (error) { + fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, pctx); + return 0; + } + header = BHDR(block_buf); + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { + fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, pctx); + return 0; + } + + entry_blk = (struct ext2_ext_attr_entry *)(header+1); + } + entry = entry_ino; + len = sizeof(entry->e_name); + entry_size = ext2fs_attr_get_next_attr(entry, index, name, len, 1); + + while (freed_bytes < needed_size) { + if (entry_size && name[0] != '\0') { + pctx->str = name; + if (fix_problem(ctx, PR_1_EISIZE_DELETE_EA, pctx)) { + ea_size = EXT2_EXT_ATTR_LEN(entry->e_name_len) + + EXT2_EXT_ATTR_SIZE(entry->e_value_size); + error = ext2fs_attr_set(ctx->fs, pctx->ino, + (struct ext2_inode *)inode, + index, name, 0, 0, 0); + if (!error) + freed_bytes += ea_size; + } + } + len = sizeof(entry->e_name); + entry_size = ext2fs_attr_get_next_attr(entry, index,name,len,0); + entry = EXT2_EXT_ATTR_NEXT(entry); + if (EXT2_EXT_IS_LAST_ENTRY(entry)) { + if (in_inode) { + entry = entry_blk; + len = sizeof(entry->e_name); + entry_size = ext2fs_attr_get_next_attr(entry, + index, name, len, 1); + in_inode = 0; + } else { + index += 1; + in_inode = 1; + if (!entry && index < EXT2_ATTR_INDEX_MAX) + entry = (struct ext2_ext_attr_entry *)start; + else + return freed_bytes; + } + } + } + + return freed_bytes; +} + +int e2fsck_pass1_expand_eisize(e2fsck_t ctx, struct ext2_inode_large *inode, + struct problem_context *pctx) +{ + int needed_size = 0, retval, ret = EXT2_EXPAND_EISIZE_UNSAFE; + static int message; + +retry: + retval = ext2fs_expand_extra_isize(ctx->fs, pctx->ino, inode, + ctx->want_extra_isize, &ret, + &needed_size); + if (ret & EXT2_EXPAND_EISIZE_NEW_BLOCK) + goto mark_expand_eisize_map; + if (!retval) { + e2fsck_write_inode_full(ctx, pctx->ino, + (struct ext2_inode *)inode, + EXT2_INODE_SIZE(ctx->fs->super), + "pass1"); + return 0; + } + + if (ret & EXT2_EXPAND_EISIZE_NOSPC) { + if (ctx->options & (E2F_OPT_PREEN | E2F_OPT_YES)) { + fix_problem(ctx, PR_1_EA_BLK_NOSPC, pctx); + ctx->flags |= E2F_FLAG_ABORT; + return -1; + } + + if (!message) { + pctx->num = ctx->fs->super->s_min_extra_isize; + fix_problem(ctx, PR_1_EXPAND_EISIZE_WARNING, pctx); + message = 1; + } +delete_EA: + retval = e2fsck_pass1_delete_attr(ctx, inode, pctx, + needed_size); + if (retval >= ctx->want_extra_isize) + goto retry; + + needed_size -= retval; + + /* + * We loop here until either the user deletes EA(s) or + * EXTRA_ISIZE feature is disabled. + */ + if (fix_problem(ctx, PR_1_CLEAR_EXTRA_ISIZE, pctx)) { + ctx->fs->super->s_feature_ro_compat &= + ~EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE; + ext2fs_mark_super_dirty(ctx->fs); + } else { + goto delete_EA; + } + ctx->fs_unexpanded_inodes++; + + /* No EA was deleted, inode cannot be expanded */ + return -1; + } + +mark_expand_eisize_map: + if (!ctx->expand_eisize_map) { + pctx->errcode = ext2fs_allocate_inode_bitmap(ctx->fs, + _("expand extrz isize map"), + &ctx->expand_eisize_map); + if (pctx->errcode) { + fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, + pctx); + exit(1); + } + } + + /* Add this inode to the expand_eisize_map */ + ext2fs_mark_inode_bitmap2(ctx->expand_eisize_map, pctx->ino); + return 0; +} + +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; +} + void e2fsck_pass1(e2fsck_t ctx) { int i; __u64 max_sizes; ext2_filsys fs = ctx->fs; - ext2_ino_t ino; - struct ext2_inode *inode; - ext2_inode_scan scan; - char *block_buf; + ext2_ino_t ino = 0; + struct ext2_inode *inode = NULL; + ext2_inode_scan scan = NULL; + char *block_buf = NULL; #ifdef RESOURCE_TRACK struct resource_track rtrack; #endif @@ -557,9 +901,12 @@ void e2fsck_pass1(e2fsck_t ctx) struct scan_callback_struct scan_struct; 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 low_dtime_check = 1; int inode_size; + int inode_exp = 0; + init_resource_track(&rtrack, ctx->fs->io); clear_problem_context(&pctx); @@ -583,7 +930,7 @@ void e2fsck_pass1(e2fsck_t ctx) max_sizes = EXT2_NDIR_BLOCKS + EXT2_BPP(i); max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i); max_sizes = max_sizes + EXT2_BPP(i) * EXT2_BPP(i) * EXT2_BPP(i); - max_sizes = (max_sizes * (1UL << i)) - 1; + max_sizes = (max_sizes * (1UL << i)); ext2_max_sizes[i - EXT2_MIN_BLOCK_LOG_SIZE] = max_sizes; } #undef EXT2_BPP @@ -594,32 +941,38 @@ void e2fsck_pass1(e2fsck_t ctx) /* * Allocate bitmaps structures */ - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, _("in-use inode map"), - &ctx->inode_used_map); + pctx.errcode = e2fsck_allocate_inode_bitmap(fs, _("in-use inode map"), + EXT2FS_BMAP64_RBTREE, + "inode_used_map", + &ctx->inode_used_map); if (pctx.errcode) { pctx.num = 1; fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; return; } - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("directory inode map"), &ctx->inode_dir_map); + pctx.errcode = e2fsck_allocate_inode_bitmap(fs, + _("directory inode map"), + EXT2FS_BMAP64_AUTODIR, + "inode_dir_map", &ctx->inode_dir_map); if (pctx.errcode) { pctx.num = 2; fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; return; } - pctx.errcode = ext2fs_allocate_inode_bitmap(fs, - _("regular file inode map"), &ctx->inode_reg_map); + pctx.errcode = e2fsck_allocate_inode_bitmap(fs, + _("regular file inode map"), EXT2FS_BMAP64_RBTREE, + "inode_reg_map", &ctx->inode_reg_map); if (pctx.errcode) { pctx.num = 6; fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; return; } - pctx.errcode = ext2fs_allocate_block_bitmap(fs, _("in-use block map"), - &ctx->block_found_map); + pctx.errcode = e2fsck_allocate_subcluster_bitmap(fs, + _("in-use block map"), EXT2FS_BMAP64_RBTREE, + "block_found_map", &ctx->block_found_map); if (pctx.errcode) { pctx.num = 1; fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); @@ -627,9 +980,14 @@ void e2fsck_pass1(e2fsck_t ctx) return; } e2fsck_setup_tdb_icount(ctx, 0, &ctx->inode_link_info); - if (!ctx->inode_link_info) + if (!ctx->inode_link_info) { + e2fsck_set_bitmap_type(fs, EXT2FS_BMAP64_RBTREE, + "inode_link_info", &save_type); pctx.errcode = ext2fs_create_icount2(fs, 0, 0, 0, &ctx->inode_link_info); + fs->default_bitmap_type = save_type; + } + if (pctx.errcode) { fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); ctx->flags |= E2F_FLAG_ABORT; @@ -650,8 +1008,7 @@ void e2fsck_pass1(e2fsck_t ctx) if (pctx.errcode) { fix_problem(ctx, PR_1_ALLOCATE_DBCOUNT, &pctx); ctx->flags |= E2F_FLAG_ABORT; - ext2fs_free_mem(&inode); - return; + goto endit; } /* @@ -669,9 +1026,17 @@ void e2fsck_pass1(e2fsck_t ctx) } mark_table_blocks(ctx); + pctx.errcode = ext2fs_convert_subcluster_bitmap(fs, + &ctx->block_found_map); + if (pctx.errcode) { + fix_problem(ctx, PR_1_CONVERT_SUBCLUSTER, &pctx); + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3, "block interate buffer"); 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); @@ -679,23 +1044,33 @@ void e2fsck_pass1(e2fsck_t ctx) if (pctx.errcode) { fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; - ext2fs_free_mem(&block_buf); - ext2fs_free_mem(&inode); - return; + goto endit; } ext2fs_inode_scan_flags(scan, EXT2_SF_SKIP_MISSING_ITABLE, 0); ctx->stashed_inode = inode; scan_struct.ctx = ctx; scan_struct.block_buf = block_buf; ext2fs_set_inode_callback(scan, scan_callback, &scan_struct); - if (ctx->progress) - if ((ctx->progress)(ctx, 1, 0, ctx->fs->group_desc_count)) - return; + if (ctx->progress && ((ctx->progress)(ctx, 1, 0, + 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) && + 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, + fs->super->s_mmp_block); while (1) { + if (ino % (fs->super->s_inodes_per_group * 4) == 1) { + if (e2fsck_mmp_update(fs)) + fatal_error(ctx, 0); + } old_op = ehandler_operation(_("getting next inode from scan")); pctx.errcode = ext2fs_get_next_inode_full(scan, &ino, inode, inode_size); @@ -712,7 +1087,7 @@ void e2fsck_pass1(e2fsck_t ctx) if (pctx.errcode) { fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } if (!ino) break; @@ -726,7 +1101,7 @@ void e2fsck_pass1(e2fsck_t ctx) pctx.num = inode->i_links_count; fix_problem(ctx, PR_1_ICOUNT_STORE, &pctx); ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } } @@ -788,27 +1163,39 @@ void e2fsck_pass1(e2fsck_t ctx) ehp = inode->i_block; #endif if ((ext2fs_extent_header_verify(ehp, - sizeof(inode->i_block)) == 0) && - (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, &pctx))) { - inode->i_flags |= EXT4_EXTENTS_FL; + sizeof(inode->i_block)) == 0)) { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + if (fix_problem(ctx, PR_1_UNSET_EXTENT_FL, + &pctx)) { + inode->i_flags |= EXT4_EXTENTS_FL; #ifdef WORDS_BIGENDIAN - memcpy(inode->i_block, tmp_block, - sizeof(inode->i_block)); + memcpy(inode->i_block, tmp_block, + sizeof(inode->i_block)); #endif - e2fsck_write_inode(ctx, ino, inode, "pass1"); + e2fsck_write_inode(ctx, ino, inode, + "pass1"); + } } } 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) && + 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"); + } + pctx.errcode = ext2fs_copy_bitmap(ctx->block_found_map, &pb.fs_meta_blocks); if (pctx.errcode) { pctx.num = 4; fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } pb.ino = EXT2_BAD_INO; pb.num_blocks = pb.last_block = 0; @@ -819,18 +1206,18 @@ void e2fsck_pass1(e2fsck_t ctx) pb.inode = inode; pb.pctx = &pctx; pb.ctx = ctx; - pctx.errcode = ext2fs_block_iterate2(fs, ino, 0, + pctx.errcode = ext2fs_block_iterate3(fs, ino, 0, block_buf, process_bad_block, &pb); ext2fs_free_block_bitmap(pb.fs_meta_blocks); if (pctx.errcode) { fix_problem(ctx, PR_1_BLOCK_ITERATE, &pctx); ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } if (pb.bbcheck) if (!fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK_PROMPT, &pctx)) { ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); clear_problem_context(&pctx); @@ -855,6 +1242,7 @@ void e2fsck_pass1(e2fsck_t ctx) * as a special case. */ if (inode->i_dtime && inode->i_links_count) { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_ROOT_DTIME, &pctx)) { inode->i_dtime = 0; e2fsck_write_inode(ctx, ino, inode, @@ -874,7 +1262,7 @@ void e2fsck_pass1(e2fsck_t ctx) check_blocks(ctx, &pctx, block_buf); continue; } - if ((inode->i_links_count || inode->i_blocks || + if ((inode->i_links_count || inode->i_blocks || inode->i_block[0]) && fix_problem(ctx, PR_1_JOURNAL_INODE_NOT_CLEAR, &pctx)) { @@ -884,8 +1272,35 @@ void e2fsck_pass1(e2fsck_t ctx) e2fsck_write_inode_full(ctx, ino, inode, inode_size, "pass1"); } + } else if ((ino == EXT4_USR_QUOTA_INO) || + (ino == EXT4_GRP_QUOTA_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 (!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"); + } + check_blocks(ctx, &pctx, block_buf); + continue; + } + if ((inode->i_links_count || + inode->i_blocks || inode->i_block[0]) && + fix_problem(ctx, PR_1_QUOTA_INODE_NOT_CLEAR, + &pctx)) { + memset(inode, 0, inode_size); + ext2fs_icount_store(ctx->inode_link_info, + ino, 0); + e2fsck_write_inode_full(ctx, ino, inode, + inode_size, "pass1"); + } } else if (ino < EXT2_FIRST_INODE(fs->super)) { - int problem = 0; + problem_t problem = 0; ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); if (ino == EXT2_BOOT_LOADER_INO) { @@ -909,6 +1324,7 @@ void e2fsck_pass1(e2fsck_t ctx) check_blocks(ctx, &pctx, block_buf); continue; } + /* * Check for inodes who might have been part of the * orphaned list linked list. They should have gotten @@ -926,7 +1342,7 @@ 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 ? @@ -962,6 +1378,7 @@ void e2fsck_pass1(e2fsck_t ctx) * */ if (inode->i_dtime) { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_SET_DTIME, &pctx)) { inode->i_dtime = 0; e2fsck_write_inode(ctx, ino, inode, "pass1"); @@ -978,18 +1395,20 @@ void e2fsck_pass1(e2fsck_t ctx) frag = fsize = 0; } + /* Fixed in pass2, e2fsck_process_bad_inode(). */ 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 & + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + 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); + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if ((fs->super->s_creator_os == EXT2_OS_LINUX) && !(fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_HUGE_FILE) && (inode->osd2.linux2.l_i_blocks_hi != 0)) - mark_inode_bad(ctx, ino); + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (inode->i_flags & EXT2_IMAGIC_FL) { if (imagic_fs) { if (!ctx->inode_imagic_map) @@ -997,6 +1416,7 @@ void e2fsck_pass1(e2fsck_t ctx) ext2fs_mark_inode_bitmap2(ctx->inode_imagic_map, ino); } else { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_SET_IMAGIC, &pctx)) { inode->i_flags &= ~EXT2_IMAGIC_FL; e2fsck_write_inode(ctx, ino, @@ -1009,12 +1429,12 @@ void e2fsck_pass1(e2fsck_t ctx) check_is_really_dir(ctx, &pctx, block_buf); /* - * ext2fs_inode_has_valid_blocks does not actually look + * ext2fs_inode_has_valid_blocks2 does not actually look * at i_block[] values, so not endian-sensitive here. */ if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL) && LINUX_S_ISLNK(inode->i_mode) && - !ext2fs_inode_has_valid_blocks(inode) && + !ext2fs_inode_has_valid_blocks2(fs, inode) && fix_problem(ctx, PR_1_FAST_SYMLINK_EXTENT_FL, &pctx)) { inode->i_flags &= ~EXT4_EXTENTS_FL; e2fsck_write_inode(ctx, ino, inode, "pass1"); @@ -1058,8 +1478,24 @@ void e2fsck_pass1(e2fsck_t ctx) check_immutable(ctx, &pctx); check_size(ctx, &pctx); ctx->fs_sockets_count++; - } else - mark_inode_bad(ctx, ino); + } else { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + } + + if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_atime, ctx->time_fudge)) + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + else if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_mtime, + ctx->time_fudge)) + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + + if (EXT4_XTIME_FUTURE(ctx, sb, inode->i_ctime, ctx->time_fudge)) + e2fsck_mark_inode_bad(ctx, ino, BADNESS_HIGH); + else if (EXT4_XTIME_ANCIENT(ctx, sb, inode->i_ctime, + ctx->time_fudge)) + e2fsck_mark_inode_bad(ctx, ino, BADNESS_HIGH); + + /* i_crtime is checked in check_inode_extra_space() */ + if (!(inode->i_flags & EXT4_EXTENTS_FL)) { if (inode->i_block[EXT2_IND_BLOCK]) ctx->fs_ind_count++; @@ -1072,25 +1508,45 @@ void e2fsck_pass1(e2fsck_t ctx) (inode->i_block[EXT2_IND_BLOCK] || inode->i_block[EXT2_DIND_BLOCK] || inode->i_block[EXT2_TIND_BLOCK] || - ext2fs_file_acl_block(inode))) { + ext2fs_file_acl_block(fs, inode))) { inodes_to_process[process_inode_count].ino = ino; inodes_to_process[process_inode_count].inode = *inode; process_inode_count++; } else check_blocks(ctx, &pctx, block_buf); + if (ctx->flags & E2F_FLAG_EXPAND_EISIZE) { + struct ext2_inode_large *inode_l; + + inode_l = (struct ext2_inode_large *)inode; + + if (inode_l->i_extra_isize < ctx->want_extra_isize) { + fix_problem(ctx, PR_1_EXPAND_EISIZE, &pctx); + inode_exp = e2fsck_pass1_expand_eisize(ctx, + inode_l, + &pctx); + } + if ((inode_l->i_extra_isize < ctx->min_extra_isize) && + inode_exp == 0) + ctx->min_extra_isize = inode_l->i_extra_isize; + } + if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; + goto endit; if (process_inode_count >= ctx->process_inode_size) { process_inodes(ctx, block_buf); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; + goto endit; } } process_inodes(ctx, block_buf); 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 @@ -1119,24 +1575,23 @@ 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) { - fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx); - /* Should never get here */ - ctx->flags |= E2F_FLAG_ABORT; - return; + if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, + &pctx)) { + ctx->flags |= E2F_FLAG_ABORT; + goto endit; + } + pctx.errcode = 0; + } + if (!pctx.errcode) { + e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, + "recreate inode"); + inode->i_mtime = ctx->now; + e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, + "recreate inode"); } - e2fsck_read_inode(ctx, EXT2_RESIZE_INO, inode, - "recreate inode"); - inode->i_mtime = ctx->now; - e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, - "recreate inode"); - fs->block_map = save_bmap; ctx->flags &= ~E2F_FLAG_RESIZE_INODE; } @@ -1163,10 +1618,15 @@ void e2fsck_pass1(e2fsck_t ctx) endit: e2fsck_use_inode_shortcuts(ctx, 0); - ext2fs_free_mem(&block_buf); - ext2fs_free_mem(&inode); + if (scan) + ext2fs_close_inode_scan(scan); + if (block_buf) + ext2fs_free_mem(&block_buf); + if (inode) + ext2fs_free_mem(&inode); - print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); + if ((ctx->flags & E2F_FLAG_SIGNAL_MASK) == 0) + print_resource_track(ctx, _("Pass 1"), &rtrack, ctx->fs->io); } /* @@ -1250,34 +1710,44 @@ static EXT2_QSORT_TYPE process_inode_cmp(const void *a, const void *b) ret = (ib_a->inode.i_block[EXT2_IND_BLOCK] - ib_b->inode.i_block[EXT2_IND_BLOCK]); if (ret == 0) - ret = ext2fs_file_acl_block(&(ib_a->inode)) - - ext2fs_file_acl_block(&ib_b->inode); + /* + * We only call process_inodes() for non-extent + * 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)); if (ret == 0) ret = ib_a->ino - ib_b->ino; return ret; } /* - * Mark an inode as being bad in some what + * Mark an inode as being bad and increment its badness counter. */ -static void mark_inode_bad(e2fsck_t ctx, ino_t ino) +void e2fsck_mark_inode_bad_loc(e2fsck_t ctx, ino_t ino, int count, + const char *func, const int line) { struct problem_context pctx; + __u16 result; - if (!ctx->inode_bad_map) { + if (!ctx->inode_badness) { clear_problem_context(&pctx); - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("bad inode map"), &ctx->inode_bad_map); + pctx.errcode = ext2fs_create_icount2(ctx->fs, 0, 0, NULL, + &ctx->inode_badness); if (pctx.errcode) { - pctx.num = 3; - fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); - /* Should never get here */ + fix_problem(ctx, PR_1_ALLOCATE_ICOUNT, &pctx); ctx->flags |= E2F_FLAG_ABORT; return; } } - ext2fs_mark_inode_bitmap2(ctx->inode_bad_map, ino); + ext2fs_icount_fetch(ctx->inode_badness, ino, &result); + ext2fs_icount_store(ctx->inode_badness, ino, count + result); + + if (ctx->options & E2F_OPT_DEBUG) + fprintf(stderr, "%s:%d: increase inode %lu badness %u to %u\n", + func, line, (unsigned long)ino, result, count + result); } @@ -1289,9 +1759,9 @@ static void alloc_bb_map(e2fsck_t ctx) struct problem_context pctx; clear_problem_context(&pctx); - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("inode in bad block map"), - &ctx->inode_bb_map); + pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, + _("inode in bad block map"), EXT2FS_BMAP64_RBTREE, + "inode_bb_map", &ctx->inode_bb_map); if (pctx.errcode) { pctx.num = 4; fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); @@ -1309,9 +1779,9 @@ static void alloc_imagic_map(e2fsck_t ctx) struct problem_context pctx; clear_problem_context(&pctx); - pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs, - _("imagic inode map"), - &ctx->inode_imagic_map); + pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs, + _("imagic inode map"), EXT2FS_BMAP64_RBTREE, + "inode_imagic_map", &ctx->inode_imagic_map); if (pctx.errcode) { pctx.num = 5; fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx); @@ -1328,7 +1798,7 @@ static void alloc_imagic_map(e2fsck_t ctx) * WARNING: Assumes checks have already been done to make sure block * is valid. This is true in both process_block and process_bad_block. */ -static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block) +static _INLINE_ void mark_block_used(e2fsck_t ctx, blk64_t block) { struct problem_context pctx; @@ -1336,9 +1806,10 @@ static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block) if (ext2fs_fast_test_block_bitmap2(ctx->block_found_map, block)) { if (!ctx->block_dup_map) { - pctx.errcode = ext2fs_allocate_block_bitmap(ctx->fs, - _("multiply claimed block map"), - &ctx->block_dup_map); + pctx.errcode = e2fsck_allocate_block_bitmap(ctx->fs, + _("multiply claimed block map"), + EXT2FS_BMAP64_RBTREE, "block_dup_map", + &ctx->block_dup_map); if (pctx.errcode) { pctx.num = 3; fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, @@ -1354,6 +1825,16 @@ static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block) } } +static _INLINE_ void mark_blocks_used(e2fsck_t ctx, blk64_t block, + unsigned int num) +{ + if (ext2fs_test_block_bitmap_range2(ctx->block_found_map, block, num)) + ext2fs_mark_block_bitmap_range2(ctx->block_found_map, block, num); + else + while (num--) + mark_block_used(ctx, block++); +} + /* * Adjust the extended attribute block's reference counts at the end * of pass 1, either by subtracting out references for EA blocks that @@ -1367,7 +1848,7 @@ static void adjust_extattr_refcount(e2fsck_t ctx, ext2_refcount_t refcount, struct ext2_ext_attr_header *header; struct problem_context pctx; ext2_filsys fs = ctx->fs; - blk_t blk; + blk64_t blk; __u32 should_be; int count; @@ -1378,21 +1859,28 @@ 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_attr(fs, blk, block_buf); + pctx.errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); + /* We already checked this block, shouldn't happen */ if (pctx.errcode) { fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); return; } - header = (struct ext2_ext_attr_header *) block_buf; + header = BHDR(block_buf); + if (header->h_magic != EXT2_EXT_ATTR_MAGIC) { + fix_problem(ctx, PR_1_EXTATTR_READ_ABORT, &pctx); + return; + } + pctx.blkcount = header->h_refcount; should_be = header->h_refcount + adjust_sign * count; pctx.num = should_be; if (fix_problem(ctx, PR_1_EXTATTR_REFCOUNT, &pctx)) { header->h_refcount = should_be; - pctx.errcode = ext2fs_write_ext_attr(fs, blk, + pctx.errcode = ext2fs_write_ext_attr2(fs, blk, block_buf); if (pctx.errcode) { - fix_problem(ctx, PR_1_EXTATTR_WRITE, &pctx); + fix_problem(ctx, PR_1_EXTATTR_WRITE_ABORT, + &pctx); continue; } } @@ -1408,14 +1896,15 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, ext2_filsys fs = ctx->fs; ext2_ino_t ino = pctx->ino; struct ext2_inode *inode = pctx->inode; - blk_t blk; + blk64_t blk; char * end; struct ext2_ext_attr_header *header; struct ext2_ext_attr_entry *entry; int count; region_t region = 0; + int ret; - blk = ext2fs_file_acl_block(inode); + blk = ext2fs_file_acl_block(fs, inode); if (blk == 0) return 0; @@ -1429,15 +1918,17 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, if (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_EXT_ATTR) || (blk < fs->super->s_first_data_block) || (blk >= ext2fs_blocks_count(fs->super))) { - mark_inode_bad(ctx, ino); + /* Fixed in pass2, e2fsck_process_bad_inode(). */ + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); return 0; } /* If ea bitmap hasn't been allocated, create it */ if (!ctx->block_ea_map) { - pctx->errcode = ext2fs_allocate_block_bitmap(fs, - _("ext attr block map"), - &ctx->block_ea_map); + pctx->errcode = e2fsck_allocate_block_bitmap(fs, + _("ext attr block map"), + EXT2FS_BMAP64_RBTREE, "block_ea_map", + &ctx->block_ea_map); if (pctx->errcode) { pctx->num = 2; fix_problem(ctx, PR_1_ALLOCATE_BBITMAP_ERROR, pctx); @@ -1486,11 +1977,11 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, * validate it */ pctx->blk = blk; - pctx->errcode = ext2fs_read_ext_attr(fs, blk, block_buf); + pctx->errcode = ext2fs_read_ext_attr2(fs, blk, block_buf); if (pctx->errcode && fix_problem(ctx, PR_1_READ_EA_BLOCK, pctx)) goto clear_extattr; - header = (struct ext2_ext_attr_header *) block_buf; - pctx->blk = ext2fs_file_acl_block(inode); + header = BHDR(block_buf); + pctx->blk = ext2fs_file_acl_block(fs, inode); if (((ctx->ext_attr_ver == 1) && (header->h_magic != EXT2_EXT_ATTR_MAGIC_v1)) || ((ctx->ext_attr_ver == 2) && @@ -1506,7 +1997,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, region = region_create(0, fs->blocksize); if (!region) { - fix_problem(ctx, PR_1_EA_ALLOC_REGION, pctx); + fix_problem(ctx, PR_1_EA_ALLOC_REGION_ABORT, pctx); ctx->flags |= E2F_FLAG_ABORT; return 0; } @@ -1534,19 +2025,30 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, goto clear_extattr; break; } - if (entry->e_value_block != 0) { - if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) - goto clear_extattr; - } - if (entry->e_value_offs + entry->e_value_size > fs->blocksize) { - if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) - goto clear_extattr; - break; - } - if (entry->e_value_size && - region_allocate(region, entry->e_value_offs, - EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { - if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, pctx)) + if (entry->e_value_inum == 0) { + if (entry->e_value_offs + entry->e_value_size > + fs->blocksize) { + if (fix_problem(ctx, PR_1_EA_BAD_VALUE, pctx)) + goto clear_extattr; + break; + } + if (entry->e_value_size && + region_allocate(region, entry->e_value_offs, + EXT2_EXT_ATTR_SIZE(entry->e_value_size))) { + if (fix_problem(ctx, PR_1_EA_ALLOC_COLLISION, + pctx)) + goto clear_extattr; + } + } else { + int i_file_acl_deleted = 0; + + ret = check_large_ea_inode(ctx, entry, pctx, + &i_file_acl_deleted); + if (ret == 0) + mark_inode_ea_map(ctx, pctx, + entry->e_value_inum); + + if (i_file_acl_deleted) goto clear_extattr; } @@ -1578,7 +2080,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, clear_extattr: if (region) region_free(region); - ext2fs_file_acl_block_set(inode, 0); + ext2fs_file_acl_block_set(fs, inode, 0); e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); return 0; } @@ -1591,20 +2093,23 @@ static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, struct ext2_dx_root_info *root; ext2_filsys fs = ctx->fs; errcode_t retval; - blk_t blk; + blk64_t blk; 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) && - fix_problem(ctx, PR_1_HTREE_SET, pctx))) - return 1; + (!(fs->super->s_feature_compat & EXT2_FEATURE_COMPAT_DIR_INDEX))) { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + if (fix_problem(ctx, PR_1_HTREE_SET, pctx)) + return 1; + } - pctx->errcode = ext2fs_bmap(fs, ino, inode, 0, 0, 0, &blk); + pctx->errcode = ext2fs_bmap2(fs, ino, inode, 0, 0, 0, 0, &blk); if ((pctx->errcode) || (blk == 0) || (blk < fs->super->s_first_data_block) || (blk >= ext2fs_blocks_count(fs->super))) { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) return 1; else @@ -1612,8 +2117,11 @@ static int handle_htree(e2fsck_t ctx, struct problem_context *pctx, } retval = io_channel_read_blk64(fs->io, blk, 1, block_buf); - if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; + if (retval) { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); + if (fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) + return 1; + } /* XXX should check that beginning matches a directory */ root = (struct ext2_dx_root_info *) (block_buf + 24); @@ -1654,8 +2162,8 @@ void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); if (ctx->inode_reg_map) ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); - if (ctx->inode_bad_map) - ext2fs_unmark_inode_bitmap2(ctx->inode_bad_map, ino); + if (ctx->inode_badness) + ext2fs_icount_store(ctx->inode_badness, ino, 0); /* * If the inode was partially accounted for before processing @@ -1663,20 +2171,58 @@ void e2fsck_clear_inode(e2fsck_t ctx, ext2_ino_t ino, */ ctx->flags |= restart_flag; + if (ino == EXT2_BAD_INO) + memset(inode, 0, sizeof(struct ext2_inode)); + 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 start_block, blk64_t end_block, + blk64_t eof_block, ext2_extent_handle_t ehandle) { struct ext2fs_extent extent; - blk_t blk; + blk64_t blk, last_lblk; e2_blkcnt_t blockcnt; unsigned int i; int is_dir, is_leaf; - errcode_t problem; + problem_t problem; struct ext2_extent_info info; pctx->errcode = ext2fs_extent_get_info(ehandle, &info); @@ -1688,30 +2234,90 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, while (!pctx->errcode && 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; - if (extent.e_pblk < ctx->fs->super->s_first_data_block || + if (extent.e_pblk == 0 || + extent.e_pblk < ctx->fs->super->s_first_data_block || extent.e_pblk >= ext2fs_blocks_count(ctx->fs->super)) problem = PR_1_EXTENT_BAD_START_BLK; else if (extent.e_lblk < start_block) problem = PR_1_OUT_OF_ORDER_EXTENTS; + else if ((end_block && last_lblk > end_block) && + (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT && + last_lblk > eof_block))) + problem = PR_1_EXTENT_END_OUT_OF_BOUNDS; + else if (is_leaf && extent.e_len == 0) + problem = PR_1_EXTENT_LENGTH_ZERO; else if (is_leaf && (extent.e_pblk + extent.e_len) > ext2fs_blocks_count(ctx->fs->super)) problem = PR_1_EXTENT_ENDS_BEYOND; + else if (is_leaf && is_dir && + ((extent.e_lblk + extent.e_len) > + (1 << (21 - ctx->fs->super->s_log_block_size)))) + problem = PR_1_TOOBIG_DIR; + + /* + * Uninitialized blocks in a directory? Clear the flag and + * we'll interpret the blocks later. + */ + if (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; + } if (problem) { - report_problem: + /* To ensure that extent is in inode */ + if (info.curr_level == 0) + e2fsck_mark_inode_bad(ctx, pctx->ino, + BADNESS_HIGH); +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) { + /* + * 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; } + 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); @@ -1725,6 +2331,8 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, } if (!is_leaf) { + blk64_t lblk = extent.e_lblk; + blk = extent.e_pblk; pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_DOWN, &extent); @@ -1735,7 +2343,27 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, goto report_problem; return; } - scan_extent_node(ctx, pctx, pb, extent.e_lblk, ehandle); + /* The next extent should match this index's logical start */ + if (extent.e_lblk != lblk) { + struct ext2_extent_info e_info; + + ext2fs_extent_get_info(ehandle, &e_info); + pctx->blk = lblk; + 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)) { + 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); if (pctx->errcode) return; pctx->errcode = ext2fs_extent_get(ehandle, @@ -1770,23 +2398,86 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, } pb->fragmented = 1; } - while (is_dir && ++pb->last_db_block < extent.e_lblk) { - pctx->errcode = ext2fs_add_dir_block(ctx->fs->dblist, - pb->ino, 0, - pb->last_db_block); + /* + * 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 (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)) & + EXT2FS_CLUSTER_MASK(ctx->fs)) | + (extent.e_lblk & + 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; + } + } +alloc_later: + while (is_dir && (++pb->last_db_block < + (e2_blkcnt_t) extent.e_lblk)) { + pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, + pb->ino, 0, + pb->last_db_block); if (pctx->errcode) { pctx->blk = 0; pctx->num = pb->last_db_block; goto failed_add_dir_block; } } + if (!ctx->fs->cluster_ratio_bits) { + mark_blocks_used(ctx, extent.e_pblk, extent.e_len); + pb->num_blocks += extent.e_len; + } for (blk = extent.e_pblk, blockcnt = extent.e_lblk, i = 0; i < extent.e_len; blk++, blockcnt++, i++) { - mark_block_used(ctx, blk); + if (ctx->fs->cluster_ratio_bits && + !(pb->previous_block && + (EXT2FS_B2C(ctx->fs, blk) == + EXT2FS_B2C(ctx->fs, pb->previous_block)) && + (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == + ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { + 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) { - pctx->errcode = ext2fs_add_dir_block(ctx->fs->dblist, pctx->ino, blk, blockcnt); + pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt); if (pctx->errcode) { pctx->blk = blk; pctx->num = blockcnt; @@ -1800,11 +2491,11 @@ static void scan_extent_node(e2fsck_t ctx, struct problem_context *pctx, } if (is_dir && extent.e_len > 0) pb->last_db_block = blockcnt - 1; - pb->num_blocks += extent.e_len; pb->previous_block = extent.e_pblk + extent.e_len - 1; - start_block = extent.e_lblk + extent.e_len - 1; - if (!(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)) - pb->last_block = start_block; + start_block = pb->last_block = last_lblk; + if (is_leaf && !is_dir && + !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT)) + pb->last_init_lblock = last_lblk; next: pctx->errcode = ext2fs_extent_get(ehandle, EXT2_EXTENT_NEXT_SIB, @@ -1823,6 +2514,7 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, ext2_filsys fs = ctx->fs; ext2_ino_t ino = pctx->ino; errcode_t retval; + blk64_t eof_lblk; pctx->errcode = ext2fs_extent_open2(fs, ino, inode, &ehandle); if (pctx->errcode) { @@ -1840,7 +2532,9 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, ctx->extent_depth_count[info.max_depth]++; } - scan_extent_node(ctx, pctx, pb, 0, ehandle); + 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); if (pctx->errcode && fix_problem(ctx, PR_1_EXTENT_ITERATE_FAILURE, pctx)) { pb->num_blocks = 0; @@ -1863,7 +2557,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, struct process_block_struct pb; ext2_ino_t ino = pctx->ino; struct ext2_inode *inode = pctx->inode; - int bad_size = 0; + unsigned bad_size = 0; int dirty_inode = 0; int extent_fs; __u64 size; @@ -1871,6 +2565,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, pb.ino = ino; pb.num_blocks = 0; pb.last_block = -1; + pb.last_init_lblock = -1; pb.last_db_block = -1; pb.num_illegal_blocks = 0; pb.suppress = 0; pb.clear = 0; @@ -1883,6 +2578,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, pb.inode = inode; pb.pctx = pctx; pb.ctx = ctx; + pb.inode_modified = 0; pctx->ino = ino; pctx->errcode = 0; @@ -1894,6 +2590,7 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, EXT2_FEATURE_INCOMPAT_COMPRESSION) pb.compressed = 1; else { + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_COMPR_SET, pctx)) { inode->i_flags &= ~EXT2_COMPRBLK_FL; dirty_inode++; @@ -1901,20 +2598,44 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } } - if (ext2fs_file_acl_block(inode) && + if (ext2fs_file_acl_block(fs, inode) && check_ext_attr(ctx, pctx, block_buf)) { if (ctx->flags & E2F_FLAG_SIGNAL_MASK) goto out; pb.num_blocks++; } - if (ext2fs_inode_has_valid_blocks(inode)) { + if (ext2fs_inode_has_valid_blocks2(fs, inode)) { if (extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) check_blocks_extents(ctx, pctx, &pb); - else - pctx->errcode = ext2fs_block_iterate2(fs, ino, + else { + /* + * 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; + } + pctx->errcode = ext2fs_block_iterate3(fs, ino, pb.is_dir ? BLOCK_FLAG_HOLE : 0, block_buf, process_block, &pb); + /* + * We do not have uninitialized extents in non extent + * 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"); + } } end_problem_latch(ctx, PR_LATCH_BLOCK); end_problem_latch(ctx, PR_LATCH_TOOBIG); @@ -1948,6 +2669,11 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } if (!pb.num_blocks && pb.is_dir) { + /* + * The mode might be in-correct. Increasing the badness by + * small amount won't hurt much. + */ + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_ZERO_LENGTH_DIR, pctx)) { e2fsck_clear_inode(ctx, ino, inode, 0, "check_blocks"); ctx->fs_directory_count--; @@ -1955,13 +2681,20 @@ 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 (!(fs->super->s_feature_ro_compat & EXT4_FEATURE_RO_COMPAT_HUGE_FILE) || !(inode->i_flags & EXT4_HUGE_FILE_FL)) pb.num_blocks *= (fs->blocksize / 512); + pb.num_blocks *= EXT2FS_CLUSTER_RATIO(fs); #if 0 - printf("inode %u, i_size = %lu, last_block = %lld, i_blocks=%lu, num_blocks = %lu\n", - ino, inode->i_size, pb.last_block, inode->i_blocks, + printf("inode %u, i_size = %u, last_block = %lld, i_blocks=%llu, num_blocks = %llu\n", + ino, inode->i_size, pb.last_block, ext2fs_inode_i_blocks(fs, inode), pb.num_blocks); #endif if (pb.is_dir) { @@ -1979,12 +2712,16 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, e2_blkcnt_t blkpg = ctx->blocks_per_page; size = EXT2_I_SIZE(inode); - if ((pb.last_block >= 0) && - /* allow allocated blocks to end of PAGE_SIZE */ - (size < (__u64)pb.last_block * fs->blocksize) && - (pb.last_block / blkpg * blkpg != pb.last_block || - size < (__u64)(pb.last_block & ~(blkpg-1)) *fs->blocksize) && - !(inode->i_flags & EXT4_EOFBLOCKS_FL)) + if ((pb.last_init_lblock >= 0) && + /* if size is smaller than expected by the block count, + * allow allocated blocks to end of PAGE_SIZE. + * last_init_lblock is the last in-use block, so it is + * the minimum expected file size. */ + (size < (__u64)pb.last_init_lblock * fs->blocksize) && + ((pb.last_init_lblock + 1) / blkpg * blkpg != + (pb.last_init_lblock + 1) || + size < (__u64)(pb.last_init_lblock & ~(blkpg - 1)) * + fs->blocksize)) bad_size = 3; else if (!(extent_fs && (inode->i_flags & EXT4_EXTENTS_FL)) && size > ext2_max_sizes[fs->super->s_log_block_size]) @@ -2000,26 +2737,29 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, if (bad_size && !LINUX_S_ISLNK(inode->i_mode)) { pctx->num = (pb.last_block+1) * fs->blocksize; pctx->group = bad_size; + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); 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); dirty_inode++; } pctx->num = 0; } if (LINUX_S_ISREG(inode->i_mode) && - (inode->i_size_high || inode->i_size & 0x80000000UL)) + 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; + e2fsck_mark_inode_bad(ctx, ino, BADNESS_NORMAL); if (fix_problem(ctx, PR_1_BAD_I_BLOCKS, pctx)) { inode->i_blocks = pb.num_blocks; - inode->osd2.linux2.l_i_blocks_hi = 0; + inode->osd2.linux2.l_i_blocks_hi = pb.num_blocks >> 32; dirty_inode++; } pctx->num = 0; @@ -2040,9 +2780,9 @@ out: * Helper function called by process block when an illegal block is * found. It returns a description about why the block is illegal */ -static char *describe_illegal_block(ext2_filsys fs, blk_t block) +static char *describe_illegal_block(ext2_filsys fs, blk64_t block) { - blk_t super; + blk64_t super; int i; static char problem[80]; @@ -2091,17 +2831,17 @@ static char *describe_illegal_block(ext2_filsys fs, blk_t block) * This is a helper function for check_blocks(). */ static int process_block(ext2_filsys fs, - blk_t *block_nr, + blk64_t *block_nr, e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), + blk64_t ref_block EXT2FS_ATTR((unused)), int ref_offset EXT2FS_ATTR((unused)), void *priv_data) { struct process_block_struct *p; struct problem_context *pctx; - blk_t blk = *block_nr; + blk64_t blk = *block_nr; int ret_code = 0; - int problem = 0; + problem_t problem = 0; e2fsck_t ctx; p = (struct process_block_struct *) priv_data; @@ -2130,6 +2870,21 @@ static int process_block(ext2_filsys fs, 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) return 0; @@ -2163,7 +2918,6 @@ static int process_block(ext2_filsys fs, p->fragmented = 1; } } - p->previous_block = blk; if (p->is_dir && blockcnt > (1 << (21 - fs->super->s_log_block_size))) problem = PR_1_TOOBIG_DIR; @@ -2173,8 +2927,10 @@ static int process_block(ext2_filsys fs, problem = PR_1_TOOBIG_SYMLINK; if (blk < fs->super->s_first_data_block || - blk >= ext2fs_blocks_count(fs->super)) + blk >= ext2fs_blocks_count(fs->super)) { problem = PR_1_ILLEGAL_BLOCK_NUM; + e2fsck_mark_inode_bad(ctx, pctx->ino, BADNESS_NORMAL); + } if (problem) { p->num_illegal_blocks++; @@ -2194,6 +2950,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; @@ -2209,25 +2977,40 @@ static int process_block(ext2_filsys fs, */ if (blockcnt == BLOCK_COUNT_DIND) mark_block_used(ctx, blk); - } else + p->num_blocks++; + } else if (!(ctx->fs->cluster_ratio_bits && + p->previous_block && + (EXT2FS_B2C(ctx->fs, blk) == + EXT2FS_B2C(ctx->fs, p->previous_block)) && + (blk & EXT2FS_CLUSTER_MASK(ctx->fs)) == + ((unsigned) blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) { mark_block_used(ctx, blk); - p->num_blocks++; + 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; + p->previous_block = blk; mark_dir: if (p->is_dir && (blockcnt >= 0)) { while (++p->last_db_block < blockcnt) { - pctx->errcode = ext2fs_add_dir_block(fs->dblist, - p->ino, 0, - p->last_db_block); + pctx->errcode = ext2fs_add_dir_block2(fs->dblist, + p->ino, 0, + p->last_db_block); if (pctx->errcode) { pctx->blk = 0; pctx->num = p->last_db_block; goto failed_add_dir_block; } } - pctx->errcode = ext2fs_add_dir_block(fs->dblist, p->ino, - blk, blockcnt); + pctx->errcode = ext2fs_add_dir_block2(fs->dblist, p->ino, + blk, blockcnt); if (pctx->errcode) { pctx->blk = blk; pctx->num = blockcnt; @@ -2242,15 +3025,15 @@ mark_dir: } static int process_bad_block(ext2_filsys fs, - blk_t *block_nr, + blk64_t *block_nr, e2_blkcnt_t blockcnt, - blk_t ref_block EXT2FS_ATTR((unused)), + blk64_t ref_block EXT2FS_ATTR((unused)), int ref_offset EXT2FS_ATTR((unused)), void *priv_data) { struct process_block_struct *p; - blk_t blk = *block_nr; - blk_t first_block; + blk64_t blk = *block_nr; + blk64_t first_block; dgrp_t i; struct problem_context *pctx; e2fsck_t ctx; @@ -2405,14 +3188,16 @@ static int process_bad_block(ext2_filsys fs, return 0; } -static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, +static void new_table_block(e2fsck_t ctx, blk64_t first_block, dgrp_t group, const char *name, int num, blk64_t *new_block) { ext2_filsys fs = ctx->fs; dgrp_t last_grp; blk64_t old_block = *new_block; blk64_t last_block; - int i, is_flexbg, flexbg, flexbg_size; + dgrp_t flexbg; + unsigned flexbg_size; + int i, is_flexbg; char *buf; struct problem_context pctx; @@ -2435,8 +3220,8 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int 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); @@ -2536,9 +3321,9 @@ static void handle_fs_bad_blocks(e2fsck_t ctx) static void mark_table_blocks(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; - blk_t b; + blk64_t b; dgrp_t i; - int j; + unsigned int j; struct problem_context pctx; clear_problem_context(&pctx); @@ -2693,33 +3478,16 @@ static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, return (0); } -static void e2fsck_block_alloc_stats(ext2_filsys fs, blk64_t blk, int inuse) -{ - e2fsck_t ctx = (e2fsck_t) fs->priv_data; - - if (ctx->block_found_map) { - if (inuse > 0) - ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); - else - ext2fs_unmark_block_bitmap2(ctx->block_found_map, blk); - } -} - -void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool) +void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int use_shortcuts) { ext2_filsys fs = ctx->fs; - if (bool) { + if (use_shortcuts) { fs->get_blocks = pass1_get_blocks; fs->check_directory = pass1_check_directory; 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; @@ -2727,3 +3495,10 @@ void e2fsck_use_inode_shortcuts(e2fsck_t ctx, int bool) 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); +}