chiark / gitweb /
unit: rework trigger dependency logic
[elogind.git] / src / core / job.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7
8   systemd is free software; you can redistribute it and/or modify it
9   under the terms of the GNU Lesser General Public License as published by
10   the Free Software Foundation; either version 2.1 of the License, or
11   (at your option) any later version.
12
13   systemd is distributed in the hope that it will be useful, but
14   WITHOUT ANY WARRANTY; without even the implied warranty of
15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16   Lesser General Public License for more details.
17
18   You should have received a copy of the GNU Lesser General Public License
19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <assert.h>
23 #include <errno.h>
24 #include <sys/timerfd.h>
25 #include <sys/epoll.h>
26
27 #include "systemd/sd-id128.h"
28 #include "systemd/sd-messages.h"
29 #include "set.h"
30 #include "unit.h"
31 #include "macro.h"
32 #include "strv.h"
33 #include "load-fragment.h"
34 #include "load-dropin.h"
35 #include "log.h"
36 #include "dbus-job.h"
37 #include "special.h"
38 #include "sync.h"
39 #include "virt.h"
40
41 JobBusClient* job_bus_client_new(DBusConnection *connection, const char *name) {
42         JobBusClient *cl;
43         size_t name_len;
44
45         name_len = strlen(name);
46         cl = malloc0(sizeof(JobBusClient) + name_len + 1);
47         if (!cl)
48                 return NULL;
49
50         cl->bus = connection;
51         memcpy(cl->name, name, name_len + 1);
52         return cl;
53 }
54
55 Job* job_new_raw(Unit *unit) {
56         Job *j;
57
58         /* used for deserialization */
59
60         assert(unit);
61
62         j = new0(Job, 1);
63         if (!j)
64                 return NULL;
65
66         j->manager = unit->manager;
67         j->unit = unit;
68         j->type = _JOB_TYPE_INVALID;
69         j->timer_watch.type = WATCH_INVALID;
70
71         return j;
72 }
73
74 Job* job_new(Unit *unit, JobType type) {
75         Job *j;
76
77         assert(type < _JOB_TYPE_MAX);
78
79         j = job_new_raw(unit);
80         if (!j)
81                 return NULL;
82
83         j->id = j->manager->current_job_id++;
84         j->type = type;
85
86         /* We don't link it here, that's what job_dependency() is for */
87
88         return j;
89 }
90
91 void job_free(Job *j) {
92         JobBusClient *cl;
93
94         assert(j);
95         assert(!j->installed);
96         assert(!j->transaction_prev);
97         assert(!j->transaction_next);
98         assert(!j->subject_list);
99         assert(!j->object_list);
100
101         if (j->in_run_queue)
102                 LIST_REMOVE(Job, run_queue, j->manager->run_queue, j);
103
104         if (j->in_dbus_queue)
105                 LIST_REMOVE(Job, dbus_queue, j->manager->dbus_job_queue, j);
106
107         if (j->timer_watch.type != WATCH_INVALID) {
108                 assert(j->timer_watch.type == WATCH_JOB_TIMER);
109                 assert(j->timer_watch.data.job == j);
110                 assert(j->timer_watch.fd >= 0);
111
112                 assert_se(epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_DEL, j->timer_watch.fd, NULL) >= 0);
113                 close_nointr_nofail(j->timer_watch.fd);
114         }
115
116         while ((cl = j->bus_client_list)) {
117                 LIST_REMOVE(JobBusClient, client, j->bus_client_list, cl);
118                 free(cl);
119         }
120         free(j);
121 }
122
123 void job_uninstall(Job *j) {
124         Job **pj;
125
126         assert(j->installed);
127
128         pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
129         assert(*pj == j);
130
131         /* Detach from next 'bigger' objects */
132
133         /* daemon-reload should be transparent to job observers */
134         if (j->manager->n_reloading <= 0)
135                 bus_job_send_removed_signal(j);
136
137         *pj = NULL;
138
139         unit_add_to_gc_queue(j->unit);
140
141         hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id));
142         j->installed = false;
143 }
144
145 static bool job_type_allows_late_merge(JobType t) {
146         /* Tells whether it is OK to merge a job of type 't' with an already
147          * running job.
148          * Reloads cannot be merged this way. Think of the sequence:
149          * 1. Reload of a daemon is in progress; the daemon has already loaded
150          *    its config file, but hasn't completed the reload operation yet.
151          * 2. Edit foo's config file.
152          * 3. Trigger another reload to have the daemon use the new config.
153          * Should the second reload job be merged into the first one, the daemon
154          * would not know about the new config.
155          * JOB_RESTART jobs on the other hand can be merged, because they get
156          * patched into JOB_START after stopping the unit. So if we see a
157          * JOB_RESTART running, it means the unit hasn't stopped yet and at
158          * this time the merge is still allowed. */
159         return t != JOB_RELOAD;
160 }
161
162 static void job_merge_into_installed(Job *j, Job *other) {
163         assert(j->installed);
164         assert(j->unit == other->unit);
165
166         if (j->type != JOB_NOP)
167                 job_type_merge_and_collapse(&j->type, other->type, j->unit);
168         else
169                 assert(other->type == JOB_NOP);
170
171         j->override = j->override || other->override;
172         j->irreversible = j->irreversible || other->irreversible;
173         j->ignore_order = j->ignore_order || other->ignore_order;
174 }
175
176 Job* job_install(Job *j) {
177         Job **pj;
178         Job *uj;
179
180         assert(!j->installed);
181         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
182
183         pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
184         uj = *pj;
185
186         if (uj) {
187                 if (j->type != JOB_NOP && job_type_is_conflicting(uj->type, j->type))
188                         job_finish_and_invalidate(uj, JOB_CANCELED, false);
189                 else {
190                         /* not conflicting, i.e. mergeable */
191
192                         if (j->type == JOB_NOP || uj->state == JOB_WAITING ||
193                             (job_type_allows_late_merge(j->type) && job_type_is_superset(uj->type, j->type))) {
194                                 job_merge_into_installed(uj, j);
195                                 log_debug_unit(uj->unit->id,
196                                                "Merged into installed job %s/%s as %u",
197                                                uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
198                                 return uj;
199                         } else {
200                                 /* already running and not safe to merge into */
201                                 /* Patch uj to become a merged job and re-run it. */
202                                 /* XXX It should be safer to queue j to run after uj finishes, but it is
203                                  * not currently possible to have more than one installed job per unit. */
204                                 job_merge_into_installed(uj, j);
205                                 log_debug_unit(uj->unit->id,
206                                                "Merged into running job, re-running: %s/%s as %u",
207                                                uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
208                                 uj->state = JOB_WAITING;
209                                 uj->manager->n_running_jobs--;
210                                 return uj;
211                         }
212                 }
213         }
214
215         /* Install the job */
216         *pj = j;
217         j->installed = true;
218         j->manager->n_installed_jobs ++;
219         log_debug_unit(j->unit->id,
220                        "Installed new job %s/%s as %u",
221                        j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
222         return j;
223 }
224
225 int job_install_deserialized(Job *j) {
226         Job **pj;
227
228         assert(!j->installed);
229
230         if (j->type < 0 || j->type >= _JOB_TYPE_MAX_IN_TRANSACTION) {
231                 log_debug("Invalid job type %s in deserialization.", strna(job_type_to_string(j->type)));
232                 return -EINVAL;
233         }
234
235         pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
236
237         if (*pj) {
238                 log_debug_unit(j->unit->id,
239                                "Unit %s already has a job installed. Not installing deserialized job.",
240                                j->unit->id);
241                 return -EEXIST;
242         }
243         *pj = j;
244         j->installed = true;
245         log_debug_unit(j->unit->id,
246                        "Reinstalled deserialized job %s/%s as %u",
247                        j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
248         return 0;
249 }
250
251 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts) {
252         JobDependency *l;
253
254         assert(object);
255
256         /* Adds a new job link, which encodes that the 'subject' job
257          * needs the 'object' job in some way. If 'subject' is NULL
258          * this means the 'anchor' job (i.e. the one the user
259          * explicitly asked for) is the requester. */
260
261         if (!(l = new0(JobDependency, 1)))
262                 return NULL;
263
264         l->subject = subject;
265         l->object = object;
266         l->matters = matters;
267         l->conflicts = conflicts;
268
269         if (subject)
270                 LIST_PREPEND(JobDependency, subject, subject->subject_list, l);
271
272         LIST_PREPEND(JobDependency, object, object->object_list, l);
273
274         return l;
275 }
276
277 void job_dependency_free(JobDependency *l) {
278         assert(l);
279
280         if (l->subject)
281                 LIST_REMOVE(JobDependency, subject, l->subject->subject_list, l);
282
283         LIST_REMOVE(JobDependency, object, l->object->object_list, l);
284
285         free(l);
286 }
287
288 void job_dump(Job *j, FILE*f, const char *prefix) {
289         assert(j);
290         assert(f);
291
292         if (!prefix)
293                 prefix = "";
294
295         fprintf(f,
296                 "%s-> Job %u:\n"
297                 "%s\tAction: %s -> %s\n"
298                 "%s\tState: %s\n"
299                 "%s\tForced: %s\n"
300                 "%s\tIrreversible: %s\n",
301                 prefix, j->id,
302                 prefix, j->unit->id, job_type_to_string(j->type),
303                 prefix, job_state_to_string(j->state),
304                 prefix, yes_no(j->override),
305                 prefix, yes_no(j->irreversible));
306 }
307
308 /*
309  * Merging is commutative, so imagine the matrix as symmetric. We store only
310  * its lower triangle to avoid duplication. We don't store the main diagonal,
311  * because A merged with A is simply A.
312  *
313  * If the resulting type is collapsed immediately afterwards (to get rid of
314  * the JOB_RELOAD_OR_START, which lies outside the lookup function's domain),
315  * the following properties hold:
316  *
317  * Merging is associative! A merged with B merged with C is the same as
318  * A merged with C merged with B.
319  *
320  * Mergeability is transitive! If A can be merged with B and B with C then
321  * A also with C.
322  *
323  * Also, if A merged with B cannot be merged with C, then either A or B cannot
324  * be merged with C either.
325  */
326 static const JobType job_merging_table[] = {
327 /* What \ With       *  JOB_START         JOB_VERIFY_ACTIVE  JOB_STOP JOB_RELOAD */
328 /*********************************************************************************/
329 /*JOB_START          */
330 /*JOB_VERIFY_ACTIVE  */ JOB_START,
331 /*JOB_STOP           */ -1,                  -1,
332 /*JOB_RELOAD         */ JOB_RELOAD_OR_START, JOB_RELOAD,          -1,
333 /*JOB_RESTART        */ JOB_RESTART,         JOB_RESTART,         -1, JOB_RESTART,
334 };
335
336 JobType job_type_lookup_merge(JobType a, JobType b) {
337         assert_cc(ELEMENTSOF(job_merging_table) == _JOB_TYPE_MAX_MERGING * (_JOB_TYPE_MAX_MERGING - 1) / 2);
338         assert(a >= 0 && a < _JOB_TYPE_MAX_MERGING);
339         assert(b >= 0 && b < _JOB_TYPE_MAX_MERGING);
340
341         if (a == b)
342                 return a;
343
344         if (a < b) {
345                 JobType tmp = a;
346                 a = b;
347                 b = tmp;
348         }
349
350         return job_merging_table[(a - 1) * a / 2 + b];
351 }
352
353 bool job_type_is_redundant(JobType a, UnitActiveState b) {
354         switch (a) {
355
356         case JOB_START:
357                 return
358                         b == UNIT_ACTIVE ||
359                         b == UNIT_RELOADING;
360
361         case JOB_STOP:
362                 return
363                         b == UNIT_INACTIVE ||
364                         b == UNIT_FAILED;
365
366         case JOB_VERIFY_ACTIVE:
367                 return
368                         b == UNIT_ACTIVE ||
369                         b == UNIT_RELOADING;
370
371         case JOB_RELOAD:
372                 return
373                         b == UNIT_RELOADING;
374
375         case JOB_RESTART:
376                 return
377                         b == UNIT_ACTIVATING;
378
379         default:
380                 assert_not_reached("Invalid job type");
381         }
382 }
383
384 void job_type_collapse(JobType *t, Unit *u) {
385         UnitActiveState s;
386
387         switch (*t) {
388
389         case JOB_TRY_RESTART:
390                 s = unit_active_state(u);
391                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
392                         *t = JOB_NOP;
393                 else
394                         *t = JOB_RESTART;
395                 break;
396
397         case JOB_RELOAD_OR_START:
398                 s = unit_active_state(u);
399                 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
400                         *t = JOB_START;
401                 else
402                         *t = JOB_RELOAD;
403                 break;
404
405         default:
406                 ;
407         }
408 }
409
410 int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) {
411         JobType t = job_type_lookup_merge(*a, b);
412         if (t < 0)
413                 return -EEXIST;
414         *a = t;
415         job_type_collapse(a, u);
416         return 0;
417 }
418
419 bool job_is_runnable(Job *j) {
420         Iterator i;
421         Unit *other;
422
423         assert(j);
424         assert(j->installed);
425
426         /* Checks whether there is any job running for the units this
427          * job needs to be running after (in the case of a 'positive'
428          * job type) or before (in the case of a 'negative' job
429          * type. */
430
431         /* First check if there is an override */
432         if (j->ignore_order)
433                 return true;
434
435         if (j->type == JOB_NOP)
436                 return true;
437
438         if (j->type == JOB_START ||
439             j->type == JOB_VERIFY_ACTIVE ||
440             j->type == JOB_RELOAD) {
441
442                 /* Immediate result is that the job is or might be
443                  * started. In this case lets wait for the
444                  * dependencies, regardless whether they are
445                  * starting or stopping something. */
446
447                 SET_FOREACH(other, j->unit->dependencies[UNIT_AFTER], i)
448                         if (other->job)
449                                 return false;
450         }
451
452         /* Also, if something else is being stopped and we should
453          * change state after it, then lets wait. */
454
455         SET_FOREACH(other, j->unit->dependencies[UNIT_BEFORE], i)
456                 if (other->job &&
457                     (other->job->type == JOB_STOP ||
458                      other->job->type == JOB_RESTART))
459                         return false;
460
461         /* This means that for a service a and a service b where b
462          * shall be started after a:
463          *
464          *  start a + start b → 1st step start a, 2nd step start b
465          *  start a + stop b  → 1st step stop b,  2nd step start a
466          *  stop a  + start b → 1st step stop a,  2nd step start b
467          *  stop a  + stop b  → 1st step stop b,  2nd step stop a
468          *
469          *  This has the side effect that restarts are properly
470          *  synchronized too. */
471
472         return true;
473 }
474
475 static void job_change_type(Job *j, JobType newtype) {
476         log_debug_unit(j->unit->id,
477                        "Converting job %s/%s -> %s/%s",
478                        j->unit->id, job_type_to_string(j->type),
479                        j->unit->id, job_type_to_string(newtype));
480
481         j->type = newtype;
482 }
483
484 int job_run_and_invalidate(Job *j) {
485         int r;
486         uint32_t id;
487         Manager *m = j->manager;
488
489         assert(j);
490         assert(j->installed);
491         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
492         assert(j->in_run_queue);
493
494         LIST_REMOVE(Job, run_queue, j->manager->run_queue, j);
495         j->in_run_queue = false;
496
497         if (j->state != JOB_WAITING)
498                 return 0;
499
500         if (!job_is_runnable(j))
501                 return -EAGAIN;
502
503         j->state = JOB_RUNNING;
504         m->n_running_jobs++;
505         job_add_to_dbus_queue(j);
506
507         /* While we execute this operation the job might go away (for
508          * example: because it is replaced by a new, conflicting
509          * job.) To make sure we don't access a freed job later on we
510          * store the id here, so that we can verify the job is still
511          * valid. */
512         id = j->id;
513
514         switch (j->type) {
515
516                 case JOB_START:
517                         r = unit_start(j->unit);
518
519                         /* If this unit cannot be started, then simply wait */
520                         if (r == -EBADR)
521                                 r = 0;
522                         break;
523
524                 case JOB_VERIFY_ACTIVE: {
525                         UnitActiveState t = unit_active_state(j->unit);
526                         if (UNIT_IS_ACTIVE_OR_RELOADING(t))
527                                 r = -EALREADY;
528                         else if (t == UNIT_ACTIVATING)
529                                 r = -EAGAIN;
530                         else
531                                 r = -ENOEXEC;
532                         break;
533                 }
534
535                 case JOB_STOP:
536                 case JOB_RESTART:
537                         r = unit_stop(j->unit);
538
539                         /* If this unit cannot stopped, then simply wait. */
540                         if (r == -EBADR)
541                                 r = 0;
542                         break;
543
544                 case JOB_RELOAD:
545                         r = unit_reload(j->unit);
546                         break;
547
548                 case JOB_NOP:
549                         r = -EALREADY;
550                         break;
551
552                 default:
553                         assert_not_reached("Unknown job type");
554         }
555
556         j = manager_get_job(m, id);
557         if (j) {
558                 if (r == -EALREADY)
559                         r = job_finish_and_invalidate(j, JOB_DONE, true);
560                 else if (r == -ENOEXEC)
561                         r = job_finish_and_invalidate(j, JOB_SKIPPED, true);
562                 else if (r == -EAGAIN) {
563                         j->state = JOB_WAITING;
564                         m->n_running_jobs--;
565                 } else if (r < 0)
566                         r = job_finish_and_invalidate(j, JOB_FAILED, true);
567         }
568
569         return r;
570 }
571
572 static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
573         const UnitStatusMessageFormats *format_table;
574
575         assert(u);
576         assert(t >= 0);
577         assert(t < _JOB_TYPE_MAX);
578
579         format_table = &UNIT_VTABLE(u)->status_message_formats;
580         if (!format_table)
581                 return NULL;
582
583         if (t == JOB_START)
584                 return format_table->finished_start_job[result];
585         else if (t == JOB_STOP || t == JOB_RESTART)
586                 return format_table->finished_stop_job[result];
587
588         return NULL;
589 }
590
591 static const char *job_get_status_message_format_try_harder(Unit *u, JobType t, JobResult result) {
592         const char *format;
593
594         assert(u);
595         assert(t >= 0);
596         assert(t < _JOB_TYPE_MAX);
597
598         format = job_get_status_message_format(u, t, result);
599         if (format)
600                 return format;
601
602         /* Return generic strings */
603         if (t == JOB_START) {
604                 if (result == JOB_DONE)
605                         return "Started %s.";
606                 else if (result == JOB_FAILED)
607                         return "Failed to start %s.";
608                 else if (result == JOB_DEPENDENCY)
609                         return "Dependency failed for %s.";
610                 else if (result == JOB_TIMEOUT)
611                         return "Timed out starting %s.";
612         } else if (t == JOB_STOP || t == JOB_RESTART) {
613                 if (result == JOB_DONE)
614                         return "Stopped %s.";
615                 else if (result == JOB_FAILED)
616                         return "Stopped (with error) %s.";
617                 else if (result == JOB_TIMEOUT)
618                         return "Timed out stoppping %s.";
619         } else if (t == JOB_RELOAD) {
620                 if (result == JOB_DONE)
621                         return "Reloaded %s.";
622                 else if (result == JOB_FAILED)
623                         return "Reload failed for %s.";
624                 else if (result == JOB_TIMEOUT)
625                         return "Timed out reloading %s.";
626         }
627
628         return NULL;
629 }
630
631 static void job_print_status_message(Unit *u, JobType t, JobResult result) {
632         const char *format;
633
634         assert(u);
635         assert(t >= 0);
636         assert(t < _JOB_TYPE_MAX);
637
638         if (t == JOB_START) {
639                 format = job_get_status_message_format(u, t, result);
640                 if (!format)
641                         return;
642
643                 switch (result) {
644
645                 case JOB_DONE:
646                         if (u->condition_result)
647                                 unit_status_printf(u, ANSI_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, format);
648                         break;
649
650                 case JOB_FAILED:
651                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON "FAILED" ANSI_HIGHLIGHT_OFF, format);
652                         manager_status_printf(u->manager, false, NULL, "See 'systemctl status %s' for details.", u->id);
653                         break;
654
655                 case JOB_DEPENDENCY:
656                         unit_status_printf(u, ANSI_HIGHLIGHT_YELLOW_ON "DEPEND" ANSI_HIGHLIGHT_OFF, format);
657                         break;
658
659                 case JOB_TIMEOUT:
660                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
661                         break;
662
663                 default:
664                         ;
665                 }
666
667         } else if (t == JOB_STOP || t == JOB_RESTART) {
668
669                 format = job_get_status_message_format(u, t, result);
670                 if (!format)
671                         return;
672
673                 switch (result) {
674
675                 case JOB_TIMEOUT:
676                         unit_status_printf(u, ANSI_HIGHLIGHT_RED_ON " TIME " ANSI_HIGHLIGHT_OFF, format);
677                         break;
678
679                 case JOB_DONE:
680                 case JOB_FAILED:
681                         unit_status_printf(u, ANSI_GREEN_ON "  OK  " ANSI_HIGHLIGHT_OFF, format);
682                         break;
683
684                 default:
685                         ;
686                 }
687
688         } else if (t == JOB_VERIFY_ACTIVE) {
689
690                 /* When verify-active detects the unit is inactive, report it.
691                  * Most likely a DEPEND warning from a requisiting unit will
692                  * occur next and it's nice to see what was requisited. */
693                 if (result == JOB_SKIPPED)
694                         unit_status_printf(u, ANSI_HIGHLIGHT_ON " INFO " ANSI_HIGHLIGHT_OFF, "%s is not active.");
695         }
696 }
697
698 #pragma GCC diagnostic push
699 #pragma GCC diagnostic ignored "-Wformat-nonliteral"
700 static void job_log_status_message(Unit *u, JobType t, JobResult result) {
701         const char *format;
702         char buf[LINE_MAX];
703
704         assert(u);
705         assert(t >= 0);
706         assert(t < _JOB_TYPE_MAX);
707
708         /* Skip this if it goes to the console. since we already print
709          * to the console anyway... */
710
711         if (log_on_console())
712                 return;
713
714         format = job_get_status_message_format_try_harder(u, t, result);
715         if (!format)
716                 return;
717
718         snprintf(buf, sizeof(buf), format, unit_description(u));
719         char_array_0(buf);
720
721         if (t == JOB_START) {
722                 sd_id128_t mid;
723
724                 mid = result == JOB_DONE ? SD_MESSAGE_UNIT_STARTED : SD_MESSAGE_UNIT_FAILED;
725                 log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR,
726                            u->id,
727                            MESSAGE_ID(mid),
728                            "RESULT=%s", job_result_to_string(result),
729                            "MESSAGE=%s", buf,
730                            NULL);
731
732         } else if (t == JOB_STOP)
733                 log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR,
734                            u->id,
735                            MESSAGE_ID(SD_MESSAGE_UNIT_STOPPED),
736                            "RESULT=%s", job_result_to_string(result),
737                            "MESSAGE=%s", buf,
738                            NULL);
739
740         else if (t == JOB_RELOAD)
741                 log_struct_unit(result == JOB_DONE ? LOG_INFO : LOG_ERR,
742                            u->id,
743                            MESSAGE_ID(SD_MESSAGE_UNIT_RELOADED),
744                            "RESULT=%s", job_result_to_string(result),
745                            "MESSAGE=%s", buf,
746                            NULL);
747 }
748 #pragma GCC diagnostic pop
749
750 int job_finish_and_invalidate(Job *j, JobResult result, bool recursive) {
751         Unit *u;
752         Unit *other;
753         JobType t;
754         Iterator i;
755
756         assert(j);
757         assert(j->installed);
758         assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
759
760         u = j->unit;
761         t = j->type;
762
763         j->result = result;
764
765         if (j->state == JOB_RUNNING)
766                 j->manager->n_running_jobs--;
767
768         log_debug_unit(u->id, "Job %s/%s finished, result=%s",
769                        u->id, job_type_to_string(t), job_result_to_string(result));
770
771         job_print_status_message(u, t, result);
772         job_log_status_message(u, t, result);
773
774         job_add_to_dbus_queue(j);
775
776         /* Patch restart jobs so that they become normal start jobs */
777         if (result == JOB_DONE && t == JOB_RESTART) {
778
779                 job_change_type(j, JOB_START);
780                 j->state = JOB_WAITING;
781
782                 job_add_to_run_queue(j);
783
784                 goto finish;
785         }
786
787         if (result == JOB_FAILED)
788                 j->manager->n_failed_jobs ++;
789
790         job_uninstall(j);
791         job_free(j);
792
793         /* Fail depending jobs on failure */
794         if (result != JOB_DONE && recursive) {
795
796                 if (t == JOB_START ||
797                     t == JOB_VERIFY_ACTIVE) {
798
799                         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY], i)
800                                 if (other->job &&
801                                     (other->job->type == JOB_START ||
802                                      other->job->type == JOB_VERIFY_ACTIVE))
803                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
804
805                         SET_FOREACH(other, u->dependencies[UNIT_BOUND_BY], i)
806                                 if (other->job &&
807                                     (other->job->type == JOB_START ||
808                                      other->job->type == JOB_VERIFY_ACTIVE))
809                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
810
811                         SET_FOREACH(other, u->dependencies[UNIT_REQUIRED_BY_OVERRIDABLE], i)
812                                 if (other->job &&
813                                     !other->job->override &&
814                                     (other->job->type == JOB_START ||
815                                      other->job->type == JOB_VERIFY_ACTIVE))
816                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
817
818                 } else if (t == JOB_STOP) {
819
820                         SET_FOREACH(other, u->dependencies[UNIT_CONFLICTED_BY], i)
821                                 if (other->job &&
822                                     (other->job->type == JOB_START ||
823                                      other->job->type == JOB_VERIFY_ACTIVE))
824                                         job_finish_and_invalidate(other->job, JOB_DEPENDENCY, true);
825                 }
826         }
827
828         /* Trigger OnFailure dependencies that are not generated by
829          * the unit itself. We don't treat JOB_CANCELED as failure in
830          * this context. And JOB_FAILURE is already handled by the
831          * unit itself. */
832         if (result == JOB_TIMEOUT || result == JOB_DEPENDENCY) {
833                 log_struct_unit(LOG_NOTICE,
834                            u->id,
835                            "JOB_TYPE=%s", job_type_to_string(t),
836                            "JOB_RESULT=%s", job_result_to_string(result),
837                            "Job %s/%s failed with result '%s'.",
838                            u->id,
839                            job_type_to_string(t),
840                            job_result_to_string(result),
841                            NULL);
842
843                 unit_start_on_failure(u);
844         }
845
846         unit_trigger_notify(u);
847
848 finish:
849         /* Try to start the next jobs that can be started */
850         SET_FOREACH(other, u->dependencies[UNIT_AFTER], i)
851                 if (other->job)
852                         job_add_to_run_queue(other->job);
853         SET_FOREACH(other, u->dependencies[UNIT_BEFORE], i)
854                 if (other->job)
855                         job_add_to_run_queue(other->job);
856
857         manager_check_finished(u->manager);
858
859         return 0;
860 }
861
862 int job_start_timer(Job *j) {
863         struct itimerspec its = {};
864         struct epoll_event ev = {
865                 .data.ptr = &j->timer_watch,
866                 .events = EPOLLIN,
867         };
868         int fd, r;
869
870         if (j->unit->job_timeout <= 0 ||
871             j->timer_watch.type == WATCH_JOB_TIMER)
872                 return 0;
873
874         assert(j->timer_watch.type == WATCH_INVALID);
875
876         if ((fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK|TFD_CLOEXEC)) < 0) {
877                 r = -errno;
878                 goto fail;
879         }
880
881         timespec_store(&its.it_value, j->unit->job_timeout);
882
883         if (timerfd_settime(fd, 0, &its, NULL) < 0) {
884                 r = -errno;
885                 goto fail;
886         }
887
888         if (epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_ADD, fd, &ev) < 0) {
889                 r = -errno;
890                 goto fail;
891         }
892
893         j->timer_watch.type = WATCH_JOB_TIMER;
894         j->timer_watch.fd = fd;
895         j->timer_watch.data.job = j;
896
897         return 0;
898
899 fail:
900         if (fd >= 0)
901                 close_nointr_nofail(fd);
902
903         return r;
904 }
905
906 void job_add_to_run_queue(Job *j) {
907         assert(j);
908         assert(j->installed);
909
910         if (j->in_run_queue)
911                 return;
912
913         LIST_PREPEND(Job, run_queue, j->manager->run_queue, j);
914         j->in_run_queue = true;
915 }
916
917 void job_add_to_dbus_queue(Job *j) {
918         assert(j);
919         assert(j->installed);
920
921         if (j->in_dbus_queue)
922                 return;
923
924         /* We don't check if anybody is subscribed here, since this
925          * job might just have been created and not yet assigned to a
926          * connection/client. */
927
928         LIST_PREPEND(Job, dbus_queue, j->manager->dbus_job_queue, j);
929         j->in_dbus_queue = true;
930 }
931
932 char *job_dbus_path(Job *j) {
933         char *p;
934
935         assert(j);
936
937         if (asprintf(&p, "/org/freedesktop/systemd1/job/%lu", (unsigned long) j->id) < 0)
938                 return NULL;
939
940         return p;
941 }
942
943 void job_timer_event(Job *j, uint64_t n_elapsed, Watch *w) {
944         assert(j);
945         assert(w == &j->timer_watch);
946
947         log_warning_unit(j->unit->id, "Job %s/%s timed out.",
948                          j->unit->id, job_type_to_string(j->type));
949         job_finish_and_invalidate(j, JOB_TIMEOUT, true);
950 }
951
952 int job_serialize(Job *j, FILE *f, FDSet *fds) {
953         fprintf(f, "job-id=%u\n", j->id);
954         fprintf(f, "job-type=%s\n", job_type_to_string(j->type));
955         fprintf(f, "job-state=%s\n", job_state_to_string(j->state));
956         fprintf(f, "job-override=%s\n", yes_no(j->override));
957         fprintf(f, "job-irreversible=%s\n", yes_no(j->irreversible));
958         fprintf(f, "job-sent-dbus-new-signal=%s\n", yes_no(j->sent_dbus_new_signal));
959         fprintf(f, "job-ignore-order=%s\n", yes_no(j->ignore_order));
960         /* Cannot save bus clients. Just note the fact that we're losing
961          * them. job_send_message() will fallback to broadcasting. */
962         fprintf(f, "job-forgot-bus-clients=%s\n",
963                 yes_no(j->forgot_bus_clients || j->bus_client_list));
964         if (j->timer_watch.type == WATCH_JOB_TIMER) {
965                 int copy = fdset_put_dup(fds, j->timer_watch.fd);
966                 if (copy < 0)
967                         return copy;
968                 fprintf(f, "job-timer-watch-fd=%d\n", copy);
969         }
970
971         /* End marker */
972         fputc('\n', f);
973         return 0;
974 }
975
976 int job_deserialize(Job *j, FILE *f, FDSet *fds) {
977         for (;;) {
978                 char line[LINE_MAX], *l, *v;
979                 size_t k;
980
981                 if (!fgets(line, sizeof(line), f)) {
982                         if (feof(f))
983                                 return 0;
984                         return -errno;
985                 }
986
987                 char_array_0(line);
988                 l = strstrip(line);
989
990                 /* End marker */
991                 if (l[0] == 0)
992                         return 0;
993
994                 k = strcspn(l, "=");
995
996                 if (l[k] == '=') {
997                         l[k] = 0;
998                         v = l+k+1;
999                 } else
1000                         v = l+k;
1001
1002                 if (streq(l, "job-id")) {
1003                         if (safe_atou32(v, &j->id) < 0)
1004                                 log_debug("Failed to parse job id value %s", v);
1005                 } else if (streq(l, "job-type")) {
1006                         JobType t = job_type_from_string(v);
1007                         if (t < 0)
1008                                 log_debug("Failed to parse job type %s", v);
1009                         else if (t >= _JOB_TYPE_MAX_IN_TRANSACTION)
1010                                 log_debug("Cannot deserialize job of type %s", v);
1011                         else
1012                                 j->type = t;
1013                 } else if (streq(l, "job-state")) {
1014                         JobState s = job_state_from_string(v);
1015                         if (s < 0)
1016                                 log_debug("Failed to parse job state %s", v);
1017                         else
1018                                 j->state = s;
1019                 } else if (streq(l, "job-override")) {
1020                         int b = parse_boolean(v);
1021                         if (b < 0)
1022                                 log_debug("Failed to parse job override flag %s", v);
1023                         else
1024                                 j->override = j->override || b;
1025                 } else if (streq(l, "job-irreversible")) {
1026                         int b = parse_boolean(v);
1027                         if (b < 0)
1028                                 log_debug("Failed to parse job irreversible flag %s", v);
1029                         else
1030                                 j->irreversible = j->irreversible || b;
1031                 } else if (streq(l, "job-sent-dbus-new-signal")) {
1032                         int b = parse_boolean(v);
1033                         if (b < 0)
1034                                 log_debug("Failed to parse job sent_dbus_new_signal flag %s", v);
1035                         else
1036                                 j->sent_dbus_new_signal = j->sent_dbus_new_signal || b;
1037                 } else if (streq(l, "job-ignore-order")) {
1038                         int b = parse_boolean(v);
1039                         if (b < 0)
1040                                 log_debug("Failed to parse job ignore_order flag %s", v);
1041                         else
1042                                 j->ignore_order = j->ignore_order || b;
1043                 } else if (streq(l, "job-forgot-bus-clients")) {
1044                         int b = parse_boolean(v);
1045                         if (b < 0)
1046                                 log_debug("Failed to parse job forgot_bus_clients flag %s", v);
1047                         else
1048                                 j->forgot_bus_clients = j->forgot_bus_clients || b;
1049                 } else if (streq(l, "job-timer-watch-fd")) {
1050                         int fd;
1051                         if (safe_atoi(v, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
1052                                 log_debug("Failed to parse job-timer-watch-fd value %s", v);
1053                         else {
1054                                 if (j->timer_watch.type == WATCH_JOB_TIMER)
1055                                         close_nointr_nofail(j->timer_watch.fd);
1056
1057                                 j->timer_watch.type = WATCH_JOB_TIMER;
1058                                 j->timer_watch.fd = fdset_remove(fds, fd);
1059                                 j->timer_watch.data.job = j;
1060                         }
1061                 }
1062         }
1063 }
1064
1065 int job_coldplug(Job *j) {
1066         struct epoll_event ev = {
1067                 .data.ptr = &j->timer_watch,
1068                 .events = EPOLLIN,
1069         };
1070
1071         if (j->timer_watch.type != WATCH_JOB_TIMER)
1072                 return 0;
1073
1074         if (epoll_ctl(j->manager->epoll_fd, EPOLL_CTL_ADD, j->timer_watch.fd, &ev) < 0)
1075                 return -errno;
1076
1077         return 0;
1078 }
1079
1080 void job_shutdown_magic(Job *j) {
1081         assert(j);
1082
1083         /* The shutdown target gets some special treatment here: we
1084          * tell the kernel to begin with flushing its disk caches, to
1085          * optimize shutdown time a bit. Ideally we wouldn't hardcode
1086          * this magic into PID 1. However all other processes aren't
1087          * options either since they'd exit much sooner than PID 1 and
1088          * asynchronous sync() would cause their exit to be
1089          * delayed. */
1090
1091         if (!unit_has_name(j->unit, SPECIAL_SHUTDOWN_TARGET))
1092                 return;
1093
1094         if (j->type != JOB_START)
1095                 return;
1096
1097         if (detect_container(NULL) > 0)
1098                 return;
1099
1100         asynchronous_sync();
1101 }
1102
1103 static const char* const job_state_table[_JOB_STATE_MAX] = {
1104         [JOB_WAITING] = "waiting",
1105         [JOB_RUNNING] = "running"
1106 };
1107
1108 DEFINE_STRING_TABLE_LOOKUP(job_state, JobState);
1109
1110 static const char* const job_type_table[_JOB_TYPE_MAX] = {
1111         [JOB_START] = "start",
1112         [JOB_VERIFY_ACTIVE] = "verify-active",
1113         [JOB_STOP] = "stop",
1114         [JOB_RELOAD] = "reload",
1115         [JOB_RELOAD_OR_START] = "reload-or-start",
1116         [JOB_RESTART] = "restart",
1117         [JOB_TRY_RESTART] = "try-restart",
1118         [JOB_NOP] = "nop",
1119 };
1120
1121 DEFINE_STRING_TABLE_LOOKUP(job_type, JobType);
1122
1123 static const char* const job_mode_table[_JOB_MODE_MAX] = {
1124         [JOB_FAIL] = "fail",
1125         [JOB_REPLACE] = "replace",
1126         [JOB_REPLACE_IRREVERSIBLY] = "replace-irreversibly",
1127         [JOB_ISOLATE] = "isolate",
1128         [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
1129         [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements"
1130 };
1131
1132 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
1133
1134 static const char* const job_result_table[_JOB_RESULT_MAX] = {
1135         [JOB_DONE] = "done",
1136         [JOB_CANCELED] = "canceled",
1137         [JOB_TIMEOUT] = "timeout",
1138         [JOB_FAILED] = "failed",
1139         [JOB_DEPENDENCY] = "dependency",
1140         [JOB_SKIPPED] = "skipped"
1141 };
1142
1143 DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);