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