X-Git-Url: https://www.chiark.greenend.org.uk/ucgi/~ianmdlvl/git?a=blobdiff_plain;f=src%2Fmanager.c;h=a71150d0a93e46ec4695d3afbc3a540beb2c0d6b;hb=a4ddf82766c41627bd94c609bb55983f4b81814f;hp=2a773c6dbbd98bc3d10dab2ea737094b92bc57bf;hpb=871d7de47c13ee6cd78b8eefdf9128be3c740ac0;p=elogind.git

diff --git a/src/manager.c b/src/manager.c
index 2a773c6db..a71150d0a 100644
--- a/src/manager.c
+++ b/src/manager.c
@@ -964,20 +964,25 @@ static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned
         /* Does a recursive sweep through the ordering graph, looking
          * for a cycle. If we find cycle we try to break it. */
 
-        /* Did we find a cycle? */
-        if (j->marker && j->generation == generation) {
+        /* Have we seen this before? */
+        if (j->generation == generation) {
                 Job *k;
 
-                /* So, we already have been here. We have a
-                 * cycle. Let's try to break it. We go backwards in
-                 * our path and try to find a suitable job to
-                 * remove. We use the marker to find our way back,
-                 * since smart how we are we stored our way back in
-                 * there. */
+                /* If the marker is NULL we have been here already and
+                 * decided the job was loop-free from here. Hence
+                 * shortcut things and return right-away. */
+                if (!j->marker)
+                        return 0;
 
+                /* So, the marker is not NULL and we already have been
+                 * here. We have a cycle. Let's try to break it. We go
+                 * backwards in our path and try to find a suitable
+                 * job to remove. We use the marker to find our way
+                 * back, since smart how we are we stored our way back
+                 * in there. */
                 log_debug("Found ordering cycle on %s/%s", j->unit->meta.id, job_type_to_string(j->type));
 
-                for (k = from; k; k = (k->generation == generation ? k->marker : NULL)) {
+                for (k = from; k; k = ((k->generation == generation && k->marker != k) ? k->marker : NULL)) {
 
                         log_debug("Walked on cycle path to %s/%s", k->unit->meta.id, job_type_to_string(k->type));
 
@@ -1002,8 +1007,10 @@ static int transaction_verify_order_one(Manager *m, Job *j, Job *from, unsigned
         }
 
         /* Make the marker point to where we come from, so that we can
-         * find our way backwards if we want to break a cycle */
-        j->marker = from;
+         * find our way backwards if we want to break a cycle. We use
+         * a special marker for the beginning: we point to
+         * ourselves. */
+        j->marker = from ? from : j;
         j->generation = generation;
 
         /* We assume that the the dependencies are bidirectional, and
@@ -1035,6 +1042,7 @@ static int transaction_verify_order(Manager *m, unsigned *generation) {
         Job *j;
         int r;
         Iterator i;
+        unsigned g;
 
         assert(m);
         assert(generation);
@@ -1042,8 +1050,10 @@ static int transaction_verify_order(Manager *m, unsigned *generation) {
         /* Check if the ordering graph is cyclic. If it is, try to fix
          * that up by dropping one of the jobs. */
 
+        g = (*generation)++;
+
         HASHMAP_FOREACH(j, m->transaction_jobs, i)
-                if ((r = transaction_verify_order_one(m, j, NULL, (*generation)++)) < 0)
+                if ((r = transaction_verify_order_one(m, j, NULL, g)) < 0)
                         return r;
 
         return 0;
@@ -1791,11 +1801,13 @@ static int manager_dispatch_sigchld(Manager *m) {
         return 0;
 }
 
-static void manager_start_target(Manager *m, const char *name) {
+static int manager_start_target(Manager *m, const char *name) {
         int r;
 
         if ((r = manager_add_job_by_name(m, JOB_START, name, JOB_REPLACE, true, NULL)) < 0)
                 log_error("Failed to enqueue %s job: %s", name, strerror(-r));
+
+        return r;
 }
 
 static int manager_process_signal_fd(Manager *m) {
@@ -1824,14 +1836,14 @@ static int manager_process_signal_fd(Manager *m) {
                         break;
 
                 case SIGTERM:
-                        if (m->running_as == MANAGER_INIT)
+                        if (m->running_as == MANAGER_INIT) {
                                 /* This is for compatibility with the
                                  * original sysvinit */
                                 m->exit_code = MANAGER_REEXECUTE;
-                        else
-                                m->exit_code = MANAGER_EXIT;
+                                break;
+                        }
 
-                        return 0;
+                        /* Fall through */
 
                 case SIGINT:
                         if (m->running_as == MANAGER_INIT) {
@@ -1839,8 +1851,13 @@ static int manager_process_signal_fd(Manager *m) {
                                 break;
                         }
 
-                        m->exit_code = MANAGER_EXIT;
-                        return 0;
+                        /* Run the exit target if there is one, if not, just exit. */
+                        if (manager_start_target(m, SPECIAL_EXIT_SERVICE) < 0) {
+                                m->exit_code = MANAGER_EXIT;
+                                return 0;
+                        }
+
+                        break;
 
                 case SIGWINCH:
                         if (m->running_as == MANAGER_INIT)