]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/job.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #7186 from poettering/track-deps
[thirdparty/systemd.git] / src / core / job.c
1 /***
2 This file is part of systemd.
3
4 Copyright 2010 Lennart Poettering
5
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
10
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
18 ***/
19
20 #include <errno.h>
21
22 #include "sd-id128.h"
23 #include "sd-messages.h"
24
25 #include "alloc-util.h"
26 #include "async.h"
27 #include "dbus-job.h"
28 #include "dbus.h"
29 #include "escape.h"
30 #include "job.h"
31 #include "log.h"
32 #include "macro.h"
33 #include "parse-util.h"
34 #include "set.h"
35 #include "special.h"
36 #include "stdio-util.h"
37 #include "string-table.h"
38 #include "string-util.h"
39 #include "strv.h"
40 #include "terminal-util.h"
41 #include "unit.h"
42 #include "virt.h"
43
44 Job* job_new_raw(Unit *unit) {
45 Job *j;
46
47 /* used for deserialization */
48
49 assert(unit);
50
51 j = new0(Job, 1);
52 if (!j)
53 return NULL;
54
55 j->manager = unit->manager;
56 j->unit = unit;
57 j->type = _JOB_TYPE_INVALID;
58
59 return j;
60 }
61
62 Job* job_new(Unit *unit, JobType type) {
63 Job *j;
64
65 assert(type < _JOB_TYPE_MAX);
66
67 j = job_new_raw(unit);
68 if (!j)
69 return NULL;
70
71 j->id = j->manager->current_job_id++;
72 j->type = type;
73
74 /* We don't link it here, that's what job_dependency() is for */
75
76 return j;
77 }
78
79 void job_free(Job *j) {
80 assert(j);
81 assert(!j->installed);
82 assert(!j->transaction_prev);
83 assert(!j->transaction_next);
84 assert(!j->subject_list);
85 assert(!j->object_list);
86
87 if (j->in_run_queue)
88 LIST_REMOVE(run_queue, j->manager->run_queue, j);
89
90 if (j->in_dbus_queue)
91 LIST_REMOVE(dbus_queue, j->manager->dbus_job_queue, j);
92
93 if (j->in_gc_queue)
94 LIST_REMOVE(gc_queue, j->manager->gc_job_queue, j);
95
96 sd_event_source_unref(j->timer_event_source);
97
98 sd_bus_track_unref(j->bus_track);
99 strv_free(j->deserialized_clients);
100
101 free(j);
102 }
103
104 static void job_set_state(Job *j, JobState state) {
105 assert(j);
106 assert(state >= 0);
107 assert(state < _JOB_STATE_MAX);
108
109 if (j->state == state)
110 return;
111
112 j->state = state;
113
114 if (!j->installed)
115 return;
116
117 if (j->state == JOB_RUNNING)
118 j->unit->manager->n_running_jobs++;
119 else {
120 assert(j->state == JOB_WAITING);
121 assert(j->unit->manager->n_running_jobs > 0);
122
123 j->unit->manager->n_running_jobs--;
124
125 if (j->unit->manager->n_running_jobs <= 0)
126 j->unit->manager->jobs_in_progress_event_source = sd_event_source_unref(j->unit->manager->jobs_in_progress_event_source);
127 }
128 }
129
130 void job_uninstall(Job *j) {
131 Job **pj;
132
133 assert(j->installed);
134
135 job_set_state(j, JOB_WAITING);
136
137 pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
138 assert(*pj == j);
139
140 /* Detach from next 'bigger' objects */
141
142 /* daemon-reload should be transparent to job observers */
143 if (!MANAGER_IS_RELOADING(j->manager))
144 bus_job_send_removed_signal(j);
145
146 *pj = NULL;
147
148 unit_add_to_gc_queue(j->unit);
149
150 hashmap_remove(j->manager->jobs, UINT32_TO_PTR(j->id));
151 j->installed = false;
152 }
153
154 static bool job_type_allows_late_merge(JobType t) {
155 /* Tells whether it is OK to merge a job of type 't' with an already
156 * running job.
157 * Reloads cannot be merged this way. Think of the sequence:
158 * 1. Reload of a daemon is in progress; the daemon has already loaded
159 * its config file, but hasn't completed the reload operation yet.
160 * 2. Edit foo's config file.
161 * 3. Trigger another reload to have the daemon use the new config.
162 * Should the second reload job be merged into the first one, the daemon
163 * would not know about the new config.
164 * JOB_RESTART jobs on the other hand can be merged, because they get
165 * patched into JOB_START after stopping the unit. So if we see a
166 * JOB_RESTART running, it means the unit hasn't stopped yet and at
167 * this time the merge is still allowed. */
168 return t != JOB_RELOAD;
169 }
170
171 static void job_merge_into_installed(Job *j, Job *other) {
172 assert(j->installed);
173 assert(j->unit == other->unit);
174
175 if (j->type != JOB_NOP)
176 job_type_merge_and_collapse(&j->type, other->type, j->unit);
177 else
178 assert(other->type == JOB_NOP);
179
180 j->irreversible = j->irreversible || other->irreversible;
181 j->ignore_order = j->ignore_order || other->ignore_order;
182 }
183
184 Job* job_install(Job *j) {
185 Job **pj;
186 Job *uj;
187
188 assert(!j->installed);
189 assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
190 assert(j->state == JOB_WAITING);
191
192 pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
193 uj = *pj;
194
195 if (uj) {
196 if (job_type_is_conflicting(uj->type, j->type))
197 job_finish_and_invalidate(uj, JOB_CANCELED, false, false);
198 else {
199 /* not conflicting, i.e. mergeable */
200
201 if (uj->state == JOB_WAITING ||
202 (job_type_allows_late_merge(j->type) && job_type_is_superset(uj->type, j->type))) {
203 job_merge_into_installed(uj, j);
204 log_unit_debug(uj->unit,
205 "Merged into installed job %s/%s as %u",
206 uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
207 return uj;
208 } else {
209 /* already running and not safe to merge into */
210 /* Patch uj to become a merged job and re-run it. */
211 /* XXX It should be safer to queue j to run after uj finishes, but it is
212 * not currently possible to have more than one installed job per unit. */
213 job_merge_into_installed(uj, j);
214 log_unit_debug(uj->unit,
215 "Merged into running job, re-running: %s/%s as %u",
216 uj->unit->id, job_type_to_string(uj->type), (unsigned) uj->id);
217
218 job_set_state(uj, JOB_WAITING);
219 return uj;
220 }
221 }
222 }
223
224 /* Install the job */
225 *pj = j;
226 j->installed = true;
227
228 j->manager->n_installed_jobs++;
229 log_unit_debug(j->unit,
230 "Installed new job %s/%s as %u",
231 j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
232
233 job_add_to_gc_queue(j);
234
235 return j;
236 }
237
238 int job_install_deserialized(Job *j) {
239 Job **pj;
240
241 assert(!j->installed);
242
243 if (j->type < 0 || j->type >= _JOB_TYPE_MAX_IN_TRANSACTION) {
244 log_debug("Invalid job type %s in deserialization.", strna(job_type_to_string(j->type)));
245 return -EINVAL;
246 }
247
248 pj = (j->type == JOB_NOP) ? &j->unit->nop_job : &j->unit->job;
249 if (*pj) {
250 log_unit_debug(j->unit, "Unit already has a job installed. Not installing deserialized job.");
251 return -EEXIST;
252 }
253
254 *pj = j;
255 j->installed = true;
256
257 if (j->state == JOB_RUNNING)
258 j->unit->manager->n_running_jobs++;
259
260 log_unit_debug(j->unit,
261 "Reinstalled deserialized job %s/%s as %u",
262 j->unit->id, job_type_to_string(j->type), (unsigned) j->id);
263 return 0;
264 }
265
266 JobDependency* job_dependency_new(Job *subject, Job *object, bool matters, bool conflicts) {
267 JobDependency *l;
268
269 assert(object);
270
271 /* Adds a new job link, which encodes that the 'subject' job
272 * needs the 'object' job in some way. If 'subject' is NULL
273 * this means the 'anchor' job (i.e. the one the user
274 * explicitly asked for) is the requester. */
275
276 l = new0(JobDependency, 1);
277 if (!l)
278 return NULL;
279
280 l->subject = subject;
281 l->object = object;
282 l->matters = matters;
283 l->conflicts = conflicts;
284
285 if (subject)
286 LIST_PREPEND(subject, subject->subject_list, l);
287
288 LIST_PREPEND(object, object->object_list, l);
289
290 return l;
291 }
292
293 void job_dependency_free(JobDependency *l) {
294 assert(l);
295
296 if (l->subject)
297 LIST_REMOVE(subject, l->subject->subject_list, l);
298
299 LIST_REMOVE(object, l->object->object_list, l);
300
301 free(l);
302 }
303
304 void job_dump(Job *j, FILE*f, const char *prefix) {
305 assert(j);
306 assert(f);
307
308 if (!prefix)
309 prefix = "";
310
311 fprintf(f,
312 "%s-> Job %u:\n"
313 "%s\tAction: %s -> %s\n"
314 "%s\tState: %s\n"
315 "%s\tIrreversible: %s\n",
316 prefix, j->id,
317 prefix, j->unit->id, job_type_to_string(j->type),
318 prefix, job_state_to_string(j->state),
319 prefix, yes_no(j->irreversible));
320 }
321
322 /*
323 * Merging is commutative, so imagine the matrix as symmetric. We store only
324 * its lower triangle to avoid duplication. We don't store the main diagonal,
325 * because A merged with A is simply A.
326 *
327 * If the resulting type is collapsed immediately afterwards (to get rid of
328 * the JOB_RELOAD_OR_START, which lies outside the lookup function's domain),
329 * the following properties hold:
330 *
331 * Merging is associative! A merged with B, and then merged with C is the same
332 * as A merged with the result of B merged with C.
333 *
334 * Mergeability is transitive! If A can be merged with B and B with C then
335 * A also with C.
336 *
337 * Also, if A merged with B cannot be merged with C, then either A or B cannot
338 * be merged with C either.
339 */
340 static const JobType job_merging_table[] = {
341 /* What \ With * JOB_START JOB_VERIFY_ACTIVE JOB_STOP JOB_RELOAD */
342 /*********************************************************************************/
343 /*JOB_START */
344 /*JOB_VERIFY_ACTIVE */ JOB_START,
345 /*JOB_STOP */ -1, -1,
346 /*JOB_RELOAD */ JOB_RELOAD_OR_START, JOB_RELOAD, -1,
347 /*JOB_RESTART */ JOB_RESTART, JOB_RESTART, -1, JOB_RESTART,
348 };
349
350 JobType job_type_lookup_merge(JobType a, JobType b) {
351 assert_cc(ELEMENTSOF(job_merging_table) == _JOB_TYPE_MAX_MERGING * (_JOB_TYPE_MAX_MERGING - 1) / 2);
352 assert(a >= 0 && a < _JOB_TYPE_MAX_MERGING);
353 assert(b >= 0 && b < _JOB_TYPE_MAX_MERGING);
354
355 if (a == b)
356 return a;
357
358 if (a < b) {
359 JobType tmp = a;
360 a = b;
361 b = tmp;
362 }
363
364 return job_merging_table[(a - 1) * a / 2 + b];
365 }
366
367 bool job_type_is_redundant(JobType a, UnitActiveState b) {
368 switch (a) {
369
370 case JOB_START:
371 return IN_SET(b, UNIT_ACTIVE, UNIT_RELOADING);
372
373 case JOB_STOP:
374 return IN_SET(b, UNIT_INACTIVE, UNIT_FAILED);
375
376 case JOB_VERIFY_ACTIVE:
377 return IN_SET(b, UNIT_ACTIVE, UNIT_RELOADING);
378
379 case JOB_RELOAD:
380 return
381 b == UNIT_RELOADING;
382
383 case JOB_RESTART:
384 return
385 b == UNIT_ACTIVATING;
386
387 case JOB_NOP:
388 return true;
389
390 default:
391 assert_not_reached("Invalid job type");
392 }
393 }
394
395 JobType job_type_collapse(JobType t, Unit *u) {
396 UnitActiveState s;
397
398 switch (t) {
399
400 case JOB_TRY_RESTART:
401 s = unit_active_state(u);
402 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
403 return JOB_NOP;
404
405 return JOB_RESTART;
406
407 case JOB_TRY_RELOAD:
408 s = unit_active_state(u);
409 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
410 return JOB_NOP;
411
412 return JOB_RELOAD;
413
414 case JOB_RELOAD_OR_START:
415 s = unit_active_state(u);
416 if (UNIT_IS_INACTIVE_OR_DEACTIVATING(s))
417 return JOB_START;
418
419 return JOB_RELOAD;
420
421 default:
422 return t;
423 }
424 }
425
426 int job_type_merge_and_collapse(JobType *a, JobType b, Unit *u) {
427 JobType t;
428
429 t = job_type_lookup_merge(*a, b);
430 if (t < 0)
431 return -EEXIST;
432
433 *a = job_type_collapse(t, u);
434 return 0;
435 }
436
437 static bool job_is_runnable(Job *j) {
438 Iterator i;
439 Unit *other;
440 void *v;
441
442 assert(j);
443 assert(j->installed);
444
445 /* Checks whether there is any job running for the units this
446 * job needs to be running after (in the case of a 'positive'
447 * job type) or before (in the case of a 'negative' job
448 * type. */
449
450 /* Note that unit types have a say in what is runnable,
451 * too. For example, if they return -EAGAIN from
452 * unit_start() they can indicate they are not
453 * runnable yet. */
454
455 /* First check if there is an override */
456 if (j->ignore_order)
457 return true;
458
459 if (j->type == JOB_NOP)
460 return true;
461
462 if (IN_SET(j->type, JOB_START, JOB_VERIFY_ACTIVE, JOB_RELOAD)) {
463 /* Immediate result is that the job is or might be
464 * started. In this case let's wait for the
465 * dependencies, regardless whether they are
466 * starting or stopping something. */
467
468 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i)
469 if (other->job)
470 return false;
471 }
472
473 /* Also, if something else is being stopped and we should
474 * change state after it, then let's wait. */
475
476 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i)
477 if (other->job &&
478 IN_SET(other->job->type, JOB_STOP, JOB_RESTART))
479 return false;
480
481 /* This means that for a service a and a service b where b
482 * shall be started after a:
483 *
484 * start a + start b → 1st step start a, 2nd step start b
485 * start a + stop b → 1st step stop b, 2nd step start a
486 * stop a + start b → 1st step stop a, 2nd step start b
487 * stop a + stop b → 1st step stop b, 2nd step stop a
488 *
489 * This has the side effect that restarts are properly
490 * synchronized too. */
491
492 return true;
493 }
494
495 static void job_change_type(Job *j, JobType newtype) {
496 assert(j);
497
498 log_unit_debug(j->unit,
499 "Converting job %s/%s -> %s/%s",
500 j->unit->id, job_type_to_string(j->type),
501 j->unit->id, job_type_to_string(newtype));
502
503 j->type = newtype;
504 }
505
506 static int job_perform_on_unit(Job **j) {
507 uint32_t id;
508 Manager *m;
509 JobType t;
510 Unit *u;
511 int r;
512
513 /* While we execute this operation the job might go away (for
514 * example: because it finishes immediately or is replaced by
515 * a new, conflicting job.) To make sure we don't access a
516 * freed job later on we store the id here, so that we can
517 * verify the job is still valid. */
518
519 assert(j);
520 assert(*j);
521
522 m = (*j)->manager;
523 u = (*j)->unit;
524 t = (*j)->type;
525 id = (*j)->id;
526
527 switch (t) {
528 case JOB_START:
529 r = unit_start(u);
530 break;
531
532 case JOB_RESTART:
533 t = JOB_STOP;
534 /* fall through */
535 case JOB_STOP:
536 r = unit_stop(u);
537 break;
538
539 case JOB_RELOAD:
540 r = unit_reload(u);
541 break;
542
543 default:
544 assert_not_reached("Invalid job type");
545 }
546
547 /* Log if the job still exists and the start/stop/reload function
548 * actually did something. */
549 *j = manager_get_job(m, id);
550 if (*j && r > 0)
551 unit_status_emit_starting_stopping_reloading(u, t);
552
553 return r;
554 }
555
556 int job_run_and_invalidate(Job *j) {
557 int r;
558
559 assert(j);
560 assert(j->installed);
561 assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
562 assert(j->in_run_queue);
563
564 LIST_REMOVE(run_queue, j->manager->run_queue, j);
565 j->in_run_queue = false;
566
567 if (j->state != JOB_WAITING)
568 return 0;
569
570 if (!job_is_runnable(j))
571 return -EAGAIN;
572
573 job_start_timer(j, true);
574 job_set_state(j, JOB_RUNNING);
575 job_add_to_dbus_queue(j);
576
577
578 switch (j->type) {
579
580 case JOB_VERIFY_ACTIVE: {
581 UnitActiveState t = unit_active_state(j->unit);
582 if (UNIT_IS_ACTIVE_OR_RELOADING(t))
583 r = -EALREADY;
584 else if (t == UNIT_ACTIVATING)
585 r = -EAGAIN;
586 else
587 r = -EBADR;
588 break;
589 }
590
591 case JOB_START:
592 case JOB_STOP:
593 case JOB_RESTART:
594 r = job_perform_on_unit(&j);
595
596 /* If the unit type does not support starting/stopping,
597 * then simply wait. */
598 if (r == -EBADR)
599 r = 0;
600 break;
601
602 case JOB_RELOAD:
603 r = job_perform_on_unit(&j);
604 break;
605
606 case JOB_NOP:
607 r = -EALREADY;
608 break;
609
610 default:
611 assert_not_reached("Unknown job type");
612 }
613
614 if (j) {
615 if (r == -EALREADY)
616 r = job_finish_and_invalidate(j, JOB_DONE, true, true);
617 else if (r == -EBADR)
618 r = job_finish_and_invalidate(j, JOB_SKIPPED, true, false);
619 else if (r == -ENOEXEC)
620 r = job_finish_and_invalidate(j, JOB_INVALID, true, false);
621 else if (r == -EPROTO)
622 r = job_finish_and_invalidate(j, JOB_ASSERT, true, false);
623 else if (r == -EOPNOTSUPP)
624 r = job_finish_and_invalidate(j, JOB_UNSUPPORTED, true, false);
625 else if (r == -ENOLINK)
626 r = job_finish_and_invalidate(j, JOB_DEPENDENCY, true, false);
627 else if (r == -EAGAIN)
628 job_set_state(j, JOB_WAITING);
629 else if (r < 0)
630 r = job_finish_and_invalidate(j, JOB_FAILED, true, false);
631 }
632
633 return r;
634 }
635
636 _pure_ static const char *job_get_status_message_format(Unit *u, JobType t, JobResult result) {
637
638 static const char *const generic_finished_start_job[_JOB_RESULT_MAX] = {
639 [JOB_DONE] = "Started %s.",
640 [JOB_TIMEOUT] = "Timed out starting %s.",
641 [JOB_FAILED] = "Failed to start %s.",
642 [JOB_DEPENDENCY] = "Dependency failed for %s.",
643 [JOB_ASSERT] = "Assertion failed for %s.",
644 [JOB_UNSUPPORTED] = "Starting of %s not supported.",
645 [JOB_COLLECTED] = "Unnecessary job for %s was removed.",
646 };
647 static const char *const generic_finished_stop_job[_JOB_RESULT_MAX] = {
648 [JOB_DONE] = "Stopped %s.",
649 [JOB_FAILED] = "Stopped (with error) %s.",
650 [JOB_TIMEOUT] = "Timed out stopping %s.",
651 };
652 static const char *const generic_finished_reload_job[_JOB_RESULT_MAX] = {
653 [JOB_DONE] = "Reloaded %s.",
654 [JOB_FAILED] = "Reload failed for %s.",
655 [JOB_TIMEOUT] = "Timed out reloading %s.",
656 };
657 /* When verify-active detects the unit is inactive, report it.
658 * Most likely a DEPEND warning from a requisiting unit will
659 * occur next and it's nice to see what was requisited. */
660 static const char *const generic_finished_verify_active_job[_JOB_RESULT_MAX] = {
661 [JOB_SKIPPED] = "%s is not active.",
662 };
663
664 const UnitStatusMessageFormats *format_table;
665 const char *format;
666
667 assert(u);
668 assert(t >= 0);
669 assert(t < _JOB_TYPE_MAX);
670
671 if (IN_SET(t, JOB_START, JOB_STOP, JOB_RESTART)) {
672 format_table = &UNIT_VTABLE(u)->status_message_formats;
673 if (format_table) {
674 format = t == JOB_START ? format_table->finished_start_job[result] :
675 format_table->finished_stop_job[result];
676 if (format)
677 return format;
678 }
679 }
680
681 /* Return generic strings */
682 if (t == JOB_START)
683 return generic_finished_start_job[result];
684 else if (IN_SET(t, JOB_STOP, JOB_RESTART))
685 return generic_finished_stop_job[result];
686 else if (t == JOB_RELOAD)
687 return generic_finished_reload_job[result];
688 else if (t == JOB_VERIFY_ACTIVE)
689 return generic_finished_verify_active_job[result];
690
691 return NULL;
692 }
693
694 static const struct {
695 const char *color, *word;
696 } job_print_status_messages [_JOB_RESULT_MAX] = {
697 [JOB_DONE] = { ANSI_GREEN, " OK " },
698 [JOB_TIMEOUT] = { ANSI_HIGHLIGHT_RED, " TIME " },
699 [JOB_FAILED] = { ANSI_HIGHLIGHT_RED, "FAILED" },
700 [JOB_DEPENDENCY] = { ANSI_HIGHLIGHT_YELLOW, "DEPEND" },
701 [JOB_SKIPPED] = { ANSI_HIGHLIGHT, " INFO " },
702 [JOB_ASSERT] = { ANSI_HIGHLIGHT_YELLOW, "ASSERT" },
703 [JOB_UNSUPPORTED] = { ANSI_HIGHLIGHT_YELLOW, "UNSUPP" },
704 /* JOB_COLLECTED */
705 };
706
707 static void job_print_status_message(Unit *u, JobType t, JobResult result) {
708 const char *format;
709 const char *status;
710
711 assert(u);
712 assert(t >= 0);
713 assert(t < _JOB_TYPE_MAX);
714
715 /* Reload status messages have traditionally not been printed to console. */
716 if (t == JOB_RELOAD)
717 return;
718
719 if (!job_print_status_messages[result].word)
720 return;
721
722 format = job_get_status_message_format(u, t, result);
723 if (!format)
724 return;
725
726 if (log_get_show_color())
727 status = strjoina(job_print_status_messages[result].color,
728 job_print_status_messages[result].word,
729 ANSI_NORMAL);
730 else
731 status = job_print_status_messages[result].word;
732
733 if (result != JOB_DONE)
734 manager_flip_auto_status(u->manager, true);
735
736 DISABLE_WARNING_FORMAT_NONLITERAL;
737 unit_status_printf(u, status, format);
738 REENABLE_WARNING;
739
740 if (t == JOB_START && result == JOB_FAILED) {
741 _cleanup_free_ char *quoted;
742
743 quoted = shell_maybe_quote(u->id, ESCAPE_BACKSLASH);
744 manager_status_printf(u->manager, STATUS_TYPE_NORMAL, NULL, "See 'systemctl status %s' for details.", strna(quoted));
745 }
746 }
747
748 static void job_log_status_message(Unit *u, JobType t, JobResult result) {
749 const char *format, *mid;
750 char buf[LINE_MAX];
751 static const int job_result_log_level[_JOB_RESULT_MAX] = {
752 [JOB_DONE] = LOG_INFO,
753 [JOB_CANCELED] = LOG_INFO,
754 [JOB_TIMEOUT] = LOG_ERR,
755 [JOB_FAILED] = LOG_ERR,
756 [JOB_DEPENDENCY] = LOG_WARNING,
757 [JOB_SKIPPED] = LOG_NOTICE,
758 [JOB_INVALID] = LOG_INFO,
759 [JOB_ASSERT] = LOG_WARNING,
760 [JOB_UNSUPPORTED] = LOG_WARNING,
761 [JOB_COLLECTED] = LOG_INFO,
762 };
763
764 assert(u);
765 assert(t >= 0);
766 assert(t < _JOB_TYPE_MAX);
767
768 /* Skip printing if output goes to the console, and job_print_status_message()
769 will actually print something to the console. */
770 if (log_on_console() && job_print_status_messages[result].word)
771 return;
772
773 format = job_get_status_message_format(u, t, result);
774 if (!format)
775 return;
776
777 /* The description might be longer than the buffer, but that's OK, we'll just truncate it here */
778 DISABLE_WARNING_FORMAT_NONLITERAL;
779 snprintf(buf, sizeof(buf), format, unit_description(u));
780 REENABLE_WARNING;
781
782 switch (t) {
783
784 case JOB_START:
785 if (result == JOB_DONE)
786 mid = "MESSAGE_ID=" SD_MESSAGE_UNIT_STARTED_STR;
787 else
788 mid = "MESSAGE_ID=" SD_MESSAGE_UNIT_FAILED_STR;
789 break;
790
791 case JOB_RELOAD:
792 mid = "MESSAGE_ID=" SD_MESSAGE_UNIT_RELOADED_STR;
793 break;
794
795 case JOB_STOP:
796 case JOB_RESTART:
797 mid = "MESSAGE_ID=" SD_MESSAGE_UNIT_STOPPED_STR;
798 break;
799
800 default:
801 log_struct(job_result_log_level[result],
802 LOG_MESSAGE("%s", buf),
803 "JOB_TYPE=%s", job_type_to_string(t),
804 "JOB_RESULT=%s", job_result_to_string(result),
805 LOG_UNIT_ID(u),
806 LOG_UNIT_INVOCATION_ID(u),
807 NULL);
808 return;
809 }
810
811 log_struct(job_result_log_level[result],
812 LOG_MESSAGE("%s", buf),
813 "JOB_TYPE=%s", job_type_to_string(t),
814 "JOB_RESULT=%s", job_result_to_string(result),
815 LOG_UNIT_ID(u),
816 LOG_UNIT_INVOCATION_ID(u),
817 mid,
818 NULL);
819 }
820
821 static void job_emit_status_message(Unit *u, JobType t, JobResult result) {
822 assert(u);
823
824 /* No message if the job did not actually do anything due to failed condition. */
825 if (t == JOB_START && result == JOB_DONE && !u->condition_result)
826 return;
827
828 job_log_status_message(u, t, result);
829 job_print_status_message(u, t, result);
830 }
831
832 static void job_fail_dependencies(Unit *u, UnitDependency d) {
833 Unit *other;
834 Iterator i;
835 void *v;
836
837 assert(u);
838
839 HASHMAP_FOREACH_KEY(v, other, u->dependencies[d], i) {
840 Job *j = other->job;
841
842 if (!j)
843 continue;
844 if (!IN_SET(j->type, JOB_START, JOB_VERIFY_ACTIVE))
845 continue;
846
847 job_finish_and_invalidate(j, JOB_DEPENDENCY, true, false);
848 }
849 }
850
851 int job_finish_and_invalidate(Job *j, JobResult result, bool recursive, bool already) {
852 Unit *u;
853 Unit *other;
854 JobType t;
855 Iterator i;
856 void *v;
857
858 assert(j);
859 assert(j->installed);
860 assert(j->type < _JOB_TYPE_MAX_IN_TRANSACTION);
861
862 u = j->unit;
863 t = j->type;
864
865 j->result = result;
866
867 log_unit_debug(u, "Job %s/%s finished, result=%s", u->id, job_type_to_string(t), job_result_to_string(result));
868
869 /* If this job did nothing to respective unit we don't log the status message */
870 if (!already)
871 job_emit_status_message(u, t, result);
872
873 /* Patch restart jobs so that they become normal start jobs */
874 if (result == JOB_DONE && t == JOB_RESTART) {
875
876 job_change_type(j, JOB_START);
877 job_set_state(j, JOB_WAITING);
878
879 job_add_to_dbus_queue(j);
880 job_add_to_run_queue(j);
881 job_add_to_gc_queue(j);
882
883 goto finish;
884 }
885
886 if (IN_SET(result, JOB_FAILED, JOB_INVALID))
887 j->manager->n_failed_jobs++;
888
889 job_uninstall(j);
890 job_free(j);
891
892 /* Fail depending jobs on failure */
893 if (result != JOB_DONE && recursive) {
894 if (IN_SET(t, JOB_START, JOB_VERIFY_ACTIVE)) {
895 job_fail_dependencies(u, UNIT_REQUIRED_BY);
896 job_fail_dependencies(u, UNIT_REQUISITE_OF);
897 job_fail_dependencies(u, UNIT_BOUND_BY);
898 } else if (t == JOB_STOP)
899 job_fail_dependencies(u, UNIT_CONFLICTED_BY);
900 }
901
902 /* Trigger OnFailure dependencies that are not generated by
903 * the unit itself. We don't treat JOB_CANCELED as failure in
904 * this context. And JOB_FAILURE is already handled by the
905 * unit itself. */
906 if (IN_SET(result, JOB_TIMEOUT, JOB_DEPENDENCY)) {
907 log_struct(LOG_NOTICE,
908 "JOB_TYPE=%s", job_type_to_string(t),
909 "JOB_RESULT=%s", job_result_to_string(result),
910 LOG_UNIT_ID(u),
911 LOG_UNIT_MESSAGE(u, "Job %s/%s failed with result '%s'.",
912 u->id,
913 job_type_to_string(t),
914 job_result_to_string(result)),
915 NULL);
916
917 unit_start_on_failure(u);
918 }
919
920 unit_trigger_notify(u);
921
922 finish:
923 /* Try to start the next jobs that can be started */
924 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_AFTER], i)
925 if (other->job) {
926 job_add_to_run_queue(other->job);
927 job_add_to_gc_queue(other->job);
928 }
929 HASHMAP_FOREACH_KEY(v, other, u->dependencies[UNIT_BEFORE], i)
930 if (other->job) {
931 job_add_to_run_queue(other->job);
932 job_add_to_gc_queue(other->job);
933 }
934
935 manager_check_finished(u->manager);
936
937 return 0;
938 }
939
940 static int job_dispatch_timer(sd_event_source *s, uint64_t monotonic, void *userdata) {
941 Job *j = userdata;
942 Unit *u;
943
944 assert(j);
945 assert(s == j->timer_event_source);
946
947 log_unit_warning(j->unit, "Job %s/%s timed out.", j->unit->id, job_type_to_string(j->type));
948
949 u = j->unit;
950 job_finish_and_invalidate(j, JOB_TIMEOUT, true, false);
951
952 emergency_action(u->manager, u->job_timeout_action, u->job_timeout_reboot_arg, "job timed out");
953
954 return 0;
955 }
956
957 int job_start_timer(Job *j, bool job_running) {
958 int r;
959 usec_t timeout_time, old_timeout_time;
960
961 if (job_running) {
962 j->begin_running_usec = now(CLOCK_MONOTONIC);
963
964 if (j->unit->job_running_timeout == USEC_INFINITY)
965 return 0;
966
967 timeout_time = usec_add(j->begin_running_usec, j->unit->job_running_timeout);
968
969 if (j->timer_event_source) {
970 /* Update only if JobRunningTimeoutSec= results in earlier timeout */
971 r = sd_event_source_get_time(j->timer_event_source, &old_timeout_time);
972 if (r < 0)
973 return r;
974
975 if (old_timeout_time <= timeout_time)
976 return 0;
977
978 return sd_event_source_set_time(j->timer_event_source, timeout_time);
979 }
980 } else {
981 if (j->timer_event_source)
982 return 0;
983
984 j->begin_usec = now(CLOCK_MONOTONIC);
985
986 if (j->unit->job_timeout == USEC_INFINITY)
987 return 0;
988
989 timeout_time = usec_add(j->begin_usec, j->unit->job_timeout);
990 }
991
992 r = sd_event_add_time(
993 j->manager->event,
994 &j->timer_event_source,
995 CLOCK_MONOTONIC,
996 timeout_time, 0,
997 job_dispatch_timer, j);
998 if (r < 0)
999 return r;
1000
1001 (void) sd_event_source_set_description(j->timer_event_source, "job-start");
1002
1003 return 0;
1004 }
1005
1006 void job_add_to_run_queue(Job *j) {
1007 assert(j);
1008 assert(j->installed);
1009
1010 if (j->in_run_queue)
1011 return;
1012
1013 if (!j->manager->run_queue)
1014 sd_event_source_set_enabled(j->manager->run_queue_event_source, SD_EVENT_ONESHOT);
1015
1016 LIST_PREPEND(run_queue, j->manager->run_queue, j);
1017 j->in_run_queue = true;
1018 }
1019
1020 void job_add_to_dbus_queue(Job *j) {
1021 assert(j);
1022 assert(j->installed);
1023
1024 if (j->in_dbus_queue)
1025 return;
1026
1027 /* We don't check if anybody is subscribed here, since this
1028 * job might just have been created and not yet assigned to a
1029 * connection/client. */
1030
1031 LIST_PREPEND(dbus_queue, j->manager->dbus_job_queue, j);
1032 j->in_dbus_queue = true;
1033 }
1034
1035 char *job_dbus_path(Job *j) {
1036 char *p;
1037
1038 assert(j);
1039
1040 if (asprintf(&p, "/org/freedesktop/systemd1/job/%"PRIu32, j->id) < 0)
1041 return NULL;
1042
1043 return p;
1044 }
1045
1046 int job_serialize(Job *j, FILE *f) {
1047 assert(j);
1048 assert(f);
1049
1050 fprintf(f, "job-id=%u\n", j->id);
1051 fprintf(f, "job-type=%s\n", job_type_to_string(j->type));
1052 fprintf(f, "job-state=%s\n", job_state_to_string(j->state));
1053 fprintf(f, "job-irreversible=%s\n", yes_no(j->irreversible));
1054 fprintf(f, "job-sent-dbus-new-signal=%s\n", yes_no(j->sent_dbus_new_signal));
1055 fprintf(f, "job-ignore-order=%s\n", yes_no(j->ignore_order));
1056
1057 if (j->begin_usec > 0)
1058 fprintf(f, "job-begin="USEC_FMT"\n", j->begin_usec);
1059 if (j->begin_running_usec > 0)
1060 fprintf(f, "job-begin-running="USEC_FMT"\n", j->begin_running_usec);
1061
1062 bus_track_serialize(j->bus_track, f, "subscribed");
1063
1064 /* End marker */
1065 fputc('\n', f);
1066 return 0;
1067 }
1068
1069 int job_deserialize(Job *j, FILE *f) {
1070 assert(j);
1071 assert(f);
1072
1073 for (;;) {
1074 char line[LINE_MAX], *l, *v;
1075 size_t k;
1076
1077 if (!fgets(line, sizeof(line), f)) {
1078 if (feof(f))
1079 return 0;
1080 return -errno;
1081 }
1082
1083 char_array_0(line);
1084 l = strstrip(line);
1085
1086 /* End marker */
1087 if (l[0] == 0)
1088 return 0;
1089
1090 k = strcspn(l, "=");
1091
1092 if (l[k] == '=') {
1093 l[k] = 0;
1094 v = l+k+1;
1095 } else
1096 v = l+k;
1097
1098 if (streq(l, "job-id")) {
1099
1100 if (safe_atou32(v, &j->id) < 0)
1101 log_debug("Failed to parse job id value %s", v);
1102
1103 } else if (streq(l, "job-type")) {
1104 JobType t;
1105
1106 t = job_type_from_string(v);
1107 if (t < 0)
1108 log_debug("Failed to parse job type %s", v);
1109 else if (t >= _JOB_TYPE_MAX_IN_TRANSACTION)
1110 log_debug("Cannot deserialize job of type %s", v);
1111 else
1112 j->type = t;
1113
1114 } else if (streq(l, "job-state")) {
1115 JobState s;
1116
1117 s = job_state_from_string(v);
1118 if (s < 0)
1119 log_debug("Failed to parse job state %s", v);
1120 else
1121 job_set_state(j, s);
1122
1123 } else if (streq(l, "job-irreversible")) {
1124 int b;
1125
1126 b = parse_boolean(v);
1127 if (b < 0)
1128 log_debug("Failed to parse job irreversible flag %s", v);
1129 else
1130 j->irreversible = j->irreversible || b;
1131
1132 } else if (streq(l, "job-sent-dbus-new-signal")) {
1133 int b;
1134
1135 b = parse_boolean(v);
1136 if (b < 0)
1137 log_debug("Failed to parse job sent_dbus_new_signal flag %s", v);
1138 else
1139 j->sent_dbus_new_signal = j->sent_dbus_new_signal || b;
1140
1141 } else if (streq(l, "job-ignore-order")) {
1142 int b;
1143
1144 b = parse_boolean(v);
1145 if (b < 0)
1146 log_debug("Failed to parse job ignore_order flag %s", v);
1147 else
1148 j->ignore_order = j->ignore_order || b;
1149
1150 } else if (streq(l, "job-begin")) {
1151 unsigned long long ull;
1152
1153 if (sscanf(v, "%llu", &ull) != 1)
1154 log_debug("Failed to parse job-begin value %s", v);
1155 else
1156 j->begin_usec = ull;
1157
1158 } else if (streq(l, "job-begin-running")) {
1159 unsigned long long ull;
1160
1161 if (sscanf(v, "%llu", &ull) != 1)
1162 log_debug("Failed to parse job-begin-running value %s", v);
1163 else
1164 j->begin_running_usec = ull;
1165
1166 } else if (streq(l, "subscribed")) {
1167
1168 if (strv_extend(&j->deserialized_clients, v) < 0)
1169 log_oom();
1170 }
1171 }
1172 }
1173
1174 int job_coldplug(Job *j) {
1175 int r;
1176 usec_t timeout_time = USEC_INFINITY;
1177
1178 assert(j);
1179
1180 /* After deserialization is complete and the bus connection
1181 * set up again, let's start watching our subscribers again */
1182 (void) bus_job_coldplug_bus_track(j);
1183
1184 if (j->state == JOB_WAITING)
1185 job_add_to_run_queue(j);
1186
1187 /* Maybe due to new dependencies we don't actually need this job anymore? */
1188 job_add_to_gc_queue(j);
1189
1190 /* Create timer only when job began or began running and the respective timeout is finite.
1191 * Follow logic of job_start_timer() if both timeouts are finite */
1192 if (j->begin_usec == 0)
1193 return 0;
1194
1195 if (j->unit->job_timeout != USEC_INFINITY)
1196 timeout_time = usec_add(j->begin_usec, j->unit->job_timeout);
1197
1198 if (j->begin_running_usec > 0 && j->unit->job_running_timeout != USEC_INFINITY)
1199 timeout_time = MIN(timeout_time, usec_add(j->begin_running_usec, j->unit->job_running_timeout));
1200
1201 if (timeout_time == USEC_INFINITY)
1202 return 0;
1203
1204 j->timer_event_source = sd_event_source_unref(j->timer_event_source);
1205
1206 r = sd_event_add_time(
1207 j->manager->event,
1208 &j->timer_event_source,
1209 CLOCK_MONOTONIC,
1210 timeout_time, 0,
1211 job_dispatch_timer, j);
1212 if (r < 0)
1213 log_debug_errno(r, "Failed to restart timeout for job: %m");
1214
1215 (void) sd_event_source_set_description(j->timer_event_source, "job-timeout");
1216
1217 return r;
1218 }
1219
1220 void job_shutdown_magic(Job *j) {
1221 assert(j);
1222
1223 /* The shutdown target gets some special treatment here: we
1224 * tell the kernel to begin with flushing its disk caches, to
1225 * optimize shutdown time a bit. Ideally we wouldn't hardcode
1226 * this magic into PID 1. However all other processes aren't
1227 * options either since they'd exit much sooner than PID 1 and
1228 * asynchronous sync() would cause their exit to be
1229 * delayed. */
1230
1231 if (j->type != JOB_START)
1232 return;
1233
1234 if (!MANAGER_IS_SYSTEM(j->unit->manager))
1235 return;
1236
1237 if (!unit_has_name(j->unit, SPECIAL_SHUTDOWN_TARGET))
1238 return;
1239
1240 /* In case messages on console has been disabled on boot */
1241 j->unit->manager->no_console_output = false;
1242
1243 if (detect_container() > 0)
1244 return;
1245
1246 asynchronous_sync();
1247 }
1248
1249 int job_get_timeout(Job *j, usec_t *timeout) {
1250 usec_t x = USEC_INFINITY, y = USEC_INFINITY;
1251 Unit *u = j->unit;
1252 int r;
1253
1254 assert(u);
1255
1256 if (j->timer_event_source) {
1257 r = sd_event_source_get_time(j->timer_event_source, &x);
1258 if (r < 0)
1259 return r;
1260 }
1261
1262 if (UNIT_VTABLE(u)->get_timeout) {
1263 r = UNIT_VTABLE(u)->get_timeout(u, &y);
1264 if (r < 0)
1265 return r;
1266 }
1267
1268 if (x == USEC_INFINITY && y == USEC_INFINITY)
1269 return 0;
1270
1271 *timeout = MIN(x, y);
1272 return 1;
1273 }
1274
1275 bool job_check_gc(Job *j) {
1276 Unit *other;
1277 Iterator i;
1278 void *v;
1279
1280 assert(j);
1281
1282 /* Checks whether this job should be GC'ed away. We only do this for jobs of units that have no effect on their
1283 * own and just track external state. For now the only unit type that qualifies for this are .device units. */
1284
1285 if (!UNIT_VTABLE(j->unit)->gc_jobs)
1286 return true;
1287
1288 if (sd_bus_track_count(j->bus_track) > 0)
1289 return true;
1290
1291 /* FIXME: So this is a bit ugly: for now we don't properly track references made via private bus connections
1292 * (because it's nasty, as sd_bus_track doesn't apply to it). We simply remember that the job was once
1293 * referenced by one, and reset this whenever we notice that no private bus connections are around. This means
1294 * the GC is a bit too conservative when it comes to jobs created by private bus connections. */
1295 if (j->ref_by_private_bus) {
1296 if (set_isempty(j->unit->manager->private_buses))
1297 j->ref_by_private_bus = false;
1298 else
1299 return true;
1300 }
1301
1302 if (j->type == JOB_NOP)
1303 return true;
1304
1305 /* If a job is ordered after ours, and is to be started, then it needs to wait for us, regardless if we stop or
1306 * start, hence let's not GC in that case. */
1307 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i) {
1308 if (!other->job)
1309 continue;
1310
1311 if (other->job->ignore_order)
1312 continue;
1313
1314 if (IN_SET(other->job->type, JOB_START, JOB_VERIFY_ACTIVE, JOB_RELOAD))
1315 return true;
1316 }
1317
1318 /* If we are going down, but something else is ordered After= us, then it needs to wait for us */
1319 if (IN_SET(j->type, JOB_STOP, JOB_RESTART))
1320 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i) {
1321 if (!other->job)
1322 continue;
1323
1324 if (other->job->ignore_order)
1325 continue;
1326
1327 return true;
1328 }
1329
1330 /* The logic above is kinda the inverse of the job_is_runnable() logic. Specifically, if the job "we" is
1331 * ordered before the job "other":
1332 *
1333 * we start + other start → stay
1334 * we start + other stop → gc
1335 * we stop + other start → stay
1336 * we stop + other stop → gc
1337 *
1338 * "we" are ordered after "other":
1339 *
1340 * we start + other start → gc
1341 * we start + other stop → gc
1342 * we stop + other start → stay
1343 * we stop + other stop → stay
1344 *
1345 */
1346
1347 return false;
1348 }
1349
1350 void job_add_to_gc_queue(Job *j) {
1351 assert(j);
1352
1353 if (j->in_gc_queue)
1354 return;
1355
1356 if (job_check_gc(j))
1357 return;
1358
1359 LIST_PREPEND(gc_queue, j->unit->manager->gc_job_queue, j);
1360 j->in_gc_queue = true;
1361 }
1362
1363 static int job_compare(const void *a, const void *b) {
1364 Job *x = *(Job**) a, *y = *(Job**) b;
1365
1366 if (x->id < y->id)
1367 return -1;
1368 if (x->id > y->id)
1369 return 1;
1370
1371 return 0;
1372 }
1373
1374 static size_t sort_job_list(Job **list, size_t n) {
1375 Job *previous = NULL;
1376 size_t a, b;
1377
1378 /* Order by numeric IDs */
1379 qsort_safe(list, n, sizeof(Job*), job_compare);
1380
1381 /* Filter out duplicates */
1382 for (a = 0, b = 0; a < n; a++) {
1383
1384 if (previous == list[a])
1385 continue;
1386
1387 previous = list[b++] = list[a];
1388 }
1389
1390 return b;
1391 }
1392
1393 int job_get_before(Job *j, Job*** ret) {
1394 _cleanup_free_ Job** list = NULL;
1395 size_t n = 0, n_allocated = 0;
1396 Unit *other = NULL;
1397 Iterator i;
1398 void *v;
1399
1400 /* Returns a list of all pending jobs that need to finish before this job may be started. */
1401
1402 assert(j);
1403 assert(ret);
1404
1405 if (j->ignore_order) {
1406 *ret = NULL;
1407 return 0;
1408 }
1409
1410 if (IN_SET(j->type, JOB_START, JOB_VERIFY_ACTIVE, JOB_RELOAD)) {
1411
1412 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i) {
1413 if (!other->job)
1414 continue;
1415
1416 if (!GREEDY_REALLOC(list, n_allocated, n+1))
1417 return -ENOMEM;
1418 list[n++] = other->job;
1419 }
1420 }
1421
1422 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i) {
1423 if (!other->job)
1424 continue;
1425
1426 if (!IN_SET(other->job->type, JOB_STOP, JOB_RESTART))
1427 continue;
1428
1429 if (!GREEDY_REALLOC(list, n_allocated, n+1))
1430 return -ENOMEM;
1431 list[n++] = other->job;
1432 }
1433
1434 n = sort_job_list(list, n);
1435
1436 *ret = list;
1437 list = NULL;
1438
1439 return (int) n;
1440 }
1441
1442 int job_get_after(Job *j, Job*** ret) {
1443 _cleanup_free_ Job** list = NULL;
1444 size_t n = 0, n_allocated = 0;
1445 Unit *other = NULL;
1446 void *v;
1447 Iterator i;
1448
1449 assert(j);
1450 assert(ret);
1451
1452 /* Returns a list of all pending jobs that are waiting for this job to finish. */
1453
1454 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_BEFORE], i) {
1455 if (!other->job)
1456 continue;
1457
1458 if (other->job->ignore_order)
1459 continue;
1460
1461 if (!IN_SET(other->job->type, JOB_START, JOB_VERIFY_ACTIVE, JOB_RELOAD))
1462 continue;
1463
1464 if (!GREEDY_REALLOC(list, n_allocated, n+1))
1465 return -ENOMEM;
1466 list[n++] = other->job;
1467 }
1468
1469 if (IN_SET(j->type, JOB_STOP, JOB_RESTART)) {
1470
1471 HASHMAP_FOREACH_KEY(v, other, j->unit->dependencies[UNIT_AFTER], i) {
1472 if (!other->job)
1473 continue;
1474
1475 if (other->job->ignore_order)
1476 continue;
1477
1478 if (!GREEDY_REALLOC(list, n_allocated, n+1))
1479 return -ENOMEM;
1480 list[n++] = other->job;
1481 }
1482 }
1483
1484 n = sort_job_list(list, n);
1485
1486 *ret = list;
1487 list = NULL;
1488
1489 return (int) n;
1490 }
1491
1492 static const char* const job_state_table[_JOB_STATE_MAX] = {
1493 [JOB_WAITING] = "waiting",
1494 [JOB_RUNNING] = "running",
1495 };
1496
1497 DEFINE_STRING_TABLE_LOOKUP(job_state, JobState);
1498
1499 static const char* const job_type_table[_JOB_TYPE_MAX] = {
1500 [JOB_START] = "start",
1501 [JOB_VERIFY_ACTIVE] = "verify-active",
1502 [JOB_STOP] = "stop",
1503 [JOB_RELOAD] = "reload",
1504 [JOB_RELOAD_OR_START] = "reload-or-start",
1505 [JOB_RESTART] = "restart",
1506 [JOB_TRY_RESTART] = "try-restart",
1507 [JOB_TRY_RELOAD] = "try-reload",
1508 [JOB_NOP] = "nop",
1509 };
1510
1511 DEFINE_STRING_TABLE_LOOKUP(job_type, JobType);
1512
1513 static const char* const job_mode_table[_JOB_MODE_MAX] = {
1514 [JOB_FAIL] = "fail",
1515 [JOB_REPLACE] = "replace",
1516 [JOB_REPLACE_IRREVERSIBLY] = "replace-irreversibly",
1517 [JOB_ISOLATE] = "isolate",
1518 [JOB_FLUSH] = "flush",
1519 [JOB_IGNORE_DEPENDENCIES] = "ignore-dependencies",
1520 [JOB_IGNORE_REQUIREMENTS] = "ignore-requirements",
1521 };
1522
1523 DEFINE_STRING_TABLE_LOOKUP(job_mode, JobMode);
1524
1525 static const char* const job_result_table[_JOB_RESULT_MAX] = {
1526 [JOB_DONE] = "done",
1527 [JOB_CANCELED] = "canceled",
1528 [JOB_TIMEOUT] = "timeout",
1529 [JOB_FAILED] = "failed",
1530 [JOB_DEPENDENCY] = "dependency",
1531 [JOB_SKIPPED] = "skipped",
1532 [JOB_INVALID] = "invalid",
1533 [JOB_ASSERT] = "assert",
1534 [JOB_UNSUPPORTED] = "unsupported",
1535 [JOB_COLLECTED] = "collected",
1536 };
1537
1538 DEFINE_STRING_TABLE_LOOKUP(job_result, JobResult);
1539
1540 const char* job_type_to_access_method(JobType t) {
1541 assert(t >= 0);
1542 assert(t < _JOB_TYPE_MAX);
1543
1544 if (IN_SET(t, JOB_START, JOB_RESTART, JOB_TRY_RESTART))
1545 return "start";
1546 else if (t == JOB_STOP)
1547 return "stop";
1548 else
1549 return "reload";
1550 }
Unnamed repository; edit this file 'description' to name the repository.