X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=name.c;h=05eafab6b207bb162998a6237f0b5ac139904f0b;hp=5dba01055bc1b7bd56f3ebd9ff75aa9ab2ed51c7;hb=c22cbe2672db2c95647c9412cfb4331d2be279a7;hpb=5cb5a6ffc33667c93e9bc3572534dcaa684046e3

diff --git a/name.c b/name.c
index 5dba01055..05eafab6b 100644
--- a/name.c
+++ b/name.c
@@ -3,6 +3,9 @@
 #include <assert.h>
 #include <errno.h>
 #include <string.h>
+#include <sys/epoll.h>
+#include <sys/timerfd.h>
+#include <sys/poll.h>
 
 #include "set.h"
 #include "name.h"
@@ -10,20 +13,19 @@
 #include "strv.h"
 #include "load-fragment.h"
 #include "load-dropin.h"
+#include "log.h"
 
-static const NameVTable * const name_vtable[_NAME_TYPE_MAX] = {
+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_TARGET] = &target_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;
 
@@ -78,7 +80,6 @@ Name *name_new(Manager *m) {
                 return NULL;
         }
 
-        /* Not much initialization happening here at this time */
         n->meta.manager = m;
         n->meta.type = _NAME_TYPE_INVALID;
 
@@ -87,10 +88,40 @@ Name *name_new(Manager *m) {
         return n;
 }
 
+int name_add_name(Name *n, const char *text) {
+        NameType t;
+        char *s;
+        int r;
+
+        assert(n);
+        assert(text);
+
+        if ((t = name_type_from_string(text)) == _NAME_TYPE_INVALID)
+                return -EINVAL;
+
+        if (n->meta.type != _NAME_TYPE_INVALID && t != n->meta.type)
+                return -EINVAL;
+
+        if (!(s = strdup(text)))
+                return -ENOMEM;
+
+        if ((r = set_put(n->meta.names, s)) < 0) {
+                free(s);
+                return r;
+        }
+
+        n->meta.type = t;
+
+        if (!n->meta.id)
+                n->meta.id = s;
+
+        return 0;
+}
+
 /* FIXME: Does not rollback on failure! */
 int name_link_names(Name *n, bool replace) {
         char *t;
-        void *state;
+        Iterator i;
         int r;
 
         assert(n);
@@ -100,7 +131,7 @@ int name_link_names(Name *n, bool replace) {
 
         /* Link all names that aren't linked yet. */
 
-        SET_FOREACH(t, n->meta.names, state)
+        SET_FOREACH(t, n->meta.names, i)
                 if (replace) {
                         if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
                                 return r;
@@ -126,24 +157,26 @@ int name_link(Name *n) {
 
         if ((r = name_link_names(n, false)) < 0) {
                 char *t;
-                void *state;
+                Iterator i;
 
                 /* Rollback the registered names */
-                SET_FOREACH(t, n->meta.names, state)
+                SET_FOREACH(t, n->meta.names, i)
                         hashmap_remove_value(n->meta.manager->names, t, n);
 
                 n->meta.linked = false;
                 return r;
         }
 
-        if (n->meta.load_state == NAME_STUB)
-                LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
+        if (n->meta.load_state == NAME_STUB) {
+                LIST_PREPEND(Meta, load_queue, n->meta.manager->load_queue, &n->meta);
+                n->meta.in_load_queue = true;
+        }
 
         return 0;
 }
 
 static void bidi_set_free(Name *name, Set *s) {
-        void *state;
+        Iterator i;
         Name *other;
 
         assert(name);
@@ -151,11 +184,13 @@ static void bidi_set_free(Name *name, Set *s) {
         /* Frees the set and makes sure we are dropped from the
          * inverse pointers */
 
-        SET_FOREACH(other, s, state) {
-                NameDependency d;
+        if (name->meta.linked) {
+                SET_FOREACH(other, s, i) {
+                        NameDependency d;
 
-                for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
-                        set_remove(other->meta.dependencies[d], name);
+                        for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
+                                set_remove(other->meta.dependencies[d], name);
+                }
         }
 
         set_free(s);
@@ -170,15 +205,19 @@ void name_free(Name *name) {
         /* Detach from next 'bigger' objects */
         if (name->meta.linked) {
                 char *t;
-                void *state;
+                Iterator i;
 
-                SET_FOREACH(t, name->meta.names, state)
+                SET_FOREACH(t, name->meta.names, i)
                         hashmap_remove_value(name->meta.manager->names, t, name);
 
-                if (name->meta.load_state == NAME_STUB)
-                        LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta);
+                if (name->meta.in_load_queue)
+                        LIST_REMOVE(Meta, load_queue, name->meta.manager->load_queue, &name->meta);
         }
 
+        if (name->meta.load_state == NAME_LOADED)
+                if (NAME_VTABLE(name)->done)
+                        NAME_VTABLE(name)->done(name);
+
         /* Free data and next 'smaller' objects */
         if (name->meta.job)
                 job_free(name->meta.job);
@@ -186,9 +225,6 @@ void name_free(Name *name) {
         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
                 bidi_set_free(name, name->meta.dependencies[d]);
 
-        if (NAME_VTABLE(name)->free_hook)
-                NAME_VTABLE(name)->free_hook(name);
-
         free(name->meta.description);
 
         while ((t = set_steal_first(name->meta.names)))
@@ -207,23 +243,6 @@ NameActiveState name_active_state(Name *name) {
         return NAME_VTABLE(name)->active_state(name);
 }
 
-static int ensure_in_set(Set **s, void *data) {
-        int r;
-
-        assert(s);
-        assert(data);
-
-        if (!*s)
-                if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
-                        return -ENOMEM;
-
-        if ((r = set_put(*s, data)) < 0)
-                if (r != -EEXIST)
-                        return r;
-
-        return 0;
-}
-
 static int ensure_merge(Set **s, Set *other) {
 
         if (!other)
@@ -262,6 +281,7 @@ int name_merge(Name *name, Name *other) {
 
         /* Merge dependencies */
         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
+                /* fixme, the inverse mapping is missing */
                 if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
                         return r;
 
@@ -277,46 +297,6 @@ int name_merge(Name *name, Name *other) {
         return 0;
 }
 
-/* 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. */
-
-        SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state)
-                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)
-                        return r;
-
-        SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
-                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)
-                        return r;
-        SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
-                        return r;
-
-        SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
-                if ((r = ensure_in_set(&other->meta.dependencies[NAME_SOFT_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;
-
-        return 0;
-}
-
 int name_sanitize(Name *n) {
         NameDependency d;
 
@@ -326,12 +306,15 @@ int name_sanitize(Name *n) {
         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
                 set_remove(n->meta.dependencies[d], n);
 
-        return augment(n);
+        return 0;
 }
 
 const char* name_id(Name *n) {
         assert(n);
 
+        if (n->meta.id)
+                return n->meta.id;
+
         return set_first(n->meta.names);
 }
 
@@ -367,22 +350,27 @@ void name_dump(Name *n, FILE *f, const char *prefix) {
                 [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;
+        Iterator i;
+        char *prefix2;
 
         assert(n);
 
         if (!prefix)
                 prefix = "";
+        prefix2 = strappend(prefix, "\t");
+        if (!prefix2)
+                prefix2 = "";
 
         fprintf(f,
-                "%sName %s:\n"
+                "%s→ Name %s:\n"
                 "%s\tDescription: %s\n"
                 "%s\tName Load State: %s\n"
                 "%s\tName Active State: %s\n",
@@ -391,45 +379,37 @@ void name_dump(Name *n, FILE *f, const char *prefix) {
                 prefix, load_state_table[n->meta.load_state],
                 prefix, active_state_table[name_active_state(n)]);
 
-        SET_FOREACH(t, n->meta.names, state)
+        SET_FOREACH(t, n->meta.names, i)
                 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)
+                SET_FOREACH(other, n->meta.dependencies[d], i)
                         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);
+                NAME_VTABLE(n)->dump(n, f, prefix2);
 
-        if (n->meta.job) {
-                char *p;
+        if (n->meta.job)
+                job_dump(n->meta.job, f, prefix2);
 
-                if (asprintf(&p, "%s\t", prefix) >= 0)
-                        prefix = p;
-                else
-                        p = NULL;
-
-                job_dump(n->meta.job, f, prefix);
-                free(p);
-        }
+        free(prefix2);
 }
 
 static int verify_type(Name *name) {
         char *n;
-        void *state;
+        Iterator i;
 
         assert(name);
 
         /* Checks that all aliases of this name have the same and valid type */
 
-        SET_FOREACH(n, name->meta.names, state) {
+        SET_FOREACH(n, name->meta.names, i) {
                 NameType t;
 
                 if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID)
@@ -472,25 +452,34 @@ int name_load(Name *name) {
 
         assert(name);
 
+        if (name->meta.in_load_queue) {
+                LIST_REMOVE(Meta, load_queue, name->meta.manager->load_queue, &name->meta);
+                name->meta.in_load_queue = false;
+        }
+
         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)
+        if (NAME_VTABLE(name)->init)
+                if ((r = NAME_VTABLE(name)->init(name)) < 0)
                         goto fail;
 
         if ((r = name_sanitize(name)) < 0)
-                goto fail;
+                goto fail_undo_init;
 
         if ((r = name_link_names(name, false)) < 0)
-                goto fail;
+                goto fail_undo_init;
 
         name->meta.load_state = NAME_LOADED;
         return 0;
 
+fail_undo_init:
+        if (NAME_VTABLE(name)->done)
+                NAME_VTABLE(name)->done(name);
+
 fail:
         name->meta.load_state = NAME_FAILED;
         return r;
@@ -513,8 +502,11 @@ int name_start(Name *n) {
         if (NAME_IS_ACTIVE_OR_RELOADING(state))
                 return -EALREADY;
 
-        if (state == NAME_ACTIVATING)
-                return 0;
+        /* We don't suppress calls to ->start() here when we are
+         * already starting, to allow this request to be used as a
+         * "hurry up" call, for example when the name is in some "auto
+         * restart" state where it waits for a holdoff timer to elapse
+         * before it will start again. */
 
         return NAME_VTABLE(n)->start(n);
 }
@@ -558,7 +550,7 @@ int name_reload(Name *n) {
 
         assert(n);
 
-        if (!NAME_VTABLE(n)->reload)
+        if (!name_can_reload(n))
                 return -EBADR;
 
         state = name_active_state(n);
@@ -573,50 +565,63 @@ int name_reload(Name *n) {
 
 bool name_type_can_reload(NameType t) {
         assert(t >= 0 && t < _NAME_TYPE_MAX);
+
         return !!name_vtable[t]->reload;
 }
 
+bool name_can_reload(Name *n) {
+        assert(n);
+
+        if (!name_type_can_reload(n->meta.type))
+                return false;
+
+        if (!NAME_VTABLE(n)->can_reload)
+                return true;
+
+        return NAME_VTABLE(n)->can_reload(n);
+}
+
 static void retroactively_start_dependencies(Name *n) {
-        void *state;
+        Iterator i;
         Name *other;
 
         assert(n);
         assert(NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(n)));
 
-        SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
+        SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], i)
                 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)
+        SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], i)
                 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)
+        SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], i)
                 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)
+        SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], i)
                 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)
+        SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], i)
                 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;
+        Iterator i;
         Name *other;
 
         assert(n);
         assert(NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(n)));
 
-        SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], state)
+        SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], i)
                 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) {
+void name_notify(Name *n, NameActiveState os, NameActiveState ns) {
         assert(n);
         assert(os < _NAME_ACTIVE_STATE_MAX);
         assert(ns < _NAME_ACTIVE_STATE_MAX);
@@ -624,7 +629,12 @@ int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
         assert(!(os == NAME_INACTIVE && ns == NAME_DEACTIVATING));
 
         if (os == ns)
-                return 0;
+                return;
+
+        if (!NAME_IS_ACTIVE_OR_RELOADING(os) && NAME_IS_ACTIVE_OR_RELOADING(ns))
+                n->meta.active_enter_timestamp = now(CLOCK_REALTIME);
+        else if (NAME_IS_ACTIVE_OR_RELOADING(os) && !NAME_IS_ACTIVE_OR_RELOADING(ns))
+                n->meta.active_exit_timestamp = now(CLOCK_REALTIME);
 
         if (n->meta.job) {
 
@@ -633,7 +643,7 @@ int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
                         /* 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);
+                        job_schedule_run(n->meta.job);
 
                 else {
                         assert(n->meta.job->state == JOB_RUNNING);
@@ -648,10 +658,11 @@ int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
                                 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;
+                                        if (NAME_IS_ACTIVE_OR_RELOADING(ns)) {
+                                                job_finish_and_invalidate(n->meta.job, true);
+                                                return;
+                                        } else if (ns == NAME_ACTIVATING)
+                                                return;
                                         else
                                                 job_finish_and_invalidate(n->meta.job, false);
 
@@ -660,10 +671,11 @@ int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
                                 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;
+                                        if (ns == NAME_ACTIVE) {
+                                                job_finish_and_invalidate(n->meta.job, true);
+                                                return;
+                                        } else if (ns == NAME_ACTIVATING || ns == NAME_ACTIVE_RELOADING)
+                                                return;
                                         else
                                                 job_finish_and_invalidate(n->meta.job, false);
 
@@ -673,10 +685,11 @@ int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
                                 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;
+                                        if (ns == NAME_INACTIVE) {
+                                                job_finish_and_invalidate(n->meta.job, true);
+                                                return;
+                                        } else if (ns == NAME_DEACTIVATING)
+                                                return;
                                         else
                                                 job_finish_and_invalidate(n->meta.job, false);
 
@@ -695,6 +708,204 @@ int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
                 retroactively_start_dependencies(n);
         else if (NAME_IS_ACTIVE_OR_ACTIVATING(os) && NAME_IS_INACTIVE_OR_DEACTIVATING(ns))
                 retroactively_stop_dependencies(n);
+}
+
+int name_watch_fd(Name *n, int fd, uint32_t events) {
+        struct epoll_event ev;
+
+        assert(n);
+        assert(fd >= 0);
+
+        zero(ev);
+        ev.data.fd = fd;
+        ev.data.ptr = n;
+        ev.data.u32 = MANAGER_FD;
+        ev.events = events;
+
+        if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) >= 0)
+                return 0;
+
+        if (errno == EEXIST)
+                if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_MOD, fd, &ev) >= 0)
+                        return 0;
+
+        return -errno;
+}
+
+void name_unwatch_fd(Name *n, int fd) {
+        assert(n);
+        assert(fd >= 0);
+
+        assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, fd, NULL) >= 0 || errno == ENOENT);
+}
+
+int name_watch_pid(Name *n, pid_t pid) {
+        assert(n);
+        assert(pid >= 1);
+
+        return hashmap_put(n->meta.manager->watch_pids, UINT32_TO_PTR(pid), n);
+}
+
+void name_unwatch_pid(Name *n, pid_t pid) {
+        assert(n);
+        assert(pid >= 1);
+
+        hashmap_remove(n->meta.manager->watch_pids, UINT32_TO_PTR(pid));
+}
+
+int name_watch_timer(Name *n, usec_t delay, int *id) {
+        struct epoll_event ev;
+        int fd;
+        struct itimerspec its;
+        int flags;
+        bool ours;
+
+        assert(n);
+        assert(id);
+
+        /* This will try to reuse the old timer if there is one */
+
+        if (*id >= 0) {
+                ours = false;
+                fd = *id;
+
+        } else {
+                ours = true;
+
+                if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0)
+                        return -errno;
+        }
+
+        zero(its);
+
+        if (delay <= 0) {
+                /* Set absolute time in the past, but not 0, since we
+                 * don't want to disarm the timer */
+                its.it_value.tv_sec = 0;
+                its.it_value.tv_nsec = 1;
+
+                flags = TFD_TIMER_ABSTIME;
+        } else {
+                timespec_store(&its.it_value, delay);
+                flags = 0;
+        }
+
+        /* This will also flush the elapse counter */
+        if (timerfd_settime(fd, flags, &its, NULL) < 0)
+                goto fail;
+
+        zero(ev);
+        ev.data.fd = fd;
+        ev.data.ptr = n;
+        ev.data.u32 = MANAGER_TIMER;
+        ev.events = POLLIN;
+
+        if (epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0)
+                goto fail;
+
+        *id = fd;
+        return 0;
+
+fail:
+        if (ours)
+                assert_se(close_nointr(fd) == 0);
+
+        return -errno;
+}
+
+void name_unwatch_timer(Name *n, int *id) {
+        assert(n);
+        assert(id);
+
+        if (*id >= 0) {
+                assert_se(epoll_ctl(n->meta.manager->epoll_fd, EPOLL_CTL_DEL, *id, NULL) >= 0);
+                assert_se(close_nointr(*id) == 0);
+
+                *id = -1;
+        }
+}
+
+char *name_change_suffix(const char *t, const char *suffix) {
+        char *e, *n;
+        size_t a, b;
+
+        assert(t);
+        assert(name_is_valid(t));
+        assert(suffix);
+
+        assert_se(e = strrchr(t, '.'));
+        a = e - t;
+        b = strlen(suffix);
+
+        if (!(n = new(char, a + b + 1)))
+                return NULL;
+
+        memcpy(n, t, a);
+        memcpy(n+a, suffix, b+1);
+
+        return n;
+}
+
+bool name_job_is_applicable(Name *n, JobType j) {
+        assert(n);
+        assert(j >= 0 && j < _JOB_TYPE_MAX);
+
+        switch (j) {
+                case JOB_VERIFY_ACTIVE:
+                case JOB_START:
+                        return true;
+
+                case JOB_STOP:
+                case JOB_RESTART:
+                case JOB_TRY_RESTART:
+                        return name_can_start(n);
+
+                case JOB_RELOAD:
+                        return name_can_reload(n);
+
+                case JOB_RELOAD_OR_START:
+                        return name_can_reload(n) && name_can_start(n);
+
+                default:
+                        assert_not_reached("Invalid job type");
+        }
+}
+
+int name_add_dependency(Name *n, NameDependency d, Name *other) {
+
+        static const NameDependency inverse_table[_NAME_DEPENDENCY_MAX] = {
+                [NAME_REQUIRES] = NAME_REQUIRED_BY,
+                [NAME_SOFT_REQUIRES] = NAME_SOFT_REQUIRED_BY,
+                [NAME_WANTS] = NAME_WANTED_BY,
+                [NAME_REQUISITE] = NAME_REQUIRED_BY,
+                [NAME_SOFT_REQUISITE] = NAME_SOFT_REQUIRED_BY,
+                [NAME_REQUIRED_BY] = _NAME_DEPENDENCY_INVALID,
+                [NAME_SOFT_REQUIRED_BY] = _NAME_DEPENDENCY_INVALID,
+                [NAME_WANTED_BY] = _NAME_DEPENDENCY_INVALID,
+                [NAME_CONFLICTS] = NAME_CONFLICTS,
+                [NAME_BEFORE] = NAME_AFTER,
+                [NAME_AFTER] = NAME_BEFORE
+        };
+        int r;
+
+        assert(n);
+        assert(d >= 0 && d < _NAME_DEPENDENCY_MAX);
+        assert(inverse_table[d] != _NAME_DEPENDENCY_INVALID);
+        assert(other);
+
+        if ((r = set_ensure_allocated(&n->meta.dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
+                return r;
+
+        if ((r = set_ensure_allocated(&other->meta.dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
+                return r;
+
+        if ((r = set_put(n->meta.dependencies[d], other)) < 0)
+                return r;
+
+        if ((r = set_put(other->meta.dependencies[inverse_table[d]], n)) < 0) {
+                set_remove(n->meta.dependencies[d], other);
+                return r;
+        }
 
         return 0;
 }