HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/fstab-generator/fstab-generator.c

63,205 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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);