/*

* fsck --- A generic, parallelizing front-end for the fsck program.

* It will automatically try to run fsck programs in parallel if the

* devices are on separate spindles. It is based on the same ideas as

* the generic front end for fsck by David Engel and Fred van Kempen,

* but it has been completely rewritten from scratch to support

* parallel execution.

*

* Written by Theodore Ts'o, <tytso@mit.edu>

*

* Miquel van Smoorenburg (miquels@drinkel.ow.org) 20-Oct-1994:

* o Changed -t fstype to behave like with mount when -A (all file

* systems) or -M (like mount) is specified.

* o fsck looks if it can find the fsck.type program to decide

* if it should ignore the fs type. This way more fsck programs

* can be added without changing this front-end.

* o -R flag skip root file system.

*

* Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,

* 2001, 2002, 2003, 2004, 2005 by Theodore Ts'o.

*

* Copyright (C) 2009-2014 Karel Zak <kzak@redhat.com>

*

* This file may be redistributed under the terms of the GNU Public

* License.

*/

#define _XOPEN_SOURCE 600 /* for inclusion of sa_handler in Solaris */

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <sys/file.h>

#include <fcntl.h>

#include <limits.h>

#include <stdio.h>

#include <ctype.h>

#include <string.h>

#include <time.h>

#include <stdlib.h>

#include <paths.h>

#include <unistd.h>

#include <errno.h>

#include <signal.h>

#include <dirent.h>

#include <sys/resource.h>

#include <sys/time.h>

#include <blkid.h>

#include <libmount.h>

#include "nls.h"

#include "pathnames.h"

#include "exitcodes.h"

#include "c.h"

#include "fileutils.h"

#include "monotonic.h"

#define STRTOXX_EXIT_CODE FSCK_EX_ERROR

#include "strutils.h"

#define XALLOC_EXIT_CODE FSCK_EX_ERROR

#include "xalloc.h"

#define CLOSE_EXIT_CODE FSCK_EX_ERROR

#include "closestream.h"

#ifndef DEFAULT_FSTYPE

# define DEFAULT_FSTYPE "ext2"

#endif

#define MAX_DEVICES 32

#define MAX_ARGS 32

#define FSCK_RUNTIME_DIRNAME "/run/fsck"

static const char *ignored_types[] = {

"ignore",

"iso9660",

"sw",

NULL

};

static const char *really_wanted[] = {

"minix",

"ext2",

"ext3",

"ext4",

"ext4dev",

"jfs",

"reiserfs"

};

/*

* Internal structure for mount table entries.

*/

struct fsck_fs_data

{

const char *device;

dev_t disk;

unsigned int stacked:1,

done:1,

eval_device:1;

};

/*

* Structure to allow exit codes to be stored

*/

struct fsck_instance {

int pid;

int flags; /* FLAG_{DONE|PROGRESS} */

int lock; /* flock()ed lockpath file descriptor or -1 */

char *lockpath; /* /run/fsck/<diskname>.lock or NULL */

int exit_status;

struct timeval start_time;

struct timeval end_time;

char * prog;

char * type;

struct rusage rusage;

struct libmnt_fs *fs;

struct fsck_instance *next;

};

#define FLAG_DONE 1

#define FLAG_PROGRESS 2

/*

* Global variables for options

*/

static char *devices[MAX_DEVICES];

static char *args[MAX_ARGS];

static int num_devices, num_args;

static int lockdisk;

static int verbose;

static int doall;

static int noexecute;

static int serialize;

static int skip_root;

static int ignore_mounted;

static int notitle;

static int parallel_root;

static int progress;

static int progress_fd;

static int force_all_parallel;

static int report_stats;

static FILE *report_stats_file;

static int num_running;

static int max_running;

static volatile int cancel_requested;

static int kill_sent;

static char *fstype;

static struct fsck_instance *instance_list;

#define FSCK_DEFAULT_PATH "/sbin"

static char *fsck_path;

/* parsed fstab and mtab */

static struct libmnt_table *fstab, *mtab;

static struct libmnt_cache *mntcache;

static int count_slaves(dev_t disk);

static int string_to_int(const char *s)

{

long l;

char *p;

l = strtol(s, &p, 0);

if (*p || l == LONG_MIN || l == LONG_MAX || l < 0 || l > INT_MAX)

return -1;

else

return (int) l;

}

/* Do we really really want to check this fs? */

static int fs_check_required(const char *type)

{

size_t i;

for(i = 0; i < ARRAY_SIZE(really_wanted); i++) {

if (strcmp(type, really_wanted[i]) == 0)

return 1;

}

return 0;

}

static int is_mounted(struct libmnt_fs *fs)

{

int rc;

const char *src;

src = mnt_fs_get_source(fs);

if (!src)

return 0;

if (!mntcache)

mntcache = mnt_new_cache();

if (!mtab) {

mtab = mnt_new_table();

if (!mtab)

err(FSCK_EX_ERROR, ("failed to initialize libmount table"));

mnt_table_set_cache(mtab, mntcache);

mnt_table_parse_mtab(mtab, NULL);

}

rc = mnt_table_find_source(mtab, src, MNT_ITER_BACKWARD) ? 1 : 0;

if (verbose) {

if (rc)

printf(_("%s is mounted\n"), src);

else

printf(_("%s is not mounted\n"), src);

}

return rc;

}

static int ignore(struct libmnt_fs *);

static struct fsck_fs_data *fs_create_data(struct libmnt_fs *fs)

{

struct fsck_fs_data *data = mnt_fs_get_userdata(fs);

if (!data) {

data = xcalloc(1, sizeof(*data));

mnt_fs_set_userdata(fs, data);

}

return data;

}

/*

* fs from fstab might contains real device name as well as symlink,

* LABEL or UUID, this function returns canonicalized result.

*/

static const char *fs_get_device(struct libmnt_fs *fs)

{

struct fsck_fs_data *data = mnt_fs_get_userdata(fs);

if (!data || !data->eval_device) {

const char *spec = mnt_fs_get_source(fs);

if (!data)

data = fs_create_data(fs);

data->eval_device = 1;

data->device = mnt_resolve_spec(spec, mnt_table_get_cache(fstab));

if (!data->device)

data->device = xstrdup(spec);

}

return data->device;

}

static dev_t fs_get_disk(struct libmnt_fs *fs, int check)

{

struct fsck_fs_data *data;

const char *device;

struct stat st;

data = mnt_fs_get_userdata(fs);

if (data && data->disk)

return data->disk;

if (!check)

return 0;

if (mnt_fs_is_netfs(fs) || mnt_fs_is_pseudofs(fs))

return 0;

device = fs_get_device(fs);

if (!device)

return 0;

data = fs_create_data(fs);

if (!stat(device, &st) &&

!blkid_devno_to_wholedisk(st.st_rdev, NULL, 0, &data->disk)) {

if (data->disk)

data->stacked = count_slaves(data->disk) > 0 ? 1 : 0;

return data->disk;

}

return 0;

}

static int fs_is_stacked(struct libmnt_fs *fs)

{

struct fsck_fs_data *data = mnt_fs_get_userdata(fs);

return data ? data->stacked : 0;

}

static int fs_is_done(struct libmnt_fs *fs)

{

struct fsck_fs_data *data = mnt_fs_get_userdata(fs);

return data ? data->done : 0;

}

static void fs_set_done(struct libmnt_fs *fs)

{

struct fsck_fs_data *data = fs_create_data(fs);

if (data)

data->done = 1;

}

static int is_irrotational_disk(dev_t disk)

{

char path[PATH_MAX];

FILE *f;

int rc, x;

rc = snprintf(path, sizeof(path),

"/sys/dev/block/%d:%d/queue/rotational",

major(disk), minor(disk));

if (rc < 0 || (unsigned int) rc >= sizeof(path))

return 0;

f = fopen(path, "r");

if (!f)

return 0;

rc = fscanf(f, "%d", &x);

if (rc != 1) {

if (ferror(f))

warn(_("cannot read %s"), path);

else

warnx(_("parse error: %s"), path);

}

fclose(f);

return rc == 1 ? !x : 0;

}

static void lock_disk(struct fsck_instance *inst)

{

dev_t disk = fs_get_disk(inst->fs, 1);

char *diskpath = NULL, *diskname;

inst->lock = -1;

if (!disk || is_irrotational_disk(disk))

goto done;

diskpath = blkid_devno_to_devname(disk);

if (!diskpath)

goto done;

if (access(FSCK_RUNTIME_DIRNAME, F_OK) != 0) {

int rc = mkdir(FSCK_RUNTIME_DIRNAME,

S_IWUSR|

S_IRUSR|S_IRGRP|S_IROTH|

S_IXUSR|S_IXGRP|S_IXOTH);

if (rc && errno != EEXIST) {

warn(_("cannot create directory %s"),

FSCK_RUNTIME_DIRNAME);

goto done;

}

}

diskname = stripoff_last_component(diskpath);

if (!diskname)

diskname = diskpath;

xasprintf(&inst->lockpath, FSCK_RUNTIME_DIRNAME "/%s.lock", diskname);

if (verbose)

printf(_("Locking disk by %s ... "), inst->lockpath);

inst->lock = open(inst->lockpath, O_RDONLY|O_CREAT|O_CLOEXEC,

S_IWUSR|S_IRUSR|S_IRGRP|S_IROTH);

if (inst->lock >= 0) {

int rc = -1;

/* inform users that we're waiting on the lock */

if (verbose &&

(rc = flock(inst->lock, LOCK_EX | LOCK_NB)) != 0 &&

errno == EWOULDBLOCK)

printf(_("(waiting) "));

if (rc != 0 && flock(inst->lock, LOCK_EX) != 0) {

close(inst->lock); /* failed */

inst->lock = -1;

}

}

if (verbose)

/* TRANSLATORS: These are followups to "Locking disk...". */

printf("%s.\n", inst->lock >= 0 ? _("succeeded") : _("failed"));

done:

if (inst->lock < 0) {

free(inst->lockpath);

inst->lockpath = NULL;

}

free(diskpath);

return;

}

static void unlock_disk(struct fsck_instance *inst)

{

if (inst->lock < 0)

return;

if (verbose)

printf(_("Unlocking %s.\n"), inst->lockpath);

close(inst->lock); /* unlock */

free(inst->lockpath);

inst->lock = -1;

inst->lockpath = NULL;

}

static void free_instance(struct fsck_instance *i)

{

if (lockdisk)

unlock_disk(i);

free(i->prog);

free(i->lockpath);

mnt_unref_fs(i->fs);

free(i);

return;

}

static struct libmnt_fs *add_dummy_fs(const char *device)

{

struct libmnt_fs *fs = mnt_new_fs();

if (fs && mnt_fs_set_source(fs, device) == 0 &&

mnt_table_add_fs(fstab, fs) == 0) {

mnt_unref_fs(fs);

return fs;

}

mnt_unref_fs(fs);

err(FSCK_EX_ERROR, _("failed to setup description for %s"), device);

}

static void fs_interpret_type(struct libmnt_fs *fs)

{

const char *device;

const char *type = mnt_fs_get_fstype(fs);

if (type && strcmp(type, "auto") != 0)

return;

mnt_fs_set_fstype(fs, NULL);

device = fs_get_device(fs);

if (device) {

int ambi = 0;

char *tp;

struct libmnt_cache *cache = mnt_table_get_cache(fstab);

tp = mnt_get_fstype(device, &ambi, cache);

if (!ambi)

mnt_fs_set_fstype(fs, tp);

if (!cache)

free(tp);

}

}

static int parser_errcb(struct libmnt_table *tb __attribute__ ((__unused__)),

const char *filename, int line)

{

warnx(_("%s: parse error at line %d -- ignored"), filename, line);

return 1;

}

/*

* Load the filesystem database from /etc/fstab

*/

static void load_fs_info(void)

{

const char *path;

fstab = mnt_new_table();

if (!fstab)

err(FSCK_EX_ERROR, ("failed to initialize libmount table"));

mnt_table_set_parser_errcb(fstab, parser_errcb);

mnt_table_set_cache(fstab, mntcache);

errno = 0;

/*

* Let's follow libmount defaults if $FSTAB_FILE is not specified

*/

path = getenv("FSTAB_FILE");

if (mnt_table_parse_fstab(fstab, path)) {

if (!path)

path = mnt_get_fstab_path();

/* don't print error when there is no fstab at all */

if (access(path, F_OK) == 0) {

if (errno)

warn(_("%s: failed to parse fstab"), path);

else

warnx(_("%s: failed to parse fstab"), path);

}

}

}

/*

* Lookup filesys in /etc/fstab and return the corresponding entry.

* The @path has to be real path (no TAG) by mnt_resolve_spec().

*/

static struct libmnt_fs *lookup(char *path)

{

struct libmnt_fs *fs;

if (!path)

return NULL;

fs = mnt_table_find_srcpath(fstab, path, MNT_ITER_FORWARD);

if (!fs) {

/*

* Maybe mountpoint has been specified on fsck command line.

* Yeah, crazy feature...

*

* Note that mnt_table_find_target() may canonicalize paths in

* the fstab to support symlinks. This is really unwanted,

* because readlink() on mountpoints may trigger automounts.

*

* So, disable the cache and compare the paths as strings

* without care about symlinks...

*/

mnt_table_set_cache(fstab, NULL);

fs = mnt_table_find_target(fstab, path, MNT_ITER_FORWARD);

mnt_table_set_cache(fstab, mntcache);

}

return fs;

}

/* Find fsck program for a given fs type. */

static char *find_fsck(const char *type)

{

char *s;

const char *tpl;

static char prog[256];

char *p = xstrdup(fsck_path);

/* Are we looking for a program or just a type? */

tpl = (strncmp(type, "fsck.", 5) ? "%s/fsck.%s" : "%s/%s");

for(s = strtok(p, ":"); s; s = strtok(NULL, ":")) {

sprintf(prog, tpl, s, type);

if (access(prog, X_OK) == 0)

break;

}

free(p);

return(s ? prog : NULL);

}

static int progress_active(void)

{

struct fsck_instance *inst;

for (inst = instance_list; inst; inst = inst->next) {

if (inst->flags & FLAG_DONE)

continue;

if (inst->flags & FLAG_PROGRESS)

return 1;

}

return 0;

}

/*

* Process run statistics for finished fsck instances.

*

* If report_stats is 0, do nothing, otherwise print a selection of

* interesting rusage statistics as well as elapsed wallclock time.

*/

static void print_stats(struct fsck_instance *inst)

{

struct timeval delta;

if (!inst || !report_stats || noexecute)

return;

timersub(&inst->end_time, &inst->start_time, &delta);

if (report_stats_file)

fprintf(report_stats_file, "%s %d %ld "

"%ld.%06ld %ld.%06ld %ld.%06ld\n",

fs_get_device(inst->fs),

inst->exit_status,

inst->rusage.ru_maxrss,

(long)delta.tv_sec, (long)delta.tv_usec,

(long)inst->rusage.ru_utime.tv_sec,

(long)inst->rusage.ru_utime.tv_usec,

(long)inst->rusage.ru_stime.tv_sec,

(long)inst->rusage.ru_stime.tv_usec);

else

fprintf(stdout, "%s: status %d, rss %ld, "

"real %ld.%06ld, user %ld.%06ld, sys %ld.%06ld\n",

fs_get_device(inst->fs),

inst->exit_status,

inst->rusage.ru_maxrss,

(long)delta.tv_sec, (long)delta.tv_usec,

(long)inst->rusage.ru_utime.tv_sec,

(long)inst->rusage.ru_utime.tv_usec,

(long)inst->rusage.ru_stime.tv_sec,

(long)inst->rusage.ru_stime.tv_usec);

}

/*

* Execute a particular fsck program, and link it into the list of

* child processes we are waiting for.

*/

static int execute(const char *progname, const char *progpath,

const char *type, struct libmnt_fs *fs, int interactive)

{

char *argv[80];

int argc, i;

struct fsck_instance *inst, *p;

pid_t pid;

inst = xcalloc(1, sizeof(*inst));

argv[0] = xstrdup(progname);

argc = 1;

for (i=0; i <num_args; i++)

argv[argc++] = xstrdup(args[i]);

if (progress &&

((strcmp(type, "ext2") == 0) ||

(strcmp(type, "ext3") == 0) ||

(strcmp(type, "ext4") == 0) ||

(strcmp(type, "ext4dev") == 0))) {

char tmp[80];

tmp[0] = 0;

if (!progress_active()) {

snprintf(tmp, 80, "-C%d", progress_fd);

inst->flags |= FLAG_PROGRESS;

} else if (progress_fd)

snprintf(tmp, 80, "-C%d", progress_fd * -1);

if (tmp[0])

argv[argc++] = xstrdup(tmp);

}

argv[argc++] = xstrdup(fs_get_device(fs));

argv[argc] = 0;

if (verbose || noexecute) {

const char *tgt = mnt_fs_get_target(fs);

if (!tgt)

tgt = fs_get_device(fs);

printf("[%s (%d) -- %s] ", progpath, num_running, tgt);

for (i=0; i < argc; i++)

printf("%s ", argv[i]);

printf("\n");

}

mnt_ref_fs(fs);

inst->fs = fs;

inst->lock = -1;

if (lockdisk)

lock_disk(inst);

/* Fork and execute the correct program. */

if (noexecute)

pid = -1;

else if ((pid = fork()) < 0) {

warn(_("fork failed"));

free_instance(inst);

return errno;

} else if (pid == 0) {

if (!interactive)

close(0);

execv(progpath, argv);

err(FSCK_EX_ERROR, _("%s: execute failed"), progpath);

}

for (i=0; i < argc; i++)

free(argv[i]);

inst->pid = pid;

inst->prog = xstrdup(progname);

inst->type = xstrdup(type);

gettime_monotonic(&inst->start_time);

inst->next = NULL;

/*

* Find the end of the list, so we add the instance on at the end.

*/

for (p = instance_list; p && p->next; p = p->next);

if (p)

p->next = inst;

else

instance_list = inst;

return 0;

}

/*

* Send a signal to all outstanding fsck child processes

*/

static int kill_all(int signum)

{

struct fsck_instance *inst;

int n = 0;

for (inst = instance_list; inst; inst = inst->next) {

if (inst->flags & FLAG_DONE)

continue;

kill(inst->pid, signum);

n++;

}

return n;

}

/*

* Wait for one child process to exit; when it does, unlink it from

* the list of executing child processes, and return it.

*/

static struct fsck_instance *wait_one(int flags)

{

int status = 0;

int sig;

struct fsck_instance *inst, *inst2, *prev;

pid_t pid;

struct rusage rusage;

if (!instance_list)

return NULL;

if (noexecute) {

inst = instance_list;

prev = 0;

#ifdef RANDOM_DEBUG

while (inst->next && (random() & 1)) {

prev = inst;

inst = inst->next;

}

#endif

inst->exit_status = 0;

goto ret_inst;

}

/*

* gcc -Wall fails saving throw against stupidity

* (inst and prev are thought to be uninitialized variables)

*/

inst = prev = NULL;

do {

pid = wait4(-1, &status, flags, &rusage);

if (cancel_requested && !kill_sent) {

kill_all(SIGTERM);

kill_sent++;

}

if ((pid == 0) && (flags & WNOHANG))

return NULL;

if (pid < 0) {

if ((errno == EINTR) || (errno == EAGAIN))

continue;

if (errno == ECHILD) {

warnx(_("wait: no more child process?!?"));

return NULL;

}

warn(_("waitpid failed"));

continue;

}

for (prev = 0, inst = instance_list;

inst;

prev = inst, inst = inst->next) {

if (inst->pid == pid)

break;

}

} while (!inst);

if (WIFEXITED(status))

status = WEXITSTATUS(status);

else if (WIFSIGNALED(status)) {

sig = WTERMSIG(status);

if (sig == SIGINT) {

status = FSCK_EX_UNCORRECTED;

} else {

warnx(_("Warning... %s for device %s exited "

"with signal %d."),

inst->prog, fs_get_device(inst->fs), sig);

status = FSCK_EX_ERROR;

}

} else {

warnx(_("%s %s: status is %x, should never happen."),

inst->prog, fs_get_device(inst->fs), status);

status = FSCK_EX_ERROR;

}

inst->exit_status = status;

inst->flags |= FLAG_DONE;

gettime_monotonic(&inst->end_time);

memcpy(&inst->rusage, &rusage, sizeof(struct rusage));

if (progress && (inst->flags & FLAG_PROGRESS) &&

!progress_active()) {

for (inst2 = instance_list; inst2; inst2 = inst2->next) {

if (inst2->flags & FLAG_DONE)

continue;

if (strcmp(inst2->type, "ext2") &&

strcmp(inst2->type, "ext3") &&

strcmp(inst2->type, "ext4") &&

strcmp(inst2->type, "ext4dev"))

continue;

/*

* If we've just started the fsck, wait a tiny

* bit before sending the kill, to give it

* time to set up the signal handler

*/

if (inst2->start_time.tv_sec < time(0) + 2) {

if (fork() == 0) {

sleep(1);

kill(inst2->pid, SIGUSR1);

exit(FSCK_EX_OK);

}

} else

kill(inst2->pid, SIGUSR1);

inst2->flags |= FLAG_PROGRESS;

break;

}

}

ret_inst:

if (prev)

prev->next = inst->next;

else

instance_list = inst->next;

print_stats(inst);

if (verbose > 1)

printf(_("Finished with %s (exit status %d)\n"),

fs_get_device(inst->fs), inst->exit_status);

num_running--;

return inst;

}

#define FLAG_WAIT_ALL 0

#define FLAG_WAIT_ATLEAST_ONE 1

/*

* Wait until all executing child processes have exited; return the

* logical OR of all of their exit code values.

*/

static int wait_many(int flags)

{

struct fsck_instance *inst;

int global_status = 0;

int wait_flags = 0;

while ((inst = wait_one(wait_flags))) {

global_status |= inst->exit_status;

free_instance(inst);

#ifdef RANDOM_DEBUG

if (noexecute && (flags & WNOHANG) && !(random() % 3))

break;

#endif

if (flags & FLAG_WAIT_ATLEAST_ONE)

wait_flags = WNOHANG;

}

return global_status;

}

/*

* Run the fsck program on a particular device

*

* If the type is specified using -t, and it isn't prefixed with "no"

* (as in "noext2") and only one filesystem type is specified, then

* use that type regardless of what is specified in /etc/fstab.

*

* If the type isn't specified by the user, then use either the type

* specified in /etc/fstab, or DEFAULT_FSTYPE.

*/

static int fsck_device(struct libmnt_fs *fs, int interactive)

{

char progname[80], *progpath;

const char *type;

int retval;

fs_interpret_type(fs);

type = mnt_fs_get_fstype(fs);

if (type && strcmp(type, "auto") != 0)

;

else if (fstype && strncmp(fstype, "no", 2) &&

strncmp(fstype, "opts=", 5) && strncmp(fstype, "loop", 4) &&

!strchr(fstype, ','))

type = fstype;

else

type = DEFAULT_FSTYPE;

sprintf(progname, "fsck.%s", type);

progpath = find_fsck(progname);

if (progpath == NULL) {

if (fs_check_required(type)) {

retval = ENOENT;

goto err;

}

return 0;

}

num_running++;

retval = execute(progname, progpath, type, fs, interactive);

if (retval) {

num_running--;

goto err;

}

return 0;

err:

warnx(_("error %d (%m) while executing fsck.%s for %s"),

retval, type, fs_get_device(fs));

return FSCK_EX_ERROR;

}

/*

* Deal with the fsck -t argument.

*/

struct fs_type_compile {

char **list;

int *type;

int negate;

} fs_type_compiled;

#define FS_TYPE_NORMAL 0

#define FS_TYPE_OPT 1

#define FS_TYPE_NEGOPT 2

static void compile_fs_type(char *fs_type, struct fs_type_compile *cmp)

{

char *cp, *list, *s;

int num = 2;

int negate, first_negate = 1;

if (fs_type) {

for (cp=fs_type; *cp; cp++) {

if (*cp == ',')

num++;

}

}

cmp->list = xcalloc(num, sizeof(char *));

cmp->type = xcalloc(num, sizeof(int));

cmp->negate = 0;

if (!fs_type)

return;

list = xstrdup(fs_type);

num = 0;

s = strtok(list, ",");

while(s) {

negate = 0;

if (strncmp(s, "no", 2) == 0) {

s += 2;

negate = 1;

} else if (*s == '!') {

s++;

negate = 1;

}

if (strcmp(s, "loop") == 0)

/* loop is really short-hand for opts=loop */

goto loop_special_case;

else if (strncmp(s, "opts=", 5) == 0) {

s += 5;

loop_special_case:

cmp->type[num] = negate ? FS_TYPE_NEGOPT : FS_TYPE_OPT;

} else {

if (first_negate) {

cmp->negate = negate;

first_negate = 0;

}

if ((negate && !cmp->negate) ||

(!negate && cmp->negate)) {

errx(FSCK_EX_USAGE,

_("Either all or none of the filesystem types passed to -t must be prefixed\n"

"with 'no' or '!'."));

}

}

cmp->list[num++] = xstrdup(s);

s = strtok(NULL, ",");

}

free(list);

}