Add -m option description to e2fsck.8 man page.
Rename e2fsck_struct fs_num_threads to pfs_num_threads to avoid
confusion with the ext2_filsys fs_num_threads field, and move
thread_info to be together with the other HAVE_PTHREAD fields.
Move ext2_filsys fs_num_threads to fit into the __u16 "pad" field
to avoid consuming one of the few remaining __u32 reserved fields.
Fix a few print format warnings.
E2fsprogs-commit:
afad25acf8c6694c8cea08820fe5af84388a76f3
Change-Id: I5ab49a3ad41f1ebb374669c5d640afa1f3fc35fd
Signed-off-by: Andreas Dilger <adilger@whamcloud.com>
Reviewed-by: Wang Shilong <wshilong@whamcloud.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
option, except the bad blocks list is cleared before the blocks listed
in the file are added to the bad blocks list.)
.TP
option, except the bad blocks list is cleared before the blocks listed
in the file are added to the bad blocks list.)
.TP
+.B \-m " threads"
+Run e2fsck with up to the specified number of
+.IR threads .
+The actual number of threads may be lower, if the filesystem does not
+have enough block groups to effectively parallelize the workload.
+.TP
.B \-n
Open the filesystem read-only, and assume an answer of `no' to all
questions. Allows
.B \-n
Open the filesystem read-only, and assume an answer of `no' to all
questions. Allows
dgrp_t et_group_next;
/* Scanned inode number */
ext2_ino_t et_inode_number;
dgrp_t et_group_next;
/* Scanned inode number */
ext2_ino_t et_inode_number;
ext2_ino_t stashed_ino;
struct ext2_inode *stashed_inode;
ext2_ino_t stashed_ino;
struct ext2_inode *stashed_inode;
- /* if @global_ctx is null, this field is unused */
-#ifdef HAVE_PTHREAD
- struct e2fsck_thread thread_info;
-#endif
-
/*
* Location of the lost and found directory
*/
/*
* Location of the lost and found directory
*/
/* Fast commit replay state */
struct e2fsck_fc_replay_state fc_replay_state;
#ifdef HAVE_PTHREAD
/* Fast commit replay state */
struct e2fsck_fc_replay_state fc_replay_state;
#ifdef HAVE_PTHREAD
+ /* if @global_ctx is null, this field is unused */
+ struct e2fsck_thread thread_info;
+ __u32 pfs_num_threads;
__u32 mmp_update_thread;
int fs_need_locking;
/* serialize fix operation for multiple threads */
__u32 mmp_update_thread;
int fs_need_locking;
/* serialize fix operation for multiple threads */
void check_resize_inode(e2fsck_t ctx);
/* util.c */
void check_resize_inode(e2fsck_t ctx);
/* util.c */
-#define E2FSCK_MAX_THREADS (65536)
+#define E2FSCK_MAX_THREADS (65535)
extern void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned long size,
const char *description);
extern int ask(e2fsck_t ctx, const char * string, int def);
extern void *e2fsck_allocate_memory(e2fsck_t ctx, unsigned long size,
const char *description);
extern int ask(e2fsck_t ctx, const char * string, int def);
{
unsigned flexbg_size = 1;
ext2_filsys fs = ctx->fs;
{
unsigned flexbg_size = 1;
ext2_filsys fs = ctx->fs;
- int num_threads = ctx->fs_num_threads;
+ int num_threads = ctx->pfs_num_threads;
int max_threads;
if (num_threads < 1) {
int max_threads;
if (num_threads < 1) {
max_threads = fs->group_desc_count / flexbg_size;
if (max_threads == 0)
max_threads = 1;
max_threads = fs->group_desc_count / flexbg_size;
if (max_threads == 0)
max_threads = 1;
+ if (max_threads > E2FSCK_MAX_THREADS)
+ max_threads = E2FSCK_MAX_THREADS;
if (num_threads > max_threads) {
fprintf(stderr, "Use max possible thread num: %d instead\n",
if (num_threads > max_threads) {
fprintf(stderr, "Use max possible thread num: %d instead\n",
num_threads = max_threads;
}
out:
num_threads = max_threads;
}
out:
- ctx->fs_num_threads = num_threads;
+ ctx->pfs_num_threads = num_threads;
ctx->fs->fs_num_threads = num_threads;
}
#endif
ctx->fs->fs_num_threads = num_threads;
}
#endif
#ifdef HAVE_PTHREAD
/* don't use more than 1/10 of memory for threads checking */
#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);
+ readahead_kb = get_memory_size() / (10 * ctx->pfs_num_threads);
/* maybe better disable RA if this is too small? */
if (ctx->readahead_kb > readahead_kb)
ctx->readahead_kb = readahead_kb;
/* maybe better disable RA if this is too small? */
if (ctx->readahead_kb > readahead_kb)
ctx->readahead_kb = readahead_kb;
#ifdef HAVE_PTHREAD
pthread_rwlock_init(&ctx->fs_fix_rwlock, NULL);
pthread_rwlock_init(&ctx->fs_block_map_rwlock, NULL);
#ifdef HAVE_PTHREAD
pthread_rwlock_init(&ctx->fs_fix_rwlock, NULL);
pthread_rwlock_init(&ctx->fs_block_map_rwlock, NULL);
- if (ctx->fs_num_threads > 1)
+ if (ctx->pfs_num_threads > 1)
ctx->fs_need_locking = 1;
#endif
ctx->fs_need_locking = 1;
#endif
if (ctx->global_ctx) {
if (ctx->options & E2F_OPT_DEBUG &&
ctx->options & E2F_OPT_MULTITHREAD)
if (ctx->global_ctx) {
if (ctx->options & E2F_OPT_DEBUG &&
ctx->options & E2F_OPT_MULTITHREAD)
- fprintf(stderr, "thread %d jumping to group %d\n",
+ fprintf(stderr, "thread %d jumping to group %u\n",
ctx->thread_info.et_thread_index,
ctx->thread_info.et_group_start);
pctx.errcode = ext2fs_inode_scan_goto_blockgroup(scan,
ctx->thread_info.et_thread_index,
ctx->thread_info.et_group_start);
pctx.errcode = ext2fs_inode_scan_goto_blockgroup(scan,
static int e2fsck_pass1_threads_join(struct e2fsck_thread_info *infos,
e2fsck_t global_ctx)
{
static int e2fsck_pass1_threads_join(struct e2fsck_thread_info *infos,
e2fsck_t global_ctx)
{
- errcode_t rc;
- errcode_t ret = 0;
- int i;
- struct e2fsck_thread_info *pinfo;
- int num_threads = global_ctx->fs_num_threads;
+ errcode_t rc;
+ errcode_t ret = 0;
+ struct e2fsck_thread_info *pinfo;
+ int num_threads = global_ctx->pfs_num_threads;
+ int i;
/* merge invalid bitmaps will recalculate it */
global_ctx->invalid_bitmaps = 0;
/* merge invalid bitmaps will recalculate it */
global_ctx->invalid_bitmaps = 0;
out:
if (thread_ctx->options & E2F_OPT_MULTITHREAD)
log_out(thread_ctx,
out:
if (thread_ctx->options & E2F_OPT_MULTITHREAD)
log_out(thread_ctx,
- _("Scanned group range [%lu, %lu), inodes %lu\n"),
+ _("Scanned group range [%u, %u), inodes %u\n"),
thread_ctx->thread_info.et_group_start,
thread_ctx->thread_info.et_group_end,
thread_ctx->thread_info.et_inode_number);
thread_ctx->thread_info.et_group_start,
thread_ctx->thread_info.et_group_end,
thread_ctx->thread_info.et_inode_number);
int i;
e2fsck_t thread_ctx;
dgrp_t average_group;
int i;
e2fsck_t thread_ctx;
dgrp_t average_group;
- int num_threads = global_ctx->fs_num_threads;
+ int num_threads = global_ctx->pfs_num_threads;
#ifdef DEBUG_THREADS
struct e2fsck_thread_debug thread_debug =
{PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};
#ifdef DEBUG_THREADS
struct e2fsck_thread_debug thread_debug =
{PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};
if (retval)
return;
#ifdef HAVE_PTHREAD
if (retval)
return;
#ifdef HAVE_PTHREAD
- if (ctx->fs_num_threads > 1 ||
- ctx->options & E2F_OPT_MULTITHREAD) {
+ if (ctx->pfs_num_threads > 1 || ctx->options & E2F_OPT_MULTITHREAD) {
need_single = 0;
e2fsck_pass1_multithread(ctx);
}
need_single = 0;
e2fsck_pass1_multithread(ctx);
}
_("Invalid multiple thread num.\n"));
if (thread_num > E2FSCK_MAX_THREADS) {
fprintf(stderr,
_("Invalid multiple thread num.\n"));
if (thread_num > E2FSCK_MAX_THREADS) {
fprintf(stderr,
- _("threads %lu too large (max %lu)\n"),
+ _("threads %lu too large (max %u)\n"),
thread_num, E2FSCK_MAX_THREADS);
fatal_error(ctx, 0);
}
ctx->options |= E2F_OPT_MULTITHREAD;
thread_num, E2FSCK_MAX_THREADS);
fatal_error(ctx, 0);
}
ctx->options |= E2F_OPT_MULTITHREAD;
- ctx->fs_num_threads = thread_num;
+ ctx->pfs_num_threads = thread_num;
time_t now;
int cluster_ratio_bits;
__u16 default_bitmap_type;
time_t now;
int cluster_ratio_bits;
__u16 default_bitmap_type;
- __u16 pad;
- __u32 fs_num_threads;
/*
* Reserved for future expansion
*/
/*
* Reserved for future expansion
*/
/*
* Reserved for the use of the calling application.
/*
* Reserved for the use of the calling application.