unit: handle nicely of certain unit types are not supported on specific systems

[elogind.git] / src / core / mount.c

diff --git a/src/core/mount.c b/src/core/mount.c
index a39076838b205f80fc0b2110131bfa78566adcf9..f8731bb8b979cb955fb07165b429ed3e798fc846 100644 (file)
--- a/src/core/mount.c
+++ b/src/core/mount.c
@@ -41,10 +41,12 @@
 #include "unit-name.h"
 #include "dbus-mount.h"
 #include "special.h"
-#include "bus-errors.h"
+#include "bus-common-errors.h"
 #include "exit-status.h"
 #include "def.h"
 
+#define RETRY_UMOUNT_MAX 32
+
 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table*, mnt_free_table);
 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter*, mnt_free_iter);
 
@@ -867,20 +869,28 @@ static void mount_enter_unmounting(Mount *m) {
 
         assert(m);
 
+        /* Start counting our attempts */
+        if (!IN_SET(m->state,
+                    MOUNT_UNMOUNTING,
+                    MOUNT_UNMOUNTING_SIGTERM,
+                    MOUNT_UNMOUNTING_SIGKILL))
+                m->n_retry_umount = 0;
+
         m->control_command_id = MOUNT_EXEC_UNMOUNT;
         m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
 
-        if ((r = exec_command_set(
-                             m->control_command,
+        r = exec_command_set(m->control_command,
                              "/bin/umount",
                              "-n",
                              m->where,
-                             NULL)) < 0)
+                             NULL);
+        if (r < 0)
                 goto fail;
 
         mount_unwatch_control_pid(m);
 
-        if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
+        r = mount_spawn(m, m->control_command, &m->control_pid);
+        if (r < 0)
                 goto fail;
 
         mount_set_state(m, MOUNT_UNMOUNTING);
@@ -1239,9 +1249,31 @@ static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
         case MOUNT_UNMOUNTING_SIGKILL:
         case MOUNT_UNMOUNTING_SIGTERM:
 
-                if (f == MOUNT_SUCCESS)
-                        mount_enter_dead(m, f);
-                else if (m->from_proc_self_mountinfo)
+                if (f == MOUNT_SUCCESS) {
+
+                        if (m->from_proc_self_mountinfo) {
+
+                                /* Still a mount point? If so, let's
+                                 * try again. Most likely there were
+                                 * multiple mount points stacked on
+                                 * top of each other. Note that due to
+                                 * the io event priority logic we can
+                                 * be sure the new mountinfo is loaded
+                                 * before we process the SIGCHLD for
+                                 * the mount command. */
+
+                                if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
+                                        log_unit_debug(u->id, "%s: mount still present, trying again.", u->id);
+                                        m->n_retry_umount++;
+                                        mount_enter_unmounting(m);
+                                } else {
+                                        log_unit_debug(u->id, "%s: mount still present after %u attempts to unmount, giving up.", u->id, m->n_retry_umount);
+                                        mount_enter_mounted(m, f);
+                                }
+                        } else
+                                mount_enter_dead(m, f);
+
+                } else if (m->from_proc_self_mountinfo)
                         mount_enter_mounted(m, f);
                 else
                         mount_enter_dead(m, f);
@@ -1415,7 +1447,6 @@ static int mount_add_one(
                         goto fail;
                 }
 
-
                 if (m->running_as == SYSTEMD_SYSTEM) {
                         const char* target;
 
@@ -1616,14 +1647,18 @@ static int mount_enumerate(Manager *m) {
 
         if (m->utab_inotify_fd < 0) {
                 m->utab_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
-                if (m->utab_inotify_fd < 0)
-                        goto fail_with_errno;
+                if (m->utab_inotify_fd < 0) {
+                        r = -errno;
+                        goto fail;
+                }
 
                 (void) mkdir_p_label("/run/mount", 0755);
 
                 r = inotify_add_watch(m->utab_inotify_fd, "/run/mount", IN_MOVED_TO);
-                if (r < 0)
-                        goto fail_with_errno;
+                if (r < 0) {
+                        r = -errno;
+                        goto fail;
+                }
 
                 r = sd_event_add_io(m->event, &m->mount_utab_event_source, m->utab_inotify_fd, EPOLLIN, mount_dispatch_io, m);
                 if (r < 0)
@@ -1640,8 +1675,6 @@ static int mount_enumerate(Manager *m) {
 
         return 0;
 
-fail_with_errno:
-        r = -errno;
 fail:
         mount_shutdown(m);
         return r;
@@ -1661,23 +1694,37 @@ static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents,
          * for mount options. */
 
         if (fd == m->utab_inotify_fd) {
-                char inotify_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
-                struct inotify_event *event;
-                char *p;
-                int rescan = 0;
-
-                while ((r = read(fd, inotify_buffer, sizeof(inotify_buffer))) > 0)
-                        for (p = inotify_buffer; p < inotify_buffer + r; ) {
-                                event = (struct inotify_event *) p;
-                                /* only care about changes to utab, but we have
-                                 * to monitor the directory to reliably get
-                                 * notifications about when utab is replaced
-                                 * using rename(2) */
-                                if ((event->mask & IN_Q_OVERFLOW) || streq(event->name, "utab"))
-                                        rescan = 1;
-                                p += sizeof(struct inotify_event) + event->len;
+                bool rescan = false;
+
+                /* FIXME: We *really* need to replace this with
+                 * libmount's own API for this, we should not hardcode
+                 * internal behaviour of libmount here. */
+
+                for (;;) {
+                        uint8_t buffer[INOTIFY_EVENT_MAX] _alignas_(struct inotify_event);
+                        struct inotify_event *e;
+                        ssize_t l;
+
+                        l = read(fd, buffer, sizeof(buffer));
+                        if (l < 0) {
+                                if (errno == EAGAIN || errno == EINTR)
+                                        break;
+
+                                log_error_errno(errno, "Failed to read utab inotify: %m");
+                                break;
                         }
 
+                        FOREACH_INOTIFY_EVENT(e, buffer, l) {
+                                /* Only care about changes to utab,
+                                 * but we have to monitor the
+                                 * directory to reliably get
+                                 * notifications about when utab is
+                                 * replaced using rename(2) */
+                                if ((e->mask & IN_Q_OVERFLOW) || streq(e->name, "utab"))
+                                        rescan = true;
+                        }
+                }
+
                 if (!rescan)
                         return 0;
         }