X-Git-Url: https://git.whamcloud.com/?a=blobdiff_plain;f=e2fsck%2Fpass1.c;h=c547db0ae5bd8448e3a147592d0778c7deb33813;hb=bad5ce5ca531b65116edfc9c79abc65b1c6ab9ed;hp=c35937f5be3257ef139676778f7acb66901b771d;hpb=e6238d3708d328851bfdff7580d1b8504c7cf2e4;p=tools%2Fe2fsprogs.git diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c index c35937f..c547db0 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; + fragmented:1, compressed:1, bbcheck:1, + inode_modified:1; blk64_t num_blocks; - blk_t max_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; @@ -94,7 +99,7 @@ struct process_block_struct { struct process_inode_block { ext2_ino_t ino; - struct ext2_inode inode; + struct ext2_inode_large inode; }; struct scan_callback_struct { @@ -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; /* @@ -164,73 +169,96 @@ int e2fsck_pass1_check_device_inode(ext2_filsys fs EXT2FS_ATTR((unused)), * Check to make sure a symlink inode is real. Returns 1 if the symlink * checks out, 0 if not. */ -int e2fsck_pass1_check_symlink(ext2_filsys fs, ext2_ino_t ino, - struct ext2_inode *inode, char *buf) +static int check_symlink(e2fsck_t ctx, struct problem_context *pctx, + ext2_ino_t ino, struct ext2_inode *inode, char *buf) { - unsigned int len; - int i; - blk_t blocks; - ext2_extent_handle_t handle; - struct ext2_extent_info info; - struct ext2fs_extent extent; + blk64_t block, num_blocks; + unsigned len, limit; 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_size > fs->blocksize) + num_blocks = ext2fs_inode_data_blocks2(ctx->fs, inode); + if (inode->i_flags & EXT4_EXTENTS_FL) { /* in extent-mapped block */ + struct ext2_extent_info info; + ext2_extent_handle_t handle; + struct ext2fs_extent extent; + + if (inode->i_size > ctx->fs->blocksize) return 0; - if (ext2fs_extent_open2(fs, ino, inode, &handle)) + if (ext2fs_extent_open2(ctx->fs, ino, inode, &handle)) return 0; - i = 0; if (ext2fs_extent_get_info(handle, &info) || (info.num_entries != 1) || - (info.max_depth != 0)) - goto exit_extent; - if (ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) || + (info.max_depth != 0) || + + ext2fs_extent_get(handle, EXT2_EXTENT_ROOT, &extent) || (extent.e_lblk != 0) || - (extent.e_len != 1) || - (extent.e_pblk < fs->super->s_first_data_block) || - (extent.e_pblk >= fs->super->s_blocks_count)) - goto exit_extent; - i = 1; - exit_extent: + (extent.e_len != 1)) { + ext2fs_extent_free(handle); + return 0; + } + + block = extent.e_pblk; + limit = ctx->fs->blocksize; + ext2fs_extent_free(handle); - return i; - } + } else if (num_blocks > 0) { /* in block-mapped block */ + int i; - blocks = ext2fs_inode_data_blocks(fs, inode); - if (blocks) { - if ((inode->i_size >= fs->blocksize) || - (blocks != fs->blocksize >> 9) || - (inode->i_block[0] < fs->super->s_first_data_block) || - (inode->i_block[0] >= fs->super->s_blocks_count)) - return 0; + block = inode->i_block[0]; + limit = ctx->fs->blocksize; for (i = 1; i < EXT2_N_BLOCKS; i++) if (inode->i_block[i]) return 0; + } else { /* inside inode i_block[] */ + block = 0; + limit = sizeof(inode->i_block); + } + + if (inode->i_size >= limit) + return 0; - if (io_channel_read_blk(fs->io, inode->i_block[0], 1, buf)) + if (num_blocks) { + if ((num_blocks != ctx->fs->blocksize >> 9) || /* == 1 block */ + (block < ctx->fs->super->s_first_data_block) || + (block >= ext2fs_blocks_count(ctx->fs->super))) return 0; - len = strnlen(buf, fs->blocksize); - if (len == fs->blocksize) + if (io_channel_read_blk64(ctx->fs->io, block, 1, buf)) return 0; } else { - if (inode->i_size >= sizeof(inode->i_block)) - return 0; + buf = (char *)inode->i_block; + } - len = strnlen((char *)inode->i_block, sizeof(inode->i_block)); - if (len == sizeof(inode->i_block)) - return 0; + len = strnlen(buf, limit); + /* Add missing NUL terminator at end of symlink (LU-1540), + * but only offer to fix this in pass1, not from pass2. */ + if (len > inode->i_size && pctx != NULL && + fix_problem(ctx, PR_1_SYMLINK_NUL, pctx)) { + buf[inode->i_size] = '\0'; + if (num_blocks != 0) { + if (io_channel_write_blk64(ctx->fs->io, block, 1, buf)) + return 0; + } else { + e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); + } + len = inode->i_size; } if (len != inode->i_size) return 0; + return 1; } +int e2fsck_pass1_check_symlink(e2fsck_t ctx, ext2_ino_t ino, + struct ext2_inode *inode, char *buf) +{ + return check_symlink(ctx, NULL, ino, inode, buf); +} + /* * If the immutable (or append-only) flag is set on the inode, offer * to clear it. @@ -241,6 +269,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 +285,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 */ @@ -305,17 +446,27 @@ static void check_ea_in_inode(e2fsck_t ctx, struct problem_context *pctx) /* attribute len eats this space */ remain -= EXT2_EXT_ATTR_SIZE(entry->e_name_len); - /* check value size */ - if (entry->e_value_size == 0 || entry->e_value_size > remain) { - pctx->num = entry->e_value_size; - problem = PR_1_ATTR_VALUE_SIZE; - goto fix; + 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); } - /* 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; + /* 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 +480,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 +506,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 +518,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 +527,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 +582,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 +615,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 */ @@ -454,9 +633,9 @@ static void check_is_really_dir(e2fsck_t ctx, struct problem_context *pctx, not_device++; if (blk < ctx->fs->super->s_first_data_block || - blk >= ctx->fs->super->s_blocks_count || - ext2fs_fast_test_block_bitmap(ctx->block_found_map, - blk)) + blk >= ext2fs_blocks_count(ctx->fs->super) || + ext2fs_fast_test_block_bitmap2(ctx->block_found_map, + blk)) return; /* Invalid block, can't be dir */ } blk = inode->i_block[0]; @@ -472,8 +651,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 +680,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 +689,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 +720,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 +917,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 +946,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 +957,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,20 +996,23 @@ 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; return; } inode_size = EXT2_INODE_SIZE(fs->super); - inode = (struct ext2_inode *) - e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); + inode = e2fsck_allocate_memory(ctx, inode_size, "scratch inode"); - inodes_to_process = (struct process_inode_block *) - e2fsck_allocate_memory(ctx, + inodes_to_process = e2fsck_allocate_memory(ctx, (ctx->process_inode_size * sizeof(struct process_inode_block)), "array of inodes to process"); @@ -650,8 +1022,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 +1040,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,40 +1058,50 @@ 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; + ctx->stashed_inode = (struct ext2_inode_large *)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); ehandler_operation(old_op); if (ctx->flags & E2F_FLAG_SIGNAL_MASK) - return; + goto endit; if (pctx.errcode == EXT2_ET_BAD_BLOCK_IN_INODE_TABLE) { if (!ctx->inode_bb_map) alloc_bb_map(ctx); - ext2fs_mark_inode_bitmap(ctx->inode_bb_map, ino); - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_bb_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); continue; } if (pctx.errcode) { fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx); ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } if (!ino) break; @@ -726,7 +1115,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; } } @@ -758,7 +1147,7 @@ void e2fsck_pass1(e2fsck_t ctx) clear_inode: e2fsck_clear_inode(ctx, ino, inode, 0, "pass1"); if (ino == EXT2_BAD_INO) - ext2fs_mark_inode_bitmap(ctx->inode_used_map, + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); continue; } @@ -788,27 +1177,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,20 +1220,20 @@ 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_bitmap(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); clear_problem_context(&pctx); continue; } else if (ino == EXT2_ROOT_INO) { @@ -855,6 +1256,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, @@ -862,7 +1264,7 @@ void e2fsck_pass1(e2fsck_t ctx) } } } else if (ino == EXT2_JOURNAL_INO) { - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); if (fs->super->s_journal_inum == EXT2_JOURNAL_INO) { if (!LINUX_S_ISREG(inode->i_mode) && fix_problem(ctx, PR_1_JOURNAL_BAD_MODE, @@ -874,7 +1276,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,10 +1286,37 @@ 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_bitmap(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); if (ino == EXT2_BOOT_LOADER_INO) { if (LINUX_S_ISDIR(inode->i_mode)) problem = PR_1_RESERVED_BAD_MODE; @@ -909,6 +1338,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 +1356,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,13 +1392,14 @@ 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"); } } - ext2fs_mark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino); switch (fs->super->s_creator_os) { case EXT2_OS_HURD: frag = inode->osd2.hurd2.h_i_frag; @@ -978,25 +1409,28 @@ 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) alloc_imagic_map(ctx); - ext2fs_mark_inode_bitmap(ctx->inode_imagic_map, + 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,23 +1443,23 @@ 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"); } if (LINUX_S_ISDIR(inode->i_mode)) { - ext2fs_mark_inode_bitmap(ctx->inode_dir_map, ino); + ext2fs_mark_inode_bitmap2(ctx->inode_dir_map, ino); e2fsck_add_dir_info(ctx, ino, 0); ctx->fs_directory_count++; } else if (LINUX_S_ISREG (inode->i_mode)) { - ext2fs_mark_inode_bitmap(ctx->inode_reg_map, ino); + 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)) { @@ -1038,8 +1472,7 @@ void e2fsck_pass1(e2fsck_t ctx) check_size(ctx, &pctx); ctx->fs_blockdev_count++; } else if (LINUX_S_ISLNK (inode->i_mode) && - e2fsck_pass1_check_symlink(fs, ino, inode, - block_buf)) { + check_symlink(ctx, &pctx, ino, inode, block_buf)) { check_immutable(ctx, &pctx); ctx->fs_symlinks_count++; if (ext2fs_inode_data_blocks(fs, inode) == 0) { @@ -1058,8 +1491,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 +1521,46 @@ void e2fsck_pass1(e2fsck_t ctx) (inode->i_block[EXT2_IND_BLOCK] || inode->i_block[EXT2_DIND_BLOCK] || inode->i_block[EXT2_TIND_BLOCK] || - inode->i_file_acl)) { + ext2fs_file_acl_block(fs, inode))) { inodes_to_process[process_inode_count].ino = ino; - inodes_to_process[process_inode_count].inode = *inode; + inodes_to_process[process_inode_count].inode = + *((struct ext2_inode_large *)inode); process_inode_count++; } else check_blocks(ctx, &pctx, block_buf); + if (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,17 +1589,13 @@ 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) { if (!fix_problem(ctx, PR_1_RESIZE_INODE_CREATE, &pctx)) { ctx->flags |= E2F_FLAG_ABORT; - return; + goto endit; } pctx.errcode = 0; } @@ -1140,7 +1606,6 @@ void e2fsck_pass1(e2fsck_t ctx) e2fsck_write_inode(ctx, EXT2_RESIZE_INO, inode, "recreate inode"); } - fs->block_map = save_bmap; ctx->flags &= ~E2F_FLAG_RESIZE_INODE; } @@ -1167,10 +1632,17 @@ 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); + else + ctx->invalid_bitmaps++; } /* @@ -1203,7 +1675,7 @@ static errcode_t scan_callback(ext2_filsys fs, static void process_inodes(e2fsck_t ctx, char *block_buf) { int i; - struct ext2_inode *old_stashed_inode; + struct ext2_inode_large *old_stashed_inode; ext2_ino_t old_stashed_ino; const char *old_operation; char buf[80]; @@ -1221,7 +1693,8 @@ static void process_inodes(e2fsck_t ctx, char *block_buf) sizeof(struct process_inode_block), process_inode_cmp); clear_problem_context(&pctx); for (i=0; i < process_inode_count; i++) { - pctx.inode = ctx->stashed_inode = &inodes_to_process[i].inode; + ctx->stashed_inode = &inodes_to_process[i].inode; + pctx.inode = (struct ext2_inode *)ctx->stashed_inode; pctx.ino = ctx->stashed_ino = inodes_to_process[i].ino; #if 0 @@ -1254,33 +1727,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 = ib_a->inode.i_file_acl - ib_b->inode.i_file_acl; + /* + * 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, (struct ext2_inode *)&(ib_a->inode)) - + ext2fs_file_acl_block(0, (struct ext2_inode *)&(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_bitmap(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); } @@ -1292,9 +1776,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); @@ -1312,9 +1796,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); @@ -1331,17 +1815,18 @@ 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; clear_problem_context(&pctx); - if (ext2fs_fast_test_block_bitmap(ctx->block_found_map, 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, @@ -1351,12 +1836,22 @@ static _INLINE_ void mark_block_used(e2fsck_t ctx, blk_t block) return; } } - ext2fs_fast_mark_block_bitmap(ctx->block_dup_map, block); + ext2fs_fast_mark_block_bitmap2(ctx->block_dup_map, block); } else { - ext2fs_fast_mark_block_bitmap(ctx->block_found_map, block); + ext2fs_fast_mark_block_bitmap2(ctx->block_found_map, 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 @@ -1370,7 +1865,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; @@ -1381,18 +1876,24 @@ 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_ABORT, @@ -1412,14 +1913,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 = inode->i_file_acl; + blk = ext2fs_file_acl_block(fs, inode); if (blk == 0) return 0; @@ -1432,16 +1934,18 @@ 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 >= fs->super->s_blocks_count)) { - mark_inode_bad(ctx, ino); + (blk >= ext2fs_blocks_count(fs->super))) { + /* 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); @@ -1467,7 +1971,7 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, #endif /* Have we seen this EA block before? */ - if (ext2fs_fast_test_block_bitmap(ctx->block_ea_map, blk)) { + if (ext2fs_fast_test_block_bitmap2(ctx->block_ea_map, blk)) { if (ea_refcount_decrement(ctx->refcount, blk, 0) == 0) return 1; /* Ooops, this EA was referenced more than it stated */ @@ -1490,11 +1994,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 = inode->i_file_acl; + 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) && @@ -1538,19 +2042,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; } @@ -1576,13 +2091,13 @@ static int check_ext_attr(e2fsck_t ctx, struct problem_context *pctx, if (count) ea_refcount_store(ctx->refcount, blk, count); mark_block_used(ctx, blk); - ext2fs_fast_mark_block_bitmap(ctx->block_ea_map, blk); + ext2fs_fast_mark_block_bitmap2(ctx->block_ea_map, blk); return 1; clear_extattr: if (region) region_free(region); - inode->i_file_acl = 0; + ext2fs_file_acl_block_set(fs, inode, 0); e2fsck_write_inode(ctx, ino, inode, "check_ext_attr"); return 0; } @@ -1595,32 +2110,38 @@ 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 >= fs->super->s_blocks_count)) { + (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 return 0; } - retval = io_channel_read_blk(fs->io, blk, 1, block_buf); - if (retval && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) - return 1; + retval = io_channel_read_blk64(fs->io, blk, 1, block_buf); + 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); + root = get_ext2_dx_root_info(fs, block_buf); if ((root->reserved_zero || root->info_length < 8) && fix_problem(ctx, PR_1_HTREE_BADROOT, pctx)) @@ -1654,12 +2175,12 @@ 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; - ext2fs_unmark_inode_bitmap(ctx->inode_dir_map, ino); - ext2fs_unmark_inode_bitmap(ctx->inode_used_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_dir_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_used_map, ino); if (ctx->inode_reg_map) - ext2fs_unmark_inode_bitmap(ctx->inode_reg_map, ino); - if (ctx->inode_bad_map) - ext2fs_unmark_inode_bitmap(ctx->inode_bad_map, ino); + ext2fs_unmark_inode_bitmap2(ctx->inode_reg_map, ino); + if (ctx->inode_badness) + ext2fs_icount_store(ctx->inode_badness, ino, 0); /* * If the inode was partially accounted for before processing @@ -1667,20 +2188,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); @@ -1692,32 +2251,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 == 0 || extent.e_pblk < ctx->fs->super->s_first_data_block || - extent.e_pblk >= ctx->fs->super->s_blocks_count) + 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) > - ctx->fs->super->s_blocks_count) + 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); @@ -1731,6 +2348,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); @@ -1741,7 +2360,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, @@ -1776,23 +2415,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; @@ -1806,9 +2508,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 = pb->last_block = extent.e_lblk + extent.e_len - 1; + 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, @@ -1827,6 +2531,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) { @@ -1844,7 +2549,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; @@ -1856,15 +2563,6 @@ static void check_blocks_extents(e2fsck_t ctx, struct problem_context *pctx, ext2fs_extent_free(ehandle); } -static blk64_t ext2fs_inode_i_blocks(ext2_filsys fs, - struct ext2_inode *inode) -{ - return (inode->i_blocks | - (fs->super->s_feature_ro_compat & - EXT4_FEATURE_RO_COMPAT_HUGE_FILE ? - (__u64)inode->osd2.linux2.l_i_blocks_hi << 32 : 0)); -} - /* * This subroutine is called on each inode to account for all of the * blocks used by that inode. @@ -1876,7 +2574,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; @@ -1884,6 +2582,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; @@ -1896,6 +2595,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; @@ -1907,6 +2607,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++; @@ -1914,19 +2615,44 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, } } - if (inode->i_file_acl && check_ext_attr(ctx, pctx, block_buf)) { + 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); @@ -1960,6 +2686,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--; @@ -1967,13 +2698,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) { @@ -1991,12 +2729,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]) @@ -2007,44 +2749,34 @@ static void check_blocks(e2fsck_t ctx, struct problem_context *pctx, ((1ULL << (32 + EXT2_BLOCK_SIZE_BITS(fs->super))) - 1)) /* too big for an extent-based file - 32bit ee_block */ bad_size = 6; - - /* - * Check to see if the EOFBLOCKS flag is set where it - * doesn't need to be. - */ - if ((inode->i_flags & EXT4_EOFBLOCKS_FL) && - (size <= (((__u64)pb.last_block + 1) * fs->blocksize))) { - pctx->blkcount = pb.last_block; - if (fix_problem(ctx, PR_1_EOFBLOCKS_FL_SET, pctx)) { - inode->i_flags &= ~EXT4_EOFBLOCKS_FL; - dirty_inode++; - } - } } /* i_size for symlinks is checked elsewhere */ 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; @@ -2065,9 +2797,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]; @@ -2076,8 +2808,8 @@ static char *describe_illegal_block(ext2_filsys fs, blk_t block) if (block < super) { sprintf(problem, "< FIRSTBLOCK (%u)", super); return(problem); - } else if (block >= fs->super->s_blocks_count) { - sprintf(problem, "> BLOCKS (%u)", fs->super->s_blocks_count); + } else if (block >= ext2fs_blocks_count(fs->super)) { + sprintf(problem, "> BLOCKS (%u)", ext2fs_blocks_count(fs->super)); return(problem); } for (i = 0; i < fs->group_desc_count; i++) { @@ -2091,16 +2823,16 @@ static char *describe_illegal_block(ext2_filsys fs, blk_t block) "of group %d", i); break; } - if (block == fs->group_desc[i].bg_block_bitmap) { + if (block == ext2fs_block_bitmap_loc(fs, i)) { sprintf(problem, "is the block bitmap of group %d", i); break; } - if (block == fs->group_desc[i].bg_inode_bitmap) { + if (block == ext2fs_inode_bitmap_loc(fs, i)) { sprintf(problem, "is the inode bitmap of group %d", i); break; } - if (block >= fs->group_desc[i].bg_inode_table && - (block < fs->group_desc[i].bg_inode_table + if (block >= ext2fs_inode_table_loc(fs, i) && + (block < ext2fs_inode_table_loc(fs, i) + fs->inode_blocks_per_group)) { sprintf(problem, "is in the inode table of group %d", i); @@ -2116,17 +2848,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; @@ -2155,6 +2887,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; @@ -2188,7 +2935,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; @@ -2198,8 +2944,10 @@ static int process_block(ext2_filsys fs, problem = PR_1_TOOBIG_SYMLINK; if (blk < fs->super->s_first_data_block || - blk >= fs->super->s_blocks_count) + 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++; @@ -2219,6 +2967,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; @@ -2234,25 +2994,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++; + } 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); - p->num_blocks++; + } 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; @@ -2267,15 +3042,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; @@ -2297,7 +3072,7 @@ static int process_bad_block(ext2_filsys fs, pctx->blkcount = blockcnt; if ((blk < fs->super->s_first_data_block) || - (blk >= fs->super->s_blocks_count)) { + (blk >= ext2fs_blocks_count(fs->super))) { if (fix_problem(ctx, PR_1_BB_ILLEGAL_BLOCK_NUM, pctx)) { *block_nr = 0; return BLOCK_CHANGED; @@ -2306,13 +3081,13 @@ static int process_bad_block(ext2_filsys fs, } if (blockcnt < 0) { - if (ext2fs_test_block_bitmap(p->fs_meta_blocks, blk)) { + if (ext2fs_test_block_bitmap2(p->fs_meta_blocks, blk)) { p->bbcheck = 1; if (fix_problem(ctx, PR_1_BB_FS_BLOCK, pctx)) { *block_nr = 0; return BLOCK_CHANGED; } - } else if (ext2fs_test_block_bitmap(ctx->block_found_map, + } else if (ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) { p->bbcheck = 1; if (fix_problem(ctx, PR_1_BBINODE_BAD_METABLOCK, @@ -2336,8 +3111,8 @@ static int process_bad_block(ext2_filsys fs, * there's an overlap between the filesystem table blocks * (bitmaps and inode table) and the bad block list. */ - if (!ext2fs_test_block_bitmap(ctx->block_found_map, blk)) { - ext2fs_mark_block_bitmap(ctx->block_found_map, blk); + if (!ext2fs_test_block_bitmap2(ctx->block_found_map, blk)) { + ext2fs_mark_block_bitmap2(ctx->block_found_map, blk); return 0; } /* @@ -2378,22 +3153,22 @@ static int process_bad_block(ext2_filsys fs, return 0; } skip_super: - if (blk == fs->group_desc[i].bg_block_bitmap) { + if (blk == ext2fs_block_bitmap_loc(fs, i)) { if (fix_problem(ctx, PR_1_BB_BAD_BLOCK, pctx)) { ctx->invalid_block_bitmap_flag[i]++; ctx->invalid_bitmaps++; } return 0; } - if (blk == fs->group_desc[i].bg_inode_bitmap) { + if (blk == ext2fs_inode_bitmap_loc(fs, i)) { if (fix_problem(ctx, PR_1_IB_BAD_BLOCK, pctx)) { ctx->invalid_inode_bitmap_flag[i]++; ctx->invalid_bitmaps++; } return 0; } - if ((blk >= fs->group_desc[i].bg_inode_table) && - (blk < (fs->group_desc[i].bg_inode_table + + if ((blk >= ext2fs_inode_table_loc(fs, i)) && + (blk < (ext2fs_inode_table_loc(fs, i) + fs->inode_blocks_per_group))) { /* * If there are bad blocks in the inode table, @@ -2430,14 +3205,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, - const char *name, int num, blk_t *new_block) +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; - blk_t old_block = *new_block; - blk_t last_block; - int i, is_flexbg, flexbg, flexbg_size; + blk64_t old_block = *new_block; + blk64_t last_block; + dgrp_t flexbg; + unsigned flexbg_size; + int i, is_flexbg; char *buf; struct problem_context pctx; @@ -2457,21 +3234,21 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, if (is_flexbg) { flexbg_size = 1 << fs->super->s_log_groups_per_flex; flexbg = group / flexbg_size; - first_block = ext2fs_group_first_block(fs, - flexbg_size * flexbg); + 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; - last_block = ext2fs_group_last_block(fs, last_grp); + 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_block(fs, group); - pctx.errcode = ext2fs_get_free_blocks(fs, first_block, last_block, - num, ctx->block_found_map, - new_block); + last_block = ext2fs_group_last_block2(fs, group); + pctx.errcode = ext2fs_get_free_blocks2(fs, first_block, last_block, + num, ctx->block_found_map, + new_block); if (is_flexbg && (pctx.errcode == EXT2_ET_BLOCK_ALLOC_FAIL)) - pctx.errcode = ext2fs_get_free_blocks(fs, + pctx.errcode = ext2fs_get_free_blocks2(fs, fs->super->s_first_data_block, - fs->super->s_blocks_count, + ext2fs_blocks_count(fs->super), num, ctx->block_found_map, new_block); if (pctx.errcode) { pctx.num = num; @@ -2495,9 +3272,9 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, pctx.blk2 = 0; for (i = 0; i < num; i++) { pctx.blk = i; - ext2fs_mark_block_bitmap(ctx->block_found_map, (*new_block)+i); + ext2fs_mark_block_bitmap2(ctx->block_found_map, (*new_block)+i); if (old_block) { - pctx.errcode = io_channel_read_blk(fs->io, + pctx.errcode = io_channel_read_blk64(fs->io, old_block + i, 1, buf); if (pctx.errcode) fix_problem(ctx, PR_1_RELOC_READ_ERR, &pctx); @@ -2505,7 +3282,7 @@ static void new_table_block(e2fsck_t ctx, blk_t first_block, int group, memset(buf, 0, fs->blocksize); pctx.blk = (*new_block) + i; - pctx.errcode = io_channel_write_blk(fs->io, pctx.blk, + pctx.errcode = io_channel_write_blk64(fs->io, pctx.blk, 1, buf); if (pctx.errcode) fix_problem(ctx, PR_1_RELOC_WRITE_ERR, &pctx); @@ -2524,23 +3301,30 @@ static void handle_fs_bad_blocks(e2fsck_t ctx) { ext2_filsys fs = ctx->fs; dgrp_t i; - blk_t first_block; + blk64_t first_block; + blk64_t new_blk; for (i = 0; i < fs->group_desc_count; i++) { - first_block = ext2fs_group_first_block(fs, i); + first_block = ext2fs_group_first_block2(fs, i); if (ctx->invalid_block_bitmap_flag[i]) { + new_blk = ext2fs_block_bitmap_loc(fs, i); new_table_block(ctx, first_block, i, _("block bitmap"), - 1, &fs->group_desc[i].bg_block_bitmap); + 1, &new_blk); + ext2fs_block_bitmap_loc_set(fs, i, new_blk); } if (ctx->invalid_inode_bitmap_flag[i]) { + new_blk = ext2fs_inode_bitmap_loc(fs, i); new_table_block(ctx, first_block, i, _("inode bitmap"), - 1, &fs->group_desc[i].bg_inode_bitmap); + 1, &new_blk); + ext2fs_inode_bitmap_loc_set(fs, i, new_blk); } if (ctx->invalid_inode_table_flag[i]) { + new_blk = ext2fs_inode_table_loc(fs, i); new_table_block(ctx, first_block, i, _("inode table"), fs->inode_blocks_per_group, - &fs->group_desc[i].bg_inode_table); + &new_blk); + ext2fs_inode_table_loc_set(fs, i, new_blk); ctx->flags |= E2F_FLAG_RESTART; } } @@ -2554,9 +3338,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); @@ -2569,11 +3353,11 @@ static void mark_table_blocks(e2fsck_t ctx) /* * Mark the blocks used for the inode table */ - if (fs->group_desc[i].bg_inode_table) { - for (j = 0, b = fs->group_desc[i].bg_inode_table; + if (ext2fs_inode_table_loc(fs, i)) { + for (j = 0, b = ext2fs_inode_table_loc(fs, i); j < fs->inode_blocks_per_group; j++, b++) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, + if (ext2fs_test_block_bitmap2(ctx->block_found_map, b)) { pctx.blk = b; if (!ctx->invalid_inode_table_flag[i] && @@ -2583,7 +3367,7 @@ static void mark_table_blocks(e2fsck_t ctx) ctx->invalid_bitmaps++; } } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, + ext2fs_mark_block_bitmap2(ctx->block_found_map, b); } } @@ -2592,34 +3376,34 @@ static void mark_table_blocks(e2fsck_t ctx) /* * Mark block used for the block bitmap */ - if (fs->group_desc[i].bg_block_bitmap) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap)) { - pctx.blk = fs->group_desc[i].bg_block_bitmap; + if (ext2fs_block_bitmap_loc(fs, i)) { + if (ext2fs_test_block_bitmap2(ctx->block_found_map, + ext2fs_block_bitmap_loc(fs, i))) { + pctx.blk = ext2fs_block_bitmap_loc(fs, i); if (fix_problem(ctx, PR_1_BB_CONFLICT, &pctx)) { ctx->invalid_block_bitmap_flag[i]++; ctx->invalid_bitmaps++; } } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_block_bitmap); + ext2fs_mark_block_bitmap2(ctx->block_found_map, + ext2fs_block_bitmap_loc(fs, i)); } } /* * Mark block used for the inode bitmap */ - if (fs->group_desc[i].bg_inode_bitmap) { - if (ext2fs_test_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap)) { - pctx.blk = fs->group_desc[i].bg_inode_bitmap; + if (ext2fs_inode_bitmap_loc(fs, i)) { + if (ext2fs_test_block_bitmap2(ctx->block_found_map, + ext2fs_inode_bitmap_loc(fs, i))) { + pctx.blk = ext2fs_inode_bitmap_loc(fs, i); if (fix_problem(ctx, PR_1_IB_CONFLICT, &pctx)) { ctx->invalid_inode_bitmap_flag[i]++; ctx->invalid_bitmaps++; } } else { - ext2fs_mark_block_bitmap(ctx->block_found_map, - fs->group_desc[i].bg_inode_bitmap); + ext2fs_mark_block_bitmap2(ctx->block_found_map, + ext2fs_inode_bitmap_loc(fs, i)); } } } @@ -2652,7 +3436,7 @@ static errcode_t pass1_read_inode(ext2_filsys fs, ext2_ino_t ino, if ((ino != ctx->stashed_ino) || !ctx->stashed_inode) return EXT2_ET_CALLBACK_NOTHANDLED; - *inode = *ctx->stashed_inode; + *inode = *(struct ext2_inode *)ctx->stashed_inode; return 0; } @@ -2662,8 +3446,8 @@ static errcode_t pass1_write_inode(ext2_filsys fs, ext2_ino_t ino, e2fsck_t ctx = (e2fsck_t) fs->priv_data; if ((ino == ctx->stashed_ino) && ctx->stashed_inode && - (inode != ctx->stashed_inode)) - *ctx->stashed_inode = *inode; + (inode != (struct ext2_inode *)ctx->stashed_inode)) + *(struct ext2_inode *)ctx->stashed_inode = *inode; return EXT2_ET_CALLBACK_NOTHANDLED; } @@ -2684,15 +3468,15 @@ static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, { e2fsck_t ctx = (e2fsck_t) fs->priv_data; errcode_t retval; - blk_t new_block; + blk64_t new_block; if (ctx->block_found_map) { - retval = ext2fs_new_block(fs, (blk_t) goal, - ctx->block_found_map, &new_block); + retval = ext2fs_new_block2(fs, goal, ctx->block_found_map, + &new_block); if (retval) return retval; if (fs->block_map) { - ext2fs_mark_block_bitmap(fs->block_map, new_block); + ext2fs_mark_block_bitmap2(fs->block_map, new_block); ext2fs_mark_bb_dirty(fs); } } else { @@ -2702,7 +3486,7 @@ static errcode_t e2fsck_get_alloc_block(ext2_filsys fs, blk64_t goal, return retval; } - retval = ext2fs_new_block(fs, (blk_t) goal, 0, &new_block); + retval = ext2fs_new_block2(fs, goal, 0, &new_block); if (retval) return retval; } @@ -2711,35 +3495,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_bitmap(ctx->block_found_map, - (blk_t) blk); - else - ext2fs_unmark_block_bitmap(ctx->block_found_map, - (blk_t) 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; @@ -2747,3 +3512,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); +}