unit: issue notify even if the high-level state didn't change

[elogind.git] / unit.c

diff --git a/unit.c b/unit.c
index 392be841d9866529e2941d20019d27d6b3dc28b9..6406015b4bc075cf9855ff222f4fe0bfa9c19533 100644 (file)
--- a/unit.c
+++ b/unit.c
@@ -219,6 +219,7 @@ int unit_set_description(Unit *u, const char *description) {
 
 void unit_add_to_load_queue(Unit *u) {
         assert(u);
+        assert(u->meta.type != _UNIT_TYPE_INVALID);
 
         if (u->meta.load_state != UNIT_STUB || u->meta.in_load_queue)
                 return;
@@ -239,6 +240,7 @@ void unit_add_to_cleanup_queue(Unit *u) {
 
 void unit_add_to_dbus_queue(Unit *u) {
         assert(u);
+        assert(u->meta.type != _UNIT_TYPE_INVALID);
 
         if (u->meta.load_state == UNIT_STUB || u->meta.in_dbus_queue || set_isempty(u->meta.manager->subscribed))
                 return;
@@ -409,6 +411,12 @@ int unit_merge(Unit *u, Unit *other) {
             other->meta.load_state != UNIT_FAILED)
                 return -EEXIST;
 
+        if (other->meta.job)
+                return -EEXIST;
+
+        if (unit_active_state(other) != UNIT_INACTIVE)
+                return -EEXIST;
+
         /* Merge names */
         merge_names(u, other);
 
@@ -416,11 +424,16 @@ int unit_merge(Unit *u, Unit *other) {
         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++)
                 merge_dependencies(u, other, d);
 
-        unit_add_to_dbus_queue(u);
-
         other->meta.load_state = UNIT_MERGED;
         other->meta.merged_into = u;
 
+        /* If there is still some data attached to the other node, we
+         * don't need it anymore, and can free it. */
+        if (other->meta.load_state != UNIT_STUB)
+                if (UNIT_VTABLE(other)->done)
+                        UNIT_VTABLE(other)->done(other);
+
+        unit_add_to_dbus_queue(u);
         unit_add_to_cleanup_queue(other);
 
         return 0;
@@ -494,6 +507,7 @@ 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];
 
         assert(u);
 
@@ -506,11 +520,15 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
                 "%s→ Unit %s:\n"
                 "%s\tDescription: %s\n"
                 "%s\tUnit Load State: %s\n"
-                "%s\tUnit Active State: %s\n",
+                "%s\tUnit Active State: %s\n"
+                "%s\tActive Enter Timestamp: %s\n"
+                "%s\tActive Exit Timestamp: %s\n",
                 prefix, unit_id(u),
                 prefix, unit_description(u),
                 prefix, unit_load_state_to_string(u->meta.load_state),
-                prefix, unit_active_state_to_string(unit_active_state(u)));
+                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)));
 
         SET_FOREACH(t, u->meta.names, i)
                 fprintf(f, "%s\tName: %s\n", prefix, t);
@@ -521,27 +539,28 @@ void unit_dump(Unit *u, FILE *f, const char *prefix) {
         for (d = 0; d < _UNIT_DEPENDENCY_MAX; d++) {
                 Unit *other;
 
-                if (set_isempty(u->meta.dependencies[d]))
-                        continue;
-
                 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\tRecursive Stop: %s\n"
-                "%s\tStop When Unneeded: %s\n",
-                prefix, yes_no(u->meta.recursive_stop),
-                prefix, yes_no(u->meta.stop_when_unneeded));
-
         if (u->meta.load_state == UNIT_LOADED) {
+                fprintf(f,
+                        "%s\tRecursive Stop: %s\n"
+                        "%s\tStop When Unneeded: %s\n",
+                        prefix, yes_no(u->meta.recursive_stop),
+                        prefix, yes_no(u->meta.stop_when_unneeded));
+
                 LIST_FOREACH(by_unit, b, u->meta.cgroup_bondings)
                         fprintf(f, "%s\tControlGroup: %s:%s\n",
                                 prefix, b->controller, b->path);
 
                 if (UNIT_VTABLE(u)->dump)
                         UNIT_VTABLE(u)->dump(u, f, prefix2);
-        }
+
+        } else if (u->meta.load_state == UNIT_MERGED)
+                fprintf(f,
+                        "%s\tMerged into: %s\n",
+                        prefix, unit_id(u->meta.merged_into));
 
         if (u->meta.job)
                 job_dump(u->meta.job, f, prefix2);
@@ -837,8 +856,12 @@ void unit_notify(Unit *u, UnitActiveState os, UnitActiveState ns) {
         assert(!(os == UNIT_ACTIVE && ns == UNIT_ACTIVATING));
         assert(!(os == UNIT_INACTIVE && ns == UNIT_DEACTIVATING));
 
-        if (os == ns)
-                return;
+        /* Note that this is called for all low-level state changes,
+         * even if they might map to the same high-level
+         * UnitActiveState! That means that ns == os is OK an expected
+         * behaviour here. For example: if a mount point is remounted
+         * this function will be called too and the utmp code below
+         * relies on that! */
 
         if (!UNIT_IS_ACTIVE_OR_RELOADING(os) && UNIT_IS_ACTIVE_OR_RELOADING(ns))
                 u->meta.active_enter_timestamp = now(CLOCK_REALTIME);