HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/fstab-generator/fstab-generator.c
Git blob: e4c85fb19fd3380efc9db9bd04efa46db021446c
Lines 1001–1768 of 1,768
bool is_sysroot_usr = in_initrd() && path_equal(where, "/sysroot/usr");
const char *target_unit =
is_sysroot ? SPECIAL_INITRD_ROOT_FS_TARGET :
is_sysroot_usr ? SPECIAL_INITRD_USR_FS_TARGET :
prefix_sysroot ? SPECIAL_INITRD_FS_TARGET :
mount_is_network(fstype, options) ? SPECIAL_REMOTE_FS_TARGET :
SPECIAL_LOCAL_FS_TARGET;
/* nofail, noauto and x-systemd.automount don't make sense for critical filesystems we must mount in initrd. */
if (is_sysroot || is_sysroot_usr) {
r = mandatory_mount_drop_unapplicable_options(&flags, where, options, &opts);
if (r < 0)
return r;
options = opts;
}
r = add_mount(source,
arg_dest,
what,
is_sysroot_usr ? "/sysusr/usr" : where,
!is_sysroot_usr && where_changed ? where_original : NULL,
fstype,
options,
passno,
flags & ~(is_sysroot_usr ? MOUNT_VALIDATEFS : 0),
target_unit,
/* extra_after= */ NULL);
if (r <= 0)
return r;
if (is_sysroot_usr) {
r = add_sysusr_sysroot_usr_bind_mount(source, flags & MOUNT_VALIDATEFS);
if (r < 0)
return r;
}
return true;
}
static int parse_fstab(bool prefix_sysroot) {
_cleanup_(mnt_free_tablep) struct libmnt_table *table = NULL;
_cleanup_(mnt_free_iterp) struct libmnt_iter *iter = NULL;
const char *fstab;
int r, ret = 0;
if (prefix_sysroot)
fstab = sysroot_fstab_path();
else {
fstab = fstab_path();
assert(!arg_sysroot_check);
}
log_debug("Parsing %s...", fstab);
r = libmount_parse_full(fstab, /* source= */ NULL, MNT_ITER_FORWARD, &table, &iter);
if (r == -ENOENT)
return 0;
if (r < 0)
return log_error_errno(r, "Failed to parse '%s': %m", fstab);
for (;;) {
struct libmnt_fs *fs;
r = sym_mnt_table_next_fs(table, iter, &fs);
if (r < 0)
return log_error_errno(r, "Failed to get next entry from '%s': %m", fstab);
if (r > 0) /* EOF */
return ret;
r = parse_fstab_one(
fstab,
sym_mnt_fs_get_source(fs),
sym_mnt_fs_get_target(fs),
sym_mnt_fs_get_fstype(fs),
sym_mnt_fs_get_options(fs),
sym_mnt_fs_get_passno(fs),
prefix_sysroot,
/* accept_root= */ false,
/* use_swap_enabled= */ true);
if (arg_sysroot_check && r > 0)
return true; /* We found a mount or swap that would be started… */
RET_GATHER(ret, r);
}
}
static int mount_source_is_nfsroot(const char *what) {
union in_addr_union u;
const char *sep, *a;
int r;
assert(what);
/* From dracut.cmdline(7).
*
* root=[<server-ip>:]<root-dir>[:<nfs-options>]
* root=nfs:[<server-ip>:]<root-dir>[:<nfs-options>],
* root=nfs4:[<server-ip>:]<root-dir>[:<nfs-options>],
* root={dhcp|dhcp6}
*
* mount nfs share from <server-ip>:/<root-dir>, if no server-ip is given, use dhcp next_server.
* If server-ip is an IPv6 address it has to be put in brackets, e.g. [2001:DB8::1]. NFS options
* can be appended with the prefix ":" or "," and are separated by ",". */
if (path_equal(what, "/dev/nfs") ||
STR_IN_SET(what, "dhcp", "dhcp6") ||
STARTSWITH_SET(what, "nfs:", "nfs4:"))
return true;
/* IPv6 address */
if (what[0] == '[') {
sep = strchr(what + 1, ']');
if (!sep)
return -EINVAL;
a = strndupa_safe(what + 1, sep - what - 1);
r = in_addr_from_string(AF_INET6, a, &u);
if (r < 0)
return r;
return true;
}
/* IPv4 address */
sep = strchr(what, ':');
if (sep) {
a = strndupa_safe(what, sep - what);
if (in_addr_from_string(AF_INET, a, &u) >= 0)
return true;
}
/* root directory without address */
return path_is_absolute(what) && !path_startswith(what, "/dev");
}
static bool validate_root_or_usr_mount_source(const char *what, const char *switch_name) {
int r;
assert(switch_name);
if (isempty(what)) {
log_debug("No %s switch specified on the kernel command line.", switch_name);
return false;
}
if (streq(what, "off")) {
log_debug("Skipping %s directory handling, as this was explicitly turned off.", switch_name);
return false;
}
if (parse_gpt_auto_root(switch_name, what) > 0) {
/* This is handled by gpt-auto-generator */
log_debug("Skipping %s directory handling, as gpt-auto was requested.", switch_name);
return false;
}
if (streq(what, "fstab")) {
/* This is handled by parse_fstab() */
log_debug("Using initrd's fstab for %s configuration.", switch_name);
return false;
}
r = mount_source_is_nfsroot(what);
if (r < 0)
log_debug_errno(r, "Failed to determine if the %s directory is on NFS, assuming not: %m", switch_name);
else if (r > 0) {
/* This is handled by the kernel or the initrd */
log_debug("Skipping %s directory handling, as root on NFS was requested.", switch_name);
return false;
}
if (startswith(what, "cifs://")) {
log_debug("Skipping %s directory handling, as root on CIFS was requested.", switch_name);
return false;
}
if (startswith(what, "iscsi:")) {
log_debug("Skipping %s directory handling, as root on iSCSI was requested.", switch_name);
return false;
}
if (startswith(what, "live:")) {
log_debug("Skipping %s directory handling, as root on live image was requested.", switch_name);
return false;
}
return true;
}
static int add_sysroot_mount(void) {
_cleanup_free_ char *what = NULL;
const char *extra_opts = NULL, *fstype = NULL;
bool default_rw = true;
MountPointFlags flags;
if (!validate_root_or_usr_mount_source(arg_root_what, "root="))
return 0;
const char *bind = startswith(arg_root_what, "bind:");
if (bind) {
if (!path_is_valid(bind) || !path_is_absolute(bind)) {
log_debug("Invalid root=bind: source path, ignoring: %s", bind);
return 0;
}
what = strdup(bind);
if (!what)
return log_oom();
extra_opts = "bind";
} else if (streq(arg_root_what, "tmpfs")) {
/* If root=tmpfs is specified, then take this as shortcut for a writable tmpfs mount as root */
what = strdup("rootfs"); /* just a pretty name, to show up in /proc/self/mountinfo */
if (!what)
return log_oom();
fstype = arg_root_fstype ?: "tmpfs"; /* tmpfs, unless overridden */
if (streq(fstype, "tmpfs") && !fstab_test_option(arg_root_options, "mode\0"))
extra_opts = "mode=0755"; /* root directory should not be world/group writable, unless overridden */
} else {
what = fstab_node_to_udev_node(arg_root_what);
if (!what)
return log_oom();
fstype = arg_root_fstype; /* if not specified explicitly, don't default to anything here */
default_rw = false; /* read-only, unless overridden */
}
_cleanup_free_ char *combined_options = NULL;
if (strdup_to(&combined_options, arg_root_options) < 0)
return log_oom();
if (arg_root_rw >= 0 || !fstab_test_option(combined_options, "ro\0" "rw\0"))
if (!strextend_with_separator(&combined_options, ",", arg_root_rw > 0 || (arg_root_rw < 0 && default_rw) ? "rw" : "ro"))
return log_oom();
if (extra_opts)
if (!strextend_with_separator(&combined_options, ",", extra_opts))
return log_oom();
/* A bind mount inherits the mount flags (nosuid, nodev, noexec, …) of the file system the source
* directory is located on. The source typically lives below /run/ (e.g. a freshly unpacked tar image
* in /run/machines/), which is mounted nosuid,nodev, and these flags would then propagate to our root
* file system, breaking suid binaries (e.g. sudo) and device nodes. Since this is supposed to become a
* regular OS root file system, default to dev,suid,exec instead, unless the user explicitly requested
* otherwise. */
if (bind) {
static const char* const defaults[] = {
"suid", "suid\0" "nosuid\0",
"dev", "dev\0" "nodev\0",
"exec", "exec\0" "noexec\0",
NULL,
};
STRV_FOREACH_PAIR(add, test, defaults)
if (!fstab_test_option(combined_options, *test))
if (!strextend_with_separator(&combined_options, ",", *add))
return log_oom();
}
log_debug("Found entry what=%s where=/sysroot type=%s opts=%s", what, strna(fstype), strempty(combined_options));
/* Only honor x-systemd.makefs and .validatefs here, others are not relevant in initrd/not used
* at all (also see mandatory_mount_drop_unapplicable_options()) */
flags = fstab_options_to_flags(combined_options, /* is_swap= */ false) & (MOUNT_MAKEFS|MOUNT_VALIDATEFS);
return add_mount("/proc/cmdline",
arg_dest,
what,
"/sysroot",
/* original_where= */ NULL,
fstype,
combined_options,
/* passno= */ is_device_path(what) ? 1 : 0,
flags,
SPECIAL_INITRD_ROOT_FS_TARGET,
"imports.target");
}
static int add_sysroot_usr_mount(void) {
_cleanup_free_ char *what = NULL;
const char *extra_opts = NULL;
bool makefs, validatefs;
int r;
/* Returns 0 if we didn't do anything, > 0 if we either generated a unit for the /usr/ mount, or we
* know for sure something else did */
if (!arg_usr_what && !arg_usr_fstype && !arg_usr_options)
return 0;
if (arg_root_what && !arg_usr_what) {
/* Copy over the root device, in case the /usr mount just differs in a mount option (consider btrfs subvolumes) */
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();
}
if (!validate_root_or_usr_mount_source(arg_usr_what, "mount.usr="))
return 0;
const char *bind = startswith(arg_usr_what, "bind:");
if (bind) {
if (!path_is_valid(bind) || !path_is_absolute(bind)) {
log_debug("Invalid mount.usr=bind: source path, ignoring: %s", bind);
return 0;
}
what = strdup(bind);
if (!what)
return log_oom();
extra_opts = "bind";
} else {
what = fstab_node_to_udev_node(arg_usr_what);
if (!what)
return log_oom();
}
_cleanup_free_ char *combined_options = NULL;
if (strdup_to(&combined_options, arg_usr_options) < 0)
return log_oom();
if (!fstab_test_option(combined_options, "ro\0" "rw\0"))
if (!strextend_with_separator(&combined_options, ",", arg_root_rw > 0 ? "rw" : "ro"))
return log_oom();
if (extra_opts)
if (!strextend_with_separator(&combined_options, ",", extra_opts))
return log_oom();
/* When mounting /usr from the initrd, we add an extra level of indirection: we first mount the /usr/
* partition to /sysusr/usr/, and then afterwards bind mount that to /sysroot/usr/. We do this so
* that we can cover for systems that initially only have a /usr/ around and where the root fs needs
* to be synthesized, based on configuration included in /usr/, e.g. systemd-repart. Software like
* this should order itself after initrd-usr-fs.target and before initrd-fs.target; and it should
* look into both /sysusr/ and /sysroot/ for the configuration data to apply. */
log_debug("Found entry what=%s where=/sysusr/usr type=%s opts=%s", what, strna(arg_usr_fstype), strempty(combined_options));
/* Only honor x-systemd.makefs and .validatefs here, others are not relevant in initrd/not used
* at all (also see mandatory_mount_drop_unapplicable_options()) */
makefs = fstab_test_option(combined_options, "x-systemd.makefs\0");
validatefs = fstab_test_option(combined_options, "x-systemd.validatefs\0");
r = add_mount("/proc/cmdline",
arg_dest,
what,
"/sysusr/usr",
/* original_where= */ NULL,
arg_usr_fstype,
combined_options,
/* passno= */ is_device_path(what) ? 1 : 0,
makefs ? MOUNT_MAKEFS : 0,
SPECIAL_INITRD_USR_FS_TARGET,
"imports.target");
if (r < 0)
return r;
r = add_sysusr_sysroot_usr_bind_mount("/proc/cmdline", validatefs);
if (r < 0)
return r;
return 1;
}
static int add_sysroot_usr_mount_or_fallback(void) {
int r;
r = add_sysroot_usr_mount();
if (r != 0)
return r;
/* OK, so we didn't write anything out for /sysusr/usr/ nor /sysroot/usr/. In this case, let's make
* sure that initrd-usr-fs.target is at least ordered after sysroot.mount so that services that order
* themselves after it get the guarantee that /usr/ is definitely mounted somewhere. */
return generator_add_symlink(
arg_dest,
SPECIAL_INITRD_USR_FS_TARGET,
"requires",
"sysroot.mount");
}
static int add_volatile_root(void) {
/* Let's add in systemd-remount-volatile.service which will remount the root device to tmpfs if this is
* requested (or as an overlayfs), leaving only /usr from the root mount inside. */
if (!IN_SET(arg_volatile_mode, VOLATILE_YES, VOLATILE_OVERLAY))
return 0;
return generator_add_symlink(arg_dest, SPECIAL_INITRD_ROOT_FS_TARGET, "requires",
SYSTEM_DATA_UNIT_DIR "/" SPECIAL_VOLATILE_ROOT_SERVICE);
}
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("/proc/cmdline",
arg_dest_late,
"tmpfs",
"/var",
/* original_where= */ NULL,
"tmpfs",
"mode=0755" TMPFS_LIMITS_VAR,
/* passno= */ 0,
/* flags= */ 0,
SPECIAL_LOCAL_FS_TARGET,
/* extra_after= */ NULL);
}
static int add_mounts_from_cmdline(void) {
int r = 0;
/* Handle each entries found in cmdline as a fstab entry. */
FOREACH_ARRAY(m, arg_mounts, arg_n_mounts) {
if (m->for_initrd && !in_initrd())
continue;
RET_GATHER(r, parse_fstab_one("/proc/cmdline",
m->what,
m->where,
m->fstype,
m->options,
/* passno= */ -1,
/* prefix_sysroot= */ !m->for_initrd && in_initrd(),
/* accept_root= */ true,
/* use_swap_enabled= */ false));
}
return r;
}
static int add_mounts_from_creds(bool prefix_sysroot) {
_cleanup_free_ void *b = NULL;
size_t bs;
const char *cred;
int r, ret = 0;
assert(in_initrd() || !prefix_sysroot);
cred = in_initrd() && !prefix_sysroot ? "fstab.extra.initrd" : "fstab.extra";
r = read_credential_with_decryption(cred, &b, &bs);
if (r <= 0)
return r;
_cleanup_fclose_ FILE *f = NULL;
f = fmemopen_unlocked(b, bs, "r");
if (!f)
return log_oom();
_cleanup_(mnt_free_tablep) struct libmnt_table *table = NULL;
_cleanup_(mnt_free_iterp) struct libmnt_iter *iter = NULL;
r = libmount_parse_full(cred, f, MNT_ITER_FORWARD, &table, &iter);
if (r < 0)
return log_error_errno(r, "Failed to parse credential '%s' (as fstab): %m", cred);
for (;;) {
struct libmnt_fs *fs;
r = sym_mnt_table_next_fs(table, iter, &fs);
if (r < 0)
return log_error_errno(r, "Failed to get next fstab entry from credential '%s': %m", cred);
if (r > 0) /* EOF */
return ret;
RET_GATHER(ret, parse_fstab_one(
"/run/credentials",
sym_mnt_fs_get_source(fs),
sym_mnt_fs_get_target(fs),
sym_mnt_fs_get_fstype(fs),
sym_mnt_fs_get_options(fs),
sym_mnt_fs_get_passno(fs),
prefix_sysroot,
/* accept_root= */ true,
/* use_swap_enabled= */ true));
}
}
static int parse_proc_cmdline_item(const char *key, const char *value, void *data) {
int r;
assert(key);
/* 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 */
if (STR_IN_SET(key, "fstab", "rd.fstab")) {
r = value ? parse_boolean(value) : 1;
if (r < 0)
log_warning("Failed to parse fstab switch %s. Ignoring.", value);
else
arg_fstab_enabled = fstab_set_enabled(r);
} else if (streq(key, "root")) {
if (proc_cmdline_value_missing(key, value))
return 0;
return free_and_strdup_warn(&arg_root_what, empty_to_null(value));
} else if (streq(key, "rootfstype")) {
if (proc_cmdline_value_missing(key, value))
return 0;
return free_and_strdup_warn(&arg_root_fstype, empty_to_null(value));
} else if (streq(key, "rootflags")) {
if (proc_cmdline_value_missing(key, value))
return 0;
if (!strextend_with_separator(&arg_root_options, ",", value))
return log_oom();
} else if (streq(key, "roothash")) {
if (proc_cmdline_value_missing(key, value))
return 0;
return free_and_strdup_warn(&arg_root_hash, empty_to_null(value));
} else if (streq(key, "mount.usr")) {
if (proc_cmdline_value_missing(key, value))
return 0;
return free_and_strdup_warn(&arg_usr_what, empty_to_null(value));
} else if (streq(key, "mount.usrfstype")) {
if (proc_cmdline_value_missing(key, value))
return 0;
return free_and_strdup_warn(&arg_usr_fstype, empty_to_null(value));
} else if (streq(key, "mount.usrflags")) {
if (proc_cmdline_value_missing(key, value))
return 0;
if (!strextend_with_separator(&arg_usr_options, ",", value))
return log_oom();
} else if (streq(key, "usrhash")) {
if (proc_cmdline_value_missing(key, value))
return 0;
return free_and_strdup_warn(&arg_usr_hash, empty_to_null(value));
} else if (streq(key, "rw") && !value)
arg_root_rw = true;
else if (streq(key, "ro") && !value)
arg_root_rw = false;
else if (streq(key, "systemd.volatile")) {
VolatileMode m;
if (value) {
m = volatile_mode_from_string(value);
if (m < 0)
log_warning_errno(m, "Failed to parse systemd.volatile= argument: %s", value);
else
arg_volatile_mode = m;
} else
arg_volatile_mode = VOLATILE_YES;
} else if (streq(key, "systemd.swap")) {
r = value ? parse_boolean(value) : 1;
if (r < 0)
log_warning("Failed to parse systemd.swap switch %s. Ignoring.", value);
else
arg_swap_enabled = r;
} else if (streq(key, "systemd.verity")) {
r = value ? parse_boolean(value) : 1;
if (r < 0)
log_warning("Failed to parse systemd.verity= kernel command line switch %s. Ignoring.", value);
else
arg_verity = r;
} else if (STR_IN_SET(key, "systemd.mount-extra", "rd.systemd.mount-extra")) {
if (proc_cmdline_value_missing(key, value))
return 0;
r = mount_array_add(startswith(key, "rd."), value);
if (r < 0)
log_warning("Failed to parse systemd.mount-extra= option, ignoring: %s", value);
} else if (STR_IN_SET(key, "systemd.swap-extra", "rd.systemd.swap-extra")) {
if (proc_cmdline_value_missing(key, value))
return 0;
r = mount_array_add_swap(startswith(key, "rd."), value);
if (r < 0)
log_warning("Failed to parse systemd.swap-extra= option, ignoring: %s", value);
}
return 0;
}
static int determine_device(
char **what,
int *rw,
char **options,
const char *hash,
const char *name) {
assert(what);
assert(name);
/* If we have a hash but no device then Verity is used, and we use the DM device. */
if (*what)
return 0;
if (!hash)
return 0;
if (!arg_verity)
return 0;
*what = path_join("/dev/mapper/", name);
if (!*what)
return log_oom();
/* Verity is always read-only */
if (rw)
*rw = false;
if (options && !strextend_with_separator(options, ",", "ro"))
return log_oom();
log_info("Using verity %s device %s.", name, *what);
return 1;
}
static int determine_root(void) {
return determine_device(&arg_root_what, &arg_root_rw, NULL, arg_root_hash, "root");
}
static int determine_usr(void) {
return determine_device(&arg_usr_what, NULL, &arg_usr_options, arg_usr_hash, "usr");
}
/* If arg_sysroot_check is false, run as generator in the usual fashion.
* If it is true, check /sysroot/etc/fstab for any units that we'd want to mount
* in the initrd, and call daemon-reload. We will get reinvoked as a generator,
* with /sysroot/etc/fstab available, and then we can write additional units based
* on that file. */
static int run_generator(void) {
int r;
r = proc_cmdline_parse(parse_proc_cmdline_item, NULL, 0);
if (r < 0)
log_warning_errno(r, "Failed to parse kernel command line, ignoring: %m");
(void) determine_root();
(void) determine_usr();
if (arg_sysroot_check) {
r = parse_fstab(/* prefix_sysroot= */ true);
if (r == 0)
log_debug("Nothing interesting found, not doing daemon-reload.");
if (r > 0)
r = do_daemon_reload();
return r;
}
r = 0;
/* Always honour root= and usr= in the kernel command line if we are in an initrd */
if (in_initrd()) {
RET_GATHER(r, add_sysroot_mount());
RET_GATHER(r, add_sysroot_usr_mount_or_fallback());
RET_GATHER(r, add_volatile_root());
} else
RET_GATHER(r, add_volatile_var());
/* Honour /etc/fstab only when that's enabled */
if (arg_fstab_enabled) {
/* Parse the local /etc/fstab, possibly from the initrd */
RET_GATHER(r, parse_fstab(/* prefix_sysroot= */ false));
/* If running in the initrd also parse the /etc/fstab from the host */
if (in_initrd())
RET_GATHER(r, parse_fstab(/* prefix_sysroot= */ true));
else
RET_GATHER(r, generator_enable_remount_fs_service(arg_dest));
}
RET_GATHER(r, add_mounts_from_cmdline());
RET_GATHER(r, add_mounts_from_creds(/* prefix_sysroot= */ false));
if (in_initrd())
RET_GATHER(r, add_mounts_from_creds(/* prefix_sysroot= */ true));
return r;
}
static int run(int argc, char **argv) {
LIBCRYPTO_NOTE(suggested);
LIBMOUNT_NOTE(recommended);
LIBSELINUX_NOTE(recommended);
TPM2_NOTE(suggested);
arg_sysroot_check = invoked_as(argv, "systemd-sysroot-fstab-check");
if (arg_sysroot_check) {
/* Run as in systemd-sysroot-fstab-check mode */
log_setup();
if (strv_length(argv) > 1)
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program takes no arguments.");
if (!in_initrd())
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program is only useful in the initrd.");
} else {
/* Run in generator mode */
log_setup_generator();
if (!IN_SET(strv_length(argv), 2, 4))
return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
"This program takes one or three arguments.");
arg_dest = ASSERT_PTR(argv[1]);
arg_dest_late = ASSERT_PTR(argv[argc > 3 ? 3 : 1]);
}
return run_generator();
}
DEFINE_MAIN_FUNCTION(run);