chiark / gitweb /
fstab-generator: generate new_root.mount in initrd
authorTom Gundersen <teg@jklm.no>
Fri, 23 Nov 2012 02:41:13 +0000 (03:41 +0100)
committerTom Gundersen <teg@jklm.no>
Fri, 28 Dec 2012 22:39:42 +0000 (23:39 +0100)
The configuration is taken from /proc/cmdline, aiming at emulating the
behavior of the kernel when no initramfs is used.

The supported options are: root=, rootfstype=, rootwait=, rootflags=,
ro, and rw. rootdelay= was dropped, as it is not really useful in a
systemd world, but could easily be added.

v2: fix comments by Lennart, and complain loudly if root= can not be found

Cc: Harald Hoyer <harald@redhat.com>
Cc: Dave Reisner <dreisner@archlinux.org>
src/fstab-generator/fstab-generator.c

index 23e5051..6766d44 100644 (file)
@@ -210,18 +210,21 @@ static bool mount_is_network(struct mntent *me) {
                 fstype_is_network(me->mnt_type);
 }
 
-static int add_mount(const char *what, const char *where, struct mntent *me) {
+static int add_mount(const char *what, const char *where, const char *type, const char *opts,
+                     int passno, bool wait, bool noauto, bool nofail, bool automount, bool isbind, bool isnetwork,
+                     const char *source) {
         char *name = NULL, *unit = NULL, *lnk = NULL, *device = NULL, *automount_name = NULL, *automount_unit = NULL;
         FILE *f = NULL;
-        bool noauto, nofail, automount, isbind, isnetwork;
         int r;
         const char *post, *pre;
 
         assert(what);
         assert(where);
-        assert(me);
+        assert(type);
+        assert(opts);
+        assert(source);
 
-        if (streq(me->mnt_type, "autofs"))
+        if (streq(type, "autofs"))
                 return 0;
 
         if (!is_path(where)) {
@@ -233,15 +236,6 @@ static int add_mount(const char *what, const char *where, struct mntent *me) {
             mount_point_ignore(where))
                 return 0;
 
-        isnetwork = mount_is_network(me);
-        isbind = mount_is_bind(me);
-
-        noauto = !!hasmntopt(me, "noauto");
-        nofail = !!hasmntopt(me, "nofail");
-        automount =
-                hasmntopt(me, "comment=systemd.automount") ||
-                hasmntopt(me, "x-systemd.automount");
-
         if (isnetwork) {
                 post = SPECIAL_REMOTE_FS_TARGET;
                 pre = SPECIAL_REMOTE_FS_PRE_TARGET;
@@ -272,10 +266,12 @@ static int add_mount(const char *what, const char *where, struct mntent *me) {
                 goto finish;
         }
 
-        fputs("# Automatically generated by systemd-fstab-generator\n\n"
+        fprintf(f,
+              "# Automatically generated by systemd-fstab-generator\n\n"
               "[Unit]\n"
-              "SourcePath=/etc/fstab\n"
-              "DefaultDependencies=no\n", f);
+              "SourcePath=%s\n"
+              "DefaultDependencies=no\n",
+              source);
 
         if (!path_equal(where, "/"))
                 fprintf(f,
@@ -301,14 +297,18 @@ static int add_mount(const char *what, const char *where, struct mntent *me) {
                 "FsckPassNo=%i\n",
                 what,
                 where,
-                me->mnt_type,
-                me->mnt_passno);
+                type,
+                passno);
 
-        if (!isempty(me->mnt_opts) &&
-            !streq(me->mnt_opts, "defaults"))
+        if (!isempty(opts) &&
+            !streq(opts, "defaults"))
                 fprintf(f,
                         "Options=%s\n",
-                        me->mnt_opts);
+                        opts);
+
+        if (wait)
+                fprintf(f,
+                        "TimeoutSec=0\n");
 
         fflush(f);
         if (ferror(f)) {
@@ -466,8 +466,22 @@ static int parse_fstab(void) {
 
                 if (streq(me->mnt_type, "swap"))
                         k = add_swap(what, me);
-                else
-                        k = add_mount(what, where, me);
+                else {
+                        bool noauto, nofail, automount, isbind, isnetwork;
+
+                        noauto = !!hasmntopt(me, "noauto");
+                        nofail = !!hasmntopt(me, "nofail");
+                        automount =
+                                  hasmntopt(me, "comment=systemd.automount") ||
+                                  hasmntopt(me, "x-systemd.automount");
+                        isbind = mount_is_bind(me);
+                        isnetwork = mount_is_network(me);
+
+                        k = add_mount(what, where, me->mnt_type, me->mnt_opts,
+                                     me->mnt_passno, false, noauto, nofail,
+                                     automount, isbind, isnetwork,
+                                     "/etc/fstab");
+                }
 
                 free(what);
                 free(where);
@@ -481,6 +495,82 @@ finish:
         return r;
 }
 
+static int parse_new_root_from_proc_cmdline(void) {
+        char *w, *state;
+        _cleanup_free_ char *what = NULL, *type = NULL, *opts = NULL, *line = NULL;
+        int r;
+        size_t l;
+        bool wait = false;
+
+        r = read_one_line_file("/proc/cmdline", &line);
+        if (r < 0) {
+                log_error("Failed to read /proc/cmdline, ignoring: %s", strerror(-r));
+                return 0;
+        }
+
+        opts = strdup("defaults");
+        if (!opts)
+                return log_oom();
+        type = strdup("auto");
+        if (!type)
+                return log_oom();
+
+       /* root= and roofstype= may occur more than once, the last instance should take precedence.
+        * In the case of multiple rootflags= the arguments should be concatenated */
+        FOREACH_WORD_QUOTED(w, l, line, state) {
+                char *word, *tmp_word;
+
+                word = strndup(w, l);
+                if (!word)
+                        return log_oom();
+
+                else if (startswith(word, "root=")) {
+                        free(what);
+                        what = fstab_node_to_udev_node(word+5);
+                        if (!what)
+                                return log_oom();
+
+                } else if (startswith(word, "rootfstype=")) {
+                        free(type);
+                        type = strdup(word + 11);
+                        if (!type)
+                                return log_oom();
+
+                } else if (startswith(word, "rootflags=")) {
+                        tmp_word = opts;
+                        opts = strjoin(opts, ",", word + 10, NULL);
+                        free(tmp_word);
+                        if (!opts)
+                                return log_oom();
+
+                } else if (streq(word, "ro") || streq(word, "rw")) {
+                        tmp_word = opts;
+                        opts = strjoin(opts, ",", word, NULL);
+                        free(tmp_word);
+                        if (!opts)
+                                return log_oom();
+
+                } else if (streq(word, "rootwait"))
+                        wait = true;
+
+                free(word);
+        }
+
+        if (what) {
+
+                log_debug("Found entry what=%s where=/new_root type=%s", what, type);
+                r = add_mount(what, "/new_root", type, opts, 0, wait, false, false,
+                              false, false, false, "/proc/cmdline");
+
+                if (r < 0)
+                        return r;
+        } else
+                log_error("Could not find a root= entry on the kernel commandline.");
+        }
+
+        return 0;
+}
+
 static int parse_proc_cmdline(void) {
         char *line, *w, *state;
         int r;
@@ -538,7 +628,7 @@ finish:
 }
 
 int main(int argc, char *argv[]) {
-        int r;
+        int r, k = 0;
 
         if (argc > 1 && argc != 4) {
                 log_error("This program takes three or no arguments.");
@@ -557,10 +647,13 @@ int main(int argc, char *argv[]) {
         if (parse_proc_cmdline() < 0)
                 return EXIT_FAILURE;
 
+        if (in_initrd())
+                k = parse_new_root_from_proc_cmdline();
+
         if (!arg_enabled)
                 return EXIT_SUCCESS;
 
         r = parse_fstab();
 
-        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
+        return (r < 0) || (k < 0) ? EXIT_FAILURE : EXIT_SUCCESS;
 }