swap: major rework, use /sbin/swapon for setting up swaps, fix merging of aliased swap disks

8 files changed, 774 insertions, 111 deletions

diff --git a/TODO b/TODO
index 4c8090b4d4..4052945897 100644
--- a/TODO
+++ b/TODO
@@ -30,8 +30,6 @@
 
 * set_put(), hashmap_put() return values check. i.e. == 0 doesn't free()!
 
-* fix merging in .swap units
-
 * chkconfig/systemd-install glue
 
 * io priority during initialization
@@ -80,8 +78,6 @@
 
 * beefed up tmpwatch that reads tmpfiles.d
 
-* use /sbin/swapon
-
 * enable syslog.socket by default, activating our kmsg bridge
 
 * when processes remain in a service even though the start command failed enter active
diff --git a/src/device.c b/src/device.c
index 2cbb81aebd..7b73110120 100644
--- a/src/device.c
+++ b/src/device.c
@@ -188,10 +188,6 @@ static int device_update_unit(Manager *m, struct udev_device *dev, const char *p
         if ((r = device_find_escape_name(m, path, &u)) < 0)
                 return r;
 
-        /* If a different unit already claimed this name then let's do
-         * nothing. This can happen for example when two disks with
-         * the same label are plugged in, and which hence try to get
-         * conflicting symlinks in /dev/disk/by-label/xxxx */
         if (u && DEVICE(u)->sysfs && !path_equal(DEVICE(u)->sysfs, sysfs))
                 return -EEXIST;
 
diff --git a/src/list.h b/src/list.h
index e49d953d0a..3cf18f1547 100644
--- a/src/list.h
+++ b/src/list.h
@@ -116,4 +116,10 @@
 #define LIST_FOREACH_SAFE(name,i,n,head)                                \
         for ((i) = (head); (i) && (((n) = (i)->name##_next), 1); (i) = (n))
 
+#define LIST_FOREACH_BEFORE(name,i,p)                                   \
+        for ((i) = (p)->name##_prev; (i); (i) = (i)->name##_prev)
+
+#define LIST_FOREACH_AFTER(name,i,p)                                    \
+        for ((i) = (p)->name##_next; (i); (i) = (i)->name##_next)
+
 #endif
diff --git a/src/manager.c b/src/manager.c
index 537ff2e39d..1fe8936cd3 100644
--- a/src/manager.c
+++ b/src/manager.c
@@ -2217,6 +2217,9 @@ int manager_loop(Manager *m) {
                 if (manager_dispatch_dbus_queue(m) > 0)
                         continue;
 
+                if (swap_dispatch_reload(m) > 0)
+                        continue;
+
                 if ((n = epoll_wait(m->epoll_fd, &event, 1, -1)) < 0) {
 
                         if (errno == EINTR)
diff --git a/src/manager.h b/src/manager.h
index 5037127655..15ffb2c1a5 100644
--- a/src/manager.h
+++ b/src/manager.h
@@ -155,6 +155,8 @@ struct Manager {
 
         /* Data specific to the swap filesystem */
         FILE *proc_swaps;
+        Hashmap *swaps_by_proc_swaps;
+        bool request_reload;
 
         /* Data specific to the D-Bus subsystem */
         DBusConnection *api_bus, *system_bus;
diff --git a/src/swap.c b/src/swap.c
index 776b707d3a..487b18350a 100644
--- a/src/swap.c
+++ b/src/swap.c
@@ -26,6 +26,7 @@
 #include <sys/epoll.h>
 #include <sys/stat.h>
 #include <sys/swap.h>
+#include <libudev.h>
 
 #include "unit.h"
 #include "swap.h"
@@ -37,17 +38,64 @@
 
 static const UnitActiveState state_translation_table[_SWAP_STATE_MAX] = {
         [SWAP_DEAD] = UNIT_INACTIVE,
+        [SWAP_ACTIVATING] = UNIT_ACTIVATING,
         [SWAP_ACTIVE] = UNIT_ACTIVE,
+        [SWAP_DEACTIVATING] = UNIT_DEACTIVATING,
+        [SWAP_ACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
+        [SWAP_ACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
+        [SWAP_DEACTIVATING_SIGTERM] = UNIT_DEACTIVATING,
+        [SWAP_DEACTIVATING_SIGKILL] = UNIT_DEACTIVATING,
         [SWAP_FAILED] = UNIT_FAILED
 };
 
-static void swap_init(Unit *u) {
+static void swap_unset_proc_swaps(Swap *s) {
+        Swap *first;
+
+        assert(s);
+
+        if (!s->parameters_proc_swaps.what)
+                return;
+
+        /* Remove this unit from the chain of swaps which share the
+         * same kernel swap device. */
+
+        first = hashmap_get(s->meta.manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
+        LIST_REMOVE(Swap, same_proc_swaps, first, s);
+
+        if (first)
+                hashmap_remove_and_replace(s->meta.manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what, first->parameters_proc_swaps.what, first);
+        else
+                hashmap_remove(s->meta.manager->swaps_by_proc_swaps, s->parameters_proc_swaps.what);
+
+        free(s->parameters_proc_swaps.what);
+        s->parameters_proc_swaps.what = NULL;
+}
+
+ static void swap_init(Unit *u) {
         Swap *s = SWAP(u);
 
         assert(s);
         assert(s->meta.load_state == UNIT_STUB);
 
+        s->timeout_usec = DEFAULT_TIMEOUT_USEC;
+
+        exec_context_init(&s->exec_context);
+
         s->parameters_etc_fstab.priority = s->parameters_proc_swaps.priority = s->parameters_fragment.priority = -1;
+
+        s->timer_watch.type = WATCH_INVALID;
+
+        s->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
+}
+
+static void swap_unwatch_control_pid(Swap *s) {
+        assert(s);
+
+        if (s->control_pid <= 0)
+                return;
+
+        unit_unwatch_pid(UNIT(s), s->control_pid);
+        s->control_pid = 0;
 }
 
 static void swap_done(Unit *u) {
@@ -55,10 +103,22 @@ static void swap_done(Unit *u) {
 
         assert(s);
 
+        swap_unset_proc_swaps(s);
+
         free(s->what);
+        s->what = NULL;
+
         free(s->parameters_etc_fstab.what);
-        free(s->parameters_proc_swaps.what);
         free(s->parameters_fragment.what);
+        s->parameters_etc_fstab.what = s->parameters_fragment.what = NULL;
+
+        exec_context_done(&s->exec_context);
+        exec_command_done_array(s->exec_command, _SWAP_EXEC_COMMAND_MAX);
+        s->control_command = NULL;
+
+        swap_unwatch_control_pid(s);
+
+        unit_unwatch_timer(u, &s->timer_watch);
 }
 
 int swap_add_one_mount_link(Swap *s, Mount *m) {
@@ -153,9 +213,8 @@ static int swap_add_default_dependencies(Swap *s) {
                 if ((r = unit_add_dependency_by_name(UNIT(s), UNIT_AFTER, SPECIAL_SYSINIT_TARGET, NULL, true)) < 0)
                         return r;
 
-                /* Note that by default we don't disable swap devices
-                 * on shutdown. i.e. there is no umount.target
-                 * conflicts here. */
+                if ((r = unit_add_two_dependencies_by_name(UNIT(s), UNIT_BEFORE, UNIT_CONFLICTED_BY, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0)
+                        return r;
         }
 
         return 0;
@@ -179,6 +238,11 @@ static int swap_verify(Swap *s) {
                 return -EINVAL;
         }
 
+        if (s->exec_context.pam_name && s->exec_context.kill_mode != KILL_CONTROL_GROUP) {
+                log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", s->meta.id);
+                return -EINVAL;
+        }
+
         return 0;
 }
 
@@ -236,59 +300,18 @@ static int swap_load(Unit *u) {
         return swap_verify(s);
 }
 
-static int swap_find(Manager *m, const char *what, Unit **_u) {
-        Unit *u;
-        char *e;
-
-        assert(m);
-        assert(what);
-        assert(_u);
-
-        /* /proc/swaps and /etc/fstab might refer to this device by
-         * different names (e.g. one by uuid, the other by the kernel
-         * name), we hence need to look for all aliases we are aware
-         * of for this device */
-
-        if (!(e = unit_name_from_path(what, ".device")))
-                return -ENOMEM;
-
-        u = manager_get_unit(m, e);
-        free(e);
-
-        if (u) {
-                Iterator i;
-                const char *d;
-
-                SET_FOREACH(d, u->meta.names, i) {
-                        Unit *k;
-
-                        if (!(e = unit_name_change_suffix(d, ".swap")))
-                                return -ENOMEM;
-
-                        k = manager_get_unit(m, e);
-                        free(e);
-
-                        if (k) {
-                                *_u = k;
-                                return 0;
-                        }
-                }
-        }
-
-        *_u = NULL;
-        return 0;
-}
-
 int swap_add_one(
                 Manager *m,
                 const char *what,
+                const char *what_proc_swaps,
                 int priority,
                 bool noauto,
                 bool nofail,
                 bool handle,
-                bool from_proc_swaps) {
+                bool set_flags) {
+
         Unit *u = NULL;
-        char *e = NULL, *w = NULL;
+        char *e = NULL, *wp = NULL;
         bool delete = false;
         int r;
         SwapParameters *p;
@@ -299,9 +322,13 @@ int swap_add_one(
         if (!(e = unit_name_from_path(what, ".swap")))
                 return -ENOMEM;
 
-        if (!(u = manager_get_unit(m, e)))
-                if ((r = swap_find(m, what, &u)) < 0)
-                        goto fail;
+        u = manager_get_unit(m, e);
+
+        if (what_proc_swaps &&
+            u &&
+            SWAP(u)->from_proc_swaps &&
+            !path_equal(SWAP(u)->parameters_proc_swaps.what, what_proc_swaps))
+                return -EEXIST;
 
         if (!u) {
                 delete = true;
@@ -310,36 +337,72 @@ int swap_add_one(
                         free(e);
                         return -ENOMEM;
                 }
+
+                if ((r = unit_add_name(u, e)) < 0)
+                        goto fail;
+
+                if (!(SWAP(u)->what = strdup(what))) {
+                        r = -ENOMEM;
+                        goto fail;
+                }
+
+                unit_add_to_load_queue(u);
         } else
                 delete = false;
 
-        if ((r = unit_add_name(u, e)) < 0)
-                goto fail;
-
-        if (!(w = strdup(what))) {
-                r = -ENOMEM;
-                goto fail;
-        }
+        if (what_proc_swaps) {
+                Swap *first;
 
-        if (from_proc_swaps) {
                 p = &SWAP(u)->parameters_proc_swaps;
+
+                if (!p->what) {
+                        if (!(wp = strdup(what_proc_swaps))) {
+                                r = -ENOMEM;
+                                goto fail;
+                        }
+
+                        if (!m->swaps_by_proc_swaps)
+                                if (!(m->swaps_by_proc_swaps = hashmap_new(string_hash_func, string_compare_func))) {
+                                        r = -ENOMEM;
+                                        goto fail;
+                                }
+
+                        free(p->what);
+                        p->what = wp;
+
+                        first = hashmap_get(m->swaps_by_proc_swaps, wp);
+                        LIST_PREPEND(Swap, same_proc_swaps, first, SWAP(u));
+
+                        if ((r = hashmap_replace(m->swaps_by_proc_swaps, wp, first)) < 0)
+                                goto fail;
+                }
+
+                if (set_flags) {
+                        SWAP(u)->is_active = true;
+                        SWAP(u)->just_activated = !SWAP(u)->from_proc_swaps;
+                }
+
                 SWAP(u)->from_proc_swaps = true;
+
         } else {
                 p = &SWAP(u)->parameters_etc_fstab;
+
+                if (!(wp = strdup(what))) {
+                        r = -ENOMEM;
+                        goto fail;
+                }
+
+                free(p->what);
+                p->what = wp;
+
                 SWAP(u)->from_etc_fstab = true;
         }
 
-        free(p->what);
-        p->what = w;
-
         p->priority = priority;
         p->noauto = noauto;
         p->nofail = nofail;
         p->handle = handle;
 
-        if (delete)
-                unit_add_to_load_queue(u);
-
         unit_add_to_dbus_queue(u);
 
         free(e);
@@ -347,7 +410,9 @@ int swap_add_one(
         return 0;
 
 fail:
-        free(w);
+        log_warning("Failed to load swap unit: %s", strerror(-r));
+
+        free(wp);
         free(e);
 
         if (delete && u)
@@ -356,13 +421,74 @@ fail:
         return r;
 }
 
+static int swap_process_new_swap(Manager *m, const char *device, int prio, bool set_flags) {
+        struct stat st;
+        int r = 0, k;
+
+        assert(m);
+
+        if (stat(device, &st) >= 0 && S_ISBLK(st.st_mode)) {
+                struct udev_device *d;
+                const char *dn;
+                struct udev_list_entry *item = NULL, *first = NULL;
+
+                /* So this is a proper swap device. Create swap units
+                 * for all names this swap device is known under */
+
+                if (!(d = udev_device_new_from_devnum(m->udev, 'b', st.st_rdev)))
+                        return -ENOMEM;
+
+                if ((dn = udev_device_get_devnode(d)))
+                        r = swap_add_one(m, dn, device, prio, false, false, false, set_flags);
+
+                /* Add additional units for all symlinks */
+                first = udev_device_get_devlinks_list_entry(d);
+                udev_list_entry_foreach(item, first) {
+                        const char *p;
+
+                        /* Don't bother with the /dev/block links */
+                        p = udev_list_entry_get_name(item);
+
+                        if (path_startswith(p, "/dev/block/"))
+                                continue;
+
+                        if (stat(p, &st) >= 0)
+                                if ((!S_ISBLK(st.st_mode)) || st.st_rdev != udev_device_get_devnum(d))
+                                        continue;
+
+                        if ((k = swap_add_one(m, p, device, prio, false, false, false, set_flags)) < 0)
+                                r = k;
+                }
+
+                udev_device_unref(d);
+        }
+
+        if ((k = swap_add_one(m, device, device, prio, false, false, false, set_flags)) < 0)
+                r = k;
+
+        return r;
+}
+
 static void swap_set_state(Swap *s, SwapState state) {
         SwapState old_state;
+
         assert(s);
 
         old_state = s->state;
         s->state = state;
 
+        if (state != SWAP_ACTIVATING &&
+            state != SWAP_ACTIVATING_SIGTERM &&
+            state != SWAP_ACTIVATING_SIGKILL &&
+            state != SWAP_DEACTIVATING &&
+            state != SWAP_DEACTIVATING_SIGTERM &&
+            state != SWAP_DEACTIVATING_SIGKILL) {
+                unit_unwatch_timer(UNIT(s), &s->timer_watch);
+                swap_unwatch_control_pid(s);
+                s->control_command = NULL;
+                s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
+        }
+
         if (state != old_state)
                 log_debug("%s changed %s -> %s",
                           s->meta.id,
@@ -375,6 +501,7 @@ static void swap_set_state(Swap *s, SwapState state) {
 static int swap_coldplug(Unit *u) {
         Swap *s = SWAP(u);
         SwapState new_state = SWAP_DEAD;
+        int r;
 
         assert(s);
         assert(s->state == SWAP_DEAD);
@@ -384,8 +511,27 @@ static int swap_coldplug(Unit *u) {
         else if (s->from_proc_swaps)
                 new_state = SWAP_ACTIVE;
 
-        if (new_state != s->state)
+        if (new_state != s->state) {
+
+                if (new_state == SWAP_ACTIVATING ||
+                    new_state == SWAP_ACTIVATING_SIGTERM ||
+                    new_state == SWAP_ACTIVATING_SIGKILL ||
+                    new_state == SWAP_DEACTIVATING ||
+                    new_state == SWAP_DEACTIVATING_SIGTERM ||
+                    new_state == SWAP_DEACTIVATING_SIGKILL) {
+
+                        if (s->control_pid <= 0)
+                                return -EBADMSG;
+
+                        if ((r = unit_watch_pid(UNIT(s), s->control_pid)) < 0)
+                                return r;
+
+                        if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+                                return r;
+                }
+
                 swap_set_state(s, new_state);
+        }
 
         return 0;
 }
@@ -423,50 +569,261 @@ static void swap_dump(Unit *u, FILE *f, const char *prefix) {
                 prefix, yes_no(s->from_etc_fstab),
                 prefix, yes_no(s->from_proc_swaps),
                 prefix, yes_no(s->from_fragment));
+
+        if (s->control_pid > 0)
+                fprintf(f,
+                        "%sControl PID: %lu\n",
+                        prefix, (unsigned long) s->control_pid);
+
+        exec_context_dump(&s->exec_context, f, prefix);
+}
+
+static int swap_spawn(Swap *s, ExecCommand *c, pid_t *_pid) {
+        pid_t pid;
+        int r;
+
+        assert(s);
+        assert(c);
+        assert(_pid);
+
+        if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+                goto fail;
+
+        if ((r = exec_spawn(c,
+                            NULL,
+                            &s->exec_context,
+                            NULL, 0,
+                            s->meta.manager->environment,
+                            true,
+                            true,
+                            true,
+                            s->meta.manager->confirm_spawn,
+                            s->meta.cgroup_bondings,
+                            &pid)) < 0)
+                goto fail;
+
+        if ((r = unit_watch_pid(UNIT(s), pid)) < 0)
+                /* FIXME: we need to do something here */
+                goto fail;
+
+        *_pid = pid;
+
+        return 0;
+
+fail:
+        unit_unwatch_timer(UNIT(s), &s->timer_watch);
+
+        return r;
 }
 
 static void swap_enter_dead(Swap *s, bool success) {
         assert(s);
 
-        swap_set_state(s, success ? SWAP_DEAD : SWAP_FAILED);
+        if (!success)
+                s->failure = true;
+
+        swap_set_state(s, s->failure ? SWAP_FAILED : SWAP_DEAD);
 }
 
-static int swap_start(Unit *u) {
-        Swap *s = SWAP(u);
-        int priority = -1;
+static void swap_enter_active(Swap *s, bool success) {
+        assert(s);
+
+        if (!success)
+                s->failure = true;
+
+        swap_set_state(s, SWAP_ACTIVE);
+}
+
+static void swap_enter_signal(Swap *s, SwapState state, bool success) {
         int r;
+        Set *pid_set = NULL;
+        bool wait_for_exit = false;
 
         assert(s);
-        assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
+
+        if (!success)
+                s->failure = true;
+
+        if (s->exec_context.kill_mode != KILL_NONE) {
+                int sig = (state == SWAP_ACTIVATING_SIGTERM ||
+                           state == SWAP_DEACTIVATING_SIGTERM) ? s->exec_context.kill_signal : SIGKILL;
+
+                if (s->control_pid > 0) {
+                        if (kill(s->exec_context.kill_mode == KILL_PROCESS_GROUP ?
+                                 -s->control_pid :
+                                 s->control_pid, sig) < 0 && errno != ESRCH)
+
+                                log_warning("Failed to kill control process %li: %m", (long) s->control_pid);
+                        else
+                                wait_for_exit = true;
+                }
+
+                if (s->exec_context.kill_mode == KILL_CONTROL_GROUP) {
+
+                        if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
+                                r = -ENOMEM;
+                                goto fail;
+                        }
+
+                        /* Exclude the control pid from being killed via the cgroup */
+                        if (s->control_pid > 0)
+                                if ((r = set_put(pid_set, LONG_TO_PTR(s->control_pid))) < 0)
+                                        goto fail;
+
+                        if ((r = cgroup_bonding_kill_list(s->meta.cgroup_bondings, sig, pid_set)) < 0) {
+                                if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
+                                        log_warning("Failed to kill control group: %s", strerror(-r));
+                        } else if (r > 0)
+                                wait_for_exit = true;
+
+                        set_free(pid_set);
+                }
+        }
+
+        if (wait_for_exit) {
+                if ((r = unit_watch_timer(UNIT(s), s->timeout_usec, &s->timer_watch)) < 0)
+                        goto fail;
+
+                swap_set_state(s, state);
+        } else
+                swap_enter_dead(s, true);
+
+        return;
+
+fail:
+        log_warning("%s failed to kill processes: %s", s->meta.id, strerror(-r));
+
+        swap_enter_dead(s, false);
+
+        if (pid_set)
+                set_free(pid_set);
+}
+
+static void swap_enter_activating(Swap *s) {
+        int r, priority;
+
+        assert(s);
+
+        s->control_command_id = SWAP_EXEC_ACTIVATE;
+        s->control_command = s->exec_command + SWAP_EXEC_ACTIVATE;
 
         if (s->from_fragment)
                 priority = s->parameters_fragment.priority;
         else if (s->from_etc_fstab)
                 priority = s->parameters_etc_fstab.priority;
+        else
+                priority = -1;
 
-        r = swapon(s->what, (priority << SWAP_FLAG_PRIO_SHIFT) & SWAP_FLAG_PRIO_MASK);
+        if (priority >= 0) {
+                char p[LINE_MAX];
 
-        if (r < 0 && errno != EBUSY) {
-                r = -errno;
-                swap_enter_dead(s, false);
-                return r;
-        }
+                snprintf(p, sizeof(p), "%i", priority);
+                char_array_0(p);
 
-        swap_set_state(s, SWAP_ACTIVE);
+                r = exec_command_set(
+                                s->control_command,
+                                "/sbin/swapon",
+                                "-p",
+                                p,
+                                s->what,
+                                NULL);
+        } else
+                r = exec_command_set(
+                                s->control_command,
+                                "/sbin/swapon",
+                                s->what,
+                                NULL);
+
+        if (r < 0)
+                goto fail;
+
+        swap_unwatch_control_pid(s);
+
+        if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
+                goto fail;
+
+        swap_set_state(s, SWAP_ACTIVATING);
+
+        return;
+
+fail:
+        log_warning("%s failed to run 'swapon' task: %s", s->meta.id, strerror(-r));
+        swap_enter_dead(s, false);
+}
+
+static void swap_enter_deactivating(Swap *s, bool success) {
+        int r;
+
+        assert(s);
+
+        if (!success)
+                s->failure = true;
+
+        s->control_command_id = SWAP_EXEC_DEACTIVATE;
+        s->control_command = s->exec_command + SWAP_EXEC_DEACTIVATE;
+
+        if ((r = exec_command_set(
+                             s->control_command,
+                             "/sbin/swapoff",
+                             s->what,
+                             NULL)) < 0)
+                goto fail;
+
+        swap_unwatch_control_pid(s);
+
+        if ((r = swap_spawn(s, s->control_command, &s->control_pid)) < 0)
+                goto fail;
+
+        swap_set_state(s, SWAP_DEACTIVATING);
+
+        return;
+
+fail:
+        log_warning("%s failed to run 'swapoff' task: %s", s->meta.id, strerror(-r));
+        swap_enter_active(s, false);
+}
+
+static int swap_start(Unit *u) {
+        Swap *s = SWAP(u);
+
+        assert(s);
+
+        /* We cannot fulfill this request right now, try again later
+         * please! */
+
+        if (s->state == SWAP_DEACTIVATING ||
+            s->state == SWAP_DEACTIVATING_SIGTERM ||
+            s->state == SWAP_DEACTIVATING_SIGKILL ||
+            s->state == SWAP_ACTIVATING_SIGTERM ||
+            s->state == SWAP_ACTIVATING_SIGKILL)
+                return -EAGAIN;
+
+        if (s->state == SWAP_ACTIVATING)
+                return 0;
+
+        assert(s->state == SWAP_DEAD || s->state == SWAP_FAILED);
+
+        s->failure = false;
+        swap_enter_activating(s);
         return 0;
 }
 
 static int swap_stop(Unit *u) {
         Swap *s = SWAP(u);
-        int r;
 
         assert(s);
 
-        assert(s->state == SWAP_ACTIVE);
+        if (s->state == SWAP_DEACTIVATING ||
+            s->state == SWAP_DEACTIVATING_SIGTERM ||
+            s->state == SWAP_DEACTIVATING_SIGKILL ||
+            s->state == SWAP_ACTIVATING_SIGTERM ||
+            s->state == SWAP_ACTIVATING_SIGKILL)
+                return 0;
 
-        r = swapoff(s->what);
-        swap_enter_dead(s, r >= 0 || errno == EINVAL);
+        assert(s->state == SWAP_ACTIVATING ||
+               s->state == SWAP_ACTIVE);
 
+        swap_enter_deactivating(s, true);
         return 0;
 }
 
@@ -478,6 +835,13 @@ static int swap_serialize(Unit *u, FILE *f, FDSet *fds) {
         assert(fds);
 
         unit_serialize_item(u, f, "state", swap_state_to_string(s->state));
+        unit_serialize_item(u, f, "failure", yes_no(s->failure));
+
+        if (s->control_pid > 0)
+                unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) s->control_pid);
+
+        if (s->control_command_id >= 0)
+                unit_serialize_item(u, f, "control-command", swap_exec_command_to_string(s->control_command_id));
 
         return 0;
 }
@@ -495,6 +859,32 @@ static int swap_deserialize_item(Unit *u, const char *key, const char *value, FD
                         log_debug("Failed to parse state value %s", value);
                 else
                         s->deserialized_state = state;
+        } else if (streq(key, "failure")) {
+                int b;
+
+                if ((b = parse_boolean(value)) < 0)
+                        log_debug("Failed to parse failure value %s", value);
+                else
+                        s->failure = b || s->failure;
+
+        } else if (streq(key, "control-pid")) {
+                pid_t pid;
+
+                if (parse_pid(value, &pid) < 0)
+                        log_debug("Failed to parse control-pid value %s", value);
+                else
+                        s->control_pid = pid;
+
+        } else if (streq(key, "control-command")) {
+                SwapExecCommand id;
+
+                if ((id = swap_exec_command_from_string(value)) < 0)
+                        log_debug("Failed to parse exec-command value %s", value);
+                else {
+                        s->control_command_id = id;
+                        s->control_command = s->exec_command + id;
+                }
+
         } else
                 log_debug("Unknown serialization key '%s'", key);
 
@@ -521,28 +911,132 @@ static bool swap_check_gc(Unit *u) {
         return s->from_etc_fstab || s->from_proc_swaps;
 }
 
-static int swap_load_proc_swaps(Manager *m) {
+static void swap_sigchld_event(Unit *u, pid_t pid, int code, int status) {
+        Swap *s = SWAP(u);
+        bool success;
+
+        assert(s);
+        assert(pid >= 0);
+
+        if (pid != s->control_pid)
+                return;
+
+        s->control_pid = 0;
+
+        success = is_clean_exit(code, status);
+        s->failure = s->failure || !success;
+
+        if (s->control_command) {
+                exec_status_exit(&s->control_command->exec_status, pid, code, status, s->exec_context.utmp_id);
+                s->control_command = NULL;
+                s->control_command_id = _SWAP_EXEC_COMMAND_INVALID;
+        }
+
+        log_full(success ? LOG_DEBUG : LOG_NOTICE,
+                 "%s swap process exited, code=%s status=%i", u->meta.id, sigchld_code_to_string(code), status);
+
+        switch (s->state) {
+
+        case SWAP_ACTIVATING:
+        case SWAP_ACTIVATING_SIGTERM:
+        case SWAP_ACTIVATING_SIGKILL:
+
+                if (success)
+                        swap_enter_active(s, true);
+                else
+                        swap_enter_dead(s, false);
+                break;
+
+        case SWAP_DEACTIVATING:
+        case SWAP_DEACTIVATING_SIGKILL:
+        case SWAP_DEACTIVATING_SIGTERM:
+
+                if (success)
+                        swap_enter_dead(s, true);
+                else
+                        swap_enter_dead(s, false);
+                break;
+
+        default:
+                assert_not_reached("Uh, control process died at wrong time.");
+        }
+
+        /* Notify clients about changed exit status */
+        unit_add_to_dbus_queue(u);
+
+        /* Request a reload of /proc/swaps, so that following units
+         * can follow our state change */
+        u->meta.manager->request_reload = true;
+}
+
+static void swap_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
+        Swap *s = SWAP(u);
+
+        assert(s);
+        assert(elapsed == 1);
+        assert(w == &s->timer_watch);
+
+        switch (s->state) {
+
+        case SWAP_ACTIVATING:
+                log_warning("%s activation timed out. Stopping.", u->meta.id);
+                swap_enter_signal(s, SWAP_ACTIVATING_SIGTERM, false);
+                break;
+
+        case SWAP_DEACTIVATING:
+                log_warning("%s deactivation timed out. Stopping.", u->meta.id);
+                swap_enter_signal(s, SWAP_DEACTIVATING_SIGTERM, false);
+                break;
+
+        case SWAP_ACTIVATING_SIGTERM:
+                log_warning("%s activation timed out. Killing.", u->meta.id);
+                swap_enter_signal(s, SWAP_ACTIVATING_SIGKILL, false);
+                break;
+
+        case SWAP_DEACTIVATING_SIGTERM:
+                log_warning("%s deactivation timed out. Killing.", u->meta.id);
+                swap_enter_signal(s, SWAP_DEACTIVATING_SIGKILL, false);
+                break;
+
+        case SWAP_ACTIVATING_SIGKILL:
+        case SWAP_DEACTIVATING_SIGKILL:
+                log_warning("%s swap process still around after SIGKILL. Ignoring.", u->meta.id);
+                swap_enter_dead(s, false);
+                break;
+
+        default:
+                assert_not_reached("Timeout at wrong time.");
+        }
+}
+
+static int swap_load_proc_swaps(Manager *m, bool set_flags) {
+        unsigned i;
+        int r = 0;
+
+        assert(m);
+
         rewind(m->proc_swaps);
 
         (void) fscanf(m->proc_swaps, "%*s %*s %*s %*s %*s\n");
 
-        for (;;) {
+        for (i = 1;; i++) {
                 char *dev = NULL, *d;
                 int prio = 0, k;
 
                 if ((k = fscanf(m->proc_swaps,
-                                "%ms " /* device/file */
-                                "%*s " /* type of swap */
-                                "%*s " /* swap size */
-                                "%*s " /* used */
+                                "%ms "  /* device/file */
+                                "%*s "  /* type of swap */
+                                "%*s "  /* swap size */
+                                "%*s "  /* used */
                                 "%i\n", /* priority */
                                 &dev, &prio)) != 2) {
 
                         if (k == EOF)
                                 break;
 
+                        log_warning("Failed to parse /proc/swaps:%u.", i);
                         free(dev);
-                        return -EBADMSG;
+                        continue;
                 }
 
                 d = cunescape(dev);
@@ -551,14 +1045,114 @@ static int swap_load_proc_swaps(Manager *m) {
                 if (!d)
                         return -ENOMEM;
 
-                k = swap_add_one(m, d, prio, false, false, false, true);
+                k = swap_process_new_swap(m, d, prio, set_flags);
                 free(d);
 
                 if (k < 0)
-                        return k;
+                        r = k;
         }
 
-        return 0;
+        return r;
+}
+
+int swap_dispatch_reload(Manager *m) {
+        Meta *meta;
+        int r;
+
+        assert(m);
+
+        if (_likely_(!m->request_reload))
+                return 0;
+
+        m->request_reload = false;
+
+        if ((r == swap_load_proc_swaps(m, true)) < 0) {
+                log_error("Failed to reread /proc/swaps: %s", strerror(-r));
+
+                /* Reset flags, just in case, for late calls */
+                LIST_FOREACH(units_per_type, meta, m->units_per_type[UNIT_SWAP]) {
+                        Swap *swap = (Swap*) meta;
+
+                        swap->is_active = swap->just_activated = false;
+                }
+
+                return 0;
+        }
+
+        manager_dispatch_load_queue(m);
+
+        LIST_FOREACH(units_per_type, meta, m->units_per_type[UNIT_SWAP]) {
+                Swap *swap = (Swap*) meta;
+
+                if (!swap->is_active) {
+                        /* This has just been deactivated */
+
+                        swap->from_proc_swaps = false;
+                        swap_unset_proc_swaps(swap);
+
+                        switch (swap->state) {
+
+                        case SWAP_ACTIVE:
+                                swap_enter_dead(swap, true);
+                                break;
+
+                        default:
+                                swap_set_state(swap, swap->state);
+                                break;
+                        }
+
+                } else if (swap->just_activated) {
+
+                        /* New swap entry */
+
+                        switch (swap->state) {
+
+                        case SWAP_DEAD:
+                        case SWAP_FAILED:
+                                swap_enter_active(swap, true);
+                                break;
+
+                        default:
+                                /* Nothing really changed, but let's
+                                 * issue an notification call
+                                 * nonetheless, in case somebody is
+                                 * waiting for this. */
+                                swap_set_state(swap, swap->state);
+                                break;
+                        }
+                }
+
+                /* Reset the flags for later calls */
+                swap->is_active = swap->just_activated = false;
+        }
+
+        return 1;
+}
+
+static Unit *swap_following(Unit *u) {
+        Swap *s = SWAP(u);
+        Swap *other, *first = NULL;
+
+        assert(s);
+
+        if (streq_ptr(s->what, s->parameters_proc_swaps.what))
+                return NULL;
+
+        /* Make everybody follow the unit that's named after the swap
+         * device in the kernel */
+
+        LIST_FOREACH_AFTER(same_proc_swaps, other, s)
+                if (streq_ptr(other->what, other->parameters_proc_swaps.what))
+                        return UNIT(other);
+
+        LIST_FOREACH_BEFORE(same_proc_swaps, other, s) {
+                if (streq_ptr(other->what, other->parameters_proc_swaps.what))
+                        return UNIT(other);
+
+                first = other;
+        }
+
+        return UNIT(first);
 }
 
 static void swap_shutdown(Manager *m) {
@@ -568,6 +1162,9 @@ static void swap_shutdown(Manager *m) {
                 fclose(m->proc_swaps);
                 m->proc_swaps = NULL;
         }
+
+        hashmap_free(m->swaps_by_proc_swaps);
+        m->swaps_by_proc_swaps = NULL;
 }
 
 static int swap_enumerate(Manager *m) {
@@ -578,7 +1175,9 @@ static int swap_enumerate(Manager *m) {
                 if (!(m->proc_swaps = fopen("/proc/swaps", "re")))
                         return -errno;
 
-        if ((r = swap_load_proc_swaps(m)) < 0)
+        /* We rely on mount.c to load /etc/fstab for us */
+
+        if ((r = swap_load_proc_swaps(m, false)) < 0)
                 swap_shutdown(m);
 
         return r;
@@ -591,19 +1190,35 @@ static void swap_reset_failed(Unit *u) {
 
         if (s->state == SWAP_FAILED)
                 swap_set_state(s, SWAP_DEAD);
+
+        s->failure = false;
 }
 
 static const char* const swap_state_table[_SWAP_STATE_MAX] = {
         [SWAP_DEAD] = "dead",
+        [SWAP_ACTIVATING] = "activating",
         [SWAP_ACTIVE] = "active",
+        [SWAP_DEACTIVATING] = "deactivating",
+        [SWAP_ACTIVATING_SIGTERM] = "activating-sigterm",
+        [SWAP_ACTIVATING_SIGKILL] = "activating-sigkill",
+        [SWAP_DEACTIVATING_SIGTERM] = "deactivating-sigterm",
+        [SWAP_DEACTIVATING_SIGKILL] = "deactivating-sigkill",
         [SWAP_FAILED] = "failed"
 };
 
 DEFINE_STRING_TABLE_LOOKUP(swap_state, SwapState);
 
+static const char* const swap_exec_command_table[_SWAP_EXEC_COMMAND_MAX] = {
+        [SWAP_EXEC_ACTIVATE] = "ExecActivate",
+        [SWAP_EXEC_DEACTIVATE] = "ExecDeactivate",
+};
+
+DEFINE_STRING_TABLE_LOOKUP(swap_exec_command, SwapExecCommand);
+
 const UnitVTable swap_vtable = {
         .suffix = ".swap",
 
+        .no_alias = true,
         .no_instances = true,
         .no_isolate = true,
         .show_status = true,
@@ -627,11 +1242,16 @@ const UnitVTable swap_vtable = {
 
         .check_gc = swap_check_gc,
 
+        .sigchld_event = swap_sigchld_event,
+        .timer_event = swap_timer_event,
+
+        .reset_failed = swap_reset_failed,
+
         .bus_interface = "org.freedesktop.systemd1.Swap",
         .bus_message_handler = bus_swap_message_handler,
         .bus_invalidating_properties =  bus_swap_invalidating_properties,
 
-        .reset_failed = swap_reset_failed,
+        .following = swap_following,
 
         .enumerate = swap_enumerate,
         .shutdown = swap_shutdown
diff --git a/src/swap.h b/src/swap.h
index 9c249ca43c..8a60416900 100644
--- a/src/swap.h
+++ b/src/swap.h
@@ -29,12 +29,25 @@ typedef struct Swap Swap;
 
 typedef enum SwapState {
         SWAP_DEAD,
+        SWAP_ACTIVATING,
         SWAP_ACTIVE,
+        SWAP_DEACTIVATING,
+        SWAP_ACTIVATING_SIGTERM,
+        SWAP_ACTIVATING_SIGKILL,
+        SWAP_DEACTIVATING_SIGTERM,
+        SWAP_DEACTIVATING_SIGKILL,
         SWAP_FAILED,
         _SWAP_STATE_MAX,
         _SWAP_STATE_INVALID = -1
 } SwapState;
 
+typedef enum SwapExecCommand {
+        SWAP_EXEC_ACTIVATE,
+        SWAP_EXEC_DEACTIVATE,
+        _SWAP_EXEC_COMMAND_MAX,
+        _SWAP_EXEC_COMMAND_INVALID = -1
+} SwapExecCommand;
+
 typedef struct SwapParameters {
         char *what;
         int priority;
@@ -46,27 +59,55 @@ typedef struct SwapParameters {
 struct Swap {
         Meta meta;
 
+        char *what;
+
         SwapParameters parameters_etc_fstab;
         SwapParameters parameters_proc_swaps;
         SwapParameters parameters_fragment;
 
-        char *what;
-
-        SwapState state, deserialized_state;
-
         bool from_etc_fstab:1;
         bool from_proc_swaps:1;
         bool from_fragment:1;
+
+        bool failure:1;
+
+        /* Used while looking for swaps that vanished or got added
+         * from/to /proc/swaps */
+        bool is_active:1;
+        bool just_activated:1;
+
+        usec_t timeout_usec;
+
+        ExecCommand exec_command[_SWAP_EXEC_COMMAND_MAX];
+        ExecContext exec_context;
+
+        SwapState state, deserialized_state;
+
+        ExecCommand* control_command;
+        SwapExecCommand control_command_id;
+        pid_t control_pid;
+
+        Watch timer_watch;
+
+        /* In order to be able to distuingish dependencies on
+        different device nodes we might end up creating multiple
+        devices for the same swap. We chain them up here. */
+
+        LIST_FIELDS(struct Swap, same_proc_swaps);
 };
 
 extern const UnitVTable swap_vtable;
 
-int swap_add_one(Manager *m, const char *what, int prio, bool no_auto, bool no_fail, bool handle, bool from_proc_swap);
+int swap_add_one(Manager *m, const char *what, const char *what_proc_swaps, int prio, bool no_auto, bool no_fail, bool handle, bool set_flags);
 
 int swap_add_one_mount_link(Swap *s, Mount *m);
 
+int swap_dispatch_reload(Manager *m);
+
 const char* swap_state_to_string(SwapState i);
 SwapState swap_state_from_string(const char *s);
 
+const char* swap_exec_command_to_string(SwapExecCommand i);
+SwapExecCommand swap_exec_command_from_string(const char *s);
 
 #endif
diff --git a/src/unit.c b/src/unit.c
index a45a1f7725..9fc9be5c79 100644
--- a/src/unit.c
+++ b/src/unit.c
@@ -376,7 +376,6 @@ void unit_free(Unit *u) {
         set_free_free(u->meta.names);
 
         free(u->meta.instance);
-
         free(u);
 }