/* Lookup filesys in /etc/fstab and return the corresponding entry. */
static struct fs_info *lookup(char *filesys)
{
struct fs_info *fs;
int try_again = 0;
/* No filesys name given. */
if (filesys == NULL)
return NULL;
for (fs = filesys_info; fs; fs = fs->next) {
if (strchr(fs->device, '='))
try_again++;
if (!strcmp(filesys, fs->device) ||
!strcmp(filesys, fs->mountpt))
break;
}
if (fs && strchr(fs->device, '='))
fs->device = interpret_device(fs->device);
if (fs || !try_again)
return fs;
for (fs = filesys_info; fs; fs = fs->next) {
fs->device = interpret_device(fs->device);
if (!strcmp(filesys, fs->device) ||
!strcmp(filesys, fs->mountpt))
break;
}
return fs;
}
static void interpret_dvd(xmlDocPtr doc, xmlNodePtr cur)
{
cur = cur->xmlChildrenNode;
while(cur != NULL) {
if(!xmlIsBlankNode(cur)) {
if(!strcmp("device", cur->name)) {
interpret_device(doc, cur);
}
}
cur = cur->next;
}
}
/*
* Interpret filesystem auto type if necessary
*/
static void interpret_type(struct fs_info *fs)
{
const char *type;
if (strcmp(fs->type, "auto") == 0 ||
(strchr(fs->type, ',') != 0)) {
if (fs && strchr(fs->device, '='))
fs->device = interpret_device(fs->device);
type = identify_fs(fs->device, fs->type);
if (type) {
free(fs->type);
fs->type = string_copy(type);
} else
fprintf(stderr, _("Could not determine "
"filesystem type for %s\n"),
fs->device);
}
}
/* Check all file systems, using the /etc/fstab table. */
static int check_all(NOARGS)
{
struct fs_info *fs = NULL;
int status = EXIT_OK;
int not_done_yet = 1;
int passno = 1;
int pass_done;
if (verbose)
printf(_("Checking all file systems.\n"));
/*
* Do an initial scan over the filesystem; mark filesystems
* which should be ignored as done, and resolve LABEL= and
* UUID= specifications to the real device.
*/
for (fs = filesys_info; fs; fs = fs->next) {
if (ignore(fs))
fs->flags |= FLAG_DONE;
else
fs->device = interpret_device(fs->device);
}
/*
* Find and check the root filesystem.
*/
if (!parallel_root) {
for (fs = filesys_info; fs; fs = fs->next) {
if (!strcmp(fs->mountpt, "/"))
break;
}
if (fs) {
if (!skip_root && !ignore(fs)) {
fsck_device(fs->device, 1);
status |= wait_all(0);
if (status > EXIT_NONDESTRUCT)
return status;
}
fs->flags |= FLAG_DONE;
}
}
/*
* This is for the bone-headed user who enters the root
* filesystem twice. Skip root will skep all root entries.
*/
if (skip_root)
for (fs = filesys_info; fs; fs = fs->next)
if (!strcmp(fs->mountpt, "/"))
fs->flags |= FLAG_DONE;
while (not_done_yet) {
not_done_yet = 0;
pass_done = 1;
for (fs = filesys_info; fs; fs = fs->next) {
if (cancel_requested)
break;
if (fs->flags & FLAG_DONE)
continue;
/*
* If the filesystem's pass number is higher
* than the current pass number, then we don't
* do it yet.
*/
if (fs->passno > passno) {
not_done_yet++;
continue;
}
/*
* If a filesystem on a particular device has
* already been spawned, then we need to defer
* this to another pass.
*/
if (device_already_active(fs->device)) {
pass_done = 0;
continue;
}
/*
* Spawn off the fsck process
*/
fsck_device(fs->device, serialize);
fs->flags |= FLAG_DONE;
/*
* Only do one filesystem at a time, or if we
* have a limit on the number of fsck's extant
* at one time, apply that limit.
*/
if (serialize ||
(max_running && (num_running >= max_running))) {
pass_done = 0;
break;
}
}
if (cancel_requested)
break;
if (verbose > 1)
printf(_("--waiting-- (pass %d)\n"), passno);
status |= wait_all(pass_done ? 0 : WNOHANG);
if (pass_done) {
if (verbose > 1)
printf("----------------------------------\n");
passno++;
} else
not_done_yet++;
}
if (cancel_requested && !kill_sent) {
kill_all(SIGTERM);
kill_sent++;
}
status |= wait_all(0);
return status;
}
static void PRS(int argc, char *argv[])
{
int i, j;
char *arg, *tmp;
char options[128];
int opt = 0;
int opts_for_fsck = 0;
#ifdef HAVE_SIGNAL_H
struct sigaction sa;
/*
* Set up signal action
*/
memset(&sa, 0, sizeof(struct sigaction));
sa.sa_handler = signal_cancel;
sigaction(SIGINT, &sa, 0);
sigaction(SIGTERM, &sa, 0);
#endif
num_devices = 0;
num_args = 0;
instance_list = 0;
progname = argv[0];
for (i=1; i < argc; i++) {
arg = argv[i];
if (!arg)
continue;
if ((arg[0] == '/' && !opts_for_fsck) ||
(strncmp(arg, "LABEL=", 6) == 0) ||
(strncmp(arg, "UUID=", 5) == 0)) {
if (num_devices >= MAX_DEVICES) {
fprintf(stderr, _("%s: too many devices\n"),
progname);
exit(EXIT_ERROR);
}
devices[num_devices++] =
interpret_device(string_copy(arg));
continue;
}
if (arg[0] != '-' || opts_for_fsck) {
if (num_args >= MAX_ARGS) {
fprintf(stderr, _("%s: too many arguments\n"),
progname);
exit(EXIT_ERROR);
}
args[num_args++] = string_copy(arg);
continue;
}
for (j=1; arg[j]; j++) {
if (opts_for_fsck) {
options[++opt] = arg[j];
continue;
}
switch (arg[j]) {
case 'A':
doall++;
break;
case 'C':
progress++;
break;
case 'V':
verbose++;
break;
case 'N':
noexecute++;
break;
case 'R':
skip_root++;
break;
case 'T':
notitle++;
break;
case 'M':
like_mount++;
break;
case 'P':
parallel_root++;
break;
case 's':
serialize++;
break;
case 't':
if (fstype)
usage();
if (arg[j+1])
tmp = arg+j+1;
else if ((i+1) < argc)
tmp = argv[++i];
else
usage();
fstype = string_copy(tmp);
compile_fs_type(fstype, &fs_type_compiled);
goto next_arg;
case '-':
opts_for_fsck++;
break;
case '?':
usage();
break;
default:
options[++opt] = arg[j];
break;
}
}
next_arg:
if (opt) {
options[0] = '-';
options[++opt] = '\0';
if (num_args >= MAX_ARGS) {
fprintf(stderr,
_("%s: too many arguments\n"),
progname);
exit(EXIT_ERROR);
}
args[num_args++] = string_copy(options);
opt = 0;
}
}
if (getenv("FSCK_FORCE_ALL_PARALLEL"))
force_all_parallel++;
if ((tmp = getenv("FSCK_MAX_INST")))
max_running = atoi(tmp);
}
static void PRS(int argc, char *argv[])
{
int i, j;
char *arg;
char options[128];
int opt = 0;
int opts_for_fsck = 0;
num_devices = 0;
num_args = 0;
instance_list = 0;
progname = argv[0];
for (i=1; i < argc; i++) {
arg = argv[i];
if (!arg)
continue;
if ((arg[0] == '/' && !opts_for_fsck) ||
(strncmp(arg, "LABEL=", 6) == 0) ||
(strncmp(arg, "UUID=", 5) == 0)) {
if (num_devices >= MAX_DEVICES) {
fprintf(stderr, _("%s: too many devices\n"),
progname);
exit(EXIT_ERROR);
}
devices[num_devices++] =
interpret_device(string_copy(arg));
continue;
}
if (arg[0] != '-' || opts_for_fsck) {
if (num_args >= MAX_ARGS) {
fprintf(stderr, _("%s: too many arguments\n"),
progname);
exit(EXIT_ERROR);
}
args[num_args++] = string_copy(arg);
continue;
}
for (j=1; arg[j]; j++) {
if (opts_for_fsck) {
options[++opt] = arg[j];
continue;
}
switch (arg[j]) {
case 'A':
doall++;
break;
case 'C':
progress++;
break;
case 'V':
verbose++;
break;
case 'N':
noexecute++;
break;
case 'R':
skip_root++;
break;
case 'T':
notitle++;
break;
case 'M':
like_mount++;
break;
case 'P':
parallel_root++;
break;
case 's':
serialize++;
break;
case 't':
if (arg[j+1]) {
fstype = string_copy(arg+j+1);
compile_fs_type(fstype, &fs_type_compiled);
goto next_arg;
}
if ((i+1) < argc) {
i++;
fstype = string_copy(argv[i]);
compile_fs_type(fstype, &fs_type_compiled);
goto next_arg;
}
usage();
break;
case '-':
opts_for_fsck++;
break;
case '?':
usage();
break;
default:
options[++opt] = arg[j];
break;
}
}
next_arg:
if (opt) {
options[0] = '-';
options[++opt] = '\0';
if (num_args >= MAX_ARGS) {
fprintf(stderr,
_("%s: too many arguments\n"),
progname);
exit(EXIT_ERROR);
}
args[num_args++] = string_copy(options);
opt = 0;
}
}
if (getenv("FSCK_FORCE_ALL_PARALLEL"))
force_all_parallel++;
}
/* Check all file systems, using the /etc/fstab table. */
static int check_all(NOARGS)
{
struct fs_info *fs = NULL;
struct fsck_instance *inst;
int status = EXIT_OK;
int not_done_yet = 1;
int passno = 1;
int pass_done;
if (verbose)
printf(_("Checking all file systems.\n"));
/*
* Do an initial scan over the filesystem; mark filesystems
* which should be ignored as done, and resolve LABEL= and
* UUID= specifications to the real device.
*/
for (fs = filesys_info; fs; fs = fs->next) {
if (ignore(fs))
fs->flags |= FLAG_DONE;
else
fs->device = interpret_device(fs->device);
}
/*
* Find and check the root filesystem.
*/
if (!parallel_root) {
for (fs = filesys_info; fs; fs = fs->next) {
if (!strcmp(fs->mountpt, "/"))
break;
}
if (fs) {
if (!skip_root && !ignore(fs)) {
fsck_device(fs->device, 1);
status |= wait_all();
if (status > EXIT_NONDESTRUCT)
return status;
}
fs->flags |= FLAG_DONE;
}
}
while (not_done_yet) {
not_done_yet = 0;
pass_done = 1;
for (fs = filesys_info; fs; fs = fs->next) {
if (fs->flags & FLAG_DONE)
continue;
/*
* If the filesystem's pass number is higher
* than the current pass number, then we don't
* do it yet.
*/
if (fs->passno > passno) {
not_done_yet++;
continue;
}
/*
* If a filesystem on a particular device has
* already been spawned, then we need to defer
* this to another pass.
*/
if (device_already_active(fs->device)) {
pass_done = 0;
continue;
}
/*
* Spawn off the fsck process
*/
fsck_device(fs->device, serialize);
fs->flags |= FLAG_DONE;
if (serialize) {
pass_done = 0;
break; /* Only do one filesystem at a time */
}
}
if (verbose > 1)
printf(_("--waiting-- (pass %d)\n"), passno);
inst = wait_one();
if (inst) {
status |= inst->exit_status;
free_instance(inst);
}
if (pass_done) {
status |= wait_all();
if (verbose > 1)
printf("----------------------------------\n");
passno++;
} else
not_done_yet++;
}
status |= wait_all();
return status;
}
