e2fsck: fix readahead for pfsck of pass1

Several improvments for this patch:

1) move readahead_kb detection to preparing phase.
2) inode readahead should be aware of thread block group
boundary.
3) make readahead_kb aware of multiple threads.

E2fsprogs-commit: 02618b8f69c1ed453b092476cbd0d735206c939d

Change-Id: I2f9d7b8ae5039c0551bb3994f1c7814af257cee5
Signed-off-by: Wang Shilong <wshilong@ddn.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/e2fsck/pass1.c b/e2fsck/pass1.c
index 4274847..f2c67b7 100644 (file)
--- a/e2fsck/pass1.c
+++ b/e2fsck/pass1.c
@@ -1098,16 +1098,20 @@ out:
 static void pass1_readahead(e2fsck_t ctx, dgrp_t *group, ext2_ino_t *next_ino)
 {
        ext2_ino_t inodes_in_group = 0, inodes_per_block, inodes_per_buffer;
-       dgrp_t start = *group, grp;
+       dgrp_t start = *group, grp, grp_end = ctx->fs->group_desc_count;
        blk64_t blocks_to_read = 0;
        errcode_t err = EXT2_ET_INVALID_ARGUMENT;
 
+#ifdef HAVE_PTHREAD
+       if (ctx->fs->fs_num_threads > 1)
+               grp_end = ctx->thread_info.et_group_end;
+#endif
        if (ctx->readahead_kb == 0)
                goto out;
 
        /* Keep iterating groups until we have enough to readahead */
        inodes_per_block = EXT2_INODES_PER_BLOCK(ctx->fs->super);
-       for (grp = start; grp < ctx->fs->group_desc_count; grp++) {
+       for (grp = start; grp < grp_end; grp++) {
                if (ext2fs_bg_flags_test(ctx->fs, grp, EXT2_BG_INODE_UNINIT))
                        continue;
                inodes_in_group = ctx->fs->super->s_inodes_per_group -
@@ -1300,12 +1304,25 @@ static errcode_t e2fsck_pass1_prepare(e2fsck_t ctx)
 {
        struct problem_context pctx;
        ext2_filsys fs = ctx->fs;
+       unsigned long long readahead_kb;
 
        init_ext2_max_sizes();
-#ifdef HAVE_PTHREAD
+#ifdef HAVE_PTHREAD
        e2fsck_pass1_set_thread_num(ctx);
 #endif
+       /* If we can do readahead, figure out how many groups to pull in. */
+       if (!e2fsck_can_readahead(ctx->fs))
+               ctx->readahead_kb = 0;
+       else if (ctx->readahead_kb == ~0ULL)
+               ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs);
 
+#ifdef HAVE_PTHREAD
+       /* don't use more than 1/10 of memory for threads checking */
+       readahead_kb = get_memory_size() / (10 * ctx->fs_num_threads);
+       /* maybe better disable RA if this is too small? */
+       if (ctx->readahead_kb > readahead_kb)
+               ctx->readahead_kb = readahead_kb;
+#endif
        clear_problem_context(&pctx);
        if (!(ctx->options & E2F_OPT_PREEN))
                fix_problem(ctx, PR_1_PASS_HEADER, &pctx);
@@ -1482,13 +1499,7 @@ void e2fsck_pass1_run(e2fsck_t ctx)
        init_resource_track(&rtrack, ctx->fs->io);
        clear_problem_context(&pctx);
 
-       /* If we can do readahead, figure out how many groups to pull in. */
-       if (!e2fsck_can_readahead(ctx->fs))
-               ctx->readahead_kb = 0;
-       else if (ctx->readahead_kb == ~0ULL)
-               ctx->readahead_kb = e2fsck_guess_readahead(ctx->fs);
        pass1_readahead(ctx, &ra_group, &ino_threshold);
-
        if (ext2fs_has_feature_dir_index(fs->super) &&
            !(ctx->options & E2F_OPT_NO)) {
                if (ext2fs_u32_list_create(&ctx->dirs_to_hash, 50))