2017-11-18 17:09:20 +01:00
|
|
|
/* SPDX-License-Identifier: LGPL-2.1+ */
|
2012-05-22 19:23:33 +02:00
|
|
|
|
|
|
|
#include <errno.h>
|
2015-10-24 22:58:24 +02:00
|
|
|
#include <stdio.h>
|
2012-05-22 19:23:33 +02:00
|
|
|
#include <unistd.h>
|
|
|
|
|
2015-10-27 03:01:06 +01:00
|
|
|
#include "alloc-util.h"
|
2015-10-25 13:14:12 +01:00
|
|
|
#include "fd-util.h"
|
2015-10-26 18:05:03 +01:00
|
|
|
#include "fileio.h"
|
2017-11-21 20:09:31 +01:00
|
|
|
#include "fs-util.h"
|
2015-01-09 22:58:29 +01:00
|
|
|
#include "fstab-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "generator.h"
|
|
|
|
#include "log.h"
|
2018-11-20 09:56:47 +01:00
|
|
|
#include "main-func.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "mkdir.h"
|
2012-05-22 19:23:33 +02:00
|
|
|
#include "mount-setup.h"
|
2015-10-26 18:44:13 +01:00
|
|
|
#include "mount-util.h"
|
2018-11-29 10:24:39 +01:00
|
|
|
#include "mountpoint-util.h"
|
2015-10-26 16:18:16 +01:00
|
|
|
#include "parse-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "path-util.h"
|
2015-10-27 00:06:29 +01:00
|
|
|
#include "proc-cmdline.h"
|
2012-05-22 19:23:33 +02:00
|
|
|
#include "special.h"
|
2017-11-21 20:09:31 +01:00
|
|
|
#include "specifier.h"
|
2015-10-26 22:01:44 +01:00
|
|
|
#include "stat-util.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "string-util.h"
|
2014-03-06 17:05:55 +01:00
|
|
|
#include "strv.h"
|
2015-10-24 22:58:24 +02:00
|
|
|
#include "unit-name.h"
|
|
|
|
#include "util.h"
|
2014-03-11 17:57:15 +01:00
|
|
|
#include "virt.h"
|
2016-12-13 12:45:19 +01:00
|
|
|
#include "volatile-util.h"
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-11-29 15:49:25 +01:00
|
|
|
typedef enum MountpointFlags {
|
|
|
|
NOAUTO = 1 << 0,
|
|
|
|
NOFAIL = 1 << 1,
|
|
|
|
AUTOMOUNT = 1 << 2,
|
2017-11-21 23:18:05 +01:00
|
|
|
MAKEFS = 1 << 3,
|
2017-11-29 20:02:11 +01:00
|
|
|
GROWFS = 1 << 4,
|
2017-11-29 15:49:25 +01:00
|
|
|
} MountpointFlags;
|
|
|
|
|
2018-12-04 11:49:42 +01:00
|
|
|
static const char *arg_dest = NULL;
|
|
|
|
static const char *arg_dest_late = NULL;
|
2014-03-05 22:26:10 +01:00
|
|
|
static bool arg_fstab_enabled = true;
|
2014-03-06 21:14:26 +01:00
|
|
|
static char *arg_root_what = NULL;
|
|
|
|
static char *arg_root_fstype = NULL;
|
|
|
|
static char *arg_root_options = NULL;
|
2016-12-16 12:57:44 +01:00
|
|
|
static char *arg_root_hash = NULL;
|
2014-03-06 21:14:26 +01:00
|
|
|
static int arg_root_rw = -1;
|
2014-10-09 21:37:17 +02:00
|
|
|
static char *arg_usr_what = NULL;
|
|
|
|
static char *arg_usr_fstype = NULL;
|
|
|
|
static char *arg_usr_options = NULL;
|
2016-12-13 12:45:19 +01:00
|
|
|
static VolatileMode arg_volatile_mode = _VOLATILE_MODE_INVALID;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2018-11-20 09:56:47 +01:00
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_root_what, freep);
|
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_root_fstype, freep);
|
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_root_options, freep);
|
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_root_hash, freep);
|
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_usr_what, freep);
|
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_usr_fstype, freep);
|
|
|
|
STATIC_DESTRUCTOR_REGISTER(arg_usr_options, freep);
|
|
|
|
|
2017-02-07 13:08:56 +01:00
|
|
|
static int write_options(FILE *f, const char *options) {
|
|
|
|
_cleanup_free_ char *o = NULL;
|
|
|
|
|
|
|
|
if (isempty(options))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (streq(options, "defaults"))
|
|
|
|
return 0;
|
|
|
|
|
2017-11-21 20:09:31 +01:00
|
|
|
o = specifier_escape(options);
|
2017-02-07 13:08:56 +01:00
|
|
|
if (!o)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
fprintf(f, "Options=%s\n", o);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2017-02-08 17:14:58 +01:00
|
|
|
static int write_what(FILE *f, const char *what) {
|
|
|
|
_cleanup_free_ char *w = NULL;
|
|
|
|
|
2017-11-21 20:09:31 +01:00
|
|
|
w = specifier_escape(what);
|
2017-02-08 17:14:58 +01:00
|
|
|
if (!w)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
fprintf(f, "What=%s\n", w);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2014-11-26 16:36:52 +01:00
|
|
|
static int add_swap(
|
|
|
|
const char *what,
|
|
|
|
struct mntent *me,
|
2017-11-29 15:49:25 +01:00
|
|
|
MountpointFlags flags) {
|
2014-11-26 16:36:52 +01:00
|
|
|
|
2017-12-09 19:23:26 +01:00
|
|
|
_cleanup_free_ char *name = NULL;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_fclose_ FILE *f = NULL;
|
2015-05-25 12:11:23 +02:00
|
|
|
int r;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
|
|
|
assert(what);
|
|
|
|
assert(me);
|
|
|
|
|
2015-01-05 12:35:08 +01:00
|
|
|
if (access("/proc/swaps", F_OK) < 0) {
|
|
|
|
log_info("Swap not supported, ignoring fstab swap entry for %s.", what);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-07 13:42:47 +02:00
|
|
|
if (detect_container() > 0) {
|
2014-03-11 17:57:15 +01:00
|
|
|
log_info("Running in a container, ignoring fstab swap entry for %s.", what);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(what, ".swap", &name);
|
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to generate unit name: %m");
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
r = generator_open_unit_file(arg_dest, fstab_path(), name, &f);
|
2017-12-09 19:23:26 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2017-12-11 19:50:30 +01:00
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
fprintf(f,
|
|
|
|
"[Unit]\n"
|
2019-12-19 17:38:55 +01:00
|
|
|
"Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n"
|
|
|
|
"SourcePath=%s\n",
|
2019-11-13 17:36:46 +01:00
|
|
|
fstab_path());
|
2017-02-08 17:14:58 +01:00
|
|
|
|
2019-12-19 17:38:55 +01:00
|
|
|
r = generator_write_blockdev_dependency(f, what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
fprintf(f,
|
|
|
|
"\n"
|
|
|
|
"[Swap]\n");
|
|
|
|
|
2017-02-08 17:14:58 +01:00
|
|
|
r = write_what(f, what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-02-07 13:08:56 +01:00
|
|
|
r = write_options(f, me->mnt_opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2014-10-28 14:24:46 +01:00
|
|
|
r = fflush_and_check(f);
|
2014-11-28 18:23:20 +01:00
|
|
|
if (r < 0)
|
2017-12-09 19:23:26 +01:00
|
|
|
return log_error_errno(r, "Failed to write unit file %s: %m", name);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2014-06-27 21:03:05 +02:00
|
|
|
/* use what as where, to have a nicer error message */
|
2015-05-25 12:11:23 +02:00
|
|
|
r = generator_write_timeouts(arg_dest, what, what, me->mnt_opts, NULL);
|
2014-06-27 21:03:05 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2017-11-21 23:18:05 +01:00
|
|
|
if (flags & MAKEFS) {
|
|
|
|
r = generator_hook_up_mkswap(arg_dest, what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2017-11-29 20:02:11 +01:00
|
|
|
if (flags & GROWFS)
|
|
|
|
/* TODO: swap devices must be wiped and recreated */
|
|
|
|
log_warning("%s: growing swap devices is currently unsupported.", what);
|
|
|
|
|
2017-11-29 15:49:25 +01:00
|
|
|
if (!(flags & NOAUTO)) {
|
2017-07-10 05:40:14 +02:00
|
|
|
r = generator_add_symlink(arg_dest, SPECIAL_SWAP_TARGET,
|
2017-11-29 15:49:25 +01:00
|
|
|
(flags & NOFAIL) ? "wants" : "requires", name);
|
2017-07-10 05:40:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2013-09-16 01:08:32 +02:00
|
|
|
}
|
|
|
|
|
2013-01-02 23:15:55 +01:00
|
|
|
return 0;
|
2012-05-22 19:23:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static bool mount_is_network(struct mntent *me) {
|
|
|
|
assert(me);
|
|
|
|
|
2015-01-11 06:04:00 +01:00
|
|
|
return fstab_test_option(me->mnt_opts, "_netdev\0") ||
|
|
|
|
fstype_is_network(me->mnt_type);
|
2012-05-22 19:23:33 +02:00
|
|
|
}
|
|
|
|
|
2013-02-22 11:52:36 +01:00
|
|
|
static bool mount_in_initrd(struct mntent *me) {
|
|
|
|
assert(me);
|
|
|
|
|
2015-01-11 06:04:00 +01:00
|
|
|
return fstab_test_option(me->mnt_opts, "x-initrd.mount\0") ||
|
|
|
|
streq(me->mnt_dir, "/usr");
|
2013-02-22 11:52:36 +01:00
|
|
|
}
|
|
|
|
|
2019-12-19 13:14:03 +01:00
|
|
|
static int write_timeout(
|
|
|
|
FILE *f,
|
|
|
|
const char *where,
|
|
|
|
const char *opts,
|
|
|
|
const char *filter,
|
|
|
|
const char *variable) {
|
|
|
|
|
2015-04-14 22:01:48 +02:00
|
|
|
_cleanup_free_ char *timeout = NULL;
|
|
|
|
char timespan[FORMAT_TIMESPAN_MAX];
|
|
|
|
usec_t u;
|
|
|
|
int r;
|
|
|
|
|
2016-11-11 15:08:57 +01:00
|
|
|
r = fstab_filter_options(opts, filter, NULL, &timeout, NULL);
|
2015-04-14 22:01:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_warning_errno(r, "Failed to parse options: %m");
|
|
|
|
if (r == 0)
|
|
|
|
return 0;
|
|
|
|
|
2017-07-03 14:29:32 +02:00
|
|
|
r = parse_sec_fix_0(timeout, &u);
|
2015-04-14 22:01:48 +02:00
|
|
|
if (r < 0) {
|
|
|
|
log_warning("Failed to parse timeout for %s, ignoring: %s", where, timeout);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-11-11 15:08:57 +01:00
|
|
|
fprintf(f, "%s=%s\n", variable, format_timespan(timespan, sizeof(timespan), u, 0));
|
2015-04-14 22:01:48 +02:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2015-05-02 19:01:29 +02:00
|
|
|
|
2016-11-11 15:08:57 +01:00
|
|
|
static int write_idle_timeout(FILE *f, const char *where, const char *opts) {
|
|
|
|
return write_timeout(f, where, opts,
|
|
|
|
"x-systemd.idle-timeout\0", "TimeoutIdleSec");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_mount_timeout(FILE *f, const char *where, const char *opts) {
|
|
|
|
return write_timeout(f, where, opts,
|
|
|
|
"x-systemd.mount-timeout\0", "TimeoutSec");
|
|
|
|
}
|
|
|
|
|
2019-12-19 13:14:03 +01:00
|
|
|
static int write_dependency(
|
|
|
|
FILE *f,
|
|
|
|
const char *opts,
|
|
|
|
const char *filter,
|
|
|
|
const char *format) {
|
|
|
|
|
2015-05-18 12:30:37 +02:00
|
|
|
_cleanup_strv_free_ char **names = NULL, **units = NULL;
|
|
|
|
_cleanup_free_ char *res = NULL;
|
|
|
|
char **s;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(f);
|
|
|
|
assert(opts);
|
|
|
|
|
2017-02-13 20:50:22 +01:00
|
|
|
r = fstab_extract_values(opts, filter, &names);
|
2015-05-18 12:30:37 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_warning_errno(r, "Failed to parse options: %m");
|
|
|
|
if (r == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
STRV_FOREACH(s, names) {
|
|
|
|
char *x;
|
|
|
|
|
2019-10-24 14:09:11 +02:00
|
|
|
r = unit_name_mangle_with_suffix(*s, "as dependency", 0, ".mount", &x);
|
2015-05-18 12:30:37 +02:00
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to generate unit name: %m");
|
2019-12-19 13:14:03 +01:00
|
|
|
|
2015-05-18 12:30:37 +02:00
|
|
|
r = strv_consume(&units, x);
|
|
|
|
if (r < 0)
|
|
|
|
return log_oom();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (units) {
|
|
|
|
res = strv_join(units, " ");
|
|
|
|
if (!res)
|
|
|
|
return log_oom();
|
2017-02-14 02:58:22 +01:00
|
|
|
#pragma GCC diagnostic push
|
|
|
|
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
|
2017-02-13 20:50:22 +01:00
|
|
|
fprintf(f, format, res);
|
2017-02-14 02:58:22 +01:00
|
|
|
#pragma GCC diagnostic pop
|
2015-05-18 12:30:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-02-13 20:50:22 +01:00
|
|
|
static int write_after(FILE *f, const char *opts) {
|
2019-12-19 13:14:03 +01:00
|
|
|
return write_dependency(f, opts,
|
|
|
|
"x-systemd.after", "After=%1$s\n");
|
2017-02-13 20:50:22 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int write_requires_after(FILE *f, const char *opts) {
|
|
|
|
return write_dependency(f, opts,
|
|
|
|
"x-systemd.requires", "After=%1$s\nRequires=%1$s\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static int write_before(FILE *f, const char *opts) {
|
|
|
|
return write_dependency(f, opts,
|
|
|
|
"x-systemd.before", "Before=%1$s\n");
|
|
|
|
}
|
|
|
|
|
2015-05-18 12:30:37 +02:00
|
|
|
static int write_requires_mounts_for(FILE *f, const char *opts) {
|
2017-11-21 20:09:31 +01:00
|
|
|
_cleanup_strv_free_ char **paths = NULL, **paths_escaped = NULL;
|
2015-05-18 12:30:37 +02:00
|
|
|
_cleanup_free_ char *res = NULL;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
assert(f);
|
|
|
|
assert(opts);
|
|
|
|
|
|
|
|
r = fstab_extract_values(opts, "x-systemd.requires-mounts-for", &paths);
|
|
|
|
if (r < 0)
|
|
|
|
return log_warning_errno(r, "Failed to parse options: %m");
|
|
|
|
if (r == 0)
|
|
|
|
return 0;
|
|
|
|
|
2017-11-21 20:09:31 +01:00
|
|
|
r = specifier_escape_strv(paths, &paths_escaped);
|
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to escape paths: %m");
|
|
|
|
|
|
|
|
res = strv_join(paths_escaped, " ");
|
2015-05-18 12:30:37 +02:00
|
|
|
if (!res)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
fprintf(f, "RequiresMountsFor=%s\n", res);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-03-25 22:04:40 +01:00
|
|
|
static int add_mount(
|
2016-12-13 12:45:19 +01:00
|
|
|
const char *dest,
|
2013-03-25 22:04:40 +01:00
|
|
|
const char *what,
|
|
|
|
const char *where,
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
const char *original_where,
|
2014-03-06 21:14:26 +01:00
|
|
|
const char *fstype,
|
2013-03-25 22:04:40 +01:00
|
|
|
const char *opts,
|
|
|
|
int passno,
|
2017-11-29 15:49:25 +01:00
|
|
|
MountpointFlags flags,
|
2013-03-25 22:04:40 +01:00
|
|
|
const char *post,
|
|
|
|
const char *source) {
|
2014-03-05 22:26:10 +01:00
|
|
|
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_free_ char
|
2017-11-21 23:18:05 +01:00
|
|
|
*name = NULL,
|
2017-12-09 19:23:26 +01:00
|
|
|
*automount_name = NULL,
|
2017-11-21 20:09:31 +01:00
|
|
|
*filtered = NULL,
|
|
|
|
*where_escaped = NULL;
|
2020-01-18 22:14:58 +01:00
|
|
|
_cleanup_strv_free_ char **wanted_by = NULL, **required_by = NULL;
|
2013-04-18 09:11:22 +02:00
|
|
|
_cleanup_fclose_ FILE *f = 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
|
|
|
int r;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
|
|
|
assert(what);
|
|
|
|
assert(where);
|
2012-11-23 03:41:13 +01:00
|
|
|
assert(opts);
|
2015-11-25 21:21:44 +01:00
|
|
|
assert(post);
|
2012-11-23 03:41:13 +01:00
|
|
|
assert(source);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2014-03-06 21:14:26 +01:00
|
|
|
if (streq_ptr(fstype, "autofs"))
|
2012-05-22 19:23:33 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!is_path(where)) {
|
|
|
|
log_warning("Mount point %s is not a valid path, ignoring.", where);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mount_point_is_api(where) ||
|
|
|
|
mount_point_ignore(where))
|
|
|
|
return 0;
|
|
|
|
|
2020-01-18 22:14:58 +01:00
|
|
|
r = fstab_extract_values(opts, "x-systemd.wanted-by", &wanted_by);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
r = fstab_extract_values(opts, "x-systemd.required-by", &required_by);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2014-03-05 22:26:10 +01:00
|
|
|
if (path_equal(where, "/")) {
|
2017-11-29 15:49:25 +01:00
|
|
|
if (flags & NOAUTO)
|
2015-05-02 19:01:29 +02:00
|
|
|
log_warning("Ignoring \"noauto\" for root device");
|
2017-11-29 15:49:25 +01:00
|
|
|
if (flags & NOFAIL)
|
2015-05-02 19:01:29 +02:00
|
|
|
log_warning("Ignoring \"nofail\" for root device");
|
2017-11-29 15:49:25 +01:00
|
|
|
if (flags & AUTOMOUNT)
|
2015-05-02 19:01:29 +02:00
|
|
|
log_warning("Ignoring automount option for root device");
|
2020-01-18 22:14:58 +01:00
|
|
|
if (!strv_isempty(wanted_by))
|
|
|
|
log_warning("Ignoring \"x-systemd.wanted-by=\" for root device");
|
|
|
|
if (!strv_isempty(required_by))
|
|
|
|
log_warning("Ignoring \"x-systemd.required-by=\" for root device");
|
2015-05-02 19:01:29 +02:00
|
|
|
|
2020-01-18 22:14:58 +01:00
|
|
|
required_by = strv_free(required_by);
|
|
|
|
wanted_by = strv_free(wanted_by);
|
2017-11-29 15:49:25 +01:00
|
|
|
SET_FLAG(flags, NOAUTO | NOFAIL | AUTOMOUNT, false);
|
2014-03-05 22:26:10 +01:00
|
|
|
}
|
|
|
|
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(where, ".mount", &name);
|
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to generate unit name: %m");
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
r = generator_open_unit_file(dest, fstab_path(), name, &f);
|
2017-12-09 19:23:26 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2017-12-11 19:50:30 +01:00
|
|
|
|
2012-11-23 03:41:13 +01:00
|
|
|
fprintf(f,
|
2014-03-06 18:26:06 +01:00
|
|
|
"[Unit]\n"
|
2019-12-19 17:38:55 +01:00
|
|
|
"Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n"
|
|
|
|
"SourcePath=%s\n",
|
2014-03-06 18:26:06 +01:00
|
|
|
source);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2019-04-10 23:28:15 +02:00
|
|
|
/* All mounts under /sysroot need to happen later, at initrd-fs.target time. IOW, it's not
|
|
|
|
* technically part of the basic initrd filesystem itself, and so shouldn't inherit the default
|
|
|
|
* Before=local-fs.target dependency. */
|
|
|
|
if (in_initrd() && path_startswith(where, "/sysroot"))
|
|
|
|
fprintf(f, "DefaultDependencies=no\n");
|
|
|
|
|
2017-11-29 15:49:25 +01:00
|
|
|
if (STRPTR_IN_SET(fstype, "nfs", "nfs4") && !(flags & AUTOMOUNT) &&
|
fstab-generator: handle NFS "bg" mounts correctly. (#6103)
When "bg" is specified for NFS mounts, and if the server is
not accessible, two behaviors are possible depending on networking
details.
If a definitive error is received, such a EHOSTUNREACH or ECONNREFUSED,
mount.nfs will fork and continue in the background, while /bin/mount
will report success.
If no definitive error is reported but the connection times out
instead, then the mount.nfs timeout will normally be longer than the
systemd.mount timeout, so mount.nfs will be killed by systemd.
In the first case the mount has appeared to succeed even though
it hasn't. This can be confusing. Also the background mount.nfs
will never get cleaned up, even if the mount unit is stopped.
In the second case, mount.nfs is killed early and so the mount will
not complete when the server comes back.
Neither of these are ideal.
This patch modifies the options when an NFS bg mount is detected to
force an "fg" mount, but retain the default "retry" time of 10000
minutes that applies to "bg" mounts.
It also imposes "nofail" behaviour and sets the TimeoutSec for the
mount to "infinity" so the retry= time is allowed to complete.
This provides near-identical behaviour to an NFS bg mount started directly
by "mount -a". The only difference is that systemd will not wait for
the first mount attempt, while "mount -a" will.
Fixes #6046
2017-07-04 09:47:40 +02:00
|
|
|
fstab_test_yes_no_option(opts, "bg\0" "fg\0")) {
|
|
|
|
/* The default retry timeout that mount.nfs uses for 'bg' mounts
|
|
|
|
* is 10000 minutes, where as it uses 2 minutes for 'fg' mounts.
|
|
|
|
* As we are making 'bg' mounts look like an 'fg' mount to
|
|
|
|
* mount.nfs (so systemd can manage the job-control aspects of 'bg'),
|
|
|
|
* we need to explicitly preserve that default, and also ensure
|
|
|
|
* the systemd mount-timeout doesn't interfere.
|
|
|
|
* By placing these options first, they can be over-ridden by
|
|
|
|
* settings in /etc/fstab. */
|
|
|
|
opts = strjoina("x-systemd.mount-timeout=infinity,retry=10000,", opts, ",fg");
|
2017-11-29 15:49:25 +01:00
|
|
|
SET_FLAG(flags, NOFAIL, true);
|
fstab-generator: handle NFS "bg" mounts correctly. (#6103)
When "bg" is specified for NFS mounts, and if the server is
not accessible, two behaviors are possible depending on networking
details.
If a definitive error is received, such a EHOSTUNREACH or ECONNREFUSED,
mount.nfs will fork and continue in the background, while /bin/mount
will report success.
If no definitive error is reported but the connection times out
instead, then the mount.nfs timeout will normally be longer than the
systemd.mount timeout, so mount.nfs will be killed by systemd.
In the first case the mount has appeared to succeed even though
it hasn't. This can be confusing. Also the background mount.nfs
will never get cleaned up, even if the mount unit is stopped.
In the second case, mount.nfs is killed early and so the mount will
not complete when the server comes back.
Neither of these are ideal.
This patch modifies the options when an NFS bg mount is detected to
force an "fg" mount, but retain the default "retry" time of 10000
minutes that applies to "bg" mounts.
It also imposes "nofail" behaviour and sets the TimeoutSec for the
mount to "infinity" so the retry= time is allowed to complete.
This provides near-identical behaviour to an NFS bg mount started directly
by "mount -a". The only difference is that systemd will not wait for
the first mount attempt, while "mount -a" will.
Fixes #6046
2017-07-04 09:47:40 +02:00
|
|
|
}
|
|
|
|
|
2017-11-29 15:49:25 +01:00
|
|
|
if (!(flags & NOFAIL) && !(flags & AUTOMOUNT))
|
2014-03-07 02:39:59 +01:00
|
|
|
fprintf(f, "Before=%s\n", post);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-11-29 15:49:25 +01:00
|
|
|
if (!(flags & AUTOMOUNT) && opts) {
|
2017-02-13 20:50:22 +01:00
|
|
|
r = write_after(f, opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2015-05-18 12:30:37 +02:00
|
|
|
r = write_requires_after(f, opts);
|
2017-02-13 20:50:22 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
r = write_before(f, opts);
|
2015-05-18 12:30:37 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
r = write_requires_mounts_for(f, opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2014-03-05 22:26:10 +01:00
|
|
|
if (passno != 0) {
|
2016-12-13 12:45:19 +01:00
|
|
|
r = generator_write_fsck_deps(f, dest, what, where, fstype);
|
2014-03-05 22:26:10 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
2013-09-30 01:34:44 +02:00
|
|
|
|
2019-12-19 17:38:55 +01:00
|
|
|
r = generator_write_blockdev_dependency(f, what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
|
|
|
fprintf(f,
|
|
|
|
"\n"
|
|
|
|
"[Mount]\n");
|
|
|
|
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
if (original_where)
|
|
|
|
fprintf(f, "# Canonicalized from %s\n", original_where);
|
2017-11-21 20:09:31 +01:00
|
|
|
|
|
|
|
where_escaped = specifier_escape(where);
|
|
|
|
if (!where_escaped)
|
|
|
|
return log_oom();
|
|
|
|
fprintf(f, "Where=%s\n", where_escaped);
|
2014-03-06 21:14:26 +01:00
|
|
|
|
2017-02-08 17:14:58 +01:00
|
|
|
r = write_what(f, what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2017-11-21 20:09:31 +01:00
|
|
|
if (!isempty(fstype) && !streq(fstype, "auto")) {
|
|
|
|
_cleanup_free_ char *t;
|
|
|
|
|
|
|
|
t = specifier_escape(fstype);
|
|
|
|
if (!t)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
fprintf(f, "Type=%s\n", t);
|
|
|
|
}
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2016-12-13 12:45:19 +01:00
|
|
|
r = generator_write_timeouts(dest, what, where, opts, &filtered);
|
2014-06-27 18:12:07 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2017-01-24 17:04:32 +01:00
|
|
|
r = generator_write_device_deps(dest, what, where, opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2016-11-11 15:08:57 +01:00
|
|
|
r = write_mount_timeout(f, where, opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2017-02-07 13:08:56 +01:00
|
|
|
r = write_options(f, filtered);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2015-05-17 00:11:12 +02:00
|
|
|
r = fflush_and_check(f);
|
|
|
|
if (r < 0)
|
2017-12-09 19:23:26 +01:00
|
|
|
return log_error_errno(r, "Failed to write unit file %s: %m", name);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-11-21 23:18:05 +01:00
|
|
|
if (flags & MAKEFS) {
|
|
|
|
r = generator_hook_up_mkfs(dest, what, where, fstype);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2017-11-29 20:02:11 +01:00
|
|
|
if (flags & GROWFS) {
|
|
|
|
r = generator_hook_up_growfs(dest, where, post);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2020-01-18 22:14:58 +01:00
|
|
|
if (!FLAGS_SET(flags, AUTOMOUNT)) {
|
|
|
|
if (!FLAGS_SET(flags, NOAUTO) && strv_isempty(wanted_by) && strv_isempty(required_by)) {
|
|
|
|
r = generator_add_symlink(dest, post,
|
|
|
|
(flags & NOFAIL) ? "wants" : "requires", name);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
} else {
|
|
|
|
char **s;
|
|
|
|
|
|
|
|
STRV_FOREACH(s, wanted_by) {
|
|
|
|
r = generator_add_symlink(dest, *s, "wants", name);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
STRV_FOREACH(s, required_by) {
|
|
|
|
r = generator_add_symlink(dest, *s, "requires", name);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
2015-04-30 20:21:00 +02:00
|
|
|
r = unit_name_from_path(where, ".automount", &automount_name);
|
|
|
|
if (r < 0)
|
|
|
|
return log_error_errno(r, "Failed to generate unit name: %m");
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2019-05-02 20:10:08 +02:00
|
|
|
f = safe_fclose(f);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
r = generator_open_unit_file(dest, fstab_path(), automount_name, &f);
|
2017-12-09 19:23:26 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2017-12-11 19:50:30 +01:00
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
fprintf(f,
|
|
|
|
"[Unit]\n"
|
2014-03-06 18:26:06 +01:00
|
|
|
"SourcePath=%s\n"
|
|
|
|
"Documentation=man:fstab(5) man:systemd-fstab-generator(8)\n",
|
2013-03-04 19:01:05 +01:00
|
|
|
source);
|
|
|
|
|
2015-11-25 21:21:44 +01:00
|
|
|
fprintf(f, "Before=%s\n", post);
|
2013-03-04 19:01:05 +01:00
|
|
|
|
2015-05-18 12:30:37 +02:00
|
|
|
if (opts) {
|
2017-02-13 20:50:22 +01:00
|
|
|
r = write_after(f, opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2015-05-18 12:30:37 +02:00
|
|
|
r = write_requires_after(f, opts);
|
2017-02-13 20:50:22 +01:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
r = write_before(f, opts);
|
2015-05-18 12:30:37 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
r = write_requires_mounts_for(f, opts);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2013-03-04 19:01:05 +01:00
|
|
|
fprintf(f,
|
2016-05-02 16:02:02 +02:00
|
|
|
"\n"
|
2012-05-22 19:23:33 +02:00
|
|
|
"[Automount]\n"
|
|
|
|
"Where=%s\n",
|
2017-11-21 20:09:31 +01:00
|
|
|
where_escaped);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2015-05-02 19:01:28 +02:00
|
|
|
r = write_idle_timeout(f, where, opts);
|
2015-04-14 22:01:48 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
|
2015-05-17 00:11:12 +02:00
|
|
|
r = fflush_and_check(f);
|
|
|
|
if (r < 0)
|
2017-12-09 19:23:26 +01:00
|
|
|
return log_error_errno(r, "Failed to write unit file %s: %m", automount_name);
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-07-10 05:40:14 +02:00
|
|
|
r = generator_add_symlink(dest, post,
|
2017-11-29 15:49:25 +01:00
|
|
|
(flags & NOFAIL) ? "wants" : "requires", automount_name);
|
2017-07-10 05:40:14 +02:00
|
|
|
if (r < 0)
|
|
|
|
return r;
|
2012-05-22 19:23:33 +02:00
|
|
|
}
|
|
|
|
|
2013-01-02 23:15:55 +01:00
|
|
|
return 0;
|
2012-05-22 19:23:33 +02:00
|
|
|
}
|
|
|
|
|
2014-03-05 22:26:10 +01:00
|
|
|
static int parse_fstab(bool initrd) {
|
2014-03-06 21:14:26 +01:00
|
|
|
_cleanup_endmntent_ FILE *f = NULL;
|
2019-11-13 17:36:46 +01:00
|
|
|
const char *fstab;
|
2012-05-22 19:23:33 +02:00
|
|
|
struct mntent *me;
|
2014-03-05 22:26:10 +01:00
|
|
|
int r = 0;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
fstab = initrd ? "/sysroot/etc/fstab" : fstab_path();
|
|
|
|
log_debug("Parsing %s...", fstab);
|
2018-12-20 12:01:16 +01:00
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
f = setmntent(fstab, "re");
|
2012-05-22 19:23:33 +02:00
|
|
|
if (!f) {
|
|
|
|
if (errno == ENOENT)
|
|
|
|
return 0;
|
|
|
|
|
2019-11-13 17:36:46 +01:00
|
|
|
return log_error_errno(errno, "Failed to open %s: %m", fstab);
|
2012-05-22 19:23:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
while ((me = getmntent(f))) {
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
_cleanup_free_ char *where = NULL, *what = NULL, *canonical_where = NULL;
|
2017-11-29 20:02:11 +01:00
|
|
|
bool makefs, growfs, noauto, nofail;
|
2012-05-22 19:23:33 +02:00
|
|
|
int k;
|
|
|
|
|
2013-02-22 11:52:36 +01:00
|
|
|
if (initrd && !mount_in_initrd(me))
|
|
|
|
continue;
|
|
|
|
|
2012-05-22 19:23:33 +02:00
|
|
|
what = fstab_node_to_udev_node(me->mnt_fsname);
|
2014-03-05 22:26:10 +01:00
|
|
|
if (!what)
|
|
|
|
return log_oom();
|
|
|
|
|
2018-12-04 14:00:19 +01:00
|
|
|
if (is_device_path(what) && path_is_read_only_fs("/sys") > 0) {
|
2014-03-11 17:57:15 +01:00
|
|
|
log_info("Running in a container, ignoring fstab device entry for %s.", what);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2017-07-20 19:13:09 +02:00
|
|
|
where = strdup(me->mnt_dir);
|
2014-03-05 22:26:10 +01:00
|
|
|
if (!where)
|
2013-10-04 04:13:55 +02:00
|
|
|
return log_oom();
|
2012-05-22 19:23:33 +02:00
|
|
|
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
if (is_path(where)) {
|
2018-05-31 16:39:31 +02:00
|
|
|
path_simplify(where, false);
|
2018-02-27 07:58:19 +01:00
|
|
|
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
/* Follow symlinks here; see 5261ba901845c084de5a8fd06500ed09bfb0bd80 which makes sense for
|
|
|
|
* mount units, but causes problems since it historically worked to have symlinks in e.g.
|
|
|
|
* /etc/fstab. So we canonicalize here. Note that we use CHASE_NONEXISTENT to handle the case
|
|
|
|
* where a symlink refers to another mount target; this works assuming the sub-mountpoint
|
2018-02-27 07:58:19 +01:00
|
|
|
* target is the final directory. */
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
r = chase_symlinks(where, initrd ? "/sysroot" : NULL,
|
|
|
|
CHASE_PREFIX_ROOT | CHASE_NONEXISTENT,
|
2019-10-24 10:33:20 +02:00
|
|
|
&canonical_where, NULL);
|
2018-02-27 07:58:19 +01:00
|
|
|
if (r < 0) /* If we can't canonicalize we continue on as if it wasn't a symlink */
|
|
|
|
log_debug_errno(r, "Failed to read symlink target for %s, ignoring: %m", where);
|
|
|
|
else if (streq(canonical_where, where)) /* If it was fully canonicalized, suppress the change */
|
|
|
|
canonical_where = mfree(canonical_where);
|
|
|
|
else
|
|
|
|
log_debug("Canonicalized what=%s where=%s to %s", what, where, canonical_where);
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
}
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-11-21 23:18:05 +01:00
|
|
|
makefs = fstab_test_option(me->mnt_opts, "x-systemd.makefs\0");
|
2017-11-29 20:02:11 +01:00
|
|
|
growfs = fstab_test_option(me->mnt_opts, "x-systemd.growfs\0");
|
2015-01-11 06:04:00 +01:00
|
|
|
noauto = fstab_test_yes_no_option(me->mnt_opts, "noauto\0" "auto\0");
|
|
|
|
nofail = fstab_test_yes_no_option(me->mnt_opts, "nofail\0" "fail\0");
|
2018-02-27 07:58:19 +01:00
|
|
|
|
2019-02-18 03:31:10 +01:00
|
|
|
log_debug("Found entry what=%s where=%s type=%s makefs=%s growfs=%s noauto=%s nofail=%s",
|
2014-11-26 16:36:52 +01:00
|
|
|
what, where, me->mnt_type,
|
2019-02-18 03:31:10 +01:00
|
|
|
yes_no(makefs), yes_no(growfs),
|
2014-11-26 16:36:52 +01:00
|
|
|
yes_no(noauto), yes_no(nofail));
|
2012-05-22 19:23:33 +02:00
|
|
|
|
|
|
|
if (streq(me->mnt_type, "swap"))
|
2017-11-29 15:49:25 +01:00
|
|
|
k = add_swap(what, me,
|
2017-11-29 20:02:11 +01:00
|
|
|
makefs*MAKEFS | growfs*GROWFS | noauto*NOAUTO | nofail*NOFAIL);
|
2012-11-23 03:41:13 +01:00
|
|
|
else {
|
2014-11-26 16:36:52 +01:00
|
|
|
bool automount;
|
2013-08-19 03:20:52 +02:00
|
|
|
const char *post;
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2015-01-11 06:04:00 +01:00
|
|
|
automount = fstab_test_option(me->mnt_opts,
|
|
|
|
"comment=systemd.automount\0"
|
|
|
|
"x-systemd.automount\0");
|
2014-03-05 22:26:10 +01:00
|
|
|
if (initrd)
|
2013-03-04 19:01:05 +01:00
|
|
|
post = SPECIAL_INITRD_FS_TARGET;
|
2014-03-05 22:26:10 +01:00
|
|
|
else if (mount_is_network(me))
|
2013-03-28 21:18:58 +01:00
|
|
|
post = SPECIAL_REMOTE_FS_TARGET;
|
2014-03-05 22:26:10 +01:00
|
|
|
else
|
2013-03-28 21:18:58 +01:00
|
|
|
post = SPECIAL_LOCAL_FS_TARGET;
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2016-12-13 12:45:19 +01:00
|
|
|
k = add_mount(arg_dest,
|
|
|
|
what,
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
canonical_where ?: where,
|
|
|
|
canonical_where ? where: NULL,
|
2014-03-06 21:14:26 +01:00
|
|
|
me->mnt_type,
|
|
|
|
me->mnt_opts,
|
|
|
|
me->mnt_passno,
|
2017-11-29 20:02:11 +01:00
|
|
|
makefs*MAKEFS | growfs*GROWFS | noauto*NOAUTO | nofail*NOFAIL | automount*AUTOMOUNT,
|
2014-03-06 21:14:26 +01:00
|
|
|
post,
|
2019-11-13 17:36:46 +01:00
|
|
|
fstab);
|
2012-11-23 03:41:13 +01:00
|
|
|
}
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2017-11-29 20:02:11 +01:00
|
|
|
if (r >= 0 && k < 0)
|
2012-05-22 19:23:33 +02:00
|
|
|
r = k;
|
|
|
|
}
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2015-05-02 19:01:29 +02:00
|
|
|
static int add_sysroot_mount(void) {
|
2014-06-23 20:11:30 +02:00
|
|
|
_cleanup_free_ char *what = NULL;
|
|
|
|
const char *opts;
|
2016-05-12 18:42:39 +02:00
|
|
|
int r;
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2015-03-25 00:05:38 +01:00
|
|
|
if (isempty(arg_root_what)) {
|
|
|
|
log_debug("Could not find a root= entry on the kernel command line.");
|
|
|
|
return 0;
|
2013-03-04 21:00:56 +01:00
|
|
|
}
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2016-06-07 10:23:20 +02:00
|
|
|
if (streq(arg_root_what, "gpt-auto")) {
|
|
|
|
/* This is handled by the gpt-auto generator */
|
|
|
|
log_debug("Skipping root directory handling, as gpt-auto was requested.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-06-24 20:59:51 +02:00
|
|
|
if (path_equal(arg_root_what, "/dev/nfs")) {
|
2016-06-23 18:47:03 +02:00
|
|
|
/* This is handled by the kernel or the initrd */
|
|
|
|
log_debug("Skipping root directory handling, as /dev/nfs was requested.");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-03-25 00:05:38 +01:00
|
|
|
what = fstab_node_to_udev_node(arg_root_what);
|
|
|
|
if (!what)
|
2015-04-08 20:27:11 +02:00
|
|
|
return log_oom();
|
2015-03-25 00:05:38 +01:00
|
|
|
|
2014-03-06 21:14:26 +01:00
|
|
|
if (!arg_root_options)
|
2014-06-23 20:11:30 +02:00
|
|
|
opts = arg_root_rw > 0 ? "rw" : "ro";
|
|
|
|
else if (arg_root_rw >= 0 ||
|
2015-01-09 22:58:29 +01:00
|
|
|
!fstab_test_option(arg_root_options, "ro\0" "rw\0"))
|
2015-02-03 02:05:59 +01:00
|
|
|
opts = strjoina(arg_root_options, ",", arg_root_rw > 0 ? "rw" : "ro");
|
2014-06-23 20:11:30 +02:00
|
|
|
else
|
|
|
|
opts = arg_root_options;
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2014-03-06 21:14:26 +01:00
|
|
|
log_debug("Found entry what=%s where=/sysroot type=%s", what, strna(arg_root_fstype));
|
2016-05-12 18:42:39 +02:00
|
|
|
|
|
|
|
if (is_device_path(what)) {
|
|
|
|
r = generator_write_initrd_root_device_deps(arg_dest, what);
|
|
|
|
if (r < 0)
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2016-12-13 12:45:19 +01:00
|
|
|
return add_mount(arg_dest,
|
|
|
|
what,
|
2014-03-06 21:14:26 +01:00
|
|
|
"/sysroot",
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
NULL,
|
2014-03-06 21:14:26 +01:00
|
|
|
arg_root_fstype,
|
2014-06-23 20:11:30 +02:00
|
|
|
opts,
|
2016-06-24 21:07:18 +02:00
|
|
|
is_device_path(what) ? 1 : 0, /* passno */
|
2017-11-29 20:02:11 +01:00
|
|
|
0, /* makefs off, growfs off, noauto off, nofail off, automount off */
|
2014-03-06 21:14:26 +01:00
|
|
|
SPECIAL_INITRD_ROOT_FS_TARGET,
|
|
|
|
"/proc/cmdline");
|
2012-11-23 03:41:13 +01:00
|
|
|
}
|
|
|
|
|
2015-05-02 19:01:29 +02:00
|
|
|
static int add_sysroot_usr_mount(void) {
|
2014-10-09 21:37:17 +02:00
|
|
|
_cleanup_free_ char *what = NULL;
|
|
|
|
const char *opts;
|
|
|
|
|
|
|
|
if (!arg_usr_what && !arg_usr_fstype && !arg_usr_options)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (arg_root_what && !arg_usr_what) {
|
2016-06-24 21:00:11 +02:00
|
|
|
/* Copy over the root device, in case the /usr mount just differs in a mount option (consider btrfs subvolumes) */
|
2014-10-09 21:37:17 +02:00
|
|
|
arg_usr_what = strdup(arg_root_what);
|
|
|
|
if (!arg_usr_what)
|
|
|
|
return log_oom();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (arg_root_fstype && !arg_usr_fstype) {
|
|
|
|
arg_usr_fstype = strdup(arg_root_fstype);
|
|
|
|
if (!arg_usr_fstype)
|
|
|
|
return log_oom();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (arg_root_options && !arg_usr_options) {
|
|
|
|
arg_usr_options = strdup(arg_root_options);
|
|
|
|
if (!arg_usr_options)
|
|
|
|
return log_oom();
|
|
|
|
}
|
|
|
|
|
2014-12-08 20:05:31 +01:00
|
|
|
if (!arg_usr_what)
|
2014-10-09 21:37:17 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
what = fstab_node_to_udev_node(arg_usr_what);
|
2016-06-24 21:01:22 +02:00
|
|
|
if (!what)
|
|
|
|
return log_oom();
|
2014-10-09 21:37:17 +02:00
|
|
|
|
2014-12-08 20:05:31 +01:00
|
|
|
if (!arg_usr_options)
|
|
|
|
opts = arg_root_rw > 0 ? "rw" : "ro";
|
2015-01-09 22:58:29 +01:00
|
|
|
else if (!fstab_test_option(arg_usr_options, "ro\0" "rw\0"))
|
2015-02-03 02:05:59 +01:00
|
|
|
opts = strjoina(arg_usr_options, ",", arg_root_rw > 0 ? "rw" : "ro");
|
2014-12-08 20:05:31 +01:00
|
|
|
else
|
|
|
|
opts = arg_usr_options;
|
2014-10-09 21:37:17 +02:00
|
|
|
|
|
|
|
log_debug("Found entry what=%s where=/sysroot/usr type=%s", what, strna(arg_usr_fstype));
|
2016-12-13 12:45:19 +01:00
|
|
|
return add_mount(arg_dest,
|
|
|
|
what,
|
2014-10-09 21:37:17 +02:00
|
|
|
"/sysroot/usr",
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
NULL,
|
2014-10-09 21:37:17 +02:00
|
|
|
arg_usr_fstype,
|
|
|
|
opts,
|
2016-06-24 21:07:18 +02:00
|
|
|
is_device_path(what) ? 1 : 0, /* passno */
|
2017-11-29 15:49:25 +01:00
|
|
|
0,
|
2016-01-17 10:58:40 +01:00
|
|
|
SPECIAL_INITRD_FS_TARGET,
|
2014-10-09 21:37:17 +02:00
|
|
|
"/proc/cmdline");
|
|
|
|
}
|
|
|
|
|
2016-12-13 12:45:19 +01:00
|
|
|
static int add_volatile_root(void) {
|
2018-12-19 17:30:13 +01:00
|
|
|
|
2016-12-13 12:45:19 +01:00
|
|
|
/* Let's add in systemd-remount-volatile.service which will remount the root device to tmpfs if this is
|
2018-12-19 17:30:13 +01:00
|
|
|
* requested (or as an overlayfs), leaving only /usr from the root mount inside. */
|
2016-12-13 12:45:19 +01:00
|
|
|
|
2018-12-19 17:30:13 +01:00
|
|
|
if (!IN_SET(arg_volatile_mode, VOLATILE_YES, VOLATILE_OVERLAY))
|
2018-12-20 12:15:09 +01:00
|
|
|
return 0;
|
2016-12-13 12:45:19 +01:00
|
|
|
|
2018-12-20 12:15:09 +01:00
|
|
|
return generator_add_symlink(arg_dest, SPECIAL_INITRD_ROOT_FS_TARGET, "requires",
|
2018-12-20 16:14:47 +01:00
|
|
|
SYSTEM_DATA_UNIT_PATH "/" SPECIAL_VOLATILE_ROOT_SERVICE);
|
2016-12-13 12:45:19 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static int add_volatile_var(void) {
|
|
|
|
|
|
|
|
if (arg_volatile_mode != VOLATILE_STATE)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* If requested, mount /var as tmpfs, but do so only if there's nothing else defined for this. */
|
|
|
|
|
|
|
|
return add_mount(arg_dest_late,
|
|
|
|
"tmpfs",
|
|
|
|
"/var",
|
fstab-generator: Chase symlinks where possible (#6293)
This has a long history; see see 5261ba901845c084de5a8fd06500ed09bfb0bd80
which originally introduced the behavior. Unfortunately that commit
doesn't include any rationale, but IIRC the basic issue is that
systemd wants to model the real mount state as units, and symlinks
make canonicalization much more difficult.
At the same time, on a RHEL6 system (upstart), one can make e.g. `/home` a
symlink, and things work as well as they always did; but one doesn't have
access to the sophistication of mount units (dependencies, introspection, etc.)
Supporting symlinks here will hence make it easier for people to do upgrades to
RHEL7 and beyond.
The `/home` as symlink case also appears prominently for OSTree; see
https://ostree.readthedocs.io/en/latest/manual/adapting-existing/
Further work has landed in the nspawn case for this; see e.g.
d944dc9553009822deaddec76814f5642a6a8176
A basic limitation with doing this in the fstab generator (and that I hit while
doing some testing) is that we obviously can't chase symlinks into mounts,
since the generator runs early before mounts. Or at least - doing so would
require multiple passes over the fstab data (as well as looking at existing
mount units), and potentially doing multi-phase generation. I'm not sure it's
worth doing that without a real world use case. For now, this will fix at least
the OSTree + `/home` <https://bugzilla.redhat.com/show_bug.cgi?id=1382873> case
mentioned above, and in general anyone who for whatever reason has symlinks in
their `/etc/fstab`.
2017-07-11 18:48:57 +02:00
|
|
|
NULL,
|
2016-12-13 12:45:19 +01:00
|
|
|
"tmpfs",
|
|
|
|
"mode=0755",
|
|
|
|
0,
|
2017-11-29 15:49:25 +01:00
|
|
|
0,
|
2016-12-13 12:45:19 +01:00
|
|
|
SPECIAL_LOCAL_FS_TARGET,
|
|
|
|
"/proc/cmdline");
|
|
|
|
}
|
|
|
|
|
2016-10-22 20:24:52 +02:00
|
|
|
static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
|
2013-11-06 03:15:16 +01:00
|
|
|
int r;
|
2012-06-22 10:27:05 +02:00
|
|
|
|
2014-10-09 21:37:17 +02:00
|
|
|
/* root=, usr=, usrfstype= and roofstype= may occur more than once, the last
|
|
|
|
* instance should take precedence. In the case of multiple rootflags=
|
|
|
|
* or usrflags= the arguments should be concatenated */
|
2014-03-06 21:14:26 +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 (STR_IN_SET(key, "fstab", "rd.fstab")) {
|
2014-03-05 22:26:10 +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
|
|
|
r = value ? parse_boolean(value) : 1;
|
2014-02-16 00:08:59 +01:00
|
|
|
if (r < 0)
|
2014-03-06 17:05:55 +01:00
|
|
|
log_warning("Failed to parse fstab switch %s. Ignoring.", value);
|
2014-02-16 00:08:59 +01:00
|
|
|
else
|
2014-03-05 22:26:10 +01:00
|
|
|
arg_fstab_enabled = r;
|
2012-06-22 10:27:05 +02: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
|
|
|
} else if (streq(key, "root")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
2014-03-06 21:14:26 +01:00
|
|
|
|
2014-10-04 02:41:43 +02:00
|
|
|
if (free_and_strdup(&arg_root_what, value) < 0)
|
2014-03-06 21:14:26 +01:00
|
|
|
return log_oom();
|
|
|
|
|
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, "rootfstype")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
2014-03-06 21:14:26 +01:00
|
|
|
|
2014-10-04 02:41:43 +02:00
|
|
|
if (free_and_strdup(&arg_root_fstype, value) < 0)
|
2014-03-06 21:14:26 +01:00
|
|
|
return log_oom();
|
|
|
|
|
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, "rootflags")) {
|
2014-03-06 21:14:26 +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 (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
|
|
|
|
2017-11-28 20:11:52 +01:00
|
|
|
if (!strextend_with_separator(&arg_root_options, ",", value, NULL))
|
2014-03-06 21:14:26 +01:00
|
|
|
return log_oom();
|
|
|
|
|
2016-12-16 12:57:44 +01:00
|
|
|
} else if (streq(key, "roothash")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (free_and_strdup(&arg_root_hash, value) < 0)
|
|
|
|
return log_oom();
|
2014-03-06 21:14:26 +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
|
|
|
} else if (streq(key, "mount.usr")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
2014-10-09 21:37:17 +02:00
|
|
|
|
|
|
|
if (free_and_strdup(&arg_usr_what, value) < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
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, "mount.usrfstype")) {
|
|
|
|
|
|
|
|
if (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
2014-10-09 21:37:17 +02:00
|
|
|
|
|
|
|
if (free_and_strdup(&arg_usr_fstype, value) < 0)
|
|
|
|
return log_oom();
|
|
|
|
|
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, "mount.usrflags")) {
|
2014-10-09 21:37:17 +02: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 (proc_cmdline_value_missing(key, value))
|
|
|
|
return 0;
|
|
|
|
|
2017-11-28 20:11:52 +01:00
|
|
|
if (!strextend_with_separator(&arg_usr_options, ",", value, NULL))
|
2014-10-09 21:37:17 +02:00
|
|
|
return log_oom();
|
|
|
|
|
2014-03-06 21:14:26 +01:00
|
|
|
} else if (streq(key, "rw") && !value)
|
|
|
|
arg_root_rw = true;
|
|
|
|
else if (streq(key, "ro") && !value)
|
|
|
|
arg_root_rw = false;
|
2016-12-13 12:45:19 +01:00
|
|
|
else if (streq(key, "systemd.volatile")) {
|
|
|
|
VolatileMode m;
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
m = volatile_mode_from_string(value);
|
|
|
|
if (m < 0)
|
|
|
|
log_warning("Failed to parse systemd.volatile= argument: %s", value);
|
|
|
|
else
|
|
|
|
arg_volatile_mode = m;
|
|
|
|
} else
|
|
|
|
arg_volatile_mode = VOLATILE_YES;
|
|
|
|
}
|
2012-06-22 10:27:05 +02:00
|
|
|
|
2013-01-02 23:15:55 +01:00
|
|
|
return 0;
|
2012-06-22 10:27:05 +02:00
|
|
|
}
|
|
|
|
|
2016-12-16 12:57:44 +01:00
|
|
|
static int determine_root(void) {
|
|
|
|
/* If we have a root hash but no root device then Verity is used, and we use the "root" DM device as root. */
|
|
|
|
|
|
|
|
if (arg_root_what)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!arg_root_hash)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
arg_root_what = strdup("/dev/mapper/root");
|
|
|
|
if (!arg_root_what)
|
|
|
|
return log_oom();
|
|
|
|
|
|
|
|
log_info("Using verity root device %s.", arg_root_what);
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-12-04 11:49:42 +01:00
|
|
|
static int run(const char *dest, const char *dest_early, const char *dest_late) {
|
2018-12-20 12:18:29 +01:00
|
|
|
int r, r2 = 0, r3 = 0;
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2018-12-04 11:49:42 +01:00
|
|
|
assert_se(arg_dest = dest);
|
|
|
|
assert_se(arg_dest_late = dest_late);
|
2012-05-22 19:23:33 +02: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
|
|
|
r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, 0);
|
2014-11-06 21:53:34 +01:00
|
|
|
if (r < 0)
|
2014-11-28 13:19:16 +01:00
|
|
|
log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
|
2012-06-22 10:27:05 +02:00
|
|
|
|
2016-12-16 12:57:44 +01:00
|
|
|
(void) determine_root();
|
|
|
|
|
2014-10-09 21:37:17 +02:00
|
|
|
/* Always honour root= and usr= in the kernel command line if we are in an initrd */
|
|
|
|
if (in_initrd()) {
|
2015-05-02 19:01:29 +02:00
|
|
|
r = add_sysroot_mount();
|
2016-06-24 21:04:48 +02:00
|
|
|
|
2018-12-20 12:18:29 +01:00
|
|
|
r2 = add_sysroot_usr_mount();
|
2016-12-13 12:45:19 +01:00
|
|
|
|
2018-12-20 12:18:29 +01:00
|
|
|
r3 = add_volatile_root();
|
2016-06-24 21:04:48 +02:00
|
|
|
} else
|
2016-12-13 12:45:19 +01:00
|
|
|
r = add_volatile_var();
|
2012-11-23 03:41:13 +01:00
|
|
|
|
2014-03-05 22:26:10 +01:00
|
|
|
/* Honour /etc/fstab only when that's enabled */
|
|
|
|
if (arg_fstab_enabled) {
|
|
|
|
/* Parse the local /etc/fstab, possibly from the initrd */
|
2018-12-20 12:18:29 +01:00
|
|
|
r2 = parse_fstab(false);
|
2013-03-05 06:45:06 +01:00
|
|
|
|
2014-03-05 22:26:10 +01:00
|
|
|
/* If running in the initrd also parse the /etc/fstab from the host */
|
2018-12-20 12:18:29 +01:00
|
|
|
if (in_initrd())
|
|
|
|
r3 = parse_fstab(true);
|
2018-12-20 15:52:52 +01:00
|
|
|
else
|
|
|
|
r3 = generator_enable_remount_fs_service(arg_dest);
|
2014-03-05 22:26:10 +01:00
|
|
|
}
|
2012-05-22 19:23:33 +02:00
|
|
|
|
2018-12-20 12:18:29 +01:00
|
|
|
return r < 0 ? r : r2 < 0 ? r2 : r3;
|
2012-05-22 19:23:33 +02:00
|
|
|
}
|
2018-11-20 09:56:47 +01:00
|
|
|
|
2018-12-04 11:49:42 +01:00
|
|
|
DEFINE_MAIN_GENERATOR_FUNCTION(run);
|