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

fsck: shrink (we were passing around some params which were unused)

Browse Source 
function                                             old     new   delta
fsck_main                                           1807    2256    +449
fsck_device                                          196     189      -7
create_fs_device                                     131     124      -7
wait_one                                             325     309     -16
wait_many                                             52      33     -19
free_instance                                         38       -     -38
packed_usage                                       23698   23650     -48
execute                                             2508    2402    -106
check_all                                            609       -    -609
------------------------------------------------------------------------------
(add/remove: 0/2 grow/shrink: 1/6 up/down: 449/-850)         Total: -401 bytes
   text    data     bss     dec     hex filename
 797604     658    7428  805690   c4b3a busybox_old
 797195     658    7428  805281   c49a1 busybox_unstripped
This commit is contained in:
Denis Vlasenko 2008-03-17 08:59:19 +00:00
parent 397de617f3
commit a55bd05f3c
1 changed files with 100 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

237
e2fsprogs/fsck.c
View File

@ -39,6 +39,11 @@
#include "libbb.h" #include "libbb.h"
/* "progress indicator" code is somewhat buggy and ext[23] specific.
* We should be filesystem agnostic. IOW: there should be a well-defined
* API for fsck.something, NOT ad-hoc hacks in generic fsck. */
#define DO_PROGRESS_INDICATOR 0
#define EXIT_OK 0 #define EXIT_OK 0
#define EXIT_NONDESTRUCT 1 #define EXIT_NONDESTRUCT 1
#define EXIT_DESTRUCT 2 #define EXIT_DESTRUCT 2
@ -57,7 +62,6 @@ struct fs_info {
char *mountpt; char *mountpt;
char *type; char *type;
char *opts; char *opts;
int freq;
int passno; int passno;
int flags; int flags;
}; };
@ -71,10 +75,10 @@ struct fsck_instance {
struct fsck_instance *next; struct fsck_instance *next;
int pid; int pid;
int flags; int flags;
int exit_status; #if DO_PROGRESS_INDICATOR
time_t start_time; time_t start_time;
#endif
char *prog; char *prog;
char *type;
char *device; char *device;
char *base_device; /* /dev/hda for /dev/hdaN etc */ char *base_device; /* /dev/hda for /dev/hdaN etc */
}; };
@ -125,10 +129,6 @@ static smallint notitle;
static smallint parallel_root; static smallint parallel_root;
static smallint force_all_parallel; static smallint force_all_parallel;
/* "progress indicator" code is somewhat buggy and ext[23] specific.
* We should be filesystem agnostic. IOW: there should be a well-defined
* API for fsck.something, NOT ad-hoc hacks in generic fsck. */
#define DO_PROGRESS_INDICATOR 0
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
static smallint progress; static smallint progress;
static int progress_fd; static int progress_fd;
@ -273,7 +273,7 @@ static void free_instance(struct fsck_instance *p)
static struct fs_info *create_fs_device(const char *device, const char *mntpnt, static struct fs_info *create_fs_device(const char *device, const char *mntpnt,
const char *type, const char *opts, const char *type, const char *opts,
int freq, int passno) int passno)
{ {
struct fs_info *fs; struct fs_info *fs;
@ -282,7 +282,6 @@ static struct fs_info *create_fs_device(const char *device, const char *mntpnt,
fs->mountpt = xstrdup(mntpnt); fs->mountpt = xstrdup(mntpnt);
fs->type = xstrdup(type); fs->type = xstrdup(type);
fs->opts = xstrdup(opts ? opts : ""); fs->opts = xstrdup(opts ? opts : "");
fs->freq = freq;
fs->passno = passno; fs->passno = passno;
/*fs->flags = 0; */ /*fs->flags = 0; */
/*fs->next = NULL; */ /*fs->next = NULL; */
@ -344,10 +343,10 @@ static void parse_escape(char *word)
static int parse_fstab_line(char *line, struct fs_info **ret_fs) static int parse_fstab_line(char *line, struct fs_info **ret_fs)
{ {
char *device, *mntpnt, *type, *opts, *freq, *passno, *cp; char *device, *mntpnt, *type, *opts, *passno, *cp;
struct fs_info *fs; struct fs_info *fs;
*ret_fs = 0; *ret_fs = NULL;
strip_line(line); strip_line(line);
*strchrnul(line, '#') = '\0'; /* Ignore everything after comment */ *strchrnul(line, '#') = '\0'; /* Ignore everything after comment */
cp = line; cp = line;
@ -357,7 +356,7 @@ static int parse_fstab_line(char *line, struct fs_info **ret_fs)
mntpnt = parse_word(&cp); mntpnt = parse_word(&cp);
type = parse_word(&cp); type = parse_word(&cp);
opts = parse_word(&cp); opts = parse_word(&cp);
freq = parse_word(&cp); /*freq =*/ parse_word(&cp);
passno = parse_word(&cp); passno = parse_word(&cp);
if (!mntpnt || !type) if (!mntpnt || !type)
@ -367,15 +366,13 @@ static int parse_fstab_line(char *line, struct fs_info **ret_fs)
parse_escape(mntpnt); parse_escape(mntpnt);
parse_escape(type); parse_escape(type);
parse_escape(opts); parse_escape(opts);
parse_escape(freq);
parse_escape(passno); parse_escape(passno);
if (strchr(type, ',')) if (strchr(type, ','))
type = NULL; type = NULL;
fs = create_fs_device(device, mntpnt, type ? type : "auto", opts, fs = create_fs_device(device, mntpnt, type ? type : "auto", opts,
freq ? atoi(freq) : -1, (passno ? atoi(passno) : -1));
passno ? atoi(passno) : -1);
*ret_fs = fs; *ret_fs = fs;
return 0; return 0;
} }
@ -477,9 +474,10 @@ static void kill_all_if_cancel_requested(void)
/* /*
* Wait for one child process to exit; when it does, unlink it from * Wait for one child process to exit; when it does, unlink it from
* the list of executing child processes, and return it. * the list of executing child processes, free, and return its exit status.
* If there is no exited child, return -1.
*/ */
static struct fsck_instance *wait_one(int flags) static int wait_one(int flags)
{ {
int status; int status;
int sig; int sig;
@ -487,46 +485,34 @@ static struct fsck_instance *wait_one(int flags)
pid_t pid; pid_t pid;
if (!instance_list) if (!instance_list)
return NULL; return -1;
/* if (noexecute) { already returned -1; } */
if (noexecute) { while (1) {
inst = instance_list;
prev = NULL;
#ifdef RANDOM_DEBUG
while (inst->next && (random() & 1)) {
prev = inst;
inst = inst->next;
}
#endif
inst->exit_status = 0;
goto ret_inst;
}
inst = prev = NULL; /* for gcc */
do {
pid = waitpid(-1, &status, flags); pid = waitpid(-1, &status, flags);
kill_all_if_cancel_requested(); kill_all_if_cancel_requested();
if (pid == 0 && (flags & WNOHANG)) if (pid == 0) /* flags == WNOHANG and no children exited */
return NULL; return -1;
if (pid < 0) { if (pid < 0) {
if (errno == EINTR || errno == EAGAIN) if (errno == EINTR)
continue; continue;
if (errno == ECHILD) { if (errno == ECHILD) { /* paranoia */
bb_error_msg("wait: no more child process?!?"); bb_error_msg("wait: no more children");
return NULL; return -1;
} }
bb_perror_msg("wait"); bb_perror_msg("wait");
continue; continue;
} }
prev = NULL; prev = NULL;
inst = instance_list; inst = instance_list;
while (inst) { do {
if (inst->pid == pid) if (inst->pid == pid)
break; goto child_died;
prev = inst; prev = inst;
inst = inst->next; inst = inst->next;
} } while (inst);
} while (!inst); }
child_died:
if (WIFEXITED(status)) if (WIFEXITED(status))
status = WEXITSTATUS(status); status = WEXITSTATUS(status);
@ -534,8 +520,8 @@ static struct fsck_instance *wait_one(int flags)
sig = WTERMSIG(status); sig = WTERMSIG(status);
status = EXIT_UNCORRECTED; status = EXIT_UNCORRECTED;
if (sig != SIGINT) { if (sig != SIGINT) {
printf("Warning... %s %s exited " printf("Warning: %s %s terminated "
"with signal %d\n", "by signal %d\n",
inst->prog, inst->device, sig); inst->prog, inst->device, sig);
status = EXIT_ERROR; status = EXIT_ERROR;
} }
@ -544,7 +530,6 @@ static struct fsck_instance *wait_one(int flags)
inst->prog, inst->device, status); inst->prog, inst->device, status);
status = EXIT_ERROR; status = EXIT_ERROR;
} }
inst->exit_status = status;
#if DO_PROGRESS_INDICATOR #if DO_PROGRESS_INDICATOR
if (progress && (inst->flags & FLAG_PROGRESS) && !progress_active()) { if (progress && (inst->flags & FLAG_PROGRESS) && !progress_active()) {
@ -573,39 +558,34 @@ static struct fsck_instance *wait_one(int flags)
} }
#endif #endif
ret_inst:
if (prev) if (prev)
prev->next = inst->next; prev->next = inst->next;
else else
instance_list = inst->next; instance_list = inst->next;
if (verbose > 1) if (verbose > 1)
printf("Finished with %s (exit status %d)\n", printf("Finished with %s (exit status %d)\n",
inst->device, inst->exit_status); inst->device, status);
num_running--; num_running--;
return inst; free_instance(inst);
return status;
} }
#define FLAG_WAIT_ALL 0
#define FLAG_WAIT_ATLEAST_ONE 1
/* /*
* Wait until all executing child processes have exited; return the * Wait until all executing child processes have exited; return the
* logical OR of all of their exit code values. * logical OR of all of their exit code values.
*/ */
#define FLAG_WAIT_ALL 0
#define FLAG_WAIT_ATLEAST_ONE WNOHANG
static int wait_many(int flags) static int wait_many(int flags)
{ {
struct fsck_instance *inst; int exit_status;
int global_status = 0; int global_status = 0;
int wait_flags = 0; int wait_flags = 0;
while ((inst = wait_one(wait_flags))) { while ((exit_status = wait_one(wait_flags)) != -1) {
global_status |= inst->exit_status; global_status |= exit_status;
free_instance(inst); wait_flags |= flags;
#ifdef RANDOM_DEBUG
if (noexecute && (flags & WNOHANG) && !(random() % 3))
break;
#endif
if (flags & FLAG_WAIT_ATLEAST_ONE)
wait_flags = WNOHANG;
} }
return global_status; return global_status;
} }
@ -614,8 +594,8 @@ static int wait_many(int flags)
* Execute a particular fsck program, and link it into the list of * Execute a particular fsck program, and link it into the list of
* child processes we are waiting for. * child processes we are waiting for.
*/ */
static void execute(const char *type, const char *device, const char *mntpt, static void execute(const char *type, const char *device,
int interactive) const char *mntpt /*, int interactive */)
{ {
char *argv[num_args + 4]; /* see count below: */ char *argv[num_args + 4]; /* see count below: */
int argc; int argc;
@ -623,8 +603,6 @@ static void execute(const char *type, const char *device, const char *mntpt,
struct fsck_instance *inst; struct fsck_instance *inst;
pid_t pid; pid_t pid;
inst = xzalloc(sizeof(*inst));
argv[0] = xasprintf("fsck.%s", type); /* 1 */ argv[0] = xasprintf("fsck.%s", type); /* 1 */
for (i = 0; i < num_args; i++) for (i = 0; i < num_args; i++)
argv[i+1] = args[i]; /* num_args */ argv[i+1] = args[i]; /* num_args */
@ -641,7 +619,7 @@ static void execute(const char *type, const char *device, const char *mntpt,
} }
#endif #endif
argv[argc++] = xstrdup(device); /* 1 */ argv[argc++] = (char*)device; /* 1 */
argv[argc] = NULL; /* 1 */ argv[argc] = NULL; /* 1 */
if (verbose || noexecute) { if (verbose || noexecute) {
@ -660,21 +638,24 @@ static void execute(const char *type, const char *device, const char *mntpt,
bb_simple_perror_msg(argv[0]); bb_simple_perror_msg(argv[0]);
} }
for (i = num_args+1; i < argc; i++) #if DO_PROGRESS_INDICATOR
free(argv[i]); free(argv[num_args + 1]);
#endif
/* No pid, so don't record an instance */ /* No child, so don't record an instance */
if (pid < 0) { if (pid <= 0) {
free(inst); free(argv[0]);
return; return;
} }
inst = xzalloc(sizeof(*inst));
inst->pid = pid; inst->pid = pid;
inst->prog = argv[0]; inst->prog = argv[0];
inst->type = xstrdup(type);
inst->device = xstrdup(device); inst->device = xstrdup(device);
inst->base_device = base_device(device); inst->base_device = base_device(device);
#if DO_PROGRESS_INDICATOR
inst->start_time = time(NULL); inst->start_time = time(NULL);
#endif
/* 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...) */
@ -692,7 +673,7 @@ static void execute(const char *type, const char *device, const char *mntpt,
* If the type isn't specified by the user, then use either the type * If the type isn't specified by the user, then use either the type
* specified in /etc/fstab, or "auto". * specified in /etc/fstab, or "auto".
*/ */
static void fsck_device(struct fs_info *fs, int interactive) static void fsck_device(struct fs_info *fs /*, int interactive */)
{ {
const char *type; const char *type;
@ -719,7 +700,7 @@ static void fsck_device(struct fs_info *fs, int interactive)
} }
num_running++; num_running++;
execute(type, fs->device, fs->mountpt, interactive); execute(type, fs->device, fs->mountpt /*, interactive */);
} }
/* /*
@ -871,32 +852,31 @@ 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 = 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 (!parallel_root) {
for (fs = filesys_info; fs; fs = fs->next) { for (fs = filesys_info; fs; fs = fs->next) {
if (LONE_CHAR(fs->mountpt, '/')) if (LONE_CHAR(fs->mountpt, '/')) {
if (!skip_root && !ignore(fs)) {
fsck_device(fs /*, 1*/);
status |= wait_many(FLAG_WAIT_ALL);
if (status > EXIT_NONDESTRUCT)
return status;
}
fs->flags |= FLAG_DONE;
break; break;
}
if (fs) {
if (!skip_root && !ignore(fs)) {
fsck_device(fs, 1);
status |= wait_many(FLAG_WAIT_ALL);
if (status > EXIT_NONDESTRUCT)
return status;
} }
fs->flags |= FLAG_DONE;
} }
} }
/* /*
* This is for the bone-headed user who enters the root * This is for the bone-headed user who has root
* filesystem twice. Skip root will skip all root entries. * filesystem listed twice.
* "Skip root" will skip _all_ root entries.
*/ */
if (skip_root) if (skip_root)
for (fs = filesys_info; fs; fs = fs->next) for (fs = filesys_info; fs; fs = fs->next)
@ -916,7 +896,7 @@ static int check_all(void)
continue; continue;
/* /*
* If the filesystem's pass number is higher * If the filesystem's pass number is higher
* than the current pass number, then we don't * than the current pass number, then we didn't
* do it yet. * do it yet.
*/ */
if (fs->passno > passno) { if (fs->passno > passno) {
@ -935,7 +915,7 @@ static int check_all(void)
/* /*
* Spawn off the fsck process * Spawn off the fsck process
*/ */
fsck_device(fs, serialize); fsck_device(fs /*, serialize*/);
fs->flags |= FLAG_DONE; fs->flags |= FLAG_DONE;
/* /*
@ -979,21 +959,16 @@ static void compile_fs_type(char *fs_type)
int num = 2; int num = 2;
smallint negate; smallint negate;
if (fs_type) { s = fs_type;
s = fs_type; while ((s = strchr(s, ','))) {
while ((s = strchr(s, ','))) { num++;
num++; s++;
s++;
}
} }
fs_type_list = xzalloc(num * sizeof(fs_type_list[0])); fs_type_list = xzalloc(num * sizeof(fs_type_list[0]));
fs_type_flag = xzalloc(num * sizeof(fs_type_flag[0])); fs_type_flag = xzalloc(num * sizeof(fs_type_flag[0]));
fs_type_negated = -1; /* not yet known is it negated or not */ fs_type_negated = -1; /* not yet known is it negated or not */
if (!fs_type)
return;
num = 0; num = 0;
s = fs_type; s = fs_type;
while (1) { while (1) {
@ -1031,12 +1006,12 @@ static void compile_fs_type(char *fs_type)
} }
} }
static void parse_args(int argc, char **argv) static void parse_args(char **argv)
{ {
int i, j; int i, j;
char *arg, *tmp; char *arg, *tmp;
char *options = NULL; char *options;
int optpos = 0; int optpos;
int opts_for_fsck = 0; int opts_for_fsck = 0;
/* in bss, so already zeroed /* in bss, so already zeroed
@ -1045,8 +1020,7 @@ static void parse_args(int argc, char **argv)
instance_list = NULL; instance_list = NULL;
*/ */
/* TODO: getopt32 */ for (i = 1; argv[i]; i++) {
for (i = 1; i < argc; i++) {
arg = argv[i]; arg = argv[i];
/* "/dev/blk" or "/path" or "UUID=xxx" or "LABEL=xxx" */ /* "/dev/blk" or "/path" or "UUID=xxx" or "LABEL=xxx" */
@ -1065,14 +1039,14 @@ static void parse_args(int argc, char **argv)
continue; continue;
} }
if (LONE_CHAR(arg + 1, '-')) { /* "--" ? */
opts_for_fsck = 1;
continue;
}
optpos = 0;
options = NULL;
for (j = 1; arg[j]; j++) { for (j = 1; arg[j]; j++) {
if (opts_for_fsck) {
optpos++;
/* one extra for '\0' */
options = xrealloc(options, optpos + 2);
options[optpos] = arg[j];
continue;
}
switch (arg[j]) { switch (arg[j]) {
case 'A': case 'A':
doall = 1; doall = 1;
@ -1085,7 +1059,8 @@ static void parse_args(int argc, char **argv)
goto next_arg; goto next_arg;
} }
/* -C n */ /* -C n */
progress_fd = xatoi_u(argv[++i]); if (!argv[++i]) bb_show_usage();
progress_fd = xatoi_u(argv[i]);
goto next_arg; goto next_arg;
#endif #endif
case 'V': case 'V':
@ -1114,16 +1089,13 @@ static void parse_args(int argc, char **argv)
bb_show_usage(); bb_show_usage();
if (arg[++j]) if (arg[++j])
tmp = &arg[j]; tmp = &arg[j];
else if (++i < argc) else if (argv[++i])
tmp = argv[i]; tmp = argv[i];
else else
bb_show_usage(); bb_show_usage();
fstype = xstrdup(tmp); fstype = xstrdup(tmp);
compile_fs_type(fstype); compile_fs_type(fstype);
goto next_arg; goto next_arg;
case '-':
opts_for_fsck++;
break;
case '?': case '?':
bb_show_usage(); bb_show_usage();
break; break;
@ -1141,8 +1113,6 @@ static void parse_args(int argc, char **argv)
options[optpos + 1] = '\0'; options[optpos + 1] = '\0';
args = xrealloc(args, (num_args+1) * sizeof(args[0])); args = xrealloc(args, (num_args+1) * sizeof(args[0]));
args[num_args++] = options; args[num_args++] = options;
optpos = 0;
options = NULL;
} }
} }
if (getenv("FSCK_FORCE_ALL_PARALLEL")) if (getenv("FSCK_FORCE_ALL_PARALLEL"))
@ -1160,17 +1130,18 @@ static void signal_cancel(int sig ATTRIBUTE_UNUSED)
int fsck_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; int fsck_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int fsck_main(int argc, char **argv) int fsck_main(int argc, char **argv)
{ {
int i, status = 0; int i, status;
int interactive; /*int interactive;*/
const char *fstab; const char *fstab;
struct fs_info *fs; struct fs_info *fs;
/* we want wait() to be interruptible */
signal_no_SA_RESTART_empty_mask(SIGINT, signal_cancel); signal_no_SA_RESTART_empty_mask(SIGINT, signal_cancel);
signal_no_SA_RESTART_empty_mask(SIGTERM, signal_cancel); signal_no_SA_RESTART_empty_mask(SIGTERM, signal_cancel);
setbuf(stdout, NULL); setbuf(stdout, NULL);
parse_args(argc, argv); parse_args(argv);
if (!notitle) if (!notitle)
puts("fsck (busybox "BB_VER", "BB_BT")"); puts("fsck (busybox "BB_VER", "BB_BT")");
@ -1182,18 +1153,14 @@ int fsck_main(int argc, 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) | serialize;*/
/* If -A was specified ("check all"), do that! */ if (num_devices == 0)
/*interactive =*/ serialize = doall = 1;
if (doall) if (doall)
return check_all(); return check_all();
if (num_devices == 0) { status = 0;
serialize = 1;
interactive = 1;
return check_all();
}
for (i = 0; i < num_devices; i++) { for (i = 0; i < num_devices; i++) {
if (cancel_requested) { if (cancel_requested) {
kill_all_if_cancel_requested(); kill_all_if_cancel_requested();
@ -1202,19 +1169,15 @@ int fsck_main(int argc, char **argv)
fs = lookup(devices[i]); fs = lookup(devices[i]);
if (!fs) if (!fs)
fs = create_fs_device(devices[i], 0, "auto", 0, -1, -1); fs = create_fs_device(devices[i], "", "auto", NULL, -1);
fsck_device(fs, interactive); fsck_device(fs /*, interactive */);
if (serialize if (serialize
|| (max_running && (num_running >= max_running)) || (max_running && (num_running >= max_running))
) { ) {
struct fsck_instance *inst; int exit_status = wait_one(0);
if (exit_status >= 0)
inst = wait_one(0); status |= exit_status;
if (inst) {
status |= inst->exit_status;
free_instance(inst);
}
if (verbose > 1) if (verbose > 1)
puts("----------------------------------"); puts("----------------------------------");
} }