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