*/
#define _GNU_SOURCE 1 /* get strnlen() */
+#include "config.h"
#include <string.h>
#include <time.h>
#ifdef HAVE_ERRNO_H
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;
blk64_t previous_block;
{
struct ext2_inode *inode = pctx->inode;
- if ((inode->i_size == 0) && (inode->i_size_high == 0))
+ if (EXT2_I_SIZE(inode) == 0)
return;
if (!fix_problem(ctx, PR_1_SET_NONZSIZE, 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
{
struct ext2_inode *inode = pctx->inode;
struct ext2_dir_entry *dirent;
- const char *old_op;
errcode_t retval;
- blk64_t blk, first_dir_blk;
+ blk64_t blk;
unsigned int i, rec_len, not_device = 0;
int extent_fs;
* 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_bmap2(ctx->fs, pctx->ino, inode, 0, 0, 0, 0,
return;
/* read the first block */
- old_op = ehandler_operation(_("reading directory block"));
+ ehandler_operation(_("reading directory block"));
retval = ext2fs_read_dir_block3(ctx->fs, blk, buf, 0);
ehandler_operation(0);
if (retval)
*ret = 0;
}
+static errcode_t recheck_bad_inode_checksum(ext2_filsys fs, ext2_ino_t ino,
+ e2fsck_t ctx,
+ struct problem_context *pctx)
+{
+ errcode_t retval;
+ struct ext2_inode_large inode;
+
+ /*
+ * Reread inode. If we don't see checksum error, then this inode
+ * has been fixed elsewhere.
+ */
+ retval = ext2fs_read_inode_full(fs, ino, (struct ext2_inode *)&inode,
+ sizeof(inode));
+ if (retval && retval != EXT2_ET_INODE_CSUM_INVALID)
+ return retval;
+ if (!retval)
+ return 0;
+
+ /*
+ * Checksum still doesn't match. That implies that the inode passes
+ * all the sanity checks, so maybe the checksum is simply corrupt.
+ * See if the user will go for fixing that.
+ */
+ if (!fix_problem(ctx, PR_1_INODE_ONLY_CSUM_INVALID, pctx))
+ return 0;
+
+ retval = ext2fs_write_inode_full(fs, ino, (struct ext2_inode *)&inode,
+ sizeof(inode));
+ if (retval)
+ return retval;
+
+ return 0;
+}
+
void e2fsck_pass1(e2fsck_t ctx)
{
int i;
__u64 max_sizes;
ext2_filsys fs = ctx->fs;
- ext2_ino_t ino;
+ ext2_ino_t ino = 0;
struct ext2_inode *inode;
ext2_inode_scan scan;
char *block_buf;
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 inode_size;
+ int failed_csum = 0;
init_resource_track(&rtrack, ctx->fs->io);
clear_problem_context(&pctx);
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
/*
* 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);
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;
}
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;
+ ext2fs_free_mem(&inode);
+ return;
+ }
block_buf = (char *) e2fsck_allocate_memory(ctx, fs->blocksize * 3,
"block interate buffer");
- e2fsck_use_inode_shortcuts(ctx, 1);
+ if (EXT2_INODE_SIZE(fs->super) == EXT2_GOOD_OLD_INODE_SIZE)
+ e2fsck_use_inode_shortcuts(ctx, 1);
old_op = ehandler_operation(_("opening inode scan"));
pctx.errcode = ext2fs_open_inode_scan(fs, ctx->inode_buffer_blocks,
&scan);
(fs->super->s_mtime < fs->super->s_inodes_count))
busted_fs_time = 1;
+ 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 >= fs->super->s_blocks_count))
+ 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);
ext2fs_mark_inode_bitmap2(ctx->inode_used_map, ino);
continue;
}
- if (pctx.errcode) {
+ if (pctx.errcode &&
+ pctx.errcode != EXT2_ET_INODE_CSUM_INVALID) {
fix_problem(ctx, PR_1_ISCAN_ERROR, &pctx);
ctx->flags |= E2F_FLAG_ABORT;
return;
pctx.ino = ino;
pctx.inode = inode;
ctx->stashed_ino = ino;
+
+ /* Clear corrupt inode? */
+ if (pctx.errcode == EXT2_ET_INODE_CSUM_INVALID) {
+ if (fix_problem(ctx, PR_1_INODE_CSUM_INVALID, &pctx))
+ goto clear_inode;
+ failed_csum = 1;
+ }
+
if (inode->i_links_count) {
pctx.errcode = ext2fs_icount_store(ctx->inode_link_info,
ino, inode->i_links_count);
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) {
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;
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
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");
(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 the inode failed the checksum and the user didn't
+ * clear the inode, test the checksum again -- if it still
+ * fails, ask the user if the checksum should be corrected.
+ */
+ if (failed_csum) {
+ pctx.errcode = recheck_bad_inode_checksum(fs, ino, ctx,
+ &pctx);
+ if (pctx.errcode) {
+ ctx->flags |= E2F_FLAG_ABORT;
+ return;
+ }
+ }
+
if (ctx->flags & E2F_FLAG_SIGNAL_MASK)
return;
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;
if (!ctx->inode_bad_map) {
clear_problem_context(&pctx);
- pctx.errcode = ext2fs_allocate_inode_bitmap(ctx->fs,
- _("bad inode map"), &ctx->inode_bad_map);
+ pctx.errcode = e2fsck_allocate_inode_bitmap(ctx->fs,
+ _("bad inode map"), EXT2FS_BMAP64_RBTREE,
+ "inode_bad_map", &ctx->inode_bad_map);
if (pctx.errcode) {
pctx.num = 3;
fix_problem(ctx, PR_1_ALLOCATE_IBITMAP_ERROR, &pctx);
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);
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);
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,
int count;
region_t region = 0;
- blk = ext2fs_file_acl_block(inode);
+ blk = ext2fs_file_acl_block(fs, inode);
if (blk == 0)
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);
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);
+ 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) &&
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;
}
*/
ctx->flags |= restart_flag;
+ if (ino == EXT2_BAD_INO)
+ memset(inode, 0, sizeof(struct ext2_inode));
+
e2fsck_write_inode(ctx, ino, inode, source);
}
problem = PR_1_EXTENT_BAD_START_BLK;
else if (extent.e_lblk < start_block)
problem = PR_1_OUT_OF_ORDER_EXTENTS;
+ 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))
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)) ==
+ (blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
+ mark_block_used(ctx, blk);
+ pb->num_blocks++;
+ }
+
+ pb->previous_block = blk;
if (is_dir) {
pctx->errcode = ext2fs_add_dir_block2(ctx->fs->dblist, pctx->ino, blk, blockcnt);
}
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;
+ if (is_leaf && !is_dir &&
+ !(extent.e_flags & EXT2_EXTENT_FLAGS_UNINIT))
+ pb->last_init_lblock = extent.e_lblk + extent.e_len - 1;
next:
pctx->errcode = ext2fs_extent_get(ehandle,
EXT2_EXTENT_NEXT_SIB,
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;
}
}
- 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
+ else {
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;
+ }
}
end_problem_latch(ctx, PR_LATCH_BLOCK);
end_problem_latch(ctx, PR_LATCH_TOOBIG);
}
}
+ 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",
+ 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
e2_blkcnt_t blkpg = ctx->blocks_per_page;
size = EXT2_I_SIZE(inode);
- if ((pb.last_block >= 0) &&
+ if ((pb.last_init_lblock >= 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))
+ (size < (__u64)pb.last_init_lblock * fs->blocksize) &&
+ (pb.last_init_lblock / blkpg * blkpg != pb.last_init_lblock ||
+ 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])
((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 = 0;
}
- if (LINUX_S_ISREG(inode->i_mode) &&
- (inode->i_size_high || inode->i_size & 0x80000000UL))
+ if (LINUX_S_ISREG(inode->i_mode) && EXT2_I_SIZE(inode) >= 0x80000000UL)
ctx->large_files++;
if ((pb.num_blocks != ext2fs_inode_i_blocks(fs, inode)) ||
((fs->super->s_feature_ro_compat &
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;
*/
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)) ==
+ (blockcnt & EXT2FS_CLUSTER_MASK(ctx->fs)))) {
mark_block_used(ctx, blk);
- p->num_blocks++;
+ 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) {
}
}
-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;
git://git.whamcloud.com / tools / e2fsprogs.git / blobdiff