emo/busybox
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

fsck: do not use statics

Browse Source 
function                                             old     new   delta
fsck_main                                           1794    1812     +18
packed_usage                                       30662   30664      +2
kill_all_if_got_signal                                60      62      +2
create_fs_device                                     158     160      +2
static.kill_sent                                       1       -      -1
skip_root                                              1       -      -1
serialize                                              1       -      -1
parallel_root                                          1       -      -1
noexecute                                              1       -      -1
fs_type_negated                                        1       -      -1
force_all_parallel                                     1       -      -1
verbose                                                4       -      -4
num_running                                            4       -      -4
num_args                                               4       -      -4
max_running                                            4       -      -4
instance_list                                          4       -      -4
fstype                                                 4       -      -4
fs_type_list                                           4       -      -4
fs_type_flag                                           4       -      -4
filesys_last                                           4       -      -4
filesys_info                                           4       -      -4
args                                                   4       -      -4
wait_one                                             309     300      -9
ignore                                               196     174     -22
------------------------------------------------------------------------------
(add/remove: 0/18 grow/shrink: 4/2 up/down: 24/-82)           Total: -58 bytes
   text    data     bss     dec     hex filename
 938527     932   17448  956907   e99eb busybox_old
 938487     932   17392  956811   e998b busybox_unstripped

Signed-off-by: Denys Vlasenko <vda.linux@googlemail.com>
This commit is contained in:
Denys Vlasenko 2015-10-19 02:24:14 +02:00
parent 36647abcc3
commit c4fb8c6ad5
1 changed files with 132 additions and 127 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

257
e2fsprogs/fsck.c
View File

@ -46,7 +46,7 @@
//kbuild:lib-$(CONFIG_FSCK) += fsck.o //kbuild:lib-$(CONFIG_FSCK) += fsck.o
//usage:#define fsck_trivial_usage //usage:#define fsck_trivial_usage
//usage: "[-ANPRTV] [-C FD] [-t FSTYPE] [FS_OPTS] [BLOCKDEV]..." //usage: "[-ANPRTV] [-t FSTYPE] [FS_OPTS] [BLOCKDEV]..."
//usage:#define fsck_full_usage "\n\n" //usage:#define fsck_full_usage "\n\n"
//usage: "Check and repair filesystems\n" //usage: "Check and repair filesystems\n"
//usage: "\n -A Walk /etc/fstab and check all filesystems" //usage: "\n -A Walk /etc/fstab and check all filesystems"
@ -55,7 +55,8 @@
//usage: "\n -R With -A, skip the root filesystem" //usage: "\n -R With -A, skip the root filesystem"
//usage: "\n -T Don't show title on startup" //usage: "\n -T Don't show title on startup"
//usage: "\n -V Verbose" //usage: "\n -V Verbose"
//usage: "\n -C n Write status information to specified filedescriptor" //DO_PROGRESS_INDICATOR is off:
////usage: "\n -C FD Write status information to specified file descriptor"
//usage: "\n -t TYPE List of filesystem types to check" //usage: "\n -t TYPE List of filesystem types to check"
#include "libbb.h" #include "libbb.h"
@ -136,35 +137,42 @@ static const char really_wanted[] ALIGN1 =
#define BASE_MD "/dev/md" #define BASE_MD "/dev/md"
static char **args; struct globals {
static int num_args; char **args;
static int verbose; int num_args;
int verbose;
#define FS_TYPE_FLAG_NORMAL 0 #define FS_TYPE_FLAG_NORMAL 0
#define FS_TYPE_FLAG_OPT 1 #define FS_TYPE_FLAG_OPT 1
#define FS_TYPE_FLAG_NEGOPT 2 #define FS_TYPE_FLAG_NEGOPT 2
static char **fs_type_list; char **fs_type_list;
static uint8_t *fs_type_flag; uint8_t *fs_type_flag;
static smallint fs_type_negated; smallint fs_type_negated;
static smallint noexecute; smallint noexecute;
static smallint serialize; smallint serialize;
static smallint skip_root; smallint skip_root;
/* static smallint like_mount; */ /* smallint like_mount; */
static smallint parallel_root; smallint parallel_root;
static smallint force_all_parallel; smallint force_all_parallel;
smallint kill_sent;
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
static smallint progress; smallint progress;
static int progress_fd; int progress_fd;
#endif #endif
static int num_running; int num_running;
static int max_running; int max_running;
static char *fstype; char *fstype;
static struct fs_info *filesys_info; struct fs_info *filesys_info;
static struct fs_info *filesys_last; struct fs_info *filesys_last;
static struct fsck_instance *instance_list; struct fsck_instance *instance_list;
} FIX_ALIASING;
#define G (*(struct globals*)&bb_common_bufsiz1)
#define INIT_G() do { \
BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
} while (0)
/* /*
* Return the "base device" given a particular device; this is used to * Return the "base device" given a particular device; this is used to
@ -313,11 +321,11 @@ static struct fs_info *create_fs_device(const char *device, const char *mntpnt,
/*fs->flags = 0; */ /*fs->flags = 0; */
/*fs->next = NULL; */ /*fs->next = NULL; */
if (!filesys_info) if (!G.filesys_info)
filesys_info = fs; G.filesys_info = fs;
else else
filesys_last->next = fs; G.filesys_last->next = fs;
filesys_last = fs; G.filesys_last = fs;
return fs; return fs;
} }
@ -327,6 +335,7 @@ static void load_fs_info(const char *filename)
{ {
FILE *fstab; FILE *fstab;
struct mntent mte; struct mntent mte;
char buf[1024];
fstab = setmntent(filename, "r"); fstab = setmntent(filename, "r");
if (!fstab) { if (!fstab) {
@ -335,7 +344,7 @@ static void load_fs_info(const char *filename)
} }
// Loop through entries // Loop through entries
while (getmntent_r(fstab, &mte, bb_common_bufsiz1, COMMON_BUFSIZE)) { while (getmntent_r(fstab, &mte, buf, sizeof(buf))) {
//bb_info_msg("CREATE[%s][%s][%s][%s][%d]", mte.mnt_fsname, mte.mnt_dir, //bb_info_msg("CREATE[%s][%s][%s][%s][%d]", mte.mnt_fsname, mte.mnt_dir,
// mte.mnt_type, mte.mnt_opts, // mte.mnt_type, mte.mnt_opts,
// mte.mnt_passno); // mte.mnt_passno);
@ -351,7 +360,7 @@ static struct fs_info *lookup(char *filesys)
{ {
struct fs_info *fs; struct fs_info *fs;
for (fs = filesys_info; fs; fs = fs->next) { for (fs = G.filesys_info; fs; fs = fs->next) {
if (strcmp(filesys, fs->device) == 0 if (strcmp(filesys, fs->device) == 0
|| (fs->mountpt && strcmp(filesys, fs->mountpt) == 0) || (fs->mountpt && strcmp(filesys, fs->mountpt) == 0)
) )
@ -366,7 +375,7 @@ static int progress_active(void)
{ {
struct fsck_instance *inst; struct fsck_instance *inst;
for (inst = instance_list; inst; inst = inst->next) { for (inst = G.instance_list; inst; inst = inst->next) {
if (inst->flags & FLAG_DONE) if (inst->flags & FLAG_DONE)
continue; continue;
if (inst->flags & FLAG_PROGRESS) if (inst->flags & FLAG_PROGRESS)
@ -382,19 +391,17 @@ static int progress_active(void)
*/ */
static void kill_all_if_got_signal(void) static void kill_all_if_got_signal(void)
{ {
static smallint kill_sent;
struct fsck_instance *inst; struct fsck_instance *inst;
if (!bb_got_signal || kill_sent) if (!bb_got_signal || G.kill_sent)
return; return;
for (inst = instance_list; inst; inst = inst->next) { for (inst = G.instance_list; inst; inst = inst->next) {
if (inst->flags & FLAG_DONE) if (inst->flags & FLAG_DONE)
continue; continue;
kill(inst->pid, SIGTERM); kill(inst->pid, SIGTERM);
} }
kill_sent = 1; G.kill_sent = 1;
} }
/* /*
@ -409,9 +416,9 @@ static int wait_one(int flags)
struct fsck_instance *inst, *prev; struct fsck_instance *inst, *prev;
pid_t pid; pid_t pid;
if (!instance_list) if (!G.instance_list)
return -1; return -1;
/* if (noexecute) { already returned -1; } */ /* if (G.noexecute) { already returned -1; } */
while (1) { while (1) {
pid = waitpid(-1, &status, flags); pid = waitpid(-1, &status, flags);
@ -429,7 +436,7 @@ static int wait_one(int flags)
continue; continue;
} }
prev = NULL; prev = NULL;
inst = instance_list; inst = G.instance_list;
do { do {
if (inst->pid == pid) if (inst->pid == pid)
goto child_died; goto child_died;
@ -439,9 +446,8 @@ static int wait_one(int flags)
} }
child_died: child_died:
if (WIFEXITED(status))
status = WEXITSTATUS(status); status = WEXITSTATUS(status);
else if (WIFSIGNALED(status)) { if (WIFSIGNALED(status)) {
sig = WTERMSIG(status); sig = WTERMSIG(status);
status = EXIT_UNCORRECTED; status = EXIT_UNCORRECTED;
if (sig != SIGINT) { if (sig != SIGINT) {
@ -450,16 +456,12 @@ static int wait_one(int flags)
inst->prog, inst->device, sig); inst->prog, inst->device, sig);
status = EXIT_ERROR; status = EXIT_ERROR;
} }
} else {
printf("%s %s: status is %x, should never happen\n",
inst->prog, inst->device, status);
status = EXIT_ERROR;
} }
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
if (progress && (inst->flags & FLAG_PROGRESS) && !progress_active()) { if (progress && (inst->flags & FLAG_PROGRESS) && !progress_active()) {
struct fsck_instance *inst2; struct fsck_instance *inst2;
for (inst2 = instance_list; inst2; inst2 = inst2->next) { for (inst2 = G.instance_list; inst2; inst2 = inst2->next) {
if (inst2->flags & FLAG_DONE) if (inst2->flags & FLAG_DONE)
continue; continue;
if (strcmp(inst2->type, "ext2") != 0 if (strcmp(inst2->type, "ext2") != 0
@ -486,11 +488,11 @@ static int wait_one(int flags)
if (prev) if (prev)
prev->next = inst->next; prev->next = inst->next;
else else
instance_list = inst->next; G.instance_list = inst->next;
if (verbose > 1) if (G.verbose > 1)
printf("Finished with %s (exit status %d)\n", printf("Finished with %s (exit status %d)\n",
inst->device, status); inst->device, status);
num_running--; G.num_running--;
free_instance(inst); free_instance(inst);
return status; return status;
@ -526,51 +528,51 @@ static void execute(const char *type, const char *device,
struct fsck_instance *inst; struct fsck_instance *inst;
pid_t pid; pid_t pid;
args[0] = xasprintf("fsck.%s", type); G.args[0] = xasprintf("fsck.%s", type);
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
if (progress && !progress_active()) { if (progress && !progress_active()) {
if (strcmp(type, "ext2") == 0 if (strcmp(type, "ext2") == 0
|| strcmp(type, "ext3") == 0 || strcmp(type, "ext3") == 0
) { ) {
args[XXX] = xasprintf("-C%d", progress_fd); /* 1 */ G.args[XXX] = xasprintf("-C%d", progress_fd); /* 1 */
inst->flags |= FLAG_PROGRESS; inst->flags |= FLAG_PROGRESS;
} }
} }
#endif #endif
args[num_args - 2] = (char*)device; G.args[G.num_args - 2] = (char*)device;
/* args[num_args - 1] = NULL; - already is */ /* G.args[G.num_args - 1] = NULL; - already is */
if (verbose || noexecute) { if (G.verbose || G.noexecute) {
printf("[%s (%d) -- %s]", args[0], num_running, printf("[%s (%d) -- %s]", G.args[0], G.num_running,
mntpt ? mntpt : device); mntpt ? mntpt : device);
for (i = 0; args[i]; i++) for (i = 0; G.args[i]; i++)
printf(" %s", args[i]); printf(" %s", G.args[i]);
bb_putchar('\n'); bb_putchar('\n');
} }
/* Fork and execute the correct program. */ /* Fork and execute the correct program. */
pid = -1; pid = -1;
if (!noexecute) { if (!G.noexecute) {
pid = spawn(args); pid = spawn(G.args);
if (pid < 0) if (pid < 0)
bb_simple_perror_msg(args[0]); bb_simple_perror_msg(G.args[0]);
} }
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
free(args[XXX]); free(G.args[XXX]);
#endif #endif
/* No child, so don't record an instance */ /* No child, so don't record an instance */
if (pid <= 0) { if (pid <= 0) {
free(args[0]); free(G.args[0]);
return; return;
} }
inst = xzalloc(sizeof(*inst)); inst = xzalloc(sizeof(*inst));
inst->pid = pid; inst->pid = pid;
inst->prog = args[0]; inst->prog = G.args[0];
inst->device = xstrdup(device); inst->device = xstrdup(device);
inst->base_device = base_device(device); inst->base_device = base_device(device);
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
@ -579,8 +581,8 @@ static void execute(const char *type, const char *device,
/* Add to the list of running fsck's. /* Add to the list of running fsck's.
* (was adding to the end, but adding to the front is simpler...) */ * (was adding to the end, but adding to the front is simpler...) */
inst->next = instance_list; inst->next = G.instance_list;
instance_list = inst; G.instance_list = inst;
} }
/* /*
@ -599,27 +601,27 @@ static void fsck_device(struct fs_info *fs /*, int interactive */)
if (strcmp(fs->type, "auto") != 0) { if (strcmp(fs->type, "auto") != 0) {
type = fs->type; type = fs->type;
if (verbose > 2) if (G.verbose > 2)
bb_info_msg("using filesystem type '%s' %s", bb_info_msg("using filesystem type '%s' %s",
type, "from fstab"); type, "from fstab");
} else if (fstype } else if (G.fstype
&& (fstype[0] != 'n' || fstype[1] != 'o') /* != "no" */ && (G.fstype[0] != 'n' || G.fstype[1] != 'o') /* != "no" */
&& !is_prefixed_with(fstype, "opts=") && !is_prefixed_with(G.fstype, "opts=")
&& !is_prefixed_with(fstype, "loop") && !is_prefixed_with(G.fstype, "loop")
&& !strchr(fstype, ',') && !strchr(G.fstype, ',')
) { ) {
type = fstype; type = G.fstype;
if (verbose > 2) if (G.verbose > 2)
bb_info_msg("using filesystem type '%s' %s", bb_info_msg("using filesystem type '%s' %s",
type, "from -t"); type, "from -t");
} else { } else {
type = "auto"; type = "auto";
if (verbose > 2) if (G.verbose > 2)
bb_info_msg("using filesystem type '%s' %s", bb_info_msg("using filesystem type '%s' %s",
type, "(default)"); type, "(default)");
} }
num_running++; G.num_running++;
execute(type, fs->device, fs->mountpt /*, interactive */); execute(type, fs->device, fs->mountpt /*, interactive */);
} }
@ -632,13 +634,13 @@ static int device_already_active(char *device)
struct fsck_instance *inst; struct fsck_instance *inst;
char *base; char *base;
if (force_all_parallel) if (G.force_all_parallel)
return 0; return 0;
#ifdef BASE_MD #ifdef BASE_MD
/* Don't check a soft raid disk with any other disk */ /* Don't check a soft raid disk with any other disk */
if (instance_list if (G.instance_list
&& (is_prefixed_with(instance_list->device, BASE_MD) && (is_prefixed_with(G.instance_list->device, BASE_MD)
|| is_prefixed_with(device, BASE_MD)) || is_prefixed_with(device, BASE_MD))
) { ) {
return 1; return 1;
@ -651,9 +653,9 @@ static int device_already_active(char *device)
* already active if there are any fsck instances running. * already active if there are any fsck instances running.
*/ */
if (!base) if (!base)
return (instance_list != NULL); return (G.instance_list != NULL);
for (inst = instance_list; inst; inst = inst->next) { for (inst = G.instance_list; inst; inst = inst->next) {
if (!inst->base_device || !strcmp(base, inst->base_device)) { if (!inst->base_device || !strcmp(base, inst->base_device)) {
free(base); free(base);
return 1; return 1;
@ -698,17 +700,17 @@ static int fs_match(struct fs_info *fs)
int n, ret, checked_type; int n, ret, checked_type;
char *cp; char *cp;
if (!fs_type_list) if (!G.fs_type_list)
return 1; return 1;
ret = 0; ret = 0;
checked_type = 0; checked_type = 0;
n = 0; n = 0;
while (1) { while (1) {
cp = fs_type_list[n]; cp = G.fs_type_list[n];
if (!cp) if (!cp)
break; break;
switch (fs_type_flag[n]) { switch (G.fs_type_flag[n]) {
case FS_TYPE_FLAG_NORMAL: case FS_TYPE_FLAG_NORMAL:
checked_type++; checked_type++;
if (strcmp(cp, fs->type) == 0) if (strcmp(cp, fs->type) == 0)
@ -728,7 +730,7 @@ static int fs_match(struct fs_info *fs)
if (checked_type == 0) if (checked_type == 0)
return 1; return 1;
return (fs_type_negated ? !ret : ret); return (G.fs_type_negated ? !ret : ret);
} }
/* Check if we should ignore this filesystem. */ /* Check if we should ignore this filesystem. */
@ -764,7 +766,7 @@ static int check_all(void)
smallint pass_done; smallint pass_done;
int passno; int passno;
if (verbose) if (G.verbose)
puts("Checking all filesystems"); puts("Checking all filesystems");
/* /*
@ -772,17 +774,17 @@ static int check_all(void)
* which should be ignored as done, and resolve any "auto" * which should be ignored as done, and resolve any "auto"
* filesystem types (done as a side-effect of calling ignore()). * filesystem types (done as a side-effect of calling ignore()).
*/ */
for (fs = filesys_info; fs; fs = fs->next) for (fs = G.filesys_info; fs; fs = fs->next)
if (ignore(fs)) if (ignore(fs))
fs->flags |= FLAG_DONE; fs->flags |= FLAG_DONE;
/* /*
* Find and check the root filesystem. * Find and check the root filesystem.
*/ */
if (!parallel_root) { if (!G.parallel_root) {
for (fs = filesys_info; fs; fs = fs->next) { for (fs = G.filesys_info; fs; fs = fs->next) {
if (LONE_CHAR(fs->mountpt, '/')) { if (LONE_CHAR(fs->mountpt, '/')) {
if (!skip_root && !ignore(fs)) { if (!G.skip_root && !ignore(fs)) {
fsck_device(fs /*, 1*/); fsck_device(fs /*, 1*/);
status |= wait_many(FLAG_WAIT_ALL); status |= wait_many(FLAG_WAIT_ALL);
if (status > EXIT_NONDESTRUCT) if (status > EXIT_NONDESTRUCT)
@ -798,8 +800,8 @@ static int check_all(void)
* filesystem listed twice. * filesystem listed twice.
* "Skip root" will skip _all_ root entries. * "Skip root" will skip _all_ root entries.
*/ */
if (skip_root) if (G.skip_root)
for (fs = filesys_info; fs; fs = fs->next) for (fs = G.filesys_info; fs; fs = fs->next)
if (LONE_CHAR(fs->mountpt, '/')) if (LONE_CHAR(fs->mountpt, '/'))
fs->flags |= FLAG_DONE; fs->flags |= FLAG_DONE;
@ -809,7 +811,7 @@ static int check_all(void)
not_done_yet = 0; not_done_yet = 0;
pass_done = 1; pass_done = 1;
for (fs = filesys_info; fs; fs = fs->next) { for (fs = G.filesys_info; fs; fs = fs->next) {
if (bb_got_signal) if (bb_got_signal)
break; break;
if (fs->flags & FLAG_DONE) if (fs->flags & FLAG_DONE)
@ -835,7 +837,7 @@ static int check_all(void)
/* /*
* Spawn off the fsck process * Spawn off the fsck process
*/ */
fsck_device(fs /*, serialize*/); fsck_device(fs /*, G.serialize*/);
fs->flags |= FLAG_DONE; fs->flags |= FLAG_DONE;
/* /*
@ -843,8 +845,8 @@ static int check_all(void)
* have a limit on the number of fsck's extant * have a limit on the number of fsck's extant
* at one time, apply that limit. * at one time, apply that limit.
*/ */
if (serialize if (G.serialize
|| (max_running && (num_running >= max_running)) || (G.num_running >= G.max_running)
) { ) {
pass_done = 0; pass_done = 0;
break; break;
@ -852,12 +854,12 @@ static int check_all(void)
} }
if (bb_got_signal) if (bb_got_signal)
break; break;
if (verbose > 1) if (G.verbose > 1)
printf("--waiting-- (pass %d)\n", passno); printf("--waiting-- (pass %d)\n", passno);
status |= wait_many(pass_done ? FLAG_WAIT_ALL : status |= wait_many(pass_done ? FLAG_WAIT_ALL :
FLAG_WAIT_ATLEAST_ONE); FLAG_WAIT_ATLEAST_ONE);
if (pass_done) { if (pass_done) {
if (verbose > 1) if (G.verbose > 1)
puts("----------------------------------"); puts("----------------------------------");
passno++; passno++;
} else } else
@ -885,9 +887,9 @@ static void compile_fs_type(char *fs_type)
s++; s++;
} }
fs_type_list = xzalloc(num * sizeof(fs_type_list[0])); G.fs_type_list = xzalloc(num * sizeof(G.fs_type_list[0]));
fs_type_flag = xzalloc(num * sizeof(fs_type_flag[0])); G.fs_type_flag = xzalloc(num * sizeof(G.fs_type_flag[0]));
fs_type_negated = -1; /* not yet known is it negated or not */ G.fs_type_negated = -1; /* not yet known is it negated or not */
num = 0; num = 0;
s = fs_type; s = fs_type;
@ -909,18 +911,18 @@ static void compile_fs_type(char *fs_type)
if (is_prefixed_with(s, "opts=")) { if (is_prefixed_with(s, "opts=")) {
s += 5; s += 5;
loop_special_case: loop_special_case:
fs_type_flag[num] = negate ? FS_TYPE_FLAG_NEGOPT : FS_TYPE_FLAG_OPT; G.fs_type_flag[num] = negate ? FS_TYPE_FLAG_NEGOPT : FS_TYPE_FLAG_OPT;
} else { } else {
if (fs_type_negated == -1) if (G.fs_type_negated == -1)
fs_type_negated = negate; G.fs_type_negated = negate;
if (fs_type_negated != negate) if (G.fs_type_negated != negate)
bb_error_msg_and_die( bb_error_msg_and_die(
"either all or none of the filesystem types passed to -t must be prefixed " "either all or none of the filesystem types passed to -t must be prefixed "
"with 'no' or '!'"); "with 'no' or '!'");
} }
comma = strchr(s, ','); comma = strchrnul(s, ',');
fs_type_list[num++] = comma ? xstrndup(s, comma-s) : xstrdup(s); G.fs_type_list[num++] = xstrndup(s, comma-s);
if (!comma) if (*comma == '\0')
break; break;
s = comma + 1; s = comma + 1;
} }
@ -928,8 +930,8 @@ static void compile_fs_type(char *fs_type)
static char **new_args(void) static char **new_args(void)
{ {
args = xrealloc_vector(args, 2, num_args); G.args = xrealloc_vector(G.args, 2, G.num_args);
return &args[num_args++]; return &G.args[G.num_args++];
} }
int fsck_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int fsck_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
@ -946,6 +948,8 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
smallint doall; smallint doall;
smallint notitle; smallint notitle;
INIT_G();
/* we want wait() to be interruptible */ /* we want wait() to be interruptible */
signal_no_SA_RESTART_empty_mask(SIGINT, record_signo); signal_no_SA_RESTART_empty_mask(SIGINT, record_signo);
signal_no_SA_RESTART_empty_mask(SIGTERM, record_signo); signal_no_SA_RESTART_empty_mask(SIGTERM, record_signo);
@ -955,8 +959,8 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
opts_for_fsck = doall = notitle = 0; opts_for_fsck = doall = notitle = 0;
devices = NULL; devices = NULL;
num_devices = 0; num_devices = 0;
new_args(); /* args[0] = NULL, will be replaced by fsck.<type> */ new_args(); /* G.args[0] = NULL, will be replaced by fsck.<type> */
/* instance_list = NULL; - in bss, so already zeroed */ /* G.instance_list = NULL; - in bss, so already zeroed */
while (*++argv) { while (*++argv) {
int j; int j;
@ -1005,13 +1009,13 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
goto next_arg; goto next_arg;
#endif #endif
case 'V': case 'V':
verbose++; G.verbose++;
break; break;
case 'N': case 'N':
noexecute = 1; G.noexecute = 1;
break; break;
case 'R': case 'R':
skip_root = 1; G.skip_root = 1;
break; break;
case 'T': case 'T':
notitle = 1; notitle = 1;
@ -1020,13 +1024,13 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
like_mount = 1; like_mount = 1;
break; */ break; */
case 'P': case 'P':
parallel_root = 1; G.parallel_root = 1;
break; break;
case 's': case 's':
serialize = 1; G.serialize = 1;
break; break;
case 't': case 't':
if (fstype) if (G.fstype)
bb_show_usage(); bb_show_usage();
if (arg[++j]) if (arg[++j])
tmp = &arg[j]; tmp = &arg[j];
@ -1034,8 +1038,8 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
tmp = *argv; tmp = *argv;
else else
bb_show_usage(); bb_show_usage();
fstype = xstrdup(tmp); G.fstype = xstrdup(tmp);
compile_fs_type(fstype); compile_fs_type(G.fstype);
goto next_arg; goto next_arg;
case '?': case '?':
bb_show_usage(); bb_show_usage();
@ -1056,12 +1060,13 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
} }
} }
if (getenv("FSCK_FORCE_ALL_PARALLEL")) if (getenv("FSCK_FORCE_ALL_PARALLEL"))
force_all_parallel = 1; G.force_all_parallel = 1;
tmp = getenv("FSCK_MAX_INST"); tmp = getenv("FSCK_MAX_INST");
G.max_running = INT_MAX;
if (tmp) if (tmp)
max_running = xatoi(tmp); G.max_running = xatoi(tmp);
new_args(); /* args[num_args - 2] will be replaced by <device> */ new_args(); /* G.args[G.num_args - 2] will be replaced by <device> */
new_args(); /* args[num_args - 1] is the last, NULL element */ new_args(); /* G.args[G.num_args - 1] is the last, NULL element */
if (!notitle) if (!notitle)
puts("fsck (busybox "BB_VER", "BB_BT")"); puts("fsck (busybox "BB_VER", "BB_BT")");
@ -1073,10 +1078,10 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
fstab = "/etc/fstab"; fstab = "/etc/fstab";
load_fs_info(fstab); load_fs_info(fstab);
/*interactive = (num_devices == 1) | serialize;*/ /*interactive = (num_devices == 1) | G.serialize;*/
if (num_devices == 0) if (num_devices == 0)
/*interactive =*/ serialize = doall = 1; /*interactive =*/ G.serialize = doall = 1;
if (doall) if (doall)
return check_all(); return check_all();
@ -1092,13 +1097,13 @@ int fsck_main(int argc UNUSED_PARAM, char **argv)
fs = create_fs_device(devices[i], "", "auto", NULL, -1); fs = create_fs_device(devices[i], "", "auto", NULL, -1);
fsck_device(fs /*, interactive */); fsck_device(fs /*, interactive */);
if (serialize if (G.serialize
|| (max_running && (num_running >= max_running)) || (G.num_running >= G.max_running)
) { ) {
int exit_status = wait_one(0); int exit_status = wait_one(0);
if (exit_status >= 0) if (exit_status >= 0)
status |= exit_status; status |= exit_status;
if (verbose > 1) if (G.verbose > 1)
puts("----------------------------------"); puts("----------------------------------");
} }
} }