fix #>&- syntax for closing fds
[oweals/busybox.git] / e2fsprogs / fsck.c
1 /* vi: set sw=4 ts=4: */
2 /*
3  * fsck --- A generic, parallelizing front-end for the fsck program.
4  * It will automatically try to run fsck programs in parallel if the
5  * devices are on separate spindles.  It is based on the same ideas as
6  * the generic front end for fsck by David Engel and Fred van Kempen,
7  * but it has been completely rewritten from scratch to support
8  * parallel execution.
9  *
10  * Written by Theodore Ts'o, <tytso@mit.edu>
11  *
12  * Miquel van Smoorenburg (miquels@drinkel.ow.org) 20-Oct-1994:
13  *   o Changed -t fstype to behave like with mount when -A (all file
14  *     systems) or -M (like mount) is specified.
15  *   o fsck looks if it can find the fsck.type program to decide
16  *     if it should ignore the fs type. This way more fsck programs
17  *     can be added without changing this front-end.
18  *   o -R flag skip root file system.
19  *
20  * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
21  *      2001, 2002, 2003, 2004, 2005 by  Theodore Ts'o.
22  *
23  * Licensed under GPLv2, see file LICENSE in this tarball for details.
24  */
25
26 /* All filesystem specific hooks have been removed.
27  * If filesystem cannot be determined, we will execute
28  * "fsck.auto". Currently this also happens if you specify
29  * UUID=xxx or LABEL=xxx as an object to check.
30  * Detection code for that is also probably has to be in fsck.auto.
31  *
32  * In other words, this is _really_ is just a driver program which
33  * spawns actual fsck.something for each filesystem to check.
34  * It doesn't guess filesystem types from on-disk format.
35  */
36
37 #include "libbb.h"
38
39 /* "progress indicator" code is somewhat buggy and ext[23] specific.
40  * We should be filesystem agnostic. IOW: there should be a well-defined
41  * API for fsck.something, NOT ad-hoc hacks in generic fsck. */
42 #define DO_PROGRESS_INDICATOR 0
43
44 #define EXIT_OK          0
45 #define EXIT_NONDESTRUCT 1
46 #define EXIT_DESTRUCT    2
47 #define EXIT_UNCORRECTED 4
48 #define EXIT_ERROR       8
49 #define EXIT_USAGE       16
50 #define FSCK_CANCELED    32     /* Aborted with a signal or ^C */
51
52 /*
53  * Internal structure for mount table entries.
54  */
55
56 struct fs_info {
57         struct fs_info *next;
58         char    *device;
59         char    *mountpt;
60         char    *type;
61         char    *opts;
62         int     passno;
63         int     flags;
64 };
65
66 #define FLAG_DONE 1
67 #define FLAG_PROGRESS 2
68 /*
69  * Structure to allow exit codes to be stored
70  */
71 struct fsck_instance {
72         struct fsck_instance *next;
73         int     pid;
74         int     flags;
75 #if DO_PROGRESS_INDICATOR
76         time_t  start_time;
77 #endif
78         char    *prog;
79         char    *device;
80         char    *base_device; /* /dev/hda for /dev/hdaN etc */
81 };
82
83 static const char ignored_types[] ALIGN1 =
84         "ignore\0"
85         "iso9660\0"
86         "nfs\0"
87         "proc\0"
88         "sw\0"
89         "swap\0"
90         "tmpfs\0"
91         "devpts\0";
92
93 #if 0
94 static const char really_wanted[] ALIGN1 =
95         "minix\0"
96         "ext2\0"
97         "ext3\0"
98         "jfs\0"
99         "reiserfs\0"
100         "xiafs\0"
101         "xfs\0";
102 #endif
103
104 #define BASE_MD "/dev/md"
105
106 static char **devices;
107 static char **args;
108 static int num_devices;
109 static int num_args;
110 static int verbose;
111
112 #define FS_TYPE_FLAG_NORMAL 0
113 #define FS_TYPE_FLAG_OPT    1
114 #define FS_TYPE_FLAG_NEGOPT 2
115 static char **fs_type_list;
116 static uint8_t *fs_type_flag;
117 static smallint fs_type_negated;
118
119 static volatile smallint cancel_requested;
120 static smallint doall;
121 static smallint noexecute;
122 static smallint serialize;
123 static smallint skip_root;
124 /* static smallint like_mount; */
125 static smallint notitle;
126 static smallint parallel_root;
127 static smallint force_all_parallel;
128
129 #if DO_PROGRESS_INDICATOR
130 static smallint progress;
131 static int progress_fd;
132 #endif
133
134 static int num_running;
135 static int max_running;
136 static char *fstype;
137 static struct fs_info *filesys_info;
138 static struct fs_info *filesys_last;
139 static struct fsck_instance *instance_list;
140
141 /*
142  * Return the "base device" given a particular device; this is used to
143  * assure that we only fsck one partition on a particular drive at any
144  * one time.  Otherwise, the disk heads will be seeking all over the
145  * place.  If the base device cannot be determined, return NULL.
146  *
147  * The base_device() function returns an allocated string which must
148  * be freed.
149  */
150 #if ENABLE_FEATURE_DEVFS
151 /*
152  * Required for the uber-silly devfs /dev/ide/host1/bus2/target3/lun3
153  * pathames.
154  */
155 static const char *const devfs_hier[] = {
156         "host", "bus", "target", "lun", NULL
157 };
158 #endif
159
160 static char *base_device(const char *device)
161 {
162         char *str, *cp;
163 #if ENABLE_FEATURE_DEVFS
164         const char *const *hier;
165         const char *disk;
166         int len;
167 #endif
168         cp = str = xstrdup(device);
169
170         /* Skip over /dev/; if it's not present, give up. */
171         if (strncmp(cp, "/dev/", 5) != 0)
172                 goto errout;
173         cp += 5;
174
175         /*
176          * For md devices, we treat them all as if they were all
177          * on one disk, since we don't know how to parallelize them.
178          */
179         if (cp[0] == 'm' && cp[1] == 'd') {
180                 cp[2] = 0;
181                 return str;
182         }
183
184         /* Handle DAC 960 devices */
185         if (strncmp(cp, "rd/", 3) == 0) {
186                 cp += 3;
187                 if (cp[0] != 'c' || !isdigit(cp[1])
188                  || cp[2] != 'd' || !isdigit(cp[3]))
189                         goto errout;
190                 cp[4] = 0;
191                 return str;
192         }
193
194         /* Now let's handle /dev/hd* and /dev/sd* devices.... */
195         if ((cp[0] == 'h' || cp[0] == 's') && cp[1] == 'd') {
196                 cp += 2;
197                 /* If there's a single number after /dev/hd, skip it */
198                 if (isdigit(*cp))
199                         cp++;
200                 /* What follows must be an alpha char, or give up */
201                 if (!isalpha(*cp))
202                         goto errout;
203                 cp[1] = 0;
204                 return str;
205         }
206
207 #if ENABLE_FEATURE_DEVFS
208         /* Now let's handle devfs (ugh) names */
209         len = 0;
210         if (strncmp(cp, "ide/", 4) == 0)
211                 len = 4;
212         if (strncmp(cp, "scsi/", 5) == 0)
213                 len = 5;
214         if (len) {
215                 cp += len;
216                 /*
217                  * Now we proceed down the expected devfs hierarchy.
218                  * i.e., .../host1/bus2/target3/lun4/...
219                  * If we don't find the expected token, followed by
220                  * some number of digits at each level, abort.
221                  */
222                 for (hier = devfs_hier; *hier; hier++) {
223                         len = strlen(*hier);
224                         if (strncmp(cp, *hier, len) != 0)
225                                 goto errout;
226                         cp += len;
227                         while (*cp != '/' && *cp != 0) {
228                                 if (!isdigit(*cp))
229                                         goto errout;
230                                 cp++;
231                         }
232                         cp++;
233                 }
234                 cp[-1] = 0;
235                 return str;
236         }
237
238         /* Now handle devfs /dev/disc or /dev/disk names */
239         disk = 0;
240         if (strncmp(cp, "discs/", 6) == 0)
241                 disk = "disc";
242         else if (strncmp(cp, "disks/", 6) == 0)
243                 disk = "disk";
244         if (disk) {
245                 cp += 6;
246                 if (strncmp(cp, disk, 4) != 0)
247                         goto errout;
248                 cp += 4;
249                 while (*cp != '/' && *cp != 0) {
250                         if (!isdigit(*cp))
251                                 goto errout;
252                         cp++;
253                 }
254                 *cp = 0;
255                 return str;
256         }
257 #endif
258  errout:
259         free(str);
260         return NULL;
261 }
262
263 static void free_instance(struct fsck_instance *p)
264 {
265         free(p->prog);
266         free(p->device);
267         free(p->base_device);
268         free(p);
269 }
270
271 static struct fs_info *create_fs_device(const char *device, const char *mntpnt,
272                                         const char *type, const char *opts,
273                                         int passno)
274 {
275         struct fs_info *fs;
276
277         fs = xzalloc(sizeof(*fs));
278         fs->device = xstrdup(device);
279         fs->mountpt = xstrdup(mntpnt);
280         if (strchr(type, ','))
281                 type = (char *)"auto";
282         fs->type = xstrdup(type);
283         fs->opts = xstrdup(opts ? opts : "");
284         fs->passno = passno < 0 ? 1 : passno;
285         /*fs->flags = 0; */
286         /*fs->next = NULL; */
287
288         if (!filesys_info)
289                 filesys_info = fs;
290         else
291                 filesys_last->next = fs;
292         filesys_last = fs;
293
294         return fs;
295 }
296
297 /* Load the filesystem database from /etc/fstab */
298 static void load_fs_info(const char *filename)
299 {
300         FILE *fstab;
301         struct mntent mte;
302         struct fs_info *fs;
303
304         fstab = setmntent(filename, "r");
305         if (!fstab) {
306                 bb_perror_msg("cannot read %s", filename);
307                 return;
308         }
309
310         // Loop through entries
311         while (getmntent_r(fstab, &mte, bb_common_bufsiz1, COMMON_BUFSIZE)) {
312                 //bb_info_msg("CREATE[%s][%s][%s][%s][%d]", mte.mnt_fsname, mte.mnt_dir,
313                 //      mte.mnt_type, mte.mnt_opts,
314                 //      mte.mnt_passno);
315                 fs = create_fs_device(mte.mnt_fsname, mte.mnt_dir,
316                         mte.mnt_type, mte.mnt_opts,
317                         mte.mnt_passno);
318         }
319         endmntent(fstab);
320 }
321
322 /* Lookup filesys in /etc/fstab and return the corresponding entry. */
323 static struct fs_info *lookup(char *filesys)
324 {
325         struct fs_info *fs;
326
327         for (fs = filesys_info; fs; fs = fs->next) {
328                 if (strcmp(filesys, fs->device) == 0
329                  || (fs->mountpt && strcmp(filesys, fs->mountpt) == 0)
330                 )
331                         break;
332         }
333
334         return fs;
335 }
336
337 #if DO_PROGRESS_INDICATOR
338 static int progress_active(void)
339 {
340         struct fsck_instance *inst;
341
342         for (inst = instance_list; inst; inst = inst->next) {
343                 if (inst->flags & FLAG_DONE)
344                         continue;
345                 if (inst->flags & FLAG_PROGRESS)
346                         return 1;
347         }
348         return 0;
349 }
350 #endif
351
352
353 /*
354  * Send a signal to all outstanding fsck child processes
355  */
356 static void kill_all_if_cancel_requested(void)
357 {
358         static smallint kill_sent;
359
360         struct fsck_instance *inst;
361
362         if (!cancel_requested || kill_sent)
363                 return;
364
365         for (inst = instance_list; inst; inst = inst->next) {
366                 if (inst->flags & FLAG_DONE)
367                         continue;
368                 kill(inst->pid, SIGTERM);
369         }
370         kill_sent = 1;
371 }
372
373 /*
374  * Wait for one child process to exit; when it does, unlink it from
375  * the list of executing child processes, free, and return its exit status.
376  * If there is no exited child, return -1.
377  */
378 static int wait_one(int flags)
379 {
380         int status;
381         int sig;
382         struct fsck_instance *inst, *prev;
383         pid_t pid;
384
385         if (!instance_list)
386                 return -1;
387         /* if (noexecute) { already returned -1; } */
388
389         while (1) {
390                 pid = waitpid(-1, &status, flags);
391                 kill_all_if_cancel_requested();
392                 if (pid == 0) /* flags == WNOHANG and no children exited */
393                         return -1;
394                 if (pid < 0) {
395                         if (errno == EINTR)
396                                 continue;
397                         if (errno == ECHILD) { /* paranoia */
398                                 bb_error_msg("wait: no more children");
399                                 return -1;
400                         }
401                         bb_perror_msg("wait");
402                         continue;
403                 }
404                 prev = NULL;
405                 inst = instance_list;
406                 do {
407                         if (inst->pid == pid)
408                                 goto child_died;
409                         prev = inst;
410                         inst = inst->next;
411                 } while (inst);
412         }
413  child_died:
414
415         if (WIFEXITED(status))
416                 status = WEXITSTATUS(status);
417         else if (WIFSIGNALED(status)) {
418                 sig = WTERMSIG(status);
419                 status = EXIT_UNCORRECTED;
420                 if (sig != SIGINT) {
421                         printf("Warning: %s %s terminated "
422                                 "by signal %d\n",
423                                 inst->prog, inst->device, sig);
424                         status = EXIT_ERROR;
425                 }
426         } else {
427                 printf("%s %s: status is %x, should never happen\n",
428                         inst->prog, inst->device, status);
429                 status = EXIT_ERROR;
430         }
431
432 #if DO_PROGRESS_INDICATOR
433         if (progress && (inst->flags & FLAG_PROGRESS) && !progress_active()) {
434                 struct fsck_instance *inst2;
435                 for (inst2 = instance_list; inst2; inst2 = inst2->next) {
436                         if (inst2->flags & FLAG_DONE)
437                                 continue;
438                         if (strcmp(inst2->type, "ext2") != 0
439                          && strcmp(inst2->type, "ext3") != 0
440                         ) {
441                                 continue;
442                         }
443                         /* ext[23], we will send USR1
444                          * (request to start displaying progress bar)
445                          *
446                          * If we've just started the fsck, wait a tiny
447                          * bit before sending the kill, to give it
448                          * time to set up the signal handler
449                          */
450                         if (inst2->start_time >= time(NULL) - 1)
451                                 sleep(1);
452                         kill(inst2->pid, SIGUSR1);
453                         inst2->flags |= FLAG_PROGRESS;
454                         break;
455                 }
456         }
457 #endif
458
459         if (prev)
460                 prev->next = inst->next;
461         else
462                 instance_list = inst->next;
463         if (verbose > 1)
464                 printf("Finished with %s (exit status %d)\n",
465                        inst->device, status);
466         num_running--;
467         free_instance(inst);
468
469         return status;
470 }
471
472 /*
473  * Wait until all executing child processes have exited; return the
474  * logical OR of all of their exit code values.
475  */
476 #define FLAG_WAIT_ALL           0
477 #define FLAG_WAIT_ATLEAST_ONE   WNOHANG
478 static int wait_many(int flags)
479 {
480         int exit_status;
481         int global_status = 0;
482         int wait_flags = 0;
483
484         while ((exit_status = wait_one(wait_flags)) != -1) {
485                 global_status |= exit_status;
486                 wait_flags |= flags;
487         }
488         return global_status;
489 }
490
491 /*
492  * Execute a particular fsck program, and link it into the list of
493  * child processes we are waiting for.
494  */
495 static void execute(const char *type, const char *device,
496                 const char *mntpt /*, int interactive */)
497 {
498         char *argv[num_args + 4]; /* see count below: */
499         int argc;
500         int i;
501         struct fsck_instance *inst;
502         pid_t pid;
503
504         argv[0] = xasprintf("fsck.%s", type); /* 1 */
505         for (i = 0; i < num_args; i++)
506                 argv[i+1] = args[i]; /* num_args */
507         argc = num_args + 1;
508
509 #if DO_PROGRESS_INDICATOR
510         if (progress && !progress_active()) {
511                 if (strcmp(type, "ext2") == 0
512                  || strcmp(type, "ext3") == 0
513                 ) {
514                         argv[argc++] = xasprintf("-C%d", progress_fd); /* 1 */
515                         inst->flags |= FLAG_PROGRESS;
516                 }
517         }
518 #endif
519
520         argv[argc++] = (char*)device; /* 1 */
521         argv[argc] = NULL; /* 1 */
522
523         if (verbose || noexecute) {
524                 printf("[%s (%d) -- %s]", argv[0], num_running,
525                                         mntpt ? mntpt : device);
526                 for (i = 0; i < argc; i++)
527                         printf(" %s", argv[i]);
528                 bb_putchar('\n');
529         }
530
531         /* Fork and execute the correct program. */
532         pid = -1;
533         if (!noexecute) {
534                 pid = spawn(argv);
535                 if (pid < 0)
536                         bb_simple_perror_msg(argv[0]);
537         }
538
539 #if DO_PROGRESS_INDICATOR
540         free(argv[num_args + 1]);
541 #endif
542
543         /* No child, so don't record an instance */
544         if (pid <= 0) {
545                 free(argv[0]);
546                 return;
547         }
548
549         inst = xzalloc(sizeof(*inst));
550         inst->pid = pid;
551         inst->prog = argv[0];
552         inst->device = xstrdup(device);
553         inst->base_device = base_device(device);
554 #if DO_PROGRESS_INDICATOR
555         inst->start_time = time(NULL);
556 #endif
557
558         /* Add to the list of running fsck's.
559          * (was adding to the end, but adding to the front is simpler...) */
560         inst->next = instance_list;
561         instance_list = inst;
562 }
563
564 /*
565  * Run the fsck program on a particular device
566  *
567  * If the type is specified using -t, and it isn't prefixed with "no"
568  * (as in "noext2") and only one filesystem type is specified, then
569  * use that type regardless of what is specified in /etc/fstab.
570  *
571  * If the type isn't specified by the user, then use either the type
572  * specified in /etc/fstab, or "auto".
573  */
574 static void fsck_device(struct fs_info *fs /*, int interactive */)
575 {
576         const char *type;
577
578         if (strcmp(fs->type, "auto") != 0) {
579                 type = fs->type;
580                 if (verbose > 2)
581                         bb_info_msg("using filesystem type '%s' %s",
582                                         type, "from fstab");
583         } else if (fstype
584          && (fstype[0] != 'n' || fstype[1] != 'o') /* != "no" */
585          && strncmp(fstype, "opts=", 5) != 0
586          && strncmp(fstype, "loop", 4) != 0
587          && !strchr(fstype, ',')
588         ) {
589                 type = fstype;
590                 if (verbose > 2)
591                         bb_info_msg("using filesystem type '%s' %s",
592                                         type, "from -t");
593         } else {
594                 type = "auto";
595                 if (verbose > 2)
596                         bb_info_msg("using filesystem type '%s' %s",
597                                         type, "(default)");
598         }
599
600         num_running++;
601         execute(type, fs->device, fs->mountpt /*, interactive */);
602 }
603
604 /*
605  * Returns TRUE if a partition on the same disk is already being
606  * checked.
607  */
608 static int device_already_active(char *device)
609 {
610         struct fsck_instance *inst;
611         char *base;
612
613         if (force_all_parallel)
614                 return 0;
615
616 #ifdef BASE_MD
617         /* Don't check a soft raid disk with any other disk */
618         if (instance_list
619          && (!strncmp(instance_list->device, BASE_MD, sizeof(BASE_MD)-1)
620              || !strncmp(device, BASE_MD, sizeof(BASE_MD)-1))
621         ) {
622                 return 1;
623         }
624 #endif
625
626         base = base_device(device);
627         /*
628          * If we don't know the base device, assume that the device is
629          * already active if there are any fsck instances running.
630          */
631         if (!base)
632                 return (instance_list != NULL);
633
634         for (inst = instance_list; inst; inst = inst->next) {
635                 if (!inst->base_device || !strcmp(base, inst->base_device)) {
636                         free(base);
637                         return 1;
638                 }
639         }
640
641         free(base);
642         return 0;
643 }
644
645 /*
646  * This function returns true if a particular option appears in a
647  * comma-delimited options list
648  */
649 static int opt_in_list(char *opt, char *optlist)
650 {
651         char *s;
652         int len;
653
654         if (!optlist)
655                 return 0;
656
657         len = strlen(opt);
658         s = optlist - 1;
659         while (1) {
660                 s = strstr(s + 1, opt);
661                 if (!s)
662                         return 0;
663                 /* neither "opt.." nor "xxx,opt.."? */
664                 if (s != optlist && s[-1] != ',')
665                         continue;
666                 /* neither "..opt" nor "..opt,xxx"? */
667                 if (s[len] != '\0' && s[len] != ',')
668                         continue;
669                 return 1;
670         }
671 }
672
673 /* See if the filesystem matches the criteria given by the -t option */
674 static int fs_match(struct fs_info *fs)
675 {
676         int n, ret, checked_type;
677         char *cp;
678
679         if (!fs_type_list)
680                 return 1;
681
682         ret = 0;
683         checked_type = 0;
684         n = 0;
685         while (1) {
686                 cp = fs_type_list[n];
687                 if (!cp)
688                         break;
689                 switch (fs_type_flag[n]) {
690                 case FS_TYPE_FLAG_NORMAL:
691                         checked_type++;
692                         if (strcmp(cp, fs->type) == 0)
693                                 ret = 1;
694                         break;
695                 case FS_TYPE_FLAG_NEGOPT:
696                         if (opt_in_list(cp, fs->opts))
697                                 return 0;
698                         break;
699                 case FS_TYPE_FLAG_OPT:
700                         if (!opt_in_list(cp, fs->opts))
701                                 return 0;
702                         break;
703                 }
704                 n++;
705         }
706         if (checked_type == 0)
707                 return 1;
708
709         return (fs_type_negated ? !ret : ret);
710 }
711
712 /* Check if we should ignore this filesystem. */
713 static int ignore(struct fs_info *fs)
714 {
715         /*
716          * If the pass number is 0, ignore it.
717          */
718         if (fs->passno == 0)
719                 return 1;
720
721         /*
722          * If a specific fstype is specified, and it doesn't match,
723          * ignore it.
724          */
725         if (!fs_match(fs))
726                 return 1;
727
728         /* Are we ignoring this type? */
729         if (index_in_strings(ignored_types, fs->type) >= 0)
730                 return 1;
731
732         /* We can and want to check this file system type. */
733         return 0;
734 }
735
736 /* Check all file systems, using the /etc/fstab table. */
737 static int check_all(void)
738 {
739         struct fs_info *fs;
740         int status = EXIT_OK;
741         smallint not_done_yet;
742         smallint pass_done;
743         int passno;
744
745         if (verbose)
746                 puts("Checking all filesystems");
747
748         /*
749          * Do an initial scan over the filesystem; mark filesystems
750          * which should be ignored as done, and resolve any "auto"
751          * filesystem types (done as a side-effect of calling ignore()).
752          */
753         for (fs = filesys_info; fs; fs = fs->next)
754                 if (ignore(fs))
755                         fs->flags |= FLAG_DONE;
756
757         /*
758          * Find and check the root filesystem.
759          */
760         if (!parallel_root) {
761                 for (fs = filesys_info; fs; fs = fs->next) {
762                         if (LONE_CHAR(fs->mountpt, '/')) {
763                                 if (!skip_root && !ignore(fs)) {
764                                         fsck_device(fs /*, 1*/);
765                                         status |= wait_many(FLAG_WAIT_ALL);
766                                         if (status > EXIT_NONDESTRUCT)
767                                                 return status;
768                                 }
769                                 fs->flags |= FLAG_DONE;
770                                 break;
771                         }
772                 }
773         }
774         /*
775          * This is for the bone-headed user who has root
776          * filesystem listed twice.
777          * "Skip root" will skip _all_ root entries.
778          */
779         if (skip_root)
780                 for (fs = filesys_info; fs; fs = fs->next)
781                         if (LONE_CHAR(fs->mountpt, '/'))
782                                 fs->flags |= FLAG_DONE;
783
784         not_done_yet = 1;
785         passno = 1;
786         while (not_done_yet) {
787                 not_done_yet = 0;
788                 pass_done = 1;
789
790                 for (fs = filesys_info; fs; fs = fs->next) {
791                         if (cancel_requested)
792                                 break;
793                         if (fs->flags & FLAG_DONE)
794                                 continue;
795                         /*
796                          * If the filesystem's pass number is higher
797                          * than the current pass number, then we didn't
798                          * do it yet.
799                          */
800                         if (fs->passno > passno) {
801                                 not_done_yet = 1;
802                                 continue;
803                         }
804                         /*
805                          * If a filesystem on a particular device has
806                          * already been spawned, then we need to defer
807                          * this to another pass.
808                          */
809                         if (device_already_active(fs->device)) {
810                                 pass_done = 0;
811                                 continue;
812                         }
813                         /*
814                          * Spawn off the fsck process
815                          */
816                         fsck_device(fs /*, serialize*/);
817                         fs->flags |= FLAG_DONE;
818
819                         /*
820                          * Only do one filesystem at a time, or if we
821                          * have a limit on the number of fsck's extant
822                          * at one time, apply that limit.
823                          */
824                         if (serialize
825                          || (max_running && (num_running >= max_running))
826                         ) {
827                                 pass_done = 0;
828                                 break;
829                         }
830                 }
831                 if (cancel_requested)
832                         break;
833                 if (verbose > 1)
834                         printf("--waiting-- (pass %d)\n", passno);
835                 status |= wait_many(pass_done ? FLAG_WAIT_ALL :
836                                     FLAG_WAIT_ATLEAST_ONE);
837                 if (pass_done) {
838                         if (verbose > 1)
839                                 puts("----------------------------------");
840                         passno++;
841                 } else
842                         not_done_yet = 1;
843         }
844         kill_all_if_cancel_requested();
845         status |= wait_many(FLAG_WAIT_ATLEAST_ONE);
846         return status;
847 }
848
849 /*
850  * Deal with the fsck -t argument.
851  * Huh, for mount "-t novfat,nfs" means "neither vfat nor nfs"!
852  * Why here we require "-t novfat,nonfs" ??
853  */
854 static void compile_fs_type(char *fs_type)
855 {
856         char *s;
857         int num = 2;
858         smallint negate;
859
860         s = fs_type;
861         while ((s = strchr(s, ','))) {
862                 num++;
863                 s++;
864         }
865
866         fs_type_list = xzalloc(num * sizeof(fs_type_list[0]));
867         fs_type_flag = xzalloc(num * sizeof(fs_type_flag[0]));
868         fs_type_negated = -1; /* not yet known is it negated or not */
869
870         num = 0;
871         s = fs_type;
872         while (1) {
873                 char *comma;
874
875                 negate = 0;
876                 if (s[0] == 'n' && s[1] == 'o') { /* "no.." */
877                         s += 2;
878                         negate = 1;
879                 } else if (s[0] == '!') {
880                         s++;
881                         negate = 1;
882                 }
883
884                 if (strcmp(s, "loop") == 0)
885                         /* loop is really short-hand for opts=loop */
886                         goto loop_special_case;
887                 if (strncmp(s, "opts=", 5) == 0) {
888                         s += 5;
889  loop_special_case:
890                         fs_type_flag[num] = negate ? FS_TYPE_FLAG_NEGOPT : FS_TYPE_FLAG_OPT;
891                 } else {
892                         if (fs_type_negated == -1)
893                                 fs_type_negated = negate;
894                         if (fs_type_negated != negate)
895                                 bb_error_msg_and_die(
896 "either all or none of the filesystem types passed to -t must be prefixed "
897 "with 'no' or '!'");
898                 }
899                 comma = strchr(s, ',');
900                 fs_type_list[num++] = comma ? xstrndup(s, comma-s) : xstrdup(s);
901                 if (!comma)
902                         break;
903                 s = comma + 1;
904         }
905 }
906
907 static void parse_args(char **argv)
908 {
909         int i, j;
910         char *arg, *tmp;
911         char *options;
912         int optpos;
913         int opts_for_fsck = 0;
914
915         /* in bss, so already zeroed
916         num_devices = 0;
917         num_args = 0;
918         instance_list = NULL;
919         */
920
921         for (i = 1; argv[i]; i++) {
922                 arg = argv[i];
923
924                 /* "/dev/blk" or "/path" or "UUID=xxx" or "LABEL=xxx" */
925                 if ((arg[0] == '/' && !opts_for_fsck) || strchr(arg, '=')) {
926 // FIXME: must check that arg is a blkdev, or resolve
927 // "/path", "UUID=xxx" or "LABEL=xxx" into block device name
928 // ("UUID=xxx"/"LABEL=xxx" can probably shifted to fsck.auto duties)
929                         devices = xrealloc_vector(devices, 2, num_devices);
930                         devices[num_devices++] = xstrdup(arg);
931                         continue;
932                 }
933
934                 if (arg[0] != '-' || opts_for_fsck) {
935                         args = xrealloc_vector(args, 2, num_args);
936                         args[num_args++] = xstrdup(arg);
937                         continue;
938                 }
939
940                 if (LONE_CHAR(arg + 1, '-')) { /* "--" ? */
941                         opts_for_fsck = 1;
942                         continue;
943                 }
944
945                 optpos = 0;
946                 options = NULL;
947                 for (j = 1; arg[j]; j++) {
948                         switch (arg[j]) {
949                         case 'A':
950                                 doall = 1;
951                                 break;
952 #if DO_PROGRESS_INDICATOR
953                         case 'C':
954                                 progress = 1;
955                                 if (arg[++j]) { /* -Cn */
956                                         progress_fd = xatoi_u(&arg[j]);
957                                         goto next_arg;
958                                 }
959                                 /* -C n */
960                                 if (!argv[++i]) bb_show_usage();
961                                 progress_fd = xatoi_u(argv[i]);
962                                 goto next_arg;
963 #endif
964                         case 'V':
965                                 verbose++;
966                                 break;
967                         case 'N':
968                                 noexecute = 1;
969                                 break;
970                         case 'R':
971                                 skip_root = 1;
972                                 break;
973                         case 'T':
974                                 notitle = 1;
975                                 break;
976 /*                      case 'M':
977                                 like_mount = 1;
978                                 break; */
979                         case 'P':
980                                 parallel_root = 1;
981                                 break;
982                         case 's':
983                                 serialize = 1;
984                                 break;
985                         case 't':
986                                 if (fstype)
987                                         bb_show_usage();
988                                 if (arg[++j])
989                                         tmp = &arg[j];
990                                 else if (argv[++i])
991                                         tmp = argv[i];
992                                 else
993                                         bb_show_usage();
994                                 fstype = xstrdup(tmp);
995                                 compile_fs_type(fstype);
996                                 goto next_arg;
997                         case '?':
998                                 bb_show_usage();
999                                 break;
1000                         default:
1001                                 optpos++;
1002                                 /* one extra for '\0' */
1003                                 options = xrealloc(options, optpos + 2);
1004                                 options[optpos] = arg[j];
1005                                 break;
1006                         }
1007                 }
1008  next_arg:
1009                 if (optpos) {
1010                         options[0] = '-';
1011                         options[optpos + 1] = '\0';
1012                         args = xrealloc_vector(args, 2, num_args);
1013                         args[num_args++] = options;
1014                 }
1015         }
1016         if (getenv("FSCK_FORCE_ALL_PARALLEL"))
1017                 force_all_parallel = 1;
1018         tmp = getenv("FSCK_MAX_INST");
1019         if (tmp)
1020                 max_running = xatoi(tmp);
1021 }
1022
1023 static void signal_cancel(int sig UNUSED_PARAM)
1024 {
1025         cancel_requested = 1;
1026 }
1027
1028 int fsck_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1029 int fsck_main(int argc UNUSED_PARAM, char **argv)
1030 {
1031         int i, status;
1032         /*int interactive;*/
1033         const char *fstab;
1034         struct fs_info *fs;
1035
1036         /* we want wait() to be interruptible */
1037         signal_no_SA_RESTART_empty_mask(SIGINT, signal_cancel);
1038         signal_no_SA_RESTART_empty_mask(SIGTERM, signal_cancel);
1039
1040         setbuf(stdout, NULL);
1041
1042         parse_args(argv);
1043
1044         if (!notitle)
1045                 puts("fsck (busybox "BB_VER", "BB_BT")");
1046
1047         /* Even plain "fsck /dev/hda1" needs fstab to get fs type,
1048          * so we are scanning it anyway */
1049         fstab = getenv("FSTAB_FILE");
1050         if (!fstab)
1051                 fstab = "/etc/fstab";
1052         load_fs_info(fstab);
1053
1054         /*interactive = (num_devices == 1) | serialize;*/
1055
1056         if (num_devices == 0)
1057                 /*interactive =*/ serialize = doall = 1;
1058         if (doall)
1059                 return check_all();
1060
1061         status = 0;
1062         for (i = 0; i < num_devices; i++) {
1063                 if (cancel_requested) {
1064                         kill_all_if_cancel_requested();
1065                         break;
1066                 }
1067
1068                 fs = lookup(devices[i]);
1069                 if (!fs)
1070                         fs = create_fs_device(devices[i], "", "auto", NULL, -1);
1071                 fsck_device(fs /*, interactive */);
1072
1073                 if (serialize
1074                  || (max_running && (num_running >= max_running))
1075                 ) {
1076                         int exit_status = wait_one(0);
1077                         if (exit_status >= 0)
1078                                 status |= exit_status;
1079                         if (verbose > 1)
1080                                 puts("----------------------------------");
1081                 }
1082         }
1083         status |= wait_many(FLAG_WAIT_ALL);
1084         return status;
1085 }