Home | History | Annotate | Download | only in misc
      1 /*
      2  * pfsck --- A generic, parallelizing front-end for the fsck program.
      3  * It will automatically try to run fsck programs in parallel if the
      4  * devices are on separate spindles.  It is based on the same ideas as
      5  * the generic front end for fsck by David Engel and Fred van Kempen,
      6  * but it has been completely rewritten from scratch to support
      7  * parallel execution.
      8  *
      9  * Written by Theodore Ts'o, <tytso (at) mit.edu>
     10  *
     11  * Miquel van Smoorenburg (miquels (at) drinkel.ow.org) 20-Oct-1994:
     12  *   o Changed -t fstype to behave like with mount when -A (all file
     13  *     systems) or -M (like mount) is specified.
     14  *   o fsck looks if it can find the fsck.type program to decide
     15  *     if it should ignore the fs type. This way more fsck programs
     16  *     can be added without changing this front-end.
     17  *   o -R flag skip root file system.
     18  *
     19  * Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
     20  * 	2001, 2002, 2003, 2004, 2005 by  Theodore Ts'o.
     21  *
     22  * %Begin-Header%
     23  * This file may be redistributed under the terms of the GNU Public
     24  * License.
     25  * %End-Header%
     26  */
     27 
     28 #define _XOPEN_SOURCE 600 /* for inclusion of sa_handler in Solaris */
     29 
     30 #include <sys/types.h>
     31 #include <sys/wait.h>
     32 #include <sys/stat.h>
     33 #include <limits.h>
     34 #include <stdio.h>
     35 #include <ctype.h>
     36 #include <string.h>
     37 #include <time.h>
     38 #if HAVE_STDLIB_H
     39 #include <stdlib.h>
     40 #endif
     41 #if HAVE_ERRNO_H
     42 #include <errno.h>
     43 #endif
     44 #if HAVE_PATHS_H
     45 #include <paths.h>
     46 #endif
     47 #if HAVE_UNISTD_H
     48 #include <unistd.h>
     49 #endif
     50 #if HAVE_ERRNO_H
     51 #include <errno.h>
     52 #endif
     53 #if HAVE_MALLOC_H
     54 #include <malloc.h>
     55 #endif
     56 #ifdef HAVE_SIGNAL_H
     57 #include <signal.h>
     58 #endif
     59 
     60 #include "../version.h"
     61 #include "nls-enable.h"
     62 #include "fsck.h"
     63 #include "blkid/blkid.h"
     64 
     65 #ifndef _PATH_MNTTAB
     66 #define	_PATH_MNTTAB	"/etc/fstab"
     67 #endif
     68 
     69 static const char *ignored_types[] = {
     70 	"ignore",
     71 	"iso9660",
     72 	"nfs",
     73 	"proc",
     74 	"sw",
     75 	"swap",
     76 	"tmpfs",
     77 	"devpts",
     78 	NULL
     79 };
     80 
     81 static const char *really_wanted[] = {
     82 	"minix",
     83 	"ext2",
     84 	"ext3",
     85 	"ext4",
     86 	"ext4dev",
     87 	"jfs",
     88 	"reiserfs",
     89 	"xiafs",
     90 	"xfs",
     91 	NULL
     92 };
     93 
     94 #define BASE_MD "/dev/md"
     95 
     96 /*
     97  * Global variables for options
     98  */
     99 static char *devices[MAX_DEVICES];
    100 static char *args[MAX_ARGS];
    101 static int num_devices, num_args;
    102 
    103 static int verbose = 0;
    104 static int doall = 0;
    105 static int noexecute = 0;
    106 static int serialize = 0;
    107 static int skip_root = 0;
    108 static int ignore_mounted = 0;
    109 static int notitle = 0;
    110 static int parallel_root = 0;
    111 static int progress = 0;
    112 static int progress_fd = 0;
    113 static int force_all_parallel = 0;
    114 static int num_running = 0;
    115 static int max_running = 0;
    116 static volatile int cancel_requested = 0;
    117 static int kill_sent = 0;
    118 static char *progname;
    119 static char *fstype = NULL;
    120 static struct fs_info *filesys_info = NULL, *filesys_last = NULL;
    121 static struct fsck_instance *instance_list;
    122 static const char *fsck_prefix_path = "/sbin:/sbin/fs.d:/sbin/fs:/etc/fs:/etc";
    123 static char *fsck_path = 0;
    124 static blkid_cache cache = NULL;
    125 
    126 static char *string_copy(const char *s)
    127 {
    128 	char	*ret;
    129 
    130 	if (!s)
    131 		return 0;
    132 	ret = malloc(strlen(s)+1);
    133 	if (ret)
    134 		strcpy(ret, s);
    135 	return ret;
    136 }
    137 
    138 static int string_to_int(const char *s)
    139 {
    140 	long l;
    141 	char *p;
    142 
    143 	l = strtol(s, &p, 0);
    144 	if (*p || l == LONG_MIN || l == LONG_MAX || l < 0 || l > INT_MAX)
    145 		return -1;
    146 	else
    147 		return (int) l;
    148 }
    149 
    150 static int ignore(struct fs_info *);
    151 
    152 static char *skip_over_blank(char *cp)
    153 {
    154 	while (*cp && isspace(*cp))
    155 		cp++;
    156 	return cp;
    157 }
    158 
    159 static char *skip_over_word(char *cp)
    160 {
    161 	while (*cp && !isspace(*cp))
    162 		cp++;
    163 	return cp;
    164 }
    165 
    166 static void strip_line(char *line)
    167 {
    168 	char	*p;
    169 
    170 	while (*line) {
    171 		p = line + strlen(line) - 1;
    172 		if ((*p == '\n') || (*p == '\r'))
    173 			*p = 0;
    174 		else
    175 			break;
    176 	}
    177 }
    178 
    179 static char *parse_word(char **buf)
    180 {
    181 	char *word, *next;
    182 
    183 	word = *buf;
    184 	if (*word == 0)
    185 		return 0;
    186 
    187 	word = skip_over_blank(word);
    188 	next = skip_over_word(word);
    189 	if (*next)
    190 		*next++ = 0;
    191 	*buf = next;
    192 	return word;
    193 }
    194 
    195 static void parse_escape(char *word)
    196 {
    197 	char	*p, *q;
    198 	int	ac, i;
    199 
    200 	if (!word)
    201 		return;
    202 
    203 	for (p = word, q = word; *p; p++, q++) {
    204 		*q = *p;
    205 		if (*p != '\\')
    206 			continue;
    207 		if (*++p == 0)
    208 			break;
    209 		if (*p == 't') {
    210 			*q = '\t';
    211 			continue;
    212 		}
    213 		if (*p == 'n') {
    214 			*q = '\n';
    215 			continue;
    216 		}
    217 		if (!isdigit(*p)) {
    218 			*q = *p;
    219 			continue;
    220 		}
    221 		ac = 0;
    222 		for (i = 0; i < 3; i++, p++) {
    223 			if (!isdigit(*p))
    224 				break;
    225 			ac = (ac * 8) + (*p - '0');
    226 		}
    227 		*q = ac;
    228 		p--;
    229 	}
    230 	*q = 0;
    231 }
    232 
    233 static void free_instance(struct fsck_instance *i)
    234 {
    235 	free(i->prog);
    236 	free(i->device);
    237 	free(i->base_device);
    238 	free(i);
    239 	return;
    240 }
    241 
    242 static struct fs_info *create_fs_device(const char *device, const char *mntpnt,
    243 					const char *type, const char *opts,
    244 					int freq, int passno)
    245 {
    246 	struct fs_info *fs;
    247 
    248 	if (!(fs = malloc(sizeof(struct fs_info))))
    249 		return NULL;
    250 
    251 	fs->device = string_copy(device);
    252 	fs->mountpt = string_copy(mntpnt);
    253 	fs->type = string_copy(type);
    254 	fs->opts = string_copy(opts ? opts : "");
    255 	fs->freq = freq;
    256 	fs->passno = passno;
    257 	fs->flags = 0;
    258 	fs->next = NULL;
    259 
    260 	if (!filesys_info)
    261 		filesys_info = fs;
    262 	else
    263 		filesys_last->next = fs;
    264 	filesys_last = fs;
    265 
    266 	return fs;
    267 }
    268 
    269 
    270 
    271 static int parse_fstab_line(char *line, struct fs_info **ret_fs)
    272 {
    273 	char	*dev, *device, *mntpnt, *type, *opts, *freq, *passno, *cp;
    274 	struct fs_info *fs;
    275 
    276 	*ret_fs = 0;
    277 	strip_line(line);
    278 	cp = line;
    279 
    280 	device = parse_word(&cp);
    281 	if (!device || *device == '#')
    282 		return 0;	/* Ignore blank lines and comments */
    283 	mntpnt = parse_word(&cp);
    284 	type = parse_word(&cp);
    285 	opts = parse_word(&cp);
    286 	freq = parse_word(&cp);
    287 	passno = parse_word(&cp);
    288 
    289 	if (!mntpnt || !type)
    290 		return -1;
    291 
    292 	parse_escape(device);
    293 	parse_escape(mntpnt);
    294 	parse_escape(type);
    295 	parse_escape(opts);
    296 	parse_escape(freq);
    297 	parse_escape(passno);
    298 
    299 	dev = blkid_get_devname(cache, device, NULL);
    300 	if (dev)
    301 		device = dev;
    302 
    303 	if (strchr(type, ','))
    304 		type = 0;
    305 
    306 	fs = create_fs_device(device, mntpnt, type ? type : "auto", opts,
    307 			      freq ? atoi(freq) : -1,
    308 			      passno ? atoi(passno) : -1);
    309 	free(dev);
    310 
    311 	if (!fs)
    312 		return -1;
    313 	*ret_fs = fs;
    314 	return 0;
    315 }
    316 
    317 static void interpret_type(struct fs_info *fs)
    318 {
    319 	char	*t;
    320 
    321 	if (strcmp(fs->type, "auto") != 0)
    322 		return;
    323 	t = blkid_get_tag_value(cache, "TYPE", fs->device);
    324 	if (t) {
    325 		free(fs->type);
    326 		fs->type = t;
    327 	}
    328 }
    329 
    330 /*
    331  * Load the filesystem database from /etc/fstab
    332  */
    333 static void load_fs_info(const char *filename)
    334 {
    335 	FILE	*f;
    336 	char	buf[1024];
    337 	int	lineno = 0;
    338 	int	old_fstab = 1;
    339 	struct fs_info *fs;
    340 
    341 	if ((f = fopen(filename, "r")) == NULL) {
    342 		fprintf(stderr, _("WARNING: couldn't open %s: %s\n"),
    343 			filename, strerror(errno));
    344 		return;
    345 	}
    346 	while (!feof(f)) {
    347 		lineno++;
    348 		if (!fgets(buf, sizeof(buf), f))
    349 			break;
    350 		buf[sizeof(buf)-1] = 0;
    351 		if (parse_fstab_line(buf, &fs) < 0) {
    352 			fprintf(stderr, _("WARNING: bad format "
    353 				"on line %d of %s\n"), lineno, filename);
    354 			continue;
    355 		}
    356 		if (!fs)
    357 			continue;
    358 		if (fs->passno < 0)
    359 			fs->passno = 0;
    360 		else
    361 			old_fstab = 0;
    362 	}
    363 
    364 	fclose(f);
    365 
    366 	if (old_fstab && filesys_info) {
    367 		fputs("\007\007\007", stderr);
    368 		fputs(_(
    369 		"WARNING: Your /etc/fstab does not contain the fsck passno\n"
    370 		"	field.  I will kludge around things for you, but you\n"
    371 		"	should fix your /etc/fstab file as soon as you can.\n\n"), stderr);
    372 
    373 		for (fs = filesys_info; fs; fs = fs->next) {
    374 			fs->passno = 1;
    375 		}
    376 	}
    377 }
    378 
    379 /* Lookup filesys in /etc/fstab and return the corresponding entry. */
    380 static struct fs_info *lookup(char *filesys)
    381 {
    382 	struct fs_info *fs;
    383 
    384 	/* No filesys name given. */
    385 	if (filesys == NULL)
    386 		return NULL;
    387 
    388 	for (fs = filesys_info; fs; fs = fs->next) {
    389 		if (!strcmp(filesys, fs->device) ||
    390 		    (fs->mountpt && !strcmp(filesys, fs->mountpt)))
    391 			break;
    392 	}
    393 
    394 	return fs;
    395 }
    396 
    397 /* Find fsck program for a given fs type. */
    398 static char *find_fsck(char *type)
    399 {
    400   char *s;
    401   const char *tpl;
    402   static char prog[256];
    403   char *p = string_copy(fsck_path);
    404   struct stat st;
    405 
    406   /* Are we looking for a program or just a type? */
    407   tpl = (strncmp(type, "fsck.", 5) ? "%s/fsck.%s" : "%s/%s");
    408 
    409   for(s = strtok(p, ":"); s; s = strtok(NULL, ":")) {
    410 	sprintf(prog, tpl, s, type);
    411 	if (stat(prog, &st) == 0) break;
    412   }
    413   free(p);
    414   return(s ? prog : NULL);
    415 }
    416 
    417 static int progress_active(NOARGS)
    418 {
    419 	struct fsck_instance *inst;
    420 
    421 	for (inst = instance_list; inst; inst = inst->next) {
    422 		if (inst->flags & FLAG_DONE)
    423 			continue;
    424 		if (inst->flags & FLAG_PROGRESS)
    425 			return 1;
    426 	}
    427 	return 0;
    428 }
    429 
    430 /*
    431  * Execute a particular fsck program, and link it into the list of
    432  * child processes we are waiting for.
    433  */
    434 static int execute(const char *type, const char *device, const char *mntpt,
    435 		   int interactive)
    436 {
    437 	char *s, *argv[80], prog[80];
    438 	int  argc, i;
    439 	struct fsck_instance *inst, *p;
    440 	pid_t	pid;
    441 
    442 	inst = malloc(sizeof(struct fsck_instance));
    443 	if (!inst)
    444 		return ENOMEM;
    445 	memset(inst, 0, sizeof(struct fsck_instance));
    446 
    447 	sprintf(prog, "fsck.%s", type);
    448 	argv[0] = string_copy(prog);
    449 	argc = 1;
    450 
    451 	for (i=0; i <num_args; i++)
    452 		argv[argc++] = string_copy(args[i]);
    453 
    454 	if (progress) {
    455 		if ((strcmp(type, "ext2") == 0) ||
    456 		    (strcmp(type, "ext3") == 0) ||
    457 		    (strcmp(type, "ext4") == 0) ||
    458 		    (strcmp(type, "ext4dev") == 0)) {
    459 			char tmp[80];
    460 
    461 			tmp[0] = 0;
    462 			if (!progress_active()) {
    463 				snprintf(tmp, 80, "-C%d", progress_fd);
    464 				inst->flags |= FLAG_PROGRESS;
    465 			} else if (progress_fd)
    466 				snprintf(tmp, 80, "-C%d", progress_fd * -1);
    467 			if (tmp[0])
    468 				argv[argc++] = string_copy(tmp);
    469 		}
    470 	}
    471 
    472 	argv[argc++] = string_copy(device);
    473 	argv[argc] = 0;
    474 
    475 	s = find_fsck(prog);
    476 	if (s == NULL) {
    477 		fprintf(stderr, _("fsck: %s: not found\n"), prog);
    478 		free(inst);
    479 		return ENOENT;
    480 	}
    481 
    482 	if (verbose || noexecute) {
    483 		printf("[%s (%d) -- %s] ", s, num_running,
    484 		       mntpt ? mntpt : device);
    485 		for (i=0; i < argc; i++)
    486 			printf("%s ", argv[i]);
    487 		printf("\n");
    488 	}
    489 
    490 	/* Fork and execute the correct program. */
    491 	if (noexecute)
    492 		pid = -1;
    493 	else if ((pid = fork()) < 0) {
    494 		perror("fork");
    495 		free(inst);
    496 		return errno;
    497 	} else if (pid == 0) {
    498 		if (!interactive)
    499 			close(0);
    500 		(void) execv(s, argv);
    501 		perror(argv[0]);
    502 		free(inst);
    503 		exit(EXIT_ERROR);
    504 	}
    505 
    506 	for (i=0; i < argc; i++)
    507 		free(argv[i]);
    508 
    509 	inst->pid = pid;
    510 	inst->prog = string_copy(prog);
    511 	inst->type = string_copy(type);
    512 	inst->device = string_copy(device);
    513 	inst->base_device = base_device(device);
    514 	inst->start_time = time(0);
    515 	inst->next = NULL;
    516 
    517 	/*
    518 	 * Find the end of the list, so we add the instance on at the end.
    519 	 */
    520 	for (p = instance_list; p && p->next; p = p->next);
    521 
    522 	if (p)
    523 		p->next = inst;
    524 	else
    525 		instance_list = inst;
    526 
    527 	return 0;
    528 }
    529 
    530 /*
    531  * Send a signal to all outstanding fsck child processes
    532  */
    533 static int kill_all(int signum)
    534 {
    535 	struct fsck_instance *inst;
    536 	int	n = 0;
    537 
    538 	for (inst = instance_list; inst; inst = inst->next) {
    539 		if (inst->flags & FLAG_DONE)
    540 			continue;
    541 		kill(inst->pid, signum);
    542 		n++;
    543 	}
    544 	return n;
    545 }
    546 
    547 /*
    548  * Wait for one child process to exit; when it does, unlink it from
    549  * the list of executing child processes, and return it.
    550  */
    551 static struct fsck_instance *wait_one(int flags)
    552 {
    553 	int	status;
    554 	int	sig;
    555 	struct fsck_instance *inst, *inst2, *prev;
    556 	pid_t	pid;
    557 
    558 	if (!instance_list)
    559 		return NULL;
    560 
    561 	if (noexecute) {
    562 		inst = instance_list;
    563 		prev = 0;
    564 #ifdef RANDOM_DEBUG
    565 		while (inst->next && (random() & 1)) {
    566 			prev = inst;
    567 			inst = inst->next;
    568 		}
    569 #endif
    570 		inst->exit_status = 0;
    571 		goto ret_inst;
    572 	}
    573 
    574 	/*
    575 	 * gcc -Wall fails saving throw against stupidity
    576 	 * (inst and prev are thought to be uninitialized variables)
    577 	 */
    578 	inst = prev = NULL;
    579 
    580 	do {
    581 		pid = waitpid(-1, &status, flags);
    582 		if (cancel_requested && !kill_sent) {
    583 			kill_all(SIGTERM);
    584 			kill_sent++;
    585 		}
    586 		if ((pid == 0) && (flags & WNOHANG))
    587 			return NULL;
    588 		if (pid < 0) {
    589 			if ((errno == EINTR) || (errno == EAGAIN))
    590 				continue;
    591 			if (errno == ECHILD) {
    592 				fprintf(stderr,
    593 					_("%s: wait: No more child process?!?\n"),
    594 					progname);
    595 				return NULL;
    596 			}
    597 			perror("wait");
    598 			continue;
    599 		}
    600 		for (prev = 0, inst = instance_list;
    601 		     inst;
    602 		     prev = inst, inst = inst->next) {
    603 			if (inst->pid == pid)
    604 				break;
    605 		}
    606 	} while (!inst);
    607 
    608 	if (WIFEXITED(status))
    609 		status = WEXITSTATUS(status);
    610 	else if (WIFSIGNALED(status)) {
    611 		sig = WTERMSIG(status);
    612 		if (sig == SIGINT) {
    613 			status = EXIT_UNCORRECTED;
    614 		} else {
    615 			printf(_("Warning... %s for device %s exited "
    616 			       "with signal %d.\n"),
    617 			       inst->prog, inst->device, sig);
    618 			status = EXIT_ERROR;
    619 		}
    620 	} else {
    621 		printf(_("%s %s: status is %x, should never happen.\n"),
    622 		       inst->prog, inst->device, status);
    623 		status = EXIT_ERROR;
    624 	}
    625 	inst->exit_status = status;
    626 	inst->flags |= FLAG_DONE;
    627 	if (progress && (inst->flags & FLAG_PROGRESS) &&
    628 	    !progress_active()) {
    629 		for (inst2 = instance_list; inst2; inst2 = inst2->next) {
    630 			if (inst2->flags & FLAG_DONE)
    631 				continue;
    632 			if (strcmp(inst2->type, "ext2") &&
    633 			    strcmp(inst2->type, "ext3") &&
    634 			    strcmp(inst2->type, "ext4") &&
    635 			    strcmp(inst2->type, "ext4dev"))
    636 				continue;
    637 			/*
    638 			 * If we've just started the fsck, wait a tiny
    639 			 * bit before sending the kill, to give it
    640 			 * time to set up the signal handler
    641 			 */
    642 			if (inst2->start_time < time(0)+2) {
    643 				if (fork() == 0) {
    644 					sleep(1);
    645 					kill(inst2->pid, SIGUSR1);
    646 					exit(0);
    647 				}
    648 			} else
    649 				kill(inst2->pid, SIGUSR1);
    650 			inst2->flags |= FLAG_PROGRESS;
    651 			break;
    652 		}
    653 	}
    654 ret_inst:
    655 	if (prev)
    656 		prev->next = inst->next;
    657 	else
    658 		instance_list = inst->next;
    659 	if (verbose > 1)
    660 		printf(_("Finished with %s (exit status %d)\n"),
    661 		       inst->device, inst->exit_status);
    662 	num_running--;
    663 	return inst;
    664 }
    665 
    666 #define FLAG_WAIT_ALL		0
    667 #define FLAG_WAIT_ATLEAST_ONE	1
    668 /*
    669  * Wait until all executing child processes have exited; return the
    670  * logical OR of all of their exit code values.
    671  */
    672 static int wait_many(int flags)
    673 {
    674 	struct fsck_instance *inst;
    675 	int	global_status = 0;
    676 	int	wait_flags = 0;
    677 
    678 	while ((inst = wait_one(wait_flags))) {
    679 		global_status |= inst->exit_status;
    680 		free_instance(inst);
    681 #ifdef RANDOM_DEBUG
    682 		if (noexecute && (flags & WNOHANG) && !(random() % 3))
    683 			break;
    684 #endif
    685 		if (flags & FLAG_WAIT_ATLEAST_ONE)
    686 			wait_flags = WNOHANG;
    687 	}
    688 	return global_status;
    689 }
    690 
    691 /*
    692  * Run the fsck program on a particular device
    693  *
    694  * If the type is specified using -t, and it isn't prefixed with "no"
    695  * (as in "noext2") and only one filesystem type is specified, then
    696  * use that type regardless of what is specified in /etc/fstab.
    697  *
    698  * If the type isn't specified by the user, then use either the type
    699  * specified in /etc/fstab, or DEFAULT_FSTYPE.
    700  */
    701 static void fsck_device(struct fs_info *fs, int interactive)
    702 {
    703 	const char *type;
    704 	int retval;
    705 
    706 	interpret_type(fs);
    707 
    708 	if (strcmp(fs->type, "auto") != 0)
    709 		type = fs->type;
    710 	else if (fstype && strncmp(fstype, "no", 2) &&
    711 	    strncmp(fstype, "opts=", 5) && strncmp(fstype, "loop", 4) &&
    712 	    !strchr(fstype, ','))
    713 		type = fstype;
    714 	else
    715 		type = DEFAULT_FSTYPE;
    716 
    717 	num_running++;
    718 	retval = execute(type, fs->device, fs->mountpt, interactive);
    719 	if (retval) {
    720 		fprintf(stderr, _("%s: Error %d while executing fsck.%s "
    721 			"for %s\n"), progname, retval, type, fs->device);
    722 		num_running--;
    723 	}
    724 }
    725 
    726 
    727 /*
    728  * Deal with the fsck -t argument.
    729  */
    730 static struct fs_type_compile {
    731 	char **list;
    732 	int *type;
    733 	int  negate;
    734 } fs_type_compiled;
    735 
    736 #define FS_TYPE_NORMAL	0
    737 #define FS_TYPE_OPT	1
    738 #define FS_TYPE_NEGOPT	2
    739 
    740 static const char *fs_type_syntax_error =
    741 N_("Either all or none of the filesystem types passed to -t must be prefixed\n"
    742    "with 'no' or '!'.\n");
    743 
    744 static void compile_fs_type(char *fs_type, struct fs_type_compile *cmp)
    745 {
    746 	char 	*cp, *list, *s;
    747 	int	num = 2;
    748 	int	negate, first_negate = 1;
    749 
    750 	if (fs_type) {
    751 		for (cp=fs_type; *cp; cp++) {
    752 			if (*cp == ',')
    753 				num++;
    754 		}
    755 	}
    756 
    757 	cmp->list = malloc(num * sizeof(char *));
    758 	cmp->type = malloc(num * sizeof(int));
    759 	if (!cmp->list || !cmp->type) {
    760 		fputs(_("Couldn't allocate memory for filesystem types\n"),
    761 		      stderr);
    762 		exit(EXIT_ERROR);
    763 	}
    764 	memset(cmp->list, 0, num * sizeof(char *));
    765 	memset(cmp->type, 0, num * sizeof(int));
    766 	cmp->negate = 0;
    767 
    768 	if (!fs_type)
    769 		return;
    770 
    771 	list = string_copy(fs_type);
    772 	num = 0;
    773 	s = strtok(list, ",");
    774 	while(s) {
    775 		negate = 0;
    776 		if (strncmp(s, "no", 2) == 0) {
    777 			s += 2;
    778 			negate = 1;
    779 		} else if (*s == '!') {
    780 			s++;
    781 			negate = 1;
    782 		}
    783 		if (strcmp(s, "loop") == 0)
    784 			/* loop is really short-hand for opts=loop */
    785 			goto loop_special_case;
    786 		else if (strncmp(s, "opts=", 5) == 0) {
    787 			s += 5;
    788 		loop_special_case:
    789 			cmp->type[num] = negate ? FS_TYPE_NEGOPT : FS_TYPE_OPT;
    790 		} else {
    791 			if (first_negate) {
    792 				cmp->negate = negate;
    793 				first_negate = 0;
    794 			}
    795 			if ((negate && !cmp->negate) ||
    796 			    (!negate && cmp->negate)) {
    797 				fputs(_(fs_type_syntax_error), stderr);
    798 				exit(EXIT_USAGE);
    799 			}
    800 		}
    801 #if 0
    802 		printf("Adding %s to list (type %d).\n", s, cmp->type[num]);
    803 #endif
    804 	        cmp->list[num++] = string_copy(s);
    805 		s = strtok(NULL, ",");
    806 	}
    807 	free(list);
    808 }
    809 
    810 /*
    811  * This function returns true if a particular option appears in a
    812  * comma-delimited options list
    813  */
    814 static int opt_in_list(const char *opt, char *optlist)
    815 {
    816 	char	*list, *s;
    817 
    818 	if (!optlist)
    819 		return 0;
    820 	list = string_copy(optlist);
    821 
    822 	s = strtok(list, ",");
    823 	while(s) {
    824 		if (strcmp(s, opt) == 0) {
    825 			free(list);
    826 			return 1;
    827 		}
    828 		s = strtok(NULL, ",");
    829 	}
    830         free(list);
    831 	return 0;
    832 }
    833 
    834 /* See if the filesystem matches the criteria given by the -t option */
    835 static int fs_match(struct fs_info *fs, struct fs_type_compile *cmp)
    836 {
    837 	int n, ret = 0, checked_type = 0;
    838 	char *cp;
    839 
    840 	if (cmp->list == 0 || cmp->list[0] == 0)
    841 		return 1;
    842 
    843 	for (n=0; (cp = cmp->list[n]); n++) {
    844 		switch (cmp->type[n]) {
    845 		case FS_TYPE_NORMAL:
    846 			checked_type++;
    847 			if (strcmp(cp, fs->type) == 0) {
    848 				ret = 1;
    849 			}
    850 			break;
    851 		case FS_TYPE_NEGOPT:
    852 			if (opt_in_list(cp, fs->opts))
    853 				return 0;
    854 			break;
    855 		case FS_TYPE_OPT:
    856 			if (!opt_in_list(cp, fs->opts))
    857 				return 0;
    858 			break;
    859 		}
    860 	}
    861 	if (checked_type == 0)
    862 		return 1;
    863 	return (cmp->negate ? !ret : ret);
    864 }
    865 
    866 /* Check if we should ignore this filesystem. */
    867 static int ignore(struct fs_info *fs)
    868 {
    869 	const char **ip;
    870 	int wanted = 0;
    871 
    872 	/*
    873 	 * If the pass number is 0, ignore it.
    874 	 */
    875 	if (fs->passno == 0)
    876 		return 1;
    877 
    878 	/*
    879 	 * If this is a bind mount, ignore it.
    880 	 */
    881 	if (opt_in_list("bind", fs->opts)) {
    882 		fprintf(stderr,
    883 			_("%s: skipping bad line in /etc/fstab: bind mount with nonzero fsck pass number\n"),
    884 			fs->mountpt);
    885 		return 1;
    886 	}
    887 
    888 	interpret_type(fs);
    889 
    890 	/*
    891 	 * If a specific fstype is specified, and it doesn't match,
    892 	 * ignore it.
    893 	 */
    894 	if (!fs_match(fs, &fs_type_compiled)) return 1;
    895 
    896 	/* Are we ignoring this type? */
    897 	for(ip = ignored_types; *ip; ip++)
    898 		if (strcmp(fs->type, *ip) == 0) return 1;
    899 
    900 	/* Do we really really want to check this fs? */
    901 	for(ip = really_wanted; *ip; ip++)
    902 		if (strcmp(fs->type, *ip) == 0) {
    903 			wanted = 1;
    904 			break;
    905 		}
    906 
    907 	/* See if the <fsck.fs> program is available. */
    908 	if (find_fsck(fs->type) == NULL) {
    909 		if (wanted)
    910 			fprintf(stderr, _("fsck: cannot check %s: fsck.%s not found\n"),
    911 				fs->device, fs->type);
    912 		return 1;
    913 	}
    914 
    915 	/* We can and want to check this file system type. */
    916 	return 0;
    917 }
    918 
    919 /*
    920  * Returns TRUE if a partition on the same disk is already being
    921  * checked.
    922  */
    923 static int device_already_active(char *device)
    924 {
    925 	struct fsck_instance *inst;
    926 	char *base;
    927 
    928 	if (force_all_parallel)
    929 		return 0;
    930 
    931 #ifdef BASE_MD
    932 	/* Don't check a soft raid disk with any other disk */
    933 	if (instance_list &&
    934 	    (!strncmp(instance_list->device, BASE_MD, sizeof(BASE_MD)-1) ||
    935 	     !strncmp(device, BASE_MD, sizeof(BASE_MD)-1)))
    936 		return 1;
    937 #endif
    938 
    939 	base = base_device(device);
    940 	/*
    941 	 * If we don't know the base device, assume that the device is
    942 	 * already active if there are any fsck instances running.
    943 	 */
    944 	if (!base)
    945 		return (instance_list != 0);
    946 	for (inst = instance_list; inst; inst = inst->next) {
    947 		if (!inst->base_device || !strcmp(base, inst->base_device)) {
    948 			free(base);
    949 			return 1;
    950 		}
    951 	}
    952 	free(base);
    953 	return 0;
    954 }
    955 
    956 /* Check all file systems, using the /etc/fstab table. */
    957 static int check_all(NOARGS)
    958 {
    959 	struct fs_info *fs = NULL;
    960 	int status = EXIT_OK;
    961 	int not_done_yet = 1;
    962 	int passno = 1;
    963 	int pass_done;
    964 
    965 	if (verbose)
    966 		fputs(_("Checking all file systems.\n"), stdout);
    967 
    968 	/*
    969 	 * Do an initial scan over the filesystem; mark filesystems
    970 	 * which should be ignored as done, and resolve any "auto"
    971 	 * filesystem types (done as a side-effect of calling ignore()).
    972 	 */
    973 	for (fs = filesys_info; fs; fs = fs->next) {
    974 		if (ignore(fs))
    975 			fs->flags |= FLAG_DONE;
    976 	}
    977 
    978 	/*
    979 	 * Find and check the root filesystem.
    980 	 */
    981 	if (!parallel_root) {
    982 		for (fs = filesys_info; fs; fs = fs->next) {
    983 			if (!strcmp(fs->mountpt, "/"))
    984 				break;
    985 		}
    986 		if (fs) {
    987 			if (!skip_root && !ignore(fs) &&
    988 			    !(ignore_mounted && is_mounted(fs->device))) {
    989 				fsck_device(fs, 1);
    990 				status |= wait_many(FLAG_WAIT_ALL);
    991 				if (status > EXIT_NONDESTRUCT)
    992 					return status;
    993 			}
    994 			fs->flags |= FLAG_DONE;
    995 		}
    996 	}
    997 	/*
    998 	 * This is for the bone-headed user who enters the root
    999 	 * filesystem twice.  Skip root will skep all root entries.
   1000 	 */
   1001 	if (skip_root)
   1002 		for (fs = filesys_info; fs; fs = fs->next)
   1003 			if (!strcmp(fs->mountpt, "/"))
   1004 				fs->flags |= FLAG_DONE;
   1005 
   1006 	while (not_done_yet) {
   1007 		not_done_yet = 0;
   1008 		pass_done = 1;
   1009 
   1010 		for (fs = filesys_info; fs; fs = fs->next) {
   1011 			if (cancel_requested)
   1012 				break;
   1013 			if (fs->flags & FLAG_DONE)
   1014 				continue;
   1015 			/*
   1016 			 * If the filesystem's pass number is higher
   1017 			 * than the current pass number, then we don't
   1018 			 * do it yet.
   1019 			 */
   1020 			if (fs->passno > passno) {
   1021 				not_done_yet++;
   1022 				continue;
   1023 			}
   1024 			if (ignore_mounted && is_mounted(fs->device)) {
   1025 				fs->flags |= FLAG_DONE;
   1026 				continue;
   1027 			}
   1028 			/*
   1029 			 * If a filesystem on a particular device has
   1030 			 * already been spawned, then we need to defer
   1031 			 * this to another pass.
   1032 			 */
   1033 			if (device_already_active(fs->device)) {
   1034 				pass_done = 0;
   1035 				continue;
   1036 			}
   1037 			/*
   1038 			 * Spawn off the fsck process
   1039 			 */
   1040 			fsck_device(fs, serialize);
   1041 			fs->flags |= FLAG_DONE;
   1042 
   1043 			/*
   1044 			 * Only do one filesystem at a time, or if we
   1045 			 * have a limit on the number of fsck's extant
   1046 			 * at one time, apply that limit.
   1047 			 */
   1048 			if (serialize ||
   1049 			    (max_running && (num_running >= max_running))) {
   1050 				pass_done = 0;
   1051 				break;
   1052 			}
   1053 		}
   1054 		if (cancel_requested)
   1055 			break;
   1056 		if (verbose > 1)
   1057 			printf(_("--waiting-- (pass %d)\n"), passno);
   1058 		status |= wait_many(pass_done ? FLAG_WAIT_ALL :
   1059 				    FLAG_WAIT_ATLEAST_ONE);
   1060 		if (pass_done) {
   1061 			if (verbose > 1)
   1062 				printf("----------------------------------\n");
   1063 			passno++;
   1064 		} else
   1065 			not_done_yet++;
   1066 	}
   1067 	if (cancel_requested && !kill_sent) {
   1068 		kill_all(SIGTERM);
   1069 		kill_sent++;
   1070 	}
   1071 	status |= wait_many(FLAG_WAIT_ATLEAST_ONE);
   1072 	return status;
   1073 }
   1074 
   1075 static void usage(NOARGS)
   1076 {
   1077 	fputs(_("Usage: fsck [-AMNPRTV] [ -C [ fd ] ] [-t fstype] [fs-options] [filesys ...]\n"), stderr);
   1078 	exit(EXIT_USAGE);
   1079 }
   1080 
   1081 #ifdef HAVE_SIGNAL_H
   1082 static void signal_cancel(int sig FSCK_ATTR((unused)))
   1083 {
   1084 	cancel_requested++;
   1085 }
   1086 #endif
   1087 
   1088 static void PRS(int argc, char *argv[])
   1089 {
   1090 	int	i, j;
   1091 	char	*arg, *dev, *tmp = 0;
   1092 	char	options[128];
   1093 	int	opt = 0;
   1094 	int     opts_for_fsck = 0;
   1095 #ifdef HAVE_SIGNAL_H
   1096 	struct sigaction	sa;
   1097 
   1098 	/*
   1099 	 * Set up signal action
   1100 	 */
   1101 	memset(&sa, 0, sizeof(struct sigaction));
   1102 	sa.sa_handler = signal_cancel;
   1103 	sigaction(SIGINT, &sa, 0);
   1104 	sigaction(SIGTERM, &sa, 0);
   1105 #endif
   1106 
   1107 	num_devices = 0;
   1108 	num_args = 0;
   1109 	instance_list = 0;
   1110 
   1111 	progname = argv[0];
   1112 
   1113 	for (i=1; i < argc; i++) {
   1114 		arg = argv[i];
   1115 		if (!arg)
   1116 			continue;
   1117 		if ((arg[0] == '/' && !opts_for_fsck) || strchr(arg, '=')) {
   1118 			if (num_devices >= MAX_DEVICES) {
   1119 				fprintf(stderr, _("%s: too many devices\n"),
   1120 					progname);
   1121 				exit(EXIT_ERROR);
   1122 			}
   1123 			dev = blkid_get_devname(cache, arg, NULL);
   1124 			if (!dev && strchr(arg, '=')) {
   1125 				/*
   1126 				 * Check to see if we failed because
   1127 				 * /proc/partitions isn't found.
   1128 				 */
   1129 				if (access("/proc/partitions", R_OK) < 0) {
   1130 					fprintf(stderr, "Couldn't open /proc/partitions: %s\n",
   1131 						strerror(errno));
   1132 					fprintf(stderr, "Is /proc mounted?\n");
   1133 					exit(EXIT_ERROR);
   1134 				}
   1135 				/*
   1136 				 * Check to see if this is because
   1137 				 * we're not running as root
   1138 				 */
   1139 				if (geteuid())
   1140 					fprintf(stderr,
   1141 		"Must be root to scan for matching filesystems: %s\n", arg);
   1142 				else
   1143 					fprintf(stderr,
   1144 		"Couldn't find matching filesystem: %s\n", arg);
   1145 				exit(EXIT_ERROR);
   1146 			}
   1147 			devices[num_devices++] = dev ? dev : string_copy(arg);
   1148 			continue;
   1149 		}
   1150 		if (arg[0] != '-' || opts_for_fsck) {
   1151 			if (num_args >= MAX_ARGS) {
   1152 				fprintf(stderr, _("%s: too many arguments\n"),
   1153 					progname);
   1154 				exit(EXIT_ERROR);
   1155 			}
   1156 			args[num_args++] = string_copy(arg);
   1157 			continue;
   1158 		}
   1159 		for (j=1; arg[j]; j++) {
   1160 			if (opts_for_fsck) {
   1161 				options[++opt] = arg[j];
   1162 				continue;
   1163 			}
   1164 			switch (arg[j]) {
   1165 			case 'A':
   1166 				doall++;
   1167 				break;
   1168 			case 'C':
   1169 				progress++;
   1170 				if (arg[j+1]) {
   1171 					progress_fd = string_to_int(arg+j+1);
   1172 					if (progress_fd < 0)
   1173 						progress_fd = 0;
   1174 					else
   1175 						goto next_arg;
   1176 				} else if ((i+1) < argc &&
   1177 					   !strncmp(argv[i+1], "-", 1) == 0) {
   1178 					progress_fd = string_to_int(argv[i]);
   1179 					if (progress_fd < 0)
   1180 						progress_fd = 0;
   1181 					else {
   1182 						++i;
   1183 						goto next_arg;
   1184 					}
   1185 				}
   1186 				break;
   1187 			case 'V':
   1188 				verbose++;
   1189 				break;
   1190 			case 'N':
   1191 				noexecute++;
   1192 				break;
   1193 			case 'R':
   1194 				skip_root++;
   1195 				break;
   1196 			case 'T':
   1197 				notitle++;
   1198 				break;
   1199 			case 'M':
   1200 				ignore_mounted++;
   1201 				break;
   1202 			case 'P':
   1203 				parallel_root++;
   1204 				break;
   1205 			case 's':
   1206 				serialize++;
   1207 				break;
   1208 			case 't':
   1209 				tmp = 0;
   1210 				if (fstype)
   1211 					usage();
   1212 				if (arg[j+1])
   1213 					tmp = arg+j+1;
   1214 				else if ((i+1) < argc)
   1215 					tmp = argv[++i];
   1216 				else
   1217 					usage();
   1218 				fstype = string_copy(tmp);
   1219 				compile_fs_type(fstype, &fs_type_compiled);
   1220 				goto next_arg;
   1221 			case '-':
   1222 				opts_for_fsck++;
   1223 				break;
   1224 			case '?':
   1225 				usage();
   1226 				break;
   1227 			default:
   1228 				options[++opt] = arg[j];
   1229 				break;
   1230 			}
   1231 		}
   1232 	next_arg:
   1233 		if (opt) {
   1234 			options[0] = '-';
   1235 			options[++opt] = '\0';
   1236 			if (num_args >= MAX_ARGS) {
   1237 				fprintf(stderr,
   1238 					_("%s: too many arguments\n"),
   1239 					progname);
   1240 				exit(EXIT_ERROR);
   1241 			}
   1242 			args[num_args++] = string_copy(options);
   1243 			opt = 0;
   1244 		}
   1245 	}
   1246 	if (getenv("FSCK_FORCE_ALL_PARALLEL"))
   1247 		force_all_parallel++;
   1248 	if ((tmp = getenv("FSCK_MAX_INST")))
   1249 	    max_running = atoi(tmp);
   1250 }
   1251 
   1252 int main(int argc, char *argv[])
   1253 {
   1254 	int i, status = 0;
   1255 	int interactive = 0;
   1256 	char *oldpath = getenv("PATH");
   1257 	const char *fstab;
   1258 	struct fs_info *fs;
   1259 
   1260 	setvbuf(stdout, NULL, _IONBF, BUFSIZ);
   1261 	setvbuf(stderr, NULL, _IONBF, BUFSIZ);
   1262 
   1263 #ifdef ENABLE_NLS
   1264 	setlocale(LC_MESSAGES, "");
   1265 	setlocale(LC_CTYPE, "");
   1266 	bindtextdomain(NLS_CAT_NAME, LOCALEDIR);
   1267 	textdomain(NLS_CAT_NAME);
   1268 #endif
   1269 	blkid_get_cache(&cache, NULL);
   1270 	PRS(argc, argv);
   1271 
   1272 	if (!notitle)
   1273 		printf("fsck %s (%s)\n", E2FSPROGS_VERSION, E2FSPROGS_DATE);
   1274 
   1275 	fstab = getenv("FSTAB_FILE");
   1276 	if (!fstab)
   1277 		fstab = _PATH_MNTTAB;
   1278 	load_fs_info(fstab);
   1279 
   1280 	/* Update our search path to include uncommon directories. */
   1281 	if (oldpath) {
   1282 		fsck_path = malloc (strlen (fsck_prefix_path) + 1 +
   1283 				    strlen (oldpath) + 1);
   1284 		if (!fsck_path) {
   1285 			fprintf(stderr, "%s: Unable to allocate memory for fsck_path\n", progname);
   1286 			exit(EXIT_ERROR);
   1287 		}
   1288 		strcpy (fsck_path, fsck_prefix_path);
   1289 		strcat (fsck_path, ":");
   1290 		strcat (fsck_path, oldpath);
   1291 	} else {
   1292 		fsck_path = string_copy(fsck_prefix_path);
   1293 	}
   1294 
   1295 	if ((num_devices == 1) || (serialize))
   1296 		interactive = 1;
   1297 
   1298 	/* If -A was specified ("check all"), do that! */
   1299 	if (doall)
   1300 		return check_all();
   1301 
   1302 	if (num_devices == 0) {
   1303 		serialize++;
   1304 		interactive++;
   1305 		return check_all();
   1306 	}
   1307 	for (i = 0 ; i < num_devices; i++) {
   1308 		if (cancel_requested) {
   1309 			if (!kill_sent) {
   1310 				kill_all(SIGTERM);
   1311 				kill_sent++;
   1312 			}
   1313 			break;
   1314 		}
   1315 		fs = lookup(devices[i]);
   1316 		if (!fs) {
   1317 			fs = create_fs_device(devices[i], 0, "auto",
   1318 					      0, -1, -1);
   1319 			if (!fs)
   1320 				continue;
   1321 		}
   1322 		if (ignore_mounted && is_mounted(fs->device))
   1323 			continue;
   1324 		fsck_device(fs, interactive);
   1325 		if (serialize ||
   1326 		    (max_running && (num_running >= max_running))) {
   1327 			struct fsck_instance *inst;
   1328 
   1329 			inst = wait_one(0);
   1330 			if (inst) {
   1331 				status |= inst->exit_status;
   1332 				free_instance(inst);
   1333 			}
   1334 			if (verbose > 1)
   1335 				printf("----------------------------------\n");
   1336 		}
   1337 	}
   1338 	status |= wait_many(FLAG_WAIT_ALL);
   1339 	free(fsck_path);
   1340 	blkid_put_cache(cache);
   1341 	return status;
   1342 }
   1343