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