X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?p=elogind.git;a=blobdiff_plain;f=unit.c;h=7779753591921d29ba4f6ff7043b9c18288ff04b;hp=a8058500d1411070e0f20bef675b279b9ae263f8;hb=173e382182d7f1ad2b132b6e923ef731d6affdf7;hpb=013b87c09199926434583e8bb54ac6cb4b835eb5

diff --git a/unit.c b/unit.c
index a8058500d..777975359 100644
--- a/unit.c
+++ b/unit.c
@@ -35,6 +35,9 @@
 #include "load-fragment.h"
 #include "load-dropin.h"
 #include "log.h"
+#include "unit-name.h"
+#include "specifier.h"
+#include "dbus-unit.h"
 
 const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
         [UNIT_SERVICE] = &service_vtable,
@@ -44,74 +47,10 @@ const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX] = {
         [UNIT_DEVICE] = &device_vtable,
         [UNIT_MOUNT] = &mount_vtable,
         [UNIT_AUTOMOUNT] = &automount_vtable,
-        [UNIT_SNAPSHOT] = &snapshot_vtable
+        [UNIT_SNAPSHOT] = &snapshot_vtable,
+        [UNIT_SWAP] = &swap_vtable
 };
 
-UnitType unit_name_to_type(const char *n) {
-        UnitType t;
-
-        assert(n);
-
-        for (t = 0; t < _UNIT_TYPE_MAX; t++)
-                if (endswith(n, unit_vtable[t]->suffix))
-                        return t;
-
-        return _UNIT_TYPE_INVALID;
-}
-
-#define VALID_CHARS                             \
-        "0123456789"                            \
-        "abcdefghijklmnopqrstuvwxyz"            \
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
-        "-_.\\"
-
-bool unit_name_is_valid(const char *n) {
-        UnitType t;
-        const char *e, *i;
-
-        assert(n);
-
-        if (strlen(n) >= UNIT_NAME_MAX)
-                return false;
-
-        t = unit_name_to_type(n);
-        if (t < 0 || t >= _UNIT_TYPE_MAX)
-                return false;
-
-        if (!(e = strrchr(n, '.')))
-                return false;
-
-        if (e == n)
-                return false;
-
-        for (i = n; i < e; i++)
-                if (!strchr(VALID_CHARS, *i))
-                        return false;
-
-        return true;
-}
-
-char *unit_name_change_suffix(const char *n, const char *suffix) {
-        char *e, *r;
-        size_t a, b;
-
-        assert(n);
-        assert(unit_name_is_valid(n));
-        assert(suffix);
-
-        assert_se(e = strrchr(n, '.'));
-        a = e - n;
-        b = strlen(suffix);
-
-        if (!(r = new(char, a + b + 1)))
-                return NULL;
-
-        memcpy(r, n, a);
-        memcpy(r+a, suffix, b+1);
-
-        return r;
-}
-
 Unit *unit_new(Manager *m) {
         Unit *u;
 
@@ -140,65 +79,119 @@ bool unit_has_name(Unit *u, const char *name) {
 
 int unit_add_name(Unit *u, const char *text) {
         UnitType t;
-        char *s;
+        char *s = NULL, *i = NULL;
         int r;
 
         assert(u);
         assert(text);
 
-        if (!unit_name_is_valid(text))
-                return -EINVAL;
-
-        if ((t = unit_name_to_type(text)) == _UNIT_TYPE_INVALID)
-                return -EINVAL;
+        if (unit_name_is_template(text)) {
+                if (!u->meta.instance)
+                        return -EINVAL;
 
-        if (u->meta.type != _UNIT_TYPE_INVALID && t != u->meta.type)
-                return -EINVAL;
+                s = unit_name_replace_instance(text, u->meta.instance);
+        } else
+                s = strdup(text);
 
-        if (!(s = strdup(text)))
+        if (!s)
                 return -ENOMEM;
 
-        if ((r = set_put(u->meta.names, s)) < 0) {
-                free(s);
+        if (!unit_name_is_valid(s)) {
+                r = -EINVAL;
+                goto fail;
+        }
 
-                if (r == -EEXIST)
-                        return 0;
+        assert_se((t = unit_name_to_type(s)) >= 0);
 
-                return r;
+        if (u->meta.type != _UNIT_TYPE_INVALID && t != u->meta.type) {
+                r = -EINVAL;
+                goto fail;
+        }
+
+        if ((r = unit_name_to_instance(s, &i)) < 0)
+                goto fail;
+
+        if (i && unit_vtable[t]->no_instances)
+                goto fail;
+
+        if (u->meta.type != _UNIT_TYPE_INVALID && !streq_ptr(u->meta.instance, i)) {
+                r = -EINVAL;
+                goto fail;
+        }
+
+        if (unit_vtable[t]->no_alias &&
+            !set_isempty(u->meta.names) &&
+            !set_get(u->meta.names, s)) {
+                r = -EEXIST;
+                goto fail;
+        }
+
+        if (hashmap_size(u->meta.manager->units) >= MANAGER_MAX_NAMES) {
+                r = -E2BIG;
+                goto fail;
+        }
+
+        if ((r = set_put(u->meta.names, s)) < 0) {
+                if (r == -EEXIST)
+                        r = 0;
+                goto fail;
         }
 
         if ((r = hashmap_put(u->meta.manager->units, s, u)) < 0) {
                 set_remove(u->meta.names, s);
-                free(s);
-                return r;
+                goto fail;
         }
 
-        if (u->meta.type == _UNIT_TYPE_INVALID)
-                LIST_PREPEND(Meta, units_per_type, u->meta.manager->units_per_type[t], &u->meta);
+        if (u->meta.type == _UNIT_TYPE_INVALID) {
 
-        u->meta.type = t;
-
-        if (!u->meta.id)
+                u->meta.type = t;
                 u->meta.id = s;
+                u->meta.instance = i;
+
+                LIST_PREPEND(Meta, units_per_type, u->meta.manager->units_per_type[t], &u->meta);
+
+                if (UNIT_VTABLE(u)->init)
+                        UNIT_VTABLE(u)->init(u);
+        } else
+                free(i);
 
         unit_add_to_dbus_queue(u);
         return 0;
+
+fail:
+        free(s);
+        free(i);
+
+        return r;
 }
 
 int unit_choose_id(Unit *u, const char *name) {
-        char *s;
+        char *s, *t = NULL;
 
         assert(u);
         assert(name);
 
+        if (unit_name_is_template(name)) {
+
+                if (!u->meta.instance)
+                        return -EINVAL;
+
+                if (!(t = unit_name_replace_instance(name, u->meta.instance)))
+                        return -ENOMEM;
+
+                name = t;
+        }
+
         /* Selects one of the names of this unit as the id */
+        s = set_get(u->meta.names, (char*) name);
+        free(t);
 
-        if (!(s = set_get(u->meta.names, (char*) name)))
+        if (!s)
                 return -ENOENT;
 
         u->meta.id = s;
-
         unit_add_to_dbus_queue(u);
+
         return 0;
 }
 
@@ -217,6 +210,25 @@ int unit_set_description(Unit *u, const char *description) {
         return 0;
 }
 
+bool unit_check_gc(Unit *u) {
+        assert(u);
+
+        if (UNIT_VTABLE(u)->no_gc)
+                return true;
+
+        if (u->meta.job)
+                return true;
+
+        if (unit_active_state(u) != UNIT_INACTIVE)
+                return true;
+
+        if (UNIT_VTABLE(u)->check_gc)
+                if (UNIT_VTABLE(u)->check_gc(u))
+                        return true;
+
+        return false;
+}
+
 void unit_add_to_load_queue(Unit *u) {
         assert(u);
         assert(u->meta.type != _UNIT_TYPE_INVALID);
@@ -238,6 +250,24 @@ void unit_add_to_cleanup_queue(Unit *u) {
         u->meta.in_cleanup_queue = true;
 }
 
+void unit_add_to_gc_queue(Unit *u) {
+        assert(u);
+
+        if (u->meta.in_gc_queue || u->meta.in_cleanup_queue)
+                return;
+
+        if (unit_check_gc(u))
+                return;
+
+        LIST_PREPEND(Meta, gc_queue, u->meta.manager->gc_queue, &u->meta);
+        u->meta.in_gc_queue = true;
+
+        u->meta.manager->n_in_gc_queue ++;
+
+        if (u->meta.manager->gc_queue_timestamp <= 0)
+                u->meta.manager->gc_queue_timestamp = now(CLOCK_MONOTONIC);
+}
+
 void unit_add_to_dbus_queue(Unit *u) {
         assert(u);
         assert(u->meta.type != _UNIT_TYPE_INVALID);
@@ -263,6 +293,8 @@ static void bidi_set_free(Unit *u, Set *s) {
 
                 for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
                         set_remove(other->meta.dependencies[d], u);
+
+                unit_add_to_gc_queue(other);
         }
 
         set_free(s);
@@ -278,9 +310,6 @@ void unit_free(Unit *u) {
         bus_unit_send_removed_signal(u);
 
         /* Detach from next 'bigger' objects */
-
-        cgroup_bonding_free_list(u->meta.cgroup_bondings);
-
         SET_FOREACH(t, u->meta.names, i)
                 hashmap_remove_value(u->meta.manager->units, t, u);
 
@@ -296,14 +325,21 @@ void unit_free(Unit *u) {
         if (u->meta.in_cleanup_queue)
                 LIST_REMOVE(Meta, cleanup_queue, u->meta.manager->cleanup_queue, &u->meta);
 
-        if (u->meta.load_state != UNIT_STUB)
-                if (UNIT_VTABLE(u)->done)
-                        UNIT_VTABLE(u)->done(u);
+        if (u->meta.in_gc_queue) {
+                LIST_REMOVE(Meta, gc_queue, u->meta.manager->gc_queue, &u->meta);
+                u->meta.manager->n_in_gc_queue--;
+        }
 
         /* Free data and next 'smaller' objects */
         if (u->meta.job)
                 job_free(u->meta.job);
 
+        if (u->meta.load_state != UNIT_STUB)
+                if (UNIT_VTABLE(u)->done)
+                        UNIT_VTABLE(u)->done(u);
+
+        cgroup_bonding_free_list(u->meta.cgroup_bondings);
+
         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
                 bidi_set_free(u, u->meta.dependencies[d]);
 
@@ -314,6 +350,8 @@ void unit_free(Unit *u) {
                 free(t);
         set_free(u->meta.names);
 
+        free(u->meta.instance);
+
         free(u);
 }
 
@@ -326,6 +364,12 @@ UnitActiveState unit_active_state(Unit *u) {
         return UNIT_VTABLE(u)->active_state(u);
 }
 
+const char* unit_sub_state_to_string(Unit *u) {
+        assert(u);
+
+        return UNIT_VTABLE(u)->sub_state_to_string(u);
+}
+
 static void complete_move(Set **s, Set **other) {
         assert(s);
         assert(other);
@@ -395,16 +439,17 @@ int unit_merge(Unit *u, Unit *other) {
         assert(u);
         assert(other);
         assert(u->meta.manager == other->meta.manager);
+        assert(u->meta.type != _UNIT_TYPE_INVALID);
 
         other = unit_follow_merge(other);
 
         if (other == u)
                 return 0;
 
-        /* This merges 'other' into 'unit'. FIXME: This does not
-         * rollback on failure. */
+        if (u->meta.type != other->meta.type)
+                return -EINVAL;
 
-        if (u->meta.type != u->meta.type)
+        if (!streq_ptr(u->meta.instance, other->meta.instance))
                 return -EINVAL;
 
         if (other->meta.load_state != UNIT_STUB &&
@@ -441,14 +486,29 @@ int unit_merge(Unit *u, Unit *other) {
 
 int unit_merge_by_name(Unit *u, const char *name) {
         Unit *other;
+        int r;
+        char *s = NULL;
 
         assert(u);
         assert(name);
 
+        if (unit_name_is_template(name)) {
+                if (!u->meta.instance)
+                        return -EINVAL;
+
+                if (!(s = unit_name_replace_instance(name, u->meta.instance)))
+                        return -ENOMEM;
+
+                name = s;
+        }
+
         if (!(other = manager_get_unit(u->meta.manager, name)))
-                return unit_add_name(u, name);
+                r = unit_add_name(u, name);
+        else
+                r = unit_merge(u, other);
 
-        return unit_merge(u, other);
+        free(s);
+        return r;
 }
 
 Unit* unit_follow_merge(Unit *u) {
@@ -466,38 +526,29 @@ int unit_add_exec_dependencies(Unit *u, ExecContext *c) {
         assert(u);
         assert(c);
 
-        if (c->output != EXEC_OUTPUT_KERNEL && c->output != EXEC_OUTPUT_SYSLOG)
+        if (c->std_output != EXEC_OUTPUT_KERNEL && c->std_output != EXEC_OUTPUT_SYSLOG)
                 return 0;
 
         /* If syslog or kernel logging is requested, make sure our own
          * logging daemon is run first. */
 
-        if ((r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_LOGGER_SOCKET)) < 0)
+        if ((r = unit_add_dependency_by_name(u, UNIT_AFTER, SPECIAL_LOGGER_SOCKET, NULL, true)) < 0)
                 return r;
 
         if (u->meta.manager->running_as != MANAGER_SESSION)
-                if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_LOGGER_SOCKET)) < 0)
+                if ((r = unit_add_dependency_by_name(u, UNIT_REQUIRES, SPECIAL_LOGGER_SOCKET, NULL, true)) < 0)
                         return r;
 
         return 0;
 }
 
-const char* unit_id(Unit *u) {
-        assert(u);
-
-        if (u->meta.id)
-                return u->meta.id;
-
-        return set_first(u->meta.names);
-}
-
 const char *unit_description(Unit *u) {
         assert(u);
 
         if (u->meta.description)
                 return u->meta.description;
 
-        return unit_id(u);
+        return u->meta.id;
 }
 
 void unit_dump(Unit *u, FILE *f, const char *prefix) {
@@ -507,9 +558,14 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
         char *p2;
         const char *prefix2;
         CGroupBonding *b;
-        char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
+        char
+                timestamp1[FORMAT_TIMESTAMP_MAX],
+                timestamp2[FORMAT_TIMESTAMP_MAX],
+                timestamp3[FORMAT_TIMESTAMP_MAX],
+                timestamp4[FORMAT_TIMESTAMP_MAX];
 
         assert(u);
+        assert(u->meta.type >= 0);
 
         if (!prefix)
                 prefix = "";
@@ -517,18 +573,26 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
         prefix2 = p2 ? p2 : prefix;
 
         fprintf(f,
-                "%s→ Unit %s:\n"
+                "%s-> Unit %s:\n"
                 "%s\tDescription: %s\n"
+                "%s\tInstance: %s\n"
                 "%s\tUnit Load State: %s\n"
                 "%s\tUnit Active State: %s\n"
+                "%s\tInactive Exit Timestamp: %s\n"
                 "%s\tActive Enter Timestamp: %s\n"
-                "%s\tActive Exit Timestamp: %s\n",
-                prefix, unit_id(u),
+                "%s\tActive Exit Timestamp: %s\n"
+                "%s\tInactive Enter Timestamp: %s\n"
+                "%s\tGC Check Good: %s\n",
+                prefix, u->meta.id,
                 prefix, unit_description(u),
+                prefix, strna(u->meta.instance),
                 prefix, unit_load_state_to_string(u->meta.load_state),
                 prefix, unit_active_state_to_string(unit_active_state(u)),
-                prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->meta.active_enter_timestamp)),
-                prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->meta.active_exit_timestamp)));
+                prefix, strna(format_timestamp(timestamp1, sizeof(timestamp1), u->meta.inactive_exit_timestamp)),
+                prefix, strna(format_timestamp(timestamp2, sizeof(timestamp2), u->meta.active_enter_timestamp)),
+                prefix, strna(format_timestamp(timestamp3, sizeof(timestamp3), u->meta.active_exit_timestamp)),
+                prefix, strna(format_timestamp(timestamp4, sizeof(timestamp4), u->meta.inactive_enter_timestamp)),
+                prefix, yes_no(unit_check_gc(u)));
 
         SET_FOREACH(t, u->meta.names, i)
                 fprintf(f, "%s\tName: %s\n", prefix, t);
@@ -540,7 +604,7 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
                 Unit *other;
 
                 SET_FOREACH(other, u->meta.dependencies[d], i)
-                        fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), unit_id(other));
+                        fprintf(f, "%s\t%s: %s\n", prefix, unit_dependency_to_string(d), other->meta.id);
         }
 
         if (u->meta.load_state == UNIT_LOADED) {
@@ -560,7 +624,7 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
         } else if (u->meta.load_state == UNIT_MERGED)
                 fprintf(f,
                         "%s\tMerged into: %s\n",
-                        prefix, unit_id(u->meta.merged_into));
+                        prefix, u->meta.merged_into->meta.id);
 
         if (u->meta.job)
                 job_dump(u->meta.job, f, prefix2);
@@ -569,18 +633,16 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
 }
 
 /* Common implementation for multiple backends */
-int unit_load_fragment_and_dropin(Unit *u, UnitLoadState *new_state) {
+int unit_load_fragment_and_dropin(Unit *u) {
         int r;
 
         assert(u);
-        assert(new_state);
-        assert(*new_state == UNIT_STUB || *new_state == UNIT_LOADED);
 
         /* Load a .service file */
-        if ((r = unit_load_fragment(u, new_state)) < 0)
+        if ((r = unit_load_fragment(u)) < 0)
                 return r;
 
-        if (*new_state == UNIT_STUB)
+        if (u->meta.load_state == UNIT_STUB)
                 return -ENOENT;
 
         /* Load drop-in directory data */
@@ -591,22 +653,20 @@ int unit_load_fragment_and_dropin(Unit *u, UnitLoadState *new_state) {
 }
 
 /* Common implementation for multiple backends */
-int unit_load_fragment_and_dropin_optional(Unit *u, UnitLoadState *new_state) {
+int unit_load_fragment_and_dropin_optional(Unit *u) {
         int r;
 
         assert(u);
-        assert(new_state);
-        assert(*new_state == UNIT_STUB || *new_state == UNIT_LOADED);
 
         /* Same as unit_load_fragment_and_dropin(), but whether
          * something can be loaded or not doesn't matter. */
 
         /* Load a .service file */
-        if ((r = unit_load_fragment(u, new_state)) < 0)
+        if ((r = unit_load_fragment(u)) < 0)
                 return r;
 
-        if (*new_state == UNIT_STUB)
-                *new_state = UNIT_LOADED;
+        if (u->meta.load_state == UNIT_STUB)
+                u->meta.load_state = UNIT_LOADED;
 
         /* Load drop-in directory data */
         if ((r = unit_load_dropin(unit_follow_merge(u))) < 0)
@@ -615,9 +675,18 @@ int unit_load_fragment_and_dropin_optional(Unit *u, UnitLoadState *new_state) {
         return 0;
 }
 
+/* Common implementation for multiple backends */
+int unit_load_nop(Unit *u) {
+        assert(u);
+
+        if (u->meta.load_state == UNIT_STUB)
+                u->meta.load_state = UNIT_LOADED;
+
+        return 0;
+}
+
 int unit_load(Unit *u) {
         int r;
-        UnitLoadState res;
 
         assert(u);
 
@@ -626,24 +695,25 @@ int unit_load(Unit *u) {
                 u->meta.in_load_queue = false;
         }
 
+        if (u->meta.type == _UNIT_TYPE_INVALID)
+                return -EINVAL;
+
         if (u->meta.load_state != UNIT_STUB)
                 return 0;
 
-        if (UNIT_VTABLE(u)->init) {
-                res = UNIT_STUB;
-                if ((r = UNIT_VTABLE(u)->init(u, &res)) < 0)
+        if (UNIT_VTABLE(u)->load)
+                if ((r = UNIT_VTABLE(u)->load(u)) < 0)
                         goto fail;
-        }
 
-        if (res == UNIT_STUB) {
+        if (u->meta.load_state == UNIT_STUB) {
                 r = -ENOENT;
                 goto fail;
         }
 
-        u->meta.load_state = res;
         assert((u->meta.load_state != UNIT_MERGED) == !u->meta.merged_into);
 
         unit_add_to_dbus_queue(unit_follow_merge(u));
+        unit_add_to_gc_queue(u);
 
         return 0;
 
@@ -651,7 +721,7 @@ fail:
         u->meta.load_state = UNIT_FAILED;
         unit_add_to_dbus_queue(u);
 
-        log_error("Failed to load configuration for %s: %s", unit_id(u), strerror(-r));
+        log_debug("Failed to load configuration for %s: %s", u->meta.id, strerror(-r));
 
         return r;
 }
@@ -711,9 +781,6 @@ int unit_stop(Unit *u) {
         if (!UNIT_VTABLE(u)->stop)
                 return -EBADR;
 
-        if (state == UNIT_DEACTIVATING)
-                return 0;
-
         unit_add_to_dbus_queue(u);
         return UNIT_VTABLE(u)->stop(u);
 }
@@ -773,7 +840,7 @@ static void unit_check_uneeded(Unit *u) {
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         return;
 
-        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUIRED_BY], i)
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         return;
 
@@ -781,7 +848,7 @@ static void unit_check_uneeded(Unit *u) {
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         return;
 
-        log_debug("Service %s is not needed anymore. Stopping.", unit_id(u));
+        log_debug("Service %s is not needed anymore. Stopping.", u->meta.id);
 
         /* Ok, nobody needs us anymore. Sniff. Then let's commit suicide */
         manager_add_job(u->meta.manager, JOB_STOP, u, JOB_FAIL, true, NULL);
@@ -798,7 +865,7 @@ static void retroactively_start_dependencies(Unit *u) {
                 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
                         manager_add_job(u->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
 
-        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUIRES], i)
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
                 if (!UNIT_IS_ACTIVE_OR_ACTIVATING(unit_active_state(other)))
                         manager_add_job(u->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
 
@@ -833,7 +900,7 @@ static void retroactively_stop_dependencies(Unit *u) {
         SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         unit_check_uneeded(other);
-        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUIRES], i)
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUIRES_OVERRIDABLE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         unit_check_uneeded(other);
         SET_FOREACH(other, u->meta.dependencies[UNIT_WANTS], i)
@@ -842,19 +909,18 @@ static void retroactively_stop_dependencies(Unit *u) {
         SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         unit_check_uneeded(other);
-        SET_FOREACH(other, u->meta.dependencies[UNIT_SOFT_REQUISITE], i)
+        SET_FOREACH(other, u->meta.dependencies[UNIT_REQUISITE_OVERRIDABLE], i)
                 if (!UNIT_IS_INACTIVE_OR_DEACTIVATING(unit_active_state(other)))
                         unit_check_uneeded(other);
 }
 
 void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
         bool unexpected = false;
+        usec_t ts;
 
         assert(u);
         assert(os < _UNIT_ACTIVE_STATE_MAX);
         assert(ns < _UNIT_ACTIVE_STATE_MAX);
-        assert(!(os == UNIT_ACTIVE && ns == UNIT_ACTIVATING));
-        assert(!(os == UNIT_INACTIVE && ns == UNIT_DEACTIVATING));
 
         /* Note that this is called for all low-level state changes,
          * even if they might map to the same high-level
@@ -863,10 +929,17 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
          * this function will be called too and the utmp code below
          * relies on that! */
 
+        ts = now(CLOCK_REALTIME);
+
+        if (os == UNIT_INACTIVE && ns != UNIT_INACTIVE)
+                u->meta.inactive_exit_timestamp = ts;
+        else if (os != UNIT_INACTIVE && ns == UNIT_INACTIVE)
+                u->meta.inactive_enter_timestamp = ts;
+
         if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
-                u->meta.active_enter_timestamp = now(CLOCK_REALTIME);
+                u->meta.active_enter_timestamp = ts;
         else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns))
-                u->meta.active_exit_timestamp = now(CLOCK_REALTIME);
+                u->meta.active_exit_timestamp = ts;
 
         if (u->meta.job) {
 
@@ -940,25 +1013,38 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
                         retroactively_stop_dependencies(u);
         }
 
-        if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
-
+        /* Some names are special */
+        if (UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
                 if (unit_has_name(u, SPECIAL_DBUS_SERVICE)) {
-                        log_info("D-Bus became available, trying to reconnect.");
-                        /* The bus just got started, hence try to connect to it. */
+                        /* The bus just might have become available,
+                         * hence try to connect to it, if we aren't
+                         * yet connected. */
                         bus_init_system(u->meta.manager);
                         bus_init_api(u->meta.manager);
                 }
 
-                if (unit_has_name(u, SPECIAL_SYSLOG_SERVICE)) {
-                        /* The syslog daemon just got started, hence try to connect to it. */
-                        log_info("Syslog became available, trying to reconnect.");
+                if (unit_has_name(u, SPECIAL_SYSLOG_SERVICE))
+                        /* The syslog daemon just might have become
+                         * available, hence try to connect to it, if
+                         * we aren't yet connected. */
                         log_open_syslog();
-                }
 
-        } else if (UNIT_IS_ACTIVE_OR_RELOADING(os) && !UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
+                if (u->meta.type == UNIT_MOUNT)
+                        /* Another directory became available, let's
+                         * check if that is enough to write our utmp
+                         * entry. */
+                        manager_write_utmp_reboot(u->meta.manager);
+
+                if (u->meta.type == UNIT_TARGET)
+                        /* A target got activated, maybe this is a runlevel? */
+                        manager_write_utmp_runlevel(u->meta.manager, u);
+
+        } else if (!UNIT_IS_ACTIVE_OR_RELOADING(ns)) {
 
                 if (unit_has_name(u, SPECIAL_SYSLOG_SERVICE))
-                        /* The syslog daemon just got terminated, hence try to disconnect from it. */
+                        /* The syslog daemon might just have
+                         * terminated, hence try to disconnect from
+                         * it. */
                         log_close_syslog();
 
                 /* We don't care about D-Bus here, since we'll get an
@@ -970,6 +1056,7 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
         unit_check_uneeded(u);
 
         unit_add_to_dbus_queue(u);
+        unit_add_to_gc_queue(u);
 }
 
 int unit_watch_fd(Unit *u, int fd, uint32_t events, Watch *w) {
@@ -1017,6 +1104,9 @@ int unit_watch_pid(Unit *u, pid_t pid) {
         assert(u);
         assert(pid >= 1);
 
+        /* Watch a specific PID. We only support one unit watching
+         * each PID for now. */
+
         return hashmap_put(u->meta.manager->watch_pids, UINT32_TO_PTR(pid), u);
 }
 
@@ -1024,7 +1114,7 @@ void unit_unwatch_pid(Unit *u, pid_t pid) {
         assert(u);
         assert(pid >= 1);
 
-        hashmap_remove(u->meta.manager->watch_pids, UINT32_TO_PTR(pid));
+        hashmap_remove_value(u->meta.manager->watch_pids, UINT32_TO_PTR(pid), u);
 }
 
 int unit_watch_timer(Unit *u, usec_t delay, Watch *w) {
@@ -1099,7 +1189,7 @@ void unit_unwatch_timer(Unit *u, Watch *w) {
         assert(w->type == WATCH_TIMER && w->data.unit == u);
 
         assert_se(epoll_ctl(u->meta.manager->epoll_fd, EPOLL_CTL_DEL, w->fd, NULL) >= 0);
-        assert_se(close_nointr(w->fd) == 0);
+        close_nointr_nofail(w->fd);
 
         w->fd = -1;
         w->type = WATCH_INVALID;
@@ -1132,22 +1222,24 @@ bool unit_job_is_applicable(Unit *u, JobType j) {
         }
 }
 
-int unit_add_dependency(Unit *u, UnitDependency d, Unit *other) {
+int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_reference) {
 
         static const UnitDependency inverse_table[_UNIT_DEPENDENCY_MAX] = {
                 [UNIT_REQUIRES] = UNIT_REQUIRED_BY,
-                [UNIT_SOFT_REQUIRES] = UNIT_SOFT_REQUIRED_BY,
+                [UNIT_REQUIRES_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
                 [UNIT_WANTS] = UNIT_WANTED_BY,
                 [UNIT_REQUISITE] = UNIT_REQUIRED_BY,
-                [UNIT_SOFT_REQUISITE] = UNIT_SOFT_REQUIRED_BY,
+                [UNIT_REQUISITE_OVERRIDABLE] = UNIT_REQUIRED_BY_OVERRIDABLE,
                 [UNIT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
-                [UNIT_SOFT_REQUIRED_BY] = _UNIT_DEPENDENCY_INVALID,
+                [UNIT_REQUIRED_BY_OVERRIDABLE] = _UNIT_DEPENDENCY_INVALID,
                 [UNIT_WANTED_BY] = _UNIT_DEPENDENCY_INVALID,
                 [UNIT_CONFLICTS] = UNIT_CONFLICTS,
                 [UNIT_BEFORE] = UNIT_AFTER,
-                [UNIT_AFTER] = UNIT_BEFORE
+                [UNIT_AFTER] = UNIT_BEFORE,
+                [UNIT_REFERENCES] = UNIT_REFERENCED_BY,
+                [UNIT_REFERENCED_BY] = UNIT_REFERENCES
         };
-        int r;
+        int r, q = 0, v = 0, w = 0;
 
         assert(u);
         assert(d >= 0 && d < _UNIT_DEPENDENCY_MAX);
@@ -1159,48 +1251,130 @@ int unit_add_dependency(Unit *u, UnitDependency d, Unit *other) {
         if (u == other)
                 return 0;
 
-        if ((r = set_ensure_allocated(&u->meta.dependencies[d], trivial_hash_func, trivial_compare_func)) < 0)
-                return r;
+        if (UNIT_VTABLE(u)->no_requires &&
+            (d == UNIT_REQUIRES ||
+             d == UNIT_REQUIRES_OVERRIDABLE ||
+             d == UNIT_REQUISITE ||
+             d == UNIT_REQUISITE_OVERRIDABLE)) {
+                    return -EINVAL;
+        }
 
-        if ((r = set_ensure_allocated(&other->meta.dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
+        if ((r = set_ensure_allocated(&u->meta.dependencies[d], trivial_hash_func, trivial_compare_func)) < 0 ||
+            (r = set_ensure_allocated(&other->meta.dependencies[inverse_table[d]], trivial_hash_func, trivial_compare_func)) < 0)
                 return r;
 
-        if ((r = set_put(u->meta.dependencies[d], other)) < 0)
-                return r;
+        if (add_reference)
+                if ((r = set_ensure_allocated(&u->meta.dependencies[UNIT_REFERENCES], trivial_hash_func, trivial_compare_func)) < 0 ||
+                    (r = set_ensure_allocated(&other->meta.dependencies[UNIT_REFERENCED_BY], trivial_hash_func, trivial_compare_func)) < 0)
+                        return r;
 
-        if ((r = set_put(other->meta.dependencies[inverse_table[d]], u)) < 0) {
-                set_remove(u->meta.dependencies[d], other);
-                return r;
+        if ((q = set_put(u->meta.dependencies[d], other)) < 0)
+                return q;
+
+        if ((v = set_put(other->meta.dependencies[inverse_table[d]], u)) < 0) {
+                r = v;
+                goto fail;
+        }
+
+        if (add_reference) {
+                if ((w = set_put(u->meta.dependencies[UNIT_REFERENCES], other)) < 0) {
+                        r = w;
+                        goto fail;
+                }
+
+                if ((r = set_put(other->meta.dependencies[UNIT_REFERENCED_BY], u)) < 0)
+                        goto fail;
         }
 
         unit_add_to_dbus_queue(u);
         return 0;
+
+fail:
+        if (q > 0)
+                set_remove(u->meta.dependencies[d], other);
+
+        if (v > 0)
+                set_remove(other->meta.dependencies[inverse_table[d]], u);
+
+        if (w > 0)
+                set_remove(u->meta.dependencies[UNIT_REFERENCES], other);
+
+        return r;
 }
 
-int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name) {
+static const char *resolve_template(Unit *u, const char *name, const char*path, char **p) {
+        char *s;
+
+        assert(u);
+        assert(name || path);
+
+        if (!name)
+                name = file_name_from_path(path);
+
+        if (!unit_name_is_template(name)) {
+                *p = NULL;
+                return name;
+        }
+
+        if (u->meta.instance)
+                s = unit_name_replace_instance(name, u->meta.instance);
+        else {
+                char *i;
+
+                if (!(i = unit_name_to_prefix(u->meta.id)))
+                        return NULL;
+
+                s = unit_name_replace_instance(name, i);
+                free(i);
+        }
+
+        if (!s)
+                return NULL;
+
+        *p = s;
+        return s;
+}
+
+int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
         Unit *other;
         int r;
+        char *s;
 
-        if ((r = manager_load_unit(u->meta.manager, name, &other)) < 0)
-                return r;
+        assert(u);
+        assert(name || path);
 
-        if ((r = unit_add_dependency(u, d, other)) < 0)
-                return r;
+        if (!(name = resolve_template(u, name, path, &s)))
+                return -ENOMEM;
 
-        return 0;
+        if ((r = manager_load_unit(u->meta.manager, name, path, &other)) < 0)
+                goto finish;
+
+        r = unit_add_dependency(u, d, other, add_reference);
+
+finish:
+        free(s);
+        return r;
 }
 
-int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name) {
+int unit_add_dependency_by_name_inverse(Unit *u, UnitDependency d, const char *name, const char *path, bool add_reference) {
         Unit *other;
         int r;
+        char *s;
 
-        if ((r = manager_load_unit(u->meta.manager, name, &other)) < 0)
-                return r;
+        assert(u);
+        assert(name || path);
 
-        if ((r = unit_add_dependency(other, d, u)) < 0)
-                return r;
+        if (!(name = resolve_template(u, name, path, &s)))
+                return -ENOMEM;
 
-        return 0;
+        if ((r = manager_load_unit(u->meta.manager, name, path, &other)) < 0)
+                goto finish;
+
+        r = unit_add_dependency(other, d, u, add_reference);
+
+finish:
+        free(s);
+        return r;
 }
 
 int set_unit_path(const char *p) {
@@ -1232,54 +1406,12 @@ int set_unit_path(const char *p) {
         return 0;
 }
 
-char *unit_name_escape_path(const char *path, const char *suffix) {
-        char *r, *t;
-        const char *f;
-        size_t a, b;
-
-        assert(path);
-
-        /* Takes a path and a suffix and prefix and makes a nice
-         * string suitable as unit name of it, escaping all weird
-         * chars on the way.
-         *
-         * / becomes ., and all chars not alloweed in a unit name get
-         * escaped as \xFF, including \ and ., of course. This
-         * escaping is hence reversible.
-         */
-
-        if (!suffix)
-                suffix = "";
-
-        a = strlen(path);
-        b = strlen(suffix);
-
-        if (!(r = new(char, a*4+b+1)))
-                return NULL;
-
-        for (f = path, t = r; *f; f++) {
-                if (*f == '/')
-                        *(t++) = '.';
-                else if (*f == '.' || *f == '\\' || !strchr(VALID_CHARS, *f)) {
-                        *(t++) = '\\';
-                        *(t++) = 'x';
-                        *(t++) = hexchar(*f > 4);
-                        *(t++) = hexchar(*f);
-                } else
-                        *(t++) = *f;
-        }
-
-        memcpy(t, suffix, b+1);
-
-        return r;
-}
-
 char *unit_dbus_path(Unit *u) {
         char *p, *e;
 
         assert(u);
 
-        if (!(e = bus_path_escape(unit_id(u))))
+        if (!(e = bus_path_escape(u->meta.id)))
                 return NULL;
 
         if (asprintf(&p, "/org/freedesktop/systemd1/unit/%s", e) < 0) {
@@ -1318,13 +1450,22 @@ int unit_add_cgroup(Unit *u, CGroupBonding *b) {
 
 static char *default_cgroup_path(Unit *u) {
         char *p;
+        int r;
 
         assert(u);
 
-        if (asprintf(&p, "%s/%s", u->meta.manager->cgroup_hierarchy, unit_id(u)) < 0)
-                return NULL;
+        if (u->meta.instance) {
+                char *t;
 
-        return p;
+                if (!(t = unit_name_template(u->meta.id)))
+                        return NULL;
+
+                r = asprintf(&p, "%s/%s/%s", u->meta.manager->cgroup_hierarchy, t, u->meta.instance);
+                free(t);
+        } else
+                r = asprintf(&p, "%s/%s", u->meta.manager->cgroup_hierarchy, u->meta.id);
+
+        return r < 0 ? NULL : p;
 }
 
 int unit_add_cgroup_from_text(Unit *u, const char *name) {
@@ -1440,6 +1581,309 @@ CGroupBonding* unit_get_default_cgroup(Unit *u) {
         return cgroup_bonding_find_list(u->meta.cgroup_bondings, u->meta.manager->cgroup_controller);
 }
 
+int unit_load_related_unit(Unit *u, const char *type, Unit **_found) {
+        char *t;
+        int r;
+
+        assert(u);
+        assert(type);
+        assert(_found);
+
+        if (!(t = unit_name_change_suffix(u->meta.id, type)))
+                return -ENOMEM;
+
+        assert(!unit_has_name(u, t));
+
+        r = manager_load_unit(u->meta.manager, t, NULL, _found);
+        free(t);
+
+        assert(r < 0 || *_found != u);
+
+        return r;
+}
+
+int unit_get_related_unit(Unit *u, const char *type, Unit **_found) {
+        Unit *found;
+        char *t;
+
+        assert(u);
+        assert(type);
+        assert(_found);
+
+        if (!(t = unit_name_change_suffix(u->meta.id, type)))
+                return -ENOMEM;
+
+        assert(!unit_has_name(u, t));
+
+        found = manager_get_unit(u->meta.manager, t);
+        free(t);
+
+        if (!found)
+                return -ENOENT;
+
+        *_found = found;
+        return 0;
+}
+
+static char *specifier_prefix_and_instance(char specifier, void *data, void *userdata) {
+        Unit *u = userdata;
+        assert(u);
+
+        return unit_name_to_prefix_and_instance(u->meta.id);
+}
+
+static char *specifier_prefix(char specifier, void *data, void *userdata) {
+        Unit *u = userdata;
+        assert(u);
+
+        return unit_name_to_prefix(u->meta.id);
+}
+
+static char *specifier_prefix_unescaped(char specifier, void *data, void *userdata) {
+        Unit *u = userdata;
+        char *p, *r;
+
+        assert(u);
+
+        if (!(p = unit_name_to_prefix(u->meta.id)))
+                return NULL;
+
+        r = unit_name_unescape(p);
+        free(p);
+
+        return r;
+}
+
+static char *specifier_instance_unescaped(char specifier, void *data, void *userdata) {
+        Unit *u = userdata;
+        assert(u);
+
+        if (u->meta.instance)
+                return unit_name_unescape(u->meta.instance);
+
+        return strdup("");
+}
+
+char *unit_name_printf(Unit *u, const char* format) {
+
+        /*
+         * This will use the passed string as format string and
+         * replace the following specifiers:
+         *
+         * %n: the full id of the unit                 (foo@bar.waldo)
+         * %N: the id of the unit without the suffix   (foo@bar)
+         * %p: the prefix                              (foo)
+         * %i: the instance                            (bar)
+         */
+
+        const Specifier table[] = {
+                { 'n', specifier_string,              u->meta.id },
+                { 'N', specifier_prefix_and_instance, NULL },
+                { 'p', specifier_prefix,              NULL },
+                { 'i', specifier_string,              u->meta.instance },
+                { 0, NULL, NULL }
+        };
+
+        assert(u);
+        assert(format);
+
+        return specifier_printf(format, table, u);
+}
+
+char *unit_full_printf(Unit *u, const char *format) {
+
+        /* This is similar to unit_name_printf() but also supports
+         * unescaping */
+
+        const Specifier table[] = {
+                { 'n', specifier_string,              u->meta.id },
+                { 'N', specifier_prefix_and_instance, NULL },
+                { 'p', specifier_prefix,              NULL },
+                { 'P', specifier_prefix_unescaped,    NULL },
+                { 'i', specifier_string,              u->meta.instance },
+                { 'I', specifier_instance_unescaped,  NULL },
+                { 0, NULL, NULL }
+        };
+
+        assert(u);
+        assert(format);
+
+        return specifier_printf(format, table, u);
+}
+
+char **unit_full_printf_strv(Unit *u, char **l) {
+        size_t n;
+        char **r, **i, **j;
+
+        /* Applies unit_full_printf to every entry in l */
+
+        assert(u);
+
+        n = strv_length(l);
+        if (!(r = new(char*, n+1)))
+                return NULL;
+
+        for (i = l, j = r; *i; i++, j++)
+                if (!(*j = unit_full_printf(u, *i)))
+                        goto fail;
+
+        *j = NULL;
+        return r;
+
+fail:
+        j--;
+        while (j >= r)
+                free(*j);
+
+        free(r);
+
+        return NULL;
+}
+
+int unit_watch_bus_name(Unit *u, const char *name) {
+        assert(u);
+        assert(name);
+
+        /* Watch a specific name on the bus. We only support one unit
+         * watching each name for now. */
+
+        return hashmap_put(u->meta.manager->watch_bus, name, u);
+}
+
+void unit_unwatch_bus_name(Unit *u, const char *name) {
+        assert(u);
+        assert(name);
+
+        hashmap_remove_value(u->meta.manager->watch_bus, name, u);
+}
+
+bool unit_can_serialize(Unit *u) {
+        assert(u);
+
+        return UNIT_VTABLE(u)->serialize && UNIT_VTABLE(u)->deserialize_item;
+}
+
+int unit_serialize(Unit *u, FILE *f, FDSet *fds) {
+        int r;
+
+        assert(u);
+        assert(f);
+        assert(fds);
+
+        if (!unit_can_serialize(u))
+                return 0;
+
+        if ((r = UNIT_VTABLE(u)->serialize(u, f, fds)) < 0)
+                return r;
+
+        /* End marker */
+        fputc('\n', f);
+        return 0;
+}
+
+void unit_serialize_item_format(Unit *u, FILE *f, const char *key, const char *format, ...) {
+        va_list ap;
+
+        assert(u);
+        assert(f);
+        assert(key);
+        assert(format);
+
+        fputs(key, f);
+        fputc('=', f);
+
+        va_start(ap, format);
+        vfprintf(f, format, ap);
+        va_end(ap);
+
+        fputc('\n', f);
+}
+
+void unit_serialize_item(Unit *u, FILE *f, const char *key, const char *value) {
+        assert(u);
+        assert(f);
+        assert(key);
+        assert(value);
+
+        fprintf(f, "%s=%s\n", key, value);
+}
+
+int unit_deserialize(Unit *u, FILE *f, FDSet *fds) {
+        int r;
+
+        assert(u);
+        assert(f);
+        assert(fds);
+
+        if (!unit_can_serialize(u))
+                return 0;
+
+        for (;;) {
+                char line[1024], *l, *v;
+                size_t k;
+
+                if (!fgets(line, sizeof(line), f)) {
+                        if (feof(f))
+                                return 0;
+                        return -errno;
+                }
+
+                l = strstrip(line);
+
+                /* End marker */
+                if (l[0] == 0)
+                        return 0;
+
+                k = strcspn(l, "=");
+
+                if (l[k] == '=') {
+                        l[k] = 0;
+                        v = l+k+1;
+                } else
+                        v = l+k;
+
+                if ((r = UNIT_VTABLE(u)->deserialize_item(u, l, v, fds)) < 0)
+                        return r;
+        }
+}
+
+int unit_add_node_link(Unit *u, const char *what, bool wants) {
+        Unit *device;
+        char *e;
+        int r;
+
+        assert(u);
+
+        if (!what)
+                return 0;
+
+        /* Adds in links to the device node that this unit is based on */
+
+        if (!path_startswith(what, "/dev/") && !path_startswith(what, "/sys/"))
+                return 0;
+
+        if (!(e = unit_name_build_escape(what+1, NULL, ".device")))
+                return -ENOMEM;
+
+        r = manager_load_unit(u->meta.manager, e, NULL, &device);
+        free(e);
+
+        if (r < 0)
+                return r;
+
+        if ((r = unit_add_dependency(u, UNIT_AFTER, device, true)) < 0)
+                return r;
+
+        if ((r = unit_add_dependency(u, UNIT_REQUIRES, device, true)) < 0)
+                return r;
+
+        if (wants)
+                if ((r = unit_add_dependency(device, UNIT_WANTS, u, false)) < 0)
+                        return r;
+
+        return 0;
+}
+
 static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
         [UNIT_SERVICE] = "service",
         [UNIT_TIMER] = "timer",
@@ -1448,7 +1892,8 @@ static const char* const unit_type_table[_UNIT_TYPE_MAX] = {
         [UNIT_DEVICE] = "device",
         [UNIT_MOUNT] = "mount",
         [UNIT_AUTOMOUNT] = "automount",
-        [UNIT_SNAPSHOT] = "snapshot"
+        [UNIT_SNAPSHOT] = "snapshot",
+        [UNIT_SWAP] = "swap"
 };
 
 DEFINE_STRING_TABLE_LOOKUP(unit_type, UnitType);
@@ -1473,24 +1918,27 @@ DEFINE_STRING_TABLE_LOOKUP(unit_active_state, UnitActiveState);
 
 static const char* const unit_dependency_table[_UNIT_DEPENDENCY_MAX] = {
         [UNIT_REQUIRES] = "Requires",
-        [UNIT_SOFT_REQUIRES] = "SoftRequires",
+        [UNIT_REQUIRES_OVERRIDABLE] = "RequiresOverridable",
         [UNIT_WANTS] = "Wants",
         [UNIT_REQUISITE] = "Requisite",
-        [UNIT_SOFT_REQUISITE] = "SoftRequisite",
+        [UNIT_REQUISITE_OVERRIDABLE] = "RequisiteOverridable",
         [UNIT_REQUIRED_BY] = "RequiredBy",
-        [UNIT_SOFT_REQUIRED_BY] = "SoftRequiredBy",
+        [UNIT_REQUIRED_BY_OVERRIDABLE] = "RequiredByOverridable",
         [UNIT_WANTED_BY] = "WantedBy",
         [UNIT_CONFLICTS] = "Conflicts",
         [UNIT_BEFORE] = "Before",
         [UNIT_AFTER] = "After",
+        [UNIT_REFERENCES] = "References",
+        [UNIT_REFERENCED_BY] = "ReferencedBy"
 };
 
 DEFINE_STRING_TABLE_LOOKUP(unit_dependency, UnitDependency);
 
 static const char* const kill_mode_table[_KILL_MODE_MAX] = {
-        [KILL_PROCESS] = "process",
+        [KILL_CONTROL_GROUP] = "control-group",
         [KILL_PROCESS_GROUP] = "process-group",
-        [KILL_CONTROL_GROUP] = "control-group"
+        [KILL_PROCESS] = "process",
+        [KILL_NONE] = "none"
 };
 
 DEFINE_STRING_TABLE_LOOKUP(kill_mode, KillMode);