X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=name.c;h=33d7f347b5a6f2d076bbba200eacd279a9eb8653;hp=80ce5d5b36a6a2bff20d35b3e9d124506f95ea02;hb=542563babda739f7aee468c3eaaab6315ffa4224;hpb=a66d02c3290008d50b2b52f84cfbf46a546ba831

diff --git a/name.c b/name.c
index 80ce5d5b3..33d7f347b 100644
--- a/name.c
+++ b/name.c
@@ -8,24 +8,29 @@
 #include "name.h"
 #include "macro.h"
 #include "strv.h"
+#include "load-fragment.h"
+#include "load-dropin.h"
+
+static const NameVTable * const name_vtable[_NAME_TYPE_MAX] = {
+        [NAME_SERVICE] = &service_vtable,
+        [NAME_TIMER] = &timer_vtable,
+        [NAME_SOCKET] = &socket_vtable,
+        [NAME_MILESTONE] = &milestone_vtable,
+        [NAME_DEVICE] = &device_vtable,
+        [NAME_MOUNT] = &mount_vtable,
+        [NAME_AUTOMOUNT] = &automount_vtable,
+        [NAME_SNAPSHOT] = &snapshot_vtable
+};
+
+#define NAME_VTABLE(n) name_vtable[(n)->meta.type]
 
 NameType name_type_from_string(const char *n) {
         NameType t;
-        static const char* suffixes[_NAME_TYPE_MAX] = {
-                [NAME_SERVICE] = ".service",
-                [NAME_TIMER] = ".timer",
-                [NAME_SOCKET] = ".socket",
-                [NAME_MILESTONE] = ".milestone",
-                [NAME_DEVICE] = ".device",
-                [NAME_MOUNT] = ".mount",
-                [NAME_AUTOMOUNT] = ".automount",
-                [NAME_SNAPSHOT] = ".snapshot",
-        };
 
         assert(n);
 
         for (t = 0; t < _NAME_TYPE_MAX; t++)
-                if (endswith(n, suffixes[t]))
+                if (endswith(n, name_vtable[t]->suffix))
                         return t;
 
         return _NAME_TYPE_INVALID;
@@ -43,6 +48,9 @@ bool name_is_valid(const char *n) {
 
         assert(n);
 
+        if (strlen(n) >= NAME_MAX)
+                return false;
+
         t = name_type_from_string(n);
         if (t < 0 || t >= _NAME_TYPE_MAX)
                 return false;
@@ -73,38 +81,65 @@ Name *name_new(Manager *m) {
         /* Not much initialization happening here at this time */
         n->meta.manager = m;
         n->meta.type = _NAME_TYPE_INVALID;
-        n->meta.state = NAME_STUB;
 
         /* We don't link the name here, that is left for name_link() */
 
         return n;
 }
 
+/* FIXME: Does not rollback on failure! */
+int name_link_names(Name *n, bool replace) {
+        char *t;
+        void *state;
+        int r;
+
+        assert(n);
+
+        if (!n->meta.linked)
+                return 0;
+
+        /* Link all names that aren't linked yet. */
+
+        SET_FOREACH(t, n->meta.names, state)
+                if (replace) {
+                        if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
+                                return r;
+                } else {
+                        if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0)
+                                return r;
+                }
+
+        return 0;
+}
+
 int name_link(Name *n) {
-        char **t;
         int r;
-        void *state;
 
         assert(n);
         assert(!set_isempty(n->meta.names));
         assert(!n->meta.linked);
 
-        SET_FOREACH(t, n->meta.names, state)
-                if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0)
-                        goto fail;
-
-        if (n->meta.state == NAME_STUB)
-                LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
+        if ((r = name_sanitize(n)) < 0)
+                return r;
 
         n->meta.linked = true;
 
-        return 0;
+        if ((r = name_link_names(n, false)) < 0) {
+                char *t;
+                void *state;
 
-fail:
-        SET_FOREACH(t, n->meta.names, state)
-                assert_se(hashmap_remove(n->meta.manager->names, t) == n);
+                /* Rollback the registered names */
+                SET_FOREACH(t, n->meta.names, state)
+                        hashmap_remove_value(n->meta.manager->names, t, n);
 
-        return r;
+                n->meta.linked = false;
+                return r;
+        }
+
+        if (n->meta.load_state == NAME_STUB)
+                LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
+
+        return 0;
 }
 
 static void bidi_set_free(Name *name, Set *s) {
@@ -134,13 +169,13 @@ void name_free(Name *name) {
 
         /* Detach from next 'bigger' objects */
         if (name->meta.linked) {
-                char **t;
+                char *t;
                 void *state;
 
                 SET_FOREACH(t, name->meta.names, state)
-                        assert_se(hashmap_remove(name->meta.manager->names, t) == name);
+                        hashmap_remove_value(name->meta.manager->names, t, name);
 
-                if (name->meta.state == NAME_STUB)
+                if (name->meta.load_state == NAME_STUB)
                         LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta);
         }
 
@@ -151,41 +186,8 @@ void name_free(Name *name) {
         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
                 bidi_set_free(name, name->meta.dependencies[d]);
 
-        switch (name->meta.type) {
-
-                case NAME_SOCKET: {
-                        unsigned i;
-                        Socket *s = SOCKET(name);
-
-                        for (i = 0; i < s->n_fds; i++)
-                                nointr_close(s->fds[i]);
-                        break;
-                }
-
-                case NAME_DEVICE: {
-                        Device *d = DEVICE(name);
-
-                        free(d->sysfs);
-                        break;
-                }
-
-                case NAME_MOUNT: {
-                        Mount *m = MOUNT(name);
-
-                        free(m->path);
-                        break;
-                }
-
-                case NAME_AUTOMOUNT: {
-                        Automount *a = AUTOMOUNT(name);
-
-                        free(a->path);
-                        break;
-                }
-
-                default:
-                        ;
-        }
+        if (NAME_VTABLE(name)->free_hook)
+                NAME_VTABLE(name)->free_hook(name);
 
         free(name->meta.description);
 
@@ -196,194 +198,504 @@ void name_free(Name *name) {
         free(name);
 }
 
-bool name_is_ready(Name *name) {
-
+NameActiveState name_active_state(Name *name) {
         assert(name);
 
-        if (name->meta.state != NAME_LOADED)
-                return false;
+        if (name->meta.load_state != NAME_LOADED)
+                return NAME_INACTIVE;
 
-        assert(name->meta.type < _NAME_TYPE_MAX);
+        return NAME_VTABLE(name)->active_state(name);
+}
 
-        switch (name->meta.type) {
-                case NAME_SERVICE: {
-                        Service *s = SERVICE(name);
+static int ensure_in_set(Set **s, void *data) {
+        int r;
 
-                        return
-                                s->state == SERVICE_RUNNING ||
-                                s->state == SERVICE_RELOAD_PRE ||
-                                s->state == SERVICE_RELOAD ||
-                                s->state == SERVICE_RELOAD_POST;
-                }
+        assert(s);
+        assert(data);
 
-                case NAME_TIMER: {
-                        Timer *t = TIMER(name);
+        if (!*s)
+                if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
+                        return -ENOMEM;
 
-                        return
-                                t->state == TIMER_WAITING ||
-                                t->state == TIMER_RUNNING;
-                }
+        if ((r = set_put(*s, data)) < 0)
+                if (r != -EEXIST)
+                        return r;
 
-                case NAME_SOCKET: {
-                        Socket *s = SOCKET(name);
+        return 0;
+}
 
-                        return
-                                s->state == SOCKET_LISTENING ||
-                                s->state == SOCKET_RUNNING;
-                }
+static int ensure_merge(Set **s, Set *other) {
 
-                case NAME_MILESTONE:
-                        return MILESTONE(name)->state == MILESTONE_ACTIVE;
+        if (!other)
+                return 0;
 
-                case NAME_DEVICE:
-                        return DEVICE(name)->state == DEVICE_AVAILABLE;
+        if (*s)
+                return set_merge(*s, other);
 
-                case NAME_MOUNT:
-                        return MOUNT(name)->state == MOUNT_MOUNTED;
+        if (!(*s = set_copy(other)))
+                return -ENOMEM;
 
-                case NAME_AUTOMOUNT: {
-                        Automount *a = AUTOMOUNT(name);
+        return 0;
+}
 
-                        return
-                                a->state == AUTOMOUNT_WAITING ||
-                                a->state == AUTOMOUNT_RUNNING;
-                }
+/* FIXME: Does not rollback on failure! */
+int name_merge(Name *name, Name *other) {
+        int r;
+        NameDependency d;
 
-                case NAME_SNAPSHOT:
-                        return SNAPSHOT(name)->state == SNAPSHOT_ACTIVE;
+        assert(name);
+        assert(other);
+        assert(name->meta.manager == other->meta.manager);
 
+        /* This merges 'other' into 'name'. FIXME: This does not
+         * rollback on failure. */
 
-                case _NAME_TYPE_MAX:
-                case _NAME_TYPE_INVALID:
-                        ;
-        }
+        if (name->meta.type != other->meta.type)
+                return -EINVAL;
 
-        assert_not_reached("Unknown name type.");
-        return false;
-}
+        if (other->meta.load_state != NAME_STUB)
+                return -EINVAL;
 
-static int ensure_in_set(Set **s, void *data) {
-        int r;
+        /* Merge names */
+        if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0)
+                return r;
 
-        assert(s);
-        assert(data);
+        /* Merge dependencies */
+        for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
+                if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
+                        return r;
 
-        if (!*s)
-                if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
-                        return -ENOMEM;
+        /* Hookup new deps and names */
+        if (name->meta.linked) {
+                if ((r = name_sanitize(name)) < 0)
+                        return r;
 
-        if ((r = set_put(*s, data) < 0))
-                if (r != -EEXIST)
+                if ((r = name_link_names(name, true)) < 0)
                         return r;
+        }
 
         return 0;
 }
 
-int name_augment(Name *n) {
+/* FIXME: Does not rollback on failure! */
+static int augment(Name *n) {
         int r;
         void* state;
         Name *other;
 
         assert(n);
 
-        /* Adds in the missing links to make all dependencies bidirectional */
+        /* Adds in the missing links to make all dependencies
+         * bidirectional. */
 
         SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n) < 0))
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n)) < 0)
                         return r;
         SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n) < 0))
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n)) < 0)
                         return r;
 
         SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n) < 0))
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n)) < 0)
                         return r;
 
         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n) < 0))
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
                         return r;
         SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n) < 0))
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
                         return r;
 
-        SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n) < 0))
-                        return r;
         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n) < 0))
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_SOFT_REQUIRED_BY], n)) < 0)
                         return r;
-        SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUISITE], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n) < 0))
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
+                if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
                         return r;
 
-        return r;
+        return 0;
 }
 
-static int ensure_merge(Set **s, Set *other) {
+int name_sanitize(Name *n) {
+        NameDependency d;
 
-        if (!other)
-                return 0;
+        assert(n);
 
-        if (*s)
-                return set_merge(*s, other);
+        /* Remove loops */
+        for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
+                set_remove(n->meta.dependencies[d], n);
 
-        if (!(*s = set_copy(other)))
-                return -ENOMEM;
+        return augment(n);
+}
 
-        return 0;
+const char* name_id(Name *n) {
+        assert(n);
+
+        return set_first(n->meta.names);
 }
 
-int name_merge(Name *name, Name *other) {
-        int r;
+const char *name_description(Name *n) {
+        assert(n);
+
+        if (n->meta.description)
+                return n->meta.description;
+
+        return name_id(n);
+}
+
+void name_dump(Name *n, FILE *f, const char *prefix) {
+
+        static const char* const load_state_table[_NAME_LOAD_STATE_MAX] = {
+                [NAME_STUB] = "stub",
+                [NAME_LOADED] = "loaded",
+                [NAME_FAILED] = "failed"
+        };
+
+        static const char* const active_state_table[_NAME_ACTIVE_STATE_MAX] = {
+                [NAME_ACTIVE] = "active",
+                [NAME_INACTIVE] = "inactive",
+                [NAME_ACTIVATING] = "activating",
+                [NAME_DEACTIVATING] = "deactivating"
+        };
+
+        static const char* const dependency_table[_NAME_DEPENDENCY_MAX] = {
+                [NAME_REQUIRES] = "Requires",
+                [NAME_SOFT_REQUIRES] = "SoftRequires",
+                [NAME_WANTS] = "Wants",
+                [NAME_REQUISITE] = "Requisite",
+                [NAME_SOFT_REQUISITE] = "SoftRequisite",
+                [NAME_REQUIRED_BY] = "RequiredBy",
+                [NAME_SOFT_REQUIRED_BY] = "SoftRequiredBy",
+                [NAME_WANTED_BY] = "WantedBy",
+                [NAME_CONFLICTS] = "Conflicts",
+                [NAME_BEFORE] = "Before",
+                [NAME_AFTER] = "After",
+        };
+
+        void *state;
+        char *t;
         NameDependency d;
 
+        assert(n);
+
+        if (!prefix)
+                prefix = "";
+
+        fprintf(f,
+                "%sName %s:\n"
+                "%s\tDescription: %s\n"
+                "%s\tName Load State: %s\n"
+                "%s\tName Active State: %s\n",
+                prefix, name_id(n),
+                prefix, name_description(n),
+                prefix, load_state_table[n->meta.load_state],
+                prefix, active_state_table[name_active_state(n)]);
+
+        SET_FOREACH(t, n->meta.names, state)
+                fprintf(f, "%s\tName: %s\n", prefix, t);
+
+        for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) {
+                void *state;
+                Name *other;
+
+                if (set_isempty(n->meta.dependencies[d]))
+                        continue;
+
+                SET_FOREACH(other, n->meta.dependencies[d], state)
+                        fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], name_id(other));
+        }
+
+        if (NAME_VTABLE(n)->dump)
+                NAME_VTABLE(n)->dump(n, f, prefix);
+
+        if (n->meta.job) {
+                char *p;
+
+                if (asprintf(&p, "%s\t", prefix) >= 0)
+                        prefix = p;
+                else
+                        p = NULL;
+
+                job_dump(n->meta.job, f, prefix);
+                free(p);
+        }
+}
+
+static int verify_type(Name *name) {
+        char *n;
+        void *state;
+
         assert(name);
-        assert(other);
 
-        assert(name->meta.manager == other->meta.manager);
+        /* Checks that all aliases of this name have the same and valid type */
 
-        if (name->meta.type != other->meta.type)
-                return -EINVAL;
+        SET_FOREACH(n, name->meta.names, state) {
+                NameType t;
+
+                if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID)
+                        return -EINVAL;
+
+                if (name->meta.type == _NAME_TYPE_INVALID) {
+                        name->meta.type = t;
+                        continue;
+                }
+
+                if (name->meta.type != t)
+                        return -EINVAL;
+        }
 
-        if (other->meta.state != NAME_STUB)
+        if (name->meta.type == _NAME_TYPE_INVALID)
                 return -EINVAL;
 
-        /* Merge names */
-        if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0)
+        return 0;
+}
+
+/* Common implementation for multiple backends */
+int name_load_fragment_and_dropin(Name *n) {
+        int r;
+
+        assert(n);
+
+        /* Load a .socket file */
+        if ((r = name_load_fragment(n)) < 0)
                 return r;
 
-        /* Merge dependencies */
-        for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
-                if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
-                        return r;
+        /* Load drop-in directory data */
+        if ((r = name_load_dropin(n)) < 0)
+                return r;
 
         return 0;
 }
 
-const char* name_id(Name *n) {
+int name_load(Name *name) {
+        int r;
+
+        assert(name);
+
+        if (name->meta.load_state != NAME_STUB)
+                return 0;
+
+        if ((r = verify_type(name)) < 0)
+                return r;
+
+        if (NAME_VTABLE(name)->load)
+                if ((r = NAME_VTABLE(name)->load(name)) < 0)
+                        goto fail;
+
+        if ((r = name_sanitize(name)) < 0)
+                goto fail;
+
+        if ((r = name_link_names(name, false)) < 0)
+                goto fail;
+
+        name->meta.load_state = NAME_LOADED;
+        return 0;
+
+fail:
+        name->meta.load_state = NAME_FAILED;
+        return r;
+}
+
+/* Errors:
+ *         -EBADR:    This name type does not support starting.
+ *         -EALREADY: Name is already started.
+ *         -EAGAIN:   An operation is already in progress. Retry later.
+ */
+int name_start(Name *n) {
+        NameActiveState state;
+
         assert(n);
 
-        return set_first(n->meta.names);
+        if (!NAME_VTABLE(n)->start)
+                return -EBADR;
+
+        state = name_active_state(n);
+        if (NAME_IS_ACTIVE_OR_RELOADING(state))
+                return -EALREADY;
+
+        if (state == NAME_ACTIVATING)
+                return 0;
+
+        return NAME_VTABLE(n)->start(n);
 }
 
-void name_dump(Name *n, FILE *f) {
+bool name_type_can_start(NameType t) {
+        assert(t >= 0 && t < _NAME_TYPE_MAX);
 
-        static const char* const state_table[_NAME_STATE_MAX] = {
-                [NAME_STUB] = "STUB",
-                [NAME_LOADED] = "LOADED",
-                [NAME_FAILED] = "FAILED"
-        };
+        return !!name_vtable[t]->start;
+}
+
+/* Errors:
+ *         -EBADR:    This name type does not support stopping.
+ *         -EALREADY: Name is already stopped.
+ *         -EAGAIN:   An operation is already in progress. Retry later.
+ */
+int name_stop(Name *n) {
+        NameActiveState state;
+
+        assert(n);
+
+        if (!NAME_VTABLE(n)->stop)
+                return -EBADR;
+
+        state = name_active_state(n);
+        if (state == NAME_INACTIVE)
+                return -EALREADY;
+
+        if (state == NAME_DEACTIVATING)
+                return 0;
+
+        return NAME_VTABLE(n)->stop(n);
+}
+
+/* Errors:
+ *         -EBADR:    This name type does not support reloading.
+ *         -ENOEXEC:  Name is not started.
+ *         -EAGAIN:   An operation is already in progress. Retry later.
+ */
+int name_reload(Name *n) {
+        NameActiveState state;
 
         assert(n);
 
-        fprintf(stderr,
-                "Name %s (%s), state %s\n",
-                name_id(n),
-                n->meta.description ? n->meta.description : name_id(n),
-                state_table[n->meta.state]);
+        if (!NAME_VTABLE(n)->reload)
+                return -EBADR;
+
+        state = name_active_state(n);
+        if (name_active_state(n) == NAME_ACTIVE_RELOADING)
+                return -EALREADY;
+
+        if (name_active_state(n) != NAME_ACTIVE)
+                return -ENOEXEC;
+
+        return NAME_VTABLE(n)->reload(n);
+}
+
+bool name_type_can_reload(NameType t) {
+        assert(t >= 0 && t < _NAME_TYPE_MAX);
+        return !!name_vtable[t]->reload;
+}
+
+static void retroactively_start_dependencies(Name *n) {
+        void *state;
+        Name *other;
+
+        assert(n);
+        assert(NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(n)));
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
+                if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
+                        manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
+                if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
+                        manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
+                if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
+                        manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
+                if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
+                        manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
+                if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
+                        manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
+}
+
+static void retroactively_stop_dependencies(Name *n) {
+        void *state;
+        Name *other;
+
+        assert(n);
+        assert(NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(n)));
+
+        SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], state)
+                if (!NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(other)))
+                        manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
+}
+
+int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
+        assert(n);
+        assert(os < _NAME_ACTIVE_STATE_MAX);
+        assert(ns < _NAME_ACTIVE_STATE_MAX);
+        assert(!(os == NAME_ACTIVE && ns == NAME_ACTIVATING));
+        assert(!(os == NAME_INACTIVE && ns == NAME_DEACTIVATING));
+
+        if (os == ns)
+                return 0;
 
         if (n->meta.job) {
-                fprintf(f, "\t▶ ");
-                job_dump(n->meta.job, f);
+
+                if (n->meta.job->state == JOB_WAITING)
+
+                        /* So we reached a different state for this
+                         * job. Let's see if we can run it now if it
+                         * failed previously due to EAGAIN. */
+                        job_run_and_invalidate(n->meta.job);
+
+                else {
+                        assert(n->meta.job->state == JOB_RUNNING);
+
+                        /* Let's check of this state change
+                         * constitutes a finished job, or maybe
+                         * cotradicts a running job and hence needs to
+                         * invalidate jobs. */
+
+                        switch (n->meta.job->type) {
+
+                                case JOB_START:
+                                case JOB_VERIFY_ACTIVE:
+
+                                        if (NAME_IS_ACTIVE_OR_RELOADING(ns))
+                                                return job_finish_and_invalidate(n->meta.job, true);
+                                        else if (ns == NAME_ACTIVATING)
+                                                return 0;
+                                        else
+                                                job_finish_and_invalidate(n->meta.job, false);
+
+                                        break;
+
+                                case JOB_RELOAD:
+                                case JOB_RELOAD_OR_START:
+
+                                        if (ns == NAME_ACTIVE)
+                                                return job_finish_and_invalidate(n->meta.job, true);
+                                        else if (ns == NAME_ACTIVATING || ns == NAME_ACTIVE_RELOADING)
+                                                return 0;
+                                        else
+                                                job_finish_and_invalidate(n->meta.job, false);
+
+                                        break;
+
+                                case JOB_STOP:
+                                case JOB_RESTART:
+                                case JOB_TRY_RESTART:
+
+                                        if (ns == NAME_INACTIVE)
+                                                return job_finish_and_invalidate(n->meta.job, true);
+                                        else if (ns == NAME_DEACTIVATING)
+                                                return 0;
+                                        else
+                                                job_finish_and_invalidate(n->meta.job, false);
+
+                                        break;
+
+                                default:
+                                        assert_not_reached("Job type unknown");
+                        }
+                }
         }
+
+        /* If this state change happened without being requested by a
+         * job, then let's retroactively start or stop dependencies */
+
+        if (NAME_IS_INACTIVE_OR_DEACTIVATING(os) && NAME_IS_ACTIVE_OR_ACTIVATING(ns))
+                retroactively_start_dependencies(n);
+        else if (NAME_IS_ACTIVE_OR_ACTIVATING(os) && NAME_IS_INACTIVE_OR_DEACTIVATING(ns))
+                retroactively_stop_dependencies(n);
+
+        return 0;
 }