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