chiark / gitweb /
gpt-auto-generator: use EBADSLT code when unable to detect partition type
[elogind.git] / src / gpt-auto-generator / gpt-auto-generator.c
index ca54925da4e9ecdd001b37060143c7979ea9cd18..05934da82f8a18a8495bbade7ebe4357112811f9 100644 (file)
@@ -24,7 +24,7 @@
 #include <fcntl.h>
 #include <sys/ioctl.h>
 #include <sys/statfs.h>
-#include <blkid.h>
+#include <blkid/blkid.h>
 
 #ifdef HAVE_LINUX_BTRFS_H
 #include <linux/btrfs.h>
 #include "missing.h"
 #include "sd-id128.h"
 #include "libudev.h"
+#include "udev-util.h"
 #include "special.h"
 #include "unit-name.h"
+#include "virt.h"
 
 /* TODO:
  *
  *
  */
 
+#define GPT_SWAP SD_ID128_MAKE(06,57,fd,6d,a4,ab,43,c4,84,e5,09,33,c8,4b,4f,4f)
+#define GPT_HOME SD_ID128_MAKE(93,3a,c7,e1,2e,b4,4f,13,b8,44,0e,14,e2,ae,f9,15)
+
 static const char *arg_dest = "/tmp";
 
-static inline void blkid_free_probep(blkid_probe *b) {
-        if (*b)
-                blkid_free_probe(*b);
-}
+DEFINE_TRIVIAL_CLEANUP_FUNC(blkid_probe, blkid_free_probe);
 #define _cleanup_blkid_freep_probe_ _cleanup_(blkid_free_probep)
 
 static int verify_gpt_partition(const char *node, sd_id128_t *type, unsigned *nr, char **fstype) {
@@ -72,10 +74,8 @@ static int verify_gpt_partition(const char *node, sd_id128_t *type, unsigned *nr
 
         errno = 0;
         r = blkid_do_safeprobe(b);
-        if (r == -2)
-                return -ENODEV;
-        else if (r == 1)
-                return -ENODEV;
+        if (r == -2 || r == 1) /* no result or uncertain */
+                return -EBADSLT;
         else if (r != 0)
                 return errno ? -errno : -EIO;
 
@@ -112,13 +112,13 @@ static int verify_gpt_partition(const char *node, sd_id128_t *type, unsigned *nr
 
 
         if (fstype) {
-                char *fst;
-
                 errno = 0;
                 r = blkid_probe_lookup_value(b, "TYPE", &v, NULL);
                 if (r != 0)
                         *fstype = NULL;
                 else {
+                        char *fst;
+
                         fst = strdup(v);
                         if (!fst)
                                 return -ENOMEM;
@@ -180,7 +180,7 @@ static int add_swap(const char *path, const char *fstype) {
 }
 
 static int add_home(const char *path, const char *fstype) {
-        _cleanup_free_ char *unit = NULL, *lnk = NULL;
+        _cleanup_free_ char *unit = NULL, *lnk = NULL, *fsck = NULL;
         _cleanup_fclose_ FILE *f = NULL;
 
         if (dir_is_empty("/home") <= 0)
@@ -198,19 +198,23 @@ static int add_home(const char *path, const char *fstype) {
                 return -errno;
         }
 
+        fsck = unit_name_from_path_instance("systemd-fsck", path, ".service");
+        if (!fsck)
+                return log_oom();
+
         fprintf(f,
                 "# Automatically generated by systemd-gpt-auto-generator\n\n"
                 "[Unit]\n"
                 "DefaultDependencies=no\n"
-                "After=" SPECIAL_LOCAL_FS_PRE_TARGET "\n"
+                "Requires=%s\n"
+                "After=" SPECIAL_LOCAL_FS_PRE_TARGET " %s\n"
                 "Conflicts=" SPECIAL_UMOUNT_TARGET "\n"
                 "Before=" SPECIAL_UMOUNT_TARGET " " SPECIAL_LOCAL_FS_TARGET "\n\n"
                 "[Mount]\n"
                 "What=%s\n"
                 "Where=/home\n"
-                "Type=%s\n"
-                "FsckPassNo=2\n",
-                path, fstype);
+                "Type=%s\n",
+                fsck, fsck, path, fstype);
 
         fflush(f);
         if (ferror(f)) {
@@ -222,7 +226,6 @@ static int add_home(const char *path, const char *fstype) {
         if (!lnk)
                 return log_oom();
 
-
         mkdir_parents_label(lnk, 0755);
         if (symlink(unit, lnk) < 0) {
                 log_error("Failed to create symlink %s: %m", lnk);
@@ -233,97 +236,83 @@ static int add_home(const char *path, const char *fstype) {
 }
 
 static int enumerate_partitions(struct udev *udev, dev_t dev) {
-        struct udev_enumerate *e = NULL;
-        struct udev_device *parent = NULL, *d = NULL;
+        struct udev_device *parent = NULL;
+        _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
+        _cleanup_udev_device_unref_ struct udev_device *d = NULL;
         struct udev_list_entry *first, *item;
         unsigned home_nr = (unsigned) -1;
         _cleanup_free_ char *home = NULL, *home_fstype = NULL;
         int r;
 
         e = udev_enumerate_new(udev);
-        if (!e) {
-                r = log_oom();
-                goto finish;
-        }
+        if (!e)
+                return log_oom();
 
         d = udev_device_new_from_devnum(udev, 'b', dev);
-        if (!d) {
-                r = log_oom();
-                goto finish;
-        }
+        if (!d)
+                return log_oom();
 
         parent = udev_device_get_parent(d);
-        if (!parent) {
-                r = log_oom();
-                goto finish;
-        }
+        if (!parent)
+                return log_oom();
 
         r = udev_enumerate_add_match_parent(e, parent);
-        if (r < 0) {
-                r = log_oom();
-                goto finish;
-        }
+        if (r < 0)
+                return log_oom();
 
         r = udev_enumerate_add_match_subsystem(e, "block");
-        if (r < 0) {
-                r = log_oom();
-                goto finish;
-        }
+        if (r < 0)
+                return log_oom();
 
         r = udev_enumerate_scan_devices(e);
         if (r < 0) {
                 log_error("Failed to enumerate partitions on /dev/block/%u:%u: %s",
                           major(dev), minor(dev), strerror(-r));
-                goto finish;
+                return r;
         }
 
         first = udev_enumerate_get_list_entry(e);
         udev_list_entry_foreach(item, first) {
                 _cleanup_free_ char *fstype = NULL;
                 const char *node = NULL;
-                struct udev_device *q;
+                _cleanup_udev_device_unref_ struct udev_device *q;
                 sd_id128_t type_id;
                 unsigned nr;
 
                 q = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item));
-                if (!q) {
-                        r = log_oom();
-                        goto finish;
-                }
+                if (!q)
+                        return log_oom();
 
                 if (udev_device_get_devnum(q) == udev_device_get_devnum(d))
-                        goto skip;
+                        continue;
 
                 if (udev_device_get_devnum(q) == udev_device_get_devnum(parent))
-                        goto skip;
+                        continue;
 
                 node = udev_device_get_devnode(q);
-                if (!node) {
-                        r = log_oom();
-                        goto finish;
-                }
+                if (!node)
+                        return log_oom();
 
                 r = verify_gpt_partition(node, &type_id, &nr, &fstype);
                 if (r < 0) {
+                        /* skip child devices which are not detected properly */
+                        if (r == -EBADSLT)
+                                continue;
                         log_error("Failed to verify GPT partition %s: %s",
                                   node, strerror(-r));
-                        udev_device_unref(q);
-                        goto finish;
+                        return r;
                 }
                 if (r == 0)
-                        goto skip;
+                        continue;
 
-                if (sd_id128_equal(type_id, SD_ID128_MAKE(06,57,fd,6d,a4,ab,43,c4,84,e5,09,33,c8,4b,4f,4f)))
+                if (sd_id128_equal(type_id, GPT_SWAP))
                         add_swap(node, fstype);
-                else if (sd_id128_equal(type_id, SD_ID128_MAKE(93,3a,c7,e1,2e,b4,4f,13,b8,44,0e,14,e2,ae,f9,15))) {
-
+                else if (sd_id128_equal(type_id, GPT_HOME)) {
                         if (!home || nr < home_nr) {
                                 free(home);
                                 home = strdup(node);
-                                if (!home) {
-                                        r = log_oom();
-                                        goto finish;
-                                }
+                                if (!home)
+                                        return log_oom();
 
                                 home_nr = nr;
 
@@ -332,27 +321,16 @@ static int enumerate_partitions(struct udev *udev, dev_t dev) {
                                 fstype = NULL;
                         }
                 }
-
-        skip:
-                udev_device_unref(q);
         }
 
         if (home && home_fstype)
                 add_home(home, home_fstype);
 
-finish:
-        if (d)
-                udev_device_unref(d);
-
-        if (e)
-                udev_enumerate_unref(e);
-
-
         return r;
 }
 
 static int get_btrfs_block_device(const char *path, dev_t *dev) {
-        struct btrfs_ioctl_fs_info_args fsi;
+        struct btrfs_ioctl_fs_info_args fsi = {};
         _cleanup_close_ int fd = -1;
         uint64_t id;
 
@@ -363,7 +341,6 @@ static int get_btrfs_block_device(const char *path, dev_t *dev) {
         if (fd < 0)
                 return -errno;
 
-        zero(fsi);
         if (ioctl(fd, BTRFS_IOC_FS_INFO, &fsi) < 0)
                 return -errno;
 
@@ -372,12 +349,11 @@ static int get_btrfs_block_device(const char *path, dev_t *dev) {
                 return 0;
 
         for (id = 1; id <= fsi.max_id; id++) {
-                struct btrfs_ioctl_dev_info_args di;
+                struct btrfs_ioctl_dev_info_args di = {
+                        .devid = id,
+                };
                 struct stat st;
 
-                zero(di);
-                di.devid = id;
-
                 if (ioctl(fd, BTRFS_IOC_DEV_INFO, &di) < 0) {
                         if (errno == ENODEV)
                                 continue;
@@ -426,44 +402,31 @@ static int get_block_device(const char *path, dev_t *dev) {
 }
 
 static int devno_to_devnode(struct udev *udev, dev_t devno, char **ret) {
-        struct udev_device *d = NULL;
+        _cleanup_udev_device_unref_ struct udev_device *d;
         const char *t;
         char *n;
-        int r;
 
         d = udev_device_new_from_devnum(udev, 'b', devno);
-        if (!d) {
-                r = log_oom();
-                goto finish;
-        }
+        if (!d)
+                return log_oom();
 
         t = udev_device_get_devnode(d);
-        if (!t) {
-                r = -ENODEV;
-                goto finish;
-        }
+        if (!t)
+                return -ENODEV;
 
         n = strdup(t);
-        if (!n) {
-                r = -ENOMEM;
-                goto finish;
-        }
+        if (!n)
+                return -ENOMEM;
 
         *ret = n;
-        r = 0;
-
-finish:
-        if (d)
-                udev_device_unref(d);
-
-        return r;
+        return 0;
 }
 
 int main(int argc, char *argv[]) {
         _cleanup_free_ char *node = NULL;
-        struct udev *udev = NULL;
+        _cleanup_udev_unref_ struct udev *udev = NULL;
         dev_t devno;
-        int r;
+        int r = 0;
 
         if (argc > 1 && argc != 4) {
                 log_error("This program takes three or no arguments.");
@@ -481,7 +444,12 @@ int main(int argc, char *argv[]) {
         umask(0022);
 
         if (in_initrd()) {
-                r = 0;
+                log_debug("In initrd, exiting.");
+                goto finish;
+        }
+
+        if (detect_container(NULL) > 0) {
+                log_debug("In a container, exiting.");
                 goto finish;
         }
 
@@ -520,8 +488,5 @@ int main(int argc, char *argv[]) {
         r = enumerate_partitions(udev, devno);
 
 finish:
-        if (udev)
-                udev_unref(udev);
-
         return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
 }