2010-10-19 21:19:12 +02:00
|
|
|
/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
|
|
|
|
|
|
|
|
/***
|
|
|
|
This file is part of systemd.
|
|
|
|
|
|
|
|
Copyright 2010 Lennart Poettering
|
2014-05-15 19:07:43 +02:00
|
|
|
Copyright 2014 Holger Hans Peter Freyther
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
2012-04-12 00:20:58 +02:00
|
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2010-10-19 21:19:12 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
2012-04-12 00:20:58 +02:00
|
|
|
Lesser General Public License for more details.
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2012-04-12 00:20:58 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
2010-10-19 21:19:12 +02:00
|
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdbool.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <unistd.h>
|
2010-10-29 19:54:02 +02:00
|
|
|
#include <fcntl.h>
|
2011-09-01 21:05:06 +02:00
|
|
|
#include <sys/file.h>
|
2015-02-04 16:42:47 +01:00
|
|
|
#include <sys/stat.h>
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2013-08-12 00:35:49 +02:00
|
|
|
#include "sd-bus.h"
|
|
|
|
#include "libudev.h"
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
#include "util.h"
|
|
|
|
#include "special.h"
|
2013-08-12 00:35:49 +02:00
|
|
|
#include "bus-util.h"
|
|
|
|
#include "bus-error.h"
|
2014-12-10 19:00:46 +01:00
|
|
|
#include "bus-common-errors.h"
|
2013-10-13 02:28:21 +02:00
|
|
|
#include "udev-util.h"
|
2014-04-12 22:07:45 +02:00
|
|
|
#include "path-util.h"
|
2015-02-04 16:42:47 +01:00
|
|
|
#include "socket-util.h"
|
|
|
|
#include "fsckd/fsckd.h"
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
static bool arg_skip = false;
|
|
|
|
static bool arg_force = false;
|
2014-05-15 19:07:43 +02:00
|
|
|
static const char *arg_repair = "-a";
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2012-05-04 10:32:47 +02:00
|
|
|
static void start_target(const char *target) {
|
2013-08-12 00:35:49 +02:00
|
|
|
_cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
|
2014-08-04 16:22:09 +02:00
|
|
|
_cleanup_bus_close_unref_ sd_bus *bus = NULL;
|
2013-08-12 00:35:49 +02:00
|
|
|
int r;
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
assert(target);
|
|
|
|
|
2013-10-30 13:52:40 +01:00
|
|
|
r = bus_open_system_systemd(&bus);
|
2013-08-12 00:35:49 +02:00
|
|
|
if (r < 0) {
|
2014-11-28 13:19:16 +01:00
|
|
|
log_error_errno(r, "Failed to get D-Bus connection: %m");
|
2013-08-12 00:35:49 +02:00
|
|
|
return;
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
2013-08-12 00:35:49 +02:00
|
|
|
log_info("Running request %s/start/replace", target);
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2010-10-19 21:53:19 +02:00
|
|
|
/* Start these units only if we can replace base.target with it */
|
2013-08-12 00:35:49 +02:00
|
|
|
r = sd_bus_call_method(bus,
|
|
|
|
"org.freedesktop.systemd1",
|
|
|
|
"/org/freedesktop/systemd1",
|
|
|
|
"org.freedesktop.systemd1.Manager",
|
|
|
|
"StartUnitReplace",
|
|
|
|
&error,
|
|
|
|
NULL,
|
|
|
|
"sss", "basic.target", target, "replace");
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2013-10-30 16:13:21 +01:00
|
|
|
/* Don't print a warning if we aren't called during startup */
|
|
|
|
if (r < 0 && !sd_bus_error_has_name(&error, BUS_ERROR_NO_SUCH_JOB))
|
|
|
|
log_error("Failed to start unit: %s", bus_error_message(&error, -r));
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
2014-03-06 17:05:55 +01:00
|
|
|
static int parse_proc_cmdline_item(const char *key, const char *value) {
|
|
|
|
|
|
|
|
if (streq(key, "fsck.mode") && value) {
|
|
|
|
|
|
|
|
if (streq(value, "auto"))
|
|
|
|
arg_force = arg_skip = false;
|
|
|
|
else if (streq(value, "force"))
|
|
|
|
arg_force = true;
|
|
|
|
else if (streq(value, "skip"))
|
|
|
|
arg_skip = true;
|
|
|
|
else
|
2014-06-19 16:55:20 +02:00
|
|
|
log_warning("Invalid fsck.mode= parameter '%s'. Ignoring.", value);
|
|
|
|
|
2014-05-15 19:07:43 +02:00
|
|
|
} else if (streq(key, "fsck.repair") && value) {
|
|
|
|
|
|
|
|
if (streq(value, "preen"))
|
|
|
|
arg_repair = "-a";
|
|
|
|
else if (streq(value, "yes"))
|
|
|
|
arg_repair = "-y";
|
|
|
|
else if (streq(value, "no"))
|
|
|
|
arg_repair = "-n";
|
|
|
|
else
|
2014-06-19 16:55:20 +02:00
|
|
|
log_warning("Invalid fsck.repair= parameter '%s'. Ignoring.", value);
|
|
|
|
}
|
|
|
|
|
2013-01-04 22:00:46 +01:00
|
|
|
#ifdef HAVE_SYSV_COMPAT
|
2014-03-06 17:05:55 +01:00
|
|
|
else if (streq(key, "fastboot") && !value) {
|
|
|
|
log_warning("Please pass 'fsck.mode=skip' rather than 'fastboot' on the kernel command line.");
|
2014-02-16 00:08:59 +01:00
|
|
|
arg_skip = true;
|
2014-06-19 16:55:20 +02:00
|
|
|
|
2014-03-06 17:05:55 +01:00
|
|
|
} else if (streq(key, "forcefsck") && !value) {
|
|
|
|
log_warning("Please pass 'fsck.mode=force' rather than 'forcefsck' on the kernel command line.");
|
2014-02-16 00:08:59 +01:00
|
|
|
arg_force = true;
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
2014-02-16 00:08:59 +01:00
|
|
|
#endif
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_files(void) {
|
2014-06-19 16:55:20 +02:00
|
|
|
|
2013-01-04 22:00:46 +01:00
|
|
|
#ifdef HAVE_SYSV_COMPAT
|
|
|
|
if (access("/fastboot", F_OK) >= 0) {
|
|
|
|
log_error("Please pass 'fsck.mode=skip' on the kernel command line rather than creating /fastboot on the root file system.");
|
2010-10-19 21:19:12 +02:00
|
|
|
arg_skip = true;
|
2013-01-04 22:00:46 +01:00
|
|
|
}
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2013-01-04 22:00:46 +01:00
|
|
|
if (access("/forcefsck", F_OK) >= 0) {
|
|
|
|
log_error("Please pass 'fsck.mode=force' on the kernel command line rather than creating /forcefsck on the root file system.");
|
2010-10-19 21:19:12 +02:00
|
|
|
arg_force = true;
|
2013-01-04 22:00:46 +01:00
|
|
|
}
|
|
|
|
#endif
|
2011-09-01 21:05:06 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2015-02-05 17:08:18 +01:00
|
|
|
static int process_progress(int fd, pid_t fsck_pid, dev_t device_num) {
|
2015-02-04 16:42:47 +01:00
|
|
|
_cleanup_fclose_ FILE *f = NULL;
|
|
|
|
usec_t last = 0;
|
|
|
|
_cleanup_close_ int fsckd_fd = -1;
|
|
|
|
static const union sockaddr_union sa = {
|
|
|
|
.un.sun_family = AF_UNIX,
|
|
|
|
.un.sun_path = FSCKD_SOCKET_PATH,
|
2011-09-01 21:05:06 +02:00
|
|
|
};
|
|
|
|
|
2015-02-04 16:42:47 +01:00
|
|
|
fsckd_fd = socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
|
|
|
if (fsckd_fd < 0)
|
|
|
|
return log_warning_errno(errno, "Cannot open fsckd socket, we won't report fsck progress: %m");
|
|
|
|
if (connect(fsckd_fd, &sa.sa, offsetof(struct sockaddr_un, sun_path) + strlen(sa.un.sun_path)) < 0)
|
|
|
|
return log_warning_errno(errno, "Cannot connect to fsckd socket, we won't report fsck progress: %m");
|
2011-09-01 21:05:06 +02:00
|
|
|
|
|
|
|
f = fdopen(fd, "r");
|
2015-02-04 16:42:47 +01:00
|
|
|
if (!f)
|
|
|
|
return log_warning_errno(errno, "Cannot connect to fsck, we won't report fsck progress: %m");
|
2011-09-01 21:05:06 +02:00
|
|
|
|
|
|
|
while (!feof(f)) {
|
2015-02-04 16:42:47 +01:00
|
|
|
int pass;
|
2015-02-05 17:08:18 +01:00
|
|
|
size_t buflen;
|
2015-02-04 16:42:47 +01:00
|
|
|
size_t cur, max;
|
2015-02-05 17:08:18 +01:00
|
|
|
ssize_t r;
|
2011-09-01 21:05:06 +02:00
|
|
|
usec_t t;
|
2015-02-04 16:42:47 +01:00
|
|
|
_cleanup_free_ char *device = NULL;
|
|
|
|
FsckProgress progress;
|
2015-02-05 17:08:18 +01:00
|
|
|
FsckdMessage fsckd_message;
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2015-03-18 22:36:16 +01:00
|
|
|
if (fscanf(f, "%i %zu %zu %ms", &pass, &cur, &max, &device) != 4)
|
2011-09-01 21:05:06 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
/* Only update once every 50ms */
|
|
|
|
t = now(CLOCK_MONOTONIC);
|
2013-11-12 05:32:31 +01:00
|
|
|
if (last + 50 * USEC_PER_MSEC > t)
|
2011-09-01 21:05:06 +02:00
|
|
|
continue;
|
|
|
|
|
|
|
|
last = t;
|
|
|
|
|
2015-02-04 16:42:47 +01:00
|
|
|
/* send progress to fsckd */
|
|
|
|
progress.devnum = device_num;
|
|
|
|
progress.cur = cur;
|
|
|
|
progress.max = max;
|
|
|
|
progress.pass = pass;
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2015-02-05 17:08:18 +01:00
|
|
|
r = send(fsckd_fd, &progress, sizeof(FsckProgress), 0);
|
|
|
|
if (r < 0 || (size_t) r < sizeof(FsckProgress))
|
2015-02-04 16:42:47 +01:00
|
|
|
log_warning_errno(errno, "Cannot communicate fsck progress to fsckd: %m");
|
2015-02-05 17:08:18 +01:00
|
|
|
|
|
|
|
/* get fsckd requests, only read when we have coherent size data */
|
|
|
|
r = ioctl(fsckd_fd, FIONREAD, &buflen);
|
|
|
|
if (r == 0 && (size_t) buflen >= sizeof(FsckdMessage)) {
|
|
|
|
r = recv(fsckd_fd, &fsckd_message, sizeof(FsckdMessage), 0);
|
|
|
|
if (r > 0 && fsckd_message.cancel == 1) {
|
|
|
|
log_info("Request to cancel fsck from fsckd");
|
|
|
|
kill(fsck_pid, SIGTERM);
|
|
|
|
}
|
|
|
|
}
|
2011-09-01 21:05:06 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]) {
|
2011-09-01 21:05:06 +02:00
|
|
|
const char *cmdline[9];
|
2010-10-19 21:19:12 +02:00
|
|
|
int i = 0, r = EXIT_FAILURE, q;
|
|
|
|
pid_t pid;
|
2015-02-05 17:08:18 +01:00
|
|
|
int progress_rc;
|
2010-10-19 21:19:12 +02:00
|
|
|
siginfo_t status;
|
2013-10-13 02:28:21 +02:00
|
|
|
_cleanup_udev_unref_ struct udev *udev = NULL;
|
|
|
|
_cleanup_udev_device_unref_ struct udev_device *udev_device = NULL;
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
const char *device, *type;
|
2010-10-20 00:44:09 +02:00
|
|
|
bool root_directory;
|
2015-03-09 19:50:37 +01:00
|
|
|
_cleanup_close_pair_ int progress_pipe[2] = { -1, -1 };
|
2015-01-27 14:00:11 +01:00
|
|
|
char dash_c[sizeof("-C")-1 + DECIMAL_STR_MAX(int) + 1];
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
struct stat st;
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2010-10-19 23:45:18 +02:00
|
|
|
if (argc > 2) {
|
|
|
|
log_error("This program expects one or no arguments.");
|
2010-10-19 21:19:12 +02:00
|
|
|
return EXIT_FAILURE;
|
|
|
|
}
|
|
|
|
|
2011-09-01 21:05:06 +02:00
|
|
|
log_set_target(LOG_TARGET_AUTO);
|
2010-10-19 21:19:12 +02:00
|
|
|
log_parse_environment();
|
|
|
|
log_open();
|
|
|
|
|
2011-08-01 20:52:18 +02:00
|
|
|
umask(0022);
|
|
|
|
|
2014-11-06 21:53:34 +01:00
|
|
|
q = parse_proc_cmdline(parse_proc_cmdline_item);
|
|
|
|
if (q < 0)
|
2014-11-28 13:19:16 +01:00
|
|
|
log_warning_errno(q, "Failed to parse kernel command line, ignoring: %m");
|
2014-11-06 21:53:34 +01:00
|
|
|
|
2010-10-19 21:19:12 +02:00
|
|
|
test_files();
|
|
|
|
|
2015-03-09 19:57:39 +01:00
|
|
|
if (!arg_force && arg_skip) {
|
|
|
|
r = 0;
|
|
|
|
goto finish;
|
|
|
|
}
|
2010-10-19 23:45:18 +02:00
|
|
|
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
udev = udev_new();
|
|
|
|
if (!udev) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_oom();
|
|
|
|
goto finish;
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
}
|
|
|
|
|
2010-10-20 00:44:09 +02:00
|
|
|
if (argc > 1) {
|
2010-10-19 23:45:18 +02:00
|
|
|
device = argv[1];
|
2010-10-20 00:44:09 +02:00
|
|
|
root_directory = false;
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
|
|
|
|
if (stat(device, &st) < 0) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_error_errno(errno, "Failed to stat '%s': %m", device);
|
|
|
|
goto finish;
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
udev_device = udev_device_new_from_devnum(udev, 'b', st.st_rdev);
|
|
|
|
if (!udev_device) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_error_errno(errno, "Failed to detect device %s", device);
|
|
|
|
goto finish;
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
}
|
2010-10-20 00:44:09 +02:00
|
|
|
} else {
|
2010-10-29 19:54:02 +02:00
|
|
|
struct timespec times[2];
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2010-10-19 23:45:18 +02:00
|
|
|
/* Find root device */
|
|
|
|
|
|
|
|
if (stat("/", &st) < 0) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_error_errno(errno, "Failed to stat() the root directory: %m");
|
|
|
|
goto finish;
|
2010-10-19 23:45:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Virtual root devices don't need an fsck */
|
2015-03-09 19:57:39 +01:00
|
|
|
if (major(st.st_dev) == 0) {
|
|
|
|
log_debug("Root directory is virtual, skipping check.");
|
|
|
|
r = 0;
|
|
|
|
goto finish;
|
|
|
|
}
|
2010-10-19 23:45:18 +02:00
|
|
|
|
2010-10-29 19:54:02 +02:00
|
|
|
/* check if we are already writable */
|
|
|
|
times[0] = st.st_atim;
|
|
|
|
times[1] = st.st_mtim;
|
|
|
|
if (utimensat(AT_FDCWD, "/", times, 0) == 0) {
|
2010-10-31 00:39:36 +02:00
|
|
|
log_info("Root directory is writable, skipping check.");
|
2015-03-09 19:57:39 +01:00
|
|
|
r = 0;
|
|
|
|
goto finish;
|
2010-10-29 19:54:02 +02:00
|
|
|
}
|
|
|
|
|
2013-11-12 05:32:31 +01:00
|
|
|
udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
|
|
|
|
if (!udev_device) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_error_errno(errno, "Failed to detect root device.");
|
|
|
|
goto finish;
|
2010-10-19 23:45:18 +02:00
|
|
|
}
|
|
|
|
|
2013-11-12 05:32:31 +01:00
|
|
|
device = udev_device_get_devnode(udev_device);
|
|
|
|
if (!device) {
|
2010-10-19 23:45:18 +02:00
|
|
|
log_error("Failed to detect device node of root directory.");
|
2015-03-09 19:57:39 +01:00
|
|
|
r = -ENXIO;
|
|
|
|
goto finish;
|
2010-10-19 21:22:47 +02:00
|
|
|
}
|
2010-10-20 00:44:09 +02:00
|
|
|
|
|
|
|
root_directory = true;
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
type = udev_device_get_property_value(udev_device, "ID_FS_TYPE");
|
|
|
|
if (type) {
|
2014-04-12 22:07:45 +02:00
|
|
|
r = fsck_exists(type);
|
2014-06-24 19:37:22 +02:00
|
|
|
if (r == -ENOENT) {
|
|
|
|
log_info("fsck.%s doesn't exist, not checking file system on %s", type, device);
|
2015-03-09 19:57:39 +01:00
|
|
|
r = 0;
|
|
|
|
goto finish;
|
2014-06-24 19:37:22 +02:00
|
|
|
} else if (r < 0)
|
2014-11-28 13:19:16 +01:00
|
|
|
log_warning_errno(r, "fsck.%s cannot be used for %s: %m", type, device);
|
fsck,fstab-generator: be lenient about missing fsck.<type>
If fstab contains 1 for passno, treat this as an error, but only warn
briefly. If fstab doesn't contain this information, don't complain at
all.
Patch is complicated a bit by the fact that we might have the fstype specified
in fstab or on /proc/cmdline, in which case we can check if we have the appropriate
fsck tool, or not specified, or specified as auto, in which case we have to look
and check the type of the filesystem ourselves. It cannot be done before the
device appears, so it is too early in the generator phase, and it must be done
directly in fsck service.
2013-11-12 06:53:59 +01:00
|
|
|
}
|
|
|
|
|
2015-01-26 16:01:11 +01:00
|
|
|
if (pipe(progress_pipe) < 0) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_error_errno(errno, "pipe(): %m");
|
|
|
|
goto finish;
|
2015-01-26 16:01:11 +01:00
|
|
|
}
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2010-10-19 21:19:12 +02:00
|
|
|
cmdline[i++] = "/sbin/fsck";
|
2014-05-15 19:07:43 +02:00
|
|
|
cmdline[i++] = arg_repair;
|
2010-10-19 21:19:12 +02:00
|
|
|
cmdline[i++] = "-T";
|
2014-06-04 11:14:48 +02:00
|
|
|
|
|
|
|
/*
|
2014-10-22 10:28:42 +02:00
|
|
|
* Since util-linux v2.25 fsck uses /run/fsck/<diskname>.lock files.
|
|
|
|
* The previous versions use flock for the device and conflict with
|
|
|
|
* udevd, see https://bugs.freedesktop.org/show_bug.cgi?id=79576#c5
|
2014-06-04 11:14:48 +02:00
|
|
|
*/
|
2014-10-22 10:28:42 +02:00
|
|
|
cmdline[i++] = "-l";
|
2010-10-20 00:44:09 +02:00
|
|
|
|
|
|
|
if (!root_directory)
|
|
|
|
cmdline[i++] = "-M";
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
if (arg_force)
|
|
|
|
cmdline[i++] = "-f";
|
|
|
|
|
2015-03-03 06:02:31 +01:00
|
|
|
xsprintf(dash_c, "-C%i", progress_pipe[1]);
|
|
|
|
cmdline[i++] = dash_c;
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2010-10-19 23:45:18 +02:00
|
|
|
cmdline[i++] = device;
|
2010-10-19 21:19:12 +02:00
|
|
|
cmdline[i++] = NULL;
|
|
|
|
|
2011-09-01 21:05:06 +02:00
|
|
|
pid = fork();
|
|
|
|
if (pid < 0) {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = log_error_errno(errno, "fork(): %m");
|
2010-10-19 21:19:12 +02:00
|
|
|
goto finish;
|
|
|
|
} else if (pid == 0) {
|
|
|
|
/* Child */
|
2015-03-09 19:50:37 +01:00
|
|
|
progress_pipe[0] = safe_close(progress_pipe[0]);
|
2010-10-19 21:19:12 +02:00
|
|
|
execv(cmdline[0], (char**) cmdline);
|
|
|
|
_exit(8); /* Operational error */
|
|
|
|
}
|
|
|
|
|
2014-03-18 19:22:43 +01:00
|
|
|
progress_pipe[1] = safe_close(progress_pipe[1]);
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2015-03-03 06:02:31 +01:00
|
|
|
progress_rc = process_progress(progress_pipe[0], pid, st.st_rdev);
|
|
|
|
progress_pipe[0] = -1;
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2015-03-09 19:57:39 +01:00
|
|
|
r = wait_for_terminate(pid, &status);
|
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "waitid(): %m");
|
2010-10-19 21:19:12 +02:00
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
2015-02-05 17:08:18 +01:00
|
|
|
if (status.si_code != CLD_EXITED || (status.si_status & ~1) || progress_rc != 0) {
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2015-02-05 17:08:18 +01:00
|
|
|
/* cancel will kill fsck (but process_progress returns 0) */
|
|
|
|
if ((progress_rc != 0 && status.si_code == CLD_KILLED) || status.si_code == CLD_DUMPED)
|
2010-10-19 23:45:18 +02:00
|
|
|
log_error("fsck terminated by signal %s.", signal_to_string(status.si_status));
|
|
|
|
else if (status.si_code == CLD_EXITED)
|
|
|
|
log_error("fsck failed with error code %i.", status.si_status);
|
2015-02-05 17:08:18 +01:00
|
|
|
else if (progress_rc != 0)
|
2010-10-19 23:45:18 +02:00
|
|
|
log_error("fsck failed due to unknown reason.");
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2015-03-09 19:57:39 +01:00
|
|
|
r = -EINVAL;
|
|
|
|
|
2011-02-15 00:30:51 +01:00
|
|
|
if (status.si_code == CLD_EXITED && (status.si_status & 2) && root_directory)
|
2010-10-19 21:19:12 +02:00
|
|
|
/* System should be rebooted. */
|
2012-05-04 10:32:47 +02:00
|
|
|
start_target(SPECIAL_REBOOT_TARGET);
|
2011-02-15 00:30:51 +01:00
|
|
|
else if (status.si_code == CLD_EXITED && (status.si_status & 6))
|
2010-10-19 21:19:12 +02:00
|
|
|
/* Some other problem */
|
2012-05-04 10:32:47 +02:00
|
|
|
start_target(SPECIAL_EMERGENCY_TARGET);
|
2011-02-15 00:30:51 +01:00
|
|
|
else {
|
2015-03-09 19:57:39 +01:00
|
|
|
r = 0;
|
2015-02-05 17:08:18 +01:00
|
|
|
if (progress_rc != 0)
|
|
|
|
log_warning("Ignoring error.");
|
2011-02-15 00:30:51 +01:00
|
|
|
}
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
} else
|
2015-03-09 19:57:39 +01:00
|
|
|
r = 0;
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2010-10-19 23:45:18 +02:00
|
|
|
if (status.si_code == CLD_EXITED && (status.si_status & 1))
|
2011-03-25 05:07:20 +01:00
|
|
|
touch("/run/systemd/quotacheck");
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
finish:
|
2015-03-09 19:57:39 +01:00
|
|
|
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|