2010-10-19 21:19:12 +02:00
|
|
|
/***
|
|
|
|
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 <errno.h>
|
2010-10-29 19:54:02 +02:00
|
|
|
#include <fcntl.h>
|
2015-11-16 22:09:36 +01:00
|
|
|
#include <stdbool.h>
|
|
|
|
#include <stdio.h>
|
2011-09-01 21:05:06 +02:00
|
|
|
#include <sys/file.h>
|
2015-04-28 17:13:23 +02:00
|
|
|
#include <sys/prctl.h>
|
2015-11-16 22:09:36 +01:00
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2013-08-12 00:35:49 +02:00
|
|
|
#include "sd-bus.h"
|
2015-04-01 14:33:02 +02:00
|
|
|
#include "sd-device.h"
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2014-12-10 19:00:46 +01:00
|
|
|
#include "bus-common-errors.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "bus-error.h"
|
|
|
|
#include "bus-util.h"
|
2015-04-01 14:33:02 +02:00
|
|
|
#include "device-util.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "fd-util.h"
|
2015-10-26 21:16:26 +01:00
|
|
|
#include "fs-util.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2014-04-12 22:07:45 +02:00
|
|
|
#include "path-util.h"
|
2015-10-27 00:06:29 +01:00
|
|
|
#include "proc-cmdline.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "process-util.h"
|
|
|
|
#include "signal-util.h"
|
2015-02-04 16:42:47 +01:00
|
|
|
#include "socket-util.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "special.h"
|
2015-10-27 01:26:31 +01:00
|
|
|
#include "stdio-util.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "util.h"
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2015-04-28 20:59:36 +02:00
|
|
|
/* exit codes as defined in fsck(8) */
|
|
|
|
enum {
|
|
|
|
FSCK_SUCCESS = 0,
|
|
|
|
FSCK_ERROR_CORRECTED = 1,
|
|
|
|
FSCK_SYSTEM_SHOULD_REBOOT = 2,
|
|
|
|
FSCK_ERRORS_LEFT_UNCORRECTED = 4,
|
|
|
|
FSCK_OPERATIONAL_ERROR = 8,
|
|
|
|
FSCK_USAGE_OR_SYNTAX_ERROR = 16,
|
|
|
|
FSCK_USER_CANCELLED = 32,
|
|
|
|
FSCK_SHARED_LIB_ERROR = 128,
|
|
|
|
};
|
|
|
|
|
2010-10-19 21:19:12 +02:00
|
|
|
static bool arg_skip = false;
|
|
|
|
static bool arg_force = false;
|
2015-04-28 17:13:23 +02:00
|
|
|
static bool arg_show_progress = false;
|
2014-05-15 19:07:43 +02:00
|
|
|
static const char *arg_repair = "-a";
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2015-09-26 20:15:13 +02:00
|
|
|
static void start_target(const char *target, const char *mode) {
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
|
|
|
|
_cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
|
2013-08-12 00:35:49 +02:00
|
|
|
int r;
|
2010-10-19 21:19:12 +02:00
|
|
|
|
|
|
|
assert(target);
|
|
|
|
|
2015-09-24 13:30:10 +02:00
|
|
|
r = bus_connect_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,
|
2015-09-26 20:15:13 +02:00
|
|
|
"sss", "basic.target", target, mode);
|
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))
|
2015-04-28 16:46:06 +02:00
|
|
|
log_error("Failed to start unit: %s", bus_error_message(&error, r));
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
2016-10-22 20:24:52 +02:00
|
|
|
static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
|
2015-04-28 16:46:06 +02:00
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(key);
|
2014-03-06 17:05:55 +01:00
|
|
|
|
util-lib: various improvements to kernel command line parsing
This improves kernel command line parsing in a number of ways:
a) An kernel option "foo_bar=xyz" is now considered equivalent to
"foo-bar-xyz", i.e. when comparing kernel command line option names "-" and
"_" are now considered equivalent (this only applies to the option names
though, not the option values!). Most of our kernel options used "-" as word
separator in kernel command line options so far, but some used "_". With
this change, which was a source of confusion for users (well, at least of
one user: myself, I just couldn't remember that it's systemd.debug-shell,
not systemd.debug_shell). Considering both as equivalent is inspired how
modern kernel module loading normalizes all kernel module names to use
underscores now too.
b) All options previously using a dash for separating words in kernel command
line options now use an underscore instead, in all documentation and in
code. Since a) has been implemented this should not create any compatibility
problems, but normalizes our documentation and our code.
c) All kernel command line options which take booleans (or are boolean-like)
have been reworked so that "foobar" (without argument) is now equivalent to
"foobar=1" (but not "foobar=0"), thus normalizing the handling of our
boolean arguments. Specifically this means systemd.debug-shell and
systemd_debug_shell=1 are now entirely equivalent.
d) All kernel command line options which take an argument, and where no
argument is specified will now result in a log message. e.g. passing just
"systemd.unit" will no result in a complain that it needs an argument. This
is implemented in the proc_cmdline_missing_value() function.
e) There's now a call proc_cmdline_get_bool() similar to proc_cmdline_get_key()
that parses booleans (following the logic explained in c).
f) The proc_cmdline_parse() call's boolean argument has been replaced by a new
flags argument that takes a common set of bits with proc_cmdline_get_key().
g) All kernel command line APIs now begin with the same "proc_cmdline_" prefix.
h) There are now tests for much of this. Yay!
2016-12-12 18:29:15 +01:00
|
|
|
if (streq(key, "fsck.mode")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
2014-03-06 17:05:55 +01:00
|
|
|
|
|
|
|
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);
|
|
|
|
|
util-lib: various improvements to kernel command line parsing
This improves kernel command line parsing in a number of ways:
a) An kernel option "foo_bar=xyz" is now considered equivalent to
"foo-bar-xyz", i.e. when comparing kernel command line option names "-" and
"_" are now considered equivalent (this only applies to the option names
though, not the option values!). Most of our kernel options used "-" as word
separator in kernel command line options so far, but some used "_". With
this change, which was a source of confusion for users (well, at least of
one user: myself, I just couldn't remember that it's systemd.debug-shell,
not systemd.debug_shell). Considering both as equivalent is inspired how
modern kernel module loading normalizes all kernel module names to use
underscores now too.
b) All options previously using a dash for separating words in kernel command
line options now use an underscore instead, in all documentation and in
code. Since a) has been implemented this should not create any compatibility
problems, but normalizes our documentation and our code.
c) All kernel command line options which take booleans (or are boolean-like)
have been reworked so that "foobar" (without argument) is now equivalent to
"foobar=1" (but not "foobar=0"), thus normalizing the handling of our
boolean arguments. Specifically this means systemd.debug-shell and
systemd_debug_shell=1 are now entirely equivalent.
d) All kernel command line options which take an argument, and where no
argument is specified will now result in a log message. e.g. passing just
"systemd.unit" will no result in a complain that it needs an argument. This
is implemented in the proc_cmdline_missing_value() function.
e) There's now a call proc_cmdline_get_bool() similar to proc_cmdline_get_key()
that parses booleans (following the logic explained in c).
f) The proc_cmdline_parse() call's boolean argument has been replaced by a new
flags argument that takes a common set of bits with proc_cmdline_get_key().
g) All kernel command line APIs now begin with the same "proc_cmdline_" prefix.
h) There are now tests for much of this. Yay!
2016-12-12 18:29:15 +01:00
|
|
|
} else if (streq(key, "fsck.repair")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
2014-05-15 19:07:43 +02:00
|
|
|
|
|
|
|
if (streq(value, "preen"))
|
|
|
|
arg_repair = "-a";
|
2015-04-28 16:46:06 +02:00
|
|
|
else {
|
|
|
|
r = parse_boolean(value);
|
|
|
|
if (r > 0)
|
|
|
|
arg_repair = "-y";
|
|
|
|
else if (r == 0)
|
|
|
|
arg_repair = "-n";
|
|
|
|
else
|
|
|
|
log_warning("Invalid fsck.repair= parameter '%s'. Ignoring.", value);
|
|
|
|
}
|
2014-06-19 16:55:20 +02:00
|
|
|
}
|
|
|
|
|
2017-10-03 10:41:51 +02:00
|
|
|
#if 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
|
|
|
|
2017-10-03 10:41:51 +02:00
|
|
|
#if HAVE_SYSV_COMPAT
|
2013-01-04 22:00:46 +01:00
|
|
|
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-04-28 17:13:23 +02:00
|
|
|
arg_show_progress = access("/run/systemd/show-status", F_OK) >= 0;
|
2011-09-01 21:05:06 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 17:13:23 +02:00
|
|
|
static double percent(int pass, unsigned long cur, unsigned long max) {
|
|
|
|
/* Values stolen from e2fsck */
|
|
|
|
|
|
|
|
static const int pass_table[] = {
|
|
|
|
0, 70, 90, 92, 95, 100
|
2011-09-01 21:05:06 +02:00
|
|
|
};
|
|
|
|
|
2015-04-28 17:13:23 +02:00
|
|
|
if (pass <= 0)
|
|
|
|
return 0.0;
|
|
|
|
|
|
|
|
if ((unsigned) pass >= ELEMENTSOF(pass_table) || max == 0)
|
|
|
|
return 100.0;
|
|
|
|
|
|
|
|
return (double) pass_table[pass-1] +
|
|
|
|
((double) pass_table[pass] - (double) pass_table[pass-1]) *
|
|
|
|
(double) cur / (double) max;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int process_progress(int fd) {
|
|
|
|
_cleanup_fclose_ FILE *console = NULL, *f = NULL;
|
|
|
|
usec_t last = 0;
|
|
|
|
bool locked = false;
|
|
|
|
int clear = 0, r;
|
|
|
|
|
|
|
|
/* No progress pipe to process? Then we are a NOP. */
|
|
|
|
if (fd < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
f = fdopen(fd, "re");
|
|
|
|
if (!f) {
|
|
|
|
safe_close(fd);
|
|
|
|
return -errno;
|
|
|
|
}
|
|
|
|
|
|
|
|
console = fopen("/dev/console", "we");
|
|
|
|
if (!console)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
int pass, m;
|
|
|
|
unsigned long cur, max;
|
2015-02-04 16:42:47 +01:00
|
|
|
_cleanup_free_ char *device = NULL;
|
2015-04-28 17:13:23 +02:00
|
|
|
double p;
|
|
|
|
usec_t t;
|
2011-09-01 21:05:06 +02:00
|
|
|
|
2015-04-28 17:13:23 +02:00
|
|
|
if (fscanf(f, "%i %lu %lu %ms", &pass, &cur, &max, &device) != 4) {
|
|
|
|
|
|
|
|
if (ferror(f))
|
|
|
|
r = log_warning_errno(errno, "Failed to read from progress pipe: %m");
|
|
|
|
else if (feof(f))
|
|
|
|
r = 0;
|
|
|
|
else {
|
|
|
|
log_warning("Failed to parse progress pipe data");
|
|
|
|
r = -EBADMSG;
|
|
|
|
}
|
2011-09-01 21:05:06 +02:00
|
|
|
break;
|
2015-04-28 17:13:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Only show one progress counter at max */
|
|
|
|
if (!locked) {
|
|
|
|
if (flock(fileno(console), LOCK_EX|LOCK_NB) < 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
locked = true;
|
|
|
|
}
|
2011-09-01 21:05:06 +02:00
|
|
|
|
|
|
|
/* 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-04-28 17:13:23 +02:00
|
|
|
p = percent(pass, cur, max);
|
|
|
|
fprintf(console, "\r%s: fsck %3.1f%% complete...\r%n", device, p, &m);
|
|
|
|
fflush(console);
|
|
|
|
|
|
|
|
if (m > clear)
|
|
|
|
clear = m;
|
2011-09-01 21:05:06 +02:00
|
|
|
}
|
|
|
|
|
2015-04-28 17:13:23 +02:00
|
|
|
if (clear > 0) {
|
|
|
|
unsigned j;
|
|
|
|
|
|
|
|
fputc('\r', console);
|
|
|
|
for (j = 0; j < (unsigned) clear; j++)
|
|
|
|
fputc(' ', console);
|
|
|
|
fputc('\r', console);
|
|
|
|
fflush(console);
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int fsck_progress_socket(void) {
|
|
|
|
static const union sockaddr_union sa = {
|
|
|
|
.un.sun_family = AF_UNIX,
|
|
|
|
.un.sun_path = "/run/systemd/fsck.progress",
|
|
|
|
};
|
|
|
|
|
|
|
|
int fd, r;
|
|
|
|
|
|
|
|
fd = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
|
|
if (fd < 0)
|
|
|
|
return log_warning_errno(errno, "socket(): %m");
|
|
|
|
|
2016-05-05 22:24:36 +02:00
|
|
|
if (connect(fd, &sa.sa, SOCKADDR_UN_LEN(sa.un)) < 0) {
|
2017-09-29 00:37:23 +02:00
|
|
|
r = log_full_errno(IN_SET(errno, ECONNREFUSED, ENOENT) ? LOG_DEBUG : LOG_WARNING,
|
2015-04-28 17:13:23 +02:00
|
|
|
errno, "Failed to connect to progress socket %s, ignoring: %m", sa.un.sun_path);
|
|
|
|
safe_close(fd);
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
return fd;
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char *argv[]) {
|
2015-04-28 17:13:23 +02:00
|
|
|
_cleanup_close_pair_ int progress_pipe[2] = { -1, -1 };
|
tree-wide: expose "p"-suffix unref calls in public APIs to make gcc cleanup easy
GLIB has recently started to officially support the gcc cleanup
attribute in its public API, hence let's do the same for our APIs.
With this patch we'll define an xyz_unrefp() call for each public
xyz_unref() call, to make it easy to use inside a
__attribute__((cleanup())) expression. Then, all code is ported over to
make use of this.
The new calls are also documented in the man pages, with examples how to
use them (well, I only added docs where the _unref() call itself already
had docs, and the examples, only cover sd_bus_unrefp() and
sd_event_unrefp()).
This also renames sd_lldp_free() to sd_lldp_unref(), since that's how we
tend to call our destructors these days.
Note that this defines no public macro that wraps gcc's attribute and
makes it easier to use. While I think it's our duty in the library to
make our stuff easy to use, I figure it's not our duty to make gcc's own
features easy to use on its own. Most likely, client code which wants to
make use of this should define its own:
#define _cleanup_(function) __attribute__((cleanup(function)))
Or similar, to make the gcc feature easier to use.
Making this logic public has the benefit that we can remove three header
files whose only purpose was to define these functions internally.
See #2008.
2015-11-27 19:13:45 +01:00
|
|
|
_cleanup_(sd_device_unrefp) sd_device *dev = 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-04-28 17:13:23 +02:00
|
|
|
siginfo_t status;
|
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;
|
2015-04-28 17:13:23 +02:00
|
|
|
int r;
|
|
|
|
pid_t pid;
|
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);
|
|
|
|
|
util-lib: various improvements to kernel command line parsing
This improves kernel command line parsing in a number of ways:
a) An kernel option "foo_bar=xyz" is now considered equivalent to
"foo-bar-xyz", i.e. when comparing kernel command line option names "-" and
"_" are now considered equivalent (this only applies to the option names
though, not the option values!). Most of our kernel options used "-" as word
separator in kernel command line options so far, but some used "_". With
this change, which was a source of confusion for users (well, at least of
one user: myself, I just couldn't remember that it's systemd.debug-shell,
not systemd.debug_shell). Considering both as equivalent is inspired how
modern kernel module loading normalizes all kernel module names to use
underscores now too.
b) All options previously using a dash for separating words in kernel command
line options now use an underscore instead, in all documentation and in
code. Since a) has been implemented this should not create any compatibility
problems, but normalizes our documentation and our code.
c) All kernel command line options which take booleans (or are boolean-like)
have been reworked so that "foobar" (without argument) is now equivalent to
"foobar=1" (but not "foobar=0"), thus normalizing the handling of our
boolean arguments. Specifically this means systemd.debug-shell and
systemd_debug_shell=1 are now entirely equivalent.
d) All kernel command line options which take an argument, and where no
argument is specified will now result in a log message. e.g. passing just
"systemd.unit" will no result in a complain that it needs an argument. This
is implemented in the proc_cmdline_missing_value() function.
e) There's now a call proc_cmdline_get_bool() similar to proc_cmdline_get_key()
that parses booleans (following the logic explained in c).
f) The proc_cmdline_parse() call's boolean argument has been replaced by a new
flags argument that takes a common set of bits with proc_cmdline_get_key().
g) All kernel command line APIs now begin with the same "proc_cmdline_" prefix.
h) There are now tests for much of this. Yay!
2016-12-12 18:29:15 +01:00
|
|
|
r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, PROC_CMDLINE_STRIP_RD_PREFIX);
|
2015-04-28 16:49:43 +02:00
|
|
|
if (r < 0)
|
|
|
|
log_warning_errno(r, "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
|
|
|
|
2010-10-20 00:44:09 +02:00
|
|
|
if (argc > 1) {
|
2010-10-19 23:45:18 +02:00
|
|
|
device = argv[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
|
|
|
|
|
|
|
if (stat(device, &st) < 0) {
|
2015-04-28 16:49:43 +02:00
|
|
|
r = log_error_errno(errno, "Failed to stat %s: %m", device);
|
|
|
|
goto finish;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!S_ISBLK(st.st_mode)) {
|
|
|
|
log_error("%s is not a block device.", device);
|
|
|
|
r = -EINVAL;
|
2015-03-09 19:57:39 +01:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-04-01 14:33:02 +02:00
|
|
|
r = sd_device_new_from_devnum(&dev, 'b', st.st_rdev);
|
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to detect device %s: %m", device);
|
2015-03-09 19:57:39 +01:00
|
|
|
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
|
|
|
}
|
2015-04-28 16:49:43 +02:00
|
|
|
|
|
|
|
root_directory = false;
|
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) {
|
2015-04-28 16:49:43 +02:00
|
|
|
log_debug("Root directory is virtual or btrfs, skipping check.");
|
2015-03-09 19:57:39 +01:00
|
|
|
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;
|
2015-04-28 16:49:43 +02:00
|
|
|
|
2010-10-29 19:54:02 +02:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-04-01 14:33:02 +02:00
|
|
|
r = sd_device_new_from_devnum(&dev, 'b', st.st_dev);
|
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to detect root device: %m");
|
2015-03-09 19:57:39 +01:00
|
|
|
goto finish;
|
2010-10-19 23:45:18 +02:00
|
|
|
}
|
|
|
|
|
2015-04-01 14:33:02 +02:00
|
|
|
r = sd_device_get_devname(dev, &device);
|
|
|
|
if (r < 0) {
|
|
|
|
log_error_errno(r, "Failed to detect device node of root directory: %m");
|
2015-03-09 19:57:39 +01:00
|
|
|
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
|
|
|
}
|
|
|
|
|
2015-04-01 14:33:02 +02:00
|
|
|
r = sd_device_get_property_value(dev, "ID_FS_TYPE", &type);
|
|
|
|
if (r >= 0) {
|
2014-04-12 22:07:45 +02:00
|
|
|
r = fsck_exists(type);
|
2015-10-22 18:24:59 +02:00
|
|
|
if (r < 0)
|
|
|
|
log_warning_errno(r, "Couldn't detect if fsck.%s may be used for %s, proceeding: %m", type, device);
|
|
|
|
else if (r == 0) {
|
|
|
|
log_info("fsck.%s doesn't exist, not checking file system on %s.", type, device);
|
2015-03-09 19:57:39 +01:00
|
|
|
goto finish;
|
2015-10-22 18:24:59 +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
|
|
|
}
|
|
|
|
|
2015-04-28 17:13:23 +02:00
|
|
|
if (arg_show_progress) {
|
|
|
|
if (pipe(progress_pipe) < 0) {
|
|
|
|
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
|
|
|
|
|
|
|
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;
|
2015-04-28 17:13:23 +02:00
|
|
|
}
|
|
|
|
if (pid == 0) {
|
|
|
|
char dash_c[sizeof("-C")-1 + DECIMAL_STR_MAX(int) + 1];
|
|
|
|
int progress_socket = -1;
|
|
|
|
const char *cmdline[9];
|
|
|
|
int i = 0;
|
|
|
|
|
2010-10-19 21:19:12 +02:00
|
|
|
/* Child */
|
2015-04-28 17:13:23 +02:00
|
|
|
|
2015-05-31 23:55:55 +02:00
|
|
|
(void) reset_all_signal_handlers();
|
|
|
|
(void) reset_signal_mask();
|
2015-04-28 17:13:23 +02:00
|
|
|
assert_se(prctl(PR_SET_PDEATHSIG, SIGTERM) == 0);
|
|
|
|
|
|
|
|
/* Close the reading side of the progress pipe */
|
2015-03-09 19:50:37 +01:00
|
|
|
progress_pipe[0] = safe_close(progress_pipe[0]);
|
2015-04-28 17:13:23 +02:00
|
|
|
|
|
|
|
/* Try to connect to a progress management daemon, if there is one */
|
|
|
|
progress_socket = fsck_progress_socket();
|
|
|
|
if (progress_socket >= 0) {
|
|
|
|
/* If this worked we close the progress pipe early, and just use the socket */
|
|
|
|
progress_pipe[1] = safe_close(progress_pipe[1]);
|
|
|
|
xsprintf(dash_c, "-C%i", progress_socket);
|
|
|
|
} else if (progress_pipe[1] >= 0) {
|
|
|
|
/* Otherwise if we have the progress pipe to our own local handle, we use it */
|
|
|
|
xsprintf(dash_c, "-C%i", progress_pipe[1]);
|
|
|
|
} else
|
|
|
|
dash_c[0] = 0;
|
|
|
|
|
|
|
|
cmdline[i++] = "/sbin/fsck";
|
|
|
|
cmdline[i++] = arg_repair;
|
|
|
|
cmdline[i++] = "-T";
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
|
*/
|
|
|
|
cmdline[i++] = "-l";
|
|
|
|
|
|
|
|
if (!root_directory)
|
|
|
|
cmdline[i++] = "-M";
|
|
|
|
|
|
|
|
if (arg_force)
|
|
|
|
cmdline[i++] = "-f";
|
|
|
|
|
|
|
|
if (!isempty(dash_c))
|
|
|
|
cmdline[i++] = dash_c;
|
|
|
|
|
|
|
|
cmdline[i++] = device;
|
|
|
|
cmdline[i++] = NULL;
|
|
|
|
|
2010-10-19 21:19:12 +02:00
|
|
|
execv(cmdline[0], (char**) cmdline);
|
2015-04-28 20:59:36 +02:00
|
|
|
_exit(FSCK_OPERATIONAL_ERROR);
|
2010-10-19 21:19:12 +02:00
|
|
|
}
|
|
|
|
|
2014-03-18 19:22:43 +01:00
|
|
|
progress_pipe[1] = safe_close(progress_pipe[1]);
|
2015-04-28 17:13:23 +02:00
|
|
|
(void) process_progress(progress_pipe[0]);
|
2015-03-03 06:02:31 +01:00
|
|
|
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-04-28 17:13:23 +02:00
|
|
|
if (status.si_code != CLD_EXITED || (status.si_status & ~1)) {
|
2010-10-19 21:19:12 +02:00
|
|
|
|
2015-04-28 17:13:23 +02:00
|
|
|
if (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-04-28 17:13:23 +02:00
|
|
|
else
|
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;
|
|
|
|
|
2015-04-28 20:59:36 +02:00
|
|
|
if (status.si_code == CLD_EXITED && (status.si_status & FSCK_SYSTEM_SHOULD_REBOOT) && root_directory)
|
2010-10-19 21:19:12 +02:00
|
|
|
/* System should be rebooted. */
|
2015-09-26 20:15:13 +02:00
|
|
|
start_target(SPECIAL_REBOOT_TARGET, "replace-irreversibly");
|
2015-04-28 20:59:36 +02:00
|
|
|
else if (status.si_code == CLD_EXITED && (status.si_status & (FSCK_SYSTEM_SHOULD_REBOOT | FSCK_ERRORS_LEFT_UNCORRECTED)))
|
2010-10-19 21:19:12 +02:00
|
|
|
/* Some other problem */
|
2015-09-26 20:15:13 +02:00
|
|
|
start_target(SPECIAL_EMERGENCY_TARGET, "replace");
|
2011-02-15 00:30:51 +01:00
|
|
|
else {
|
2015-04-28 17:13:23 +02:00
|
|
|
log_warning("Ignoring error.");
|
2015-03-09 19:57:39 +01:00
|
|
|
r = 0;
|
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
|
|
|
|
2015-04-28 20:59:36 +02:00
|
|
|
if (status.si_code == CLD_EXITED && (status.si_status & FSCK_ERROR_CORRECTED))
|
2015-04-28 16:49:43 +02:00
|
|
|
(void) 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
|
|
|
}
|